![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to if.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1980, 1986, 1993
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52: * SUCH DAMAGE.
53: *
54: * @(#)if.c 8.3 (Berkeley) 1/4/94
55: */
56:
57: /*
58: #include "opt_compat.h"
59: */
60:
61: #include <sys/param.h>
62: #include <sys/malloc.h>
63: #include <sys/mbuf.h>
64: #include <sys/systm.h>
65: #include <sys/proc.h>
66: #include <sys/socket.h>
67: #include <sys/socketvar.h>
68: #include <sys/protosw.h>
69: #include <sys/kernel.h>
70: #include <sys/sockio.h>
71: #include <sys/syslog.h>
72: #include <sys/sysctl.h>
73: #include <net/if.h>
74: #include <net/if_dl.h>
75: #include <net/radix.h>
76: #include <net/if_blue.h>
77: #include <netinet/in.h>
78: #include <net/dlil.h>
79:
80: /*
81: * System initialization
82: */
83:
84: static int ifconf __P((u_long, caddr_t));
85: static void if_qflush __P((struct ifqueue *));
86: static void link_rtrequest __P((int, struct rtentry *, struct sockaddr *));
87:
88: MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
89: MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
90:
91: int ifqmaxlen = IFQ_MAXLEN;
92: struct ifnethead ifnet; /* depend on static init XXX */
93:
94: /*
95: * Network interface utility routines.
96: *
97: * Routines with ifa_ifwith* names take sockaddr *'s as
98: * parameters.
99: *
100: * This routine assumes that it will be called at splimp() or higher.
101: */
102: /* ARGSUSED*/
103:
104:
105: int if_index = 0;
106: struct ifaddr **ifnet_addrs;
107:
108:
109: /*
110: * Attach an interface to the
111: * list of "active" interfaces.
112: */
113: void
114: old_if_attach(ifp)
115: struct ifnet *ifp;
116: {
117: unsigned socksize, ifasize;
118: int namelen, masklen;
119: char workbuf[64];
120: register struct sockaddr_dl *sdl;
121: register struct ifaddr *ifa;
122: static int if_indexlim = 8;
123:
124:
125: if (ifp->if_snd.ifq_maxlen == 0)
126: ifp->if_snd.ifq_maxlen = ifqmaxlen;
127:
128: TAILQ_INSERT_TAIL(&ifnet, ifp, if_link);
129: ifp->if_index = ++if_index;
130: /*
131: * XXX -
132: * The old code would work if the interface passed a pre-existing
133: * chain of ifaddrs to this code. We don't trust our callers to
134: * properly initialize the tailq, however, so we no longer allow
135: * this unlikely case.
136: */
137: TAILQ_INIT(&ifp->if_addrhead);
138: LIST_INIT(&ifp->if_multiaddrs);
139: getmicrotime(&ifp->if_lastchange);
140: if (ifnet_addrs == 0 || if_index >= if_indexlim) {
141: unsigned n = (if_indexlim <<= 1) * sizeof(ifa);
142: struct ifaddr **q = (struct ifaddr **)
143: _MALLOC(n, M_IFADDR, M_WAITOK);
144: bzero((caddr_t)q, n);
145: if (ifnet_addrs) {
146: bcopy((caddr_t)ifnet_addrs, (caddr_t)q, n/2);
147: FREE((caddr_t)ifnet_addrs, M_IFADDR);
148: }
149: ifnet_addrs = q;
150: }
151: /*
152: * create a Link Level name for this device
153: */
154: namelen = snprintf(workbuf, sizeof(workbuf),
155: "%s%d", ifp->if_name, ifp->if_unit);
156: #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m))
157: masklen = _offsetof(struct sockaddr_dl, sdl_data[0]) + namelen;
158: socksize = masklen + ifp->if_addrlen;
159: #define ROUNDUP(a) (1 + (((a) - 1) | (sizeof(long) - 1)))
160: if (socksize < sizeof(*sdl))
161: socksize = sizeof(*sdl);
162: socksize = ROUNDUP(socksize);
163: ifasize = sizeof(*ifa) + 2 * socksize;
164: ifa = (struct ifaddr *) _MALLOC(ifasize, M_IFADDR, M_WAITOK);
165: if (ifa) {
166: bzero((caddr_t)ifa, ifasize);
167: sdl = (struct sockaddr_dl *)(ifa + 1);
168: sdl->sdl_len = socksize;
169: sdl->sdl_family = AF_LINK;
170: bcopy(workbuf, sdl->sdl_data, namelen);
171: sdl->sdl_nlen = namelen;
172: sdl->sdl_index = ifp->if_index;
173: sdl->sdl_type = ifp->if_type;
174: ifnet_addrs[if_index - 1] = ifa;
175: ifa->ifa_ifp = ifp;
176: ifa->ifa_rtrequest = link_rtrequest;
177: ifa->ifa_addr = (struct sockaddr *)sdl;
178: sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
179: ifa->ifa_netmask = (struct sockaddr *)sdl;
180: sdl->sdl_len = masklen;
181: while (namelen != 0)
182: sdl->sdl_data[--namelen] = 0xff;
183: TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
184: }
185: }
186: /*
187: * Locate an interface based on a complete address.
188: */
189: /*ARGSUSED*/
190: struct ifaddr *
191: ifa_ifwithaddr(addr)
192: register struct sockaddr *addr;
193: {
194: register struct ifnet *ifp;
195: register struct ifaddr *ifa;
196:
197: #define equal(a1, a2) \
198: (bcmp((caddr_t)(a1), (caddr_t)(a2), ((struct sockaddr *)(a1))->sa_len) == 0)
199: for (ifp = ifnet.tqh_first; ifp; ifp = ifp->if_link.tqe_next)
200: for (ifa = ifp->if_addrhead.tqh_first; ifa;
201: ifa = ifa->ifa_link.tqe_next) {
202: if (ifa->ifa_addr->sa_family != addr->sa_family)
203: continue;
204: if (equal(addr, ifa->ifa_addr))
205: return (ifa);
206: if ((ifp->if_flags & IFF_BROADCAST) && ifa->ifa_broadaddr &&
207: equal(ifa->ifa_broadaddr, addr))
208: return (ifa);
209: }
210: return ((struct ifaddr *)0);
211: }
212: /*
213: * Locate the point to point interface with a given destination address.
214: */
215: /*ARGSUSED*/
216: struct ifaddr *
217: ifa_ifwithdstaddr(addr)
218: register struct sockaddr *addr;
219: {
220: register struct ifnet *ifp;
221: register struct ifaddr *ifa;
222:
223: for (ifp = ifnet.tqh_first; ifp; ifp = ifp->if_link.tqe_next)
224: if (ifp->if_flags & IFF_POINTOPOINT)
225: for (ifa = ifp->if_addrhead.tqh_first; ifa;
226: ifa = ifa->ifa_link.tqe_next) {
227: if (ifa->ifa_addr->sa_family != addr->sa_family)
228: continue;
229: if (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr))
230: return (ifa);
231: }
232: return ((struct ifaddr *)0);
233: }
234:
235: /*
236: * Find an interface on a specific network. If many, choice
237: * is most specific found.
238: */
239: struct ifaddr *
240: ifa_ifwithnet(addr)
241: struct sockaddr *addr;
242: {
243: register struct ifnet *ifp;
244: register struct ifaddr *ifa;
245: struct ifaddr *ifa_maybe = (struct ifaddr *) 0;
246: u_int af = addr->sa_family;
247: char *addr_data = addr->sa_data, *cplim;
248:
249: /*
250: * AF_LINK addresses can be looked up directly by their index number,
251: * so do that if we can.
252: */
253: if (af == AF_LINK) {
254: register struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr;
255: if (sdl->sdl_index && sdl->sdl_index <= if_index)
256: return (ifnet_addrs[sdl->sdl_index - 1]);
257: }
258:
259: /*
260: * Scan though each interface, looking for ones that have
261: * addresses in this address family.
262: */
263: for (ifp = ifnet.tqh_first; ifp; ifp = ifp->if_link.tqe_next) {
264: for (ifa = ifp->if_addrhead.tqh_first; ifa;
265: ifa = ifa->ifa_link.tqe_next) {
266: register char *cp, *cp2, *cp3;
267:
268: if (ifa->ifa_addr->sa_family != af)
269: next: continue;
270: if (ifp->if_flags & IFF_POINTOPOINT) {
271: /*
272: * This is a bit broken as it doesn't
273: * take into account that the remote end may
274: * be a single node in the network we are
275: * looking for.
276: * The trouble is that we don't know the
277: * netmask for the remote end.
278: */
279: if (ifa->ifa_dstaddr != 0
280: && equal(addr, ifa->ifa_dstaddr))
281: return (ifa);
282: } else {
283: /*
284: * if we have a special address handler,
285: * then use it instead of the generic one.
286: */
287: if (ifa->ifa_claim_addr) {
288: if ((*ifa->ifa_claim_addr)(ifa, addr)) {
289: return (ifa);
290: } else {
291: continue;
292: }
293: }
294:
295: /*
296: * Scan all the bits in the ifa's address.
297: * If a bit dissagrees with what we are
298: * looking for, mask it with the netmask
299: * to see if it really matters.
300: * (A byte at a time)
301: */
302: if (ifa->ifa_netmask == 0)
303: continue;
304: cp = addr_data;
305: cp2 = ifa->ifa_addr->sa_data;
306: cp3 = ifa->ifa_netmask->sa_data;
307: cplim = ifa->ifa_netmask->sa_len
308: + (char *)ifa->ifa_netmask;
309: while (cp3 < cplim)
310: if ((*cp++ ^ *cp2++) & *cp3++)
311: goto next; /* next address! */
312: /*
313: * If the netmask of what we just found
314: * is more specific than what we had before
315: * (if we had one) then remember the new one
316: * before continuing to search
317: * for an even better one.
318: */
319: if (ifa_maybe == 0 ||
320: rn_refines((caddr_t)ifa->ifa_netmask,
321: (caddr_t)ifa_maybe->ifa_netmask))
322: ifa_maybe = ifa;
323: }
324: }
325: }
326: return (ifa_maybe);
327: }
328:
329: /*
330: * Find an interface address specific to an interface best matching
331: * a given address.
332: */
333: struct ifaddr *
334: ifaof_ifpforaddr(addr, ifp)
335: struct sockaddr *addr;
336: register struct ifnet *ifp;
337: {
338: register struct ifaddr *ifa;
339: register char *cp, *cp2, *cp3;
340: register char *cplim;
341: struct ifaddr *ifa_maybe = 0;
342: u_int af = addr->sa_family;
343:
344: if (af >= AF_MAX)
345: return (0);
346: for (ifa = ifp->if_addrhead.tqh_first; ifa;
347: ifa = ifa->ifa_link.tqe_next) {
348: if (ifa->ifa_addr->sa_family != af)
349: continue;
350: if (ifa_maybe == 0)
351: ifa_maybe = ifa;
352: if (ifa->ifa_netmask == 0) {
353: if (equal(addr, ifa->ifa_addr) ||
354: (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr)))
355: return (ifa);
356: continue;
357: }
358: if (ifp->if_flags & IFF_POINTOPOINT) {
359: if (equal(addr, ifa->ifa_dstaddr))
360: return (ifa);
361: } else {
362: cp = addr->sa_data;
363: cp2 = ifa->ifa_addr->sa_data;
364: cp3 = ifa->ifa_netmask->sa_data;
365: cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
366: for (; cp3 < cplim; cp3++)
367: if ((*cp++ ^ *cp2++) & *cp3)
368: break;
369: if (cp3 == cplim)
370: return (ifa);
371: }
372: }
373: return (ifa_maybe);
374: }
375:
376: #include <net/route.h>
377:
378: /*
379: * Default action when installing a route with a Link Level gateway.
380: * Lookup an appropriate real ifa to point to.
381: * This should be moved to /sys/net/link.c eventually.
382: */
383: static void
384: link_rtrequest(cmd, rt, sa)
385: int cmd;
386: register struct rtentry *rt;
387: struct sockaddr *sa;
388: {
389: register struct ifaddr *ifa;
390: struct sockaddr *dst;
391: struct ifnet *ifp;
392:
393: if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == 0) ||
394: ((ifp = ifa->ifa_ifp) == 0) || ((dst = rt_key(rt)) == 0))
395: return;
396: ifa = ifaof_ifpforaddr(dst, ifp);
397: if (ifa) {
398: IFAFREE(rt->rt_ifa);
399: rt->rt_ifa = ifa;
400: ifa->ifa_refcnt++;
401: if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
402: ifa->ifa_rtrequest(cmd, rt, sa);
403: }
404: }
405:
406: /*
407: * Mark an interface down and notify protocols of
408: * the transition.
409: * NOTE: must be called at splnet or eqivalent.
410: */
411: void
412: if_unroute(ifp, flag, fam)
413: register struct ifnet *ifp;
414: int flag, fam;
415: {
416: register struct ifaddr *ifa;
417:
418: ifp->if_flags &= ~flag;
419: getmicrotime(&ifp->if_lastchange);
420: TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
421: if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
422: pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
423: if_qflush(&ifp->if_snd);
424: rt_ifmsg(ifp);
425: }
426:
427: /*
428: * Mark an interface up and notify protocols of
429: * the transition.
430: * NOTE: must be called at splnet or eqivalent.
431: */
432: void
433: if_route(ifp, flag, fam)
434: register struct ifnet *ifp;
435: int flag, fam;
436: {
437: register struct ifaddr *ifa;
438:
439: ifp->if_flags |= flag;
440: getmicrotime(&ifp->if_lastchange);
441: TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
442: if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
443: pfctlinput(PRC_IFUP, ifa->ifa_addr);
444: rt_ifmsg(ifp);
445: }
446:
447: /*
448: * Mark an interface down and notify protocols of
449: * the transition.
450: * NOTE: must be called at splnet or eqivalent.
451: */
452: void
453: if_down(ifp)
454: register struct ifnet *ifp;
455: {
456:
457: if_unroute(ifp, IFF_UP, AF_UNSPEC);
458: }
459:
460: /*
461: * Mark an interface up and notify protocols of
462: * the transition.
463: * NOTE: must be called at splnet or eqivalent.
464: */
465: void
466: if_up(ifp)
467: register struct ifnet *ifp;
468: {
469:
470: if_route(ifp, IFF_UP, AF_UNSPEC);
471: }
472:
473: /*
474: * Flush an interface queue.
475: */
476: static void
477: if_qflush(ifq)
478: register struct ifqueue *ifq;
479: {
480: register struct mbuf *m, *n;
481:
482: n = ifq->ifq_head;
483: while ((m = n) != 0) {
484: n = m->m_act;
485: m_freem(m);
486: }
487: ifq->ifq_head = 0;
488: ifq->ifq_tail = 0;
489: ifq->ifq_len = 0;
490: }
491:
492:
493: /*
494: * Map interface name to
495: * interface structure pointer.
496: */
497: struct ifnet *
498: ifunit(name)
499: register char *name;
500: {
501: char namebuf[IFNAMSIZ + 1];
502: register char *cp, *cp2;
503: char *end;
504: register struct ifnet *ifp;
505: int unit;
506: unsigned len;
507: register char c = '\0';
508:
509: /*
510: * Look for a non numeric part
511: */
512: end = name + IFNAMSIZ;
513: cp2 = namebuf;
514: cp = name;
515: while ((cp < end) && (c = *cp)) {
516: if (c >= '0' && c <= '9')
517: break;
518: *cp2++ = c;
519: cp++;
520: }
521: if ((cp == end) || (c == '\0') || (cp == name))
522: return ((struct ifnet *)0);
523: *cp2 = '\0';
524: /*
525: * check we have a legal number (limit to 7 digits?)
526: */
527: len = cp - name + 1;
528: for (unit = 0;
529: ((c = *cp) >= '0') && (c <= '9') && (unit < 1000000); cp++ )
530: unit = (unit * 10) + (c - '0');
531: if (*cp != '\0')
532: return 0; /* no trailing garbage allowed */
533: /*
534: * Now search all the interfaces for this name/number
535: */
536: for (ifp = ifnet.tqh_first; ifp; ifp = ifp->if_link.tqe_next) {
537: if (bcmp(ifp->if_name, namebuf, len))
538: continue;
539: if (unit == ifp->if_unit)
540: break;
541: }
542: return (ifp);
543: }
544:
545: /*
546: * Interface ioctls.
547: */
548: int
549: ifioctl(so, cmd, data, p)
550: struct socket *so;
551: u_long cmd;
552: caddr_t data;
553: struct proc *p;
554: {
555: register struct ifnet *ifp;
556: register struct ifreq *ifr;
557: int error;
558: extern int new_splitter(struct socket *);
559: void if_register(struct BlueFilter *);
560:
561: switch (cmd) {
562:
563: case SIOCGIFCONF:
564: case OSIOCGIFCONF:
565: return (ifconf(cmd, data));
566: }
567: ifr = (struct ifreq *)data;
568: ifp = ifunit(ifr->ifr_name);
569: if (ifp == 0)
570: return (ENXIO);
571: switch (cmd) {
572:
573: case SIOCSSPLITTER:
574: if ((error = new_splitter(so)))
575: return(error);
576: break;
577:
578: case SIOCGSPLITTER:
579: ifr->ifr_data = (caddr_t)(ifp->if_flags & IFF_SPLITTER);
580: break;
581:
582: case SIOCGIFFLAGS:
583: ifr->ifr_flags = ifp->if_flags;
584: break;
585:
586: case SIOCGIFMETRIC:
587: ifr->ifr_metric = ifp->if_metric;
588: break;
589:
590: case SIOCGIFMTU:
591: ifr->ifr_mtu = ifp->if_mtu;
592: break;
593:
594: case SIOCGIFPHYS:
595: ifr->ifr_phys = ifp->if_physical;
596: break;
597:
598: case SIOCSIFFLAGS:
599: error = suser(p->p_ucred, &p->p_acflag);
600: if (error)
601: return (error);
602: if (ifp->if_flags & IFF_UP && (ifr->ifr_flags & IFF_UP) == 0) {
603: int s = splimp();
604: if_down(ifp);
605: splx(s);
606: }
607: if (ifr->ifr_flags & IFF_UP && (ifp->if_flags & IFF_UP) == 0) {
608: int s = splimp();
609: if_up(ifp);
610: splx(s);
611: }
612: ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
613: (ifr->ifr_flags &~ IFF_CANTCHANGE);
614: if (ifp->if_ioctl)
615: dlil_ioctl(0, ifp, cmd, (caddr_t) data);
616: getmicrotime(&ifp->if_lastchange);
617: break;
618:
619: case SIOCSIFMETRIC:
620: error = suser(p->p_ucred, &p->p_acflag);
621: if (error)
622: return (error);
623: ifp->if_metric = ifr->ifr_metric;
624: getmicrotime(&ifp->if_lastchange);
625: break;
626:
627: case SIOCSIFPHYS:
628: error = suser(p->p_ucred, &p->p_acflag);
629: if (error)
630: return error;
631: if (!ifp->if_ioctl)
632: return EOPNOTSUPP;
633: error = dlil_ioctl(0, ifp, cmd, (caddr_t) data);
634: if (error == 0)
635: getmicrotime(&ifp->if_lastchange);
636: return(error);
637:
638: case SIOCSIFMTU:
639: error = suser(p->p_ucred, &p->p_acflag);
640: if (error)
641: return (error);
642: if (ifp->if_ioctl == NULL)
643: return (EOPNOTSUPP);
644: /*
645: * 72 was chosen below because it is the size of a TCP/IP
646: * header (40) + the minimum mss (32).
647: */
648: if (ifr->ifr_mtu < 72 || ifr->ifr_mtu > 65535)
649: return (EINVAL);
650: error = dlil_ioctl(0, ifp, cmd, (caddr_t) data);
651: if (error == 0)
652: getmicrotime(&ifp->if_lastchange);
653: return(error);
654:
655: case SIOCADDMULTI:
656: case SIOCDELMULTI:
657: error = suser(p->p_ucred, &p->p_acflag);
658: if (error)
659: return (error);
660:
661: /* Don't allow group membership on non-multicast interfaces. */
662: if ((ifp->if_flags & IFF_MULTICAST) == 0)
663: return EOPNOTSUPP;
664:
665: #if 0
666: /*
667: * Don't let users change protocols' entries.
668: */
669: if (ifr->ifr_addr.sa_family != AF_LINK)
670: return EINVAL;
671: #endif
672: if (cmd == SIOCADDMULTI) {
673: struct ifmultiaddr *ifma;
674: error = if_addmulti(ifp, &ifr->ifr_addr, &ifma);
675: } else {
676: error = if_delmulti(ifp, &ifr->ifr_addr);
677: }
678: if (error == 0)
679: getmicrotime(&ifp->if_lastchange);
680: return error;
681:
682: case SIOCSIFMEDIA:
683: case SIOCSIFGENERIC:
684: error = suser(p->p_ucred, &p->p_acflag);
685: if (error)
686: return (error);
687: if (ifp->if_ioctl == 0)
688: return (EOPNOTSUPP);
689: error = dlil_ioctl(0, ifp, cmd, (caddr_t) data);
690: if (error == 0)
691: getmicrotime(&ifp->if_lastchange);
692: return error;
693:
694: case SIOCGIFMEDIA:
695: case SIOCGIFGENERIC:
696: if (ifp->if_ioctl == 0)
697: return (EOPNOTSUPP);
698: return dlil_ioctl(0, ifp, cmd, (caddr_t) data);
699:
700: default:
701: if (so->so_proto == 0)
702: return (EOPNOTSUPP);
703: #if !COMPAT_43
704: return ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd,
705: data,
706: ifp, p));
707: #else
708: {
709: int ocmd = cmd;
710:
711: switch (cmd) {
712:
713: case SIOCSIFDSTADDR:
714: case SIOCSIFADDR:
715: case SIOCSIFBRDADDR:
716: case SIOCSIFNETMASK:
717: #if BYTE_ORDER != BIG_ENDIAN
718: if (ifr->ifr_addr.sa_family == 0 &&
719: ifr->ifr_addr.sa_len < 16) {
720: ifr->ifr_addr.sa_family = ifr->ifr_addr.sa_len;
721: ifr->ifr_addr.sa_len = 16;
722: }
723: #else
724: if (ifr->ifr_addr.sa_len == 0)
725: ifr->ifr_addr.sa_len = 16;
726: #endif
727: #define IFR2IN(ifr) ((struct in_addr *)&(ifr->ifr_addr))->s_addr
728: if (ifr->ifr_addr.sa_family == AF_INET)
729: { /*
730: * If we have an address, and we're 'splitting',
731: * register the address. Note that this
732: * is to handle the case of addresses
733: * registered after the Blue Box starts.
734: */
735: if ((ifp->if_flags & IFF_SPLITTER) &&
736: (IFR2IN(ifr) != 0))
737: { struct BlueFilter filter;
738:
739: filter.BF_flags = (BF_ALLOC|BF_IP);
740: filter.BF_address = IFR2IN(ifr);
741: log(LOG_WARNING,
742: "[2]IP registering %x",
743: filter.BF_address);
744: if_register(&filter);
745: }
746: }
747: /* Fall through! */
748: break;
749:
750: case OSIOCGIFADDR:
751: cmd = SIOCGIFADDR;
752: break;
753:
754: case OSIOCGIFDSTADDR:
755: cmd = SIOCGIFDSTADDR;
756: break;
757:
758: case OSIOCGIFBRDADDR:
759: cmd = SIOCGIFBRDADDR;
760: break;
761:
762: case OSIOCGIFNETMASK:
763: cmd = SIOCGIFNETMASK;
764: }
765: error = ((*so->so_proto->pr_usrreqs->pru_control)(so,
766: cmd,
767: data,
768: ifp, p));
769: switch (ocmd) {
770:
771: case OSIOCGIFADDR:
772: case OSIOCGIFDSTADDR:
773: case OSIOCGIFBRDADDR:
774: case OSIOCGIFNETMASK:
775: *(u_short *)&ifr->ifr_addr = ifr->ifr_addr.sa_family;
776: }
777: return (error);
778:
779: }
780: #endif
781: }
782: return (0);
783: }
784:
785: /*
786: * Set/clear promiscuous mode on interface ifp based on the truth value
787: * of pswitch. The calls are reference counted so that only the first
788: * "on" request actually has an effect, as does the final "off" request.
789: * Results are undefined if the "off" and "on" requests are not matched.
790: */
791: int
792: ifpromisc(ifp, pswitch)
793: struct ifnet *ifp;
794: int pswitch;
795: {
796: struct ifreq ifr;
797: int error;
798:
799: if (pswitch) {
800: /*
801: * If the device is not configured up, we cannot put it in
802: * promiscuous mode.
803: */
804: if ((ifp->if_flags & IFF_UP) == 0)
805: return (ENETDOWN);
806: if (ifp->if_pcount++ != 0)
807: return (0);
808: ifp->if_flags |= IFF_PROMISC;
809: log(LOG_INFO, "%s%d: promiscuous mode enabled\n",
810: ifp->if_name, ifp->if_unit);
811: } else {
812: if (--ifp->if_pcount > 0)
813: return (0);
814: ifp->if_flags &= ~IFF_PROMISC;
815: }
816: ifr.ifr_flags = ifp->if_flags;
817: error = dlil_ioctl(0, ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
818: if (error == 0)
819: rt_ifmsg(ifp);
820: return error;
821: }
822:
823: /*
824: * Return interface configuration
825: * of system. List may be used
826: * in later ioctl's (above) to get
827: * other information.
828: */
829: /*ARGSUSED*/
830: static int
831: ifconf(cmd, data)
832: u_long cmd;
833: caddr_t data;
834: {
835: register struct ifconf *ifc = (struct ifconf *)data;
836: register struct ifnet *ifp = ifnet.tqh_first;
837: register struct ifaddr *ifa;
838: struct ifreq ifr, *ifrp;
839: int space = ifc->ifc_len, error = 0;
840:
841: ifrp = ifc->ifc_req;
842: for (; space > sizeof (ifr) && ifp; ifp = ifp->if_link.tqe_next) {
843: char workbuf[64];
844: int ifnlen;
845:
846: ifnlen = snprintf(workbuf, sizeof(workbuf),
847: "%s%d", ifp->if_name, ifp->if_unit);
848: if(ifnlen + 1 > sizeof ifr.ifr_name) {
849: error = ENAMETOOLONG;
850: } else {
851: strcpy(ifr.ifr_name, workbuf);
852: }
853:
854: if ((ifa = ifp->if_addrhead.tqh_first) == 0) {
855: bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
856: error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
857: sizeof (ifr));
858: if (error)
859: break;
860: space -= sizeof (ifr), ifrp++;
861: } else
862: for ( ; space > sizeof (ifr) && ifa;
863: ifa = ifa->ifa_link.tqe_next) {
864: register struct sockaddr *sa = ifa->ifa_addr;
865: #if COMPAT_43
866: if (cmd == OSIOCGIFCONF) {
867: struct osockaddr *osa =
868: (struct osockaddr *)&ifr.ifr_addr;
869: ifr.ifr_addr = *sa;
870: osa->sa_family = sa->sa_family;
871: error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
872: sizeof (ifr));
873: ifrp++;
874: } else
875: #endif
876: if (sa->sa_len <= sizeof(*sa)) {
877: ifr.ifr_addr = *sa;
878: error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
879: sizeof (ifr));
880: ifrp++;
881: } else {
882: space -= sa->sa_len - sizeof(*sa);
883: if (space < sizeof (ifr))
884: break;
885: error = copyout((caddr_t)&ifr, (caddr_t)ifrp,
886: sizeof (ifr.ifr_name));
887: if (error == 0)
888: error = copyout((caddr_t)sa,
889: (caddr_t)&ifrp->ifr_addr, sa->sa_len);
890: ifrp = (struct ifreq *)
891: (sa->sa_len + (caddr_t)&ifrp->ifr_addr);
892: }
893: if (error)
894: break;
895: space -= sizeof (ifr);
896: }
897: }
898: ifc->ifc_len -= space;
899: return (error);
900: }
901:
902: /*
903: * Just like if_promisc(), but for all-multicast-reception mode.
904: */
905: int
906: if_allmulti(ifp, onswitch)
907: struct ifnet *ifp;
908: int onswitch;
909: {
910: int error = 0;
911: int s = splimp();
912:
913: if (onswitch) {
914: if (ifp->if_amcount++ == 0) {
915: ifp->if_flags |= IFF_ALLMULTI;
916: error = dlil_ioctl(0, ifp, SIOCSIFFLAGS, (caddr_t) 0);
917: }
918: } else {
919: if (ifp->if_amcount > 1) {
920: ifp->if_amcount--;
921: } else {
922: ifp->if_amcount = 0;
923: ifp->if_flags &= ~IFF_ALLMULTI;
924: error = dlil_ioctl(0, ifp, SIOCSIFFLAGS, (caddr_t) 0);
925: }
926: }
927: splx(s);
928:
929: if (error == 0)
930: rt_ifmsg(ifp);
931: return error;
932: }
933:
934: /*
935: * Add a multicast listenership to the interface in question.
936: * The link layer provides a routine which converts
937: */
938: int
939: if_addmulti(ifp, sa, retifma)
940: struct ifnet *ifp; /* interface to manipulate */
941: struct sockaddr *sa; /* address to add */
942: struct ifmultiaddr **retifma;
943: {
944: struct sockaddr *llsa, *dupsa;
945: int error, s;
946: struct ifmultiaddr *ifma;
947:
948: /*
949: * If the matching multicast address already exists
950: * then don't add a new one, just add a reference
951: */
952: for (ifma = ifp->if_multiaddrs.lh_first; ifma;
953: ifma = ifma->ifma_link.le_next) {
954: if (equal(sa, ifma->ifma_addr)) {
955: ifma->ifma_refcount++;
956: if (retifma)
957: *retifma = ifma;
958: return 0;
959: }
960: }
961:
962: /*
963: * Give the link layer a chance to accept/reject it, and also
964: * find out which AF_LINK address this maps to, if it isn't one
965: * already.
966: */
967: if (ifp->if_resolvemulti) {
968: error = ifp->if_resolvemulti(ifp, &llsa, sa);
969: if (error) return error;
970: } else {
971: llsa = 0;
972: }
973:
974: MALLOC(ifma, struct ifmultiaddr *, sizeof *ifma, M_IFMADDR, M_WAITOK);
975: MALLOC(dupsa, struct sockaddr *, sa->sa_len, M_IFMADDR, M_WAITOK);
976: bcopy(sa, dupsa, sa->sa_len);
977:
978: ifma->ifma_addr = dupsa;
979: ifma->ifma_lladdr = llsa;
980: ifma->ifma_ifp = ifp;
981: ifma->ifma_refcount = 1;
982: ifma->ifma_protospec = 0;
983: rt_newmaddrmsg(RTM_NEWMADDR, ifma);
984:
985: /*
986: * Some network interfaces can scan the address list at
987: * interrupt time; lock them out.
988: */
989: s = splimp();
990: LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
991: splx(s);
992: if (retifma)
993: *retifma = ifma;
994:
995: if (llsa != 0) {
996: for (ifma = ifp->if_multiaddrs.lh_first; ifma;
997: ifma = ifma->ifma_link.le_next) {
998: if (equal(ifma->ifma_addr, llsa))
999: break;
1000: }
1001: if (ifma) {
1002: ifma->ifma_refcount++;
1003: } else {
1004: MALLOC(ifma, struct ifmultiaddr *, sizeof *ifma,
1005: M_IFMADDR, M_WAITOK);
1006: MALLOC(dupsa, struct sockaddr *, llsa->sa_len,
1007: M_IFMADDR, M_WAITOK);
1008: bcopy(llsa, dupsa, llsa->sa_len);
1009: ifma->ifma_addr = dupsa;
1010: ifma->ifma_ifp = ifp;
1011: ifma->ifma_refcount = 1;
1012: s = splimp();
1013: LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
1014: splx(s);
1015: }
1016: }
1017: /*
1018: * We are certain we have added something, so call down to the
1019: * interface to let them know about it.
1020: */
1021: s = splimp();
1022:
1023: dlil_ioctl(0, ifp, SIOCADDMULTI, (caddr_t) 0);
1024: splx(s);
1025:
1026: return 0;
1027: }
1028:
1029: /*
1030: * Remove a reference to a multicast address on this interface. Yell
1031: * if the request does not match an existing membership.
1032: */
1033: int
1034: if_delmulti(ifp, sa)
1035: struct ifnet *ifp;
1036: struct sockaddr *sa;
1037: {
1038: struct ifmultiaddr *ifma;
1039: int s;
1040:
1041: for (ifma = ifp->if_multiaddrs.lh_first; ifma;
1042: ifma = ifma->ifma_link.le_next)
1043: if (equal(sa, ifma->ifma_addr))
1044: break;
1045: if (ifma == 0)
1046: return ENOENT;
1047:
1048: if (ifma->ifma_refcount > 1) {
1049: ifma->ifma_refcount--;
1050: return 0;
1051: }
1052:
1053: rt_newmaddrmsg(RTM_DELMADDR, ifma);
1054: sa = ifma->ifma_lladdr;
1055: s = splimp();
1056: LIST_REMOVE(ifma, ifma_link);
1057: splx(s);
1058: FREE(ifma->ifma_addr, M_IFMADDR);
1059: FREE(ifma, M_IFMADDR);
1060: if (sa == 0)
1061: return 0;
1062:
1063: /*
1064: * Now look for the link-layer address which corresponds to
1065: * this network address. It had been squirreled away in
1066: * ifma->ifma_lladdr for this purpose (so we don't have
1067: * to call ifp->if_resolvemulti() again), and we saved that
1068: * value in sa above. If some nasty deleted the
1069: * link-layer address out from underneath us, we can deal because
1070: * the address we stored was is not the same as the one which was
1071: * in the record for the link-layer address. (So we don't complain
1072: * in that case.)
1073: */
1074: for (ifma = ifp->if_multiaddrs.lh_first; ifma;
1075: ifma = ifma->ifma_link.le_next)
1076: if (equal(sa, ifma->ifma_addr))
1077: break;
1078: if (ifma == 0)
1079: return 0;
1080:
1081: if (ifma->ifma_refcount > 1) {
1082: ifma->ifma_refcount--;
1083: return 0;
1084: }
1085:
1086: s = splimp();
1087: LIST_REMOVE(ifma, ifma_link);
1088: dlil_ioctl(0, ifp, SIOCDELMULTI, (caddr_t) 0);
1089: splx(s);
1090: FREE(ifma->ifma_addr, M_IFMADDR);
1091: FREE(sa, M_IFMADDR);
1092: FREE(ifma, M_IFMADDR);
1093:
1094: return 0;
1095: }
1096:
1097: struct ifmultiaddr *
1098: ifmaof_ifpforaddr(sa, ifp)
1099: struct sockaddr *sa;
1100: struct ifnet *ifp;
1101: {
1102: struct ifmultiaddr *ifma;
1103:
1104: for (ifma = ifp->if_multiaddrs.lh_first; ifma;
1105: ifma = ifma->ifma_link.le_next)
1106: if (equal(ifma->ifma_addr, sa))
1107: break;
1108:
1109: return ifma;
1110: }
1111:
1112: SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW, 0, "Link layers");
1113: SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW, 0, "Generic link-management");
1114:
1115:
1116: /*
1117: * Shutdown all network activity. Used boot() when halting
1118: * system.
1119: */
1120: int if_down_all(void)
1121: {
1122: struct ifnet *ifp;
1123: int s;
1124:
1125: s = splnet();
1126: TAILQ_FOREACH(ifp, &ifnet, if_link)
1127: if_down(ifp);
1128:
1129: splx(s);
1130: return(0); /* Sheesh */
1131: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.