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.h"
  31 #include "scsi_id.h"
  32 #include "scsi_id_version.h"
  33
  34 /* temporary names for mknod  */
  35 #define TMP_DIR         "/dev"
  36 #define TMP_PREFIX      "tmp-scsi"
  37
  38 static const struct option options[] = {
  39         { "device", 1, NULL, 'd' },
  40         { "config", 1, NULL, 'f' },
  41         { "page", 1, NULL, 'p' },
  42         { "devpath", 1, NULL, 's' },
  43         { "fallback-to-sysfs", 0, NULL, 'a' },
  44         { "blacklisted", 0, NULL, 'b' },
  45         { "whitelisted", 0, NULL, 'g' },
  46         { "prefix-bus-id", 0, NULL, 'i' },
  47         { "replace-whitespace", 0, NULL, 'u' },
  48         { "ignore-sysfs", 0, NULL, 'n' },
  49         { "verbose", 0, NULL, 'v' },
  50         { "version", 0, NULL, 'V' },
  51         { "export", 0, NULL, 'x' },
  52         { "help", 0, NULL, 'h' },
  53         {}
  54 };
  55
  56 static const char short_options[] = "abd:f:ghinp:s:uvVx";
  57 static const char dev_short_options[] = "bgp:";
  58
  59 static int all_good;
  60 static int always_info;
  61 static int dev_specified;
  62 static int sys_specified;
  63 static char config_file[MAX_PATH_LEN] = SCSI_ID_CONFIG_FILE;
  64 static int display_bus_id;
  65 static enum page_code default_page_code;
  66 static int use_stderr;
  67 static int debug;
  68 static int hotplug_mode;
  69 static int reformat_serial;
  70 static int ignore_sysfs;
  71 static int export;
  72 static char vendor_str[64];
  73 static char model_str[64];
  74 static char revision_str[16];
  75 static char type_str[16];
  76
  77 #ifdef USE_LOG
  78 void log_message(int priority, const char *format, ...)
  79 {
  80         va_list args;
  81         static int udev_log = -1;
  82
  83         if (udev_log == -1) {
  84                 const char *value;
  85
  86                 value = getenv("UDEV_LOG");
  87                 if (value)
  88                         udev_log = log_priority(value);
  89                 else
  90                         udev_log = LOG_ERR;
  91         }
  92
  93         if (priority > udev_log)
  94                 return;
  95
  96         va_start(args, format);
  97         vsyslog(priority, format, args);
  98         va_end(args);
  99 }
 100 #endif
 101
 102 static void set_str(char *to, const char *from, size_t count)
 103 {
 104         size_t i, j, len;
 105
 106         /* strip trailing whitespace */
 107         len = strnlen(from, count);
 108         while (len && isspace(from[len-1]))
 109                 len--;
 110
 111         /* strip leading whitespace */
 112         i = 0;
 113         while (isspace(from[i]) && (i < len))
 114                 i++;
 115
 116         j = 0;
 117         while (i < len) {
 118                 /* substitute multiple whitespace */
 119                 if (isspace(from[i])) {
 120                         while (isspace(from[i]))
 121                                 i++;
 122                         to[j++] = '_';
 123                 }
 124                 /* skip chars */
 125                 if (from[i] == '/') {
 126                         i++;
 127                         continue;
 128                 }
 129                 to[j++] = from[i++];
 130         }
 131         to[j] = '\0';
 132 }
 133
 134 static void set_type(char *to, const char *from, size_t len)
 135 {
 136         int type_num;
 137         char *eptr;
 138         char *type = "generic";
 139
 140         type_num = strtoul(from, &eptr, 0);
 141         if (eptr != from) {
 142                 switch (type_num) {
 143                 case 0:
 144                         type = "disk";
 145                         break;
 146                 case 1:
 147                         type = "tape";
 148                         break;
 149                 case 4:
 150                         type = "optical";
 151                         break;
 152                 case 5:
 153                         type = "cd";
 154                         break;
 155                 case 7:
 156                         type = "optical";
 157                         break;
 158                 case 0xe:
 159                         type = "disk";
 160                         break;
 161                 case 0xf:
 162                         type = "optical";
 163                         break;
 164                 default:
 165                         break;
 166                 }
 167         }
 168         strncpy(to, type, len);
 169         to[len-1] = '\0';
 170 }
 171
 172 static int create_tmp_dev(const char *devpath, char *tmpdev, int dev_type)
 173 {
 174         unsigned int maj, min;
 175         const char *attr;
 176
 177         dbg("%s\n", devpath);
 178         attr = sysfs_attr_get_value(devpath, "dev");
 179         if (attr == NULL) {
 180                 dbg("%s: could not get dev attribute: %s\n", devpath, strerror(errno));
 181                 return -1;
 182         }
 183
 184         dbg("dev value %s\n", attr);
 185         if (sscanf(attr, "%u:%u", &maj, &min) != 2) {
 186                 err("%s: invalid dev major/minor\n", devpath);
 187                 return -1;
 188         }
 189
 190         snprintf(tmpdev, MAX_PATH_LEN, "%s/%s-maj%d-min%d-%u",
 191                  TMP_DIR, TMP_PREFIX, maj, min, getpid());
 192
 193         dbg("tmpdev '%s'\n", tmpdev);
 194         if (mknod(tmpdev, 0600 | dev_type, makedev(maj, min))) {
 195                 err("mknod failed: %s\n", strerror(errno));
 196                 return -1;
 197         }
 198         return 0;
 199 }
 200
 201 /*
 202  * get_value:
 203  *
 204  * buf points to an '=' followed by a quoted string ("foo") or a string ending
 205  * with a space or ','.
 206  *
 207  * Return a pointer to the NUL terminated string, returns NULL if no
 208  * matches.
 209  */
 210 static char *get_value(char **buffer)
 211 {
 212         static char *quote_string = "\"\n";
 213         static char *comma_string = ",\n";
 214         char *val;
 215         char *end;
 216
 217         if (**buffer == '"') {
 218                 /*
 219                  * skip leading quote, terminate when quote seen
 220                  */
 221                 (*buffer)++;
 222                 end = quote_string;
 223         } else {
 224                 end = comma_string;
 225         }
 226         val = strsep(buffer, end);
 227         if (val && end == quote_string)
 228                 /*
 229                  * skip trailing quote
 230                  */
 231                 (*buffer)++;
 232
 233         while (isspace(**buffer))
 234                 (*buffer)++;
 235
 236         return val;
 237 }
 238
 239 static int argc_count(char *opts)
 240 {
 241         int i = 0;
 242         while (*opts != '\0')
 243                 if (*opts++ == ' ')
 244                         i++;
 245         return i;
 246 }
 247
 248 /*
 249  * get_file_options:
 250  *
 251  * If vendor == NULL, find a line in the config file with only "OPTIONS=";
 252  * if vendor and model are set find the first OPTIONS line in the config
 253  * file that matches. Set argc and argv to match the OPTIONS string.
 254  *
 255  * vendor and model can end in '\n'.
 256  */
 257 static int get_file_options(const char *vendor, const char *model,
 258                             int *argc, char ***newargv)
 259 {
 260         char *buffer;
 261         FILE *fd;
 262         char *buf;
 263         char *str1;
 264         char *vendor_in, *model_in, *options_in; /* read in from file */
 265         int lineno;
 266         int c;
 267         int retval = 0;
 268
 269         dbg("vendor='%s'; model='%s'\n", vendor, model);
 270         fd = fopen(config_file, "r");
 271         if (fd == NULL) {
 272                 dbg("can't open %s\n", config_file);
 273                 if (errno == ENOENT) {
 274                         return 1;
 275                 } else {
 276                         err("can't open %s: %s\n", config_file, strerror(errno));
 277                         return -1;
 278                 }
 279         }
 280
 281         /*
 282          * Allocate a buffer rather than put it on the stack so we can
 283          * keep it around to parse any options (any allocated newargv
 284          * points into this buffer for its strings).
 285          */
 286         buffer = malloc(MAX_BUFFER_LEN);
 287         if (!buffer) {
 288                 err("can't allocate memory\n");
 289                 return -1;
 290         }
 291
 292         *newargv = NULL;
 293         lineno = 0;
 294         while (1) {
 295                 vendor_in = model_in = options_in = NULL;
 296
 297                 buf = fgets(buffer, MAX_BUFFER_LEN, fd);
 298                 if (buf == NULL)
 299                         break;
 300                 lineno++;
 301                 if (buf[strlen(buffer) - 1] != '\n') {
 302                         info("Config file line %d too long\n", lineno);
 303                         break;
 304                 }
 305
 306                 while (isspace(*buf))
 307                         buf++;
 308
 309                 /* blank or all whitespace line */
 310                 if (*buf == '\0')
 311                         continue;
 312
 313                 /* comment line */
 314                 if (*buf == '#')
 315                         continue;
 316
 317                 dbg("lineno %d: '%s'\n", lineno, buf);
 318                 str1 = strsep(&buf, "=");
 319                 if (str1 && strcasecmp(str1, "VENDOR") == 0) {
 320                         str1 = get_value(&buf);
 321                         if (!str1) {
 322                                 retval = -1;
 323                                 break;
 324                         }
 325                         vendor_in = str1;
 326
 327                         str1 = strsep(&buf, "=");
 328                         if (str1 && strcasecmp(str1, "MODEL") == 0) {
 329                                 str1 = get_value(&buf);
 330                                 if (!str1) {
 331                                         retval = -1;
 332                                         break;
 333                                 }
 334                                 model_in = str1;
 335                                 str1 = strsep(&buf, "=");
 336                         }
 337                 }
 338
 339                 if (str1 && strcasecmp(str1, "OPTIONS") == 0) {
 340                         str1 = get_value(&buf);
 341                         if (!str1) {
 342                                 retval = -1;
 343                                 break;
 344                         }
 345                         options_in = str1;
 346                 }
 347                 dbg("config file line %d:\n"
 348                         " vendor '%s'; model '%s'; options '%s'\n",
 349                         lineno, vendor_in, model_in, options_in);
 350                 /*
 351                  * Only allow: [vendor=foo[,model=bar]]options=stuff
 352                  */
 353                 if (!options_in || (!vendor_in && model_in)) {
 354                         info("Error parsing config file line %d '%s'\n", lineno, buffer);
 355                         retval = -1;
 356                         break;
 357                 }
 358                 if (vendor == NULL) {
 359                         if (vendor_in == NULL) {
 360                                 dbg("matched global option\n");
 361                                 break;
 362                         }
 363                 } else if ((vendor_in && strncmp(vendor, vendor_in,
 364                                                  strlen(vendor_in)) == 0) &&
 365                            (!model_in || (strncmp(model, model_in,
 366                                                   strlen(model_in)) == 0))) {
 367                                 /*
 368                                  * Matched vendor and optionally model.
 369                                  *
 370                                  * Note: a short vendor_in or model_in can
 371                                  * give a partial match (that is FOO
 372                                  * matches FOOBAR).
 373                                  */
 374                                 dbg("matched vendor/model\n");
 375                                 break;
 376                 } else {
 377                         dbg("no match\n");
 378                 }
 379         }
 380
 381         if (retval == 0) {
 382                 if (vendor_in != NULL || model_in != NULL ||
 383                     options_in != NULL) {
 384                         /*
 385                          * Something matched. Allocate newargv, and store
 386                          * values found in options_in.
 387                          */
 388                         strcpy(buffer, options_in);
 389                         c = argc_count(buffer) + 2;
 390                         *newargv = calloc(c, sizeof(**newargv));
 391                         if (!*newargv) {
 392                                 err("can't allocate memory\n");
 393                                 retval = -1;
 394                         } else {
 395                                 *argc = c;
 396                                 c = 0;
 397                                 /*
 398                                  * argv[0] at 0 is skipped by getopt, but
 399                                  * store the buffer address there for
 400                                  * later freeing
 401                                  */
 402                                 (*newargv)[c] = buffer;
 403                                 for (c = 1; c < *argc; c++)
 404                                         (*newargv)[c] = strsep(&buffer, " \t");
 405                         }
 406                 } else {
 407                         /* No matches  */
 408                         retval = 1;
 409                 }
 410         }
 411         if (retval != 0)
 412                 free(buffer);
 413         fclose(fd);
 414         return retval;
 415 }
 416
 417 static int set_options(int argc, char **argv, const char *short_opts,
 418                        char *target, char *maj_min_dev)
 419 {
 420         int option;
 421
 422         /*
 423          * optind is a global extern used by getopt. Since we can call
 424          * set_options twice (once for command line, and once for config
 425          * file) we have to reset this back to 1.
 426          */
 427         optind = 1;
 428         while (1) {
 429                 option = getopt_long(argc, argv, short_opts, options, NULL);
 430                 if (option == -1)
 431                         break;
 432
 433                 if (optarg)
 434                         dbg("option '%c' arg '%s'\n", option, optarg);
 435                 else
 436                         dbg("option '%c'\n", option);
 437
 438                 switch (option) {
 439                 case 'a':
 440                         always_info = 1;
 441                         break;
 442                 case 'b':
 443                         all_good = 0;
 444                         break;
 445
 446                 case 'd':
 447                         dev_specified = 1;
 448                         strncpy(maj_min_dev, optarg, MAX_PATH_LEN);
 449                         maj_min_dev[MAX_PATH_LEN-1] = '\0';
 450                         break;
 451
 452                 case 'e':
 453                         use_stderr = 1;
 454                         break;
 455
 456                 case 'f':
 457                         strncpy(config_file, optarg, MAX_PATH_LEN);
 458                         config_file[MAX_PATH_LEN-1] = '\0';
 459                         break;
 460
 461                 case 'g':
 462                         all_good = 1;
 463                         break;
 464
 465                 case 'h':
 466                         printf("Usage: scsi_id OPTIONS <device>\n"
 467                                "  --device               device node for SG_IO commands\n"
 468                                "  --devpath              sysfs devpath\n"
 469                                "  --config               location of config file\n"
 470                                "  --page                 SCSI page (0x80, 0x83, pre-spc3-83)\n"
 471                                "  --fallback-to-sysfs    print sysfs values if inquiry fails\n"
 472                                "  --ignore-sysfs         ignore sysfs entries\n"
 473                                "  --blacklisted          threat device as blacklisted\n"
 474                                "  --whitelisted          threat device as whitelisted\n"
 475                                "  --prefix-bus-id        prefix SCSI bus id\n"
 476                                "  --replace-whitespace   replace all whitespaces by underscores\n"
 477                                "  --verbose              verbose logging\n"
 478                                "  --version              print version\n"
 479                                "  --export               print values as environment keys\n"
 480                                "  --help                 print this help text\n\n");
 481                         exit(0);
 482
 483                 case 'i':
 484                         display_bus_id = 1;
 485                         break;
 486
 487                 case 'p':
 488                         if (strcmp(optarg, "0x80") == 0) {
 489                                 default_page_code = PAGE_80;
 490                         } else if (strcmp(optarg, "0x83") == 0) {
 491                                 default_page_code = PAGE_83;
 492                         } else if (strcmp(optarg, "pre-spc3-83") == 0) {
 493                                 default_page_code = PAGE_83_PRE_SPC3;
 494                         } else {
 495                                 info("Unknown page code '%s'\n", optarg);
 496                                 return -1;
 497                         }
 498                         break;
 499
 500                 case 'n':
 501                         ignore_sysfs = 1;
 502                         break;
 503
 504                 case 's':
 505                         sys_specified = 1;
 506                         strncpy(target, optarg, MAX_PATH_LEN);
 507                         target[MAX_PATH_LEN-1] = '\0';
 508                         break;
 509
 510                 case 'u':
 511                         reformat_serial = 1;
 512                         break;
 513
 514                 case 'x':
 515                         export = 1;
 516                         break;
 517
 518                 case 'v':
 519                         debug++;
 520                         break;
 521
 522                 case 'V':
 523                         printf("%s\n", SCSI_ID_VERSION);
 524                         exit(0);
 525                         break;
 526
 527                 default:
 528                         exit(1);
 529                 }
 530         }
 531         return 0;
 532 }
 533
 534 static int per_dev_options(struct sysfs_device *dev_scsi, int *good_bad, int *page_code)
 535 {
 536         int retval;
 537         int newargc;
 538         char **newargv = NULL;
 539         int option;
 540
 541         *good_bad = all_good;
 542         *page_code = default_page_code;
 543
 544         retval = get_file_options(vendor_str, model_str, &newargc, &newargv);
 545
 546         optind = 1; /* reset this global extern */
 547         while (retval == 0) {
 548                 option = getopt_long(newargc, newargv, dev_short_options, options, NULL);
 549                 if (option == -1)
 550                         break;
 551
 552                 if (optarg)
 553                         dbg("option '%c' arg '%s'\n", option, optarg);
 554                 else
 555                         dbg("option '%c'\n", option);
 556
 557                 switch (option) {
 558                 case 'b':
 559                         *good_bad = 0;
 560                         break;
 561
 562                 case 'g':
 563                         *good_bad = 1;
 564                         break;
 565
 566                 case 'p':
 567                         if (strcmp(optarg, "0x80") == 0) {
 568                                 *page_code = PAGE_80;
 569                         } else if (strcmp(optarg, "0x83") == 0) {
 570                                 *page_code = PAGE_83;
 571                         } else if (strcmp(optarg, "pre-spc3-83") == 0) {
 572                                 *page_code = PAGE_83_PRE_SPC3;
 573                         } else {
 574                                 info("Unknown page code '%s'\n", optarg);
 575                                 retval = -1;
 576                         }
 577                         break;
 578
 579                 default:
 580                         info("Unknown or bad option '%c' (0x%x)\n", option, option);
 581                         retval = -1;
 582                         break;
 583                 }
 584         }
 585
 586         if (newargv) {
 587                 free(newargv[0]);
 588                 free(newargv);
 589         }
 590         return retval;
 591 }
 592
 593 static int set_sysfs_values(struct sysfs_device *dev_scsi)
 594 {
 595         const char *vendor, *model, *type;
 596
 597         vendor = sysfs_attr_get_value(dev_scsi->devpath, "vendor");
 598         if (!vendor) {
 599                 info("%s: cannot get vendor attribute\n", dev_scsi->devpath);
 600                 return -1;
 601         }
 602         set_str(vendor_str, vendor, sizeof(vendor_str)-1);
 603
 604         model = sysfs_attr_get_value(dev_scsi->devpath, "model");
 605         if (!model) {
 606                 info("%s: cannot get model attribute\n", dev_scsi->devpath);
 607                 return -1;
 608         }
 609         set_str(model_str, model, sizeof(model_str)-1);
 610
 611         type = sysfs_attr_get_value(dev_scsi->devpath, "type");
 612         if (!type) {
 613                 info("%s: cannot get type attribute\n", dev_scsi->devpath);
 614                 return -1;
 615         }
 616         set_type(type_str, type, sizeof(type_str));
 617
 618         type = sysfs_attr_get_value(dev_scsi->devpath, "rev");
 619         if (!type) {
 620                 info("%s: cannot get type attribute\n", dev_scsi->devpath);
 621                 return -1;
 622         }
 623         set_str(revision_str, type, sizeof(revision_str)-1);
 624
 625         return 0;
 626 }
 627
 628 static int set_inq_values(struct sysfs_device *dev_scsi, const char *path)
 629 {
 630         int retval;
 631         char vendor[8], model[16], type[4], rev[4];
 632
 633         retval = scsi_std_inquiry(dev_scsi, path, vendor, model, rev, type);
 634         if (retval)
 635             return retval;
 636
 637         set_str(vendor_str, vendor, 8);
 638         set_str(model_str, model, 16);
 639         set_type(type_str, type, sizeof(type_str) - 1);
 640         set_str(revision_str, rev, sizeof(revision_str) -1);
 641
 642         return 0;
 643 }
 644
 645 /*
 646  * format_serial: replace to whitespaces by underscores for calling
 647  * programs that use the serial for device naming (multipath, Suse
 648  * naming, etc...)
 649  */
 650 static void format_serial(char *serial)
 651 {
 652         char *p = serial, *q;
 653
 654         q = p;
 655         while (*p != '\0') {
 656                 if (isspace(*p)) {
 657                         if (q > serial && q[-1] != '_') {
 658                                 *q = '_';
 659                                 q++;
 660                         }
 661                 } else {
 662                         *q = *p;
 663                         q++;
 664                 }
 665                 p++;
 666         }
 667         *q = '\0';
 668 }
 669
 670 /*
 671  * scsi_id: try to get an id, if one is found, printf it to stdout.
 672  * returns a value passed to exit() - 0 if printed an id, else 1. This
 673  * could be expanded, for example, if we want to report a failure like no
 674  * memory etc. return 2, and return 1 for expected cases (like broken
 675  * device found) that do not print an id.
 676  */
 677 static int scsi_id(const char *devpath, char *maj_min_dev)
 678 {
 679         int retval;
 680         int dev_type = 0;
 681         struct sysfs_device *dev;
 682         struct sysfs_device *dev_scsi = NULL;
 683         int good_dev;
 684         int page_code;
 685         char serial[MAX_SERIAL_LEN] = "";
 686         char serial_short[MAX_SERIAL_LEN] = "";
 687         const char *bus_str = NULL;
 688
 689         dbg("devpath %s\n", devpath);
 690
 691         dev = sysfs_device_get(devpath);
 692         if (dev == NULL) {
 693                 err("unable to access '%s'\n", devpath);
 694                 return 1;
 695         }
 696
 697         if (strcmp(dev->subsystem, "block") == 0)
 698                 dev_type = S_IFBLK;
 699         else
 700                 dev_type = S_IFCHR;
 701
 702         /* mknod a temp dev to communicate with the device */
 703         if (!dev_specified && create_tmp_dev(dev->devpath, maj_min_dev, dev_type)) {
 704                 dbg("create_tmp_dev failed\n");
 705                 return 1;
 706         }
 707
 708         if (!ignore_sysfs) {
 709                 /* get scsi parent device */
 710                 dev_scsi = sysfs_device_get_parent_with_subsystem(dev, "scsi");
 711                 if (dev_scsi == NULL) {
 712                         err("unable to access parent device of '%s'\n", devpath);
 713                         return 1;
 714                 }
 715                 set_sysfs_values(dev_scsi);
 716                 bus_str = "scsi";
 717         } else {
 718                 dev_scsi = dev;
 719                 set_inq_values(dev_scsi, maj_min_dev);
 720         }
 721
 722         /* get per device (vendor + model) options from the config file */
 723         retval = per_dev_options(dev_scsi, &good_dev, &page_code);
 724         dbg("per dev options: good %d; page code 0x%x\n", good_dev, page_code);
 725
 726         if (!good_dev) {
 727                 retval = 1;
 728         } else if (scsi_get_serial(dev_scsi, maj_min_dev, page_code,
 729                                    serial, serial_short, MAX_SERIAL_LEN)) {
 730                 retval = always_info?0:1;
 731         } else {
 732                 retval = 0;
 733         }
 734         if (!retval) {
 735                 if (export) {
 736                         char serial_str[MAX_SERIAL_LEN];
 737
 738                         printf("ID_VENDOR=%s\n", vendor_str);
 739                         printf("ID_MODEL=%s\n", model_str);
 740                         printf("ID_REVISION=%s\n", revision_str);
 741                         set_str(serial_str, serial, sizeof(serial_str));
 742                         printf("ID_SERIAL=%s\n", serial_str);
 743                         set_str(serial_str, serial_short, sizeof(serial_str));
 744                         printf("ID_SERIAL_SHORT=%s\n", serial_str);
 745                         printf("ID_TYPE=%s\n", type_str);
 746                         if (bus_str != NULL)
 747                                 printf("ID_BUS=%s\n", bus_str);
 748                 } else {
 749                         if (reformat_serial)
 750                                 format_serial(serial);
 751                         if (display_bus_id)
 752                                 printf("%s: ", dev_scsi->kernel);
 753                         printf("%s\n", serial);
 754                 }
 755                 dbg("%s\n", serial);
 756                 retval = 0;
 757         }
 758
 759         if (!dev_specified)
 760                 unlink(maj_min_dev);
 761
 762         return retval;
 763 }
 764
 765 int main(int argc, char **argv)
 766 {
 767         int retval = 0;
 768         char devpath[MAX_PATH_LEN];
 769         char maj_min_dev[MAX_PATH_LEN];
 770         int newargc;
 771         const char *env;
 772         char **newargv;
 773
 774         logging_init("scsi_id");
 775         sysfs_init();
 776         dbg("argc is %d\n", argc);
 777
 778         /* sysfs path can be overridden for testing */
 779         env = getenv("SYSFS_PATH");
 780         if (env) {
 781                 strncpy(sysfs_path, env, sizeof(sysfs_path));
 782                 sysfs_path[sizeof(sysfs_path)-1] = '\0';
 783         } else
 784                 strcpy(sysfs_path, "/sys");
 785
 786         env = getenv("DEVPATH");
 787         if (env) {
 788                 hotplug_mode = 1;
 789                 sys_specified = 1;
 790                 strncpy(devpath, env, MAX_PATH_LEN);
 791                 devpath[sizeof(devpath)-1] = '\0';
 792         }
 793
 794         /*
 795          * Get config file options.
 796          */
 797         newargv = NULL;
 798         retval = get_file_options(NULL, NULL, &newargc, &newargv);
 799         if (retval < 0) {
 800                 retval = 1;
 801                 goto exit;
 802         }
 803         if (newargv && (retval == 0)) {
 804                 if (set_options(newargc, newargv, short_options, devpath,
 805                                 maj_min_dev) < 0) {
 806                         retval = 2;
 807                         goto exit;
 808                 }
 809                 free(newargv);
 810         }
 811
 812         /*
 813          * Get command line options (overriding any config file or DEVPATH
 814          * settings).
 815          */
 816         if (set_options(argc, argv, short_options, devpath, maj_min_dev) < 0)
 817                 exit(1);
 818
 819         if (!sys_specified) {
 820                 info("--devpath=<path> must be specified\n");
 821                 retval = 1;
 822                 goto exit;
 823         }
 824
 825         retval = scsi_id(devpath, maj_min_dev);
 826
 827 exit:
 828         sysfs_cleanup();
 829         logging_close();
 830         return retval;
 831 }