in.c revision 1.65 1 /* $NetBSD: in.c,v 1.65 2000/10/08 09:15:28 enami 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/route.h>
119
120 #include <net/if_ether.h>
121
122 #include <netinet/in_systm.h>
123 #include <netinet/in.h>
124 #include <netinet/in_var.h>
125 #include <netinet/if_inarp.h>
126 #include <netinet/ip_mroute.h>
127 #include <netinet/igmp_var.h>
128
129 #ifdef INET
130
131 static int in_mask2len __P((struct in_addr *));
132 static void in_len2mask __P((struct in_addr *, int));
133 static int in_lifaddr_ioctl __P((struct socket *, u_long, caddr_t,
134 struct ifnet *, struct proc *));
135
136 #ifndef SUBNETSARELOCAL
137 #define SUBNETSARELOCAL 1
138 #endif
139
140 #ifndef HOSTZEROBROADCAST
141 #define HOSTZEROBROADCAST 1
142 #endif
143
144 int subnetsarelocal = SUBNETSARELOCAL;
145 int hostzeroisbroadcast = HOSTZEROBROADCAST;
146
147 /*
148 * This list is used to keep track of in_multi chains which belong to
149 * deleted interface addresses. We use in_ifaddr so that a chain head
150 * won't be deallocated until all multicast address record are deleted.
151 */
152 static TAILQ_HEAD(, in_ifaddr) in_mk = TAILQ_HEAD_INITIALIZER(in_mk);
153
154 /*
155 * Return 1 if an internet address is for a ``local'' host
156 * (one to which we have a connection). If subnetsarelocal
157 * is true, this includes other subnets of the local net.
158 * Otherwise, it includes only the directly-connected (sub)nets.
159 */
160 int
161 in_localaddr(in)
162 struct in_addr in;
163 {
164 struct in_ifaddr *ia;
165
166 if (subnetsarelocal) {
167 for (ia = in_ifaddr.tqh_first; ia != 0; ia = ia->ia_list.tqe_next)
168 if ((in.s_addr & ia->ia_netmask) == ia->ia_net)
169 return (1);
170 } else {
171 for (ia = in_ifaddr.tqh_first; ia != 0; ia = ia->ia_list.tqe_next)
172 if ((in.s_addr & ia->ia_subnetmask) == ia->ia_subnet)
173 return (1);
174 }
175 return (0);
176 }
177
178 /*
179 * Determine whether an IP address is in a reserved set of addresses
180 * that may not be forwarded, or whether datagrams to that destination
181 * may be forwarded.
182 */
183 int
184 in_canforward(in)
185 struct in_addr in;
186 {
187 u_int32_t net;
188
189 if (IN_EXPERIMENTAL(in.s_addr) || IN_MULTICAST(in.s_addr))
190 return (0);
191 if (IN_CLASSA(in.s_addr)) {
192 net = in.s_addr & IN_CLASSA_NET;
193 if (net == 0 || net == htonl(IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
194 return (0);
195 }
196 return (1);
197 }
198
199 /*
200 * Trim a mask in a sockaddr
201 */
202 void
203 in_socktrim(ap)
204 struct sockaddr_in *ap;
205 {
206 char *cplim = (char *) &ap->sin_addr;
207 char *cp = (char *) (&ap->sin_addr + 1);
208
209 ap->sin_len = 0;
210 while (--cp >= cplim)
211 if (*cp) {
212 (ap)->sin_len = cp - (char *) (ap) + 1;
213 break;
214 }
215 }
216
217 /*
218 * Routine to take an Internet address and convert into a
219 * "dotted quad" representation for printing.
220 */
221 const char *
222 in_fmtaddr(addr)
223 struct in_addr addr;
224 {
225 static char buf[sizeof("123.456.789.123")];
226
227 addr.s_addr = ntohl(addr.s_addr);
228
229 sprintf(buf, "%d.%d.%d.%d",
230 (addr.s_addr >> 24) & 0xFF,
231 (addr.s_addr >> 16) & 0xFF,
232 (addr.s_addr >> 8) & 0xFF,
233 (addr.s_addr >> 0) & 0xFF);
234 return buf;
235 }
236
237 /*
238 * Maintain the "in_maxmtu" variable, which is the largest
239 * mtu for non-local interfaces with AF_INET addresses assigned
240 * to them that are up.
241 */
242 unsigned long in_maxmtu;
243
244 void
245 in_setmaxmtu()
246 {
247 struct in_ifaddr *ia;
248 struct ifnet *ifp;
249 unsigned long maxmtu = 0;
250
251 for (ia = in_ifaddr.tqh_first; ia != 0; ia = ia->ia_list.tqe_next) {
252 if ((ifp = ia->ia_ifp) == 0)
253 continue;
254 if ((ifp->if_flags & (IFF_UP|IFF_LOOPBACK)) != IFF_UP)
255 continue;
256 if (ifp->if_mtu > maxmtu)
257 maxmtu = ifp->if_mtu;
258 }
259 if (maxmtu)
260 in_maxmtu = maxmtu;
261 }
262
263 static int
264 in_mask2len(mask)
265 struct in_addr *mask;
266 {
267 int x, y;
268 u_char *p;
269
270 p = (u_char *)mask;
271 for (x = 0; x < sizeof(*mask); x++) {
272 if (p[x] != 0xff)
273 break;
274 }
275 y = 0;
276 if (x < sizeof(*mask)) {
277 for (y = 0; y < 8; y++) {
278 if ((p[x] & (0x80 >> y)) == 0)
279 break;
280 }
281 }
282 return x * 8 + y;
283 }
284
285 static void
286 in_len2mask(mask, len)
287 struct in_addr *mask;
288 int len;
289 {
290 int i;
291 u_char *p;
292
293 p = (u_char *)mask;
294 bzero(mask, sizeof(*mask));
295 for (i = 0; i < len / 8; i++)
296 p[i] = 0xff;
297 if (len % 8)
298 p[i] = (0xff00 >> (len % 8)) & 0xff;
299 }
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 struct ifnet *ifp;
312 struct proc *p;
313 {
314 struct ifreq *ifr = (struct ifreq *)data;
315 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 int newifaddr;
320
321 switch (cmd) {
322 case SIOCALIFADDR:
323 case SIOCDLIFADDR:
324 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag)))
325 return(EPERM);
326 /*fall through*/
327 case SIOCGLIFADDR:
328 if (!ifp)
329 return EINVAL;
330 return in_lifaddr_ioctl(so, cmd, data, ifp, p);
331 }
332
333 /*
334 * Find address for this interface, if it exists.
335 */
336 if (ifp)
337 IFP_TO_IA(ifp, ia);
338
339 switch (cmd) {
340
341 case SIOCAIFADDR:
342 case SIOCDIFADDR:
343 case SIOCGIFALIAS:
344 if (ifra->ifra_addr.sin_family == AF_INET)
345 for (ia = IN_IFADDR_HASH(ifra->ifra_addr.sin_addr.s_addr).lh_first;
346 ia != 0; ia = ia->ia_hash.le_next) {
347 if (ia->ia_ifp == ifp &&
348 in_hosteq(ia->ia_addr.sin_addr,
349 ifra->ifra_addr.sin_addr))
350 break;
351 }
352 if (cmd == SIOCDIFADDR) {
353 if (ia == 0)
354 return (EADDRNOTAVAIL);
355 #if 1 /*def COMPAT_43*/
356 if (ifra->ifra_addr.sin_family == AF_UNSPEC)
357 ifra->ifra_addr.sin_family = AF_INET;
358 #endif
359 }
360 /* FALLTHROUGH */
361 case SIOCSIFADDR:
362 case SIOCSIFDSTADDR:
363 if (ifra->ifra_addr.sin_family != AF_INET)
364 return (EAFNOSUPPORT);
365 /* FALLTHROUGH */
366 case SIOCSIFNETMASK:
367 if (ifp == 0)
368 panic("in_control");
369
370 if (cmd == SIOCGIFALIAS)
371 break;
372
373 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag)))
374 return (EPERM);
375
376 if (ia == 0) {
377 MALLOC(ia, struct in_ifaddr *, sizeof(*ia),
378 M_IFADDR, M_WAITOK);
379 if (ia == 0)
380 return (ENOBUFS);
381 bzero((caddr_t)ia, sizeof *ia);
382 TAILQ_INSERT_TAIL(&in_ifaddr, ia, ia_list);
383 IFAREF(&ia->ia_ifa);
384 TAILQ_INSERT_TAIL(&ifp->if_addrlist, &ia->ia_ifa,
385 ifa_list);
386 IFAREF(&ia->ia_ifa);
387 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr);
388 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr);
389 ia->ia_ifa.ifa_netmask = sintosa(&ia->ia_sockmask);
390 ia->ia_sockmask.sin_len = 8;
391 if (ifp->if_flags & IFF_BROADCAST) {
392 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);
393 ia->ia_broadaddr.sin_family = AF_INET;
394 }
395 ia->ia_ifp = ifp;
396 LIST_INIT(&ia->ia_multiaddrs);
397 newifaddr = 1;
398 } else
399 newifaddr = 0;
400 break;
401
402 case SIOCSIFBRDADDR:
403 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag)))
404 return (EPERM);
405 /* FALLTHROUGH */
406
407 case SIOCGIFADDR:
408 case SIOCGIFNETMASK:
409 case SIOCGIFDSTADDR:
410 case SIOCGIFBRDADDR:
411 if (ia == 0)
412 return (EADDRNOTAVAIL);
413 break;
414 }
415 switch (cmd) {
416
417 case SIOCGIFADDR:
418 *satosin(&ifr->ifr_addr) = ia->ia_addr;
419 break;
420
421 case SIOCGIFBRDADDR:
422 if ((ifp->if_flags & IFF_BROADCAST) == 0)
423 return (EINVAL);
424 *satosin(&ifr->ifr_dstaddr) = ia->ia_broadaddr;
425 break;
426
427 case SIOCGIFDSTADDR:
428 if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
429 return (EINVAL);
430 *satosin(&ifr->ifr_dstaddr) = ia->ia_dstaddr;
431 break;
432
433 case SIOCGIFNETMASK:
434 *satosin(&ifr->ifr_addr) = ia->ia_sockmask;
435 break;
436
437 case SIOCSIFDSTADDR:
438 if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
439 return (EINVAL);
440 oldaddr = ia->ia_dstaddr;
441 ia->ia_dstaddr = *satosin(&ifr->ifr_dstaddr);
442 if (ifp->if_ioctl && (error = (*ifp->if_ioctl)
443 (ifp, SIOCSIFDSTADDR, (caddr_t)ia))) {
444 ia->ia_dstaddr = oldaddr;
445 return (error);
446 }
447 if (ia->ia_flags & IFA_ROUTE) {
448 ia->ia_ifa.ifa_dstaddr = sintosa(&oldaddr);
449 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
450 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr);
451 rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
452 }
453 break;
454
455 case SIOCSIFBRDADDR:
456 if ((ifp->if_flags & IFF_BROADCAST) == 0)
457 return (EINVAL);
458 ia->ia_broadaddr = *satosin(&ifr->ifr_broadaddr);
459 break;
460
461 case SIOCSIFADDR:
462 error = in_ifinit(ifp, ia, satosin(&ifr->ifr_addr), 1);
463 #if 0
464 /*
465 * the code chokes if we are to assign multiple addresses with
466 * the same address prefix (rtinit() will return EEXIST, which
467 * is not fatal actually). we will get memory leak if we
468 * don't do it.
469 * -> we may want to hide EEXIST from rtinit().
470 */
471 undo:
472 if (error && newifaddr) {
473 TAILQ_REMOVE(&ifp->if_addrlist, &ia->ia_ifa, ifa_list);
474 IFAFREE(&ia->ia_ifa);
475 TAILQ_REMOVE(&in_ifaddr, ia, ia_list);
476 IFAFREE(&ia->ia_ifa);
477 }
478 #endif
479 return error;
480
481 case SIOCSIFNETMASK:
482 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr =
483 ifra->ifra_addr.sin_addr.s_addr;
484 break;
485
486 case SIOCAIFADDR:
487 maskIsNew = 0;
488 hostIsNew = 1;
489 error = 0;
490 if (ia->ia_addr.sin_family == AF_INET) {
491 if (ifra->ifra_addr.sin_len == 0) {
492 ifra->ifra_addr = ia->ia_addr;
493 hostIsNew = 0;
494 } else if (in_hosteq(ia->ia_addr.sin_addr, ifra->ifra_addr.sin_addr))
495 hostIsNew = 0;
496 }
497 if (ifra->ifra_mask.sin_len) {
498 in_ifscrub(ifp, ia);
499 ia->ia_sockmask = ifra->ifra_mask;
500 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr;
501 maskIsNew = 1;
502 }
503 if ((ifp->if_flags & IFF_POINTOPOINT) &&
504 (ifra->ifra_dstaddr.sin_family == AF_INET)) {
505 in_ifscrub(ifp, ia);
506 ia->ia_dstaddr = ifra->ifra_dstaddr;
507 maskIsNew = 1; /* We lie; but the effect's the same */
508 }
509 if (ifra->ifra_addr.sin_family == AF_INET &&
510 (hostIsNew || maskIsNew)) {
511 error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);
512 #if 0
513 if (error)
514 goto undo;
515 #endif
516 }
517 if ((ifp->if_flags & IFF_BROADCAST) &&
518 (ifra->ifra_broadaddr.sin_family == AF_INET))
519 ia->ia_broadaddr = ifra->ifra_broadaddr;
520 return (error);
521
522 case SIOCGIFALIAS:
523 ifra->ifra_mask = ia->ia_sockmask;
524 if ((ifp->if_flags & IFF_POINTOPOINT) &&
525 (ia->ia_dstaddr.sin_family == AF_INET))
526 ifra->ifra_dstaddr = ia->ia_dstaddr;
527 else if ((ifp->if_flags & IFF_BROADCAST) &&
528 (ia->ia_broadaddr.sin_family == AF_INET))
529 ifra->ifra_broadaddr = ia->ia_broadaddr;
530 else
531 bzero(&ifra->ifra_broadaddr,
532 sizeof(ifra->ifra_broadaddr));
533 return 0;
534
535 case SIOCDIFADDR:
536 in_purgeaddr(&ia->ia_ifa, ifp);
537 break;
538
539 #ifdef MROUTING
540 case SIOCGETVIFCNT:
541 case SIOCGETSGCNT:
542 return (mrt_ioctl(so, cmd, data));
543 #endif /* MROUTING */
544
545 default:
546 if (ifp == 0 || ifp->if_ioctl == 0)
547 return (EOPNOTSUPP);
548 error = (*ifp->if_ioctl)(ifp, cmd, data);
549 in_setmaxmtu();
550 return(error);
551 }
552 return (0);
553 }
554
555 void
556 in_purgeaddr(ifa, ifp)
557 struct ifaddr *ifa;
558 struct ifnet *ifp;
559 {
560 struct in_ifaddr *ia = (void *) ifa;
561
562 in_ifscrub(ifp, ia);
563 LIST_REMOVE(ia, ia_hash);
564 TAILQ_REMOVE(&ifp->if_addrlist, &ia->ia_ifa, ifa_list);
565 IFAFREE(&ia->ia_ifa);
566 TAILQ_REMOVE(&in_ifaddr, ia, ia_list);
567 if (ia->ia_allhosts != NULL)
568 in_delmulti(ia->ia_allhosts);
569 if (LIST_FIRST(&ia->ia_multiaddrs) != NULL &&
570 /*
571 * If the interface is going away, don't bother to save
572 * the multicast entries.
573 */
574 ifp->if_output != if_nulloutput)
575 in_savemkludge(ia);
576 IFAFREE(&ia->ia_ifa);
577 in_setmaxmtu();
578 }
579
580 void
581 in_purgeif(ifp)
582 struct ifnet *ifp;
583 {
584 struct ifaddr *ifa, *nifa;
585
586 for (ifa = TAILQ_FIRST(&ifp->if_addrlist); ifa != NULL; ifa = nifa) {
587 nifa = TAILQ_NEXT(ifa, ifa_list);
588 if (ifa->ifa_addr->sa_family != AF_INET)
589 continue;
590 in_purgeaddr(ifa, ifp);
591 }
592 in_purgemkludge(ifp);
593 }
594
595 /*
596 * SIOC[GAD]LIFADDR.
597 * SIOCGLIFADDR: get first address. (???)
598 * SIOCGLIFADDR with IFLR_PREFIX:
599 * get first address that matches the specified prefix.
600 * SIOCALIFADDR: add the specified address.
601 * SIOCALIFADDR with IFLR_PREFIX:
602 * EINVAL since we can't deduce hostid part of the address.
603 * SIOCDLIFADDR: delete the specified address.
604 * SIOCDLIFADDR with IFLR_PREFIX:
605 * delete the first address that matches the specified prefix.
606 * return values:
607 * EINVAL on invalid parameters
608 * EADDRNOTAVAIL on prefix match failed/specified address not found
609 * other values may be returned from in_ioctl()
610 */
611 static int
612 in_lifaddr_ioctl(so, cmd, data, ifp, p)
613 struct socket *so;
614 u_long cmd;
615 caddr_t data;
616 struct ifnet *ifp;
617 struct proc *p;
618 {
619 struct if_laddrreq *iflr = (struct if_laddrreq *)data;
620 struct ifaddr *ifa;
621 struct sockaddr *sa;
622
623 /* sanity checks */
624 if (!data || !ifp) {
625 panic("invalid argument to in_lifaddr_ioctl");
626 /*NOTRECHED*/
627 }
628
629 switch (cmd) {
630 case SIOCGLIFADDR:
631 /* address must be specified on GET with IFLR_PREFIX */
632 if ((iflr->flags & IFLR_PREFIX) == 0)
633 break;
634 /*FALLTHROUGH*/
635 case SIOCALIFADDR:
636 case SIOCDLIFADDR:
637 /* address must be specified on ADD and DELETE */
638 sa = (struct sockaddr *)&iflr->addr;
639 if (sa->sa_family != AF_INET)
640 return EINVAL;
641 if (sa->sa_len != sizeof(struct sockaddr_in))
642 return EINVAL;
643 /* XXX need improvement */
644 sa = (struct sockaddr *)&iflr->dstaddr;
645 if (sa->sa_family
646 && sa->sa_family != AF_INET)
647 return EINVAL;
648 if (sa->sa_len && sa->sa_len != sizeof(struct sockaddr_in))
649 return EINVAL;
650 break;
651 default: /*shouldn't happen*/
652 #if 0
653 panic("invalid cmd to in_lifaddr_ioctl");
654 /*NOTREACHED*/
655 #else
656 return EOPNOTSUPP;
657 #endif
658 }
659 if (sizeof(struct in_addr) * 8 < iflr->prefixlen)
660 return EINVAL;
661
662 switch (cmd) {
663 case SIOCALIFADDR:
664 {
665 struct in_aliasreq ifra;
666
667 if (iflr->flags & IFLR_PREFIX)
668 return EINVAL;
669
670 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR_IN6). */
671 bzero(&ifra, sizeof(ifra));
672 bcopy(iflr->iflr_name, ifra.ifra_name,
673 sizeof(ifra.ifra_name));
674
675 bcopy(&iflr->addr, &ifra.ifra_addr,
676 ((struct sockaddr *)&iflr->addr)->sa_len);
677
678 if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /*XXX*/
679 bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr,
680 ((struct sockaddr *)&iflr->dstaddr)->sa_len);
681 }
682
683 ifra.ifra_mask.sin_family = AF_INET;
684 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in);
685 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen);
686
687 return in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, p);
688 }
689 case SIOCGLIFADDR:
690 case SIOCDLIFADDR:
691 {
692 struct in_ifaddr *ia;
693 struct in_addr mask, candidate, match;
694 struct sockaddr_in *sin;
695 int cmp;
696
697 bzero(&mask, sizeof(mask));
698 if (iflr->flags & IFLR_PREFIX) {
699 /* lookup a prefix rather than address. */
700 in_len2mask(&mask, iflr->prefixlen);
701
702 sin = (struct sockaddr_in *)&iflr->addr;
703 match.s_addr = sin->sin_addr.s_addr;
704 match.s_addr &= mask.s_addr;
705
706 /* if you set extra bits, that's wrong */
707 if (match.s_addr != sin->sin_addr.s_addr)
708 return EINVAL;
709
710 cmp = 1;
711 } else {
712 if (cmd == SIOCGLIFADDR) {
713 /* on getting an address, take the 1st match */
714 cmp = 0; /*XXX*/
715 } else {
716 /* on deleting an address, do exact match */
717 in_len2mask(&mask, 32);
718 sin = (struct sockaddr_in *)&iflr->addr;
719 match.s_addr = sin->sin_addr.s_addr;
720
721 cmp = 1;
722 }
723 }
724
725 for (ifa = ifp->if_addrlist.tqh_first; ifa; ifa = ifa->ifa_list.tqe_next) {
726 if (ifa->ifa_addr->sa_family != AF_INET6)
727 continue;
728 if (!cmp)
729 break;
730 candidate.s_addr = ((struct sockaddr_in *)&ifa->ifa_addr)->sin_addr.s_addr;
731 candidate.s_addr &= mask.s_addr;
732 if (candidate.s_addr == match.s_addr)
733 break;
734 }
735 if (!ifa)
736 return EADDRNOTAVAIL;
737 ia = (struct in_ifaddr *)ifa;
738
739 if (cmd == SIOCGLIFADDR) {
740 /* fill in the if_laddrreq structure */
741 bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin_len);
742
743 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
744 bcopy(&ia->ia_dstaddr, &iflr->dstaddr,
745 ia->ia_dstaddr.sin_len);
746 } else
747 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr));
748
749 iflr->prefixlen =
750 in_mask2len(&ia->ia_sockmask.sin_addr);
751
752 iflr->flags = 0; /*XXX*/
753
754 return 0;
755 } else {
756 struct in_aliasreq ifra;
757
758 /* fill in_aliasreq and do ioctl(SIOCDIFADDR_IN6) */
759 bzero(&ifra, sizeof(ifra));
760 bcopy(iflr->iflr_name, ifra.ifra_name,
761 sizeof(ifra.ifra_name));
762
763 bcopy(&ia->ia_addr, &ifra.ifra_addr,
764 ia->ia_addr.sin_len);
765 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) {
766 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr,
767 ia->ia_dstaddr.sin_len);
768 }
769 bcopy(&ia->ia_sockmask, &ifra.ifra_dstaddr,
770 ia->ia_sockmask.sin_len);
771
772 return in_control(so, SIOCDIFADDR, (caddr_t)&ifra,
773 ifp, p);
774 }
775 }
776 }
777
778 return EOPNOTSUPP; /*just for safety*/
779 }
780
781 /*
782 * Delete any existing route for an interface.
783 */
784 void
785 in_ifscrub(ifp, ia)
786 struct ifnet *ifp;
787 struct in_ifaddr *ia;
788 {
789
790 if ((ia->ia_flags & IFA_ROUTE) == 0)
791 return;
792 if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT))
793 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
794 else
795 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0);
796 ia->ia_flags &= ~IFA_ROUTE;
797 }
798
799 /*
800 * Initialize an interface's internet address
801 * and routing table entry.
802 */
803 int
804 in_ifinit(ifp, ia, sin, scrub)
805 struct ifnet *ifp;
806 struct in_ifaddr *ia;
807 struct sockaddr_in *sin;
808 int scrub;
809 {
810 u_int32_t i = sin->sin_addr.s_addr;
811 struct sockaddr_in oldaddr;
812 int s = splimp(), flags = RTF_UP, error;
813
814 /*
815 * Set up new addresses.
816 */
817 oldaddr = ia->ia_addr;
818 if (ia->ia_addr.sin_family == AF_INET)
819 LIST_REMOVE(ia, ia_hash);
820 ia->ia_addr = *sin;
821 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, ia_hash);
822
823 /*
824 * Give the interface a chance to initialize
825 * if this is its first address,
826 * and to validate the address if necessary.
827 */
828 if (ifp->if_ioctl &&
829 (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia)))
830 goto bad;
831 splx(s);
832 if (scrub) {
833 ia->ia_ifa.ifa_addr = sintosa(&oldaddr);
834 in_ifscrub(ifp, ia);
835 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr);
836 }
837
838 if (IN_CLASSA(i))
839 ia->ia_netmask = IN_CLASSA_NET;
840 else if (IN_CLASSB(i))
841 ia->ia_netmask = IN_CLASSB_NET;
842 else
843 ia->ia_netmask = IN_CLASSC_NET;
844 /*
845 * The subnet mask usually includes at least the standard network part,
846 * but may may be smaller in the case of supernetting.
847 * If it is set, we believe it.
848 */
849 if (ia->ia_subnetmask == 0) {
850 ia->ia_subnetmask = ia->ia_netmask;
851 ia->ia_sockmask.sin_addr.s_addr = ia->ia_subnetmask;
852 } else
853 ia->ia_netmask &= ia->ia_subnetmask;
854
855 ia->ia_net = i & ia->ia_netmask;
856 ia->ia_subnet = i & ia->ia_subnetmask;
857 in_socktrim(&ia->ia_sockmask);
858 /* re-calculate the "in_maxmtu" value */
859 in_setmaxmtu();
860 /*
861 * Add route for the network.
862 */
863 ia->ia_ifa.ifa_metric = ifp->if_metric;
864 if (ifp->if_flags & IFF_BROADCAST) {
865 ia->ia_broadaddr.sin_addr.s_addr =
866 ia->ia_subnet | ~ia->ia_subnetmask;
867 ia->ia_netbroadcast.s_addr =
868 ia->ia_net | ~ia->ia_netmask;
869 } else if (ifp->if_flags & IFF_LOOPBACK) {
870 ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr;
871 flags |= RTF_HOST;
872 } else if (ifp->if_flags & IFF_POINTOPOINT) {
873 if (ia->ia_dstaddr.sin_family != AF_INET)
874 return (0);
875 flags |= RTF_HOST;
876 }
877 error = rtinit(&ia->ia_ifa, (int)RTM_ADD, flags);
878 if (!error)
879 ia->ia_flags |= IFA_ROUTE;
880 /* XXX check if the subnet route points to the same interface */
881 if (error == EEXIST)
882 error = 0;
883 /*
884 * recover multicast kludge entry, if there is.
885 */
886 if (ifp->if_flags & IFF_MULTICAST)
887 in_restoremkludge(ia, ifp);
888 /*
889 * If the interface supports multicast, join the "all hosts"
890 * multicast group on that interface.
891 */
892 if ((ifp->if_flags & IFF_MULTICAST) != 0 && ia->ia_allhosts == NULL) {
893 struct in_addr addr;
894
895 addr.s_addr = INADDR_ALLHOSTS_GROUP;
896 ia->ia_allhosts = in_addmulti(&addr, ifp);
897 }
898 return (error);
899 bad:
900 splx(s);
901 LIST_REMOVE(ia, ia_hash);
902 ia->ia_addr = oldaddr;
903 if (ia->ia_addr.sin_family == AF_INET)
904 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr),
905 ia, ia_hash);
906 return (error);
907 }
908
909 /*
910 * Return 1 if the address might be a local broadcast address.
911 */
912 int
913 in_broadcast(in, ifp)
914 struct in_addr in;
915 struct ifnet *ifp;
916 {
917 struct ifaddr *ifa;
918
919 if (in.s_addr == INADDR_BROADCAST ||
920 in_nullhost(in))
921 return 1;
922 if ((ifp->if_flags & IFF_BROADCAST) == 0)
923 return 0;
924 /*
925 * Look through the list of addresses for a match
926 * with a broadcast address.
927 */
928 #define ia (ifatoia(ifa))
929 for (ifa = ifp->if_addrlist.tqh_first; ifa; ifa = ifa->ifa_list.tqe_next)
930 if (ifa->ifa_addr->sa_family == AF_INET &&
931 (in_hosteq(in, ia->ia_broadaddr.sin_addr) ||
932 in_hosteq(in, ia->ia_netbroadcast) ||
933 (hostzeroisbroadcast &&
934 /*
935 * Check for old-style (host 0) broadcast.
936 */
937 (in.s_addr == ia->ia_subnet ||
938 in.s_addr == ia->ia_net))))
939 return 1;
940 return (0);
941 #undef ia
942 }
943
944 /*
945 * Multicast address kludge:
946 * If there were any multicast addresses attached to this interface address,
947 * either move them to another address on this interface, or save them until
948 * such time as this interface is reconfigured for IPv4.
949 */
950 void
951 in_savemkludge(oia)
952 struct in_ifaddr *oia;
953 {
954 struct in_ifaddr *ia;
955 struct in_multi *inm, *next;
956
957 IFP_TO_IA(oia->ia_ifp, ia);
958 if (ia) { /* there is another address */
959 for (inm = oia->ia_multiaddrs.lh_first; inm; inm = next){
960 next = inm->inm_list.le_next;
961 IFAFREE(&inm->inm_ia->ia_ifa);
962 IFAREF(&ia->ia_ifa);
963 inm->inm_ia = ia;
964 LIST_INSERT_HEAD(&ia->ia_multiaddrs, inm, inm_list);
965 }
966 } else { /* last address on this if deleted, save */
967 TAILQ_INSERT_TAIL(&in_mk, oia, ia_list);
968 IFAREF(&oia->ia_ifa);
969 }
970 }
971
972 /*
973 * Continuation of multicast address hack:
974 * If there was a multicast group list previously saved for this interface,
975 * then we re-attach it to the first address configured on the i/f.
976 */
977 void
978 in_restoremkludge(ia, ifp)
979 struct in_ifaddr *ia;
980 struct ifnet *ifp;
981 {
982 struct in_ifaddr *oia;
983
984 for (oia = TAILQ_FIRST(&in_mk); oia != NULL;
985 oia = TAILQ_NEXT(oia, ia_list)) {
986 if (oia->ia_ifp == ifp) {
987 struct in_multi *inm, *next;
988
989 for (inm = LIST_FIRST(&oia->ia_multiaddrs);
990 inm != NULL; inm = next) {
991 next = LIST_NEXT(inm, inm_list);
992 IFAFREE(&inm->inm_ia->ia_ifa);
993 IFAREF(&ia->ia_ifa);
994 inm->inm_ia = ia;
995 LIST_INSERT_HEAD(&ia->ia_multiaddrs,
996 inm, inm_list);
997 }
998 TAILQ_REMOVE(&in_mk, oia, ia_list);
999 IFAFREE(&oia->ia_ifa);
1000 break;
1001 }
1002 }
1003 }
1004
1005 void
1006 in_purgemkludge(ifp)
1007 struct ifnet *ifp;
1008 {
1009 struct in_ifaddr *oia;
1010
1011 for (oia = TAILQ_FIRST(&in_mk); oia != NULL;
1012 oia = TAILQ_NEXT(oia, ia_list)) {
1013 if (oia->ia_ifp != ifp)
1014 continue;
1015
1016 /*
1017 * Leaving from all multicast groups joined through
1018 * this interface is done via in_pcbpurgeif().
1019 */
1020
1021 TAILQ_REMOVE(&in_mk, oia, ia_list);
1022 IFAFREE(&oia->ia_ifa);
1023 break;
1024 }
1025 }
1026
1027 /*
1028 * Add an address to the list of IP multicast addresses for a given interface.
1029 */
1030 struct in_multi *
1031 in_addmulti(ap, ifp)
1032 struct in_addr *ap;
1033 struct ifnet *ifp;
1034 {
1035 struct in_multi *inm;
1036 struct ifreq ifr;
1037 struct in_ifaddr *ia;
1038 int s = splsoftnet();
1039
1040 /*
1041 * See if address already in list.
1042 */
1043 IN_LOOKUP_MULTI(*ap, ifp, inm);
1044 if (inm != NULL) {
1045 /*
1046 * Found it; just increment the reference count.
1047 */
1048 ++inm->inm_refcount;
1049 } else {
1050 /*
1051 * New address; allocate a new multicast record
1052 * and link it into the interface's multicast list.
1053 */
1054 inm = (struct in_multi *)malloc(sizeof(*inm),
1055 M_IPMADDR, M_NOWAIT);
1056 if (inm == NULL) {
1057 splx(s);
1058 return (NULL);
1059 }
1060 inm->inm_addr = *ap;
1061 inm->inm_ifp = ifp;
1062 inm->inm_refcount = 1;
1063 IFP_TO_IA(ifp, ia);
1064 if (ia == NULL) {
1065 free(inm, M_IPMADDR);
1066 splx(s);
1067 return (NULL);
1068 }
1069 inm->inm_ia = ia;
1070 IFAREF(&inm->inm_ia->ia_ifa);
1071 LIST_INSERT_HEAD(&ia->ia_multiaddrs, inm, inm_list);
1072 /*
1073 * Ask the network driver to update its multicast reception
1074 * filter appropriately for the new address.
1075 */
1076 satosin(&ifr.ifr_addr)->sin_len = sizeof(struct sockaddr_in);
1077 satosin(&ifr.ifr_addr)->sin_family = AF_INET;
1078 satosin(&ifr.ifr_addr)->sin_addr = *ap;
1079 if ((ifp->if_ioctl == NULL) ||
1080 (*ifp->if_ioctl)(ifp, SIOCADDMULTI,(caddr_t)&ifr) != 0) {
1081 LIST_REMOVE(inm, inm_list);
1082 free(inm, M_IPMADDR);
1083 splx(s);
1084 return (NULL);
1085 }
1086 /*
1087 * Let IGMP know that we have joined a new IP multicast group.
1088 */
1089 igmp_joingroup(inm);
1090 }
1091 splx(s);
1092 return (inm);
1093 }
1094
1095 /*
1096 * Delete a multicast address record.
1097 */
1098 void
1099 in_delmulti(inm)
1100 struct in_multi *inm;
1101 {
1102 struct ifreq ifr;
1103 int s = splsoftnet();
1104
1105 if (--inm->inm_refcount == 0) {
1106 /*
1107 * No remaining claims to this record; let IGMP know that
1108 * we are leaving the multicast group.
1109 */
1110 igmp_leavegroup(inm);
1111 /*
1112 * Unlink from list.
1113 */
1114 LIST_REMOVE(inm, inm_list);
1115 IFAFREE(&inm->inm_ia->ia_ifa);
1116 /*
1117 * Notify the network driver to update its multicast reception
1118 * filter.
1119 */
1120 satosin(&ifr.ifr_addr)->sin_family = AF_INET;
1121 satosin(&ifr.ifr_addr)->sin_addr = inm->inm_addr;
1122 (*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI,
1123 (caddr_t)&ifr);
1124 free(inm, M_IPMADDR);
1125 }
1126 splx(s);
1127 }
1128 #endif
1129