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