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