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