Home | History | Annotate | Line # | Download | only in netatalk
ddp_usrreq.c revision 1.56 
      1 /*	$NetBSD: ddp_usrreq.c,v 1.56 2014/07/30 10:04:26 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.56 2014/07/30 10:04:26 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 mbuf *);
     61 static int at_pcbsetaddr(struct ddpcb *, struct mbuf *);
     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_CONTROL);
     92 	KASSERT(req != PRU_SENSE);
     93 	KASSERT(req != PRU_PEERADDR);
     94 	KASSERT(req != PRU_SOCKADDR);
     95 	KASSERT(req != PRU_RCVOOB);
     96 	KASSERT(req != PRU_SENDOOB);
     97 
     98 	ddp = sotoddpcb(so);
     99 
    100 	if (req == PRU_PURGEIF) {
    101 		mutex_enter(softnet_lock);
    102 		at_purgeif((struct ifnet *) rights);
    103 		mutex_exit(softnet_lock);
    104 		return (0);
    105 	}
    106 	if (rights && rights->m_len) {
    107 		error = EINVAL;
    108 		goto release;
    109 	}
    110 	if (ddp == NULL) {
    111 		error = EINVAL;
    112 		goto release;
    113 	}
    114 	switch (req) {
    115 	case PRU_DISCONNECT:
    116 		if (ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE) {
    117 			error = ENOTCONN;
    118 			break;
    119 		}
    120 		at_pcbdisconnect(ddp);
    121 		soisdisconnected(so);
    122 		break;
    123 
    124 	case PRU_SHUTDOWN:
    125 		socantsendmore(so);
    126 		break;
    127 
    128 	case PRU_SEND:{
    129 			int s = 0;
    130 
    131 			if (addr) {
    132 				if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
    133 					error = EISCONN;
    134 					break;
    135 				}
    136 				s = splnet();
    137 				error = at_pcbconnect(ddp, addr);
    138 				if (error) {
    139 					splx(s);
    140 					break;
    141 				}
    142 			} else {
    143 				if (ddp->ddp_fsat.sat_port == ATADDR_ANYPORT) {
    144 					error = ENOTCONN;
    145 					break;
    146 				}
    147 			}
    148 
    149 			error = ddp_output(m, ddp);
    150 			m = NULL;
    151 			if (addr) {
    152 				at_pcbdisconnect(ddp);
    153 				splx(s);
    154 			}
    155 		}
    156 		break;
    157 
    158 	case PRU_ABORT:
    159 		soisdisconnected(so);
    160 		ddp_detach(so);
    161 		break;
    162 
    163 	case PRU_CONNECT2:
    164 	case PRU_FASTTIMO:
    165 	case PRU_SLOWTIMO:
    166 	case PRU_PROTORCV:
    167 	case PRU_PROTOSEND:
    168 		error = EOPNOTSUPP;
    169 		break;
    170 
    171 	case PRU_RCVD:
    172 		/*
    173 		 * Don't mfree. Good architecture...
    174 		 */
    175 		return (EOPNOTSUPP);
    176 
    177 	default:
    178 		error = EOPNOTSUPP;
    179 	}
    180 
    181 release:
    182 	if (m != NULL) {
    183 		m_freem(m);
    184 	}
    185 	return (error);
    186 }
    187 
    188 static void
    189 at_sockaddr(struct ddpcb *ddp, struct mbuf *addr)
    190 {
    191 	struct sockaddr_at *sat;
    192 
    193 	addr->m_len = sizeof(struct sockaddr_at);
    194 	sat = mtod(addr, struct sockaddr_at *);
    195 	*sat = ddp->ddp_lsat;
    196 }
    197 
    198 static int
    199 at_pcbsetaddr(struct ddpcb *ddp, struct mbuf *addr)
    200 {
    201 	struct sockaddr_at lsat, *sat;
    202 	struct at_ifaddr *aa;
    203 	struct ddpcb   *ddpp;
    204 
    205 	if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT) {	/* shouldn't be bound */
    206 		return (EINVAL);
    207 	}
    208 	if (addr != 0) {	/* validate passed address */
    209 		sat = mtod(addr, struct sockaddr_at *);
    210 		if (addr->m_len != sizeof(*sat))
    211 			return (EINVAL);
    212 
    213 		if (sat->sat_family != AF_APPLETALK)
    214 			return (EAFNOSUPPORT);
    215 
    216 		if (sat->sat_addr.s_node != ATADDR_ANYNODE ||
    217 		    sat->sat_addr.s_net != ATADDR_ANYNET) {
    218 			TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    219 				if ((sat->sat_addr.s_net ==
    220 				    AA_SAT(aa)->sat_addr.s_net) &&
    221 				    (sat->sat_addr.s_node ==
    222 				    AA_SAT(aa)->sat_addr.s_node))
    223 					break;
    224 			}
    225 			if (!aa)
    226 				return (EADDRNOTAVAIL);
    227 		}
    228 		if (sat->sat_port != ATADDR_ANYPORT) {
    229 			int error;
    230 
    231 			if (sat->sat_port < ATPORT_FIRST ||
    232 			    sat->sat_port >= ATPORT_LAST)
    233 				return (EINVAL);
    234 
    235 			if (sat->sat_port < ATPORT_RESERVED &&
    236 			    (error = kauth_authorize_network(curlwp->l_cred,
    237 			    KAUTH_NETWORK_BIND, KAUTH_REQ_NETWORK_BIND_PRIVPORT,
    238 			    ddpcb->ddp_socket, sat, NULL)) != 0)
    239 				return (error);
    240 		}
    241 	} else {
    242 		memset((void *) & lsat, 0, sizeof(struct sockaddr_at));
    243 		lsat.sat_len = sizeof(struct sockaddr_at);
    244 		lsat.sat_addr.s_node = ATADDR_ANYNODE;
    245 		lsat.sat_addr.s_net = ATADDR_ANYNET;
    246 		lsat.sat_family = AF_APPLETALK;
    247 		sat = &lsat;
    248 	}
    249 
    250 	if (sat->sat_addr.s_node == ATADDR_ANYNODE &&
    251 	    sat->sat_addr.s_net == ATADDR_ANYNET) {
    252 		if (TAILQ_EMPTY(&at_ifaddr))
    253 			return EADDRNOTAVAIL;
    254 		sat->sat_addr = AA_SAT(TAILQ_FIRST(&at_ifaddr))->sat_addr;
    255 	}
    256 	ddp->ddp_lsat = *sat;
    257 
    258 	/*
    259          * Choose port.
    260          */
    261 	if (sat->sat_port == ATADDR_ANYPORT) {
    262 		for (sat->sat_port = ATPORT_RESERVED;
    263 		     sat->sat_port < ATPORT_LAST; sat->sat_port++) {
    264 			if (ddp_ports[sat->sat_port - 1] == 0)
    265 				break;
    266 		}
    267 		if (sat->sat_port == ATPORT_LAST) {
    268 			return (EADDRNOTAVAIL);
    269 		}
    270 		ddp->ddp_lsat.sat_port = sat->sat_port;
    271 		ddp_ports[sat->sat_port - 1] = ddp;
    272 	} else {
    273 		for (ddpp = ddp_ports[sat->sat_port - 1]; ddpp;
    274 		     ddpp = ddpp->ddp_pnext) {
    275 			if (ddpp->ddp_lsat.sat_addr.s_net ==
    276 			    sat->sat_addr.s_net &&
    277 			    ddpp->ddp_lsat.sat_addr.s_node ==
    278 			    sat->sat_addr.s_node)
    279 				break;
    280 		}
    281 		if (ddpp != NULL)
    282 			return (EADDRINUSE);
    283 
    284 		ddp->ddp_pnext = ddp_ports[sat->sat_port - 1];
    285 		ddp_ports[sat->sat_port - 1] = ddp;
    286 		if (ddp->ddp_pnext)
    287 			ddp->ddp_pnext->ddp_pprev = ddp;
    288 	}
    289 
    290 	return 0;
    291 }
    292 
    293 static int
    294 at_pcbconnect(struct ddpcb *ddp, struct mbuf *addr)
    295 {
    296 	struct rtentry *rt;
    297 	const struct sockaddr_at *cdst;
    298 	struct sockaddr_at *sat = mtod(addr, struct sockaddr_at *);
    299 	struct route *ro;
    300 	struct at_ifaddr *aa;
    301 	struct ifnet   *ifp;
    302 	u_short         hintnet = 0, net;
    303 
    304 	if (addr->m_len != sizeof(*sat))
    305 		return EINVAL;
    306 	if (sat->sat_family != AF_APPLETALK) {
    307 		return EAFNOSUPPORT;
    308 	}
    309 	/*
    310          * Under phase 2, network 0 means "the network".  We take "the
    311          * network" to mean the network the control block is bound to.
    312          * If the control block is not bound, there is an error.
    313          */
    314 	if (sat->sat_addr.s_net == ATADDR_ANYNET
    315 	    && sat->sat_addr.s_node != ATADDR_ANYNODE) {
    316 		if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT) {
    317 			return EADDRNOTAVAIL;
    318 		}
    319 		hintnet = ddp->ddp_lsat.sat_addr.s_net;
    320 	}
    321 	ro = &ddp->ddp_route;
    322 	/*
    323          * If we've got an old route for this pcb, check that it is valid.
    324          * If we've changed our address, we may have an old "good looking"
    325          * route here.  Attempt to detect it.
    326          */
    327 	if ((rt = rtcache_validate(ro)) != NULL ||
    328 	    (rt = rtcache_update(ro, 1)) != NULL) {
    329 		if (hintnet) {
    330 			net = hintnet;
    331 		} else {
    332 			net = sat->sat_addr.s_net;
    333 		}
    334 		if ((ifp = rt->rt_ifp) != NULL) {
    335 			TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    336 				if (aa->aa_ifp == ifp &&
    337 				    ntohs(net) >= ntohs(aa->aa_firstnet) &&
    338 				    ntohs(net) <= ntohs(aa->aa_lastnet)) {
    339 					break;
    340 				}
    341 			}
    342 		} else
    343 			aa = NULL;
    344 		cdst = satocsat(rtcache_getdst(ro));
    345 		if (aa == NULL || (cdst->sat_addr.s_net !=
    346 		    (hintnet ? hintnet : sat->sat_addr.s_net) ||
    347 		    cdst->sat_addr.s_node != sat->sat_addr.s_node)) {
    348 			rtcache_free(ro);
    349 			rt = NULL;
    350 		}
    351 	}
    352 	/*
    353          * If we've got no route for this interface, try to find one.
    354          */
    355 	if (rt == NULL) {
    356 		union {
    357 			struct sockaddr		dst;
    358 			struct sockaddr_at	dsta;
    359 		} u;
    360 
    361 		sockaddr_at_init(&u.dsta, &sat->sat_addr, 0);
    362 		if (hintnet)
    363 			u.dsta.sat_addr.s_net = hintnet;
    364 		rt = rtcache_lookup(ro, &u.dst);
    365 	}
    366 	/*
    367          * Make sure any route that we have has a valid interface.
    368          */
    369 	if (rt != NULL && (ifp = rt->rt_ifp) != NULL) {
    370 		TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
    371 			if (aa->aa_ifp == ifp)
    372 				break;
    373 		}
    374 	} else
    375 		aa = NULL;
    376 	if (aa == NULL)
    377 		return ENETUNREACH;
    378 	ddp->ddp_fsat = *sat;
    379 	if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT)
    380 		return at_pcbsetaddr(ddp, NULL);
    381 	return 0;
    382 }
    383 
    384 static void
    385 at_pcbdisconnect(struct ddpcb *ddp)
    386 {
    387 	ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
    388 	ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
    389 	ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
    390 }
    391 
    392 static int
    393 ddp_attach(struct socket *so, int proto)
    394 {
    395 	struct ddpcb *ddp;
    396 	int error;
    397 
    398 	KASSERT(sotoddpcb(so) == NULL);
    399 	sosetlock(so);
    400 #ifdef MBUFTRACE
    401 	so->so_rcv.sb_mowner = &atalk_rx_mowner;
    402 	so->so_snd.sb_mowner = &atalk_tx_mowner;
    403 #endif
    404 	error = soreserve(so, ddp_sendspace, ddp_recvspace);
    405 	if (error) {
    406 		return error;
    407 	}
    408 
    409 	ddp = kmem_zalloc(sizeof(*ddp), KM_SLEEP);
    410 	ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
    411 
    412 	ddp->ddp_next = ddpcb;
    413 	ddp->ddp_prev = NULL;
    414 	ddp->ddp_pprev = NULL;
    415 	ddp->ddp_pnext = NULL;
    416 	if (ddpcb) {
    417 		ddpcb->ddp_prev = ddp;
    418 	}
    419 	ddpcb = ddp;
    420 
    421 	ddp->ddp_socket = so;
    422 	so->so_pcb = ddp;
    423 	return 0;
    424 }
    425 
    426 static void
    427 ddp_detach(struct socket *so)
    428 {
    429 	struct ddpcb *ddp = sotoddpcb(so);
    430 
    431 	soisdisconnected(so);
    432 	so->so_pcb = NULL;
    433 	/* sofree drops the lock */
    434 	sofree(so);
    435 	mutex_enter(softnet_lock);
    436 
    437 	/* remove ddp from ddp_ports list */
    438 	if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
    439 	    ddp_ports[ddp->ddp_lsat.sat_port - 1] != NULL) {
    440 		if (ddp->ddp_pprev != NULL) {
    441 			ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
    442 		} else {
    443 			ddp_ports[ddp->ddp_lsat.sat_port - 1] = ddp->ddp_pnext;
    444 		}
    445 		if (ddp->ddp_pnext != NULL) {
    446 			ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
    447 		}
    448 	}
    449 	rtcache_free(&ddp->ddp_route);
    450 	if (ddp->ddp_prev) {
    451 		ddp->ddp_prev->ddp_next = ddp->ddp_next;
    452 	} else {
    453 		ddpcb = ddp->ddp_next;
    454 	}
    455 	if (ddp->ddp_next) {
    456 		ddp->ddp_next->ddp_prev = ddp->ddp_prev;
    457 	}
    458 	kmem_free(ddp, sizeof(*ddp));
    459 }
    460 
    461 static int
    462 ddp_accept(struct socket *so, struct mbuf *nam)
    463 {
    464 	KASSERT(solocked(so));
    465 
    466 	return EOPNOTSUPP;
    467 }
    468 
    469 static int
    470 ddp_bind(struct socket *so, struct mbuf *nam)
    471 {
    472 	KASSERT(solocked(so));
    473 	KASSERT(sotoddpcb(so) != NULL);
    474 
    475 	return at_pcbsetaddr(sotoddpcb(so), nam);
    476 }
    477 
    478 static int
    479 ddp_listen(struct socket *so)
    480 {
    481 	KASSERT(solocked(so));
    482 
    483 	return EOPNOTSUPP;
    484 }
    485 
    486 static int
    487 ddp_connect(struct socket *so, struct mbuf *nam)
    488 {
    489 	struct ddpcb *ddp = sotoddpcb(so);
    490 	int error = 0;
    491 
    492 	KASSERT(solocked(so));
    493 	KASSERT(ddp != NULL);
    494 	KASSERT(nam != NULL);
    495 
    496 	if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT)
    497 		return EISCONN;
    498 	error = at_pcbconnect(ddp, nam);
    499 	if (error == 0)
    500 		soisconnected(so);
    501 
    502 	return error;
    503 }
    504 
    505 static int
    506 ddp_ioctl(struct socket *so, u_long cmd, void *addr, struct ifnet *ifp)
    507 {
    508 	return at_control(cmd, addr, ifp);
    509 }
    510 
    511 static int
    512 ddp_stat(struct socket *so, struct stat *ub)
    513 {
    514 	KASSERT(solocked(so));
    515 
    516 	/* stat: don't bother with a blocksize. */
    517 	return 0;
    518 }
    519 
    520 static int
    521 ddp_peeraddr(struct socket *so, struct mbuf *nam)
    522 {
    523 	KASSERT(solocked(so));
    524 
    525 	return EOPNOTSUPP;
    526 }
    527 
    528 static int
    529 ddp_sockaddr(struct socket *so, struct mbuf *nam)
    530 {
    531 	KASSERT(solocked(so));
    532 	KASSERT(sotoddpcb(so) != NULL);
    533 	KASSERT(nam != NULL);
    534 
    535 	at_sockaddr(sotoddpcb(so), nam);
    536 	return 0;
    537 }
    538 
    539 static int
    540 ddp_recvoob(struct socket *so, struct mbuf *m, int flags)
    541 {
    542 	KASSERT(solocked(so));
    543 
    544 	return EOPNOTSUPP;
    545 }
    546 
    547 static int
    548 ddp_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
    549 {
    550 	KASSERT(solocked(so));
    551 
    552 	if (m)
    553 		m_freem(m);
    554 
    555 	return EOPNOTSUPP;
    556 }
    557 
    558 /*
    559  * For the moment, this just find the pcb with the correct local address.
    560  * In the future, this will actually do some real searching, so we can use
    561  * the sender's address to do de-multiplexing on a single port to many
    562  * sockets (pcbs).
    563  */
    564 struct ddpcb   *
    565 ddp_search(
    566     struct sockaddr_at *from,
    567     struct sockaddr_at *to,
    568     struct at_ifaddr *aa)
    569 {
    570 	struct ddpcb   *ddp;
    571 
    572 	/*
    573          * Check for bad ports.
    574          */
    575 	if (to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST)
    576 		return NULL;
    577 
    578 	/*
    579          * Make sure the local address matches the sent address.  What about
    580          * the interface?
    581          */
    582 	for (ddp = ddp_ports[to->sat_port - 1]; ddp; ddp = ddp->ddp_pnext) {
    583 		/* XXX should we handle 0.YY? */
    584 
    585 		/* XXXX.YY to socket on destination interface */
    586 		if (to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
    587 		    to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node) {
    588 			break;
    589 		}
    590 		/* 0.255 to socket on receiving interface */
    591 		if (to->sat_addr.s_node == ATADDR_BCAST &&
    592 		    (to->sat_addr.s_net == 0 ||
    593 		    to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net) &&
    594 		ddp->ddp_lsat.sat_addr.s_net == AA_SAT(aa)->sat_addr.s_net) {
    595 			break;
    596 		}
    597 		/* XXXX.0 to socket on destination interface */
    598 		if (to->sat_addr.s_net == aa->aa_firstnet &&
    599 		    to->sat_addr.s_node == 0 &&
    600 		    ntohs(ddp->ddp_lsat.sat_addr.s_net) >=
    601 		    ntohs(aa->aa_firstnet) &&
    602 		    ntohs(ddp->ddp_lsat.sat_addr.s_net) <=
    603 		    ntohs(aa->aa_lastnet)) {
    604 			break;
    605 		}
    606 	}
    607 	return (ddp);
    608 }
    609 
    610 /*
    611  * Initialize all the ddp & appletalk stuff
    612  */
    613 void
    614 ddp_init(void)
    615 {
    616 
    617 	ddpstat_percpu = percpu_alloc(sizeof(uint64_t) * DDP_NSTATS);
    618 
    619 	TAILQ_INIT(&at_ifaddr);
    620 	atintrq1.ifq_maxlen = IFQ_MAXLEN;
    621 	atintrq2.ifq_maxlen = IFQ_MAXLEN;
    622 
    623 	MOWNER_ATTACH(&atalk_tx_mowner);
    624 	MOWNER_ATTACH(&atalk_rx_mowner);
    625 	MOWNER_ATTACH(&aarp_mowner);
    626 }
    627 
    628 PR_WRAP_USRREQS(ddp)
    629 #define	ddp_attach	ddp_attach_wrapper
    630 #define	ddp_detach	ddp_detach_wrapper
    631 #define	ddp_accept	ddp_accept_wrapper
    632 #define	ddp_bind	ddp_bind_wrapper
    633 #define	ddp_listen	ddp_listen_wrapper
    634 #define	ddp_connect	ddp_connect_wrapper
    635 #define	ddp_ioctl	ddp_ioctl_wrapper
    636 #define	ddp_stat	ddp_stat_wrapper
    637 #define	ddp_peeraddr	ddp_peeraddr_wrapper
    638 #define	ddp_sockaddr	ddp_sockaddr_wrapper
    639 #define	ddp_recvoob	ddp_recvoob_wrapper
    640 #define	ddp_sendoob	ddp_sendoob_wrapper
    641 #define	ddp_usrreq	ddp_usrreq_wrapper
    642 
    643 const struct pr_usrreqs ddp_usrreqs = {
    644 	.pr_attach	= ddp_attach,
    645 	.pr_detach	= ddp_detach,
    646 	.pr_accept	= ddp_accept,
    647 	.pr_bind	= ddp_bind,
    648 	.pr_listen	= ddp_listen,
    649 	.pr_connect	= ddp_connect,
    650 	.pr_ioctl	= ddp_ioctl,
    651 	.pr_stat	= ddp_stat,
    652 	.pr_peeraddr	= ddp_peeraddr,
    653 	.pr_sockaddr	= ddp_sockaddr,
    654 	.pr_recvoob	= ddp_recvoob,
    655 	.pr_sendoob	= ddp_sendoob,
    656 	.pr_generic	= ddp_usrreq,
    657 };
    658 
    659 static int
    660 sysctl_net_atalk_ddp_stats(SYSCTLFN_ARGS)
    661 {
    662 
    663 	return (NETSTAT_SYSCTL(ddpstat_percpu, DDP_NSTATS));
    664 }
    665 
    666 /*
    667  * Sysctl for DDP variables.
    668  */
    669 SYSCTL_SETUP(sysctl_net_atalk_ddp_setup, "sysctl net.atalk.ddp subtree setup")
    670 {
    671 
    672 	sysctl_createv(clog, 0, NULL, NULL,
    673 		       CTLFLAG_PERMANENT,
    674 		       CTLTYPE_NODE, "atalk", NULL,
    675 		       NULL, 0, NULL, 0,
    676 		       CTL_NET, PF_APPLETALK, CTL_EOL);
    677 	sysctl_createv(clog, 0, NULL, NULL,
    678 		       CTLFLAG_PERMANENT,
    679 		       CTLTYPE_NODE, "ddp",
    680 		       SYSCTL_DESCR("DDP related settings"),
    681 		       NULL, 0, NULL, 0,
    682 		       CTL_NET, PF_APPLETALK, ATPROTO_DDP, CTL_EOL);
    683 
    684 	sysctl_createv(clog, 0, NULL, NULL,
    685 		       CTLFLAG_PERMANENT,
    686 		       CTLTYPE_STRUCT, "stats",
    687 		       SYSCTL_DESCR("DDP statistics"),
    688 		       sysctl_net_atalk_ddp_stats, 0, NULL, 0,
    689 		       CTL_NET, PF_APPLETALK, ATPROTO_DDP, CTL_CREATE,
    690 		       CTL_EOL);
    691 }
    692