Home | History | Annotate | Line # | Download | only in netatalk
ddp_usrreq.c revision 1.65 
      1 /*	$NetBSD: ddp_usrreq.c,v 1.65 2015/04/24 22:32:37 rtr Exp $	 */
      2 
      3 /*
      4  * Copyright (c) 1990,1991 Regents of The University of Michigan.
      5  * All Rights Reserved.
      6  *
      7  * Permission to use, copy, modify, and distribute this software and
      8  * its documentation for any purpose and without fee is hereby granted,
      9  * provided that the above copyright notice appears in all copies and
     10  * that both that copyright notice and this permission notice appear
     11  * in supporting documentation, and that the name of The University
     12  * of Michigan not be used in advertising or publicity pertaining to
     13  * distribution of the software without specific, written prior
     14  * permission. This software is supplied as is without expressed or
     15  * implied warranties of any kind.
     16  *
     17  * This product includes software developed by the University of
     18  * California, Berkeley and its contributors.
     19  *
     20  *	Research Systems Unix Group
     21  *	The University of Michigan
     22  *	c/o Wesley Craig
     23  *	535 W. William Street
     24  *	Ann Arbor, Michigan
     25  *	+1-313-764-2278
     26  *	netatalk (at) umich.edu
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 __KERNEL_RCSID(0, "$NetBSD: ddp_usrreq.c,v 1.65 2015/04/24 22:32:37 rtr Exp $");
     31 
     32 #include "opt_mbuftrace.h"
     33 
     34 #include <sys/param.h>
     35 #include <sys/errno.h>
     36 #include <sys/systm.h>
     37 #include <sys/mbuf.h>
     38 #include <sys/ioctl.h>
     39 #include <sys/queue.h>
     40 #include <sys/socket.h>
     41 #include <sys/socketvar.h>
     42 #include <sys/protosw.h>
     43 #include <sys/kauth.h>
     44 #include <sys/kmem.h>
     45 #include <sys/sysctl.h>
     46 #include <net/if.h>
     47 #include <net/route.h>
     48 #include <net/if_ether.h>
     49 #include <net/net_stats.h>
     50 #include <netinet/in.h>
     51 
     52 #include <netatalk/at.h>
     53 #include <netatalk/at_var.h>
     54 #include <netatalk/ddp_var.h>
     55 #include <netatalk/ddp_private.h>
     56 #include <netatalk/aarp.h>
     57 #include <netatalk/at_extern.h>
     58 
     59 static void at_pcbdisconnect(struct ddpcb *);
     60 static void at_sockaddr(struct ddpcb *, struct sockaddr_at *);
     61 static int at_pcbsetaddr(struct ddpcb *, struct sockaddr_at *);
     62 static int at_pcbconnect(struct ddpcb *, struct mbuf *);
     63 static void ddp_detach(struct socket *);
     64 
     65 struct ifqueue atintrq1, atintrq2;
     66 struct ddpcb   *ddp_ports[ATPORT_LAST];
     67 struct ddpcb   *ddpcb = NULL;
     68 percpu_t *ddpstat_percpu;
     69 struct at_ifaddrhead at_ifaddr;		/* Here as inited in this file */
     70 u_long ddp_sendspace = DDP_MAXSZ;	/* Max ddp size + 1 (ddp_type) */
     71 u_long ddp_recvspace = 25 * (587 + sizeof(struct sockaddr_at));
     72 
     73 #ifdef MBUFTRACE
     74 struct mowner atalk_rx_mowner = MOWNER_INIT("atalk", "rx");
     75 struct mowner atalk_tx_mowner = MOWNER_INIT("atalk", "tx");
     76 #endif
     77 
     78 static int
     79 ddp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *addr,
     80     struct mbuf *rights, struct lwp *l)
     81 {
     82 	struct ddpcb   *ddp;
     83 	int             error = 0;
     84 
     85 	KASSERT(req != PRU_ATTACH);
     86 	KASSERT(req != PRU_DETACH);
     87 	KASSERT(req != PRU_ACCEPT);
     88 	KASSERT(req != PRU_BIND);
     89 	KASSERT(req != PRU_LISTEN);
     90 	KASSERT(req != PRU_CONNECT);
     91 	KASSERT(req != PRU_CONNECT2);
     92 	KASSERT(req != PRU_DISCONNECT);
     93 	KASSERT(req != PRU_SHUTDOWN);
     94 	KASSERT(req != PRU_ABORT);
     95 	KASSERT(req != PRU_CONTROL);
     96 	KASSERT(req != PRU_SENSE);
     97 	KASSERT(req != PRU_PEERADDR);
     98 	KASSERT(req != PRU_SOCKADDR);
     99 	KASSERT(req != PRU_RCVD);
    100 	KASSERT(req != PRU_RCVOOB);
    101 	KASSERT(req != PRU_SEND);
    102 	KASSERT(req != PRU_SENDOOB);
    103 	KASSERT(req != PRU_PURGEIF);
    104 
    105 	ddp = sotoddpcb(so);
    106 
    107 	if (rights && rights->m_len) {
    108 		error = EINVAL;
    109 		goto release;
    110 	}
    111 	if (ddp == NULL) {
    112 		error = EINVAL;
    113 		goto release;
    114 	}
    115 	switch (req) {
    116 	case PRU_FASTTIMO:
    117 	case PRU_SLOWTIMO:
    118 	case PRU_PROTORCV:
    119 	case PRU_PROTOSEND:
    120 		error = EOPNOTSUPP;
    121 		break;
    122 
    123 	default:
    124 		error = EOPNOTSUPP;
    125 	}
    126 
    127 release:
    128 	if (m != NULL) {
    129 		m_freem(m);
    130 	}
    131 	return (error);
    132 }
    133 
    134 static void
    135 at_sockaddr(struct ddpcb *ddp, struct sockaddr_at *addr)
    136 {
    137 
    138 	*addr = ddp->ddp_lsat;
    139 }
    140 
    141 static int
    142 at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr_at *sat)
    143 {
    144 	struct sockaddr_at lsat;
    145 	struct at_ifaddr *aa;
    146 	struct ddpcb   *ddpp;
    147 
    148 	if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT) {	/* shouldn't be bound */
    149 		return (EINVAL);
    150 	}
    151 	if (NULL != sat) {	/* validate passed address */
    152 
    153 		if (sat->sat_family != AF_APPLETALK)
    154 			return (EAFNOSUPPORT);
    155 
    156 		if (sat->sat_addr.s_node != ATADDR_ANYNODE ||
    157 		    sat->sat_addr.s_net != ATADDR_ANYNET) {
    158 			TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    159 				if ((sat->sat_addr.s_net ==
    160 				    AA_SAT(aa)->sat_addr.s_net) &&
    161 				    (sat->sat_addr.s_node ==
    162 				    AA_SAT(aa)->sat_addr.s_node))
    163 					break;
    164 			}
    165 			if (!aa)
    166 				return (EADDRNOTAVAIL);
    167 		}
    168 		if (sat->sat_port != ATADDR_ANYPORT) {
    169 			int error;
    170 
    171 			if (sat->sat_port < ATPORT_FIRST ||
    172 			    sat->sat_port >= ATPORT_LAST)
    173 				return (EINVAL);
    174 
    175 			if (sat->sat_port < ATPORT_RESERVED &&
    176 			    (error = kauth_authorize_network(curlwp->l_cred,
    177 			    KAUTH_NETWORK_BIND, KAUTH_REQ_NETWORK_BIND_PRIVPORT,
    178 			    ddpcb->ddp_socket, sat, NULL)) != 0)
    179 				return (error);
    180 		}
    181 	} else {
    182 		memset((void *) & lsat, 0, sizeof(struct sockaddr_at));
    183 		lsat.sat_len = sizeof(struct sockaddr_at);
    184 		lsat.sat_addr.s_node = ATADDR_ANYNODE;
    185 		lsat.sat_addr.s_net = ATADDR_ANYNET;
    186 		lsat.sat_family = AF_APPLETALK;
    187 		sat = &lsat;
    188 	}
    189 
    190 	if (sat->sat_addr.s_node == ATADDR_ANYNODE &&
    191 	    sat->sat_addr.s_net == ATADDR_ANYNET) {
    192 		if (TAILQ_EMPTY(&at_ifaddr))
    193 			return EADDRNOTAVAIL;
    194 		sat->sat_addr = AA_SAT(TAILQ_FIRST(&at_ifaddr))->sat_addr;
    195 	}
    196 	ddp->ddp_lsat = *sat;
    197 
    198 	/*
    199          * Choose port.
    200          */
    201 	if (sat->sat_port == ATADDR_ANYPORT) {
    202 		for (sat->sat_port = ATPORT_RESERVED;
    203 		     sat->sat_port < ATPORT_LAST; sat->sat_port++) {
    204 			if (ddp_ports[sat->sat_port - 1] == 0)
    205 				break;
    206 		}
    207 		if (sat->sat_port == ATPORT_LAST) {
    208 			return (EADDRNOTAVAIL);
    209 		}
    210 		ddp->ddp_lsat.sat_port = sat->sat_port;
    211 		ddp_ports[sat->sat_port - 1] = ddp;
    212 	} else {
    213 		for (ddpp = ddp_ports[sat->sat_port - 1]; ddpp;
    214 		     ddpp = ddpp->ddp_pnext) {
    215 			if (ddpp->ddp_lsat.sat_addr.s_net ==
    216 			    sat->sat_addr.s_net &&
    217 			    ddpp->ddp_lsat.sat_addr.s_node ==
    218 			    sat->sat_addr.s_node)
    219 				break;
    220 		}
    221 		if (ddpp != NULL)
    222 			return (EADDRINUSE);
    223 
    224 		ddp->ddp_pnext = ddp_ports[sat->sat_port - 1];
    225 		ddp_ports[sat->sat_port - 1] = ddp;
    226 		if (ddp->ddp_pnext)
    227 			ddp->ddp_pnext->ddp_pprev = ddp;
    228 	}
    229 
    230 	return 0;
    231 }
    232 
    233 static int
    234 at_pcbconnect(struct ddpcb *ddp, struct mbuf *addr)
    235 {
    236 	struct rtentry *rt;
    237 	const struct sockaddr_at *cdst;
    238 	struct sockaddr_at *sat = mtod(addr, struct sockaddr_at *);
    239 	struct route *ro;
    240 	struct at_ifaddr *aa;
    241 	struct ifnet   *ifp;
    242 	u_short         hintnet = 0, net;
    243 
    244 	if (addr->m_len != sizeof(*sat))
    245 		return EINVAL;
    246 	if (sat->sat_family != AF_APPLETALK) {
    247 		return EAFNOSUPPORT;
    248 	}
    249 	/*
    250          * Under phase 2, network 0 means "the network".  We take "the
    251          * network" to mean the network the control block is bound to.
    252          * If the control block is not bound, there is an error.
    253          */
    254 	if (sat->sat_addr.s_net == ATADDR_ANYNET
    255 	    && sat->sat_addr.s_node != ATADDR_ANYNODE) {
    256 		if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT) {
    257 			return EADDRNOTAVAIL;
    258 		}
    259 		hintnet = ddp->ddp_lsat.sat_addr.s_net;
    260 	}
    261 	ro = &ddp->ddp_route;
    262 	/*
    263          * If we've got an old route for this pcb, check that it is valid.
    264          * If we've changed our address, we may have an old "good looking"
    265          * route here.  Attempt to detect it.
    266          */
    267 	if ((rt = rtcache_validate(ro)) != NULL ||
    268 	    (rt = rtcache_update(ro, 1)) != NULL) {
    269 		if (hintnet) {
    270 			net = hintnet;
    271 		} else {
    272 			net = sat->sat_addr.s_net;
    273 		}
    274 		if ((ifp = rt->rt_ifp) != NULL) {
    275 			TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    276 				if (aa->aa_ifp == ifp &&
    277 				    ntohs(net) >= ntohs(aa->aa_firstnet) &&
    278 				    ntohs(net) <= ntohs(aa->aa_lastnet)) {
    279 					break;
    280 				}
    281 			}
    282 		} else
    283 			aa = NULL;
    284 		cdst = satocsat(rtcache_getdst(ro));
    285 		if (aa == NULL || (cdst->sat_addr.s_net !=
    286 		    (hintnet ? hintnet : sat->sat_addr.s_net) ||
    287 		    cdst->sat_addr.s_node != sat->sat_addr.s_node)) {
    288 			rtcache_free(ro);
    289 			rt = NULL;
    290 		}
    291 	}
    292 	/*
    293          * If we've got no route for this interface, try to find one.
    294          */
    295 	if (rt == NULL) {
    296 		union {
    297 			struct sockaddr		dst;
    298 			struct sockaddr_at	dsta;
    299 		} u;
    300 
    301 		sockaddr_at_init(&u.dsta, &sat->sat_addr, 0);
    302 		if (hintnet)
    303 			u.dsta.sat_addr.s_net = hintnet;
    304 		rt = rtcache_lookup(ro, &u.dst);
    305 	}
    306 	/*
    307          * Make sure any route that we have has a valid interface.
    308          */
    309 	if (rt != NULL && (ifp = rt->rt_ifp) != NULL) {
    310 		TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    311 			if (aa->aa_ifp == ifp)
    312 				break;
    313 		}
    314 	} else
    315 		aa = NULL;
    316 	if (aa == NULL)
    317 		return ENETUNREACH;
    318 	ddp->ddp_fsat = *sat;
    319 	if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT)
    320 		return at_pcbsetaddr(ddp, NULL);
    321 	return 0;
    322 }
    323 
    324 static void
    325 at_pcbdisconnect(struct ddpcb *ddp)
    326 {
    327 	ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
    328 	ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
    329 	ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
    330 }
    331 
    332 static int
    333 ddp_attach(struct socket *so, int proto)
    334 {
    335 	struct ddpcb *ddp;
    336 	int error;
    337 
    338 	KASSERT(sotoddpcb(so) == NULL);
    339 	sosetlock(so);
    340 #ifdef MBUFTRACE
    341 	so->so_rcv.sb_mowner = &atalk_rx_mowner;
    342 	so->so_snd.sb_mowner = &atalk_tx_mowner;
    343 #endif
    344 	error = soreserve(so, ddp_sendspace, ddp_recvspace);
    345 	if (error) {
    346 		return error;
    347 	}
    348 
    349 	ddp = kmem_zalloc(sizeof(*ddp), KM_SLEEP);
    350 	ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
    351 
    352 	ddp->ddp_next = ddpcb;
    353 	ddp->ddp_prev = NULL;
    354 	ddp->ddp_pprev = NULL;
    355 	ddp->ddp_pnext = NULL;
    356 	if (ddpcb) {
    357 		ddpcb->ddp_prev = ddp;
    358 	}
    359 	ddpcb = ddp;
    360 
    361 	ddp->ddp_socket = so;
    362 	so->so_pcb = ddp;
    363 	return 0;
    364 }
    365 
    366 static void
    367 ddp_detach(struct socket *so)
    368 {
    369 	struct ddpcb *ddp = sotoddpcb(so);
    370 
    371 	soisdisconnected(so);
    372 	so->so_pcb = NULL;
    373 	/* sofree drops the lock */
    374 	sofree(so);
    375 	mutex_enter(softnet_lock);
    376 
    377 	/* remove ddp from ddp_ports list */
    378 	if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
    379 	    ddp_ports[ddp->ddp_lsat.sat_port - 1] != NULL) {
    380 		if (ddp->ddp_pprev != NULL) {
    381 			ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
    382 		} else {
    383 			ddp_ports[ddp->ddp_lsat.sat_port - 1] = ddp->ddp_pnext;
    384 		}
    385 		if (ddp->ddp_pnext != NULL) {
    386 			ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
    387 		}
    388 	}
    389 	rtcache_free(&ddp->ddp_route);
    390 	if (ddp->ddp_prev) {
    391 		ddp->ddp_prev->ddp_next = ddp->ddp_next;
    392 	} else {
    393 		ddpcb = ddp->ddp_next;
    394 	}
    395 	if (ddp->ddp_next) {
    396 		ddp->ddp_next->ddp_prev = ddp->ddp_prev;
    397 	}
    398 	kmem_free(ddp, sizeof(*ddp));
    399 }
    400 
    401 static int
    402 ddp_accept(struct socket *so, struct sockaddr *nam)
    403 {
    404 	KASSERT(solocked(so));
    405 
    406 	return EOPNOTSUPP;
    407 }
    408 
    409 static int
    410 ddp_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
    411 {
    412 	KASSERT(solocked(so));
    413 	KASSERT(sotoddpcb(so) != NULL);
    414 
    415 	return at_pcbsetaddr(sotoddpcb(so), (struct sockaddr_at *)nam);
    416 }
    417 
    418 static int
    419 ddp_listen(struct socket *so, struct lwp *l)
    420 {
    421 	KASSERT(solocked(so));
    422 
    423 	return EOPNOTSUPP;
    424 }
    425 
    426 static int
    427 ddp_connect(struct socket *so, struct mbuf *nam, struct lwp *l)
    428 {
    429 	struct ddpcb *ddp = sotoddpcb(so);
    430 	int error = 0;
    431 
    432 	KASSERT(solocked(so));
    433 	KASSERT(ddp != NULL);
    434 	KASSERT(nam != NULL);
    435 
    436 	if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT)
    437 		return EISCONN;
    438 	error = at_pcbconnect(ddp, nam);
    439 	if (error == 0)
    440 		soisconnected(so);
    441 
    442 	return error;
    443 }
    444 
    445 static int
    446 ddp_connect2(struct socket *so, struct socket *so2)
    447 {
    448 	KASSERT(solocked(so));
    449 
    450 	return EOPNOTSUPP;
    451 }
    452 
    453 static int
    454 ddp_disconnect(struct socket *so)
    455 {
    456 	struct ddpcb *ddp = sotoddpcb(so);
    457 
    458 	KASSERT(solocked(so));
    459 	KASSERT(ddp != NULL);
    460 
    461 	if (ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE)
    462 		return ENOTCONN;
    463 
    464 	at_pcbdisconnect(ddp);
    465 	soisdisconnected(so);
    466 	return 0;
    467 }
    468 
    469 static int
    470 ddp_shutdown(struct socket *so)
    471 {
    472 	KASSERT(solocked(so));
    473 
    474 	socantsendmore(so);
    475 	return 0;
    476 }
    477 
    478 static int
    479 ddp_abort(struct socket *so)
    480 {
    481 	KASSERT(solocked(so));
    482 
    483 	soisdisconnected(so);
    484 	ddp_detach(so);
    485 	return 0;
    486 }
    487 
    488 static int
    489 ddp_ioctl(struct socket *so, u_long cmd, void *addr, struct ifnet *ifp)
    490 {
    491 	return at_control(cmd, addr, ifp);
    492 }
    493 
    494 static int
    495 ddp_stat(struct socket *so, struct stat *ub)
    496 {
    497 	KASSERT(solocked(so));
    498 
    499 	/* stat: don't bother with a blocksize. */
    500 	return 0;
    501 }
    502 
    503 static int
    504 ddp_peeraddr(struct socket *so, struct sockaddr *nam)
    505 {
    506 	KASSERT(solocked(so));
    507 
    508 	return EOPNOTSUPP;
    509 }
    510 
    511 static int
    512 ddp_sockaddr(struct socket *so, struct sockaddr *nam)
    513 {
    514 	KASSERT(solocked(so));
    515 	KASSERT(sotoddpcb(so) != NULL);
    516 	KASSERT(nam != NULL);
    517 
    518 	at_sockaddr(sotoddpcb(so), (struct sockaddr_at *)nam);
    519 	return 0;
    520 }
    521 
    522 static int
    523 ddp_rcvd(struct socket *so, int flags, struct lwp *l)
    524 {
    525 	KASSERT(solocked(so));
    526 
    527 	return EOPNOTSUPP;
    528 }
    529 
    530 static int
    531 ddp_recvoob(struct socket *so, struct mbuf *m, int flags)
    532 {
    533 	KASSERT(solocked(so));
    534 
    535 	return EOPNOTSUPP;
    536 }
    537 
    538 static int
    539 ddp_send(struct socket *so, struct mbuf *m, struct mbuf *nam,
    540     struct mbuf *control, struct lwp *l)
    541 {
    542 	struct ddpcb *ddp = sotoddpcb(so);
    543 	int error = 0;
    544 	int s = 0; /* XXX gcc 4.8 warns on sgimips */
    545 
    546 	KASSERT(solocked(so));
    547 	KASSERT(ddp != NULL);
    548 
    549 	if (nam) {
    550 		if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT)
    551 			return EISCONN;
    552 		s = splnet();
    553 		error = at_pcbconnect(ddp, nam);
    554 		if (error) {
    555 			splx(s);
    556 			return error;
    557 		}
    558 	} else {
    559 		if (ddp->ddp_fsat.sat_port == ATADDR_ANYPORT)
    560 			return ENOTCONN;
    561 	}
    562 
    563 	error = ddp_output(m, ddp);
    564 	m = NULL;
    565 	if (nam) {
    566 		at_pcbdisconnect(ddp);
    567 		splx(s);
    568 	}
    569 
    570 	return error;
    571 }
    572 
    573 static int
    574 ddp_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
    575 {
    576 	KASSERT(solocked(so));
    577 
    578 	if (m)
    579 		m_freem(m);
    580 
    581 	return EOPNOTSUPP;
    582 }
    583 
    584 static int
    585 ddp_purgeif(struct socket *so, struct ifnet *ifp)
    586 {
    587 
    588 	mutex_enter(softnet_lock);
    589 	at_purgeif(ifp);
    590 	mutex_exit(softnet_lock);
    591 
    592 	return 0;
    593 }
    594 
    595 /*
    596  * For the moment, this just find the pcb with the correct local address.
    597  * In the future, this will actually do some real searching, so we can use
    598  * the sender's address to do de-multiplexing on a single port to many
    599  * sockets (pcbs).
    600  */
    601 struct ddpcb   *
    602 ddp_search(
    603     struct sockaddr_at *from,
    604     struct sockaddr_at *to,
    605     struct at_ifaddr *aa)
    606 {
    607 	struct ddpcb   *ddp;
    608 
    609 	/*
    610          * Check for bad ports.
    611          */
    612 	if (to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST)
    613 		return NULL;
    614 
    615 	/*
    616          * Make sure the local address matches the sent address.  What about
    617          * the interface?
    618          */
    619 	for (ddp = ddp_ports[to->sat_port - 1]; ddp; ddp = ddp->ddp_pnext) {
    620 		/* XXX should we handle 0.YY? */
    621 
    622 		/* XXXX.YY to socket on destination interface */
    623 		if (to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
    624 		    to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node) {
    625 			break;
    626 		}
    627 		/* 0.255 to socket on receiving interface */
    628 		if (to->sat_addr.s_node == ATADDR_BCAST &&
    629 		    (to->sat_addr.s_net == 0 ||
    630 		    to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net) &&
    631 		ddp->ddp_lsat.sat_addr.s_net == AA_SAT(aa)->sat_addr.s_net) {
    632 			break;
    633 		}
    634 		/* XXXX.0 to socket on destination interface */
    635 		if (to->sat_addr.s_net == aa->aa_firstnet &&
    636 		    to->sat_addr.s_node == 0 &&
    637 		    ntohs(ddp->ddp_lsat.sat_addr.s_net) >=
    638 		    ntohs(aa->aa_firstnet) &&
    639 		    ntohs(ddp->ddp_lsat.sat_addr.s_net) <=
    640 		    ntohs(aa->aa_lastnet)) {
    641 			break;
    642 		}
    643 	}
    644 	return (ddp);
    645 }
    646 
    647 /*
    648  * Initialize all the ddp & appletalk stuff
    649  */
    650 void
    651 ddp_init(void)
    652 {
    653 
    654 	ddpstat_percpu = percpu_alloc(sizeof(uint64_t) * DDP_NSTATS);
    655 
    656 	TAILQ_INIT(&at_ifaddr);
    657 	atintrq1.ifq_maxlen = IFQ_MAXLEN;
    658 	atintrq2.ifq_maxlen = IFQ_MAXLEN;
    659 
    660 	MOWNER_ATTACH(&atalk_tx_mowner);
    661 	MOWNER_ATTACH(&atalk_rx_mowner);
    662 	MOWNER_ATTACH(&aarp_mowner);
    663 }
    664 
    665 PR_WRAP_USRREQS(ddp)
    666 #define	ddp_attach	ddp_attach_wrapper
    667 #define	ddp_detach	ddp_detach_wrapper
    668 #define	ddp_accept	ddp_accept_wrapper
    669 #define	ddp_bind	ddp_bind_wrapper
    670 #define	ddp_listen	ddp_listen_wrapper
    671 #define	ddp_connect	ddp_connect_wrapper
    672 #define	ddp_connect2	ddp_connect2_wrapper
    673 #define	ddp_disconnect	ddp_disconnect_wrapper
    674 #define	ddp_shutdown	ddp_shutdown_wrapper
    675 #define	ddp_abort	ddp_abort_wrapper
    676 #define	ddp_ioctl	ddp_ioctl_wrapper
    677 #define	ddp_stat	ddp_stat_wrapper
    678 #define	ddp_peeraddr	ddp_peeraddr_wrapper
    679 #define	ddp_sockaddr	ddp_sockaddr_wrapper
    680 #define	ddp_rcvd	ddp_rcvd_wrapper
    681 #define	ddp_recvoob	ddp_recvoob_wrapper
    682 #define	ddp_send	ddp_send_wrapper
    683 #define	ddp_sendoob	ddp_sendoob_wrapper
    684 #define	ddp_purgeif	ddp_purgeif_wrapper
    685 #define	ddp_usrreq	ddp_usrreq_wrapper
    686 
    687 const struct pr_usrreqs ddp_usrreqs = {
    688 	.pr_attach	= ddp_attach,
    689 	.pr_detach	= ddp_detach,
    690 	.pr_accept	= ddp_accept,
    691 	.pr_bind	= ddp_bind,
    692 	.pr_listen	= ddp_listen,
    693 	.pr_connect	= ddp_connect,
    694 	.pr_connect2	= ddp_connect2,
    695 	.pr_disconnect	= ddp_disconnect,
    696 	.pr_shutdown	= ddp_shutdown,
    697 	.pr_abort	= ddp_abort,
    698 	.pr_ioctl	= ddp_ioctl,
    699 	.pr_stat	= ddp_stat,
    700 	.pr_peeraddr	= ddp_peeraddr,
    701 	.pr_sockaddr	= ddp_sockaddr,
    702 	.pr_rcvd	= ddp_rcvd,
    703 	.pr_recvoob	= ddp_recvoob,
    704 	.pr_send	= ddp_send,
    705 	.pr_sendoob	= ddp_sendoob,
    706 	.pr_purgeif	= ddp_purgeif,
    707 	.pr_generic	= ddp_usrreq,
    708 };
    709 
    710 static int
    711 sysctl_net_atalk_ddp_stats(SYSCTLFN_ARGS)
    712 {
    713 
    714 	return (NETSTAT_SYSCTL(ddpstat_percpu, DDP_NSTATS));
    715 }
    716 
    717 /*
    718  * Sysctl for DDP variables.
    719  */
    720 SYSCTL_SETUP(sysctl_net_atalk_ddp_setup, "sysctl net.atalk.ddp subtree setup")
    721 {
    722 
    723 	sysctl_createv(clog, 0, NULL, NULL,
    724 		       CTLFLAG_PERMANENT,
    725 		       CTLTYPE_NODE, "atalk", NULL,
    726 		       NULL, 0, NULL, 0,
    727 		       CTL_NET, PF_APPLETALK, CTL_EOL);
    728 	sysctl_createv(clog, 0, NULL, NULL,
    729 		       CTLFLAG_PERMANENT,
    730 		       CTLTYPE_NODE, "ddp",
    731 		       SYSCTL_DESCR("DDP related settings"),
    732 		       NULL, 0, NULL, 0,
    733 		       CTL_NET, PF_APPLETALK, ATPROTO_DDP, CTL_EOL);
    734 
    735 	sysctl_createv(clog, 0, NULL, NULL,
    736 		       CTLFLAG_PERMANENT,
    737 		       CTLTYPE_STRUCT, "stats",
    738 		       SYSCTL_DESCR("DDP statistics"),
    739 		       sysctl_net_atalk_ddp_stats, 0, NULL, 0,
    740 		       CTL_NET, PF_APPLETALK, ATPROTO_DDP, CTL_CREATE,
    741 		       CTL_EOL);
    742 }
    743