1 | /* |
2 | * Copyright (c) 1997-2014 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* |
29 | * @(#)ndrv.c 1.1 (MacOSX) 6/10/43 |
30 | * Justin Walker, 970604 |
31 | * AF_NDRV support |
32 | * 980130 - Cleanup, reorg, performance improvemements |
33 | * 000816 - Removal of Y adapter cruft |
34 | */ |
35 | |
36 | /* |
37 | * PF_NDRV allows raw access to a specified network device, directly |
38 | * with a socket. Expected use involves a socket option to request |
39 | * protocol packets. This lets ndrv_output() call ifnet_output(), and |
40 | * lets DLIL find the proper recipient for incoming packets. |
41 | * The purpose here is for user-mode protocol implementation. |
42 | * Note that "pure raw access" will still be accomplished with BPF. |
43 | * |
44 | * In addition to the former use, when combined with socket NKEs, |
45 | * PF_NDRV permits a fairly flexible mechanism for implementing |
46 | * strange protocol support. |
47 | */ |
48 | #include <mach/mach_types.h> |
49 | |
50 | #include <sys/param.h> |
51 | #include <sys/systm.h> |
52 | #include <sys/kernel.h> |
53 | #include <sys/malloc.h> |
54 | #include <sys/mbuf.h> |
55 | #include <sys/protosw.h> |
56 | #include <sys/domain.h> |
57 | #include <sys/socket.h> |
58 | #include <sys/socketvar.h> |
59 | #include <sys/ioctl.h> |
60 | #include <sys/sysctl.h> |
61 | #include <sys/errno.h> |
62 | #include <sys/syslog.h> |
63 | #include <sys/proc.h> |
64 | |
65 | #include <kern/queue.h> |
66 | |
67 | #include <net/ndrv.h> |
68 | #include <net/route.h> |
69 | #include <net/if_llc.h> |
70 | #include <net/if_dl.h> |
71 | #include <net/if_types.h> |
72 | #include <net/ndrv_var.h> |
73 | #include <net/dlil.h> |
74 | |
75 | #if INET |
76 | #include <netinet/in.h> |
77 | #include <netinet/in_var.h> |
78 | #endif |
79 | #include <netinet/if_ether.h> |
80 | |
81 | static unsigned int ndrv_multi_max_count = NDRV_DMUX_MAX_DESCR; |
82 | SYSCTL_UINT(_net, OID_AUTO, ndrv_multi_max_count, CTLFLAG_RW | CTLFLAG_LOCKED, |
83 | &ndrv_multi_max_count, 0, "Number of allowed multicast addresses per NRDV socket" ); |
84 | |
85 | static int ndrv_do_detach(struct ndrv_cb *); |
86 | static int ndrv_do_disconnect(struct ndrv_cb *); |
87 | static struct ndrv_cb *ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol_family); |
88 | static int ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt); |
89 | static int ndrv_delspec(struct ndrv_cb *); |
90 | static int ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux); |
91 | static void ndrv_handle_ifp_detach(u_int32_t family, short unit); |
92 | static int ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt); |
93 | static int ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt); |
94 | static struct ndrv_multiaddr* ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* addr); |
95 | static void ndrv_remove_all_multicast(struct ndrv_cb *np); |
96 | static void ndrv_dominit(struct domain *); |
97 | |
98 | u_int32_t ndrv_sendspace = NDRVSNDQ; |
99 | u_int32_t ndrv_recvspace = NDRVRCVQ; |
100 | TAILQ_HEAD(, ndrv_cb) ndrvl = TAILQ_HEAD_INITIALIZER(ndrvl); |
101 | |
102 | static struct domain *ndrvdomain = NULL; |
103 | extern struct domain ndrvdomain_s; |
104 | |
105 | #define NDRV_PROTODEMUX_COUNT 10 |
106 | |
107 | /* |
108 | * Verify these values match. |
109 | * To keep clients from including dlil.h, we define |
110 | * these values independently in ndrv.h. They must |
111 | * match or a conversion function must be written. |
112 | */ |
113 | #if NDRV_DEMUXTYPE_ETHERTYPE != DLIL_DESC_ETYPE2 |
114 | #error NDRV_DEMUXTYPE_ETHERTYPE must match DLIL_DESC_ETYPE2 |
115 | #endif |
116 | #if NDRV_DEMUXTYPE_SAP != DLIL_DESC_SAP |
117 | #error NDRV_DEMUXTYPE_SAP must match DLIL_DESC_SAP |
118 | #endif |
119 | #if NDRV_DEMUXTYPE_SNAP != DLIL_DESC_SNAP |
120 | #error NDRV_DEMUXTYPE_SNAP must match DLIL_DESC_SNAP |
121 | #endif |
122 | |
123 | /* |
124 | * Protocol output - Called to output a raw network packet directly |
125 | * to the driver. |
126 | */ |
127 | static int |
128 | ndrv_output(struct mbuf *m, struct socket *so) |
129 | { |
130 | struct ndrv_cb *np = sotondrvcb(so); |
131 | struct ifnet *ifp = np->nd_if; |
132 | int result = 0; |
133 | |
134 | #if NDRV_DEBUG |
135 | printf("NDRV output: %x, %x, %x\n" , m, so, np); |
136 | #endif |
137 | |
138 | /* |
139 | * No header is a format error |
140 | */ |
141 | if ((m->m_flags&M_PKTHDR) == 0) |
142 | return(EINVAL); |
143 | |
144 | /* Unlock before calling ifnet_output */ |
145 | socket_unlock(so, 0); |
146 | |
147 | /* |
148 | * Call DLIL if we can. DLIL is much safer than calling the |
149 | * ifp directly. |
150 | */ |
151 | result = ifnet_output_raw(ifp, np->nd_proto_family, m); |
152 | |
153 | socket_lock(so, 0); |
154 | |
155 | return (result); |
156 | } |
157 | |
158 | /* Our input routine called from DLIL */ |
159 | static errno_t |
160 | ndrv_input( |
161 | ifnet_t ifp, |
162 | protocol_family_t proto_family, |
163 | mbuf_t m, |
164 | char *) |
165 | { |
166 | struct socket *so; |
167 | struct sockaddr_dl ndrvsrc; |
168 | struct ndrv_cb *np; |
169 | int error = 0; |
170 | |
171 | ndrvsrc.sdl_len = sizeof (struct sockaddr_dl); |
172 | ndrvsrc.sdl_family = AF_NDRV; |
173 | ndrvsrc.sdl_index = 0; |
174 | |
175 | /* move packet from if queue to socket */ |
176 | /* Should be media-independent */ |
177 | ndrvsrc.sdl_type = IFT_ETHER; |
178 | ndrvsrc.sdl_nlen = 0; |
179 | ndrvsrc.sdl_alen = 6; |
180 | ndrvsrc.sdl_slen = 0; |
181 | bcopy(frame_header, &ndrvsrc.sdl_data, 6); |
182 | |
183 | np = ndrv_find_inbound(ifp, proto_family); |
184 | if (np == NULL) |
185 | { |
186 | return(ENOENT); |
187 | } |
188 | so = np->nd_socket; |
189 | /* prepend the frame header */ |
190 | m = m_prepend(m, ifnet_hdrlen(ifp), M_NOWAIT); |
191 | if (m == NULL) |
192 | return EJUSTRETURN; |
193 | bcopy(frame_header, m->m_data, ifnet_hdrlen(ifp)); |
194 | |
195 | LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED); |
196 | lck_mtx_lock(ndrvdomain->dom_mtx); |
197 | if (sbappendaddr(&(so->so_rcv), (struct sockaddr *)&ndrvsrc, |
198 | m, (struct mbuf *)0, &error) != 0) { |
199 | sorwakeup(so); |
200 | } |
201 | lck_mtx_unlock(ndrvdomain->dom_mtx); |
202 | return 0; /* radar 4030377 - always return 0 */ |
203 | } |
204 | |
205 | /* |
206 | * Allocate an ndrv control block and some buffer space for the socket |
207 | */ |
208 | static int |
209 | ndrv_attach(struct socket *so, int proto, __unused struct proc *p) |
210 | { |
211 | int error; |
212 | struct ndrv_cb *np = sotondrvcb(so); |
213 | |
214 | if ((so->so_state & SS_PRIV) == 0) |
215 | return(EPERM); |
216 | |
217 | #if NDRV_DEBUG |
218 | printf("NDRV attach: %x, %x, %x\n" , so, proto, np); |
219 | #endif |
220 | |
221 | if ((error = soreserve(so, ndrv_sendspace, ndrv_recvspace))) |
222 | return(error); |
223 | |
224 | MALLOC(np, struct ndrv_cb *, sizeof(*np), M_PCB, M_WAITOK); |
225 | if (np == NULL) |
226 | return (ENOMEM); |
227 | so->so_pcb = (caddr_t)np; |
228 | bzero(np, sizeof(*np)); |
229 | #if NDRV_DEBUG |
230 | printf("NDRV attach: %x, %x, %x\n" , so, proto, np); |
231 | #endif |
232 | TAILQ_INIT(&np->nd_dlist); |
233 | np->nd_signature = NDRV_SIGNATURE; |
234 | np->nd_socket = so; |
235 | np->nd_proto.sp_family = SOCK_DOM(so); |
236 | np->nd_proto.sp_protocol = proto; |
237 | np->nd_if = NULL; |
238 | np->nd_proto_family = 0; |
239 | np->nd_family = 0; |
240 | np->nd_unit = 0; |
241 | TAILQ_INSERT_TAIL(&ndrvl, np, nd_next); |
242 | return(0); |
243 | } |
244 | |
245 | /* |
246 | * Destroy state just before socket deallocation. |
247 | * Flush data or not depending on the options. |
248 | */ |
249 | |
250 | static int |
251 | ndrv_detach(struct socket *so) |
252 | { |
253 | struct ndrv_cb *np = sotondrvcb(so); |
254 | |
255 | if (np == 0) |
256 | return EINVAL; |
257 | return ndrv_do_detach(np); |
258 | } |
259 | |
260 | |
261 | /* |
262 | * If a socket isn't bound to a single address, |
263 | * the ndrv input routine will hand it anything |
264 | * within that protocol family (assuming there's |
265 | * nothing else around it should go to). |
266 | * |
267 | * Don't expect this to be used. |
268 | */ |
269 | |
270 | static int |
271 | ndrv_connect(struct socket *so, struct sockaddr *nam, __unused struct proc *p) |
272 | { |
273 | struct ndrv_cb *np = sotondrvcb(so); |
274 | |
275 | if (np == 0) |
276 | return EINVAL; |
277 | |
278 | if (np->nd_faddr) |
279 | return EISCONN; |
280 | |
281 | /* Allocate memory to store the remote address */ |
282 | MALLOC(np->nd_faddr, struct sockaddr_ndrv*, |
283 | nam->sa_len, M_IFADDR, M_WAITOK); |
284 | if (np->nd_faddr == NULL) |
285 | return ENOMEM; |
286 | |
287 | bcopy((caddr_t) nam, (caddr_t) np->nd_faddr, nam->sa_len); |
288 | soisconnected(so); |
289 | return 0; |
290 | } |
291 | |
292 | static void |
293 | ndrv_event(struct ifnet *ifp, __unused protocol_family_t protocol, |
294 | const struct kev_msg *event) |
295 | { |
296 | if (event->vendor_code == KEV_VENDOR_APPLE && |
297 | event->kev_class == KEV_NETWORK_CLASS && |
298 | event->kev_subclass == KEV_DL_SUBCLASS && |
299 | event->event_code == KEV_DL_IF_DETACHING) { |
300 | LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED); |
301 | lck_mtx_lock(ndrvdomain->dom_mtx); |
302 | ndrv_handle_ifp_detach(ifnet_family(ifp), ifnet_unit(ifp)); |
303 | lck_mtx_unlock(ndrvdomain->dom_mtx); |
304 | } |
305 | } |
306 | |
307 | static int name_cmp(struct ifnet *, char *); |
308 | |
309 | /* |
310 | * This is the "driver open" hook - we 'bind' to the |
311 | * named driver. |
312 | * Here's where we latch onto the driver. |
313 | */ |
314 | static int |
315 | ndrv_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p) |
316 | { |
317 | struct sockaddr_ndrv *sa = (struct sockaddr_ndrv *) nam; |
318 | char *dname; |
319 | struct ndrv_cb *np; |
320 | struct ifnet *ifp; |
321 | int result; |
322 | |
323 | if TAILQ_EMPTY(&ifnet_head) |
324 | return(EADDRNOTAVAIL); /* Quick sanity check */ |
325 | np = sotondrvcb(so); |
326 | if (np == 0) |
327 | return EINVAL; |
328 | |
329 | if (np->nd_laddr) |
330 | return EINVAL; /* XXX */ |
331 | |
332 | /* I think we just latch onto a copy here; the caller frees */ |
333 | np->nd_laddr = _MALLOC(sizeof(struct sockaddr_ndrv), M_IFADDR, M_WAITOK); |
334 | if (np->nd_laddr == NULL) |
335 | return(ENOMEM); |
336 | bcopy((caddr_t) sa, (caddr_t) np->nd_laddr, sizeof(struct sockaddr_ndrv)); |
337 | dname = (char *) sa->snd_name; |
338 | np->nd_laddr->snd_len = sizeof(struct sockaddr_ndrv); |
339 | if (*dname == '\0') |
340 | return(EINVAL); |
341 | #if NDRV_DEBUG |
342 | printf("NDRV bind: %x, %x, %s\n" , so, np, dname); |
343 | #endif |
344 | /* Track down the driver and its ifnet structure. |
345 | * There's no internal call for this so we have to dup the code |
346 | * in if.c/ifconf() |
347 | */ |
348 | ifnet_head_lock_shared(); |
349 | TAILQ_FOREACH(ifp, &ifnet_head, if_link) { |
350 | if (name_cmp(ifp, dname) == 0) |
351 | break; |
352 | } |
353 | ifnet_head_done(); |
354 | |
355 | if (ifp == NULL) |
356 | return(EADDRNOTAVAIL); |
357 | |
358 | // PPP doesn't support PF_NDRV. |
359 | if (ifnet_family(ifp) != APPLE_IF_FAM_PPP) |
360 | { |
361 | /* NDRV on this interface */ |
362 | struct ifnet_attach_proto_param ndrv_proto; |
363 | result = 0; |
364 | bzero(&ndrv_proto, sizeof(ndrv_proto)); |
365 | ndrv_proto.event = ndrv_event; |
366 | |
367 | /* We aren't worried about double attaching, that should just return an error */ |
368 | socket_unlock(so, 0); |
369 | result = ifnet_attach_protocol(ifp, PF_NDRV, &ndrv_proto); |
370 | socket_lock(so, 0); |
371 | if (result && result != EEXIST) { |
372 | return result; |
373 | } |
374 | np->nd_proto_family = PF_NDRV; |
375 | } |
376 | else { |
377 | np->nd_proto_family = 0; |
378 | } |
379 | |
380 | np->nd_if = ifp; |
381 | np->nd_family = ifnet_family(ifp); |
382 | np->nd_unit = ifnet_unit(ifp); |
383 | |
384 | return(0); |
385 | } |
386 | |
387 | static int |
388 | ndrv_disconnect(struct socket *so) |
389 | { |
390 | struct ndrv_cb *np = sotondrvcb(so); |
391 | |
392 | if (np == 0) |
393 | return EINVAL; |
394 | |
395 | if (np->nd_faddr == 0) |
396 | return ENOTCONN; |
397 | |
398 | ndrv_do_disconnect(np); |
399 | return 0; |
400 | } |
401 | |
402 | /* |
403 | * Mark the connection as being incapable of further input. |
404 | */ |
405 | static int |
406 | ndrv_shutdown(struct socket *so) |
407 | { |
408 | LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED); |
409 | socantsendmore(so); |
410 | return 0; |
411 | } |
412 | |
413 | /* |
414 | * Ship a packet out. The ndrv output will pass it |
415 | * to the appropriate driver. The really tricky part |
416 | * is the destination address... |
417 | */ |
418 | static int |
419 | ndrv_send(struct socket *so, __unused int flags, struct mbuf *m, |
420 | __unused struct sockaddr *addr, struct mbuf *control, |
421 | __unused struct proc *p) |
422 | { |
423 | int error; |
424 | |
425 | if (control) |
426 | return EOPNOTSUPP; |
427 | |
428 | error = ndrv_output(m, so); |
429 | m = NULL; |
430 | return error; |
431 | } |
432 | |
433 | |
434 | static int |
435 | ndrv_abort(struct socket *so) |
436 | { |
437 | struct ndrv_cb *np = sotondrvcb(so); |
438 | |
439 | if (np == 0) |
440 | return EINVAL; |
441 | |
442 | ndrv_do_disconnect(np); |
443 | return 0; |
444 | } |
445 | |
446 | static int |
447 | ndrv_sockaddr(struct socket *so, struct sockaddr **nam) |
448 | { |
449 | struct ndrv_cb *np = sotondrvcb(so); |
450 | int len; |
451 | |
452 | if (np == 0) |
453 | return EINVAL; |
454 | |
455 | if (np->nd_laddr == 0) |
456 | return EINVAL; |
457 | |
458 | len = np->nd_laddr->snd_len; |
459 | MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK); |
460 | if (*nam == NULL) |
461 | return ENOMEM; |
462 | bcopy((caddr_t)np->nd_laddr, *nam, |
463 | (unsigned)len); |
464 | return 0; |
465 | } |
466 | |
467 | |
468 | static int |
469 | ndrv_peeraddr(struct socket *so, struct sockaddr **nam) |
470 | { |
471 | struct ndrv_cb *np = sotondrvcb(so); |
472 | int len; |
473 | |
474 | if (np == 0) |
475 | return EINVAL; |
476 | |
477 | if (np->nd_faddr == 0) |
478 | return ENOTCONN; |
479 | |
480 | len = np->nd_faddr->snd_len; |
481 | MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK); |
482 | if (*nam == NULL) |
483 | return ENOMEM; |
484 | bcopy((caddr_t)np->nd_faddr, *nam, |
485 | (unsigned)len); |
486 | return 0; |
487 | } |
488 | |
489 | |
490 | /* Control output */ |
491 | |
492 | static int |
493 | ndrv_ctloutput(struct socket *so, struct sockopt *sopt) |
494 | { |
495 | struct ndrv_cb *np = sotondrvcb(so); |
496 | int error = 0; |
497 | |
498 | switch(sopt->sopt_name) |
499 | { |
500 | case NDRV_DELDMXSPEC: /* Delete current spec */ |
501 | /* Verify no parameter was passed */ |
502 | if (sopt->sopt_val != 0 || sopt->sopt_valsize != 0) { |
503 | /* |
504 | * We don't support deleting a specific demux, it's |
505 | * all or nothing. |
506 | */ |
507 | return EINVAL; |
508 | } |
509 | error = ndrv_delspec(np); |
510 | break; |
511 | case NDRV_SETDMXSPEC: /* Set protocol spec */ |
512 | error = ndrv_setspec(np, sopt); |
513 | break; |
514 | case NDRV_ADDMULTICAST: |
515 | error = ndrv_do_add_multicast(np, sopt); |
516 | break; |
517 | case NDRV_DELMULTICAST: |
518 | error = ndrv_do_remove_multicast(np, sopt); |
519 | break; |
520 | default: |
521 | error = ENOTSUP; |
522 | } |
523 | #ifdef NDRV_DEBUG |
524 | log(LOG_WARNING, "NDRV CTLOUT: %x returns %d\n" , sopt->sopt_name, |
525 | error); |
526 | #endif |
527 | return(error); |
528 | } |
529 | |
530 | static int |
531 | ndrv_do_detach(struct ndrv_cb *np) |
532 | { |
533 | struct ndrv_cb* cur_np = NULL; |
534 | struct socket *so = np->nd_socket; |
535 | int error = 0; |
536 | struct ifnet * ifp; |
537 | |
538 | #if NDRV_DEBUG |
539 | printf("NDRV detach: %x, %x\n" , so, np); |
540 | #endif |
541 | ndrv_remove_all_multicast(np); |
542 | |
543 | ifp = np->nd_if; |
544 | /* Remove from the linked list of control blocks */ |
545 | TAILQ_REMOVE(&ndrvl, np, nd_next); |
546 | if (ifp != NULL) { |
547 | u_int32_t proto_family = np->nd_proto_family; |
548 | |
549 | if (proto_family != PF_NDRV && proto_family != 0) { |
550 | socket_unlock(so, 0); |
551 | ifnet_detach_protocol(ifp, proto_family); |
552 | socket_lock(so, 0); |
553 | } |
554 | |
555 | /* Check if this is the last socket attached to this interface */ |
556 | TAILQ_FOREACH(cur_np, &ndrvl, nd_next) { |
557 | if (cur_np->nd_family == np->nd_family && |
558 | cur_np->nd_unit == np->nd_unit) { |
559 | break; |
560 | } |
561 | } |
562 | |
563 | /* If there are no other interfaces, detach PF_NDRV from the interface */ |
564 | if (cur_np == NULL) { |
565 | socket_unlock(so, 0); |
566 | ifnet_detach_protocol(ifp, PF_NDRV); |
567 | socket_lock(so, 0); |
568 | } |
569 | } |
570 | if (np->nd_laddr != NULL) { |
571 | FREE((caddr_t)np->nd_laddr, M_IFADDR); |
572 | np->nd_laddr = NULL; |
573 | } |
574 | FREE((caddr_t)np, M_PCB); |
575 | so->so_pcb = 0; |
576 | so->so_flags |= SOF_PCBCLEARING; |
577 | sofree(so); |
578 | return error; |
579 | } |
580 | |
581 | static int |
582 | ndrv_do_disconnect(struct ndrv_cb *np) |
583 | { |
584 | struct socket * so = np->nd_socket; |
585 | #if NDRV_DEBUG |
586 | printf("NDRV disconnect: %x\n" , np); |
587 | #endif |
588 | if (np->nd_faddr) |
589 | { |
590 | FREE(np->nd_faddr, M_IFADDR); |
591 | np->nd_faddr = 0; |
592 | } |
593 | /* |
594 | * A multipath subflow socket would have its SS_NOFDREF set by default, |
595 | * so check for SOF_MP_SUBFLOW socket flag before detaching the PCB; |
596 | * when the socket is closed for real, SOF_MP_SUBFLOW would be cleared. |
597 | */ |
598 | if (!(so->so_flags & SOF_MP_SUBFLOW) && (so->so_state & SS_NOFDREF)) |
599 | ndrv_do_detach(np); |
600 | soisdisconnected(so); |
601 | return(0); |
602 | } |
603 | |
604 | /* Hackery - return a string version of a decimal number */ |
605 | static void |
606 | sprint_d(u_int n, char *buf, int buflen) |
607 | { char dbuf[IFNAMSIZ]; |
608 | char *cp = dbuf+IFNAMSIZ-1; |
609 | |
610 | *cp = 0; |
611 | do { buflen--; |
612 | cp--; |
613 | *cp = "0123456789" [n % 10]; |
614 | n /= 10; |
615 | } while (n != 0 && buflen > 0); |
616 | strlcpy(buf, cp, IFNAMSIZ-buflen); |
617 | return; |
618 | } |
619 | |
620 | /* |
621 | * Try to compare a device name (q) with one of the funky ifnet |
622 | * device names (ifp). |
623 | */ |
624 | static int name_cmp(struct ifnet *ifp, char *q) |
625 | { char *r; |
626 | int len; |
627 | char buf[IFNAMSIZ]; |
628 | |
629 | r = buf; |
630 | len = strlen(ifnet_name(ifp)); |
631 | strlcpy(r, ifnet_name(ifp), IFNAMSIZ); |
632 | r += len; |
633 | sprint_d(ifnet_unit(ifp), r, IFNAMSIZ-(r-buf)); |
634 | #if NDRV_DEBUG |
635 | printf("Comparing %s, %s\n" , buf, q); |
636 | #endif |
637 | return(strncmp(buf, q, IFNAMSIZ)); |
638 | } |
639 | |
640 | #if 0 |
641 | //### Not used |
642 | /* |
643 | * When closing, dump any enqueued mbufs. |
644 | */ |
645 | void |
646 | ndrv_flushq(struct ifqueue *q) |
647 | { |
648 | struct mbuf *m; |
649 | for (;;) |
650 | { |
651 | IF_DEQUEUE(q, m); |
652 | if (m == NULL) |
653 | break; |
654 | IF_DROP(q); |
655 | if (m) |
656 | m_freem(m); |
657 | } |
658 | } |
659 | #endif |
660 | |
661 | int |
662 | ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt) |
663 | { |
664 | struct ifnet_attach_proto_param proto_param; |
665 | struct ndrv_protocol_desc ndrvSpec; |
666 | struct ndrv_demux_desc* ndrvDemux = NULL; |
667 | int error = 0; |
668 | struct socket * so = np->nd_socket; |
669 | user_addr_t user_addr; |
670 | |
671 | /* Sanity checking */ |
672 | if (np->nd_proto_family != PF_NDRV) |
673 | return EBUSY; |
674 | if (np->nd_if == NULL) |
675 | return EINVAL; |
676 | |
677 | /* Copy the ndrvSpec */ |
678 | if (proc_is64bit(sopt->sopt_p)) { |
679 | struct ndrv_protocol_desc64 ndrvSpec64; |
680 | |
681 | if (sopt->sopt_valsize != sizeof(ndrvSpec64)) |
682 | return EINVAL; |
683 | |
684 | error = sooptcopyin(sopt, &ndrvSpec64, sizeof(ndrvSpec64), sizeof(ndrvSpec64)); |
685 | if (error != 0) |
686 | return error; |
687 | |
688 | ndrvSpec.version = ndrvSpec64.version; |
689 | ndrvSpec.protocol_family = ndrvSpec64.protocol_family; |
690 | ndrvSpec.demux_count = ndrvSpec64.demux_count; |
691 | |
692 | user_addr = ndrvSpec64.demux_list; |
693 | } |
694 | else { |
695 | struct ndrv_protocol_desc32 ndrvSpec32; |
696 | |
697 | if (sopt->sopt_valsize != sizeof(ndrvSpec32)) |
698 | return EINVAL; |
699 | |
700 | error = sooptcopyin(sopt, &ndrvSpec32, sizeof(ndrvSpec32), sizeof(ndrvSpec32)); |
701 | if (error != 0) |
702 | return error; |
703 | |
704 | ndrvSpec.version = ndrvSpec32.version; |
705 | ndrvSpec.protocol_family = ndrvSpec32.protocol_family; |
706 | ndrvSpec.demux_count = ndrvSpec32.demux_count; |
707 | |
708 | user_addr = CAST_USER_ADDR_T(ndrvSpec32.demux_list); |
709 | } |
710 | |
711 | /* Verify the parameter */ |
712 | if (ndrvSpec.version > NDRV_PROTOCOL_DESC_VERS) |
713 | return ENOTSUP; // version is too new! |
714 | else if (ndrvSpec.version < 1) |
715 | return EINVAL; // version is not valid |
716 | else if (ndrvSpec.demux_count > NDRV_PROTODEMUX_COUNT || ndrvSpec.demux_count == 0) |
717 | return EINVAL; // demux_count is not valid |
718 | |
719 | bzero(&proto_param, sizeof(proto_param)); |
720 | proto_param.demux_count = ndrvSpec.demux_count; |
721 | |
722 | /* Allocate storage for demux array */ |
723 | MALLOC(ndrvDemux, struct ndrv_demux_desc*, proto_param.demux_count * |
724 | sizeof(struct ndrv_demux_desc), M_TEMP, M_WAITOK); |
725 | if (ndrvDemux == NULL) |
726 | return ENOMEM; |
727 | |
728 | /* Allocate enough ifnet_demux_descs */ |
729 | MALLOC(proto_param.demux_array, struct ifnet_demux_desc*, |
730 | sizeof(*proto_param.demux_array) * ndrvSpec.demux_count, |
731 | M_TEMP, M_WAITOK); |
732 | if (proto_param.demux_array == NULL) |
733 | error = ENOMEM; |
734 | |
735 | if (error == 0) |
736 | { |
737 | /* Copy the ndrv demux array from userland */ |
738 | error = copyin(user_addr, ndrvDemux, |
739 | ndrvSpec.demux_count * sizeof(struct ndrv_demux_desc)); |
740 | ndrvSpec.demux_list = ndrvDemux; |
741 | } |
742 | |
743 | if (error == 0) |
744 | { |
745 | /* At this point, we've at least got enough bytes to start looking around */ |
746 | u_int32_t demuxOn = 0; |
747 | |
748 | proto_param.demux_count = ndrvSpec.demux_count; |
749 | proto_param.input = ndrv_input; |
750 | proto_param.event = ndrv_event; |
751 | |
752 | for (demuxOn = 0; demuxOn < ndrvSpec.demux_count; demuxOn++) |
753 | { |
754 | /* Convert an ndrv_demux_desc to a ifnet_demux_desc */ |
755 | error = ndrv_to_ifnet_demux(&ndrvSpec.demux_list[demuxOn], |
756 | &proto_param.demux_array[demuxOn]); |
757 | if (error) |
758 | break; |
759 | } |
760 | } |
761 | |
762 | if (error == 0) |
763 | { |
764 | /* We've got all our ducks lined up...lets attach! */ |
765 | socket_unlock(so, 0); |
766 | error = ifnet_attach_protocol(np->nd_if, ndrvSpec.protocol_family, |
767 | &proto_param); |
768 | socket_lock(so, 0); |
769 | if (error == 0) |
770 | np->nd_proto_family = ndrvSpec.protocol_family; |
771 | } |
772 | |
773 | /* Free any memory we've allocated */ |
774 | if (proto_param.demux_array) |
775 | FREE(proto_param.demux_array, M_TEMP); |
776 | if (ndrvDemux) |
777 | FREE(ndrvDemux, M_TEMP); |
778 | |
779 | return error; |
780 | } |
781 | |
782 | |
783 | int |
784 | ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux) |
785 | { |
786 | bzero(ifdemux, sizeof(*ifdemux)); |
787 | |
788 | if (ndrv->type < DLIL_DESC_ETYPE2) |
789 | { |
790 | /* using old "type", not supported */ |
791 | return ENOTSUP; |
792 | } |
793 | |
794 | if (ndrv->length > 28) |
795 | { |
796 | return EINVAL; |
797 | } |
798 | |
799 | ifdemux->type = ndrv->type; |
800 | ifdemux->data = ndrv->data.other; |
801 | ifdemux->datalen = ndrv->length; |
802 | |
803 | return 0; |
804 | } |
805 | |
806 | int |
807 | ndrv_delspec(struct ndrv_cb *np) |
808 | { |
809 | int result = 0; |
810 | |
811 | if (np->nd_proto_family == PF_NDRV || |
812 | np->nd_proto_family == 0) |
813 | return EINVAL; |
814 | |
815 | /* Detach the protocol */ |
816 | result = ifnet_detach_protocol(np->nd_if, np->nd_proto_family); |
817 | np->nd_proto_family = PF_NDRV; |
818 | |
819 | return result; |
820 | } |
821 | |
822 | struct ndrv_cb * |
823 | ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol) |
824 | { |
825 | struct ndrv_cb* np; |
826 | |
827 | if (protocol == PF_NDRV) return NULL; |
828 | |
829 | TAILQ_FOREACH(np, &ndrvl, nd_next) { |
830 | if (np->nd_proto_family == protocol && |
831 | np->nd_if == ifp) { |
832 | return np; |
833 | } |
834 | } |
835 | |
836 | return NULL; |
837 | } |
838 | |
839 | static void |
840 | ndrv_handle_ifp_detach(u_int32_t family, short unit) |
841 | { |
842 | struct ndrv_cb* np; |
843 | struct ifnet *ifp = NULL; |
844 | struct socket *so; |
845 | |
846 | /* Find all sockets using this interface. */ |
847 | TAILQ_FOREACH(np, &ndrvl, nd_next) { |
848 | if (np->nd_family == family && |
849 | np->nd_unit == unit) |
850 | { |
851 | /* This cb is using the detaching interface, but not for long. */ |
852 | /* Let the protocol go */ |
853 | ifp = np->nd_if; |
854 | if (np->nd_proto_family != 0) |
855 | ndrv_delspec(np); |
856 | |
857 | /* Delete the multicasts first */ |
858 | ndrv_remove_all_multicast(np); |
859 | |
860 | /* Disavow all knowledge of the ifp */ |
861 | np->nd_if = NULL; |
862 | np->nd_unit = 0; |
863 | np->nd_family = 0; |
864 | |
865 | so = np->nd_socket; |
866 | /* Make sure sending returns an error */ |
867 | LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED); |
868 | socantsendmore(so); |
869 | socantrcvmore(so); |
870 | } |
871 | } |
872 | |
873 | /* Unregister our protocol */ |
874 | if (ifp) { |
875 | ifnet_detach_protocol(ifp, PF_NDRV); |
876 | } |
877 | } |
878 | |
879 | static int |
880 | ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt) |
881 | { |
882 | struct ndrv_multiaddr* ndrv_multi; |
883 | int result; |
884 | |
885 | if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 || |
886 | sopt->sopt_level != SOL_NDRVPROTO || sopt->sopt_valsize > SOCK_MAXADDRLEN) |
887 | return EINVAL; |
888 | if (np->nd_if == NULL) |
889 | return ENXIO; |
890 | if (!(np->nd_dlist_cnt < ndrv_multi_max_count)) |
891 | return EPERM; |
892 | |
893 | // Allocate storage |
894 | MALLOC(ndrv_multi, struct ndrv_multiaddr*, sizeof(struct ndrv_multiaddr) - |
895 | sizeof(struct sockaddr) + sopt->sopt_valsize, M_IFADDR, M_WAITOK); |
896 | if (ndrv_multi == NULL) |
897 | return ENOMEM; |
898 | |
899 | // Copy in the address |
900 | result = copyin(sopt->sopt_val, &ndrv_multi->addr, sopt->sopt_valsize); |
901 | |
902 | // Validate the sockaddr |
903 | if (result == 0 && sopt->sopt_valsize != ndrv_multi->addr.sa_len) |
904 | result = EINVAL; |
905 | |
906 | if (result == 0 && ndrv_have_multicast(np, &ndrv_multi->addr)) |
907 | result = EEXIST; |
908 | |
909 | if (result == 0) |
910 | { |
911 | // Try adding the multicast |
912 | result = ifnet_add_multicast(np->nd_if, &ndrv_multi->addr, |
913 | &ndrv_multi->ifma); |
914 | } |
915 | |
916 | if (result == 0) |
917 | { |
918 | // Add to our linked list |
919 | ndrv_multi->next = np->nd_multiaddrs; |
920 | np->nd_multiaddrs = ndrv_multi; |
921 | np->nd_dlist_cnt++; |
922 | } |
923 | else |
924 | { |
925 | // Free up the memory, something went wrong |
926 | FREE(ndrv_multi, M_IFADDR); |
927 | } |
928 | |
929 | return result; |
930 | } |
931 | |
932 | static int |
933 | ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt) |
934 | { |
935 | struct sockaddr* multi_addr; |
936 | struct ndrv_multiaddr* ndrv_entry = NULL; |
937 | int result; |
938 | |
939 | if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 || |
940 | sopt->sopt_level != SOL_NDRVPROTO) |
941 | return EINVAL; |
942 | if (np->nd_if == NULL || np->nd_dlist_cnt == 0) |
943 | return ENXIO; |
944 | |
945 | // Allocate storage |
946 | MALLOC(multi_addr, struct sockaddr*, sopt->sopt_valsize, |
947 | M_TEMP, M_WAITOK); |
948 | if (multi_addr == NULL) |
949 | return ENOMEM; |
950 | |
951 | // Copy in the address |
952 | result = copyin(sopt->sopt_val, multi_addr, sopt->sopt_valsize); |
953 | |
954 | // Validate the sockaddr |
955 | if (result == 0 && sopt->sopt_valsize != multi_addr->sa_len) |
956 | result = EINVAL; |
957 | |
958 | if (result == 0) |
959 | { |
960 | /* Find the old entry */ |
961 | ndrv_entry = ndrv_have_multicast(np, multi_addr); |
962 | |
963 | if (ndrv_entry == NULL) |
964 | result = ENOENT; |
965 | } |
966 | |
967 | if (result == 0) |
968 | { |
969 | // Try deleting the multicast |
970 | result = ifnet_remove_multicast(ndrv_entry->ifma); |
971 | } |
972 | |
973 | if (result == 0) |
974 | { |
975 | // Remove from our linked list |
976 | struct ndrv_multiaddr* cur = np->nd_multiaddrs; |
977 | |
978 | ifmaddr_release(ndrv_entry->ifma); |
979 | |
980 | if (cur == ndrv_entry) |
981 | { |
982 | np->nd_multiaddrs = cur->next; |
983 | } |
984 | else |
985 | { |
986 | for (cur = cur->next; cur != NULL; cur = cur->next) |
987 | { |
988 | if (cur->next == ndrv_entry) |
989 | { |
990 | cur->next = cur->next->next; |
991 | break; |
992 | } |
993 | } |
994 | } |
995 | |
996 | np->nd_dlist_cnt--; |
997 | |
998 | // Free the memory |
999 | FREE(ndrv_entry, M_IFADDR); |
1000 | } |
1001 | FREE(multi_addr, M_TEMP); |
1002 | |
1003 | return result; |
1004 | } |
1005 | |
1006 | static struct ndrv_multiaddr* |
1007 | ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* inAddr) |
1008 | { |
1009 | struct ndrv_multiaddr* cur; |
1010 | for (cur = np->nd_multiaddrs; cur != NULL; cur = cur->next) |
1011 | { |
1012 | |
1013 | if ((inAddr->sa_len == cur->addr.sa_len) && |
1014 | (bcmp(&cur->addr, inAddr, inAddr->sa_len) == 0)) |
1015 | { |
1016 | // Found a match |
1017 | return cur; |
1018 | } |
1019 | } |
1020 | |
1021 | return NULL; |
1022 | } |
1023 | |
1024 | static void |
1025 | ndrv_remove_all_multicast(struct ndrv_cb* np) |
1026 | { |
1027 | struct ndrv_multiaddr* cur; |
1028 | |
1029 | if (np->nd_if != NULL) |
1030 | { |
1031 | while (np->nd_multiaddrs != NULL) |
1032 | { |
1033 | cur = np->nd_multiaddrs; |
1034 | np->nd_multiaddrs = cur->next; |
1035 | |
1036 | ifnet_remove_multicast(cur->ifma); |
1037 | ifmaddr_release(cur->ifma); |
1038 | FREE(cur, M_IFADDR); |
1039 | } |
1040 | } |
1041 | } |
1042 | |
1043 | static struct pr_usrreqs ndrv_usrreqs = { |
1044 | .pru_abort = ndrv_abort, |
1045 | .pru_attach = ndrv_attach, |
1046 | .pru_bind = ndrv_bind, |
1047 | .pru_connect = ndrv_connect, |
1048 | .pru_detach = ndrv_detach, |
1049 | .pru_disconnect = ndrv_disconnect, |
1050 | .pru_peeraddr = ndrv_peeraddr, |
1051 | .pru_send = ndrv_send, |
1052 | .pru_shutdown = ndrv_shutdown, |
1053 | .pru_sockaddr = ndrv_sockaddr, |
1054 | .pru_sosend = sosend, |
1055 | .pru_soreceive = soreceive, |
1056 | }; |
1057 | |
1058 | static struct protosw ndrvsw[] = { |
1059 | { |
1060 | .pr_type = SOCK_RAW, |
1061 | .pr_protocol = NDRVPROTO_NDRV, |
1062 | .pr_flags = PR_ATOMIC|PR_ADDR, |
1063 | .pr_output = ndrv_output, |
1064 | .pr_ctloutput = ndrv_ctloutput, |
1065 | .pr_usrreqs = &ndrv_usrreqs, |
1066 | } |
1067 | }; |
1068 | |
1069 | static int ndrv_proto_count = (sizeof (ndrvsw) / sizeof (struct protosw)); |
1070 | |
1071 | struct domain ndrvdomain_s = { |
1072 | .dom_family = PF_NDRV, |
1073 | .dom_name = "NetDriver" , |
1074 | .dom_init = ndrv_dominit, |
1075 | }; |
1076 | |
1077 | static void |
1078 | ndrv_dominit(struct domain *dp) |
1079 | { |
1080 | struct protosw *pr; |
1081 | int i; |
1082 | |
1083 | VERIFY(!(dp->dom_flags & DOM_INITIALIZED)); |
1084 | VERIFY(ndrvdomain == NULL); |
1085 | |
1086 | ndrvdomain = dp; |
1087 | |
1088 | for (i = 0, pr = &ndrvsw[0]; i < ndrv_proto_count; i++, pr++) |
1089 | net_add_proto(pr, dp, 1); |
1090 | } |
1091 | |