sbin/ifconfig/ifvlan.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 1999 Bill Paul <wpaul@ctr.columbia.edu>
   5  * Copyright (c) 2012 ADARA Networks, Inc.
   6  * All rights reserved.
   7   *
   8  * Portions of this software were developed by Robert N. M. Watson under
   9  * contract to ADARA Networks, Inc.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *      This product includes software developed by Bill Paul.
  22  * 4. Neither the name of the author nor the names of any co-contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  36  * THE POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/ioctl.h>
  41 #include <sys/socket.h>
  42 #include <sys/sockio.h>
  43
  44 #include <stdlib.h>
  45 #include <unistd.h>
  46
  47 #include <net/ethernet.h>
  48 #include <net/if.h>
  49 #include <net/if_vlan_var.h>
  50 #include <net/route.h>
  51
  52 #include <ctype.h>
  53 #include <stdio.h>
  54 #include <string.h>
  55 #include <stdlib.h>
  56 #include <unistd.h>
  57 #include <err.h>
  58 #include <errno.h>
  59
  60 #include "ifconfig.h"
  61
  62 #ifndef lint
  63 static const char rcsid[] =
  64   "$FreeBSD$";
  65 #endif
  66
  67 #define NOTAG   ((u_short) -1)
  68
  69 static const char proto_8021Q[]  = "802.1q";
  70 static const char proto_8021ad[] = "802.1ad";
  71 static const char proto_qinq[] = "qinq";
  72
  73 static  struct vlanreq params = {
  74         .vlr_tag        = NOTAG,
  75         .vlr_proto      = ETHERTYPE_VLAN,
  76 };
  77
  78 static int
  79 getvlan(int s, struct ifreq *ifr, struct vlanreq *vreq)
  80 {
  81         bzero((char *)vreq, sizeof(*vreq));
  82         ifr->ifr_data = (caddr_t)vreq;
  83
  84         return ioctl(s, SIOCGETVLAN, (caddr_t)ifr);
  85 }
  86
  87 static void
  88 vlan_status(int s)
  89 {
  90         struct vlanreq          vreq;
  91
  92         if (getvlan(s, &ifr, &vreq) == -1)
  93                 return;
  94         printf("\tvlan: %d", vreq.vlr_tag);
  95         printf(" vlanproto: ");
  96         switch (vreq.vlr_proto) {
  97                 case ETHERTYPE_VLAN:
  98                         printf(proto_8021Q);
  99                         break;
 100                 case ETHERTYPE_QINQ:
 101                         printf(proto_8021ad);
 102                         break;
 103                 default:
 104                         printf("0x%04x", vreq.vlr_proto);
 105         }
 106         if (ioctl(s, SIOCGVLANPCP, (caddr_t)&ifr) != -1)
 107                 printf(" vlanpcp: %u", ifr.ifr_vlan_pcp);
 108         printf(" parent interface: %s", vreq.vlr_parent[0] == '\0' ?
 109             "<none>" : vreq.vlr_parent);
 110         printf("\n");
 111 }
 112
 113 static int
 114 vlan_match_ethervid(const char *name)
 115 {
 116         return (strchr(name, '.') != NULL);
 117 }
 118
 119 static void
 120 vlan_parse_ethervid(const char *name)
 121 {
 122         char ifname[IFNAMSIZ];
 123         char *cp;
 124         int vid;
 125
 126         strlcpy(ifname, name, IFNAMSIZ);
 127         if ((cp = strrchr(ifname, '.')) == NULL)
 128                 return;
 129         /*
 130          * Derive params from interface name: "parent.vid".
 131          */
 132         *cp++ = '\0';
 133         if ((*cp < '1') || (*cp > '9'))
 134                 errx(1, "invalid vlan tag");
 135
 136         vid = *cp++ - '0';
 137         while ((*cp >= '0') && (*cp <= '9'))
 138                 vid = (vid * 10) + (*cp++ - '0');
 139         if ((*cp != '\0') || (vid & ~0xFFF))
 140                 errx(1, "invalid vlan tag");
 141
 142         /*
 143          * allow "devX.Y vlandev devX vlan Y" syntax
 144          */
 145         if (params.vlr_tag == NOTAG || params.vlr_tag == vid)
 146                 params.vlr_tag = vid;
 147         else
 148                 errx(1, "ambiguous vlan specification");
 149
 150         /* Restrict overriding interface name */
 151         if (params.vlr_parent[0] == '\0' || !strcmp(params.vlr_parent, ifname))
 152                 strlcpy(params.vlr_parent, ifname, IFNAMSIZ);
 153         else
 154                 errx(1, "ambiguous vlan specification");
 155 }
 156
 157 static void
 158 vlan_create(int s, struct ifreq *ifr)
 159 {
 160         vlan_parse_ethervid(ifr->ifr_name);
 161
 162         if (params.vlr_tag != NOTAG || params.vlr_parent[0] != '\0') {
 163                 /*
 164                  * One or both parameters were specified, make sure both.
 165                  */
 166                 if (params.vlr_tag == NOTAG)
 167                         errx(1, "must specify a tag for vlan create");
 168                 if (params.vlr_parent[0] == '\0')
 169                         errx(1, "must specify a parent device for vlan create");
 170                 ifr->ifr_data = (caddr_t) &params;
 171         }
 172         ioctl_ifcreate(s, ifr);
 173 }
 174
 175 static void
 176 vlan_cb(int s, void *arg)
 177 {
 178         if ((params.vlr_tag != NOTAG) ^ (params.vlr_parent[0] != '\0'))
 179                 errx(1, "both vlan and vlandev must be specified");
 180 }
 181
 182 static void
 183 vlan_set(int s, struct ifreq *ifr)
 184 {
 185         if (params.vlr_tag != NOTAG && params.vlr_parent[0] != '\0') {
 186                 ifr->ifr_data = (caddr_t) &params;
 187                 if (ioctl(s, SIOCSETVLAN, (caddr_t)ifr) == -1)
 188                         err(1, "SIOCSETVLAN");
 189         }
 190 }
 191
 192 static
 193 DECL_CMD_FUNC(setvlantag, val, d)
 194 {
 195         struct vlanreq vreq;
 196         u_long ul;
 197         char *endp;
 198
 199         ul = strtoul(val, &endp, 0);
 200         if (*endp != '\0')
 201                 errx(1, "invalid value for vlan");
 202         params.vlr_tag = ul;
 203         /* check if the value can be represented in vlr_tag */
 204         if (params.vlr_tag != ul)
 205                 errx(1, "value for vlan out of range");
 206
 207         if (getvlan(s, &ifr, &vreq) != -1)
 208                 vlan_set(s, &ifr);
 209 }
 210
 211 static
 212 DECL_CMD_FUNC(setvlandev, val, d)
 213 {
 214         struct vlanreq vreq;
 215
 216         strlcpy(params.vlr_parent, val, sizeof(params.vlr_parent));
 217
 218         if (getvlan(s, &ifr, &vreq) != -1)
 219                 vlan_set(s, &ifr);
 220 }
 221
 222 static
 223 DECL_CMD_FUNC(setvlanproto, val, d)
 224 {
 225         struct vlanreq vreq;
 226
 227         if (strncasecmp(proto_8021Q, val,
 228             strlen(proto_8021Q)) == 0) {
 229                 params.vlr_proto = ETHERTYPE_VLAN;
 230         } else if ((strncasecmp(proto_8021ad, val, strlen(proto_8021ad)) == 0)
 231             || (strncasecmp(proto_qinq, val, strlen(proto_qinq)) == 0)) {
 232                 params.vlr_proto = ETHERTYPE_QINQ;
 233         } else
 234                 errx(1, "invalid value for vlanproto");
 235
 236         if (getvlan(s, &ifr, &vreq) != -1)
 237                 vlan_set(s, &ifr);
 238 }
 239
 240 static
 241 DECL_CMD_FUNC(setvlanpcp, val, d)
 242 {
 243         u_long ul;
 244         char *endp;
 245
 246         ul = strtoul(val, &endp, 0);
 247         if (*endp != '\0')
 248                 errx(1, "invalid value for vlanpcp");
 249         if (ul > 7)
 250                 errx(1, "value for vlanpcp out of range");
 251         ifr.ifr_vlan_pcp = ul;
 252         if (ioctl(s, SIOCSVLANPCP, (caddr_t)&ifr) == -1)
 253                 err(1, "SIOCSVLANPCP");
 254 }
 255
 256 static
 257 DECL_CMD_FUNC(unsetvlandev, val, d)
 258 {
 259         struct vlanreq          vreq;
 260
 261         bzero((char *)&vreq, sizeof(struct vlanreq));
 262         ifr.ifr_data = (caddr_t)&vreq;
 263
 264         if (ioctl(s, SIOCGETVLAN, (caddr_t)&ifr) == -1)
 265                 err(1, "SIOCGETVLAN");
 266
 267         bzero((char *)&vreq.vlr_parent, sizeof(vreq.vlr_parent));
 268         vreq.vlr_tag = 0;
 269
 270         if (ioctl(s, SIOCSETVLAN, (caddr_t)&ifr) == -1)
 271                 err(1, "SIOCSETVLAN");
 272 }
 273
 274 static struct cmd vlan_cmds[] = {
 275         DEF_CLONE_CMD_ARG("vlan",                       setvlantag),
 276         DEF_CLONE_CMD_ARG("vlandev",                    setvlandev),
 277         DEF_CLONE_CMD_ARG("vlanproto",                  setvlanproto),
 278         DEF_CMD_ARG("vlanpcp",                          setvlanpcp),
 279         /* NB: non-clone cmds */
 280         DEF_CMD_ARG("vlan",                             setvlantag),
 281         DEF_CMD_ARG("vlandev",                          setvlandev),
 282         DEF_CMD_ARG("vlanproto",                        setvlanproto),
 283         /* XXX For compatibility.  Should become DEF_CMD() some day. */
 284         DEF_CMD_OPTARG("-vlandev",                      unsetvlandev),
 285         DEF_CMD("vlanmtu",      IFCAP_VLAN_MTU,         setifcap),
 286         DEF_CMD("-vlanmtu",     -IFCAP_VLAN_MTU,        setifcap),
 287         DEF_CMD("vlanhwtag",    IFCAP_VLAN_HWTAGGING,   setifcap),
 288         DEF_CMD("-vlanhwtag",   -IFCAP_VLAN_HWTAGGING,  setifcap),
 289         DEF_CMD("vlanhwfilter", IFCAP_VLAN_HWFILTER,    setifcap),
 290         DEF_CMD("-vlanhwfilter", -IFCAP_VLAN_HWFILTER,  setifcap),
 291         DEF_CMD("-vlanhwtso",   -IFCAP_VLAN_HWTSO,      setifcap),
 292         DEF_CMD("vlanhwtso",    IFCAP_VLAN_HWTSO,       setifcap),
 293         DEF_CMD("vlanhwcsum",   IFCAP_VLAN_HWCSUM,      setifcap),
 294         DEF_CMD("-vlanhwcsum",  -IFCAP_VLAN_HWCSUM,     setifcap),
 295 };
 296 static struct afswtch af_vlan = {
 297         .af_name        = "af_vlan",
 298         .af_af          = AF_UNSPEC,
 299         .af_other_status = vlan_status,
 300 };
 301
 302 static __constructor void
 303 vlan_ctor(void)
 304 {
 305         size_t i;
 306
 307         for (i = 0; i < nitems(vlan_cmds);  i++)
 308                 cmd_register(&vlan_cmds[i]);
 309         af_register(&af_vlan);
 310         callback_register(vlan_cb, NULL);
 311         clone_setdefcallback_prefix("vlan", vlan_create);
 312         clone_setdefcallback_filter(vlan_match_ethervid, vlan_create);
 313 }