root/net/if_vlan.c

DEFINITIONS

1. vlanattach
2. vlan_clone_create
3. vlan_clone_destroy
4. vlan_ifdetach
5. vlan_start
6. vlan_input
7. vlan_config
8. vlan_unconfig
9. vlan_vlandev_state
10. vlan_set_promisc
11. vlan_ioctl
12. vlan_ether_addmulti
13. vlan_ether_delmulti
14. vlan_ether_purgemulti

    1 /*      $OpenBSD: if_vlan.c,v 1.70 2007/06/06 14:05:58 henning Exp $    */
    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  */
   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  */
   51 #include "vlan.h"
   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>
   64 #include "bpfilter.h"
   65 #if NBPFILTER > 0
   66 #include <net/bpf.h>
   67 #endif
   69 #include <net/if.h>
   70 #include <net/if_dl.h>
   71 #include <net/if_types.h>
   73 #ifdef INET
   74 #include <netinet/in.h>
   75 #include <netinet/if_ether.h>
   76 #endif
   78 #include <net/if_vlan_var.h>
   80 extern struct   ifaddr  **ifnet_addrs;
u_long vlan_tagmask;
   83 #define TAG_HASH_SIZE   32
   84 #define TAG_HASH(tag)   (tag & vlan_tagmask)
LIST_HEAD(, ifvlan)     *vlan_tagh;
   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 *);
  101 struct if_clone vlan_cloner =
IF_CLONE_INITIALIZER("vlan", vlan_clone_create, vlan_clone_destroy);
  104 /* ARGSUSED */
  105 void
  106 vlanattach(int count)
  107 {
vlan_tagh = hashinit(TAG_HASH_SIZE, M_DEVBUF, M_NOWAIT, &vlan_tagmask);
  109         if (vlan_tagh == NULL)
panic("vlanattach: hashinit");
if_clone_attach(&vlan_cloner);
  113 }
  115 int
  116 vlan_clone_create(struct if_clone *ifc, int unit)
  117 {
  118         struct ifvlan *ifv;
  119         struct ifnet *ifp;
ifv = malloc(sizeof(*ifv), M_DEVBUF, M_NOWAIT);
  122         if (!ifv)
  123                 return (ENOMEM);
bzero(ifv, sizeof(*ifv));
LIST_INIT(&ifv->vlan_mc_listhead);
ifp = &ifv->ifv_if;
ifp->if_softc = ifv;
snprintf(ifp->if_xname, sizeof ifp->if_xname, "%s%d", ifc->ifc_name,
unit);
  131         /* NB: flags are not set here */
  132         /* NB: mtu is not set here */
ifp->if_start = vlan_start;
ifp->if_ioctl = vlan_ioctl;
ifp->if_output = ether_output;
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
ether_ifattach(ifp);
  141         /* Now undo some of the damage... */
ifp->if_type = IFT_L2VLAN;
ifp->if_hdrlen = EVL_ENCAPLEN;
  145         return (0);
  146 }
  148 int
vlan_clone_destroy(struct ifnet *ifp)
  150 {
  151         struct ifvlan *ifv = ifp->if_softc;
vlan_unconfig(ifp);
ether_ifdetach(ifp);
if_detach(ifp);
free(ifv, M_DEVBUF);
  158         return (0);
  159 }
  161 void
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          */
ifv->dh_cookie = NULL;
vlan_clone_destroy(&ifv->ifv_if);
  173 }
  175 void
vlan_start(struct ifnet *ifp)
  177 {
  178         struct ifvlan *ifv;
  179         struct ifnet *p;
  180         struct mbuf *m;
  181         int error;
ifv = ifp->if_softc;
p = ifv->ifv_p;
ifp->if_flags |= IFF_OACTIVE;
  187         for (;;) {
IFQ_DEQUEUE(&ifp->if_snd, m);
  189                 if (m == NULL)
  190                         break;
  192                 if ((p->if_flags & (IFF_UP|IFF_RUNNING)) !=
  193                     (IFF_UP|IFF_RUNNING)) {
IF_DROP(&p->if_snd);
  195                                 /* XXX stats */
ifp->if_oerrors++;
m_freem(m);
  198                         continue;
  199                 }
  201 #if NBPFILTER > 0
  202                 if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
  204 #endif
  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) {
m->m_pkthdr.rcvif = ifp;
m->m_flags |= M_PROTO1;
  227                 } else {
  228                         struct ether_vlan_header evh;
m_copydata(m, 0, ETHER_HDR_LEN, (caddr_t)&evh);
evh.evl_proto = evh.evl_encap_proto;
evh.evl_encap_proto = htons(ETHERTYPE_VLAN);
evh.evl_tag = htons(ifv->ifv_tag +
  234                             (ifv->ifv_prio << EVL_PRIO_BITS));
m_adj(m, ETHER_HDR_LEN);
M_PREPEND(m, sizeof(evh), M_DONTWAIT);
  238                         if (m == NULL) {
ifp->if_oerrors++;
  240                                 continue;
  241                         }
m_copyback(m, 0, sizeof(evh), &evh);
  244                 }
  246                 /*
  247                  * Send it, precisely as ether_output() would have.
  248                  * We are already running at splnet.
  249                  */
p->if_obytes += m->m_pkthdr.len;
  251                 if (m->m_flags & M_MCAST)
p->if_omcasts++;
IFQ_ENQUEUE(&p->if_snd, m, NULL, error);
  254                 if (error) {
  255                         /* mbuf is already freed */
ifp->if_oerrors++;
  257                         continue;
  258                 }
ifp->if_opackets++;
  261                 if ((p->if_flags & (IFF_RUNNING|IFF_OACTIVE)) == IFF_RUNNING)
p->if_start(p);
  263         }
ifp->if_flags &= ~IFF_OACTIVE;
  266         return;
  267 }
  269 /*
  270  * vlan_input() returns 0 if it has consumed the packet, 1 otherwise.
  271  */
  272 int
vlan_input(eh, m)
  274         struct ether_header *eh;
  275         struct mbuf *m;
  276 {
  277         struct ifvlan *ifv;
u_int tag;
  279         struct ifnet *ifp = m->m_pkthdr.rcvif;
  281         if (m->m_len < EVL_ENCAPLEN &&
  282             (m = m_pullup(m, EVL_ENCAPLEN)) == NULL) {
ifp->if_ierrors++;
  284                 return (0);
  285         }
tag = EVL_VLANOFTAG(ntohs(*mtod(m, u_int16_t *)));
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);
  296         if ((ifv->ifv_if.if_flags & (IFF_UP|IFF_RUNNING)) !=
  297             (IFF_UP|IFF_RUNNING)) {
m_freem(m);
  299                 return (0);
  300         }
  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          */
m->m_pkthdr.rcvif = &ifv->ifv_if;
eh->ether_type = mtod(m, u_int16_t *)[1];
m->m_len -= EVL_ENCAPLEN;
m->m_data += EVL_ENCAPLEN;
m->m_pkthdr.len -= EVL_ENCAPLEN;
  315 #if NBPFILTER > 0
  316         if (ifv->ifv_if.if_bpf)
bpf_mtap_hdr(ifv->ifv_if.if_bpf, (char *)eh, ETHER_HDR_LEN,
m, BPF_DIRECTION_IN);
  319 #endif
ifv->ifv_if.if_ipackets++;
ether_input(&ifv->ifv_if, eh, m);
  323         return (0);
  324 }
  326 int
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;
  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;
ifv->ifv_p = p;
  342         if (p->if_capabilities & IFCAP_VLAN_MTU)
ifv->ifv_if.if_mtu = p->if_mtu;
  344         else {
  345                 /*
  346                  * This will be incompatible with strict
  347                  * 802.1Q implementations
  348                  */
ifv->ifv_if.if_mtu = p->if_mtu - EVL_ENCAPLEN;
  350 #ifdef DIAGNOSTIC
printf("%s: initialized with non-standard mtu %lu (parent %s)\n",
ifv->ifv_if.if_xname, ifv->ifv_if.if_mtu,
ifv->ifv_p->if_xname);
  354 #endif
  355         }
ifv->ifv_if.if_flags = p->if_flags &
  358             (IFF_UP | IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
  360         /*
  361          * Inherit the if_type from the parent.  This allows us to
  362          * participate in bridges of that type.
  363          */
ifv->ifv_if.if_type = p->if_type;
  366         /*
  367          * Inherit baudrate from the parent.  An SNMP agent would use this
  368          * information.
  369          */
ifv->ifv_if.if_baudrate = p->if_baudrate;
  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)
ifv->ifv_if.if_capabilities = p->if_capabilities &
  385                     (IFCAP_CSUM_IPv4|IFCAP_CSUM_TCPv4|
IFCAP_CSUM_UDPv4);
  387                 /* (IFCAP_CSUM_TCPv6|IFCAP_CSUM_UDPv6); */
  389         /*
  390          * Set up our ``Ethernet address'' to reflect the underlying
  391          * physical interface's.
  392          */
ifa1 = ifnet_addrs[ifv->ifv_if.if_index];
ifa2 = ifnet_addrs[p->if_index];
sdl1 = (struct sockaddr_dl *)ifa1->ifa_addr;
sdl2 = (struct sockaddr_dl *)ifa2->ifa_addr;
sdl1->sdl_type = IFT_ETHER;
sdl1->sdl_alen = ETHER_ADDR_LEN;
bcopy(LLADDR(sdl2), LLADDR(sdl1), ETHER_ADDR_LEN);
bcopy(LLADDR(sdl2), ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN);
ifv->ifv_tag = tag;
s = splnet();
LIST_INSERT_HEAD(&vlan_tagh[TAG_HASH(tag)], ifv, ifv_list);
  406         /* Register callback for physical link state changes */
ifv->lh_cookie = hook_establish(p->if_linkstatehooks, 1,
vlan_vlandev_state, ifv);
  410         /* Register callback if parent wants to unregister */
ifv->dh_cookie = hook_establish(p->if_detachhooks, 1,
vlan_ifdetach, ifv);
vlan_vlandev_state(ifv);
splx(s);
  417         return 0;
  418 }
  420 int
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;
ifv = ifp->if_softc;
p = ifv->ifv_p;
  432         if (p == NULL)
  433                 return 0;
ifr = (struct ifreq *)&ifp->if_data;
ifr_p = (struct ifreq *)&ifv->ifv_p->if_data;
s = splnet();
LIST_REMOVE(ifv, ifv_list);
  440         if (ifv->lh_cookie != NULL)
hook_disestablish(p->if_linkstatehooks, ifv->lh_cookie);
  442         /* The cookie is NULL if disestablished externally */
  443         if (ifv->dh_cookie != NULL)
hook_disestablish(p->if_detachhooks, ifv->dh_cookie);
splx(s);
  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          */
vlan_ether_purgemulti(ifv);
  455         /* Disconnect from parent. */
ifv->ifv_p = NULL;
ifv->ifv_if.if_mtu = ETHERMTU;
  459         /* Clear our MAC address. */
ifa = ifnet_addrs[ifv->ifv_if.if_index];
sdl = (struct sockaddr_dl *)ifa->ifa_addr;
sdl->sdl_type = IFT_ETHER;
sdl->sdl_alen = ETHER_ADDR_LEN;
bzero(LLADDR(sdl), ETHER_ADDR_LEN);
bzero(ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN);
  467         return 0;
  468 }
  470 void
vlan_vlandev_state(void *v)
  472 {
  473         struct ifvlan *ifv = v;
  475         if (ifv->ifv_if.if_link_state == ifv->ifv_p->if_link_state)
  476                 return;
ifv->ifv_if.if_link_state = ifv->ifv_p->if_link_state;
ifv->ifv_if.if_baudrate = ifv->ifv_p->if_baudrate;
if_link_state_change(&ifv->ifv_if);
  481 }
  483 int
vlan_set_promisc(struct ifnet *ifp)
  485 {
  486         struct ifvlan *ifv = ifp->if_softc;
  487         int error = 0;
  489         if ((ifp->if_flags & IFF_PROMISC) != 0) {
  490                 if ((ifv->ifv_flags & IFVF_PROMISC) == 0) {
error = ifpromisc(ifv->ifv_p, 1);
  492                         if (error == 0)
ifv->ifv_flags |= IFVF_PROMISC;
  494                 }
  495         } else {
  496                 if ((ifv->ifv_flags & IFVF_PROMISC) != 0) {
error = ifpromisc(ifv->ifv_p, 0);
  498                         if (error == 0)
ifv->ifv_flags &= ~IFVF_PROMISC;
  500                 }
  501         }
  503         return (0);
  504 }
  506 int
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;
ifr = (struct ifreq *)data;
ifa = (struct ifaddr *)data;
ifv = ifp->if_softc;
  521         switch (cmd) {
  522         case SIOCSIFADDR:
  523                 if (ifv->ifv_p != NULL) {
ifp->if_flags |= IFF_UP;
  526                         switch (ifa->ifa_addr->sa_family) {
  527 #ifdef INET
  528                         case AF_INET:
arp_ifinit(&ifv->ifv_ac, ifa);
  530                                 break;
  531 #endif
  532                         default:
  533                                 break;
  534                         }
  535                 } else {
error = EINVAL;
  537                 }
  538                 break;
  540         case SIOCGIFADDR:
  541                 {
  542                         struct sockaddr *sa;
sa = (struct sockaddr *) &ifr->ifr_data;
bcopy(((struct arpcom *)ifp->if_softc)->ac_enaddr,
  546                             (caddr_t) sa->sa_data, ETHER_ADDR_LEN);
  547                 }
  548                 break;
  550         case SIOCSIFMTU:
  551                 if (ifv->ifv_p != NULL) {
  552                         if (ifv->ifv_p->if_capabilities & IFCAP_VLAN_MTU)
p_mtu = ifv->ifv_p->if_mtu;
  554                         else
p_mtu = ifv->ifv_p->if_mtu - EVL_ENCAPLEN;
  557                         if (ifr->ifr_mtu > p_mtu || ifr->ifr_mtu < ETHERMIN)
error = EINVAL;
  559                         else
ifp->if_mtu = ifr->ifr_mtu;
  561                 } else
error = EINVAL;
  564                 break;
  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') {
s = splnet();
vlan_unconfig(ifp);
  574                         if (ifp->if_flags & IFF_UP)
if_down(ifp);
ifp->if_flags &= ~IFF_RUNNING;
splx(s);
  578                         break;
  579                 }
pr = ifunit(vlr.vlr_parent);
  581                 if (pr == NULL) {
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) {
error = EINVAL;
  591                         break;
  592                 }
error = vlan_config(ifv, pr, vlr.vlr_tag);
  594                 if (error)
  595                         break;
ifp->if_flags |= IFF_RUNNING;
  598                 /* Update promiscuous mode, if necessary. */
vlan_set_promisc(ifp);
  600                 break;
  602         case SIOCGETVLAN:
bzero(&vlr, sizeof vlr);
  604                 if (ifv->ifv_p) {
snprintf(vlr.vlr_parent, sizeof(vlr.vlr_parent),
  606                             "%s", ifv->ifv_p->if_xname);
vlr.vlr_tag = ifv->ifv_tag;
  608                 }
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) {
error = EINVAL;
  622                         break;
  623                 }
ifv->ifv_prio = vlr.vlr_tag;
  625                 break;
  626         case SIOCGETVLANPRIO:
bzero(&vlr, sizeof vlr);
  628                 if (ifv->ifv_p)
strlcpy(vlr.vlr_parent, ifv->ifv_p->if_xname,
  630                             sizeof(vlr.vlr_parent));
vlr.vlr_tag = ifv->ifv_prio;
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)
error = vlan_set_promisc(ifp);
  641                 break;
  643         case SIOCADDMULTI:
error = (ifv->ifv_p != NULL) ?
vlan_ether_addmulti(ifv, ifr) : EINVAL;
  646                 break;
  648         case SIOCDELMULTI:
error = (ifv->ifv_p != NULL) ?
vlan_ether_delmulti(ifv, ifr) : EINVAL;
  651                 break;
  652         default:
error = EINVAL;
  654         }
  655         return error;
  656 }
  659 int
vlan_ether_addmulti(struct ifvlan *ifv, struct ifreq *ifr)
  661 {
  662         struct ifnet *ifp = ifv->ifv_p;         /* Parent. */
  663         struct vlan_mc_entry *mc;
u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
  665         int error;
  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         */
error = ether_addmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
  673         if (error != ENETRESET)
  674                 return (error);
  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          */
MALLOC(mc, struct vlan_mc_entry *, sizeof(struct vlan_mc_entry),
M_DEVBUF, M_NOWAIT);
  683         if (mc == NULL) {
error = ENOMEM;
  685                 goto alloc_failed;
  686         }
  688         /*
  689          * As ether_addmulti() returns ENETRESET, following two
  690          * statement shouldn't fail.
  691          */
  692         (void)ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
ETHER_LOOKUP_MULTI(addrlo, addrhi, &ifv->ifv_ac, mc->mc_enm);
memcpy(&mc->mc_addr, &ifr->ifr_addr, ifr->ifr_addr.sa_len);
LIST_INSERT_HEAD(&ifv->vlan_mc_listhead, mc, mc_entries);
error = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, (caddr_t)ifr);
  698         if (error != 0)
  699                 goto ioctl_failed;
  701         return (error);
ioctl_failed:
LIST_REMOVE(mc, mc_entries);
FREE(mc, M_DEVBUF);
alloc_failed:
  707         (void)ether_delmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
  709         return (error);
  710 }
  712 int
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;
u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
  719         int error;
  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);
ETHER_LOOKUP_MULTI(addrlo, addrhi, &ifv->ifv_ac, enm);
  728         if (enm == NULL)
  729                 return (EINVAL);
LIST_FOREACH(mc, &ifv->vlan_mc_listhead, mc_entries)
  732                 if (mc->mc_enm == enm)
  733                         break;
  735         /* We won't delete entries we didn't add */
  736         if (mc == NULL)
  737                 return (EINVAL);
error = ether_delmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
  740         if (error != ENETRESET)
  741                 return (error);
  743         /* We no longer use this multicast address.  Tell parent so. */
error = (*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)ifr);
  745         if (error == 0) {
  746                 /* And forget about this address. */
LIST_REMOVE(mc, mc_entries);
FREE(mc, M_DEVBUF);
  749         } else
  750                 (void)ether_addmulti(ifr, (struct arpcom *)&ifv->ifv_ac);
  751         return (error);
  752 }
  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
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;
memcpy(ifr->ifr_name, ifp->if_xname, IFNAMSIZ);
  773         while ((mc = LIST_FIRST(&ifv->vlan_mc_listhead)) != NULL) {
memcpy(&ifr->ifr_addr, &mc->mc_addr, mc->mc_addr.ss_len);
  775                 (void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)ifr);
LIST_REMOVE(mc, mc_entries);
FREE(mc, M_DEVBUF);
  778         }
  779 }