Annotation of sys/net/if_vlan.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_vlan.c,v 1.70 2007/06/06 14:05:58 henning Exp $ */
2:
3: /*
4: * Copyright 1998 Massachusetts Institute of Technology
5: *
6: * Permission to use, copy, modify, and distribute this software and
7: * its documentation for any purpose and without fee is hereby
8: * granted, provided that both the above copyright notice and this
9: * permission notice appear in all copies, that both the above
10: * copyright notice and this permission notice appear in all
11: * supporting documentation, and that the name of M.I.T. not be used
12: * in advertising or publicity pertaining to distribution of the
13: * software without specific, written prior permission. M.I.T. makes
14: * no representations about the suitability of this software for any
15: * purpose. It is provided "as is" without express or implied
16: * warranty.
17: *
18: * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS
19: * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
20: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
22: * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
25: * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26: * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
28: * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29: * SUCH DAMAGE.
30: *
31: * $FreeBSD: src/sys/net/if_vlan.c,v 1.16 2000/03/26 15:21:40 charnier Exp $
32: */
33:
34: /*
35: * if_vlan.c - pseudo-device driver for IEEE 802.1Q virtual LANs.
36: * Might be extended some day to also handle IEEE 802.1p priority
37: * tagging. This is sort of sneaky in the implementation, since
38: * we need to pretend to be enough of an Ethernet implementation
39: * to make arp work. The way we do this is by telling everyone
40: * that we are an Ethernet, and then catch the packets that
41: * ether_output() left on our output queue when it calls
42: * if_start(), rewrite them for use by the real outgoing interface,
43: * and ask it to send them.
44: *
45: * Some devices support 802.1Q tag insertion in firmware. The
46: * vlan interface behavior changes when the IFCAP_VLAN_HWTAGGING
47: * capability is set on the parent. In this case, vlan_start()
48: * will not modify the ethernet header.
49: */
50:
51: #include "vlan.h"
52:
53: #include <sys/param.h>
54: #include <sys/kernel.h>
55: #include <sys/malloc.h>
56: #include <sys/mbuf.h>
57: #include <sys/queue.h>
58: #include <sys/socket.h>
59: #include <sys/sockio.h>
60: #include <sys/sysctl.h>
61: #include <sys/systm.h>
62: #include <sys/proc.h>
63:
64: #include "bpfilter.h"
65: #if NBPFILTER > 0
66: #include <net/bpf.h>
67: #endif
68:
69: #include <net/if.h>
70: #include <net/if_dl.h>
71: #include <net/if_types.h>
72:
73: #ifdef INET
74: #include <netinet/in.h>
75: #include <netinet/if_ether.h>
76: #endif
77:
78: #include <net/if_vlan_var.h>
79:
80: extern struct ifaddr **ifnet_addrs;
81: u_long vlan_tagmask;
82:
83: #define TAG_HASH_SIZE 32
84: #define TAG_HASH(tag) (tag & vlan_tagmask)
85: LIST_HEAD(, ifvlan) *vlan_tagh;
86:
87: void vlan_start (struct ifnet *ifp);
88: int vlan_ioctl (struct ifnet *ifp, u_long cmd, caddr_t addr);
89: int vlan_unconfig (struct ifnet *ifp);
90: int vlan_config (struct ifvlan *, struct ifnet *, u_int16_t);
91: void vlan_vlandev_state(void *);
92: void vlanattach (int count);
93: int vlan_set_promisc (struct ifnet *ifp);
94: int vlan_ether_addmulti(struct ifvlan *, struct ifreq *);
95: int vlan_ether_delmulti(struct ifvlan *, struct ifreq *);
96: void vlan_ether_purgemulti(struct ifvlan *);
97: int vlan_clone_create(struct if_clone *, int);
98: int vlan_clone_destroy(struct ifnet *);
99: void vlan_ifdetach(void *);
100:
101: struct if_clone vlan_cloner =
102: IF_CLONE_INITIALIZER("vlan", vlan_clone_create, vlan_clone_destroy);
103:
104: /* ARGSUSED */
105: void
106: vlanattach(int count)
107: {
108: vlan_tagh = hashinit(TAG_HASH_SIZE, M_DEVBUF, M_NOWAIT, &vlan_tagmask);
109: if (vlan_tagh == NULL)
110: panic("vlanattach: hashinit");
111:
112: if_clone_attach(&vlan_cloner);
113: }
114:
115: int
116: vlan_clone_create(struct if_clone *ifc, int unit)
117: {
118: struct ifvlan *ifv;
119: struct ifnet *ifp;
120:
121: ifv = malloc(sizeof(*ifv), M_DEVBUF, M_NOWAIT);
122: if (!ifv)
123: return (ENOMEM);
124: bzero(ifv, sizeof(*ifv));
125:
126: LIST_INIT(&ifv->vlan_mc_listhead);
127: ifp = &ifv->ifv_if;
128: ifp->if_softc = ifv;
129: snprintf(ifp->if_xname, sizeof ifp->if_xname, "%s%d", ifc->ifc_name,
130: unit);
131: /* NB: flags are not set here */
132: /* NB: mtu is not set here */
133:
134: ifp->if_start = vlan_start;
135: ifp->if_ioctl = vlan_ioctl;
136: ifp->if_output = ether_output;
137: IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
138: IFQ_SET_READY(&ifp->if_snd);
139: if_attach(ifp);
140: ether_ifattach(ifp);
141: /* Now undo some of the damage... */
142: ifp->if_type = IFT_L2VLAN;
143: ifp->if_hdrlen = EVL_ENCAPLEN;
144:
145: return (0);
146: }
147:
148: int
149: vlan_clone_destroy(struct ifnet *ifp)
150: {
151: struct ifvlan *ifv = ifp->if_softc;
152:
153: vlan_unconfig(ifp);
154: ether_ifdetach(ifp);
155: if_detach(ifp);
156:
157: free(ifv, M_DEVBUF);
158: return (0);
159: }
160:
161: void
162: vlan_ifdetach(void *ptr)
163: {
164: struct ifvlan *ifv = (struct ifvlan *)ptr;
165: /*
166: * Destroy the vlan interface because the parent has been
167: * detached. Set the dh_cookie to NULL because we're running
168: * inside of dohooks which is told to disestablish the hook
169: * for us (otherwise we would kill the TAILQ element...).
170: */
171: ifv->dh_cookie = NULL;
172: vlan_clone_destroy(&ifv->ifv_if);
173: }
174:
175: void
176: vlan_start(struct ifnet *ifp)
177: {
178: struct ifvlan *ifv;
179: struct ifnet *p;
180: struct mbuf *m;
181: int error;
182:
183: ifv = ifp->if_softc;
184: p = ifv->ifv_p;
185:
186: ifp->if_flags |= IFF_OACTIVE;
187: for (;;) {
188: IFQ_DEQUEUE(&ifp->if_snd, m);
189: if (m == NULL)
190: break;
191:
192: if ((p->if_flags & (IFF_UP|IFF_RUNNING)) !=
193: (IFF_UP|IFF_RUNNING)) {
194: IF_DROP(&p->if_snd);
195: /* XXX stats */
196: ifp->if_oerrors++;
197: m_freem(m);
198: continue;
199: }
200:
201: #if NBPFILTER > 0
202: if (ifp->if_bpf)
203: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
204: #endif
205:
206: /*
207: * If the IFCAP_VLAN_HWTAGGING capability is set on the parent,
208: * it can do VLAN tag insertion itself and doesn't require us
209: * to create a special header for it. In this case, we just pass
210: * the packet along. However, we need some way to tell the
211: * interface where the packet came from so that it knows how
212: * to find the VLAN tag to use, so we set the rcvif in the
213: * mbuf header to our ifnet.
214: *
215: * Note: we also set the M_PROTO1 flag in the mbuf to let
216: * the parent driver know that the rcvif pointer is really
217: * valid. We need to do this because sometimes mbufs will
218: * be allocated by other parts of the system that contain
219: * garbage in the rcvif pointer. Using the M_PROTO1 flag
220: * lets the driver perform a proper sanity check and avoid
221: * following potentially bogus rcvif pointers off into
222: * never-never land.
223: */
224: if (p->if_capabilities & IFCAP_VLAN_HWTAGGING) {
225: m->m_pkthdr.rcvif = ifp;
226: m->m_flags |= M_PROTO1;
227: } else {
228: struct ether_vlan_header evh;
229:
230: m_copydata(m, 0, ETHER_HDR_LEN, (caddr_t)&evh);
231: evh.evl_proto = evh.evl_encap_proto;
232: evh.evl_encap_proto = htons(ETHERTYPE_VLAN);
233: evh.evl_tag = htons(ifv->ifv_tag +
234: (ifv->ifv_prio << EVL_PRIO_BITS));
235:
236: m_adj(m, ETHER_HDR_LEN);
237: M_PREPEND(m, sizeof(evh), M_DONTWAIT);
238: if (m == NULL) {
239: ifp->if_oerrors++;
240: continue;
241: }
242:
243: m_copyback(m, 0, sizeof(evh), &evh);
244: }
245:
246: /*
247: * Send it, precisely as ether_output() would have.
248: * We are already running at splnet.
249: */
250: p->if_obytes += m->m_pkthdr.len;
251: if (m->m_flags & M_MCAST)
252: p->if_omcasts++;
253: IFQ_ENQUEUE(&p->if_snd, m, NULL, error);
254: if (error) {
255: /* mbuf is already freed */
256: ifp->if_oerrors++;
257: continue;
258: }
259:
260: ifp->if_opackets++;
261: if ((p->if_flags & (IFF_RUNNING|IFF_OACTIVE)) == IFF_RUNNING)
262: p->if_start(p);
263: }
264: ifp->if_flags &= ~IFF_OACTIVE;
265:
266: return;
267: }
268:
269: /*
270: * vlan_input() returns 0 if it has consumed the packet, 1 otherwise.
271: */
272: int
273: vlan_input(eh, m)
274: struct ether_header *eh;
275: struct mbuf *m;
276: {
277: struct ifvlan *ifv;
278: u_int tag;
279: struct ifnet *ifp = m->m_pkthdr.rcvif;
280:
281: if (m->m_len < EVL_ENCAPLEN &&
282: (m = m_pullup(m, EVL_ENCAPLEN)) == NULL) {
283: ifp->if_ierrors++;
284: return (0);
285: }
286:
287: tag = EVL_VLANOFTAG(ntohs(*mtod(m, u_int16_t *)));
288:
289: LIST_FOREACH(ifv, &vlan_tagh[TAG_HASH(tag)], ifv_list) {
290: if (m->m_pkthdr.rcvif == ifv->ifv_p && tag == ifv->ifv_tag)
291: break;
292: }
293: if (ifv == NULL)
294: return (1);
295:
296: if ((ifv->ifv_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
297: (IFF_UP|IFF_RUNNING)) {
298: m_freem(m);
299: return (0);
300: }
301:
302: /*
303: * Having found a valid vlan interface corresponding to
304: * the given source interface and vlan tag, remove the
305: * encapsulation, and run the real packet through
306: * ether_input() a second time (it had better be
307: * reentrant!).
308: */
309: m->m_pkthdr.rcvif = &ifv->ifv_if;
310: eh->ether_type = mtod(m, u_int16_t *)[1];
311: m->m_len -= EVL_ENCAPLEN;
312: m->m_data += EVL_ENCAPLEN;
313: m->m_pkthdr.len -= EVL_ENCAPLEN;
314:
315: #if NBPFILTER > 0
316: if (ifv->ifv_if.if_bpf)
317: bpf_mtap_hdr(ifv->ifv_if.if_bpf, (char *)eh, ETHER_HDR_LEN,
318: m, BPF_DIRECTION_IN);
319: #endif
320: ifv->ifv_if.if_ipackets++;
321: ether_input(&ifv->ifv_if, eh, m);
322:
323: return (0);
324: }
325:
326: int
327: vlan_config(struct ifvlan *ifv, struct ifnet *p, u_int16_t tag)
328: {
329: struct ifaddr *ifa1, *ifa2;
330: struct sockaddr_dl *sdl1, *sdl2;
331: int s;
332:
333: if (p->if_type != IFT_ETHER)
334: return EPROTONOSUPPORT;
335: if (ifv->ifv_p == p && ifv->ifv_tag == tag) /* noop */
336: return (0);
337: if (ifv->ifv_p)
338: return EBUSY;
339:
340: ifv->ifv_p = p;
341:
342: if (p->if_capabilities & IFCAP_VLAN_MTU)
343: ifv->ifv_if.if_mtu = p->if_mtu;
344: else {
345: /*
346: * This will be incompatible with strict
347: * 802.1Q implementations
348: */
349: ifv->ifv_if.if_mtu = p->if_mtu - EVL_ENCAPLEN;
350: #ifdef DIAGNOSTIC
351: printf("%s: initialized with non-standard mtu %lu (parent %s)\n",
352: ifv->ifv_if.if_xname, ifv->ifv_if.if_mtu,
353: ifv->ifv_p->if_xname);
354: #endif
355: }
356:
357: ifv->ifv_if.if_flags = p->if_flags &
358: (IFF_UP | IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
359:
360: /*
361: * Inherit the if_type from the parent. This allows us to
362: * participate in bridges of that type.
363: */
364: ifv->ifv_if.if_type = p->if_type;
365:
366: /*
367: * Inherit baudrate from the parent. An SNMP agent would use this
368: * information.
369: */
370: ifv->ifv_if.if_baudrate = p->if_baudrate;
371:
372: /*
373: * If the parent interface can do hardware-assisted
374: * VLAN encapsulation, then propagate its hardware-
375: * assisted checksumming flags.
376: *
377: * If the card cannot handle hardware tagging, it cannot
378: * possibly compute the correct checksums for tagged packets.
379: *
380: * This brings up another possibility, do cards exist which
381: * have all of these capabilities but cannot utilize them together?
382: */
383: if (p->if_capabilities & IFCAP_VLAN_HWTAGGING)
384: ifv->ifv_if.if_capabilities = p->if_capabilities &
385: (IFCAP_CSUM_IPv4|IFCAP_CSUM_TCPv4|
386: IFCAP_CSUM_UDPv4);
387: /* (IFCAP_CSUM_TCPv6|IFCAP_CSUM_UDPv6); */
388:
389: /*
390: * Set up our ``Ethernet address'' to reflect the underlying
391: * physical interface's.
392: */
393: ifa1 = ifnet_addrs[ifv->ifv_if.if_index];
394: ifa2 = ifnet_addrs[p->if_index];
395: sdl1 = (struct sockaddr_dl *)ifa1->ifa_addr;
396: sdl2 = (struct sockaddr_dl *)ifa2->ifa_addr;
397: sdl1->sdl_type = IFT_ETHER;
398: sdl1->sdl_alen = ETHER_ADDR_LEN;
399: bcopy(LLADDR(sdl2), LLADDR(sdl1), ETHER_ADDR_LEN);
400: bcopy(LLADDR(sdl2), ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN);
401:
402: ifv->ifv_tag = tag;
403: s = splnet();
404: LIST_INSERT_HEAD(&vlan_tagh[TAG_HASH(tag)], ifv, ifv_list);
405:
406: /* Register callback for physical link state changes */
407: ifv->lh_cookie = hook_establish(p->if_linkstatehooks, 1,
408: vlan_vlandev_state, ifv);
409:
410: /* Register callback if parent wants to unregister */
411: ifv->dh_cookie = hook_establish(p->if_detachhooks, 1,
412: vlan_ifdetach, ifv);
413:
414: vlan_vlandev_state(ifv);
415: splx(s);
416:
417: return 0;
418: }
419:
420: int
421: vlan_unconfig(struct ifnet *ifp)
422: {
423: struct ifaddr *ifa;
424: struct sockaddr_dl *sdl;
425: struct ifvlan *ifv;
426: struct ifnet *p;
427: struct ifreq *ifr, *ifr_p;
428: int s;
429:
430: ifv = ifp->if_softc;
431: p = ifv->ifv_p;
432: if (p == NULL)
433: return 0;
434:
435: ifr = (struct ifreq *)&ifp->if_data;
436: ifr_p = (struct ifreq *)&ifv->ifv_p->if_data;
437:
438: s = splnet();
439: LIST_REMOVE(ifv, ifv_list);
440: if (ifv->lh_cookie != NULL)
441: hook_disestablish(p->if_linkstatehooks, ifv->lh_cookie);
442: /* The cookie is NULL if disestablished externally */
443: if (ifv->dh_cookie != NULL)
444: hook_disestablish(p->if_detachhooks, ifv->dh_cookie);
445: splx(s);
446:
447: /*
448: * Since the interface is being unconfigured, we need to
449: * empty the list of multicast groups that we may have joined
450: * while we were alive and remove them from the parent's list
451: * as well.
452: */
453: vlan_ether_purgemulti(ifv);
454:
455: /* Disconnect from parent. */
456: ifv->ifv_p = NULL;
457: ifv->ifv_if.if_mtu = ETHERMTU;
458:
459: /* Clear our MAC address. */
460: ifa = ifnet_addrs[ifv->ifv_if.if_index];
461: sdl = (struct sockaddr_dl *)ifa->ifa_addr;
462: sdl->sdl_type = IFT_ETHER;
463: sdl->sdl_alen = ETHER_ADDR_LEN;
464: bzero(LLADDR(sdl), ETHER_ADDR_LEN);
465: bzero(ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN);
466:
467: return 0;
468: }
469:
470: void
471: vlan_vlandev_state(void *v)
472: {
473: struct ifvlan *ifv = v;
474:
475: if (ifv->ifv_if.if_link_state == ifv->ifv_p->if_link_state)
476: return;
477:
478: ifv->ifv_if.if_link_state = ifv->ifv_p->if_link_state;
479: ifv->ifv_if.if_baudrate = ifv->ifv_p->if_baudrate;
480: if_link_state_change(&ifv->ifv_if);
481: }
482:
483: int
484: vlan_set_promisc(struct ifnet *ifp)
485: {
486: struct ifvlan *ifv = ifp->if_softc;
487: int error = 0;
488:
489: if ((ifp->if_flags & IFF_PROMISC) != 0) {
490: if ((ifv->ifv_flags & IFVF_PROMISC) == 0) {
491: error = ifpromisc(ifv->ifv_p, 1);
492: if (error == 0)
493: ifv->ifv_flags |= IFVF_PROMISC;
494: }
495: } else {
496: if ((ifv->ifv_flags & IFVF_PROMISC) != 0) {
497: error = ifpromisc(ifv->ifv_p, 0);
498: if (error == 0)
499: ifv->ifv_flags &= ~IFVF_PROMISC;
500: }
501: }
502:
503: return (0);
504: }
505:
506: int
507: vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
508: {
509: struct proc *p = curproc; /* XXX */
510: struct ifaddr *ifa;
511: struct ifnet *pr;
512: struct ifreq *ifr;
513: struct ifvlan *ifv;
514: struct vlanreq vlr;
515: int error = 0, p_mtu = 0, s;
516:
517: ifr = (struct ifreq *)data;
518: ifa = (struct ifaddr *)data;
519: ifv = ifp->if_softc;
520:
521: switch (cmd) {
522: case SIOCSIFADDR:
523: if (ifv->ifv_p != NULL) {
524: ifp->if_flags |= IFF_UP;
525:
526: switch (ifa->ifa_addr->sa_family) {
527: #ifdef INET
528: case AF_INET:
529: arp_ifinit(&ifv->ifv_ac, ifa);
530: break;
531: #endif
532: default:
533: break;
534: }
535: } else {
536: error = EINVAL;
537: }
538: break;
539:
540: case SIOCGIFADDR:
541: {
542: struct sockaddr *sa;
543:
544: sa = (struct sockaddr *) &ifr->ifr_data;
545: bcopy(((struct arpcom *)ifp->if_softc)->ac_enaddr,
546: (caddr_t) sa->sa_data, ETHER_ADDR_LEN);
547: }
548: break;
549:
550: case SIOCSIFMTU:
551: if (ifv->ifv_p != NULL) {
552: if (ifv->ifv_p->if_capabilities & IFCAP_VLAN_MTU)
553: p_mtu = ifv->ifv_p->if_mtu;
554: else
555: p_mtu = ifv->ifv_p->if_mtu - EVL_ENCAPLEN;
556:
557: if (ifr->ifr_mtu > p_mtu || ifr->ifr_mtu < ETHERMIN)
558: error = EINVAL;
559: else
560: ifp->if_mtu = ifr->ifr_mtu;
561: } else
562: error = EINVAL;
563:
564: break;
565:
566: case SIOCSETVLAN:
567: if ((error = suser(p, 0)) != 0)
568: break;
569: if ((error = copyin(ifr->ifr_data, &vlr, sizeof vlr)))
570: break;
571: if (vlr.vlr_parent[0] == '\0') {
572: s = splnet();
573: vlan_unconfig(ifp);
574: if (ifp->if_flags & IFF_UP)
575: if_down(ifp);
576: ifp->if_flags &= ~IFF_RUNNING;
577: splx(s);
578: break;
579: }
580: pr = ifunit(vlr.vlr_parent);
581: if (pr == NULL) {
582: error = ENOENT;
583: break;
584: }
585: /*
586: * Don't let the caller set up a VLAN tag with
587: * anything except VLID bits.
588: */
589: if (vlr.vlr_tag & ~EVL_VLID_MASK) {
590: error = EINVAL;
591: break;
592: }
593: error = vlan_config(ifv, pr, vlr.vlr_tag);
594: if (error)
595: break;
596: ifp->if_flags |= IFF_RUNNING;
597:
598: /* Update promiscuous mode, if necessary. */
599: vlan_set_promisc(ifp);
600: break;
601:
602: case SIOCGETVLAN:
603: bzero(&vlr, sizeof vlr);
604: if (ifv->ifv_p) {
605: snprintf(vlr.vlr_parent, sizeof(vlr.vlr_parent),
606: "%s", ifv->ifv_p->if_xname);
607: vlr.vlr_tag = ifv->ifv_tag;
608: }
609: error = copyout(&vlr, ifr->ifr_data, sizeof vlr);
610: break;
611: case SIOCSETVLANPRIO:
612: if ((error = suser(p, 0)) != 0)
613: break;
614: if ((error = copyin(ifr->ifr_data, &vlr, sizeof vlr)))
615: break;
616: /*
617: * Don't let the caller set up a VLAN priority
618: * outside the range 0-7
619: */
620: if (vlr.vlr_tag > EVL_PRIO_MAX) {
621: error = EINVAL;
622: break;
623: }
624: ifv->ifv_prio = vlr.vlr_tag;
625: break;
626: case SIOCGETVLANPRIO:
627: bzero(&vlr, sizeof vlr);
628: if (ifv->ifv_p)
629: strlcpy(vlr.vlr_parent, ifv->ifv_p->if_xname,
630: sizeof(vlr.vlr_parent));
631: vlr.vlr_tag = ifv->ifv_prio;
632: error = copyout(&vlr, ifr->ifr_data, sizeof vlr);
633: break;
634: case SIOCSIFFLAGS:
635: /*
636: * For promiscuous mode, we enable promiscuous mode on
637: * the parent if we need promiscuous on the VLAN interface.
638: */
639: if (ifv->ifv_p != NULL)
640: error = vlan_set_promisc(ifp);
641: break;
642:
643: case SIOCADDMULTI:
644: error = (ifv->ifv_p != NULL) ?
645: vlan_ether_addmulti(ifv, ifr) : EINVAL;
646: break;
647:
648: case SIOCDELMULTI:
649: error = (ifv->ifv_p != NULL) ?
650: vlan_ether_delmulti(ifv, ifr) : EINVAL;
651: break;
652: default:
653: error = EINVAL;
654: }
655: return error;
656: }
657:
658:
659: int
660: vlan_ether_addmulti(struct ifvlan *ifv, struct ifreq *ifr)
661: {
662: struct ifnet *ifp = ifv->ifv_p; /* Parent. */
663: struct vlan_mc_entry *mc;
664: u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
665: int error;
666:
667: /* XXX: sa_len is too small for such comparison
668: if (ifr->ifr_addr.sa_len > sizeof(struct sockaddr_storage))
669: return (EINVAL);
670: */
671:
672: error = ether_addmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
673: if (error != ENETRESET)
674: return (error);
675:
676: /*
677: * This is new multicast address. We have to tell parent
678: * about it. Also, remember this multicast address so that
679: * we can delete them on unconfigure.
680: */
681: MALLOC(mc, struct vlan_mc_entry *, sizeof(struct vlan_mc_entry),
682: M_DEVBUF, M_NOWAIT);
683: if (mc == NULL) {
684: error = ENOMEM;
685: goto alloc_failed;
686: }
687:
688: /*
689: * As ether_addmulti() returns ENETRESET, following two
690: * statement shouldn't fail.
691: */
692: (void)ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
693: ETHER_LOOKUP_MULTI(addrlo, addrhi, &ifv->ifv_ac, mc->mc_enm);
694: memcpy(&mc->mc_addr, &ifr->ifr_addr, ifr->ifr_addr.sa_len);
695: LIST_INSERT_HEAD(&ifv->vlan_mc_listhead, mc, mc_entries);
696:
697: error = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, (caddr_t)ifr);
698: if (error != 0)
699: goto ioctl_failed;
700:
701: return (error);
702:
703: ioctl_failed:
704: LIST_REMOVE(mc, mc_entries);
705: FREE(mc, M_DEVBUF);
706: alloc_failed:
707: (void)ether_delmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
708:
709: return (error);
710: }
711:
712: int
713: vlan_ether_delmulti(struct ifvlan *ifv, struct ifreq *ifr)
714: {
715: struct ifnet *ifp = ifv->ifv_p; /* Parent. */
716: struct ether_multi *enm;
717: struct vlan_mc_entry *mc;
718: u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
719: int error;
720:
721: /*
722: * Find a key to lookup vlan_mc_entry. We have to do this
723: * before calling ether_delmulti for obvious reason.
724: */
725: if ((error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi)) != 0)
726: return (error);
727: ETHER_LOOKUP_MULTI(addrlo, addrhi, &ifv->ifv_ac, enm);
728: if (enm == NULL)
729: return (EINVAL);
730:
731: LIST_FOREACH(mc, &ifv->vlan_mc_listhead, mc_entries)
732: if (mc->mc_enm == enm)
733: break;
734:
735: /* We won't delete entries we didn't add */
736: if (mc == NULL)
737: return (EINVAL);
738:
739: error = ether_delmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
740: if (error != ENETRESET)
741: return (error);
742:
743: /* We no longer use this multicast address. Tell parent so. */
744: error = (*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)ifr);
745: if (error == 0) {
746: /* And forget about this address. */
747: LIST_REMOVE(mc, mc_entries);
748: FREE(mc, M_DEVBUF);
749: } else
750: (void)ether_addmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
751: return (error);
752: }
753:
754: /*
755: * Delete any multicast address we have asked to add from parent
756: * interface. Called when the vlan is being unconfigured.
757: */
758: void
759: vlan_ether_purgemulti(struct ifvlan *ifv)
760: {
761: struct ifnet *ifp = ifv->ifv_p; /* Parent. */
762: struct vlan_mc_entry *mc;
763: union {
764: struct ifreq ifreq;
765: struct {
766: char ifr_name[IFNAMSIZ];
767: struct sockaddr_storage ifr_ss;
768: } ifreq_storage;
769: } ifreq;
770: struct ifreq *ifr = &ifreq.ifreq;
771:
772: memcpy(ifr->ifr_name, ifp->if_xname, IFNAMSIZ);
773: while ((mc = LIST_FIRST(&ifv->vlan_mc_listhead)) != NULL) {
774: memcpy(&ifr->ifr_addr, &mc->mc_addr, mc->mc_addr.ss_len);
775: (void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)ifr);
776: LIST_REMOVE(mc, mc_entries);
777: FREE(mc, M_DEVBUF);
778: }
779: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_vlan.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net