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 #define NOTAG   ((u_short) -1)
  63
  64 static const char proto_8021Q[]  = "802.1q";
  65 static const char proto_8021ad[] = "802.1ad";
  66 static const char proto_qinq[] = "qinq";
  67
  68 static  struct vlanreq params = {
  69         .vlr_tag        = NOTAG,
  70         .vlr_proto      = ETHERTYPE_VLAN,
  71 };
  72
  73 static void
  74 vlan_status(if_ctx *ctx)
  75 {
  76         struct vlanreq vreq = {};
  77         struct ifreq ifr = { .ifr_data = (caddr_t)&vreq };
  78
  79         if (ioctl_ctx_ifr(ctx, SIOCGETVLAN, &ifr) == -1)
  80                 return;
  81         printf("\tvlan: %d", vreq.vlr_tag);
  82         printf(" vlanproto: ");
  83         switch (vreq.vlr_proto) {
  84                 case ETHERTYPE_VLAN:
  85                         printf(proto_8021Q);
  86                         break;
  87                 case ETHERTYPE_QINQ:
  88                         printf(proto_8021ad);
  89                         break;
  90                 default:
  91                         printf("0x%04x", vreq.vlr_proto);
  92         }
  93         if (ioctl_ctx_ifr(ctx, SIOCGVLANPCP, &ifr) != -1)
  94                 printf(" vlanpcp: %u", ifr.ifr_vlan_pcp);
  95         printf(" parent interface: %s", vreq.vlr_parent[0] == '\0' ?
  96             "<none>" : vreq.vlr_parent);
  97         printf("\n");
  98 }
  99
 100 static int
 101 vlan_match_ethervid(const char *name)
 102 {
 103         return (strchr(name, '.') != NULL);
 104 }
 105
 106 static void
 107 vlan_parse_ethervid(const char *name)
 108 {
 109         char ifname[IFNAMSIZ];
 110         char *cp;
 111         unsigned int vid;
 112
 113         strlcpy(ifname, name, IFNAMSIZ);
 114         if ((cp = strrchr(ifname, '.')) == NULL)
 115                 return;
 116         /*
 117          * Derive params from interface name: "parent.vid".
 118          */
 119         *cp++ = '\0';
 120         if ((*cp < '1') || (*cp > '9'))
 121                 errx(1, "invalid vlan tag");
 122
 123         vid = *cp++ - '0';
 124         while ((*cp >= '0') && (*cp <= '9')) {
 125                 vid = (vid * 10) + (*cp++ - '0');
 126                 if (vid >= 0xFFF)
 127                         errx(1, "invalid vlan tag");
 128         }
 129         if (*cp != '\0')
 130                 errx(1, "invalid vlan tag");
 131
 132         /*
 133          * allow "devX.Y vlandev devX vlan Y" syntax
 134          */
 135         if (params.vlr_tag == NOTAG || params.vlr_tag == vid)
 136                 params.vlr_tag = vid;
 137         else
 138                 errx(1, "ambiguous vlan specification");
 139
 140         /* Restrict overriding interface name */
 141         if (params.vlr_parent[0] == '\0' || !strcmp(params.vlr_parent, ifname))
 142                 strlcpy(params.vlr_parent, ifname, IFNAMSIZ);
 143         else
 144                 errx(1, "ambiguous vlan specification");
 145 }
 146
 147 static void
 148 vlan_create(if_ctx *ctx, struct ifreq *ifr)
 149 {
 150         vlan_parse_ethervid(ifr->ifr_name);
 151
 152         if (params.vlr_tag != NOTAG || params.vlr_parent[0] != '\0') {
 153                 /*
 154                  * One or both parameters were specified, make sure both.
 155                  */
 156                 if (params.vlr_tag == NOTAG)
 157                         errx(1, "must specify a tag for vlan create");
 158                 if (params.vlr_parent[0] == '\0')
 159                         errx(1, "must specify a parent device for vlan create");
 160                 ifr->ifr_data = (caddr_t) &params;
 161         }
 162         ifcreate_ioctl(ctx, ifr);
 163 }
 164
 165 static void
 166 vlan_cb(if_ctx *ctx __unused, void *arg __unused)
 167 {
 168         if ((params.vlr_tag != NOTAG) ^ (params.vlr_parent[0] != '\0'))
 169                 errx(1, "both vlan and vlandev must be specified");
 170 }
 171
 172 static void
 173 vlan_set(int s, struct ifreq *ifr)
 174 {
 175         if (params.vlr_tag != NOTAG && params.vlr_parent[0] != '\0') {
 176                 ifr->ifr_data = (caddr_t) &params;
 177                 if (ioctl(s, SIOCSETVLAN, (caddr_t)ifr) == -1)
 178                         err(1, "SIOCSETVLAN");
 179         }
 180 }
 181
 182 static void
 183 setvlantag(if_ctx *ctx, const char *val, int dummy __unused)
 184 {
 185         struct vlanreq vreq = {};
 186         struct ifreq ifr = { .ifr_data = (caddr_t)&vreq };
 187         u_long ul;
 188         char *endp;
 189
 190         ul = strtoul(val, &endp, 0);
 191         if (*endp != '\0')
 192                 errx(1, "invalid value for vlan");
 193         params.vlr_tag = ul;
 194         /* check if the value can be represented in vlr_tag */
 195         if (params.vlr_tag != ul)
 196                 errx(1, "value for vlan out of range");
 197
 198         if (ioctl_ctx_ifr(ctx, SIOCGETVLAN, &ifr) != -1) {
 199                 vreq.vlr_tag = params.vlr_tag;
 200                 memcpy(&params, &vreq, sizeof(params));
 201                 vlan_set(ctx->io_s, &ifr);
 202         }
 203 }
 204
 205 static void
 206 setvlandev(if_ctx *ctx, const char *val, int dummy __unused)
 207 {
 208         struct vlanreq vreq = {};
 209         struct ifreq ifr = { .ifr_data = (caddr_t)&vreq };
 210
 211         strlcpy(params.vlr_parent, val, sizeof(params.vlr_parent));
 212
 213         if (ioctl_ctx_ifr(ctx, SIOCGETVLAN, &ifr) != -1)
 214                 vlan_set(ctx->io_s, &ifr);
 215 }
 216
 217 static void
 218 setvlanproto(if_ctx *ctx, const char *val, int dummy __unused)
 219 {
 220         struct vlanreq vreq = {};
 221         struct ifreq ifr = { .ifr_data = (caddr_t)&vreq };
 222
 223         if (strncasecmp(proto_8021Q, val,
 224             strlen(proto_8021Q)) == 0) {
 225                 params.vlr_proto = ETHERTYPE_VLAN;
 226         } else if ((strncasecmp(proto_8021ad, val, strlen(proto_8021ad)) == 0)
 227             || (strncasecmp(proto_qinq, val, strlen(proto_qinq)) == 0)) {
 228                 params.vlr_proto = ETHERTYPE_QINQ;
 229         } else
 230                 errx(1, "invalid value for vlanproto");
 231
 232         if (ioctl_ctx_ifr(ctx, SIOCGETVLAN, &ifr) != -1) {
 233                 vreq.vlr_proto = params.vlr_proto;
 234                 memcpy(&params, &vreq, sizeof(params));
 235                 vlan_set(ctx->io_s, &ifr);
 236         }
 237 }
 238
 239 static void
 240 setvlanpcp(if_ctx *ctx, const char *val, int dummy __unused)
 241 {
 242         u_long ul;
 243         char *endp;
 244         struct ifreq ifr = {};
 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_ctx_ifr(ctx, SIOCSVLANPCP, &ifr) == -1)
 253                 err(1, "SIOCSVLANPCP");
 254 }
 255
 256 static void
 257 unsetvlandev(if_ctx *ctx, const char *val __unused, int dummy __unused)
 258 {
 259         struct vlanreq vreq = {};
 260         struct ifreq ifr = { .ifr_data = (caddr_t)&vreq };
 261
 262         if (ioctl_ctx_ifr(ctx, SIOCGETVLAN, &ifr) == -1)
 263                 err(1, "SIOCGETVLAN");
 264
 265         bzero((char *)&vreq.vlr_parent, sizeof(vreq.vlr_parent));
 266         vreq.vlr_tag = 0;
 267
 268         if (ioctl_ctx(ctx, SIOCSETVLAN, (caddr_t)&ifr) == -1)
 269                 err(1, "SIOCSETVLAN");
 270 }
 271
 272 static struct cmd vlan_cmds[] = {
 273         DEF_CLONE_CMD_ARG("vlan",                       setvlantag),
 274         DEF_CLONE_CMD_ARG("vlandev",                    setvlandev),
 275         DEF_CLONE_CMD_ARG("vlanproto",                  setvlanproto),
 276         DEF_CMD_ARG("vlanpcp",                          setvlanpcp),
 277         /* NB: non-clone cmds */
 278         DEF_CMD_ARG("vlan",                             setvlantag),
 279         DEF_CMD_ARG("vlandev",                          setvlandev),
 280         DEF_CMD_ARG("vlanproto",                        setvlanproto),
 281         /* XXX For compatibility.  Should become DEF_CMD() some day. */
 282         DEF_CMD_OPTARG("-vlandev",                      unsetvlandev),
 283         DEF_CMD("vlanmtu",      IFCAP_VLAN_MTU,         setifcap),
 284         DEF_CMD("-vlanmtu",     IFCAP_VLAN_MTU,         clearifcap),
 285         DEF_CMD("vlanhwtag",    IFCAP_VLAN_HWTAGGING,   setifcap),
 286         DEF_CMD("-vlanhwtag",   IFCAP_VLAN_HWTAGGING,   clearifcap),
 287         DEF_CMD("vlanhwfilter", IFCAP_VLAN_HWFILTER,    setifcap),
 288         DEF_CMD("-vlanhwfilter", IFCAP_VLAN_HWFILTER,   clearifcap),
 289         DEF_CMD("vlanhwtso",    IFCAP_VLAN_HWTSO,       setifcap),
 290         DEF_CMD("-vlanhwtso",   IFCAP_VLAN_HWTSO,       clearifcap),
 291         DEF_CMD("vlanhwcsum",   IFCAP_VLAN_HWCSUM,      setifcap),
 292         DEF_CMD("-vlanhwcsum",  IFCAP_VLAN_HWCSUM,      clearifcap),
 293 };
 294 static struct afswtch af_vlan = {
 295         .af_name        = "af_vlan",
 296         .af_af          = AF_UNSPEC,
 297         .af_other_status = vlan_status,
 298 };
 299
 300 static __constructor void
 301 vlan_ctor(void)
 302 {
 303         size_t i;
 304
 305         for (i = 0; i < nitems(vlan_cmds);  i++)
 306                 cmd_register(&vlan_cmds[i]);
 307         af_register(&af_vlan);
 308         callback_register(vlan_cb, NULL);
 309         clone_setdefcallback_prefix("vlan", vlan_create);
 310         clone_setdefcallback_filter(vlan_match_ethervid, vlan_create);
 311 }