link_proto.c revision 1.24.10.1
1 /* $NetBSD: link_proto.c,v 1.24.10.1 2019/01/29 08:12:17 msaitoh Exp $ */ 2 3 /*- 4 * Copyright (c) 1982, 1986, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)uipc_proto.c 8.2 (Berkeley) 2/14/95 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: link_proto.c,v 1.24.10.1 2019/01/29 08:12:17 msaitoh Exp $"); 36 37 #include <sys/param.h> 38 #include <sys/socket.h> 39 #include <sys/protosw.h> 40 #include <sys/domain.h> 41 #include <sys/mbuf.h> 42 #include <sys/un.h> 43 #include <sys/socketvar.h> 44 45 #include <net/if.h> 46 #include <net/if_dl.h> 47 #include <net/raw_cb.h> 48 #include <net/route.h> 49 50 static int sockaddr_dl_cmp(const struct sockaddr *, const struct sockaddr *); 51 static int link_attach(struct socket *, int); 52 static void link_detach(struct socket *); 53 static int link_accept(struct socket *, struct mbuf *); 54 static int link_bind(struct socket *, struct mbuf *, struct lwp *); 55 static int link_listen(struct socket *, struct lwp *); 56 static int link_connect(struct socket *, struct mbuf *, struct lwp *); 57 static int link_connect2(struct socket *, struct socket *); 58 static int link_disconnect(struct socket *); 59 static int link_shutdown(struct socket *); 60 static int link_abort(struct socket *); 61 static int link_ioctl(struct socket *, u_long, void *, struct ifnet *); 62 static int link_stat(struct socket *, struct stat *); 63 static int link_peeraddr(struct socket *, struct mbuf *); 64 static int link_sockaddr(struct socket *, struct mbuf *); 65 static int link_rcvd(struct socket *, int, struct lwp *); 66 static int link_recvoob(struct socket *, struct mbuf *, int); 67 static int link_send(struct socket *, struct mbuf *, struct mbuf *, 68 struct mbuf *, struct lwp *); 69 static int link_sendoob(struct socket *, struct mbuf *, struct mbuf *); 70 static int link_purgeif(struct socket *, struct ifnet *); 71 static int link_usrreq(struct socket *, int, struct mbuf *, struct mbuf *, 72 struct mbuf *, struct lwp *); 73 static void link_init(void); 74 75 /* 76 * Definitions of protocols supported in the link-layer domain. 77 */ 78 79 DOMAIN_DEFINE(linkdomain); /* forward define and add to link set */ 80 81 static const struct pr_usrreqs link_usrreqs = { 82 .pr_attach = link_attach, 83 .pr_detach = link_detach, 84 .pr_accept = link_accept, 85 .pr_bind = link_bind, 86 .pr_listen = link_listen, 87 .pr_connect = link_connect, 88 .pr_connect2 = link_connect2, 89 .pr_disconnect = link_disconnect, 90 .pr_shutdown = link_shutdown, 91 .pr_abort = link_abort, 92 .pr_ioctl = link_ioctl, 93 .pr_stat = link_stat, 94 .pr_peeraddr = link_peeraddr, 95 .pr_sockaddr = link_sockaddr, 96 .pr_rcvd = link_rcvd, 97 .pr_recvoob = link_recvoob, 98 .pr_send = link_send, 99 .pr_sendoob = link_sendoob, 100 .pr_purgeif = link_purgeif, 101 .pr_generic = link_usrreq, 102 }; 103 104 const struct protosw linksw[] = { 105 { .pr_type = SOCK_DGRAM, 106 .pr_domain = &linkdomain, 107 .pr_protocol = 0, /* XXX */ 108 .pr_flags = PR_ATOMIC|PR_ADDR|PR_PURGEIF, 109 .pr_input = NULL, 110 .pr_ctlinput = NULL, 111 .pr_ctloutput = NULL, 112 .pr_usrreqs = &link_usrreqs, 113 .pr_init = link_init, 114 }, 115 }; 116 117 struct domain linkdomain = { 118 .dom_family = AF_LINK, 119 .dom_name = "link", 120 .dom_externalize = NULL, 121 .dom_dispose = NULL, 122 .dom_protosw = linksw, 123 .dom_protoswNPROTOSW = &linksw[__arraycount(linksw)], 124 .dom_sockaddr_cmp = sockaddr_dl_cmp 125 }; 126 127 static void 128 link_init(void) 129 { 130 return; 131 } 132 133 static int 134 link_control(struct socket *so, unsigned long cmd, void *data, 135 struct ifnet *ifp) 136 { 137 int error, s; 138 bool isactive, mkactive; 139 struct if_laddrreq *iflr; 140 union { 141 struct sockaddr sa; 142 struct sockaddr_dl sdl; 143 struct sockaddr_storage ss; 144 } u; 145 struct ifaddr *ifa; 146 const struct sockaddr_dl *asdl, *nsdl; 147 148 switch (cmd) { 149 case SIOCALIFADDR: 150 case SIOCDLIFADDR: 151 case SIOCGLIFADDR: 152 iflr = data; 153 154 if (iflr->addr.ss_family != AF_LINK) 155 return EINVAL; 156 157 asdl = satocsdl(sstocsa(&iflr->addr)); 158 159 if (asdl->sdl_alen != ifp->if_addrlen) 160 return EINVAL; 161 162 if (sockaddr_dl_init(&u.sdl, sizeof(u.ss), ifp->if_index, 163 ifp->if_type, ifp->if_xname, strlen(ifp->if_xname), 164 CLLADDR(asdl), asdl->sdl_alen) == NULL) 165 return EINVAL; 166 167 if ((iflr->flags & IFLR_PREFIX) == 0) 168 ; 169 else if (iflr->prefixlen != NBBY * ifp->if_addrlen) 170 return EINVAL; /* XXX match with prefix */ 171 172 error = 0; 173 174 s = splnet(); 175 176 IFADDR_FOREACH(ifa, ifp) { 177 if (sockaddr_cmp(&u.sa, ifa->ifa_addr) == 0) 178 break; 179 } 180 181 switch (cmd) { 182 case SIOCGLIFADDR: 183 if ((iflr->flags & IFLR_PREFIX) == 0) { 184 IFADDR_FOREACH(ifa, ifp) { 185 if (ifa->ifa_addr->sa_family == AF_LINK) 186 break; 187 } 188 } 189 if (ifa == NULL) { 190 error = EADDRNOTAVAIL; 191 break; 192 } 193 194 if (ifa == ifp->if_dl) 195 iflr->flags = IFLR_ACTIVE; 196 else 197 iflr->flags = 0; 198 199 if (ifa == ifp->if_hwdl) 200 iflr->flags |= IFLR_FACTORY; 201 202 sockaddr_copy(sstosa(&iflr->addr), sizeof(iflr->addr), 203 ifa->ifa_addr); 204 205 break; 206 case SIOCDLIFADDR: 207 if (ifa == NULL) 208 error = EADDRNOTAVAIL; 209 else if (ifa == ifp->if_dl || ifa == ifp->if_hwdl) 210 error = EBUSY; 211 else { 212 /* TBD routing socket */ 213 rt_newaddrmsg(RTM_DELETE, ifa, 0, NULL); 214 ifa_remove(ifp, ifa); 215 } 216 break; 217 case SIOCALIFADDR: 218 if (ifa != NULL) 219 ; 220 else if ((ifa = if_dl_create(ifp, &nsdl)) == NULL) { 221 error = ENOMEM; 222 break; 223 } else { 224 sockaddr_copy(ifa->ifa_addr, 225 ifa->ifa_addr->sa_len, &u.sa); 226 ifa_insert(ifp, ifa); 227 rt_newaddrmsg(RTM_ADD, ifa, 0, NULL); 228 } 229 230 mkactive = (iflr->flags & IFLR_ACTIVE) != 0; 231 isactive = (ifa == ifp->if_dl); 232 233 if (!isactive && mkactive) { 234 if_activate_sadl(ifp, ifa, nsdl); 235 rt_newaddrmsg(RTM_CHANGE, ifa, 0, NULL); 236 error = ENETRESET; 237 } 238 break; 239 } 240 splx(s); 241 if (error != ENETRESET) 242 return error; 243 else if ((ifp->if_flags & IFF_RUNNING) != 0 && 244 ifp->if_init != NULL) 245 return (*ifp->if_init)(ifp); 246 else 247 return 0; 248 default: 249 return ENOTTY; 250 } 251 } 252 253 static int 254 link_attach(struct socket *so, int proto) 255 { 256 sosetlock(so); 257 KASSERT(solocked(so)); 258 return 0; 259 } 260 261 static void 262 link_detach(struct socket *so) 263 { 264 KASSERT(solocked(so)); 265 sofree(so); 266 } 267 268 static int 269 link_accept(struct socket *so, struct mbuf *nam) 270 { 271 KASSERT(solocked(so)); 272 273 return EOPNOTSUPP; 274 } 275 276 static int 277 link_bind(struct socket *so, struct mbuf *nam, struct lwp *l) 278 { 279 KASSERT(solocked(so)); 280 281 return EOPNOTSUPP; 282 } 283 284 static int 285 link_listen(struct socket *so, struct lwp *l) 286 { 287 KASSERT(solocked(so)); 288 289 return EOPNOTSUPP; 290 } 291 292 static int 293 link_connect(struct socket *so, struct mbuf *nam, struct lwp *l) 294 { 295 KASSERT(solocked(so)); 296 297 return EOPNOTSUPP; 298 } 299 300 static int 301 link_connect2(struct socket *so, struct socket *so2) 302 { 303 KASSERT(solocked(so)); 304 305 return EOPNOTSUPP; 306 } 307 308 static int 309 link_disconnect(struct socket *so) 310 { 311 KASSERT(solocked(so)); 312 313 return EOPNOTSUPP; 314 } 315 316 static int 317 link_shutdown(struct socket *so) 318 { 319 KASSERT(solocked(so)); 320 321 return EOPNOTSUPP; 322 } 323 324 static int 325 link_abort(struct socket *so) 326 { 327 KASSERT(solocked(so)); 328 329 return EOPNOTSUPP; 330 } 331 332 static int 333 link_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp) 334 { 335 return link_control(so, cmd, nam, ifp); 336 } 337 338 static int 339 link_stat(struct socket *so, struct stat *ub) 340 { 341 KASSERT(solocked(so)); 342 343 return EOPNOTSUPP; 344 } 345 346 static int 347 link_peeraddr(struct socket *so, struct mbuf *nam) 348 { 349 KASSERT(solocked(so)); 350 351 return EOPNOTSUPP; 352 } 353 354 static int 355 link_sockaddr(struct socket *so, struct mbuf *nam) 356 { 357 KASSERT(solocked(so)); 358 359 return EOPNOTSUPP; 360 } 361 362 static int 363 link_rcvd(struct socket *so, int flags, struct lwp *l) 364 { 365 KASSERT(solocked(so)); 366 367 return EOPNOTSUPP; 368 } 369 370 static int 371 link_recvoob(struct socket *so, struct mbuf *m, int flags) 372 { 373 KASSERT(solocked(so)); 374 375 return EOPNOTSUPP; 376 } 377 378 static int 379 link_send(struct socket *so, struct mbuf *m, struct mbuf *nam, 380 struct mbuf *control, struct lwp *l) 381 { 382 KASSERT(solocked(so)); 383 384 return EOPNOTSUPP; 385 } 386 387 static int 388 link_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control) 389 { 390 KASSERT(solocked(so)); 391 392 m_freem(m); 393 m_freem(control); 394 395 return EOPNOTSUPP; 396 } 397 398 static int 399 link_purgeif(struct socket *so, struct ifnet *ifp) 400 { 401 402 return EOPNOTSUPP; 403 } 404 405 static int 406 link_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam, 407 struct mbuf *control, struct lwp *l) 408 { 409 KASSERT(req != PRU_ATTACH); 410 KASSERT(req != PRU_DETACH); 411 KASSERT(req != PRU_ACCEPT); 412 KASSERT(req != PRU_BIND); 413 KASSERT(req != PRU_LISTEN); 414 KASSERT(req != PRU_CONNECT); 415 KASSERT(req != PRU_CONNECT2); 416 KASSERT(req != PRU_DISCONNECT); 417 KASSERT(req != PRU_SHUTDOWN); 418 KASSERT(req != PRU_ABORT); 419 KASSERT(req != PRU_CONTROL); 420 KASSERT(req != PRU_SENSE); 421 KASSERT(req != PRU_PEERADDR); 422 KASSERT(req != PRU_SOCKADDR); 423 KASSERT(req != PRU_RCVD); 424 KASSERT(req != PRU_RCVOOB); 425 KASSERT(req != PRU_SEND); 426 KASSERT(req != PRU_SENDOOB); 427 KASSERT(req != PRU_PURGEIF); 428 429 return EOPNOTSUPP; 430 } 431 432 /* Compare the field at byte offsets [fieldstart, fieldend) in 433 * two memory regions, [l, l + llen) and [r, r + llen). 434 */ 435 static inline int 436 submemcmp(const void *l, const void *r, 437 const uint_fast8_t llen, const uint_fast8_t rlen, 438 const uint_fast8_t fieldstart, const uint_fast8_t fieldend) 439 { 440 uint_fast8_t cmpend, minlen; 441 const uint8_t *lb = l, *rb = r; 442 int rc; 443 444 minlen = MIN(llen, rlen); 445 446 /* The field is missing from one region. The shorter region is the 447 * lesser region. 448 */ 449 if (fieldstart >= minlen) 450 return llen - rlen; 451 452 /* Two empty, present fields are always equal. */ 453 if (fieldstart > fieldend) 454 return 0; 455 456 cmpend = MIN(fieldend, minlen); 457 458 rc = memcmp(&lb[fieldstart], &rb[fieldstart], cmpend - fieldstart); 459 460 if (rc != 0) 461 return rc; 462 /* If one or both fields are truncated, then the shorter is the lesser 463 * field. 464 */ 465 if (minlen < fieldend) 466 return llen - rlen; 467 /* Fields are full-length and equal. The fields are equal. */ 468 return 0; 469 } 470 471 uint8_t 472 sockaddr_dl_measure(uint8_t namelen, uint8_t addrlen) 473 { 474 return offsetof(struct sockaddr_dl, sdl_data[namelen + addrlen]); 475 } 476 477 struct sockaddr * 478 sockaddr_dl_alloc(uint16_t ifindex, uint8_t type, 479 const void *name, uint8_t namelen, const void *addr, uint8_t addrlen, 480 int flags) 481 { 482 struct sockaddr *sa; 483 socklen_t len; 484 485 len = sockaddr_dl_measure(namelen, addrlen); 486 sa = sockaddr_alloc(AF_LINK, len, flags); 487 488 if (sa == NULL) 489 return NULL; 490 491 if (sockaddr_dl_init(satosdl(sa), len, ifindex, type, name, namelen, 492 addr, addrlen) == NULL) { 493 sockaddr_free(sa); 494 return NULL; 495 } 496 497 return sa; 498 } 499 500 struct sockaddr_dl * 501 sockaddr_dl_init(struct sockaddr_dl *sdl, socklen_t socklen, uint16_t ifindex, 502 uint8_t type, const void *name, uint8_t namelen, const void *addr, 503 uint8_t addrlen) 504 { 505 socklen_t len; 506 507 sdl->sdl_family = AF_LINK; 508 sdl->sdl_slen = 0; 509 len = sockaddr_dl_measure(namelen, addrlen); 510 if (len > socklen) { 511 sdl->sdl_len = socklen; 512 #ifdef DIAGNOSTIC 513 printf("%s: too long: %u > %u\n", __func__, (u_int)len, 514 (u_int)socklen); 515 #endif 516 return NULL; 517 } 518 sdl->sdl_len = len; 519 sdl->sdl_index = ifindex; 520 sdl->sdl_type = type; 521 memset(&sdl->sdl_data[0], 0, namelen + addrlen); 522 if (name != NULL) { 523 memcpy(&sdl->sdl_data[0], name, namelen); 524 sdl->sdl_nlen = namelen; 525 } else 526 sdl->sdl_nlen = 0; 527 if (addr != NULL) { 528 memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen); 529 sdl->sdl_alen = addrlen; 530 } else 531 sdl->sdl_alen = 0; 532 return sdl; 533 } 534 535 static int 536 sockaddr_dl_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2) 537 { 538 int rc; 539 const uint_fast8_t indexofs = offsetof(struct sockaddr_dl, sdl_index); 540 const uint_fast8_t nlenofs = offsetof(struct sockaddr_dl, sdl_nlen); 541 uint_fast8_t dataofs = offsetof(struct sockaddr_dl, sdl_data[0]); 542 const struct sockaddr_dl *sdl1, *sdl2; 543 544 sdl1 = satocsdl(sa1); 545 sdl2 = satocsdl(sa2); 546 547 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 548 indexofs, nlenofs); 549 550 if (rc != 0) 551 return rc; 552 553 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 554 dataofs, dataofs + MIN(sdl1->sdl_nlen, sdl2->sdl_nlen)); 555 556 if (rc != 0) 557 return rc; 558 559 if (sdl1->sdl_nlen != sdl2->sdl_nlen) 560 return sdl1->sdl_nlen - sdl2->sdl_nlen; 561 562 dataofs += sdl1->sdl_nlen; 563 564 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 565 dataofs, dataofs + MIN(sdl1->sdl_alen, sdl2->sdl_alen)); 566 567 if (rc != 0) 568 return rc; 569 570 if (sdl1->sdl_alen != sdl2->sdl_alen) 571 return sdl1->sdl_alen - sdl2->sdl_alen; 572 573 dataofs += sdl1->sdl_alen; 574 575 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 576 dataofs, dataofs + MIN(sdl1->sdl_slen, sdl2->sdl_slen)); 577 578 if (sdl1->sdl_slen != sdl2->sdl_slen) 579 return sdl1->sdl_slen - sdl2->sdl_slen; 580 581 return sdl1->sdl_len - sdl2->sdl_len; 582 } 583 584 struct sockaddr_dl * 585 sockaddr_dl_setaddr(struct sockaddr_dl *sdl, socklen_t socklen, 586 const void *addr, uint8_t addrlen) 587 { 588 socklen_t len; 589 590 len = sockaddr_dl_measure(sdl->sdl_nlen, addrlen); 591 if (len > socklen) { 592 #ifdef DIAGNOSTIC 593 printf("%s: too long: %u > %u\n", __func__, (u_int)len, 594 (u_int)socklen); 595 #endif 596 return NULL; 597 } 598 memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen); 599 sdl->sdl_alen = addrlen; 600 sdl->sdl_len = len; 601 return sdl; 602 } 603
Indexes created Sat Oct 11 16:09:52 GMT 2025