1 /* $NetBSD: in.c,v 1.49 1999/12/12 15:57:07 itojun Exp $ */ 2 3 /* 4 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 5 * 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 project 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 PROJECT 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 PROJECT 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 32 /*- 33 * Copyright (c) 1998 The NetBSD Foundation, Inc. 34 * All rights reserved. 35 * 36 * This code is derived from software contributed to The NetBSD Foundation 37 * by Public Access Networks Corporation ("Panix"). It was developed under 38 * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon. 39 * 40 * Redistribution and use in source and binary forms, with or without 41 * modification, are permitted provided that the following conditions 42 * are met: 43 * 1. Redistributions of source code must retain the above copyright 44 * notice, this list of conditions and the following disclaimer. 45 * 2. Redistributions in binary form must reproduce the above copyright 46 * notice, this list of conditions and the following disclaimer in the 47 * documentation and/or other materials provided with the distribution. 48 * 3. All advertising materials mentioning features or use of this software 49 * must display the following acknowledgement: 50 * This product includes software developed by the NetBSD 51 * Foundation, Inc. and its contributors. 52 * 4. Neither the name of The NetBSD Foundation nor the names of its 53 * contributors may be used to endorse or promote products derived 54 * from this software without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 57 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 58 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 59 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 60 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 61 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 62 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 63 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 64 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 65 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 66 * POSSIBILITY OF SUCH DAMAGE. 67 */ 68 69 /* 70 * Copyright (c) 1982, 1986, 1991, 1993 71 * The Regents of the University of California. All rights reserved. 72 * 73 * Redistribution and use in source and binary forms, with or without 74 * modification, are permitted provided that the following conditions 75 * are met: 76 * 1. Redistributions of source code must retain the above copyright 77 * notice, this list of conditions and the following disclaimer. 78 * 2. Redistributions in binary form must reproduce the above copyright 79 * notice, this list of conditions and the following disclaimer in the 80 * documentation and/or other materials provided with the distribution. 81 * 3. All advertising materials mentioning features or use of this software 82 * must display the following acknowledgement: 83 * This product includes software developed by the University of 84 * California, Berkeley and its contributors. 85 * 4. Neither the name of the University nor the names of its contributors 86 * may be used to endorse or promote products derived from this software 87 * without specific prior written permission. 88 * 89 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 90 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 92 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 93 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 94 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 95 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 96 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 97 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 98 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 99 * SUCH DAMAGE. 100 * 101 * @(#)in.c 8.4 (Berkeley) 1/9/95 102 */ 103 104 #include "opt_inet.h" 105 #include "opt_inet_conf.h" 106 #include "opt_mrouting.h" 107 108 #include <sys/param.h> 109 #include <sys/ioctl.h> 110 #include <sys/errno.h> 111 #include <sys/malloc.h> 112 #include <sys/socket.h> 113 #include <sys/socketvar.h> 114 #include <sys/systm.h> 115 #include <sys/proc.h> 116 117 #include <net/if.h> 118 #include <net/if_types.h> 119 #include <net/route.h> 120 #include "gif.h" 121 #if NGIF > 0 122 #include <net/if_gif.h> 123 #endif 124 125 #include <net/if_ether.h> 126 127 #include <netinet/in_systm.h> 128 #include <netinet/in.h> 129 #include <netinet/in_var.h> 130 #include <netinet/if_inarp.h> 131 #include <netinet/ip_mroute.h> 132 #include <netinet/igmp_var.h> 133 134 #ifdef INET 135 136 static int in_mask2len __P((struct in_addr *)); 137 static void in_len2mask __P((struct in_addr *, int)); 138 static int in_lifaddr_ioctl __P((struct socket *, u_long, caddr_t, 139 struct ifnet *, struct proc *)); 140 141 #ifndef SUBNETSARELOCAL 142 #define SUBNETSARELOCAL 1 143 #endif 144 145 #ifndef HOSTZEROBROADCAST 146 #define HOSTZEROBROADCAST 1 147 #endif 148 149 int subnetsarelocal = SUBNETSARELOCAL; 150 int hostzeroisbroadcast = HOSTZEROBROADCAST; 151 152 /* 153 * Return 1 if an internet address is for a ``local'' host 154 * (one to which we have a connection). If subnetsarelocal 155 * is true, this includes other subnets of the local net. 156 * Otherwise, it includes only the directly-connected (sub)nets. 157 */ 158 int 159 in_localaddr(in) 160 struct in_addr in; 161 { 162 register struct in_ifaddr *ia; 163 164 if (subnetsarelocal) { 165 for (ia = in_ifaddr.tqh_first; ia != 0; ia = ia->ia_list.tqe_next) 166 if ((in.s_addr & ia->ia_netmask) == ia->ia_net) 167 return (1); 168 } else { 169 for (ia = in_ifaddr.tqh_first; ia != 0; ia = ia->ia_list.tqe_next) 170 if ((in.s_addr & ia->ia_subnetmask) == ia->ia_subnet) 171 return (1); 172 } 173 return (0); 174 } 175 176 /* 177 * Determine whether an IP address is in a reserved set of addresses 178 * that may not be forwarded, or whether datagrams to that destination 179 * may be forwarded. 180 */ 181 int 182 in_canforward(in) 183 struct in_addr in; 184 { 185 register u_int32_t net; 186 187 if (IN_EXPERIMENTAL(in.s_addr) || IN_MULTICAST(in.s_addr)) 188 return (0); 189 if (IN_CLASSA(in.s_addr)) { 190 net = in.s_addr & IN_CLASSA_NET; 191 if (net == 0 || net == htonl(IN_LOOPBACKNET << IN_CLASSA_NSHIFT)) 192 return (0); 193 } 194 return (1); 195 } 196 197 /* 198 * Trim a mask in a sockaddr 199 */ 200 void 201 in_socktrim(ap) 202 struct sockaddr_in *ap; 203 { 204 register char *cplim = (char *) &ap->sin_addr; 205 register char *cp = (char *) (&ap->sin_addr + 1); 206 207 ap->sin_len = 0; 208 while (--cp >= cplim) 209 if (*cp) { 210 (ap)->sin_len = cp - (char *) (ap) + 1; 211 break; 212 } 213 } 214 215 /* 216 * Routine to take an Internet address and convert into a 217 * "dotted quad" representation for printing. 218 */ 219 const char * 220 in_fmtaddr(addr) 221 struct in_addr addr; 222 { 223 static char buf[sizeof("123.456.789.123")]; 224 225 addr.s_addr = ntohl(addr.s_addr); 226 227 sprintf(buf, "%d.%d.%d.%d", 228 (addr.s_addr >> 24) & 0xFF, 229 (addr.s_addr >> 16) & 0xFF, 230 (addr.s_addr >> 8) & 0xFF, 231 (addr.s_addr >> 0) & 0xFF); 232 return buf; 233 } 234 235 /* 236 * Maintain the "in_maxmtu" variable, which is the largest 237 * mtu for non-local interfaces with AF_INET addresses assigned 238 * to them that are up. 239 */ 240 unsigned long in_maxmtu; 241 242 void 243 in_setmaxmtu() 244 { 245 register struct in_ifaddr *ia; 246 register struct ifnet *ifp; 247 unsigned long maxmtu = 0; 248 249 for (ia = in_ifaddr.tqh_first; ia != 0; ia = ia->ia_list.tqe_next) { 250 if ((ifp = ia->ia_ifp) == 0) 251 continue; 252 if ((ifp->if_flags & (IFF_UP|IFF_LOOPBACK)) != IFF_UP) 253 continue; 254 if (ifp->if_mtu > maxmtu) 255 maxmtu = ifp->if_mtu; 256 } 257 if (maxmtu) 258 in_maxmtu = maxmtu; 259 } 260 261 static int 262 in_mask2len(mask) 263 struct in_addr *mask; 264 { 265 int x, y; 266 u_char *p; 267 268 p = (u_char *)mask; 269 for (x = 0; x < sizeof(*mask); x++) { 270 if (p[x] != 0xff) 271 break; 272 } 273 y = 0; 274 if (x < sizeof(*mask)) { 275 for (y = 0; y < 8; y++) { 276 if ((p[x] & (0x80 >> y)) == 0) 277 break; 278 } 279 } 280 return x * 8 + y; 281 } 282 283 static void 284 in_len2mask(mask, len) 285 struct in_addr *mask; 286 int len; 287 { 288 int i; 289 u_char *p; 290 291 p = (u_char *)mask; 292 bzero(mask, sizeof(*mask)); 293 for (i = 0; i < len / 8; i++) 294 p[i] = 0xff; 295 if (len % 8) 296 p[i] = (0xff00 >> (len % 8)) & 0xff; 297 } 298 299 int in_interfaces; /* number of external internet interfaces */ 300 301 /* 302 * Generic internet control operations (ioctl's). 303 * Ifp is 0 if not an interface-specific ioctl. 304 */ 305 /* ARGSUSED */ 306 int 307 in_control(so, cmd, data, ifp, p) 308 struct socket *so; 309 u_long cmd; 310 caddr_t data; 311 register struct ifnet *ifp; 312 struct proc *p; 313 { 314 register struct ifreq *ifr = (struct ifreq *)data; 315 register struct in_ifaddr *ia = 0; 316 struct in_aliasreq *ifra = (struct in_aliasreq *)data; 317 struct sockaddr_in oldaddr; 318 int error, hostIsNew, maskIsNew; 319 320 #if NGIF > 0 321 if (ifp && ifp->if_type == IFT_GIF) { 322 switch (cmd) { 323 case SIOCSIFPHYADDR: 324 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 325 return(EPERM); 326 case SIOCGIFPSRCADDR: 327 case SIOCGIFPDSTADDR: 328 return gif_ioctl(ifp, cmd, data); 329 } 330 } 331 #endif 332 333 switch (cmd) { 334 case SIOCALIFADDR: 335 case SIOCDLIFADDR: 336 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 337 return(EPERM); 338 /*fall through*/ 339 case SIOCGLIFADDR: 340 if (!ifp) 341 return EINVAL; 342 return in_lifaddr_ioctl(so, cmd, data, ifp, p); 343 } 344 345 /* 346 * Find address for this interface, if it exists. 347 */ 348 if (ifp) 349 IFP_TO_IA(ifp, ia); 350 351 switch (cmd) { 352 353 case SIOCAIFADDR: 354 case SIOCDIFADDR: 355 case SIOCGIFALIAS: 356 if (ifra->ifra_addr.sin_family == AF_INET) 357 for (ia = IN_IFADDR_HASH(ifra->ifra_addr.sin_addr.s_addr).lh_first; 358 ia != 0; ia = ia->ia_hash.le_next) { 359 if (ia->ia_ifp == ifp && 360 in_hosteq(ia->ia_addr.sin_addr, 361 ifra->ifra_addr.sin_addr)) 362 break; 363 } 364 if (cmd == SIOCDIFADDR && ia == 0) 365 return (EADDRNOTAVAIL); 366 /* FALLTHROUGH */ 367 case SIOCSIFADDR: 368 case SIOCSIFNETMASK: 369 case SIOCSIFDSTADDR: 370 if (ifp == 0) 371 panic("in_control"); 372 373 if (cmd == SIOCGIFALIAS) 374 break; 375 376 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 377 return (EPERM); 378 379 if (ia == 0) { 380 MALLOC(ia, struct in_ifaddr *, sizeof(*ia), 381 M_IFADDR, M_WAITOK); 382 if (ia == 0) 383 return (ENOBUFS); 384 bzero((caddr_t)ia, sizeof *ia); 385 TAILQ_INSERT_TAIL(&in_ifaddr, ia, ia_list); 386 TAILQ_INSERT_TAIL(&ifp->if_addrlist, (struct ifaddr *)ia, 387 ifa_list); 388 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 389 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 390 ia->ia_ifa.ifa_netmask = sintosa(&ia->ia_sockmask); 391 ia->ia_sockmask.sin_len = 8; 392 if (ifp->if_flags & IFF_BROADCAST) { 393 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr); 394 ia->ia_broadaddr.sin_family = AF_INET; 395 } 396 ia->ia_ifp = ifp; 397 LIST_INIT(&ia->ia_multiaddrs); 398 if ((ifp->if_flags & IFF_LOOPBACK) == 0) 399 in_interfaces++; 400 } 401 break; 402 403 case SIOCSIFBRDADDR: 404 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 405 return (EPERM); 406 /* FALLTHROUGH */ 407 408 case SIOCGIFADDR: 409 case SIOCGIFNETMASK: 410 case SIOCGIFDSTADDR: 411 case SIOCGIFBRDADDR: 412 if (ia == 0) 413 return (EADDRNOTAVAIL); 414 break; 415 } 416 switch (cmd) { 417 418 case SIOCGIFADDR: 419 *satosin(&ifr->ifr_addr) = ia->ia_addr; 420 break; 421 422 case SIOCGIFBRDADDR: 423 if ((ifp->if_flags & IFF_BROADCAST) == 0) 424 return (EINVAL); 425 *satosin(&ifr->ifr_dstaddr) = ia->ia_broadaddr; 426 break; 427 428 case SIOCGIFDSTADDR: 429 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) 430 return (EINVAL); 431 *satosin(&ifr->ifr_dstaddr) = ia->ia_dstaddr; 432 break; 433 434 case SIOCGIFNETMASK: 435 *satosin(&ifr->ifr_addr) = ia->ia_sockmask; 436 break; 437 438 case SIOCSIFDSTADDR: 439 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) 440 return (EINVAL); 441 oldaddr = ia->ia_dstaddr; 442 ia->ia_dstaddr = *satosin(&ifr->ifr_dstaddr); 443 if (ifp->if_ioctl && (error = (*ifp->if_ioctl) 444 (ifp, SIOCSIFDSTADDR, (caddr_t)ia))) { 445 ia->ia_dstaddr = oldaddr; 446 return (error); 447 } 448 if (ia->ia_flags & IFA_ROUTE) { 449 ia->ia_ifa.ifa_dstaddr = sintosa(&oldaddr); 450 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST); 451 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 452 rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP); 453 } 454 break; 455 456 case SIOCSIFBRDADDR: 457 if ((ifp->if_flags & IFF_BROADCAST) == 0) 458 return (EINVAL); 459 ia->ia_broadaddr = *satosin(&ifr->ifr_broadaddr); 460 break; 461 462 case SIOCSIFADDR: 463 return (in_ifinit(ifp, ia, satosin(&ifr->ifr_addr), 1)); 464 465 case SIOCSIFNETMASK: 466 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr = 467 ifra->ifra_addr.sin_addr.s_addr; 468 break; 469 470 case SIOCAIFADDR: 471 maskIsNew = 0; 472 hostIsNew = 1; 473 error = 0; 474 if (ia->ia_addr.sin_family == AF_INET) { 475 if (ifra->ifra_addr.sin_len == 0) { 476 ifra->ifra_addr = ia->ia_addr; 477 hostIsNew = 0; 478 } else if (in_hosteq(ia->ia_addr.sin_addr, ifra->ifra_addr.sin_addr)) 479 hostIsNew = 0; 480 } 481 if (ifra->ifra_mask.sin_len) { 482 in_ifscrub(ifp, ia); 483 ia->ia_sockmask = ifra->ifra_mask; 484 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 485 maskIsNew = 1; 486 } 487 if ((ifp->if_flags & IFF_POINTOPOINT) && 488 (ifra->ifra_dstaddr.sin_family == AF_INET)) { 489 in_ifscrub(ifp, ia); 490 ia->ia_dstaddr = ifra->ifra_dstaddr; 491 maskIsNew = 1; /* We lie; but the effect's the same */ 492 } 493 if (ifra->ifra_addr.sin_family == AF_INET && 494 (hostIsNew || maskIsNew)) 495 error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0); 496 if ((ifp->if_flags & IFF_BROADCAST) && 497 (ifra->ifra_broadaddr.sin_family == AF_INET)) 498 ia->ia_broadaddr = ifra->ifra_broadaddr; 499 return (error); 500 501 case SIOCGIFALIAS: 502 ifra->ifra_mask = ia->ia_sockmask; 503 if ((ifp->if_flags & IFF_POINTOPOINT) && 504 (ia->ia_dstaddr.sin_family == AF_INET)) 505 ifra->ifra_dstaddr = ia->ia_dstaddr; 506 else if ((ifp->if_flags & IFF_BROADCAST) && 507 (ia->ia_broadaddr.sin_family == AF_INET)) 508 ifra->ifra_broadaddr = ia->ia_broadaddr; 509 else 510 bzero(&ifra->ifra_broadaddr, 511 sizeof(ifra->ifra_broadaddr)); 512 return 0; 513 514 case SIOCDIFADDR: 515 in_ifscrub(ifp, ia); 516 LIST_REMOVE(ia, ia_hash); 517 TAILQ_REMOVE(&ifp->if_addrlist, (struct ifaddr *)ia, ifa_list); 518 TAILQ_REMOVE(&in_ifaddr, ia, ia_list); 519 IFAFREE((&ia->ia_ifa)); 520 in_setmaxmtu(); 521 break; 522 523 #ifdef MROUTING 524 case SIOCGETVIFCNT: 525 case SIOCGETSGCNT: 526 return (mrt_ioctl(so, cmd, data)); 527 #endif /* MROUTING */ 528 529 default: 530 if (ifp == 0 || ifp->if_ioctl == 0) 531 return (EOPNOTSUPP); 532 error = (*ifp->if_ioctl)(ifp, cmd, data); 533 in_setmaxmtu(); 534 return(error); 535 } 536 return (0); 537 } 538 539 /* 540 * SIOC[GAD]LIFADDR. 541 * SIOCGLIFADDR: get first address. (???) 542 * SIOCGLIFADDR with IFLR_PREFIX: 543 * get first address that matches the specified prefix. 544 * SIOCALIFADDR: add the specified address. 545 * SIOCALIFADDR with IFLR_PREFIX: 546 * EINVAL since we can't deduce hostid part of the address. 547 * SIOCDLIFADDR: delete the specified address. 548 * SIOCDLIFADDR with IFLR_PREFIX: 549 * delete the first address that matches the specified prefix. 550 * return values: 551 * EINVAL on invalid parameters 552 * EADDRNOTAVAIL on prefix match failed/specified address not found 553 * other values may be returned from in_ioctl() 554 */ 555 static int 556 in_lifaddr_ioctl(so, cmd, data, ifp, p) 557 struct socket *so; 558 u_long cmd; 559 caddr_t data; 560 struct ifnet *ifp; 561 struct proc *p; 562 { 563 struct if_laddrreq *iflr = (struct if_laddrreq *)data; 564 struct ifaddr *ifa; 565 struct sockaddr *sa; 566 567 /* sanity checks */ 568 if (!data || !ifp) { 569 panic("invalid argument to in_lifaddr_ioctl"); 570 /*NOTRECHED*/ 571 } 572 573 switch (cmd) { 574 case SIOCGLIFADDR: 575 /* address must be specified on GET with IFLR_PREFIX */ 576 if ((iflr->flags & IFLR_PREFIX) == 0) 577 break; 578 /*FALLTHROUGH*/ 579 case SIOCALIFADDR: 580 case SIOCDLIFADDR: 581 /* address must be specified on ADD and DELETE */ 582 sa = (struct sockaddr *)&iflr->addr; 583 if (sa->sa_family != AF_INET) 584 return EINVAL; 585 if (sa->sa_len != sizeof(struct sockaddr_in)) 586 return EINVAL; 587 /* XXX need improvement */ 588 sa = (struct sockaddr *)&iflr->dstaddr; 589 if (sa->sa_family 590 && sa->sa_family != AF_INET) 591 return EINVAL; 592 if (sa->sa_len && sa->sa_len != sizeof(struct sockaddr_in)) 593 return EINVAL; 594 break; 595 default: /*shouldn't happen*/ 596 #if 0 597 panic("invalid cmd to in_lifaddr_ioctl"); 598 /*NOTREACHED*/ 599 #else 600 return EOPNOTSUPP; 601 #endif 602 } 603 if (sizeof(struct in_addr) * 8 < iflr->prefixlen) 604 return EINVAL; 605 606 switch (cmd) { 607 case SIOCALIFADDR: 608 { 609 struct in_aliasreq ifra; 610 611 if (iflr->flags & IFLR_PREFIX) 612 return EINVAL; 613 614 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR_IN6). */ 615 bzero(&ifra, sizeof(ifra)); 616 bcopy(iflr->iflr_name, ifra.ifra_name, 617 sizeof(ifra.ifra_name)); 618 619 bcopy(&iflr->addr, &ifra.ifra_addr, 620 ((struct sockaddr *)&iflr->addr)->sa_len); 621 622 if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /*XXX*/ 623 bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr, 624 ((struct sockaddr *)&iflr->dstaddr)->sa_len); 625 } 626 627 ifra.ifra_mask.sin_family = AF_INET; 628 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in); 629 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen); 630 631 return in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, p); 632 } 633 case SIOCGLIFADDR: 634 case SIOCDLIFADDR: 635 { 636 struct in_ifaddr *ia; 637 struct in_addr mask, candidate, match; 638 struct sockaddr_in *sin; 639 int cmp; 640 641 bzero(&mask, sizeof(mask)); 642 if (iflr->flags & IFLR_PREFIX) { 643 /* lookup a prefix rather than address. */ 644 in_len2mask(&mask, iflr->prefixlen); 645 646 sin = (struct sockaddr_in *)&iflr->addr; 647 match.s_addr = sin->sin_addr.s_addr; 648 match.s_addr &= mask.s_addr; 649 650 /* if you set extra bits, that's wrong */ 651 if (match.s_addr != sin->sin_addr.s_addr) 652 return EINVAL; 653 654 cmp = 1; 655 } else { 656 if (cmd == SIOCGLIFADDR) { 657 /* on getting an address, take the 1st match */ 658 cmp = 0; /*XXX*/ 659 } else { 660 /* on deleting an address, do exact match */ 661 in_len2mask(&mask, 32); 662 sin = (struct sockaddr_in *)&iflr->addr; 663 match.s_addr = sin->sin_addr.s_addr; 664 665 cmp = 1; 666 } 667 } 668 669 for (ifa = ifp->if_addrlist.tqh_first; ifa; ifa = ifa->ifa_list.tqe_next) { 670 if (ifa->ifa_addr->sa_family != AF_INET6) 671 continue; 672 if (!cmp) 673 break; 674 candidate.s_addr = ((struct sockaddr_in *)&ifa->ifa_addr)->sin_addr.s_addr; 675 candidate.s_addr &= mask.s_addr; 676 if (candidate.s_addr == match.s_addr) 677 break; 678 } 679 if (!ifa) 680 return EADDRNOTAVAIL; 681 ia = (struct in_ifaddr *)ifa; 682 683 if (cmd == SIOCGLIFADDR) { 684 /* fill in the if_laddrreq structure */ 685 bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin_len); 686 687 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 688 bcopy(&ia->ia_dstaddr, &iflr->dstaddr, 689 ia->ia_dstaddr.sin_len); 690 } else 691 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr)); 692 693 iflr->prefixlen = 694 in_mask2len(&ia->ia_sockmask.sin_addr); 695 696 iflr->flags = 0; /*XXX*/ 697 698 return 0; 699 } else { 700 struct in_aliasreq ifra; 701 702 /* fill in_aliasreq and do ioctl(SIOCDIFADDR_IN6) */ 703 bzero(&ifra, sizeof(ifra)); 704 bcopy(iflr->iflr_name, ifra.ifra_name, 705 sizeof(ifra.ifra_name)); 706 707 bcopy(&ia->ia_addr, &ifra.ifra_addr, 708 ia->ia_addr.sin_len); 709 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 710 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr, 711 ia->ia_dstaddr.sin_len); 712 } 713 bcopy(&ia->ia_sockmask, &ifra.ifra_dstaddr, 714 ia->ia_sockmask.sin_len); 715 716 return in_control(so, SIOCDIFADDR, (caddr_t)&ifra, 717 ifp, p); 718 } 719 } 720 } 721 722 return EOPNOTSUPP; /*just for safety*/ 723 } 724 725 /* 726 * Delete any existing route for an interface. 727 */ 728 void 729 in_ifscrub(ifp, ia) 730 register struct ifnet *ifp; 731 register struct in_ifaddr *ia; 732 { 733 734 if ((ia->ia_flags & IFA_ROUTE) == 0) 735 return; 736 if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT)) 737 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST); 738 else 739 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0); 740 ia->ia_flags &= ~IFA_ROUTE; 741 } 742 743 /* 744 * Initialize an interface's internet address 745 * and routing table entry. 746 */ 747 int 748 in_ifinit(ifp, ia, sin, scrub) 749 register struct ifnet *ifp; 750 register struct in_ifaddr *ia; 751 struct sockaddr_in *sin; 752 int scrub; 753 { 754 register u_int32_t i = sin->sin_addr.s_addr; 755 struct sockaddr_in oldaddr; 756 int s = splimp(), flags = RTF_UP, error; 757 758 /* 759 * Set up new addresses. 760 */ 761 oldaddr = ia->ia_addr; 762 if (ia->ia_addr.sin_family == AF_INET) 763 LIST_REMOVE(ia, ia_hash); 764 ia->ia_addr = *sin; 765 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, ia_hash); 766 767 /* 768 * Give the interface a chance to initialize 769 * if this is its first address, 770 * and to validate the address if necessary. 771 */ 772 if (ifp->if_ioctl && 773 (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) 774 goto bad; 775 splx(s); 776 if (scrub) { 777 ia->ia_ifa.ifa_addr = sintosa(&oldaddr); 778 in_ifscrub(ifp, ia); 779 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 780 } 781 782 if (IN_CLASSA(i)) 783 ia->ia_netmask = IN_CLASSA_NET; 784 else if (IN_CLASSB(i)) 785 ia->ia_netmask = IN_CLASSB_NET; 786 else 787 ia->ia_netmask = IN_CLASSC_NET; 788 /* 789 * The subnet mask usually includes at least the standard network part, 790 * but may may be smaller in the case of supernetting. 791 * If it is set, we believe it. 792 */ 793 if (ia->ia_subnetmask == 0) { 794 ia->ia_subnetmask = ia->ia_netmask; 795 ia->ia_sockmask.sin_addr.s_addr = ia->ia_subnetmask; 796 } else 797 ia->ia_netmask &= ia->ia_subnetmask; 798 799 ia->ia_net = i & ia->ia_netmask; 800 ia->ia_subnet = i & ia->ia_subnetmask; 801 in_socktrim(&ia->ia_sockmask); 802 /* re-calculate the "in_maxmtu" value */ 803 in_setmaxmtu(); 804 /* 805 * Add route for the network. 806 */ 807 ia->ia_ifa.ifa_metric = ifp->if_metric; 808 if (ifp->if_flags & IFF_BROADCAST) { 809 ia->ia_broadaddr.sin_addr.s_addr = 810 ia->ia_subnet | ~ia->ia_subnetmask; 811 ia->ia_netbroadcast.s_addr = 812 ia->ia_net | ~ia->ia_netmask; 813 } else if (ifp->if_flags & IFF_LOOPBACK) { 814 ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr; 815 flags |= RTF_HOST; 816 } else if (ifp->if_flags & IFF_POINTOPOINT) { 817 if (ia->ia_dstaddr.sin_family != AF_INET) 818 return (0); 819 flags |= RTF_HOST; 820 } 821 error = rtinit(&ia->ia_ifa, (int)RTM_ADD, flags); 822 if (!error) 823 ia->ia_flags |= IFA_ROUTE; 824 /* 825 * If the interface supports multicast, join the "all hosts" 826 * multicast group on that interface. 827 */ 828 if (ifp->if_flags & IFF_MULTICAST) { 829 struct in_addr addr; 830 831 addr.s_addr = INADDR_ALLHOSTS_GROUP; 832 in_addmulti(&addr, ifp); 833 } 834 return (error); 835 bad: 836 splx(s); 837 LIST_REMOVE(ia, ia_hash); 838 ia->ia_addr = oldaddr; 839 if (ia->ia_addr.sin_family == AF_INET) 840 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), 841 ia, ia_hash); 842 return (error); 843 } 844 845 /* 846 * Return 1 if the address might be a local broadcast address. 847 */ 848 int 849 in_broadcast(in, ifp) 850 struct in_addr in; 851 struct ifnet *ifp; 852 { 853 register struct ifaddr *ifa; 854 855 if (in.s_addr == INADDR_BROADCAST || 856 in_nullhost(in)) 857 return 1; 858 if ((ifp->if_flags & IFF_BROADCAST) == 0) 859 return 0; 860 /* 861 * Look through the list of addresses for a match 862 * with a broadcast address. 863 */ 864 #define ia (ifatoia(ifa)) 865 for (ifa = ifp->if_addrlist.tqh_first; ifa; ifa = ifa->ifa_list.tqe_next) 866 if (ifa->ifa_addr->sa_family == AF_INET && 867 (in_hosteq(in, ia->ia_broadaddr.sin_addr) || 868 in_hosteq(in, ia->ia_netbroadcast) || 869 (hostzeroisbroadcast && 870 /* 871 * Check for old-style (host 0) broadcast. 872 */ 873 (in.s_addr == ia->ia_subnet || 874 in.s_addr == ia->ia_net)))) 875 return 1; 876 return (0); 877 #undef ia 878 } 879 880 /* 881 * Add an address to the list of IP multicast addresses for a given interface. 882 */ 883 struct in_multi * 884 in_addmulti(ap, ifp) 885 register struct in_addr *ap; 886 register struct ifnet *ifp; 887 { 888 register struct in_multi *inm; 889 struct ifreq ifr; 890 struct in_ifaddr *ia; 891 int s = splsoftnet(); 892 893 /* 894 * See if address already in list. 895 */ 896 IN_LOOKUP_MULTI(*ap, ifp, inm); 897 if (inm != NULL) { 898 /* 899 * Found it; just increment the reference count. 900 */ 901 ++inm->inm_refcount; 902 } else { 903 /* 904 * New address; allocate a new multicast record 905 * and link it into the interface's multicast list. 906 */ 907 inm = (struct in_multi *)malloc(sizeof(*inm), 908 M_IPMADDR, M_NOWAIT); 909 if (inm == NULL) { 910 splx(s); 911 return (NULL); 912 } 913 inm->inm_addr = *ap; 914 inm->inm_ifp = ifp; 915 inm->inm_refcount = 1; 916 IFP_TO_IA(ifp, ia); 917 if (ia == NULL) { 918 free(inm, M_IPMADDR); 919 splx(s); 920 return (NULL); 921 } 922 inm->inm_ia = ia; 923 LIST_INSERT_HEAD(&ia->ia_multiaddrs, inm, inm_list); 924 /* 925 * Ask the network driver to update its multicast reception 926 * filter appropriately for the new address. 927 */ 928 satosin(&ifr.ifr_addr)->sin_len = sizeof(struct sockaddr_in); 929 satosin(&ifr.ifr_addr)->sin_family = AF_INET; 930 satosin(&ifr.ifr_addr)->sin_addr = *ap; 931 if ((ifp->if_ioctl == NULL) || 932 (*ifp->if_ioctl)(ifp, SIOCADDMULTI,(caddr_t)&ifr) != 0) { 933 LIST_REMOVE(inm, inm_list); 934 free(inm, M_IPMADDR); 935 splx(s); 936 return (NULL); 937 } 938 /* 939 * Let IGMP know that we have joined a new IP multicast group. 940 */ 941 igmp_joingroup(inm); 942 } 943 splx(s); 944 return (inm); 945 } 946 947 /* 948 * Delete a multicast address record. 949 */ 950 void 951 in_delmulti(inm) 952 register struct in_multi *inm; 953 { 954 struct ifreq ifr; 955 int s = splsoftnet(); 956 957 if (--inm->inm_refcount == 0) { 958 /* 959 * No remaining claims to this record; let IGMP know that 960 * we are leaving the multicast group. 961 */ 962 igmp_leavegroup(inm); 963 /* 964 * Unlink from list. 965 */ 966 LIST_REMOVE(inm, inm_list); 967 /* 968 * Notify the network driver to update its multicast reception 969 * filter. 970 */ 971 satosin(&ifr.ifr_addr)->sin_family = AF_INET; 972 satosin(&ifr.ifr_addr)->sin_addr = inm->inm_addr; 973 (*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI, 974 (caddr_t)&ifr); 975 free(inm, M_IPMADDR); 976 } 977 splx(s); 978 } 979 #endif 980