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