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