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