sbin/etherswitchcfg/etherswitchcfg.c

   1 /*-
   2  * Copyright (c) 2011-2012 Stefan Bethke.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <ctype.h>
  33 #include <err.h>
  34 #include <errno.h>
  35 #include <fcntl.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <sysexits.h>
  40 #include <unistd.h>
  41 #include <sys/types.h>
  42 #include <sys/ioctl.h>
  43 #include <net/if.h>
  44 #include <net/if_media.h>
  45 #include <dev/etherswitch/etherswitch.h>
  46
  47 int     get_media_subtype(int, const char *);
  48 int     get_media_mode(int, const char *);
  49 int     get_media_options(int, const char *);
  50 int     lookup_media_word(struct ifmedia_description *, const char *);
  51 void    print_media_word(int, int);
  52 void    print_media_word_ifconfig(int);
  53
  54 /* some constants */
  55 #define IEEE802DOT1Q_VID_MAX    4094
  56 #define IFMEDIAREQ_NULISTENTRIES        256
  57
  58 enum cmdmode {
  59         MODE_NONE = 0,
  60         MODE_PORT,
  61         MODE_CONFIG,
  62         MODE_VLANGROUP,
  63         MODE_REGISTER,
  64         MODE_PHYREG
  65 };
  66
  67 struct cfg {
  68         int                                     fd;
  69         int                                     verbose;
  70         int                                     mediatypes;
  71         const char                      *controlfile;
  72         etherswitch_conf_t      conf;
  73         etherswitch_info_t      info;
  74         enum cmdmode            mode;
  75         int                                     unit;
  76 };
  77
  78 struct cmds {
  79         enum cmdmode    mode;
  80         const char              *name;
  81         int                             args;
  82         void                    (*f)(struct cfg *, char *argv[]);
  83 };
  84 static struct cmds cmds[];
  85
  86
  87 /*
  88  * Print a value a la the %b format of the kernel's printf.
  89  * Stolen from ifconfig.c.
  90  */
  91 static void
  92 printb(const char *s, unsigned v, const char *bits)
  93 {
  94         int i, any = 0;
  95         char c;
  96
  97         if (bits && *bits == 8)
  98                 printf("%s=%o", s, v);
  99         else
 100                 printf("%s=%x", s, v);
 101         bits++;
 102         if (bits) {
 103                 putchar('<');
 104                 while ((i = *bits++) != '\0') {
 105                         if (v & (1 << (i-1))) {
 106                                 if (any)
 107                                         putchar(',');
 108                                 any = 1;
 109                                 for (; (c = *bits) > 32; bits++)
 110                                         putchar(c);
 111                         } else
 112                                 for (; *bits > 32; bits++)
 113                                         ;
 114                 }
 115                 putchar('>');
 116         }
 117 }
 118
 119 static int
 120 read_register(struct cfg *cfg, int r)
 121 {
 122         struct etherswitch_reg er;
 123
 124         er.reg = r;
 125         if (ioctl(cfg->fd, IOETHERSWITCHGETREG, &er) != 0)
 126                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETREG)");
 127         return (er.val);
 128 }
 129
 130 static void
 131 write_register(struct cfg *cfg, int r, int v)
 132 {
 133         struct etherswitch_reg er;
 134
 135         er.reg = r;
 136         er.val = v;
 137         if (ioctl(cfg->fd, IOETHERSWITCHSETREG, &er) != 0)
 138                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETREG)");
 139 }
 140
 141 static int
 142 read_phyregister(struct cfg *cfg, int phy, int reg)
 143 {
 144         struct etherswitch_phyreg er;
 145
 146         er.phy = phy;
 147         er.reg = reg;
 148         if (ioctl(cfg->fd, IOETHERSWITCHGETPHYREG, &er) != 0)
 149                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETPHYREG)");
 150         return (er.val);
 151 }
 152
 153 static void
 154 write_phyregister(struct cfg *cfg, int phy, int reg, int val)
 155 {
 156         struct etherswitch_phyreg er;
 157
 158         er.phy = phy;
 159         er.reg = reg;
 160         er.val = val;
 161         if (ioctl(cfg->fd, IOETHERSWITCHSETPHYREG, &er) != 0)
 162                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETPHYREG)");
 163 }
 164
 165 static void
 166 set_port_vid(struct cfg *cfg, char *argv[])
 167 {
 168         int v;
 169         etherswitch_port_t p;
 170
 171         v = strtol(argv[1], NULL, 0);
 172         if (v < 0 || v > IEEE802DOT1Q_VID_MAX)
 173                 errx(EX_USAGE, "pvid must be between 0 and %d",
 174                     IEEE802DOT1Q_VID_MAX);
 175         bzero(&p, sizeof(p));
 176         p.es_port = cfg->unit;
 177         if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)
 178                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");
 179         p.es_pvid = v;
 180         if (ioctl(cfg->fd, IOETHERSWITCHSETPORT, &p) != 0)
 181                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETPORT)");
 182 }
 183
 184 static void
 185 set_port_flag(struct cfg *cfg, char *argv[])
 186 {
 187         char *flag;
 188         int n;
 189         uint32_t f;
 190         etherswitch_port_t p;
 191
 192         n = 0;
 193         f = 0;
 194         flag = argv[0];
 195         if (strcmp(flag, "none") != 0) {
 196                 if (*flag == '-') {
 197                         n++;
 198                         flag++;
 199                 }
 200                 if (strcasecmp(flag, "striptag") == 0)
 201                         f = ETHERSWITCH_PORT_STRIPTAG;
 202                 else if (strcasecmp(flag, "addtag") == 0)
 203                         f = ETHERSWITCH_PORT_ADDTAG;
 204                 else if (strcasecmp(flag, "firstlock") == 0)
 205                         f = ETHERSWITCH_PORT_FIRSTLOCK;
 206                 else if (strcasecmp(flag, "dropuntagged") == 0)
 207                         f = ETHERSWITCH_PORT_DROPUNTAGGED;
 208                 else if (strcasecmp(flag, "doubletag") == 0)
 209                         f = ETHERSWITCH_PORT_DOUBLE_TAG;
 210                 else if (strcasecmp(flag, "ingress") == 0)
 211                         f = ETHERSWITCH_PORT_INGRESS;
 212         }
 213         bzero(&p, sizeof(p));
 214         p.es_port = cfg->unit;
 215         if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)
 216                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");
 217         if (n)
 218                 p.es_flags &= ~f;
 219         else
 220                 p.es_flags |= f;
 221         if (ioctl(cfg->fd, IOETHERSWITCHSETPORT, &p) != 0)
 222                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETPORT)");
 223 }
 224
 225 static void
 226 set_port_media(struct cfg *cfg, char *argv[])
 227 {
 228         etherswitch_port_t p;
 229         int ifm_ulist[IFMEDIAREQ_NULISTENTRIES];
 230         int subtype;
 231
 232         bzero(&p, sizeof(p));
 233         p.es_port = cfg->unit;
 234         p.es_ifmr.ifm_ulist = ifm_ulist;
 235         p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;
 236         if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)
 237                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");
 238         if (p.es_ifmr.ifm_count == 0)
 239                 return;
 240         subtype = get_media_subtype(IFM_TYPE(ifm_ulist[0]), argv[1]);
 241         p.es_ifr.ifr_media = (p.es_ifmr.ifm_current & IFM_IMASK) |
 242                 IFM_TYPE(ifm_ulist[0]) | subtype;
 243         if (ioctl(cfg->fd, IOETHERSWITCHSETPORT, &p) != 0)
 244                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETPORT)");
 245 }
 246
 247 static void
 248 set_port_mediaopt(struct cfg *cfg, char *argv[])
 249 {
 250         etherswitch_port_t p;
 251         int ifm_ulist[IFMEDIAREQ_NULISTENTRIES];
 252         int options;
 253
 254         bzero(&p, sizeof(p));
 255         p.es_port = cfg->unit;
 256         p.es_ifmr.ifm_ulist = ifm_ulist;
 257         p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;
 258         if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)
 259                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");
 260         options = get_media_options(IFM_TYPE(ifm_ulist[0]), argv[1]);
 261         if (options == -1)
 262                 errx(EX_USAGE, "invalid media options \"%s\"", argv[1]);
 263         if (options & IFM_HDX) {
 264                 p.es_ifr.ifr_media &= ~IFM_FDX;
 265                 options &= ~IFM_HDX;
 266         }
 267         p.es_ifr.ifr_media |= options;
 268         if (ioctl(cfg->fd, IOETHERSWITCHSETPORT, &p) != 0)
 269                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETPORT)");
 270 }
 271
 272 static void
 273 set_vlangroup_vid(struct cfg *cfg, char *argv[])
 274 {
 275         int v;
 276         etherswitch_vlangroup_t vg;
 277
 278         memset(&vg, 0, sizeof(vg));
 279         v = strtol(argv[1], NULL, 0);
 280         if (v < 0 || v > IEEE802DOT1Q_VID_MAX)
 281                 errx(EX_USAGE, "vlan must be between 0 and %d", IEEE802DOT1Q_VID_MAX);
 282         vg.es_vlangroup = cfg->unit;
 283         if (ioctl(cfg->fd, IOETHERSWITCHGETVLANGROUP, &vg) != 0)
 284                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETVLANGROUP)");
 285         vg.es_vid = v;
 286         if (ioctl(cfg->fd, IOETHERSWITCHSETVLANGROUP, &vg) != 0)
 287                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETVLANGROUP)");
 288 }
 289
 290 static void
 291 set_vlangroup_members(struct cfg *cfg, char *argv[])
 292 {
 293         etherswitch_vlangroup_t vg;
 294         int member, untagged;
 295         char *c, *d;
 296         int v;
 297
 298         member = untagged = 0;
 299         memset(&vg, 0, sizeof(vg));
 300         if (strcmp(argv[1], "none") != 0) {
 301                 for (c=argv[1]; *c; c=d) {
 302                         v = strtol(c, &d, 0);
 303                         if (d == c)
 304                                 break;
 305                         if (v < 0 || v >= cfg->info.es_nports)
 306                                 errx(EX_USAGE, "Member port must be between 0 and %d", cfg->info.es_nports-1);
 307                         if (d[0] == ',' || d[0] == '\0' ||
 308                                 ((d[0] == 't' || d[0] == 'T') && (d[1] == ',' || d[1] == '\0'))) {
 309                                 if (d[0] == 't' || d[0] == 'T') {
 310                                         untagged &= ~ETHERSWITCH_PORTMASK(v);
 311                                         d++;
 312                                 } else
 313                                         untagged |= ETHERSWITCH_PORTMASK(v);
 314                                 member |= ETHERSWITCH_PORTMASK(v);
 315                                 d++;
 316                         } else
 317                                 errx(EX_USAGE, "Invalid members specification \"%s\"", d);
 318                 }
 319         }
 320         vg.es_vlangroup = cfg->unit;
 321         if (ioctl(cfg->fd, IOETHERSWITCHGETVLANGROUP, &vg) != 0)
 322                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETVLANGROUP)");
 323         vg.es_member_ports = member;
 324         vg.es_untagged_ports = untagged;
 325         if (ioctl(cfg->fd, IOETHERSWITCHSETVLANGROUP, &vg) != 0)
 326                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETVLANGROUP)");
 327 }
 328
 329 static int
 330 set_register(struct cfg *cfg, char *arg)
 331 {
 332         int a, v;
 333         char *c;
 334
 335         a = strtol(arg, &c, 0);
 336         if (c==arg)
 337                 return (1);
 338         if (*c == '=') {
 339                 v = strtol(c+1, NULL, 0);
 340                 write_register(cfg, a, v);
 341         }
 342         printf("\treg 0x%04x=0x%04x\n", a, read_register(cfg, a));
 343         return (0);
 344 }
 345
 346 static int
 347 set_phyregister(struct cfg *cfg, char *arg)
 348 {
 349         int phy, reg, val;
 350         char *c, *d;
 351
 352         phy = strtol(arg, &c, 0);
 353         if (c==arg)
 354                 return (1);
 355         if (*c != '.')
 356                 return (1);
 357         d = c+1;
 358         reg = strtol(d, &c, 0);
 359         if (d == c)
 360                 return (1);
 361         if (*c == '=') {
 362                 val = strtol(c+1, NULL, 0);
 363                 write_phyregister(cfg, phy, reg, val);
 364         }
 365         printf("\treg %d.0x%02x=0x%04x\n", phy, reg, read_phyregister(cfg, phy, reg));
 366         return (0);
 367 }
 368
 369 static void
 370 set_vlan_mode(struct cfg *cfg, char *argv[])
 371 {
 372         etherswitch_conf_t conf;
 373
 374         bzero(&conf, sizeof(conf));
 375         conf.cmd = ETHERSWITCH_CONF_VLAN_MODE;
 376         if (strcasecmp(argv[1], "isl") == 0)
 377                 conf.vlan_mode = ETHERSWITCH_VLAN_ISL;
 378         else if (strcasecmp(argv[1], "port") == 0)
 379                 conf.vlan_mode = ETHERSWITCH_VLAN_PORT;
 380         else if (strcasecmp(argv[1], "dot1q") == 0)
 381                 conf.vlan_mode = ETHERSWITCH_VLAN_DOT1Q;
 382         else if (strcasecmp(argv[1], "dot1q4k") == 0)
 383                 conf.vlan_mode = ETHERSWITCH_VLAN_DOT1Q_4K;
 384         else if (strcasecmp(argv[1], "qinq") == 0)
 385                 conf.vlan_mode = ETHERSWITCH_VLAN_DOUBLE_TAG;
 386         else
 387                 conf.vlan_mode = 0;
 388         if (ioctl(cfg->fd, IOETHERSWITCHSETCONF, &conf) != 0)
 389                 err(EX_OSERR, "ioctl(IOETHERSWITCHSETCONF)");
 390 }
 391
 392 static void
 393 print_config(struct cfg *cfg)
 394 {
 395         const char *c;
 396
 397         /* Get the device name. */
 398         c = strrchr(cfg->controlfile, '/');
 399         if (c != NULL)
 400                 c = c + 1;
 401         else
 402                 c = cfg->controlfile;
 403
 404         /* Print VLAN mode. */
 405         if (cfg->conf.cmd & ETHERSWITCH_CONF_VLAN_MODE) {
 406                 printf("%s: VLAN mode: ", c);
 407                 switch (cfg->conf.vlan_mode) {
 408                 case ETHERSWITCH_VLAN_ISL:
 409                         printf("ISL\n");
 410                         break;
 411                 case ETHERSWITCH_VLAN_PORT:
 412                         printf("PORT\n");
 413                         break;
 414                 case ETHERSWITCH_VLAN_DOT1Q:
 415                         printf("DOT1Q\n");
 416                         break;
 417                 case ETHERSWITCH_VLAN_DOT1Q_4K:
 418                         printf("DOT1Q4K\n");
 419                         break;
 420                 case ETHERSWITCH_VLAN_DOUBLE_TAG:
 421                         printf("QinQ\n");
 422                         break;
 423                 default:
 424                         printf("none\n");
 425                 }
 426         }
 427 }
 428
 429 static void
 430 print_port(struct cfg *cfg, int port)
 431 {
 432         etherswitch_port_t p;
 433         int ifm_ulist[IFMEDIAREQ_NULISTENTRIES];
 434         int i;
 435
 436         bzero(&p, sizeof(p));
 437         p.es_port = port;
 438         p.es_ifmr.ifm_ulist = ifm_ulist;
 439         p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;
 440         if (ioctl(cfg->fd, IOETHERSWITCHGETPORT, &p) != 0)
 441                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETPORT)");
 442         printf("port%d:\n", port);
 443         if (cfg->conf.vlan_mode == ETHERSWITCH_VLAN_DOT1Q)
 444                 printf("\tpvid: %d\n", p.es_pvid);
 445         printb("\tflags", p.es_flags, ETHERSWITCH_PORT_FLAGS_BITS);
 446         printf("\n");
 447         printf("\tmedia: ");
 448         print_media_word(p.es_ifmr.ifm_current, 1);
 449         if (p.es_ifmr.ifm_active != p.es_ifmr.ifm_current) {
 450                 putchar(' ');
 451                 putchar('(');
 452                 print_media_word(p.es_ifmr.ifm_active, 0);
 453                 putchar(')');
 454         }
 455         putchar('\n');
 456         printf("\tstatus: %s\n", (p.es_ifmr.ifm_status & IFM_ACTIVE) != 0 ? "active" : "no carrier");
 457         if (cfg->mediatypes) {
 458                 printf("\tsupported media:\n");
 459                 if (p.es_ifmr.ifm_count > IFMEDIAREQ_NULISTENTRIES)
 460                         p.es_ifmr.ifm_count = IFMEDIAREQ_NULISTENTRIES;
 461                 for (i=0; i<p.es_ifmr.ifm_count; i++) {
 462                         printf("\t\tmedia ");
 463                         print_media_word(ifm_ulist[i], 0);
 464                         putchar('\n');
 465                 }
 466         }
 467 }
 468
 469 static void
 470 print_vlangroup(struct cfg *cfg, int vlangroup)
 471 {
 472         etherswitch_vlangroup_t vg;
 473         int i, comma;
 474
 475         vg.es_vlangroup = vlangroup;
 476         if (ioctl(cfg->fd, IOETHERSWITCHGETVLANGROUP, &vg) != 0)
 477                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETVLANGROUP)");
 478         if ((vg.es_vid & ETHERSWITCH_VID_VALID) == 0)
 479                 return;
 480         vg.es_vid &= ETHERSWITCH_VID_MASK;
 481         printf("vlangroup%d:\n", vlangroup);
 482         if (cfg->conf.vlan_mode == ETHERSWITCH_VLAN_PORT)
 483                 printf("\tport: %d\n", vg.es_vid);
 484         else
 485                 printf("\tvlan: %d\n", vg.es_vid);
 486         printf("\tmembers ");
 487         comma = 0;
 488         if (vg.es_member_ports != 0)
 489                 for (i=0; i<cfg->info.es_nports; i++) {
 490                         if ((vg.es_member_ports & ETHERSWITCH_PORTMASK(i)) != 0) {
 491                                 if (comma)
 492                                         printf(",");
 493                                 printf("%d", i);
 494                                 if ((vg.es_untagged_ports & ETHERSWITCH_PORTMASK(i)) == 0)
 495                                         printf("t");
 496                                 comma = 1;
 497                         }
 498                 }
 499         else
 500                 printf("none");
 501         printf("\n");
 502 }
 503
 504 static void
 505 print_info(struct cfg *cfg)
 506 {
 507         const char *c;
 508         int i;
 509
 510         c = strrchr(cfg->controlfile, '/');
 511         if (c != NULL)
 512                 c = c + 1;
 513         else
 514                 c = cfg->controlfile;
 515         if (cfg->verbose) {
 516                 printf("%s: %s with %d ports and %d VLAN groups\n", c,
 517                     cfg->info.es_name, cfg->info.es_nports,
 518                     cfg->info.es_nvlangroups);
 519                 printf("%s: ", c);
 520                 printb("VLAN capabilities",  cfg->info.es_vlan_caps,
 521                     ETHERSWITCH_VLAN_CAPS_BITS);
 522                 printf("\n");
 523         }
 524         print_config(cfg);
 525         for (i=0; i<cfg->info.es_nports; i++) {
 526                 print_port(cfg, i);
 527         }
 528         for (i=0; i<cfg->info.es_nvlangroups; i++) {
 529                 print_vlangroup(cfg, i);
 530         }
 531 }
 532
 533 static void
 534 usage(struct cfg *cfg __unused, char *argv[] __unused)
 535 {
 536         fprintf(stderr, "usage: etherswitchctl\n");
 537         fprintf(stderr, "\tetherswitchcfg [-f control file] info\n");
 538         fprintf(stderr, "\tetherswitchcfg [-f control file] config "
 539             "command parameter\n");
 540         fprintf(stderr, "\t\tconfig commands: vlan_mode\n");
 541         fprintf(stderr, "\tetherswitchcfg [-f control file] phy "
 542             "phy.register[=value]\n");
 543         fprintf(stderr, "\tetherswitchcfg [-f control file] portX "
 544             "[flags] command parameter\n");
 545         fprintf(stderr, "\t\tport commands: pvid, media, mediaopt\n");
 546         fprintf(stderr, "\tetherswitchcfg [-f control file] reg "
 547             "register[=value]\n");
 548         fprintf(stderr, "\tetherswitchcfg [-f control file] vlangroupX "
 549             "command parameter\n");
 550         fprintf(stderr, "\t\tvlangroup commands: vlan, members\n");
 551         exit(EX_USAGE);
 552 }
 553
 554 static void
 555 newmode(struct cfg *cfg, enum cmdmode mode)
 556 {
 557         if (mode == cfg->mode)
 558                 return;
 559         switch (cfg->mode) {
 560         case MODE_NONE:
 561                 break;
 562         case MODE_CONFIG:
 563                 /*
 564                  * Read the updated the configuration (it can be different
 565                  * from the last time we read it).
 566                  */
 567                 if (ioctl(cfg->fd, IOETHERSWITCHGETCONF, &cfg->conf) != 0)
 568                         err(EX_OSERR, "ioctl(IOETHERSWITCHGETCONF)");
 569                 print_config(cfg);
 570                 break;
 571         case MODE_PORT:
 572                 print_port(cfg, cfg->unit);
 573                 break;
 574         case MODE_VLANGROUP:
 575                 print_vlangroup(cfg, cfg->unit);
 576                 break;
 577         case MODE_REGISTER:
 578         case MODE_PHYREG:
 579                 break;
 580         }
 581         cfg->mode = mode;
 582 }
 583
 584 int
 585 main(int argc, char *argv[])
 586 {
 587         int ch;
 588         struct cfg cfg;
 589         int i;
 590
 591         bzero(&cfg, sizeof(cfg));
 592         cfg.controlfile = "/dev/etherswitch0";
 593         while ((ch = getopt(argc, argv, "f:mv?")) != -1)
 594                 switch(ch) {
 595                 case 'f':
 596                         cfg.controlfile = optarg;
 597                         break;
 598                 case 'm':
 599                         cfg.mediatypes++;
 600                         break;
 601                 case 'v':
 602                         cfg.verbose++;
 603                         break;
 604                 case '?':
 605                         /* FALLTHROUGH */
 606                 default:
 607                         usage(&cfg, argv);
 608                 }
 609         argc -= optind;
 610         argv += optind;
 611         cfg.fd = open(cfg.controlfile, O_RDONLY);
 612         if (cfg.fd < 0)
 613                 err(EX_UNAVAILABLE, "Can't open control file: %s", cfg.controlfile);
 614         if (ioctl(cfg.fd, IOETHERSWITCHGETINFO, &cfg.info) != 0)
 615                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETINFO)");
 616         if (ioctl(cfg.fd, IOETHERSWITCHGETCONF, &cfg.conf) != 0)
 617                 err(EX_OSERR, "ioctl(IOETHERSWITCHGETCONF)");
 618         if (argc == 0) {
 619                 print_info(&cfg);
 620                 return (0);
 621         }
 622         cfg.mode = MODE_NONE;
 623         while (argc > 0) {
 624                 switch(cfg.mode) {
 625                 case MODE_NONE:
 626                         if (strcmp(argv[0], "info") == 0) {
 627                                 print_info(&cfg);
 628                         } else if (sscanf(argv[0], "port%d", &cfg.unit) == 1) {
 629                                 if (cfg.unit < 0 || cfg.unit >= cfg.info.es_nports)
 630                                         errx(EX_USAGE, "port unit must be between 0 and %d", cfg.info.es_nports - 1);
 631                                 newmode(&cfg, MODE_PORT);
 632                         } else if (sscanf(argv[0], "vlangroup%d", &cfg.unit) == 1) {
 633                                 if (cfg.unit < 0 || cfg.unit >= cfg.info.es_nvlangroups)
 634                                         errx(EX_USAGE,
 635                                             "vlangroup unit must be between 0 and %d",
 636                                             cfg.info.es_nvlangroups - 1);
 637                                 newmode(&cfg, MODE_VLANGROUP);
 638                         } else if (strcmp(argv[0], "config") == 0) {
 639                                 newmode(&cfg, MODE_CONFIG);
 640                         } else if (strcmp(argv[0], "phy") == 0) {
 641                                 newmode(&cfg, MODE_PHYREG);
 642                         } else if (strcmp(argv[0], "reg") == 0) {
 643                                 newmode(&cfg, MODE_REGISTER);
 644                         } else if (strcmp(argv[0], "help") == 0) {
 645                                 usage(&cfg, argv);
 646                         } else {
 647                                 errx(EX_USAGE, "Unknown command \"%s\"", argv[0]);
 648                         }
 649                         break;
 650                 case MODE_PORT:
 651                 case MODE_CONFIG:
 652                 case MODE_VLANGROUP:
 653                         for(i=0; cmds[i].name != NULL; i++) {
 654                                 if (cfg.mode == cmds[i].mode && strcmp(argv[0], cmds[i].name) == 0) {
 655                                         if (argc < (cmds[i].args + 1)) {
 656                                                 printf("%s needs an argument\n", cmds[i].name);
 657                                                 break;
 658                                         }
 659                                         (cmds[i].f)(&cfg, argv);
 660                                         argc -= cmds[i].args;
 661                                         argv += cmds[i].args;
 662                                         break;
 663                                 }
 664                         }
 665                         if (cmds[i].name == NULL) {
 666                                 newmode(&cfg, MODE_NONE);
 667                                 continue;
 668                         }
 669                         break;
 670                 case MODE_REGISTER:
 671                         if (set_register(&cfg, argv[0]) != 0) {
 672                                 newmode(&cfg, MODE_NONE);
 673                                 continue;
 674                         }
 675                         break;
 676                 case MODE_PHYREG:
 677                         if (set_phyregister(&cfg, argv[0]) != 0) {
 678                                 newmode(&cfg, MODE_NONE);
 679                                 continue;
 680                         }
 681                         break;
 682                 }
 683                 argc--;
 684                 argv++;
 685         }
 686         /* switch back to command mode to print configuration for last command */
 687         newmode(&cfg, MODE_NONE);
 688         close(cfg.fd);
 689         return (0);
 690 }
 691
 692 static struct cmds cmds[] = {
 693         { MODE_PORT, "pvid", 1, set_port_vid },
 694         { MODE_PORT, "media", 1, set_port_media },
 695         { MODE_PORT, "mediaopt", 1, set_port_mediaopt },
 696         { MODE_PORT, "addtag", 0, set_port_flag },
 697         { MODE_PORT, "-addtag", 0, set_port_flag },
 698         { MODE_PORT, "ingress", 0, set_port_flag },
 699         { MODE_PORT, "-ingress", 0, set_port_flag },
 700         { MODE_PORT, "striptag", 0, set_port_flag },
 701         { MODE_PORT, "-striptag", 0, set_port_flag },
 702         { MODE_PORT, "doubletag", 0, set_port_flag },
 703         { MODE_PORT, "-doubletag", 0, set_port_flag },
 704         { MODE_PORT, "firstlock", 0, set_port_flag },
 705         { MODE_PORT, "-firstlock", 0, set_port_flag },
 706         { MODE_PORT, "dropuntagged", 0, set_port_flag },
 707         { MODE_PORT, "-dropuntagged", 0, set_port_flag },
 708         { MODE_CONFIG, "vlan_mode", 1, set_vlan_mode },
 709         { MODE_VLANGROUP, "vlan", 1, set_vlangroup_vid },
 710         { MODE_VLANGROUP, "members", 1, set_vlangroup_members },
 711         { 0, NULL, 0, NULL }
 712 };