![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_vlan.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_vlan.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 1998 Massachusetts Institute of Technology ! 24: * ! 25: * Permission to use, copy, modify, and distribute this software and ! 26: * its documentation for any purpose and without fee is hereby ! 27: * granted, provided that both the above copyright notice and this ! 28: * permission notice appear in all copies, that both the above ! 29: * copyright notice and this permission notice appear in all ! 30: * supporting documentation, and that the name of M.I.T. not be used ! 31: * in advertising or publicity pertaining to distribution of the ! 32: * software without specific, written prior permission. M.I.T. makes ! 33: * no representations about the suitability of this software for any ! 34: * purpose. It is provided "as is" without express or implied ! 35: * warranty. ! 36: * ! 37: * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS ! 38: * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE, ! 39: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF ! 40: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT ! 41: * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ! 42: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ! 43: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF ! 44: * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ! 45: * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, ! 46: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ! 47: * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 48: * SUCH DAMAGE. ! 49: * ! 50: */ ! 51: ! 52: /* ! 53: * if_vlan.c - pseudo-device driver for IEEE 802.1Q virtual LANs. ! 54: * Might be extended some day to also handle IEEE 802.1p priority ! 55: * tagging. This is sort of sneaky in the implementation, since ! 56: * we need to pretend to be enough of an Ethernet implementation ! 57: * to make arp work. The way we do this is by telling everyone ! 58: * that we are an Ethernet, and then catch the packets that ! 59: * ether_output() left on our output queue queue when it calls ! 60: * if_start(), rewrite them for use by the real outgoing interface, ! 61: * and ask it to send them. ! 62: * ! 63: * ! 64: * XXX It's incorrect to assume that we must always kludge up ! 65: * headers on the physical device's behalf: some devices support ! 66: * VLAN tag insersion and extraction in firmware. For these cases, ! 67: * one can change the behavior of the vlan interface by setting ! 68: * the LINK0 flag on it (that is setting the vlan interface's LINK0 ! 69: * flag, _not_ the parent's LINK0 flag; we try to leave the parent ! 70: * alone). If the interface as the LINK0 flag set, then it will ! 71: * not modify the ethernet header on output because the parent ! 72: * can do that for itself. On input, the parent can call vlan_input_tag() ! 73: * directly in order to supply us with an incoming mbuf and the vlan ! 74: * tag value that goes with it. ! 75: */ ! 76: ! 77: #include "vlan.h" ! 78: #if NVLAN > 0 ! 79: #include "opt_inet.h" ! 80: #include "bpfilter.h" ! 81: ! 82: #include <sys/param.h> ! 83: #include <sys/kernel.h> ! 84: #include <sys/mbuf.h> ! 85: #include <sys/socket.h> ! 86: #include <sys/sockio.h> ! 87: #include <sys/sysctl.h> ! 88: #include <sys/systm.h> ! 89: ! 90: #if NBPFILTER > 0 ! 91: #include <net/bpf.h> ! 92: #endif ! 93: #include <net/ethernet.h> ! 94: #include <net/if.h> ! 95: #include <net/if_arp.h> ! 96: #include <net/if_dl.h> ! 97: #include <net/if_types.h> ! 98: #include <net/if_vlan_var.h> ! 99: ! 100: #if INET ! 101: #include <netinet/in.h> ! 102: #include <netinet/if_ether.h> ! 103: #endif ! 104: ! 105: SYSCTL_DECL(_net_link); ! 106: SYSCTL_NODE(_net_link, IFT_8021_VLAN, vlan, CTLFLAG_RW, 0, "IEEE 802.1Q VLAN"); ! 107: SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0, "for consistency"); ! 108: ! 109: u_int vlan_proto = ETHERTYPE_VLAN; ! 110: SYSCTL_INT(_net_link_vlan_link, VLANCTL_PROTO, proto, CTLFLAG_RW, &vlan_proto, ! 111: 0, "Ethernet protocol used for VLAN encapsulation"); ! 112: ! 113: static struct ifvlan ifv_softc[NVLAN]; ! 114: ! 115: static void vlan_start(struct ifnet *ifp); ! 116: static void vlan_ifinit(void *foo); ! 117: static int vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr); ! 118: static int vlan_setmulti(struct ifnet *ifp); ! 119: static int vlan_unconfig(struct ifnet *ifp); ! 120: static int vlan_config(struct ifvlan *ifv, struct ifnet *p); ! 121: ! 122: /* ! 123: * Program our multicast filter. What we're actually doing is ! 124: * programming the multicast filter of the parent. This has the ! 125: * side effect of causing the parent interface to receive multicast ! 126: * traffic that it doesn't really want, which ends up being discarded ! 127: * later by the upper protocol layers. Unfortunately, there's no way ! 128: * to avoid this: there really is only one physical interface. ! 129: */ ! 130: static int vlan_setmulti(struct ifnet *ifp) ! 131: { ! 132: struct ifnet *ifp_p; ! 133: struct ifmultiaddr *ifma, *rifma = NULL; ! 134: struct ifvlan *sc; ! 135: struct vlan_mc_entry *mc = NULL; ! 136: struct sockaddr_dl sdl; ! 137: int error; ! 138: ! 139: /* Find the parent. */ ! 140: sc = ifp->if_softc; ! 141: ifp_p = sc->ifv_p; ! 142: ! 143: sdl.sdl_len = ETHER_ADDR_LEN; ! 144: sdl.sdl_family = AF_LINK; ! 145: ! 146: /* First, remove any existing filter entries. */ ! 147: while(sc->vlan_mc_listhead.slh_first != NULL) { ! 148: mc = sc->vlan_mc_listhead.slh_first; ! 149: bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN); ! 150: error = if_delmulti(ifp_p, (struct sockaddr *)&sdl); ! 151: if (error) ! 152: return(error); ! 153: SLIST_REMOVE_HEAD(&sc->vlan_mc_listhead, mc_entries); ! 154: FREE(mc, M_DEVBUF); ! 155: } ! 156: ! 157: /* Now program new ones. */ ! 158: for (ifma = ifp->if_multiaddrs.lh_first; ! 159: ifma != NULL;ifma = ifma->ifma_link.le_next) { ! 160: if (ifma->ifma_addr->sa_family != AF_LINK) ! 161: continue; ! 162: mc = _MALLOC(sizeof(struct vlan_mc_entry), M_DEVBUF, M_NOWAIT); ! 163: bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), ! 164: (char *)&mc->mc_addr, ETHER_ADDR_LEN); ! 165: SLIST_INSERT_HEAD(&sc->vlan_mc_listhead, mc, mc_entries); ! 166: error = if_addmulti(ifp_p, (struct sockaddr *)&sdl, &rifma); ! 167: if (error) ! 168: return(error); ! 169: } ! 170: ! 171: return(0); ! 172: } ! 173: ! 174: static void ! 175: vlaninit(void *dummy) ! 176: { ! 177: int i; ! 178: ! 179: for (i = 0; i < NVLAN; i++) { ! 180: struct ifnet *ifp = &ifv_softc[i].ifv_if; ! 181: ! 182: ifp->if_softc = &ifv_softc[i]; ! 183: ifp->if_name = "vlan"; ! 184: ifp->if_family = APPLE_IF_FAM_VLAN; ! 185: ifp->if_unit = i; ! 186: /* NB: flags are not set here */ ! 187: ifp->if_linkmib = &ifv_softc[i].ifv_mib; ! 188: ifp->if_linkmiblen = sizeof ifv_softc[i].ifv_mib; ! 189: /* NB: mtu is not set here */ ! 190: ! 191: ifp->if_init = vlan_ifinit; ! 192: ifp->if_start = vlan_start; ! 193: ifp->if_ioctl = vlan_ioctl; ! 194: ifp->if_output = ether_output; ! 195: ifp->if_snd.ifq_maxlen = ifqmaxlen; ! 196: if_attach(ifp); ! 197: ether_ifattach(ifp); ! 198: #if NBPFILTER > 0 ! 199: bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header)); ! 200: #endif ! 201: /* Now undo some of the damage... */ ! 202: ifp->if_data.ifi_type = IFT_8021_VLAN; ! 203: ifp->if_data.ifi_hdrlen = EVL_ENCAPLEN; ! 204: ifp->if_resolvemulti = 0; ! 205: } ! 206: } ! 207: PSEUDO_SET(vlaninit, if_vlan); ! 208: ! 209: static void ! 210: vlan_ifinit(void *foo) ! 211: { ! 212: return; ! 213: } ! 214: ! 215: static void ! 216: vlan_start(struct ifnet *ifp) ! 217: { ! 218: struct ifvlan *ifv; ! 219: struct ifnet *p; ! 220: struct ether_vlan_header *evl; ! 221: struct mbuf *m; ! 222: ! 223: ifv = ifp->if_softc; ! 224: p = ifv->ifv_p; ! 225: ! 226: ifp->if_flags |= IFF_OACTIVE; ! 227: for (;;) { ! 228: IF_DEQUEUE(&ifp->if_snd, m); ! 229: if (m == 0) ! 230: break; ! 231: #if NBPFILTER > 0 ! 232: if (ifp->if_bpf) ! 233: bpf_mtap(ifp, m); ! 234: #endif /* NBPFILTER > 0 */ ! 235: ! 236: /* ! 237: * If the LINK0 flag is set, it means the underlying interface ! 238: * can do VLAN tag insertion itself and doesn't require us to ! 239: * create a special header for it. In this case, we just pass ! 240: * the packet along. However, we need some way to tell the ! 241: * interface where the packet came from so that it knows how ! 242: * to find the VLAN tag to use, so we set the rcvif in the ! 243: * mbuf header to our ifnet. ! 244: * ! 245: * Note: we also set the M_PROTO1 flag in the mbuf to let ! 246: * the parent driver know that the rcvif pointer is really ! 247: * valid. We need to do this because sometimes mbufs will ! 248: * be allocated by other parts of the system that contain ! 249: * garbage in the rcvif pointer. Using the M_PROTO1 flag ! 250: * lets the driver perform a proper sanity check and avoid ! 251: * following potentially bogus rcvif pointers off into ! 252: * never-never land. ! 253: */ ! 254: if (ifp->if_flags & IFF_LINK0) { ! 255: m->m_pkthdr.rcvif = ifp; ! 256: m->m_flags |= M_PROTO1; ! 257: } else { ! 258: M_PREPEND(m, EVL_ENCAPLEN, M_DONTWAIT); ! 259: if (m == 0) ! 260: continue; ! 261: /* M_PREPEND takes care of m_len, m_pkthdr.len for us */ ! 262: ! 263: /* ! 264: * Transform the Ethernet header into an Ethernet header ! 265: * with 802.1Q encapsulation. ! 266: */ ! 267: bcopy(mtod(m, char *) + EVL_ENCAPLEN, mtod(m, char *), ! 268: sizeof(struct ether_header)); ! 269: evl = mtod(m, struct ether_vlan_header *); ! 270: evl->evl_proto = evl->evl_encap_proto; ! 271: evl->evl_encap_proto = htons(vlan_proto); ! 272: evl->evl_tag = htons(ifv->ifv_tag); ! 273: #ifdef DEBUG ! 274: printf("vlan_start: %*D\n", sizeof *evl, ! 275: (char *)evl, ":"); ! 276: #endif ! 277: } ! 278: ! 279: /* ! 280: * Send it, precisely as ether_output() would have. ! 281: * We are already running at splimp. ! 282: */ ! 283: if (IF_QFULL(&p->if_snd)) { ! 284: IF_DROP(&p->if_snd); ! 285: /* XXX stats */ ! 286: ifp->if_oerrors++; ! 287: m_freem(m); ! 288: continue; ! 289: } ! 290: IF_ENQUEUE(&p->if_snd, m); ! 291: if ((p->if_flags & IFF_OACTIVE) == 0) { ! 292: p->if_start(p); ! 293: ifp->if_opackets++; ! 294: } ! 295: } ! 296: ifp->if_flags &= ~IFF_OACTIVE; ! 297: ! 298: return; ! 299: } ! 300: ! 301: void ! 302: vlan_input_tag(struct ether_header *eh, struct mbuf *m, u_int16_t t) ! 303: { ! 304: int i; ! 305: struct ifvlan *ifv; ! 306: ! 307: for (i = 0; i < NVLAN; i++) { ! 308: ifv = &ifv_softc[i]; ! 309: if (ifv->ifv_tag == t) ! 310: break; ! 311: } ! 312: ! 313: if (i >= NVLAN || (ifv->ifv_if.if_flags & IFF_UP) == 0) { ! 314: m_freem(m); ! 315: ifv->ifv_p->if_data.ifi_noproto++; ! 316: return; ! 317: } ! 318: ! 319: /* ! 320: * Having found a valid vlan interface corresponding to ! 321: * the given source interface and vlan tag, run the ! 322: * the real packet through ethert_input(). ! 323: */ ! 324: m->m_pkthdr.rcvif = &ifv->ifv_if; ! 325: ! 326: #if NBPFILTER > 0 ! 327: if (ifv->ifv_if.if_bpf) { ! 328: /* ! 329: * Do the usual BPF fakery. Note that we don't support ! 330: * promiscuous mode here, since it would require the ! 331: * drivers to know about VLANs and we're not ready for ! 332: * that yet. ! 333: */ ! 334: struct mbuf m0; ! 335: m0.m_next = m; ! 336: m0.m_len = sizeof(struct ether_header); ! 337: m0.m_data = (char *)eh; ! 338: bpf_mtap(&ifv->ifv_if, &m0); ! 339: } ! 340: #endif ! 341: ifv->ifv_if.if_ipackets++; ! 342: ether_input(&ifv->ifv_if, eh, m); ! 343: return; ! 344: } ! 345: ! 346: int ! 347: vlan_input(struct ether_header *eh, struct mbuf *m) ! 348: { ! 349: int i; ! 350: struct ifvlan *ifv; ! 351: ! 352: for (i = 0; i < NVLAN; i++) { ! 353: ifv = &ifv_softc[i]; ! 354: if (m->m_pkthdr.rcvif == ifv->ifv_p ! 355: && (EVL_VLANOFTAG(ntohs(*mtod(m, u_int16_t *))) ! 356: == ifv->ifv_tag)) ! 357: break; ! 358: } ! 359: ! 360: if (i >= NVLAN || (ifv->ifv_if.if_flags & IFF_UP) == 0) { ! 361: m_freem(m); ! 362: return -1; /* so ether_input can take note */ ! 363: } ! 364: ! 365: /* ! 366: * Having found a valid vlan interface corresponding to ! 367: * the given source interface and vlan tag, remove the ! 368: * encapsulation, and run the real packet through ! 369: * ether_input() a second time (it had better be ! 370: * reentrant!). ! 371: */ ! 372: m->m_pkthdr.rcvif = &ifv->ifv_if; ! 373: eh->ether_type = mtod(m, u_int16_t *)[1]; ! 374: m->m_data += EVL_ENCAPLEN; ! 375: m->m_len -= EVL_ENCAPLEN; ! 376: m->m_pkthdr.len -= EVL_ENCAPLEN; ! 377: ! 378: #if NBPFILTER > 0 ! 379: if (ifv->ifv_if.if_bpf) { ! 380: /* ! 381: * Do the usual BPF fakery. Note that we don't support ! 382: * promiscuous mode here, since it would require the ! 383: * drivers to know about VLANs and we're not ready for ! 384: * that yet. ! 385: */ ! 386: struct mbuf m0; ! 387: m0.m_next = m; ! 388: m0.m_len = sizeof(struct ether_header); ! 389: m0.m_data = (char *)eh; ! 390: bpf_mtap(&ifv->ifv_if, &m0); ! 391: } ! 392: #endif ! 393: ifv->ifv_if.if_ipackets++; ! 394: ether_input(&ifv->ifv_if, eh, m); ! 395: return 0; ! 396: } ! 397: ! 398: static int ! 399: vlan_config(struct ifvlan *ifv, struct ifnet *p) ! 400: { ! 401: struct ifaddr *ifa1, *ifa2; ! 402: struct sockaddr_dl *sdl1, *sdl2; ! 403: ! 404: if (p->if_data.ifi_type != IFT_ETHER) ! 405: return EPROTONOSUPPORT; ! 406: if (ifv->ifv_p) ! 407: return EBUSY; ! 408: ifv->ifv_p = p; ! 409: if (p->if_data.ifi_hdrlen == sizeof(struct ether_vlan_header)) ! 410: ifv->ifv_if.if_mtu = p->if_mtu; ! 411: else ! 412: ifv->ifv_if.if_mtu = p->if_data.ifi_mtu - EVL_ENCAPLEN; ! 413: ! 414: /* ! 415: * Preserve the state of the LINK0 flag for ourselves. ! 416: */ ! 417: ifv->ifv_if.if_flags = (p->if_flags & ~(IFF_LINK0)); ! 418: ! 419: /* ! 420: * Set up our ``Ethernet address'' to reflect the underlying ! 421: * physical interface's. ! 422: */ ! 423: ifa1 = ifnet_addrs[ifv->ifv_if.if_index - 1]; ! 424: ifa2 = ifnet_addrs[p->if_index - 1]; ! 425: sdl1 = (struct sockaddr_dl *)ifa1->ifa_addr; ! 426: sdl2 = (struct sockaddr_dl *)ifa2->ifa_addr; ! 427: sdl1->sdl_type = IFT_ETHER; ! 428: sdl1->sdl_alen = ETHER_ADDR_LEN; ! 429: bcopy(LLADDR(sdl2), LLADDR(sdl1), ETHER_ADDR_LEN); ! 430: bcopy(LLADDR(sdl2), ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN); ! 431: return 0; ! 432: } ! 433: ! 434: static int ! 435: vlan_unconfig(struct ifnet *ifp) ! 436: { ! 437: struct ifaddr *ifa; ! 438: struct sockaddr_dl *sdl; ! 439: struct vlan_mc_entry *mc; ! 440: struct ifvlan *ifv; ! 441: struct ifnet *p; ! 442: int error; ! 443: ! 444: ifv = ifp->if_softc; ! 445: p = ifv->ifv_p; ! 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: while(ifv->vlan_mc_listhead.slh_first != NULL) { ! 454: struct sockaddr_dl sdl; ! 455: ! 456: sdl.sdl_len = ETHER_ADDR_LEN; ! 457: sdl.sdl_family = AF_LINK; ! 458: mc = ifv->vlan_mc_listhead.slh_first; ! 459: bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN); ! 460: error = if_delmulti(p, (struct sockaddr *)&sdl); ! 461: error = if_delmulti(ifp, (struct sockaddr *)&sdl); ! 462: if (error) ! 463: return(error); ! 464: SLIST_REMOVE_HEAD(&ifv->vlan_mc_listhead, mc_entries); ! 465: FREE(mc, M_DEVBUF); ! 466: } ! 467: ! 468: /* Disconnect from parent. */ ! 469: ifv->ifv_p = NULL; ! 470: ifv->ifv_if.if_mtu = ETHERMTU; ! 471: ! 472: /* Clear our MAC address. */ ! 473: ifa = ifnet_addrs[ifv->ifv_if.if_index - 1]; ! 474: sdl = (struct sockaddr_dl *)ifa->ifa_addr; ! 475: sdl->sdl_type = IFT_ETHER; ! 476: sdl->sdl_alen = ETHER_ADDR_LEN; ! 477: bzero(LLADDR(sdl), ETHER_ADDR_LEN); ! 478: bzero(ifv->ifv_ac.ac_enaddr, ETHER_ADDR_LEN); ! 479: ! 480: return 0; ! 481: } ! 482: ! 483: static int ! 484: vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) ! 485: { ! 486: struct ifaddr *ifa; ! 487: struct ifnet *p; ! 488: struct ifreq *ifr; ! 489: struct ifvlan *ifv; ! 490: struct vlanreq vlr; ! 491: int error = 0; ! 492: ! 493: ifr = (struct ifreq *)data; ! 494: ifa = (struct ifaddr *)data; ! 495: ifv = ifp->if_softc; ! 496: ! 497: switch (cmd) { ! 498: case SIOCSIFADDR: ! 499: ifp->if_flags |= IFF_UP; ! 500: ! 501: switch (ifa->ifa_addr->sa_family) { ! 502: #if INET ! 503: case AF_INET: ! 504: arp_ifinit(&ifv->ifv_ac, ifa); ! 505: break; ! 506: #endif ! 507: default: ! 508: break; ! 509: } ! 510: break; ! 511: ! 512: case SIOCGIFADDR: ! 513: { ! 514: struct sockaddr *sa; ! 515: ! 516: sa = (struct sockaddr *) &ifr->ifr_data; ! 517: bcopy(((struct arpcom *)ifp->if_softc)->ac_enaddr, ! 518: (caddr_t) sa->sa_data, ETHER_ADDR_LEN); ! 519: } ! 520: break; ! 521: ! 522: case SIOCSIFMTU: ! 523: /* ! 524: * Set the interface MTU. ! 525: * This is bogus. The underlying interface might support ! 526: * jumbo frames. ! 527: */ ! 528: if (ifr->ifr_mtu > ETHERMTU) { ! 529: error = EINVAL; ! 530: } else { ! 531: ifp->if_mtu = ifr->ifr_mtu; ! 532: } ! 533: break; ! 534: ! 535: case SIOCSETVLAN: ! 536: error = copyin(ifr->ifr_data, &vlr, sizeof vlr); ! 537: if (error) ! 538: break; ! 539: if (vlr.vlr_parent[0] == '\0') { ! 540: vlan_unconfig(ifp); ! 541: if_down(ifp); ! 542: ifp->if_flags = 0; ! 543: break; ! 544: } ! 545: p = ifunit(vlr.vlr_parent); ! 546: if (p == 0) { ! 547: error = ENOENT; ! 548: break; ! 549: } ! 550: error = vlan_config(ifv, p); ! 551: if (error) ! 552: break; ! 553: ifv->ifv_tag = vlr.vlr_tag; ! 554: break; ! 555: ! 556: case SIOCGETVLAN: ! 557: bzero(&vlr, sizeof vlr); ! 558: if (ifv->ifv_p) { ! 559: snprintf(vlr.vlr_parent, sizeof(vlr.vlr_parent), ! 560: "%s%d", ifv->ifv_p->if_name, ifv->ifv_p->if_unit); ! 561: vlr.vlr_tag = ifv->ifv_tag; ! 562: } ! 563: error = copyout(&vlr, ifr->ifr_data, sizeof vlr); ! 564: break; ! 565: ! 566: case SIOCSIFFLAGS: ! 567: /* ! 568: * We don't support promiscuous mode ! 569: * right now because it would require help from the ! 570: * underlying drivers, which hasn't been implemented. ! 571: */ ! 572: if (ifr->ifr_flags & (IFF_PROMISC)) { ! 573: ifp->if_flags &= ~(IFF_PROMISC); ! 574: error = EINVAL; ! 575: } ! 576: break; ! 577: case SIOCADDMULTI: ! 578: case SIOCDELMULTI: ! 579: error = vlan_setmulti(ifp); ! 580: break; ! 581: default: ! 582: error = EINVAL; ! 583: } ! 584: return error; ! 585: } ! 586: ! 587: #endif /* NVLAN > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.