1 /* $NetBSD: can_pcb.c,v 1.8 2019/07/20 15:34:41 bouyer Exp $ */
2
3 /*-
4 * Copyright (c) 2003, 2017 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Robert Swindells and Manuel Bouyer
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: can_pcb.c,v 1.8 2019/07/20 15:34:41 bouyer Exp $");
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/malloc.h>
38 #include <sys/kmem.h>
39 #include <sys/mbuf.h>
40 #include <sys/protosw.h>
41 #include <sys/socket.h>
42 #include <sys/socketvar.h>
43 #include <sys/ioctl.h>
44 #include <sys/errno.h>
45 #include <sys/time.h>
46 #include <sys/pool.h>
47 #include <sys/proc.h>
48
49 #include <net/if.h>
50 #include <net/route.h>
51
52 #include <netcan/can.h>
53 #include <netcan/can_var.h>
54 #include <netcan/can_pcb.h>
55
56 #define CANPCBHASH_BIND(table, ifindex) \
57 &(table)->canpt_bindhashtbl[ \
58 (ifindex) & (table)->canpt_bindhash]
59 #define CANPCBHASH_CONNECT(table, ifindex) \
60 &(table)->canpt_connecthashtbl[ \
61 (ifindex) & (table)->canpt_bindhash]
62
63 struct pool canpcb_pool;
64
65 void
can_pcbinit(struct canpcbtable * table,int bindhashsize,int connecthashsize)66 can_pcbinit(struct canpcbtable *table, int bindhashsize, int connecthashsize)
67 {
68 static int canpcb_pool_initialized;
69
70 if (canpcb_pool_initialized == 0) {
71 pool_init(&canpcb_pool, sizeof(struct canpcb), 0, 0, 0,
72 "canpcbpl", NULL, IPL_SOFTNET);
73 canpcb_pool_initialized = 1;
74 }
75
76 TAILQ_INIT(&table->canpt_queue);
77 table->canpt_bindhashtbl = hashinit(bindhashsize, HASH_LIST, true,
78 &table->canpt_bindhash);
79 table->canpt_connecthashtbl = hashinit(connecthashsize, HASH_LIST,
80 true, &table->canpt_connecthash);
81 }
82
83 int
can_pcballoc(struct socket * so,void * v)84 can_pcballoc(struct socket *so, void *v)
85 {
86 struct canpcbtable *table = v;
87 struct canpcb *canp;
88 struct can_filter *can_init_filter;
89 int s;
90
91 can_init_filter = kmem_alloc(sizeof(struct can_filter), KM_NOSLEEP);
92 if (can_init_filter == NULL)
93 return (ENOBUFS);
94 can_init_filter->can_id = 0;
95 can_init_filter->can_mask = 0; /* accept all by default */
96
97 s = splnet();
98 canp = pool_get(&canpcb_pool, PR_NOWAIT);
99 splx(s);
100 if (canp == NULL) {
101 kmem_free(can_init_filter, sizeof(struct can_filter));
102 return (ENOBUFS);
103 }
104 memset(canp, 0, sizeof(*canp));
105 canp->canp_table = table;
106 canp->canp_socket = so;
107 canp->canp_filters = can_init_filter;
108 canp->canp_nfilters = 1;
109 mutex_init(&canp->canp_mtx, MUTEX_DEFAULT, IPL_NET);
110 canp->canp_refcount = 1;
111
112 so->so_pcb = canp;
113 mutex_enter(&canp->canp_mtx);
114 TAILQ_INSERT_HEAD(&table->canpt_queue, canp, canp_queue);
115 can_pcbstate(canp, CANP_ATTACHED);
116 mutex_exit(&canp->canp_mtx);
117 return (0);
118 }
119
120 int
can_pcbbind(void * v,struct sockaddr_can * scan,struct lwp * l)121 can_pcbbind(void *v, struct sockaddr_can *scan, struct lwp *l)
122 {
123 struct canpcb *canp = v;
124
125 if (scan->can_family != AF_CAN)
126 return (EAFNOSUPPORT);
127 if (scan->can_len != sizeof(*scan))
128 return EINVAL;
129 mutex_enter(&canp->canp_mtx);
130 if (scan->can_ifindex != 0) {
131 canp->canp_ifp = if_byindex(scan->can_ifindex);
132 if (canp->canp_ifp == NULL ||
133 canp->canp_ifp->if_dlt != DLT_CAN_SOCKETCAN) {
134 canp->canp_ifp = NULL;
135 mutex_exit(&canp->canp_mtx);
136 return (EADDRNOTAVAIL);
137 }
138 soisconnected(canp->canp_socket);
139 } else {
140 canp->canp_ifp = NULL;
141 canp->canp_socket->so_state &= ~SS_ISCONNECTED; /* XXX */
142 }
143 can_pcbstate(canp, CANP_BOUND);
144 mutex_exit(&canp->canp_mtx);
145 return 0;
146 }
147
148 /*
149 * Connect from a socket to a specified address.
150 */
151 int
can_pcbconnect(void * v,struct sockaddr_can * scan)152 can_pcbconnect(void *v, struct sockaddr_can *scan)
153 {
154 #if 0
155 struct canpcb *canp = v;
156 struct sockaddr_can *ifaddr = NULL;
157 int error;
158 #endif
159
160 if (scan->can_family != AF_CAN)
161 return (EAFNOSUPPORT);
162 if (scan->can_len != sizeof(*scan))
163 return EINVAL;
164 #if 0
165 mutex_enter(&canp->canp_mtx);
166 memcpy(&canp->canp_dst, scan, sizeof(struct sockaddr_can));
167 can_pcbstate(canp, CANP_CONNECTED);
168 mutex_exit(&canp->canp_mtx);
169 return 0;
170 #endif
171 return EOPNOTSUPP;
172 }
173
174 void
can_pcbdisconnect(void * v)175 can_pcbdisconnect(void *v)
176 {
177 struct canpcb *canp = v;
178
179 mutex_enter(&canp->canp_mtx);
180 can_pcbstate(canp, CANP_DETACHED);
181 mutex_exit(&canp->canp_mtx);
182 if (canp->canp_socket->so_state & SS_NOFDREF)
183 can_pcbdetach(canp);
184 }
185
186 void
can_pcbdetach(void * v)187 can_pcbdetach(void *v)
188 {
189 struct canpcb *canp = v;
190 struct socket *so = canp->canp_socket;
191
192 KASSERT(mutex_owned(softnet_lock));
193 so->so_pcb = NULL;
194 mutex_enter(&canp->canp_mtx);
195 can_pcbstate(canp, CANP_DETACHED);
196 mutex_exit(&canp->canp_mtx);
197 can_pcbsetfilter(canp, NULL, 0);
198 TAILQ_REMOVE(&canp->canp_table->canpt_queue, canp, canp_queue);
199 sofree(so); /* sofree drops the softnet_lock */
200 canp_unref(canp);
201 mutex_enter(softnet_lock);
202 }
203
204 void
canp_ref(struct canpcb * canp)205 canp_ref(struct canpcb *canp)
206 {
207 KASSERT(mutex_owned(&canp->canp_mtx));
208 canp->canp_refcount++;
209 }
210
211 void
canp_unref(struct canpcb * canp)212 canp_unref(struct canpcb *canp)
213 {
214 mutex_enter(&canp->canp_mtx);
215 canp->canp_refcount--;
216 KASSERT(canp->canp_refcount >= 0);
217 if (canp->canp_refcount > 0) {
218 mutex_exit(&canp->canp_mtx);
219 return;
220 }
221 mutex_exit(&canp->canp_mtx);
222 mutex_destroy(&canp->canp_mtx);
223 pool_put(&canpcb_pool, canp);
224 }
225
226 void
can_setsockaddr(struct canpcb * canp,struct sockaddr_can * scan)227 can_setsockaddr(struct canpcb *canp, struct sockaddr_can *scan)
228 {
229
230 mutex_enter(&canp->canp_mtx);
231 memset(scan, 0, sizeof (*scan));
232 scan->can_family = AF_CAN;
233 scan->can_len = sizeof(*scan);
234 if (canp->canp_ifp)
235 scan->can_ifindex = canp->canp_ifp->if_index;
236 else
237 scan->can_ifindex = 0;
238 mutex_exit(&canp->canp_mtx);
239 }
240
241 int
can_pcbsetfilter(struct canpcb * canp,struct can_filter * fp,int nfilters)242 can_pcbsetfilter(struct canpcb *canp, struct can_filter *fp, int nfilters)
243 {
244
245 struct can_filter *newf;
246 struct can_filter *oldf;
247 int oldnf;
248 int error = 0;
249
250 if (nfilters > 0) {
251 newf =
252 kmem_alloc(sizeof(struct can_filter) * nfilters, KM_SLEEP);
253 memcpy(newf, fp, sizeof(struct can_filter) * nfilters);
254 } else {
255 newf = NULL;
256 }
257 mutex_enter(&canp->canp_mtx);
258 oldf = canp->canp_filters;
259 oldnf = canp->canp_nfilters;
260 if (newf != NULL && canp->canp_state == CANP_DETACHED) {
261 error = ECONNRESET;
262 } else {
263 canp->canp_filters = newf;
264 canp->canp_nfilters = nfilters;
265 newf = NULL;
266 }
267 mutex_exit(&canp->canp_mtx);
268 if (oldf != NULL) {
269 kmem_free(oldf, sizeof(struct can_filter) * oldnf);
270 }
271 if (newf != NULL) {
272 kmem_free(newf, sizeof(struct can_filter) * nfilters);
273 }
274 return error;
275 }
276
277
278
279 #if 0
280 /*
281 * Pass some notification to all connections of a protocol
282 * associated with address dst. The local address and/or port numbers
283 * may be specified to limit the search. The "usual action" will be
284 * taken, depending on the ctlinput cmd. The caller must filter any
285 * cmds that are uninteresting (e.g., no error in the map).
286 * Call the protocol specific routine (if any) to report
287 * any errors for each matching socket.
288 *
289 * Must be called at splsoftnet.
290 */
291 int
292 can_pcbnotify(struct canpcbtable *table, u_int32_t faddr, u_int32_t laddr,
293 int errno, void (*notify)(struct canpcb *, int))
294 {
295 struct canpcbhead *head;
296 struct canpcb *canp, *ncanp;
297 int nmatch;
298
299 if (faddr == 0 || notify == 0)
300 return (0);
301
302 nmatch = 0;
303 head = CANPCBHASH_CONNECT(table, faddr, laddr);
304 for (canp = LIST_FIRST(head); canp != NULL; canp = ncanp) {
305 ncanp = LIST_NEXT(canp, canp_hash);
306 if (canp->canp_faddr == faddr &&
307 canp->canp_laddr == laddr) {
308 (*notify)(canp, errno);
309 nmatch++;
310 }
311 }
312 return (nmatch);
313 }
314
315 void
316 can_pcbnotifyall(struct canpcbtable *table, u_int32_t faddr, int errno,
317 void (*notify)(struct canpcb *, int))
318 {
319 struct canpcb *canp, *ncanp;
320
321 if (faddr == 0 || notify == 0)
322 return;
323
324 TAILQ_FOREACH_SAFE(canp, &table->canpt_queue, canp_queue, ncanp) {
325 if (canp->canp_faddr == faddr)
326 (*notify)(canp, errno);
327 }
328 }
329 #endif
330
331 #if 0
332 void
333 can_pcbpurgeif0(struct canpcbtable *table, struct ifnet *ifp)
334 {
335 struct canpcb *canp, *ncanp;
336 struct ip_moptions *imo;
337 int i, gap;
338
339 }
340
341 void
342 can_pcbpurgeif(struct canpcbtable *table, struct ifnet *ifp)
343 {
344 struct canpcb *canp, *ncanp;
345
346 for (canp = CIRCLEQ_FIRST(&table->canpt_queue);
347 canp != (void *)&table->canpt_queue;
348 canp = ncanp) {
349 ncanp = CIRCLEQ_NEXT(canp, canp_queue);
350 }
351 }
352 #endif
353
354
355
356 void
can_pcbstate(struct canpcb * canp,int state)357 can_pcbstate(struct canpcb *canp, int state)
358 {
359 int ifindex = canp->canp_ifp ? canp->canp_ifp->if_index : 0;
360 KASSERT(mutex_owned(&canp->canp_mtx));
361
362 if (canp->canp_state > CANP_ATTACHED)
363 LIST_REMOVE(canp, canp_hash);
364
365 switch (state) {
366 case CANP_BOUND:
367 LIST_INSERT_HEAD(CANPCBHASH_BIND(canp->canp_table,
368 ifindex), canp, canp_hash);
369 break;
370 case CANP_CONNECTED:
371 LIST_INSERT_HEAD(CANPCBHASH_CONNECT(canp->canp_table,
372 ifindex), canp, canp_hash);
373 break;
374 }
375
376 canp->canp_state = state;
377 }
378
379 /*
380 * check mbuf against socket accept filter.
381 * returns true if mbuf is accepted, false otherwise
382 */
383 bool
can_pcbfilter(struct canpcb * canp,struct mbuf * m)384 can_pcbfilter(struct canpcb *canp, struct mbuf *m)
385 {
386 int i;
387 struct can_frame *fmp;
388 struct can_filter *fip;
389
390 KASSERT(mutex_owned(&canp->canp_mtx));
391 KASSERT((m->m_flags & M_PKTHDR) != 0);
392 KASSERT(m->m_len == m->m_pkthdr.len);
393
394 fmp = mtod(m, struct can_frame *);
395 for (i = 0; i < canp->canp_nfilters; i++) {
396 fip = &canp->canp_filters[i];
397 if ((fmp->can_id & fip->can_mask) == fip->can_id)
398 return true;
399 }
400 /* no match */
401 return false;
402 }
403