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