link_proto.c revision 1.23
1 /* $NetBSD: link_proto.c,v 1.23 2014/08/08 03:05:45 rtr 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.23 2014/08/08 03:05:45 rtr 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_disconnect(struct socket *); 58 static int link_shutdown(struct socket *); 59 static int link_abort(struct socket *); 60 static int link_ioctl(struct socket *, u_long, void *, struct ifnet *); 61 static int link_stat(struct socket *, struct stat *); 62 static int link_peeraddr(struct socket *, struct mbuf *); 63 static int link_sockaddr(struct socket *, struct mbuf *); 64 static int link_rcvd(struct socket *, int, struct lwp *); 65 static int link_recvoob(struct socket *, struct mbuf *, int); 66 static int link_send(struct socket *, struct mbuf *, struct mbuf *, 67 struct mbuf *, struct lwp *); 68 static int link_sendoob(struct socket *, struct mbuf *, struct mbuf *); 69 static int link_usrreq(struct socket *, int, struct mbuf *, struct mbuf *, 70 struct mbuf *, struct lwp *); 71 static void link_init(void); 72 73 /* 74 * Definitions of protocols supported in the link-layer domain. 75 */ 76 77 DOMAIN_DEFINE(linkdomain); /* forward define and add to link set */ 78 79 static const struct pr_usrreqs link_usrreqs = { 80 .pr_attach = link_attach, 81 .pr_detach = link_detach, 82 .pr_accept = link_accept, 83 .pr_bind = link_bind, 84 .pr_listen = link_listen, 85 .pr_connect = link_connect, 86 .pr_disconnect = link_disconnect, 87 .pr_shutdown = link_shutdown, 88 .pr_abort = link_abort, 89 .pr_ioctl = link_ioctl, 90 .pr_stat = link_stat, 91 .pr_peeraddr = link_peeraddr, 92 .pr_sockaddr = link_sockaddr, 93 .pr_rcvd = link_rcvd, 94 .pr_recvoob = link_recvoob, 95 .pr_send = link_send, 96 .pr_sendoob = link_sendoob, 97 .pr_generic = link_usrreq, 98 }; 99 100 const struct protosw linksw[] = { 101 { .pr_type = SOCK_DGRAM, 102 .pr_domain = &linkdomain, 103 .pr_protocol = 0, /* XXX */ 104 .pr_flags = PR_ATOMIC|PR_ADDR|PR_PURGEIF, 105 .pr_input = NULL, 106 .pr_ctlinput = NULL, 107 .pr_ctloutput = NULL, 108 .pr_usrreqs = &link_usrreqs, 109 .pr_init = link_init, 110 }, 111 }; 112 113 struct domain linkdomain = { 114 .dom_family = AF_LINK, 115 .dom_name = "link", 116 .dom_externalize = NULL, 117 .dom_dispose = NULL, 118 .dom_protosw = linksw, 119 .dom_protoswNPROTOSW = &linksw[__arraycount(linksw)], 120 .dom_sockaddr_cmp = sockaddr_dl_cmp 121 }; 122 123 static void 124 link_init(void) 125 { 126 return; 127 } 128 129 static int 130 link_control(struct socket *so, unsigned long cmd, void *data, 131 struct ifnet *ifp) 132 { 133 int error, s; 134 bool isactive, mkactive; 135 struct if_laddrreq *iflr; 136 union { 137 struct sockaddr sa; 138 struct sockaddr_dl sdl; 139 struct sockaddr_storage ss; 140 } u; 141 struct ifaddr *ifa; 142 const struct sockaddr_dl *asdl, *nsdl; 143 144 switch (cmd) { 145 case SIOCALIFADDR: 146 case SIOCDLIFADDR: 147 case SIOCGLIFADDR: 148 iflr = data; 149 150 if (iflr->addr.ss_family != AF_LINK) 151 return EINVAL; 152 153 asdl = satocsdl(sstocsa(&iflr->addr)); 154 155 if (asdl->sdl_alen != ifp->if_addrlen) 156 return EINVAL; 157 158 if (sockaddr_dl_init(&u.sdl, sizeof(u.ss), ifp->if_index, 159 ifp->if_type, ifp->if_xname, strlen(ifp->if_xname), 160 CLLADDR(asdl), asdl->sdl_alen) == NULL) 161 return EINVAL; 162 163 if ((iflr->flags & IFLR_PREFIX) == 0) 164 ; 165 else if (iflr->prefixlen != NBBY * ifp->if_addrlen) 166 return EINVAL; /* XXX match with prefix */ 167 168 error = 0; 169 170 s = splnet(); 171 172 IFADDR_FOREACH(ifa, ifp) { 173 if (sockaddr_cmp(&u.sa, ifa->ifa_addr) == 0) 174 break; 175 } 176 177 switch (cmd) { 178 case SIOCGLIFADDR: 179 if ((iflr->flags & IFLR_PREFIX) == 0) { 180 IFADDR_FOREACH(ifa, ifp) { 181 if (ifa->ifa_addr->sa_family == AF_LINK) 182 break; 183 } 184 } 185 if (ifa == NULL) { 186 error = EADDRNOTAVAIL; 187 break; 188 } 189 190 if (ifa == ifp->if_dl) 191 iflr->flags = IFLR_ACTIVE; 192 else 193 iflr->flags = 0; 194 195 if (ifa == ifp->if_hwdl) 196 iflr->flags |= IFLR_FACTORY; 197 198 sockaddr_copy(sstosa(&iflr->addr), sizeof(iflr->addr), 199 ifa->ifa_addr); 200 201 break; 202 case SIOCDLIFADDR: 203 if (ifa == NULL) 204 error = EADDRNOTAVAIL; 205 else if (ifa == ifp->if_dl || ifa == ifp->if_hwdl) 206 error = EBUSY; 207 else { 208 /* TBD routing socket */ 209 rt_newaddrmsg(RTM_DELETE, ifa, 0, NULL); 210 ifa_remove(ifp, ifa); 211 } 212 break; 213 case SIOCALIFADDR: 214 if (ifa != NULL) 215 ; 216 else if ((ifa = if_dl_create(ifp, &nsdl)) == NULL) { 217 error = ENOMEM; 218 break; 219 } else { 220 sockaddr_copy(ifa->ifa_addr, 221 ifa->ifa_addr->sa_len, &u.sa); 222 ifa_insert(ifp, ifa); 223 rt_newaddrmsg(RTM_ADD, ifa, 0, NULL); 224 } 225 226 mkactive = (iflr->flags & IFLR_ACTIVE) != 0; 227 isactive = (ifa == ifp->if_dl); 228 229 if (!isactive && mkactive) { 230 if_activate_sadl(ifp, ifa, nsdl); 231 rt_newaddrmsg(RTM_CHANGE, ifa, 0, NULL); 232 error = ENETRESET; 233 } 234 break; 235 } 236 splx(s); 237 if (error != ENETRESET) 238 return error; 239 else if ((ifp->if_flags & IFF_RUNNING) != 0 && 240 ifp->if_init != NULL) 241 return (*ifp->if_init)(ifp); 242 else 243 return 0; 244 default: 245 return ENOTTY; 246 } 247 } 248 249 static int 250 link_attach(struct socket *so, int proto) 251 { 252 sosetlock(so); 253 KASSERT(solocked(so)); 254 return 0; 255 } 256 257 static void 258 link_detach(struct socket *so) 259 { 260 KASSERT(solocked(so)); 261 sofree(so); 262 } 263 264 static int 265 link_accept(struct socket *so, struct mbuf *nam) 266 { 267 KASSERT(solocked(so)); 268 269 return EOPNOTSUPP; 270 } 271 272 static int 273 link_bind(struct socket *so, struct mbuf *nam, struct lwp *l) 274 { 275 KASSERT(solocked(so)); 276 277 return EOPNOTSUPP; 278 } 279 280 static int 281 link_listen(struct socket *so, struct lwp *l) 282 { 283 KASSERT(solocked(so)); 284 285 return EOPNOTSUPP; 286 } 287 288 static int 289 link_connect(struct socket *so, struct mbuf *nam, struct lwp *l) 290 { 291 KASSERT(solocked(so)); 292 293 return EOPNOTSUPP; 294 } 295 296 static int 297 link_disconnect(struct socket *so) 298 { 299 KASSERT(solocked(so)); 300 301 return EOPNOTSUPP; 302 } 303 304 static int 305 link_shutdown(struct socket *so) 306 { 307 KASSERT(solocked(so)); 308 309 return EOPNOTSUPP; 310 } 311 312 static int 313 link_abort(struct socket *so) 314 { 315 KASSERT(solocked(so)); 316 317 return EOPNOTSUPP; 318 } 319 320 static int 321 link_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp) 322 { 323 return link_control(so, cmd, nam, ifp); 324 } 325 326 static int 327 link_stat(struct socket *so, struct stat *ub) 328 { 329 KASSERT(solocked(so)); 330 331 return EOPNOTSUPP; 332 } 333 334 static int 335 link_peeraddr(struct socket *so, struct mbuf *nam) 336 { 337 KASSERT(solocked(so)); 338 339 return EOPNOTSUPP; 340 } 341 342 static int 343 link_sockaddr(struct socket *so, struct mbuf *nam) 344 { 345 KASSERT(solocked(so)); 346 347 return EOPNOTSUPP; 348 } 349 350 static int 351 link_rcvd(struct socket *so, int flags, struct lwp *l) 352 { 353 KASSERT(solocked(so)); 354 355 return EOPNOTSUPP; 356 } 357 358 static int 359 link_recvoob(struct socket *so, struct mbuf *m, int flags) 360 { 361 KASSERT(solocked(so)); 362 363 return EOPNOTSUPP; 364 } 365 366 static int 367 link_send(struct socket *so, struct mbuf *m, struct mbuf *nam, 368 struct mbuf *control, struct lwp *l) 369 { 370 KASSERT(solocked(so)); 371 372 return EOPNOTSUPP; 373 } 374 375 static int 376 link_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control) 377 { 378 KASSERT(solocked(so)); 379 380 return EOPNOTSUPP; 381 } 382 383 static int 384 link_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam, 385 struct mbuf *control, struct lwp *l) 386 { 387 KASSERT(req != PRU_ATTACH); 388 KASSERT(req != PRU_DETACH); 389 KASSERT(req != PRU_ACCEPT); 390 KASSERT(req != PRU_BIND); 391 KASSERT(req != PRU_LISTEN); 392 KASSERT(req != PRU_CONNECT); 393 KASSERT(req != PRU_DISCONNECT); 394 KASSERT(req != PRU_SHUTDOWN); 395 KASSERT(req != PRU_ABORT); 396 KASSERT(req != PRU_CONTROL); 397 KASSERT(req != PRU_SENSE); 398 KASSERT(req != PRU_PEERADDR); 399 KASSERT(req != PRU_SOCKADDR); 400 KASSERT(req != PRU_RCVD); 401 KASSERT(req != PRU_RCVOOB); 402 KASSERT(req != PRU_SEND); 403 KASSERT(req != PRU_SENDOOB); 404 405 return EOPNOTSUPP; 406 } 407 408 /* Compare the field at byte offsets [fieldstart, fieldend) in 409 * two memory regions, [l, l + llen) and [r, r + llen). 410 */ 411 static inline int 412 submemcmp(const void *l, const void *r, 413 const uint_fast8_t llen, const uint_fast8_t rlen, 414 const uint_fast8_t fieldstart, const uint_fast8_t fieldend) 415 { 416 uint_fast8_t cmpend, minlen; 417 const uint8_t *lb = l, *rb = r; 418 int rc; 419 420 minlen = MIN(llen, rlen); 421 422 /* The field is missing from one region. The shorter region is the 423 * lesser region. 424 */ 425 if (fieldstart >= minlen) 426 return llen - rlen; 427 428 /* Two empty, present fields are always equal. */ 429 if (fieldstart > fieldend) 430 return 0; 431 432 cmpend = MIN(fieldend, minlen); 433 434 rc = memcmp(&lb[fieldstart], &rb[fieldstart], cmpend - fieldstart); 435 436 if (rc != 0) 437 return rc; 438 /* If one or both fields are truncated, then the shorter is the lesser 439 * field. 440 */ 441 if (minlen < fieldend) 442 return llen - rlen; 443 /* Fields are full-length and equal. The fields are equal. */ 444 return 0; 445 } 446 447 uint8_t 448 sockaddr_dl_measure(uint8_t namelen, uint8_t addrlen) 449 { 450 return offsetof(struct sockaddr_dl, sdl_data[namelen + addrlen]); 451 } 452 453 struct sockaddr * 454 sockaddr_dl_alloc(uint16_t ifindex, uint8_t type, 455 const void *name, uint8_t namelen, const void *addr, uint8_t addrlen, 456 int flags) 457 { 458 struct sockaddr *sa; 459 socklen_t len; 460 461 len = sockaddr_dl_measure(namelen, addrlen); 462 sa = sockaddr_alloc(AF_LINK, len, flags); 463 464 if (sa == NULL) 465 return NULL; 466 467 if (sockaddr_dl_init(satosdl(sa), len, ifindex, type, name, namelen, 468 addr, addrlen) == NULL) { 469 sockaddr_free(sa); 470 return NULL; 471 } 472 473 return sa; 474 } 475 476 struct sockaddr_dl * 477 sockaddr_dl_init(struct sockaddr_dl *sdl, socklen_t socklen, uint16_t ifindex, 478 uint8_t type, const void *name, uint8_t namelen, const void *addr, 479 uint8_t addrlen) 480 { 481 socklen_t len; 482 483 sdl->sdl_family = AF_LINK; 484 sdl->sdl_slen = 0; 485 len = sockaddr_dl_measure(namelen, addrlen); 486 if (len > socklen) { 487 sdl->sdl_len = socklen; 488 #ifdef DIAGNOSTIC 489 printf("%s: too long: %u > %u\n", __func__, (u_int)len, 490 (u_int)socklen); 491 #endif 492 return NULL; 493 } 494 sdl->sdl_len = len; 495 sdl->sdl_index = ifindex; 496 sdl->sdl_type = type; 497 memset(&sdl->sdl_data[0], 0, namelen + addrlen); 498 if (name != NULL) { 499 memcpy(&sdl->sdl_data[0], name, namelen); 500 sdl->sdl_nlen = namelen; 501 } else 502 sdl->sdl_nlen = 0; 503 if (addr != NULL) { 504 memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen); 505 sdl->sdl_alen = addrlen; 506 } else 507 sdl->sdl_alen = 0; 508 return sdl; 509 } 510 511 static int 512 sockaddr_dl_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2) 513 { 514 int rc; 515 const uint_fast8_t indexofs = offsetof(struct sockaddr_dl, sdl_index); 516 const uint_fast8_t nlenofs = offsetof(struct sockaddr_dl, sdl_nlen); 517 uint_fast8_t dataofs = offsetof(struct sockaddr_dl, sdl_data[0]); 518 const struct sockaddr_dl *sdl1, *sdl2; 519 520 sdl1 = satocsdl(sa1); 521 sdl2 = satocsdl(sa2); 522 523 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 524 indexofs, nlenofs); 525 526 if (rc != 0) 527 return rc; 528 529 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 530 dataofs, dataofs + MIN(sdl1->sdl_nlen, sdl2->sdl_nlen)); 531 532 if (rc != 0) 533 return rc; 534 535 if (sdl1->sdl_nlen != sdl2->sdl_nlen) 536 return sdl1->sdl_nlen - sdl2->sdl_nlen; 537 538 dataofs += sdl1->sdl_nlen; 539 540 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 541 dataofs, dataofs + MIN(sdl1->sdl_alen, sdl2->sdl_alen)); 542 543 if (rc != 0) 544 return rc; 545 546 if (sdl1->sdl_alen != sdl2->sdl_alen) 547 return sdl1->sdl_alen - sdl2->sdl_alen; 548 549 dataofs += sdl1->sdl_alen; 550 551 rc = submemcmp(sdl1, sdl2, sdl1->sdl_len, sdl2->sdl_len, 552 dataofs, dataofs + MIN(sdl1->sdl_slen, sdl2->sdl_slen)); 553 554 if (sdl1->sdl_slen != sdl2->sdl_slen) 555 return sdl1->sdl_slen - sdl2->sdl_slen; 556 557 return sdl1->sdl_len - sdl2->sdl_len; 558 } 559 560 struct sockaddr_dl * 561 sockaddr_dl_setaddr(struct sockaddr_dl *sdl, socklen_t socklen, 562 const void *addr, uint8_t addrlen) 563 { 564 socklen_t len; 565 566 len = sockaddr_dl_measure(sdl->sdl_nlen, addrlen); 567 if (len > socklen) { 568 #ifdef DIAGNOSTIC 569 printf("%s: too long: %u > %u\n", __func__, (u_int)len, 570 (u_int)socklen); 571 #endif 572 return NULL; 573 } 574 memcpy(&sdl->sdl_data[sdl->sdl_nlen], addr, addrlen); 575 sdl->sdl_alen = addrlen; 576 sdl->sdl_len = len; 577 return sdl; 578 } 579
Indexes created Thu Sep 25 15:09:46 GMT 2025