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