extras/scsi_id/scsi_id.c

   1 /*
   2  * scsi_id.c
   3  *
   4  * Main section of the scsi_id program
   5  *
   6  * Copyright (C) IBM Corp. 2003
   7  * Copyright (C) SUSE Linux Products GmbH, 2006
   8  *
   9  * Author:
  10  *      Patrick Mansfield<patmans@us.ibm.com>
  11  *
  12  *      This program is free software; you can redistribute it and/or modify it
  13  *      under the terms of the GNU General Public License as published by the
  14  *      Free Software Foundation version 2 of the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <signal.h>
  21 #include <fcntl.h>
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <syslog.h>
  25 #include <stdarg.h>
  26 #include <ctype.h>
  27 #include <getopt.h>
  28 #include <sys/stat.h>
  29
  30 #include "../../udev/udev.h"
  31 #include "scsi_id.h"
  32
  33 static const struct option options[] = {
  34         { "device", required_argument, NULL, 'd' },
  35         { "config", required_argument, NULL, 'f' },
  36         { "page", required_argument, NULL, 'p' },
  37         { "blacklisted", no_argument, NULL, 'b' },
  38         { "whitelisted", no_argument, NULL, 'g' },
  39         { "replace-whitespace", no_argument, NULL, 'u' },
  40         { "sg-version", required_argument, NULL, 's' },
  41         { "verbose", no_argument, NULL, 'v' },
  42         { "version", no_argument, NULL, 'V' },
  43         { "export", no_argument, NULL, 'x' },
  44         { "help", no_argument, NULL, 'h' },
  45         {}
  46 };
  47
  48 static const char short_options[] = "d:f:ghip:uvVx";
  49 static const char dev_short_options[] = "bgp:";
  50
  51 static int all_good;
  52 static int dev_specified;
  53 static char config_file[MAX_PATH_LEN] = SYSCONFDIR "/scsi_id.config";
  54 static enum page_code default_page_code;
  55 static int sg_version = 4;
  56 static int use_stderr;
  57 static int debug;
  58 static int reformat_serial;
  59 static int export;
  60 static char vendor_str[64];
  61 static char model_str[64];
  62 static char revision_str[16];
  63 static char type_str[16];
  64
  65 static void log_fn(struct udev *udev, int priority,
  66                    const char *file, int line, const char *fn,
  67                    const char *format, va_list args)
  68 {
  69         vsyslog(priority, format, args);
  70 }
  71
  72 static void set_type(const char *from, char *to, size_t len)
  73 {
  74         int type_num;
  75         char *eptr;
  76         char *type = "generic";
  77
  78         type_num = strtoul(from, &eptr, 0);
  79         if (eptr != from) {
  80                 switch (type_num) {
  81                 case 0:
  82                         type = "disk";
  83                         break;
  84                 case 1:
  85                         type = "tape";
  86                         break;
  87                 case 4:
  88                         type = "optical";
  89                         break;
  90                 case 5:
  91                         type = "cd";
  92                         break;
  93                 case 7:
  94                         type = "optical";
  95                         break;
  96                 case 0xe:
  97                         type = "disk";
  98                         break;
  99                 case 0xf:
 100                         type = "optical";
 101                         break;
 102                 default:
 103                         break;
 104                 }
 105         }
 106         util_strlcpy(to, type, len);
 107 }
 108
 109 /*
 110  * get_value:
 111  *
 112  * buf points to an '=' followed by a quoted string ("foo") or a string ending
 113  * with a space or ','.
 114  *
 115  * Return a pointer to the NUL terminated string, returns NULL if no
 116  * matches.
 117  */
 118 static char *get_value(char **buffer)
 119 {
 120         static char *quote_string = "\"\n";
 121         static char *comma_string = ",\n";
 122         char *val;
 123         char *end;
 124
 125         if (**buffer == '"') {
 126                 /*
 127                  * skip leading quote, terminate when quote seen
 128                  */
 129                 (*buffer)++;
 130                 end = quote_string;
 131         } else {
 132                 end = comma_string;
 133         }
 134         val = strsep(buffer, end);
 135         if (val && end == quote_string)
 136                 /*
 137                  * skip trailing quote
 138                  */
 139                 (*buffer)++;
 140
 141         while (isspace(**buffer))
 142                 (*buffer)++;
 143
 144         return val;
 145 }
 146
 147 static int argc_count(char *opts)
 148 {
 149         int i = 0;
 150         while (*opts != '\0')
 151                 if (*opts++ == ' ')
 152                         i++;
 153         return i;
 154 }
 155
 156 /*
 157  * get_file_options:
 158  *
 159  * If vendor == NULL, find a line in the config file with only "OPTIONS=";
 160  * if vendor and model are set find the first OPTIONS line in the config
 161  * file that matches. Set argc and argv to match the OPTIONS string.
 162  *
 163  * vendor and model can end in '\n'.
 164  */
 165 static int get_file_options(struct udev *udev,
 166                             const char *vendor, const char *model,
 167                             int *argc, char ***newargv)
 168 {
 169         char *buffer;
 170         FILE *fd;
 171         char *buf;
 172         char *str1;
 173         char *vendor_in, *model_in, *options_in; /* read in from file */
 174         int lineno;
 175         int c;
 176         int retval = 0;
 177
 178         dbg(udev, "vendor='%s'; model='%s'\n", vendor, model);
 179         fd = fopen(config_file, "r");
 180         if (fd == NULL) {
 181                 dbg(udev, "can't open %s\n", config_file);
 182                 if (errno == ENOENT) {
 183                         return 1;
 184                 } else {
 185                         err(udev, "can't open %s: %s\n", config_file, strerror(errno));
 186                         return -1;
 187                 }
 188         }
 189
 190         /*
 191          * Allocate a buffer rather than put it on the stack so we can
 192          * keep it around to parse any options (any allocated newargv
 193          * points into this buffer for its strings).
 194          */
 195         buffer = malloc(MAX_BUFFER_LEN);
 196         if (!buffer) {
 197                 err(udev, "can't allocate memory\n");
 198                 return -1;
 199         }
 200
 201         *newargv = NULL;
 202         lineno = 0;
 203         while (1) {
 204                 vendor_in = model_in = options_in = NULL;
 205
 206                 buf = fgets(buffer, MAX_BUFFER_LEN, fd);
 207                 if (buf == NULL)
 208                         break;
 209                 lineno++;
 210                 if (buf[strlen(buffer) - 1] != '\n') {
 211                         err(udev, "Config file line %d too long\n", lineno);
 212                         break;
 213                 }
 214
 215                 while (isspace(*buf))
 216                         buf++;
 217
 218                 /* blank or all whitespace line */
 219                 if (*buf == '\0')
 220                         continue;
 221
 222                 /* comment line */
 223                 if (*buf == '#')
 224                         continue;
 225
 226                 dbg(udev, "lineno %d: '%s'\n", lineno, buf);
 227                 str1 = strsep(&buf, "=");
 228                 if (str1 && strcasecmp(str1, "VENDOR") == 0) {
 229                         str1 = get_value(&buf);
 230                         if (!str1) {
 231                                 retval = -1;
 232                                 break;
 233                         }
 234                         vendor_in = str1;
 235
 236                         str1 = strsep(&buf, "=");
 237                         if (str1 && strcasecmp(str1, "MODEL") == 0) {
 238                                 str1 = get_value(&buf);
 239                                 if (!str1) {
 240                                         retval = -1;
 241                                         break;
 242                                 }
 243                                 model_in = str1;
 244                                 str1 = strsep(&buf, "=");
 245                         }
 246                 }
 247
 248                 if (str1 && strcasecmp(str1, "OPTIONS") == 0) {
 249                         str1 = get_value(&buf);
 250                         if (!str1) {
 251                                 retval = -1;
 252                                 break;
 253                         }
 254                         options_in = str1;
 255                 }
 256                 dbg(udev, "config file line %d:\n"
 257                         " vendor '%s'; model '%s'; options '%s'\n",
 258                         lineno, vendor_in, model_in, options_in);
 259                 /*
 260                  * Only allow: [vendor=foo[,model=bar]]options=stuff
 261                  */
 262                 if (!options_in || (!vendor_in && model_in)) {
 263                         err(udev, "Error parsing config file line %d '%s'\n", lineno, buffer);
 264                         retval = -1;
 265                         break;
 266                 }
 267                 if (vendor == NULL) {
 268                         if (vendor_in == NULL) {
 269                                 dbg(udev, "matched global option\n");
 270                                 break;
 271                         }
 272                 } else if ((vendor_in && strncmp(vendor, vendor_in,
 273                                                  strlen(vendor_in)) == 0) &&
 274                            (!model_in || (strncmp(model, model_in,
 275                                                   strlen(model_in)) == 0))) {
 276                                 /*
 277                                  * Matched vendor and optionally model.
 278                                  *
 279                                  * Note: a short vendor_in or model_in can
 280                                  * give a partial match (that is FOO
 281                                  * matches FOOBAR).
 282                                  */
 283                                 dbg(udev, "matched vendor/model\n");
 284                                 break;
 285                 } else {
 286                         dbg(udev, "no match\n");
 287                 }
 288         }
 289
 290         if (retval == 0) {
 291                 if (vendor_in != NULL || model_in != NULL ||
 292                     options_in != NULL) {
 293                         /*
 294                          * Something matched. Allocate newargv, and store
 295                          * values found in options_in.
 296                          */
 297                         strcpy(buffer, options_in);
 298                         c = argc_count(buffer) + 2;
 299                         *newargv = calloc(c, sizeof(**newargv));
 300                         if (!*newargv) {
 301                                 err(udev, "can't allocate memory\n");
 302                                 retval = -1;
 303                         } else {
 304                                 *argc = c;
 305                                 c = 0;
 306                                 /*
 307                                  * argv[0] at 0 is skipped by getopt, but
 308                                  * store the buffer address there for
 309                                  * later freeing
 310                                  */
 311                                 (*newargv)[c] = buffer;
 312                                 for (c = 1; c < *argc; c++)
 313                                         (*newargv)[c] = strsep(&buffer, " \t");
 314                         }
 315                 } else {
 316                         /* No matches  */
 317                         retval = 1;
 318                 }
 319         }
 320         if (retval != 0)
 321                 free(buffer);
 322         fclose(fd);
 323         return retval;
 324 }
 325
 326 static int set_options(struct udev *udev,
 327                        int argc, char **argv, const char *short_opts,
 328                        char *maj_min_dev)
 329 {
 330         int option;
 331
 332         /*
 333          * optind is a global extern used by getopt. Since we can call
 334          * set_options twice (once for command line, and once for config
 335          * file) we have to reset this back to 1.
 336          */
 337         optind = 1;
 338         while (1) {
 339                 option = getopt_long(argc, argv, short_opts, options, NULL);
 340                 if (option == -1)
 341                         break;
 342
 343                 if (optarg)
 344                         dbg(udev, "option '%c' arg '%s'\n", option, optarg);
 345                 else
 346                         dbg(udev, "option '%c'\n", option);
 347
 348                 switch (option) {
 349                 case 'b':
 350                         all_good = 0;
 351                         break;
 352
 353                 case 'd':
 354                         dev_specified = 1;
 355                         util_strlcpy(maj_min_dev, optarg, MAX_PATH_LEN);
 356                         break;
 357
 358                 case 'e':
 359                         use_stderr = 1;
 360                         break;
 361
 362                 case 'f':
 363                         util_strlcpy(config_file, optarg, MAX_PATH_LEN);
 364                         break;
 365
 366                 case 'g':
 367                         all_good = 1;
 368                         break;
 369
 370                 case 'h':
 371                         printf("Usage: scsi_id OPTIONS <device>\n"
 372                                "  --device=                     device node for SG_IO commands\n"
 373                                "  --config=                     location of config file\n"
 374                                "  --page=0x80|0x83|pre-spc3-83  SCSI page (0x80, 0x83, pre-spc3-83)\n"
 375                                "  --sg-version=3|4              use SGv3 or SGv4\n"
 376                                "  --blacklisted                 threat device as blacklisted\n"
 377                                "  --whitelisted                 threat device as whitelisted\n"
 378                                "  --replace-whitespace          replace all whitespaces by underscores\n"
 379                                "  --verbose                     verbose logging\n"
 380                                "  --version                     print version\n"
 381                                "  --export                      print values as environment keys\n"
 382                                "  --help                        print this help text\n\n");
 383                         exit(0);
 384
 385                 case 'p':
 386                         if (strcmp(optarg, "0x80") == 0) {
 387                                 default_page_code = PAGE_80;
 388                         } else if (strcmp(optarg, "0x83") == 0) {
 389                                 default_page_code = PAGE_83;
 390                         } else if (strcmp(optarg, "pre-spc3-83") == 0) {
 391                                 default_page_code = PAGE_83_PRE_SPC3;
 392                         } else {
 393                                 err(udev, "Unknown page code '%s'\n", optarg);
 394                                 return -1;
 395                         }
 396                         break;
 397
 398                 case 's':
 399                         sg_version = atoi(optarg);
 400                         if (sg_version < 3 || sg_version > 4) {
 401                                 err(udev, "Unknown SG version '%s'\n", optarg);
 402                                 return -1;
 403                         }
 404                         break;
 405
 406                 case 'u':
 407                         reformat_serial = 1;
 408                         break;
 409
 410                 case 'x':
 411                         export = 1;
 412                         break;
 413
 414                 case 'v':
 415                         debug++;
 416                         break;
 417
 418                 case 'V':
 419                         printf("%s\n", VERSION);
 420                         exit(0);
 421                         break;
 422
 423                 default:
 424                         exit(1);
 425                 }
 426         }
 427         if (optind < argc && !dev_specified) {
 428                 dev_specified = 1;
 429                 util_strlcpy(maj_min_dev, argv[optind], MAX_PATH_LEN);
 430         }
 431         return 0;
 432 }
 433
 434 static int per_dev_options(struct udev *udev,
 435                            struct scsi_id_device *dev_scsi, int *good_bad, int *page_code)
 436 {
 437         int retval;
 438         int newargc;
 439         char **newargv = NULL;
 440         int option;
 441
 442         *good_bad = all_good;
 443         *page_code = default_page_code;
 444
 445         retval = get_file_options(udev, vendor_str, model_str, &newargc, &newargv);
 446
 447         optind = 1; /* reset this global extern */
 448         while (retval == 0) {
 449                 option = getopt_long(newargc, newargv, dev_short_options, options, NULL);
 450                 if (option == -1)
 451                         break;
 452
 453                 if (optarg)
 454                         dbg(udev, "option '%c' arg '%s'\n", option, optarg);
 455                 else
 456                         dbg(udev, "option '%c'\n", option);
 457
 458                 switch (option) {
 459                 case 'b':
 460                         *good_bad = 0;
 461                         break;
 462
 463                 case 'g':
 464                         *good_bad = 1;
 465                         break;
 466
 467                 case 'p':
 468                         if (strcmp(optarg, "0x80") == 0) {
 469                                 *page_code = PAGE_80;
 470                         } else if (strcmp(optarg, "0x83") == 0) {
 471                                 *page_code = PAGE_83;
 472                         } else if (strcmp(optarg, "pre-spc3-83") == 0) {
 473                                 *page_code = PAGE_83_PRE_SPC3;
 474                         } else {
 475                                 err(udev, "Unknown page code '%s'\n", optarg);
 476                                 retval = -1;
 477                         }
 478                         break;
 479
 480                 default:
 481                         err(udev, "Unknown or bad option '%c' (0x%x)\n", option, option);
 482                         retval = -1;
 483                         break;
 484                 }
 485         }
 486
 487         if (newargv) {
 488                 free(newargv[0]);
 489                 free(newargv);
 490         }
 491         return retval;
 492 }
 493
 494 static int set_inq_values(struct udev *udev, struct scsi_id_device *dev_scsi, const char *path)
 495 {
 496         int retval;
 497
 498         dev_scsi->use_sg = sg_version;
 499
 500         retval = scsi_std_inquiry(udev, dev_scsi, path);
 501         if (retval)
 502                 return retval;
 503
 504         udev_util_replace_whitespace(dev_scsi->vendor, vendor_str, sizeof(vendor_str));
 505         udev_util_replace_chars(vendor_str, NULL);
 506         udev_util_replace_whitespace(dev_scsi->model, model_str, sizeof(model_str));
 507         udev_util_replace_chars(model_str, NULL);
 508         set_type(dev_scsi->type, type_str, sizeof(type_str));
 509         udev_util_replace_whitespace(dev_scsi->revision, revision_str, sizeof(revision_str));
 510         udev_util_replace_chars(revision_str, NULL);
 511         return 0;
 512 }
 513
 514 /*
 515  * format_serial: replace to whitespaces by underscores for calling
 516  * programs that use the serial for device naming (multipath, Suse
 517  * naming, etc...)
 518  */
 519 static void format_serial(char *serial)
 520 {
 521         char *p = serial, *q;
 522
 523         q = p;
 524         while (*p != '\0') {
 525                 if (isspace(*p)) {
 526                         if (q > serial && q[-1] != '_') {
 527                                 *q = '_';
 528                                 q++;
 529                         }
 530                 } else {
 531                         *q = *p;
 532                         q++;
 533                 }
 534                 p++;
 535         }
 536         *q = '\0';
 537 }
 538
 539 /*
 540  * scsi_id: try to get an id, if one is found, printf it to stdout.
 541  * returns a value passed to exit() - 0 if printed an id, else 1.
 542  */
 543 static int scsi_id(struct udev *udev, char *maj_min_dev)
 544 {
 545         struct scsi_id_device dev_scsi;
 546         int good_dev;
 547         int page_code;
 548         int retval = 0;
 549
 550         memset(&dev_scsi, 0x00, sizeof(struct scsi_id_device));
 551
 552         if (set_inq_values(udev, &dev_scsi, maj_min_dev) < 0) {
 553                 retval = 1;
 554                 goto out;
 555         }
 556
 557         /* get per device (vendor + model) options from the config file */
 558         per_dev_options(udev, &dev_scsi, &good_dev, &page_code);
 559         dbg(udev, "per dev options: good %d; page code 0x%x\n", good_dev, page_code);
 560         if (!good_dev) {
 561                 retval = 1;
 562                 goto out;
 563         }
 564
 565         /* read serial number from mode pages (no values for optical drives) */
 566         scsi_get_serial(udev, &dev_scsi, maj_min_dev, page_code, MAX_SERIAL_LEN);
 567
 568         if (export) {
 569                 char serial_str[MAX_SERIAL_LEN];
 570
 571                 printf("ID_VENDOR=%s\n", vendor_str);
 572                 printf("ID_MODEL=%s\n", model_str);
 573                 printf("ID_REVISION=%s\n", revision_str);
 574                 printf("ID_TYPE=%s\n", type_str);
 575                 if (dev_scsi.serial[0] != '\0') {
 576                         udev_util_replace_whitespace(dev_scsi.serial, serial_str, sizeof(serial_str));
 577                         udev_util_replace_chars(serial_str, NULL);
 578                         printf("ID_SERIAL=%s\n", serial_str);
 579                         udev_util_replace_whitespace(dev_scsi.serial_short, serial_str, sizeof(serial_str));
 580                         udev_util_replace_chars(serial_str, NULL);
 581                         printf("ID_SERIAL_SHORT=%s\n", serial_str);
 582                 }
 583                 goto out;
 584         }
 585
 586         if (dev_scsi.serial[0] == '\0') {
 587                 retval = 1;
 588                 goto out;
 589         }
 590         if (reformat_serial)
 591                 format_serial(dev_scsi.serial);
 592         printf("%s\n", dev_scsi.serial);
 593 out:
 594         return retval;
 595 }
 596
 597 int main(int argc, char **argv)
 598 {
 599         struct udev *udev;
 600         int retval = 0;
 601         char maj_min_dev[MAX_PATH_LEN];
 602         int newargc;
 603         char **newargv;
 604
 605         udev = udev_new();
 606         if (udev == NULL)
 607                 goto exit;
 608
 609         logging_init("scsi_id");
 610         udev_set_log_fn(udev, log_fn);
 611
 612         /*
 613          * Get config file options.
 614          */
 615         newargv = NULL;
 616         retval = get_file_options(udev, NULL, NULL, &newargc, &newargv);
 617         if (retval < 0) {
 618                 retval = 1;
 619                 goto exit;
 620         }
 621         if (newargv && (retval == 0)) {
 622                 if (set_options(udev, newargc, newargv, short_options, maj_min_dev) < 0) {
 623                         retval = 2;
 624                         goto exit;
 625                 }
 626                 free(newargv);
 627         }
 628
 629         /*
 630          * Get command line options (overriding any config file settings).
 631          */
 632         if (set_options(udev, argc, argv, short_options, maj_min_dev) < 0)
 633                 exit(1);
 634
 635         if (!dev_specified) {
 636                 err(udev, "no device specified\n");
 637                 retval = 1;
 638                 goto exit;
 639         }
 640
 641         retval = scsi_id(udev, maj_min_dev);
 642
 643 exit:
 644         udev_unref(udev);
 645         logging_close();
 646         return retval;
 647 }