bin/chio/chio.c

   1 /*      $NetBSD: chio.c,v 1.6 1998/01/04 23:53:58 thorpej Exp $ */
   2 /*-
   3  * Copyright (c) 1996 Jason R. Thorpe <thorpej@and.com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgements:
  16  *      This product includes software developed by Jason R. Thorpe
  17  *      for And Communications, http://www.and.com/
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 /*
  34  * Additional Copyright (c) 1997, by Matthew Jacob, for NASA/Ames Research Ctr.
  35  * Addidional Copyright (c) 2000, by C. Stephen Gunn, Waterspout Communications
  36  */
  37
  38 #if 0
  39 #ifndef lint
  40 static const char copyright[] =
  41         "@(#) Copyright (c) 1996 Jason R. Thorpe.  All rights reserved.";
  42 #endif /* not lint */
  43 #endif
  44
  45 #include <sys/cdefs.h>
  46 __FBSDID("$FreeBSD$");
  47
  48 #include <sys/param.h>
  49 #include <sys/chio.h>
  50 #include <err.h>
  51 #include <fcntl.h>
  52 #include <stdio.h>
  53 #include <stdint.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <unistd.h>
  57 #include <langinfo.h>
  58 #include <locale.h>
  59
  60 #include "defs.h"
  61 #include "pathnames.h"
  62
  63 static  void usage(void);
  64 static  void cleanup(void);
  65 static  u_int16_t parse_element_type(char *);
  66 static  u_int16_t parse_element_unit(char *);
  67 static  const char * element_type_name(int et);
  68 static  int parse_special(char *);
  69 static  int is_special(char *);
  70 static  const char *bits_to_string(ces_status_flags, const char *);
  71
  72 static  void find_element(char *, uint16_t *, uint16_t *);
  73 static  struct changer_element_status *get_element_status
  74            (unsigned int, unsigned int, int);
  75
  76 static  int do_move(const char *, int, char **);
  77 static  int do_exchange(const char *, int, char **);
  78 static  int do_position(const char *, int, char **);
  79 static  int do_params(const char *, int, char **);
  80 static  int do_getpicker(const char *, int, char **);
  81 static  int do_setpicker(const char *, int, char **);
  82 static  int do_status(const char *, int, char **);
  83 static  int do_ielem(const char *, int, char **);
  84 static  int do_return(const char *, int, char **);
  85 static  int do_voltag(const char *, int, char **);
  86 static  void print_designator(const char *, u_int8_t, u_int8_t);
  87
  88 #ifndef CHET_VT
  89 #define CHET_VT         10                      /* Completely Arbitrary */
  90 #endif
  91
  92 /* Valid changer element types. */
  93 static  const struct element_type elements[] = {
  94         { "drive",              CHET_DT },
  95         { "picker",             CHET_MT },
  96         { "portal",             CHET_IE },
  97         { "slot",               CHET_ST },
  98         { "voltag",             CHET_VT },      /* Select tapes by barcode */
  99         { NULL,                 0 },
 100 };
 101
 102 /* Valid commands. */
 103 static  const struct changer_command commands[] = {
 104         { "exchange",           do_exchange },
 105         { "getpicker",          do_getpicker },
 106         { "ielem",              do_ielem },
 107         { "move",               do_move },
 108         { "params",             do_params },
 109         { "position",           do_position },
 110         { "setpicker",          do_setpicker },
 111         { "status",             do_status },
 112         { "return",             do_return },
 113         { "voltag",             do_voltag },
 114         { NULL,                 0 },
 115 };
 116
 117 /* Valid special words. */
 118 static  const struct special_word specials[] = {
 119         { "inv",                SW_INVERT },
 120         { "inv1",               SW_INVERT1 },
 121         { "inv2",               SW_INVERT2 },
 122         { NULL,                 0 },
 123 };
 124
 125 static  int changer_fd;
 126 static  const char *changer_name;
 127
 128 int
 129 main(int argc, char **argv)
 130 {
 131         int ch, i;
 132
 133         while ((ch = getopt(argc, argv, "f:")) != -1) {
 134                 switch (ch) {
 135                 case 'f':
 136                         changer_name = optarg;
 137                         break;
 138
 139                 default:
 140                         usage();
 141                 }
 142         }
 143         argc -= optind;
 144         argv += optind;
 145
 146         if (argc == 0)
 147                 usage();
 148
 149         /* Get the default changer if not already specified. */
 150         if (changer_name == NULL)
 151                 if ((changer_name = getenv(CHANGER_ENV_VAR)) == NULL)
 152                         changer_name = _PATH_CH;
 153
 154         /* Open the changer device. */
 155         if ((changer_fd = open(changer_name, O_RDWR, 0600)) == -1)
 156                 err(1, "%s: open", changer_name);
 157
 158         /* Register cleanup function. */
 159         if (atexit(cleanup))
 160                 err(1, "can't register cleanup function");
 161
 162         /* Find the specified command. */
 163         for (i = 0; commands[i].cc_name != NULL; ++i)
 164                 if (strcmp(*argv, commands[i].cc_name) == 0)
 165                         break;
 166         if (commands[i].cc_name == NULL) {
 167                 /* look for abbreviation */
 168                 for (i = 0; commands[i].cc_name != NULL; ++i)
 169                         if (strncmp(*argv, commands[i].cc_name,
 170                             strlen(*argv)) == 0)
 171                                 break;
 172         }
 173
 174         if (commands[i].cc_name == NULL)
 175                 errx(1, "unknown command: %s", *argv);
 176
 177         exit ((*commands[i].cc_handler)(commands[i].cc_name, argc, argv));
 178         /* NOTREACHED */
 179 }
 180
 181 static int
 182 do_move(const char *cname, int argc, char **argv)
 183 {
 184         struct changer_move cmd;
 185         int val;
 186
 187         /*
 188          * On a move command, we expect the following:
 189          *
 190          * <from ET> <from EU> <to ET> <to EU> [inv]
 191          *
 192          * where ET == element type and EU == element unit.
 193          */
 194
 195         ++argv; --argc;
 196
 197         if (argc < 4) {
 198                 warnx("%s: too few arguments", cname);
 199                 goto usage;
 200         } else if (argc > 5) {
 201                 warnx("%s: too many arguments", cname);
 202                 goto usage;
 203         }
 204         (void) memset(&cmd, 0, sizeof(cmd));
 205
 206         /* <from ET>  */
 207         cmd.cm_fromtype = parse_element_type(*argv);
 208         ++argv; --argc;
 209
 210         /* Check for voltag virtual type */
 211         if (CHET_VT == cmd.cm_fromtype) {
 212                 find_element(*argv, &cmd.cm_fromtype, &cmd.cm_fromunit);
 213         } else {
 214                 /* <from EU> */
 215                 cmd.cm_fromunit = parse_element_unit(*argv);
 216         }
 217         ++argv; --argc;
 218
 219         /* <to ET> */
 220         cmd.cm_totype = parse_element_type(*argv);
 221         ++argv; --argc;
 222
 223         /* Check for voltag virtual type, and report error */
 224         if (CHET_VT == cmd.cm_totype)
 225                 errx(1,"%s: voltag only makes sense as an element source",
 226                      cname);
 227
 228         /* <to EU> */
 229         cmd.cm_tounit = parse_element_unit(*argv);
 230         ++argv; --argc;
 231
 232         /* Deal with optional command modifier. */
 233         if (argc) {
 234                 val = parse_special(*argv);
 235                 switch (val) {
 236                 case SW_INVERT:
 237                         cmd.cm_flags |= CM_INVERT;
 238                         break;
 239
 240                 default:
 241                         errx(1, "%s: inappropriate modifier `%s'",
 242                             cname, *argv);
 243                         /* NOTREACHED */
 244                 }
 245         }
 246
 247         /* Send command to changer. */
 248         if (ioctl(changer_fd, CHIOMOVE, &cmd))
 249                 err(1, "%s: CHIOMOVE", changer_name);
 250
 251         return (0);
 252
 253  usage:
 254         (void) fprintf(stderr, "usage: %s %s "
 255             "<from ET> <from EU> <to ET> <to EU> [inv]\n", getprogname(), cname);
 256         return (1);
 257 }
 258
 259 static int
 260 do_exchange(const char *cname, int argc, char **argv)
 261 {
 262         struct changer_exchange cmd;
 263         int val;
 264
 265         /*
 266          * On an exchange command, we expect the following:
 267          *
 268   * <src ET> <src EU> <dst1 ET> <dst1 EU> [<dst2 ET> <dst2 EU>] [inv1] [inv2]
 269          *
 270          * where ET == element type and EU == element unit.
 271          */
 272
 273         ++argv; --argc;
 274
 275         if (argc < 4) {
 276                 warnx("%s: too few arguments", cname);
 277                 goto usage;
 278         } else if (argc > 8) {
 279                 warnx("%s: too many arguments", cname);
 280                 goto usage;
 281         }
 282         (void) memset(&cmd, 0, sizeof(cmd));
 283
 284         /* <src ET>  */
 285         cmd.ce_srctype = parse_element_type(*argv);
 286         ++argv; --argc;
 287
 288         /* Check for voltag virtual type */
 289         if (CHET_VT == cmd.ce_srctype) {
 290                 find_element(*argv, &cmd.ce_srctype, &cmd.ce_srcunit);
 291         } else {
 292                 /* <from EU> */
 293                 cmd.ce_srcunit = parse_element_unit(*argv);
 294         }
 295         ++argv; --argc;
 296
 297         /* <dst1 ET> */
 298         cmd.ce_fdsttype = parse_element_type(*argv);
 299         ++argv; --argc;
 300
 301         /* Check for voltag virtual type */
 302         if (CHET_VT == cmd.ce_fdsttype) {
 303                 find_element(*argv, &cmd.ce_fdsttype, &cmd.ce_fdstunit);
 304         } else {
 305                 /* <from EU> */
 306                 cmd.ce_fdstunit = parse_element_unit(*argv);
 307         }
 308         ++argv; --argc;
 309
 310         /*
 311          * If the next token is a special word or there are no more
 312          * arguments, then this is a case of simple exchange.
 313          * dst2 == src.
 314          */
 315         if ((argc == 0) || is_special(*argv)) {
 316                 cmd.ce_sdsttype = cmd.ce_srctype;
 317                 cmd.ce_sdstunit = cmd.ce_srcunit;
 318                 goto do_special;
 319         }
 320
 321         /* <dst2 ET> */
 322         cmd.ce_sdsttype = parse_element_type(*argv);
 323         ++argv; --argc;
 324
 325         if (CHET_VT == cmd.ce_sdsttype)
 326                 errx(1,"%s %s: voltag only makes sense as an element source",
 327                      cname, *argv);
 328
 329         /* <dst2 EU> */
 330         cmd.ce_sdstunit = parse_element_unit(*argv);
 331         ++argv; --argc;
 332
 333  do_special:
 334         /* Deal with optional command modifiers. */
 335         while (argc) {
 336                 val = parse_special(*argv);
 337                 ++argv; --argc;
 338                 switch (val) {
 339                 case SW_INVERT1:
 340                         cmd.ce_flags |= CE_INVERT1;
 341                         break;
 342
 343                 case SW_INVERT2:
 344                         cmd.ce_flags |= CE_INVERT2;
 345                         break;
 346
 347                 default:
 348                         errx(1, "%s: inappropriate modifier `%s'",
 349                             cname, *argv);
 350                         /* NOTREACHED */
 351                 }
 352         }
 353
 354         /* Send command to changer. */
 355         if (ioctl(changer_fd, CHIOEXCHANGE, &cmd))
 356                 err(1, "%s: CHIOEXCHANGE", changer_name);
 357
 358         return (0);
 359
 360  usage:
 361         (void) fprintf(stderr,
 362             "usage: %s %s <src ET> <src EU> <dst1 ET> <dst1 EU>\n"
 363             "       [<dst2 ET> <dst2 EU>] [inv1] [inv2]\n",
 364             getprogname(), cname);
 365         return (1);
 366 }
 367
 368 static int
 369 do_position(const char *cname, int argc, char **argv)
 370 {
 371         struct changer_position cmd;
 372         int val;
 373
 374         /*
 375          * On a position command, we expect the following:
 376          *
 377          * <to ET> <to EU> [inv]
 378          *
 379          * where ET == element type and EU == element unit.
 380          */
 381
 382         ++argv; --argc;
 383
 384         if (argc < 2) {
 385                 warnx("%s: too few arguments", cname);
 386                 goto usage;
 387         } else if (argc > 3) {
 388                 warnx("%s: too many arguments", cname);
 389                 goto usage;
 390         }
 391         (void) memset(&cmd, 0, sizeof(cmd));
 392
 393         /* <to ET>  */
 394         cmd.cp_type = parse_element_type(*argv);
 395         ++argv; --argc;
 396
 397         /* <to EU> */
 398         cmd.cp_unit = parse_element_unit(*argv);
 399         ++argv; --argc;
 400
 401         /* Deal with optional command modifier. */
 402         if (argc) {
 403                 val = parse_special(*argv);
 404                 switch (val) {
 405                 case SW_INVERT:
 406                         cmd.cp_flags |= CP_INVERT;
 407                         break;
 408
 409                 default:
 410                         errx(1, "%s: inappropriate modifier `%s'",
 411                             cname, *argv);
 412                         /* NOTREACHED */
 413                 }
 414         }
 415
 416         /* Send command to changer. */
 417         if (ioctl(changer_fd, CHIOPOSITION, &cmd))
 418                 err(1, "%s: CHIOPOSITION", changer_name);
 419
 420         return (0);
 421
 422  usage:
 423         (void) fprintf(stderr, "usage: %s %s <to ET> <to EU> [inv]\n",
 424             getprogname(), cname);
 425         return (1);
 426 }
 427
 428 /* ARGSUSED */
 429 static int
 430 do_params(const char *cname, int argc, char **argv)
 431 {
 432         struct changer_params data;
 433         int picker;
 434
 435         /* No arguments to this command. */
 436
 437         ++argv; --argc;
 438
 439         if (argc) {
 440                 warnx("%s: no arguments expected", cname);
 441                 goto usage;
 442         }
 443
 444         /* Get params from changer and display them. */
 445         (void) memset(&data, 0, sizeof(data));
 446         if (ioctl(changer_fd, CHIOGPARAMS, &data))
 447                 err(1, "%s: CHIOGPARAMS", changer_name);
 448
 449         (void) printf("%s: %d slot%s, %d drive%s, %d picker%s",
 450             changer_name,
 451             data.cp_nslots, (data.cp_nslots > 1) ? "s" : "",
 452             data.cp_ndrives, (data.cp_ndrives > 1) ? "s" : "",
 453             data.cp_npickers, (data.cp_npickers > 1) ? "s" : "");
 454         if (data.cp_nportals)
 455                 (void) printf(", %d portal%s", data.cp_nportals,
 456                     (data.cp_nportals > 1) ? "s" : "");
 457
 458         /* Get current picker from changer and display it. */
 459         if (ioctl(changer_fd, CHIOGPICKER, &picker))
 460                 err(1, "%s: CHIOGPICKER", changer_name);
 461
 462         (void) printf("\n%s: current picker: %d\n", changer_name, picker);
 463
 464         return (0);
 465
 466  usage:
 467         (void) fprintf(stderr, "usage: %s %s\n", getprogname(), cname);
 468         return (1);
 469 }
 470
 471 /* ARGSUSED */
 472 static int
 473 do_getpicker(const char *cname, int argc, char **argv)
 474 {
 475         int picker;
 476
 477         /* No arguments to this command. */
 478
 479         ++argv; --argc;
 480
 481         if (argc) {
 482                 warnx("%s: no arguments expected", cname);
 483                 goto usage;
 484         }
 485
 486         /* Get current picker from changer and display it. */
 487         if (ioctl(changer_fd, CHIOGPICKER, &picker))
 488                 err(1, "%s: CHIOGPICKER", changer_name);
 489
 490         (void) printf("%s: current picker: %d\n", changer_name, picker);
 491
 492         return (0);
 493
 494  usage:
 495         (void) fprintf(stderr, "usage: %s %s\n", getprogname(), cname);
 496         return (1);
 497 }
 498
 499 static int
 500 do_setpicker(const char *cname, int argc, char **argv)
 501 {
 502         int picker;
 503
 504         ++argv; --argc;
 505
 506         if (argc < 1) {
 507                 warnx("%s: too few arguments", cname);
 508                 goto usage;
 509         } else if (argc > 1) {
 510                 warnx("%s: too many arguments", cname);
 511                 goto usage;
 512         }
 513
 514         picker = parse_element_unit(*argv);
 515
 516         /* Set the changer picker. */
 517         if (ioctl(changer_fd, CHIOSPICKER, &picker))
 518                 err(1, "%s: CHIOSPICKER", changer_name);
 519
 520         return (0);
 521
 522  usage:
 523         (void) fprintf(stderr, "usage: %s %s <picker>\n", getprogname(), cname);
 524         return (1);
 525 }
 526
 527 static int
 528 do_status(const char *cname, int argc, char **argv)
 529 {
 530         struct changer_params cp;
 531         struct changer_element_status_request cesr;
 532         int i;
 533         u_int16_t base, count, chet, schet, echet;
 534         const char *description;
 535         int pvoltag = 0;
 536         int avoltag = 0;
 537         int sense = 0;
 538         int scsi = 0;
 539         int source = 0;
 540         int intaddr = 0;
 541         int c;
 542
 543         count = 0;
 544         base = 0;
 545         description = NULL;
 546
 547         optind = optreset = 1;
 548         while ((c = getopt(argc, argv, "vVsSbaI")) != -1) {
 549                 switch (c) {
 550                 case 'v':
 551                         pvoltag = 1;
 552                         break;
 553                 case 'V':
 554                         avoltag = 1;
 555                         break;
 556                 case 's':
 557                         sense = 1;
 558                         break;
 559                 case 'S':
 560                         source = 1;
 561                         break;
 562                 case 'b':
 563                         scsi = 1;
 564                         break;
 565                 case 'I':
 566                         intaddr = 1;
 567                         break;
 568                 case 'a':
 569                         pvoltag = avoltag = source = sense = scsi = intaddr = 1;
 570                         break;
 571                 default:
 572                         warnx("%s: bad option", cname);
 573                         goto usage;
 574                 }
 575         }
 576
 577         argc -= optind;
 578         argv += optind;
 579
 580         /*
 581          * On a status command, we expect the following:
 582          *
 583          * [<ET> [<start> [<end>] ] ]
 584          *
 585          * where ET == element type, start == first element to report,
 586          * end == number of elements to report
 587          *
 588          * If we get no arguments, we get the status of all
 589          * known element types.
 590          */
 591         if (argc > 3) {
 592                 warnx("%s: too many arguments", cname);
 593                 goto usage;
 594         }
 595
 596         /*
 597          * Get params from changer.  Specifically, we need the element
 598          * counts.
 599          */
 600         if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
 601                 err(1, "%s: CHIOGPARAMS", changer_name);
 602
 603         if (argc > 0)
 604                 schet = echet = parse_element_type(argv[0]);
 605         else {
 606                 schet = CHET_MT;
 607                 echet = CHET_DT;
 608         }
 609         if (argc > 1) {
 610                 base = (u_int16_t)atol(argv[1]);
 611                 count = 1;
 612         }
 613         if (argc > 2)
 614                 count = (u_int16_t)atol(argv[2]) - base + 1;
 615
 616         for (chet = schet; chet <= echet; ++chet) {
 617                 switch (chet) {
 618                 case CHET_MT:
 619                         if (count == 0)
 620                                 count = cp.cp_npickers;
 621                         else if (count > cp.cp_npickers)
 622                                 errx(1, "not that many pickers in device");
 623                         description = "picker";
 624                         break;
 625
 626                 case CHET_ST:
 627                         if (count == 0)
 628                                 count = cp.cp_nslots;
 629                         else if (count > cp.cp_nslots)
 630                                 errx(1, "not that many slots in device");
 631                         description = "slot";
 632                         break;
 633
 634                 case CHET_IE:
 635                         if (count == 0)
 636                                 count = cp.cp_nportals;
 637                         else if (count > cp.cp_nportals)
 638                                 errx(1, "not that many portals in device");
 639                         description = "portal";
 640                         break;
 641
 642                 case CHET_DT:
 643                         if (count == 0)
 644                                 count = cp.cp_ndrives;
 645                         else if (count > cp.cp_ndrives)
 646                                 errx(1, "not that many drives in device");
 647                         description = "drive";
 648                         break;
 649
 650                 default:
 651                         /* To appease gcc -Wuninitialized. */
 652                         count = 0;
 653                         description = NULL;
 654                 }
 655
 656                 if (count == 0) {
 657                         if (argc == 0)
 658                                 continue;
 659                         else {
 660                                 printf("%s: no %s elements\n",
 661                                     changer_name, description);
 662                                 return (0);
 663                         }
 664                 }
 665
 666                 bzero(&cesr, sizeof(cesr));
 667                 cesr.cesr_element_type = chet;
 668                 cesr.cesr_element_base = base;
 669                 cesr.cesr_element_count = count;
 670                 /* Allocate storage for the status structures. */
 671                 cesr.cesr_element_status =
 672                   (struct changer_element_status *)
 673                   calloc((size_t)count, sizeof(struct changer_element_status));
 674
 675                 if (!cesr.cesr_element_status)
 676                         errx(1, "can't allocate status storage");
 677
 678                 if (avoltag || pvoltag)
 679                         cesr.cesr_flags |= CESR_VOLTAGS;
 680
 681                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr)) {
 682                         free(cesr.cesr_element_status);
 683                         err(1, "%s: CHIOGSTATUS", changer_name);
 684                 }
 685
 686                 /* Dump the status for each reported element. */
 687                 for (i = 0; i < count; ++i) {
 688                         struct changer_element_status *ces =
 689                                  &(cesr.cesr_element_status[i]);
 690                         printf("%s %d: %s", description, ces->ces_addr,
 691                             bits_to_string(ces->ces_flags,
 692                                            CESTATUS_BITS));
 693                         if (sense)
 694                                 printf(" sense: <0x%02x/0x%02x>",
 695                                        ces->ces_sensecode,
 696                                        ces->ces_sensequal);
 697                         if (pvoltag)
 698                                 printf(" voltag: <%s:%d>",
 699                                        ces->ces_pvoltag.cv_volid,
 700                                        ces->ces_pvoltag.cv_serial);
 701                         if (avoltag)
 702                                 printf(" avoltag: <%s:%d>",
 703                                        ces->ces_avoltag.cv_volid,
 704                                        ces->ces_avoltag.cv_serial);
 705                         if (source) {
 706                                 if (ces->ces_flags & CES_SOURCE_VALID)
 707                                         printf(" source: <%s %d>",
 708                                                element_type_name(
 709                                                        ces->ces_source_type),
 710                                                ces->ces_source_addr);
 711                                 else
 712                                         printf(" source: <>");
 713                         }
 714                         if (intaddr)
 715                                 printf(" intaddr: <%d>", ces->ces_int_addr);
 716                         if (scsi) {
 717                                 printf(" scsi: <");
 718                                 if (ces->ces_flags & CES_SCSIID_VALID)
 719                                         printf("%d", ces->ces_scsi_id);
 720                                 else
 721                                         putchar('?');
 722                                 putchar(':');
 723                                 if (ces->ces_flags & CES_LUN_VALID)
 724                                         printf("%d", ces->ces_scsi_lun);
 725                                 else
 726                                         putchar('?');
 727                                 putchar('>');
 728                         }
 729                         if (ces->ces_designator_length > 0)
 730                                 print_designator(ces->ces_designator,
 731                                                  ces->ces_code_set,
 732                                                  ces->ces_designator_length);
 733                         putchar('\n');
 734                 }
 735
 736                 free(cesr.cesr_element_status);
 737                 count = 0;
 738         }
 739
 740         return (0);
 741
 742  usage:
 743         (void) fprintf(stderr, "usage: %s %s [-vVsSbaA] [<element type> [<start-addr> [<end-addr>] ] ]\n",
 744                        getprogname(), cname);
 745         return (1);
 746 }
 747
 748 static int
 749 do_ielem(const char *cname, int argc, char **argv)
 750 {
 751         int timeout = 0;
 752
 753         if (argc == 2) {
 754                 timeout = atol(argv[1]);
 755         } else if (argc > 1) {
 756                 warnx("%s: too many arguments", cname);
 757                 goto usage;
 758         }
 759
 760         if (ioctl(changer_fd, CHIOIELEM, &timeout))
 761                 err(1, "%s: CHIOIELEM", changer_name);
 762
 763         return (0);
 764
 765  usage:
 766         (void) fprintf(stderr, "usage: %s %s [<timeout>]\n",
 767                        getprogname(), cname);
 768         return (1);
 769 }
 770
 771 static int
 772 do_voltag(const char *cname, int argc, char **argv)
 773 {
 774         int force = 0;
 775         int clear = 0;
 776         int alternate = 0;
 777         int c;
 778         struct changer_set_voltag_request csvr;
 779
 780         bzero(&csvr, sizeof(csvr));
 781
 782         optind = optreset = 1;
 783         while ((c = getopt(argc, argv, "fca")) != -1) {
 784                 switch (c) {
 785                 case 'f':
 786                         force = 1;
 787                         break;
 788                 case 'c':
 789                         clear = 1;
 790                         break;
 791                 case 'a':
 792                         alternate = 1;
 793                         break;
 794                 default:
 795                         warnx("%s: bad option", cname);
 796                         goto usage;
 797                 }
 798         }
 799
 800         argc -= optind;
 801         argv += optind;
 802
 803         if (argc < 2) {
 804                 warnx("%s: missing element specification", cname);
 805                 goto usage;
 806         }
 807
 808         csvr.csvr_type = parse_element_type(argv[0]);
 809         csvr.csvr_addr = (u_int16_t)atol(argv[1]);
 810
 811         if (!clear) {
 812                 if (argc < 3 || argc > 4) {
 813                         warnx("%s: missing argument", cname);
 814                         goto usage;
 815                 }
 816
 817                 if (force)
 818                         csvr.csvr_flags = CSVR_MODE_REPLACE;
 819                 else
 820                         csvr.csvr_flags = CSVR_MODE_SET;
 821
 822                 if (strlen(argv[2]) > sizeof(csvr.csvr_voltag.cv_volid)) {
 823                         warnx("%s: volume label too long", cname);
 824                         goto usage;
 825                 }
 826
 827                 strlcpy((char *)csvr.csvr_voltag.cv_volid, argv[2],
 828                        sizeof(csvr.csvr_voltag.cv_volid));
 829
 830                 if (argc == 4) {
 831                         csvr.csvr_voltag.cv_serial = (u_int16_t)atol(argv[3]);
 832                 }
 833         } else {
 834                 if (argc != 2) {
 835                         warnx("%s: unexpected argument", cname);
 836                         goto usage;
 837                 }
 838                 csvr.csvr_flags = CSVR_MODE_CLEAR;
 839         }
 840
 841         if (alternate) {
 842                 csvr.csvr_flags |= CSVR_ALTERNATE;
 843         }
 844
 845         if (ioctl(changer_fd, CHIOSETVOLTAG, &csvr))
 846                 err(1, "%s: CHIOSETVOLTAG", changer_name);
 847
 848         return 0;
 849  usage:
 850         (void) fprintf(stderr,
 851                        "usage: %s %s [-fca] <element> [<voltag> [<vsn>] ]\n",
 852                        getprogname(), cname);
 853         return 1;
 854 }
 855
 856 static u_int16_t
 857 parse_element_type(char *cp)
 858 {
 859         int i;
 860
 861         for (i = 0; elements[i].et_name != NULL; ++i)
 862                 if (strcmp(elements[i].et_name, cp) == 0)
 863                         return ((u_int16_t)elements[i].et_type);
 864
 865         errx(1, "invalid element type `%s'", cp);
 866         /* NOTREACHED */
 867 }
 868
 869 static const char *
 870 element_type_name(int et)
 871 {
 872         int i;
 873
 874         for (i = 0; elements[i].et_name != NULL; i++)
 875                 if (elements[i].et_type == et)
 876                         return elements[i].et_name;
 877
 878         return "unknown";
 879 }
 880
 881 static u_int16_t
 882 parse_element_unit(char *cp)
 883 {
 884         int i;
 885         char *p;
 886
 887         i = (int)strtol(cp, &p, 10);
 888         if ((i < 0) || (*p != '\0'))
 889                 errx(1, "invalid unit number `%s'", cp);
 890
 891         return ((u_int16_t)i);
 892 }
 893
 894 static int
 895 parse_special(char *cp)
 896 {
 897         int val;
 898
 899         val = is_special(cp);
 900         if (val)
 901                 return (val);
 902
 903         errx(1, "invalid modifier `%s'", cp);
 904         /* NOTREACHED */
 905 }
 906
 907 static int
 908 is_special(char *cp)
 909 {
 910         int i;
 911
 912         for (i = 0; specials[i].sw_name != NULL; ++i)
 913                 if (strcmp(specials[i].sw_name, cp) == 0)
 914                         return (specials[i].sw_value);
 915
 916         return (0);
 917 }
 918
 919 static const char *
 920 bits_to_string(ces_status_flags v, const char *cp)
 921 {
 922         const char *np;
 923         char f, sep, *bp;
 924         static char buf[128];
 925
 926         bp = buf;
 927         (void) memset(buf, 0, sizeof(buf));
 928
 929         for (sep = '<'; (f = *cp++) != 0; cp = np) {
 930                 for (np = cp; *np >= ' ';)
 931                         np++;
 932                 if (((int)v & (1 << (f - 1))) == 0)
 933                         continue;
 934                 (void) snprintf(bp, sizeof(buf) - (size_t)(bp - &buf[0]),
 935                         "%c%.*s", sep, (int)(long)(np - cp), cp);
 936                 bp += strlen(bp);
 937                 sep = ',';
 938         }
 939         if (sep != '<')
 940                 *bp = '>';
 941
 942         return (buf);
 943 }
 944 /*
 945  * do_return()
 946  *
 947  * Given an element reference, ask the changer/picker to move that
 948  * element back to its source slot.
 949  */
 950 static int
 951 do_return(const char *cname, int argc, char **argv)
 952 {
 953         struct changer_element_status *ces;
 954         struct changer_move cmd;
 955         uint16_t        type, element;
 956
 957         ++argv; --argc;
 958
 959         if (argc < 2) {
 960                 warnx("%s: too few arguments", cname);
 961                 goto usage;
 962         } else if (argc > 3) {
 963                 warnx("%s: too many arguments", cname);
 964                 goto usage;
 965         }
 966
 967         type = parse_element_type(*argv);
 968         ++argv; --argc;
 969
 970         /* Handle voltag virtual Changer Element Type */
 971         if (CHET_VT == type) {
 972                 find_element(*argv, &type, &element);
 973         } else {
 974                 element = parse_element_unit(*argv);
 975         }
 976         ++argv; --argc;
 977
 978         /* Get the status */
 979         ces = get_element_status((unsigned int)type, (unsigned int)element,
 980             CHET_VT == type);
 981
 982         if (NULL == ces)
 983                 errx(1, "%s: null element status pointer", cname);
 984
 985         if (!(ces->ces_flags & CES_SOURCE_VALID))
 986                 errx(1, "%s: no source information", cname);
 987
 988         (void) memset(&cmd, 0, sizeof(cmd));
 989
 990         cmd.cm_fromtype = type;
 991         cmd.cm_fromunit = element;
 992         cmd.cm_totype = ces->ces_source_type;
 993         cmd.cm_tounit = ces->ces_source_addr;
 994
 995         if (ioctl(changer_fd, CHIOMOVE, &cmd) == -1)
 996                 err(1, "%s: CHIOMOVE", changer_name);
 997         free(ces);
 998
 999         return(0);
1000
1001 usage:
1002         (void) fprintf(stderr, "usage: %s %s "
1003             "<from ET> <from EU>\n", getprogname(), cname);
1004         return(1);
1005 }
1006
1007 /*
1008  * get_element_status()
1009  *
1010  * return a *cesr for the specified changer element.  This
1011  * routing will malloc()/calloc() the memory.  The caller
1012  * should free() it when done.
1013  */
1014 static struct changer_element_status *
1015 get_element_status(unsigned int type, unsigned int element, int use_voltags)
1016 {
1017         struct changer_element_status_request cesr;
1018         struct changer_element_status *ces;
1019
1020         ces = (struct changer_element_status *)
1021             calloc((size_t)1, sizeof(struct changer_element_status));
1022
1023         if (NULL == ces)
1024                 errx(1, "can't allocate status storage");
1025
1026         (void)memset(&cesr, 0, sizeof(cesr));
1027
1028         cesr.cesr_element_type = (uint16_t)type;
1029         cesr.cesr_element_base = (uint16_t)element;
1030         cesr.cesr_element_count = 1;            /* Only this one element */
1031         if (use_voltags)
1032                 cesr.cesr_flags |= CESR_VOLTAGS; /* Grab voltags as well */
1033         cesr.cesr_element_status = ces;
1034
1035         if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1036                 free(ces);
1037                 err(1, "%s: CHIOGSTATUS", changer_name);
1038                 /* NOTREACHED */
1039         }
1040
1041         return ces;
1042 }
1043
1044
1045 /*
1046  * find_element()
1047  *
1048  * Given a <voltag> find the chager element and unit, or exit
1049  * with an error if it isn't found.  We grab the changer status
1050  * and iterate until we find a match, or crap out.
1051  */
1052 static void
1053 find_element(char *voltag, uint16_t *et, uint16_t *eu)
1054 {
1055         struct changer_params cp;
1056         struct changer_element_status_request cesr;
1057         struct changer_element_status *ch_ces, *ces;
1058         int found = 0;
1059         size_t elem, total_elem;
1060
1061         /*
1062          * Get the changer parameters, we're interested in the counts
1063          * for all types of elements to perform our search.
1064          */
1065         if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
1066                 err(1, "%s: CHIOGPARAMS", changer_name);
1067
1068         /* Allocate some memory for the results */
1069         total_elem = (cp.cp_nslots + cp.cp_ndrives
1070             + cp.cp_npickers + cp.cp_nportals);
1071
1072         ch_ces = (struct changer_element_status *)
1073             calloc(total_elem, sizeof(struct changer_element_status));
1074
1075         if (NULL == ch_ces)
1076                 errx(1, "can't allocate status storage");
1077
1078         ces = ch_ces;
1079
1080         /* Read in the changer slots */
1081         if (cp.cp_nslots > 0) {
1082                 (void) memset(&cesr, 0, sizeof(cesr));
1083                 cesr.cesr_element_type = CHET_ST;
1084                 cesr.cesr_element_base = 0;
1085                 cesr.cesr_element_count = cp.cp_nslots;
1086                 cesr.cesr_flags |= CESR_VOLTAGS;
1087                 cesr.cesr_element_status = ces;
1088
1089                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1090                         free(ch_ces);
1091                         err(1, "%s: CHIOGSTATUS", changer_name);
1092                 }
1093                 ces += cp.cp_nslots;
1094         }
1095
1096         /* Read in the drive information */
1097         if (cp.cp_ndrives > 0 ) {
1098
1099                 (void) memset(&cesr, 0, sizeof(cesr));
1100                 cesr.cesr_element_type = CHET_DT;
1101                 cesr.cesr_element_base = 0;
1102                 cesr.cesr_element_count = cp.cp_ndrives;
1103                 cesr.cesr_flags |= CESR_VOLTAGS;
1104                 cesr.cesr_element_status = ces;
1105
1106                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1107                         free(ch_ces);
1108                         err(1, "%s: CHIOGSTATUS", changer_name);
1109                 }
1110                 ces += cp.cp_ndrives;
1111         }
1112
1113         /* Read in the portal information */
1114         if (cp.cp_nportals > 0 ) {
1115                 (void) memset(&cesr, 0, sizeof(cesr));
1116                 cesr.cesr_element_type = CHET_IE;
1117                 cesr.cesr_element_base = 0;
1118                 cesr.cesr_element_count = cp.cp_nportals;
1119                 cesr.cesr_flags |= CESR_VOLTAGS;
1120                 cesr.cesr_element_status = ces;
1121
1122                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1123                         free(ch_ces);
1124                         err(1, "%s: CHIOGSTATUS", changer_name);
1125                 }
1126                 ces += cp.cp_nportals;
1127         }
1128
1129         /* Read in the picker information */
1130         if (cp.cp_npickers > 0) {
1131                 (void) memset(&cesr, 0, sizeof(cesr));
1132                 cesr.cesr_element_type = CHET_MT;
1133                 cesr.cesr_element_base = 0;
1134                 cesr.cesr_element_count = cp.cp_npickers;
1135                 cesr.cesr_flags |= CESR_VOLTAGS;
1136                 cesr.cesr_element_status = ces;
1137
1138                 if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1139                         free(ch_ces);
1140                         err(1, "%s: CHIOGSTATUS", changer_name);
1141                 }
1142         }
1143
1144         /*
1145          * Now search the list the specified <voltag>
1146          */
1147         for (elem = 0; elem <= total_elem; ++elem) {
1148
1149                 ces = &ch_ces[elem];
1150
1151                 /* Make sure we have a tape in this element */
1152                 if ((ces->ces_flags & (CES_STATUS_ACCESS|CES_STATUS_FULL))
1153                     != (CES_STATUS_ACCESS|CES_STATUS_FULL))
1154                         continue;
1155
1156                 /* Check to see if it is our target */
1157                 if (strcasecmp(voltag,
1158                     (const char *)ces->ces_pvoltag.cv_volid) == 0) {
1159                         *et = ces->ces_type;
1160                         *eu = ces->ces_addr;
1161                         ++found;
1162                         break;
1163                 }
1164         }
1165         if (!found) {
1166                 errx(1, "%s: unable to locate voltag: %s", changer_name,
1167                      voltag);
1168         }
1169         free(ch_ces);
1170         return;
1171 }
1172
1173 static void
1174 cleanup(void)
1175 {
1176         /* Simple enough... */
1177         (void)close(changer_fd);
1178 }
1179
1180 static void
1181 usage(void)
1182 {
1183         (void)fprintf(stderr, "usage: %s [-f changer] command [-<flags>] "
1184                 "arg1 arg2 [arg3 [...]]\n", getprogname());
1185         exit(1);
1186 }
1187
1188 #define UTF8CODESET     "UTF-8"
1189
1190 static void
1191 print_designator(const char *designator, u_int8_t code_set,
1192     u_int8_t designator_length)
1193 {
1194         printf(" serial number: <");
1195         switch (code_set) {
1196         case CES_CODE_SET_ASCII: {
1197                 /*
1198                  * The driver insures that the string is always NUL terminated.
1199                  */
1200                 printf("%s", designator);
1201                 break;
1202         }
1203         case CES_CODE_SET_UTF_8: {
1204                 char *cs_native;
1205
1206                 setlocale(LC_ALL, "");
1207                 cs_native = nl_langinfo(CODESET);
1208
1209                 /* See if we can natively print UTF-8 */
1210                 if (strcmp(cs_native, UTF8CODESET) == 0)
1211                         cs_native = NULL;
1212
1213                 if (cs_native == NULL) {
1214                         /* We can natively print UTF-8, so use printf. */
1215                         printf("%s", designator);
1216                 } else {
1217                         int i;
1218
1219                         /*
1220                          * We can't natively print UTF-8.  We should
1221                          * convert it to the terminal's codeset, but that
1222                          * requires iconv(3) and FreeBSD doesn't have
1223                          * iconv(3) in the base system yet.  So we use %XX
1224                          * notation for non US-ASCII characters instead.
1225                          */
1226                         for (i = 0; i < designator_length &&
1227                             designator[i] != '\0'; i++) {
1228                                 if ((unsigned char)designator[i] < 0x80)
1229                                         printf("%c", designator[i]);
1230                                 else
1231                                         printf("%%%02x",
1232                                             (unsigned char)designator[i]);
1233                         }
1234                 }
1235                 break;
1236         }
1237         case CES_CODE_SET_BINARY: {
1238                 int i;
1239
1240                 for (i = 0; i < designator_length; i++)
1241                         printf("%02X%s", designator[i],
1242                             (i == designator_length - 1) ? "" : " ");
1243                 break;
1244         }
1245         default:
1246                 break;
1247         }
1248         printf(">");
1249 }