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
81static unsigned int ndrv_multi_max_count = NDRV_DMUX_MAX_DESCR;
82SYSCTL_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
85static int ndrv_do_detach(struct ndrv_cb *);
86static int ndrv_do_disconnect(struct ndrv_cb *);
87static struct ndrv_cb *ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol_family);
88static int ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt);
89static int ndrv_delspec(struct ndrv_cb *);
90static int ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux);
91static void ndrv_handle_ifp_detach(u_int32_t family, short unit);
92static int ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt);
93static int ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt);
94static struct ndrv_multiaddr* ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* addr);
95static void ndrv_remove_all_multicast(struct ndrv_cb *np);
96static void ndrv_dominit(struct domain *);
97
98u_int32_t ndrv_sendspace = NDRVSNDQ;
99u_int32_t ndrv_recvspace = NDRVRCVQ;
100TAILQ_HEAD(, ndrv_cb) ndrvl = TAILQ_HEAD_INITIALIZER(ndrvl);
101
102static struct domain *ndrvdomain = NULL;
103extern 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 */
127static int
128ndrv_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 */
159static errno_t
160ndrv_input(
161 ifnet_t ifp,
162 protocol_family_t proto_family,
163 mbuf_t m,
164 char *frame_header)
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 */
208static int
209ndrv_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
250static int
251ndrv_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
270static int
271ndrv_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
292static void
293ndrv_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
307static 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 */
314static int
315ndrv_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
387static int
388ndrv_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 */
405static int
406ndrv_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 */
418static int
419ndrv_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
434static int
435ndrv_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
446static int
447ndrv_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
468static int
469ndrv_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
492static int
493ndrv_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
530static int
531ndrv_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
581static int
582ndrv_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 */
605static void
606sprint_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 */
624static 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 */
645void
646ndrv_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
661int
662ndrv_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
783int
784ndrv_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
806int
807ndrv_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
822struct ndrv_cb *
823ndrv_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
839static void
840ndrv_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
879static int
880ndrv_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
932static int
933ndrv_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
1006static struct ndrv_multiaddr*
1007ndrv_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
1024static void
1025ndrv_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
1043static 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
1058static 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
1069static int ndrv_proto_count = (sizeof (ndrvsw) / sizeof (struct protosw));
1070
1071struct domain ndrvdomain_s = {
1072 .dom_family = PF_NDRV,
1073 .dom_name = "NetDriver",
1074 .dom_init = ndrv_dominit,
1075};
1076
1077static void
1078ndrv_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