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