bsd/net/ndrv.c

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