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