usr/src/cmd/fwflash/common/fwflash.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 /*
  26  * fwflash.c
  27  */
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include <strings.h>
  32 #include <errno.h>
  33 #include <sys/queue.h>
  34 #include <signal.h>
  35 #include <locale.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <sys/param.h>
  39 #include <fcntl.h>
  40 #include <dlfcn.h>
  41 #include <dirent.h>
  42 #include <sys/varargs.h>
  43 #include <libintl.h> /* for gettext(3c) */
  44 #include <libdevinfo.h>
  45 #include <libscf_priv.h>
  46 #include <fwflash/fwflash.h>
  47 #include <sys/modctl.h> /* for MAXMODCONFNAME */
  48
  49 /* global arg list */
  50 int     fwflash_arg_list = 0;
  51 char    *filelist[10];
  52
  53 /* exposed global args */
  54 di_node_t rootnode;
  55 struct PLUGINLIST *fw_pluginlist;
  56 struct DEVICELIST *fw_devices;
  57 struct vrfyplugin *verifier;
  58 struct fw_plugin *self;
  59 int fwflash_debug = 0;
  60
  61 /* are we writing to flash? */
  62 static int fwflash_in_write = 0;
  63
  64 /*
  65  * If we *must* track the version string for fwflash, then
  66  * we should do so in this common file rather than the header
  67  * file since it will then be in sync with what the customer
  68  * sees. We should deprecate the "-v" option since it is not
  69  * actually of any use - it doesn't line up with Mercurial's
  70  * concept of the changeset.
  71  */
  72 #define FWFLASH_VERSION         "v1.9"
  73 #define FWFLASH_PROG_NAME       "fwflash"
  74
  75 static int get_fileopts(char *options);
  76 static int flash_device_list();
  77 static int flash_load_plugins();
  78 static int fwflash_update(char *device, char *filename, int flags);
  79 static int fwflash_read_file(char *device, char *filename);
  80 static int fwflash_list_fw(char *class);
  81 static int fwflash_load_verifier(char *drv, char *vendorid, char *fwimg);
  82 static void fwflash_intr(int sig);
  83 static void fwflash_handle_signals(void);
  84 static void fwflash_usage(char *arg);
  85 static void fwflash_version(void);
  86 static int confirm_target(struct devicelist *thisdev, char *file);
  87
  88 /*
  89  * FWFlash main code
  90  */
  91 int
  92 main(int argc, char **argv)
  93 {
  94         int             rv = FWFLASH_SUCCESS;
  95         int             i;
  96         char            ch;
  97         char            *read_file;
  98         extern char     *optarg;
  99         char            *devclass = NULL;
 100         char            *devpath = NULL;
 101
 102         /* local variables from env */
 103         (void) setlocale(LC_ALL, "");
 104
 105 #if !defined(TEXT_DOMAIN)               /* Should be defined by cc -D */
 106 #define TEXT_DOMAIN     "SYS_TEST"      /* Use this only if it isn't. */
 107 #endif
 108
 109         (void) textdomain(TEXT_DOMAIN);
 110
 111         read_file = NULL;
 112
 113         if (argc < 2) {
 114                 /* no args supplied */
 115                 fwflash_usage(NULL);
 116                 return (FWFLASH_FAILURE);
 117         }
 118
 119         while ((ch = getopt(argc, argv, "hvylc:f:r:Qd:")) != EOF) {
 120                 switch (ch) {
 121                 case 'h':
 122                         fwflash_arg_list |= FWFLASH_HELP_FLAG;
 123                         break;
 124                 case 'v':
 125                         fwflash_arg_list |= FWFLASH_VER_FLAG;
 126                         break;
 127                 case 'y':
 128                         fwflash_arg_list |= FWFLASH_YES_FLAG;
 129                         break;
 130                 case 'l':
 131                         fwflash_arg_list |= FWFLASH_LIST_FLAG;
 132                         break;
 133                 case 'c':
 134                         fwflash_arg_list |= FWFLASH_CLASS_FLAG;
 135                         /* we validate later */
 136                         devclass = strdup(optarg);
 137                         break;
 138                 case 'd':
 139                         fwflash_arg_list |= FWFLASH_DEVICE_FLAG;
 140                         devpath = strdup(optarg);
 141                         break;
 142                 case 'f':
 143                         fwflash_arg_list |= FWFLASH_FW_FLAG;
 144                         if ((rv = get_fileopts(optarg)) != FWFLASH_SUCCESS) {
 145                                 fwflash_usage(NULL);
 146                                 return (FWFLASH_FAILURE);
 147                         }
 148                         break;
 149                 case 'r':
 150                         fwflash_arg_list |= FWFLASH_READ_FLAG;
 151                         read_file = strdup(optarg);
 152                         break;
 153                 case 'Q':
 154                         /* NOT in the manpage */
 155                         fwflash_debug = 1;
 156                         break;
 157                 /* illegal options */
 158                 default:
 159                         fwflash_usage(optarg);
 160                         return (FWFLASH_FAILURE);
 161                 }
 162         }
 163
 164         /* Do Help */
 165         if ((fwflash_arg_list & FWFLASH_HELP_FLAG) ||
 166             ((fwflash_arg_list & FWFLASH_DEVICE_FLAG) &&
 167             !((fwflash_arg_list & FWFLASH_FW_FLAG) ||
 168             (fwflash_arg_list & FWFLASH_READ_FLAG)))) {
 169                 fwflash_usage(NULL);
 170                 return (FWFLASH_SUCCESS);
 171         }
 172
 173         /* Do Version */
 174         if (fwflash_arg_list == FWFLASH_VER_FLAG) {
 175                 fwflash_version();
 176                 return (FWFLASH_SUCCESS);
 177         }
 178
 179         /* generate global list of devices */
 180         if ((rv = flash_load_plugins()) != FWFLASH_SUCCESS) {
 181                 logmsg(MSG_ERROR,
 182                     gettext("Unable to load fwflash plugins\n"));
 183                 fwflash_intr(0);
 184                 return (rv);
 185         }
 186
 187         if ((rv = flash_device_list()) != FWFLASH_SUCCESS) {
 188                 logmsg(MSG_ERROR,
 189                     gettext("No flashable devices in this system\n"));
 190                 fwflash_intr(0);
 191                 return (rv);
 192         }
 193
 194         /* Do list */
 195         if (fwflash_arg_list == (FWFLASH_LIST_FLAG) ||
 196             fwflash_arg_list == (FWFLASH_LIST_FLAG | FWFLASH_CLASS_FLAG)) {
 197                 rv = fwflash_list_fw(devclass);
 198                 fwflash_intr(0);
 199                 return (rv);
 200         }
 201
 202         fwflash_handle_signals();
 203
 204         /* Do flash update (write) */
 205         if ((fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG)) ||
 206             (fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG |
 207             FWFLASH_YES_FLAG))) {
 208                 int fastreboot_disabled = 0;
 209                 /* the update function handles the real arg parsing */
 210                 i = 0;
 211                 while (filelist[i] != NULL) {
 212                         if ((rv = fwflash_update(devpath, filelist[i],
 213                             fwflash_arg_list)) == FWFLASH_SUCCESS) {
 214                                 /* failed ops have already been noted */
 215                                 if (!fastreboot_disabled &&
 216                                     scf_fastreboot_default_set_transient(
 217                                     B_FALSE) != SCF_SUCCESS)
 218                                         logmsg(MSG_ERROR, gettext(
 219                                             "Failed to disable fast "
 220                                             "reboot.\n"));
 221                                 else
 222                                         fastreboot_disabled = 1;
 223                                 logmsg(MSG_ERROR,
 224                                     gettext("New firmware will be activated "
 225                                     "after you reboot\n\n"));
 226                         }
 227                         ++i;
 228                 }
 229
 230                 fwflash_intr(0);
 231                 return (rv);
 232         }
 233
 234         /* Do flash read */
 235         if ((fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG)) ||
 236             (fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG |
 237             FWFLASH_YES_FLAG))) {
 238                 rv = fwflash_read_file(devpath, read_file);
 239                 fwflash_intr(0);
 240                 return (rv);
 241         }
 242
 243         fwflash_usage(NULL);
 244
 245         return (FWFLASH_FAILURE);
 246 }
 247
 248
 249 static int
 250 flash_load_plugins()
 251 {
 252
 253         int rval = FWFLASH_SUCCESS;
 254         DIR *dirp;
 255         struct dirent *plugdir;
 256         char *plugname;
 257         struct fw_plugin *tmpplug;
 258         struct pluginlist *tmpelem;
 259         void *sym;
 260         char *fwplugdirpath, *tempdirpath;
 261
 262
 263 #define CLOSEFREE()     {                       \
 264         (void) dlclose(tmpplug->handle);        \
 265         free(tmpplug); }
 266
 267         /*
 268          * Procedure:
 269          *
 270          * cd /usr/lib/fwflash/identify
 271          * open each .so file found therein
 272          * dlopen(.sofile)
 273          * if it's one of our plugins, add it to fw_pluginlist;
 274          *
 275          * functions we need here include dlopen and dlsym.
 276          *
 277          * If we get to the end and fw_pluginlist struct is empty,
 278          * return FWFLASH_FAILURE so we return to the shell.
 279          */
 280
 281         if ((fwplugdirpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
 282                 logmsg(MSG_ERROR,
 283                     gettext("Unable to malloc %d bytes while "
 284                     "trying to load plugins: %s\n"),
 285                     MAXPATHLEN + 1, strerror(errno));
 286                 return (FWFLASH_FAILURE);
 287         }
 288
 289         tempdirpath = getenv("FWPLUGINDIR");
 290
 291         if ((fwflash_debug > 0) && (tempdirpath != NULL)) {
 292                 (void) strlcpy(fwplugdirpath, tempdirpath,
 293                     strlen(tempdirpath) + 1);
 294         } else {
 295                 (void) strlcpy(fwplugdirpath, FWPLUGINDIR,
 296                     strlen(FWPLUGINDIR) + 1);
 297         }
 298
 299         if ((dirp = opendir(fwplugdirpath)) == NULL) {
 300                 logmsg(MSG_ERROR,
 301                     gettext("Unable to open %s\n"),
 302                     fwplugdirpath);
 303                 return (errno);
 304         }
 305
 306         if ((plugdir = calloc(1, sizeof (struct dirent) + MAXPATHLEN + 1))
 307             == NULL) {
 308                 logmsg(MSG_ERROR,
 309                     gettext("Unable to malloc %d bytes while "
 310                     "trying to load plugins: %s\n"),
 311                     MAXPATHLEN + 1 + sizeof (struct dirent),
 312                     strerror(errno));
 313                 return (FWFLASH_FAILURE);
 314         }
 315
 316         if ((fw_pluginlist = calloc(1, sizeof (struct fw_plugin)))
 317             == NULL) {
 318                 logmsg(MSG_ERROR,
 319                     gettext("Unable to malloc %d bytes while "
 320                     "trying to load plugins: %s\n"),
 321                     sizeof (struct fw_plugin), strerror(errno));
 322                 return (FWFLASH_FAILURE);
 323         }
 324
 325         TAILQ_INIT(fw_pluginlist);
 326
 327         while ((readdir_r(dirp, plugdir, &plugdir) == 0) && (plugdir != NULL)) {
 328
 329                 errno = 0; /* remove chance of false results */
 330
 331                 if ((plugdir->d_name[0] == '.') ||
 332                     (strstr(plugdir->d_name, ".so") == NULL)) {
 333                         continue;
 334                 }
 335
 336                 if ((plugname = calloc(1, MAXPATHLEN + 1)) == NULL) {
 337                         logmsg(MSG_ERROR,
 338                             gettext("Unable to malloc %d bytes while "
 339                             "trying to load plugins: %s\n"),
 340                             MAXPATHLEN + 1, strerror(errno));
 341                         return (FWFLASH_FAILURE);
 342                 }
 343
 344                 (void) snprintf(plugname, MAXPATHLEN, "%s/%s",
 345                     fwplugdirpath, plugdir->d_name);
 346
 347                 /* start allocating storage */
 348                 if ((tmpelem = calloc(1, sizeof (struct pluginlist)))
 349                     == NULL) {
 350                         logmsg(MSG_ERROR,
 351                             gettext("Unable to malloc %d bytes while "
 352                             "trying to load plugins: %s\n"),
 353                             sizeof (struct pluginlist), strerror(errno));
 354                         return (FWFLASH_FAILURE);
 355                 }
 356
 357                 if ((tmpplug = calloc(1, sizeof (struct fw_plugin)))
 358                     == NULL) {
 359                         logmsg(MSG_ERROR,
 360                             gettext("Unable to malloc %d bytes while "
 361                             "trying to load plugins: %s\n"),
 362                             sizeof (struct fw_plugin), strerror(errno));
 363                         return (FWFLASH_FAILURE);
 364                 }
 365
 366                 /* load 'er up! */
 367                 tmpplug->handle = dlopen(plugname, RTLD_NOW);
 368                 if (tmpplug->handle == NULL) {
 369                         free(tmpplug);
 370                         continue; /* assume there are other plugins */
 371                 }
 372
 373                 if ((tmpplug->filename = calloc(1, strlen(plugname) + 1))
 374                     == NULL) {
 375                         logmsg(MSG_ERROR,
 376                             gettext("Unable to allocate %d bytes for plugin "
 377                             "filename %s:%s\n"),
 378                             strlen(plugname) + 1, plugname,
 379                             strerror(errno));
 380                         return (rval);
 381                 }
 382
 383                 (void) strlcpy(tmpplug->filename, plugname,
 384                     strlen(plugname) + 1);
 385
 386                 /* now sanity check the file */
 387                 if ((sym = dlsym(tmpplug->handle, "drivername"))
 388                     != NULL) {
 389                         /* max length of drivername */
 390                         tmpplug->drvname = calloc(1, MAXMODCONFNAME);
 391
 392                         /* are we doing double-time? */
 393                         if (strncmp((char *)sym, plugdir->d_name,
 394                             MAXMODCONFNAME) != 0) {
 395                                 char *tempnm = calloc(1, MAXMODCONFNAME);
 396
 397                                 (void) memcpy(tempnm, plugdir->d_name,
 398                                     MAXMODCONFNAME);
 399                                 (void) strlcpy(tmpplug->drvname,
 400                                     strtok(tempnm, "."),
 401                                     strlen(plugdir->d_name) + 1);
 402                                 free(tempnm);
 403                         } else {
 404                                 (void) strlcpy(tmpplug->drvname,
 405                                     (char *)sym, strlen(sym) + 1);
 406                         }
 407                 } else {
 408                         CLOSEFREE();
 409                         continue;
 410                 }
 411                 if ((sym = dlsym(tmpplug->handle, "fw_readfw"))
 412                     != NULL) {
 413                         tmpplug->fw_readfw = (int (*)())sym;
 414                 } else {
 415                         CLOSEFREE();
 416                         continue;
 417                 }
 418                 if ((sym = dlsym(tmpplug->handle, "fw_writefw"))
 419                     != NULL) {
 420                         tmpplug->fw_writefw = (int (*)())sym;
 421                 } else {
 422                         CLOSEFREE();
 423                         continue;
 424                 }
 425
 426                 if ((sym = dlsym(tmpplug->handle, "fw_identify"))
 427                     != NULL) {
 428                         tmpplug->fw_identify =
 429                             (int (*)(int))sym;
 430                 } else {
 431                         CLOSEFREE();
 432                         continue;
 433                 }
 434                 if ((sym = dlsym(tmpplug->handle, "fw_devinfo"))
 435                     != NULL) {
 436                         tmpplug->fw_devinfo =
 437                             (int (*)(struct devicelist *))sym;
 438                 } else {
 439                         CLOSEFREE();
 440                         continue;
 441                 }
 442
 443                 if ((sym = dlsym(tmpplug->handle, "plugin_version"))
 444                     != NULL) {
 445                         if ((*(int *)sym) >= FWPLUGIN_VERSION_2) {
 446                                 if ((sym = dlsym(tmpplug->handle,
 447                                     "fw_cleanup")) != NULL) {
 448                                         tmpplug->fw_cleanup =
 449                                             (void (*)(struct devicelist *))sym;
 450                                 } else {
 451                                         logmsg(MSG_ERROR,
 452                                             gettext("ERROR: v2 plugin (%s) "
 453                                             "has no fw_cleanup function\n"),
 454                                             tmpplug->filename);
 455                                         CLOSEFREE();
 456                                         continue;
 457                                 }
 458                         } else {
 459                                 logmsg(MSG_INFO,
 460                                     "Identification plugin %s defined "
 461                                     "plugin_version < FWPLUGIN_VERSION_2 !");
 462                         }
 463                 }
 464
 465                 if ((tmpelem->drvname = calloc(1, MAXMODCONFNAME))
 466                     == NULL) {
 467                         logmsg(MSG_ERROR,
 468                             gettext("Unable to allocate space for a"
 469                             "drivername %s\n"),
 470                             tmpplug->drvname);
 471                         return (FWFLASH_FAILURE);
 472                 }
 473
 474                 (void) strlcpy(tmpelem->drvname, tmpplug->drvname,
 475                     strlen(tmpplug->drvname) + 1);
 476
 477                 if ((tmpelem->filename = calloc(1,
 478                     strlen(tmpplug->filename) + 1)) == NULL) {
 479                         logmsg(MSG_ERROR,
 480                             gettext("Unable to allocate %d bytes for "
 481                             "filename %s\n"),
 482                             strlen(tmpplug->filename) + 1,
 483                             tmpplug->filename);
 484                         return (FWFLASH_FAILURE);
 485                 }
 486
 487                 (void) strlcpy(tmpelem->filename, plugname,
 488                     strlen(plugname) + 1);
 489                 tmpelem->plugin = tmpplug;
 490
 491                 /* CONSTCOND */
 492                 TAILQ_INSERT_TAIL(fw_pluginlist, tmpelem, nextplugin);
 493         }
 494
 495         if ((plugdir == NULL) && TAILQ_EMPTY(fw_pluginlist)) {
 496                 return (FWFLASH_FAILURE);
 497         }
 498
 499         if (errno != 0) {
 500                 logmsg(MSG_ERROR,
 501                     gettext("Error reading directory entry in %s\n"),
 502                     fwplugdirpath);
 503                 rval = errno;
 504         }
 505
 506         free(fwplugdirpath);
 507         free(plugdir);
 508         (void) closedir(dirp);
 509         return (rval);
 510 }
 511
 512 /*
 513  * fwflash_load_verifier dlload()s the appropriate firmware image
 514  * verification plugin, and attaches the designated fwimg's fd to
 515  * the vrfyplugin structure so we only have to load the image in
 516  * one place.
 517  */
 518 int
 519 fwflash_load_verifier(char *drv, char *vendorid, char *fwimg)
 520 {
 521
 522         int rv = FWFLASH_FAILURE;
 523         int imgfd;
 524         char *fwvrfydirpath, *tempdirpath, *filename;
 525         char *clean; /* for the space-removed vid */
 526         struct stat fwstat;
 527         struct vrfyplugin *vrfy;
 528         void *vrfysym;
 529
 530         /*
 531          * To make flashing multiple firmware images somewhat more
 532          * efficient, we start this function by checking whether a
 533          * verifier for this device has already been loaded. If it
 534          * has been loaded, we replace the imgfile information, and
 535          * then continue as if we were loading for the first time.
 536          */
 537
 538         if (verifier != NULL) {
 539                 verifier->imgsize = 0;
 540                 verifier->flashbuf = 0; /* set by the verifier function */
 541
 542                 if (verifier->imgfile != NULL) {
 543                         free(verifier->imgfile);
 544                         verifier->imgfile = NULL;
 545                 }
 546
 547                 if (verifier->fwimage != NULL) {
 548                         free(verifier->fwimage);
 549                         verifier->fwimage = NULL;
 550                 }
 551         } else {
 552                 if ((fwvrfydirpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
 553                         logmsg(MSG_ERROR,
 554                             gettext("Unable to allocate space for a firmware "
 555                             "verifier file(1)"));
 556                         return (rv);
 557                 }
 558
 559                 if ((filename = calloc(1, MAXPATHLEN + 1)) == NULL) {
 560                         logmsg(MSG_ERROR,
 561                             gettext("Unable to allocate space "
 562                             "for a firmware verifier file(2)"));
 563                         free(fwvrfydirpath);
 564                         return (rv);
 565                 }
 566
 567                 /*
 568                  * Since SCSI devices can have a vendor id of up to 8
 569                  * left-aligned and _space-padded_ characters, we first need to
 570                  * strip off any space characters before we try to make a
 571                  * filename out of it
 572                  */
 573                 clean = strtok(vendorid, " ");
 574                 if (clean == NULL) {
 575                         /* invalid vendorid, something's really wrong */
 576                         logmsg(MSG_ERROR,
 577                             gettext("Invalid vendorid (null) specified for "
 578                             "device\n"));
 579                         free(filename);
 580                         free(fwvrfydirpath);
 581                         return (rv);
 582                 }
 583
 584                 tempdirpath = getenv("FWVERIFYPLUGINDIR");
 585
 586                 if ((fwflash_debug > 0) && (tempdirpath != NULL)) {
 587                         (void) strlcpy(fwvrfydirpath, tempdirpath,
 588                             strlen(tempdirpath) + 1);
 589                 } else {
 590                         (void) strlcpy(fwvrfydirpath, FWVERIFYPLUGINDIR,
 591                             strlen(FWVERIFYPLUGINDIR) + 1);
 592                 }
 593
 594                 if ((vrfy = calloc(1, sizeof (struct vrfyplugin))) == NULL) {
 595                         logmsg(MSG_ERROR,
 596                             gettext("Unable to allocate space "
 597                             "for a firmware verifier structure"));
 598                         free(filename);
 599                         free(fwvrfydirpath);
 600                         return (rv);
 601                 }
 602
 603                 errno = 0; /* false positive removal */
 604
 605                 (void) snprintf(filename, MAXPATHLEN, "%s/%s-%s.so",
 606                     fwvrfydirpath, drv, clean);
 607                 if ((vrfy->handle = dlopen(filename, RTLD_NOW)) == NULL) {
 608                         logmsg(MSG_INFO, gettext(dlerror()));
 609                         logmsg(MSG_INFO,
 610                             gettext("\nUnable to open verification plugin "
 611                             "%s. Looking for %s-GENERIC plugin instead.\n"),
 612                             filename, drv);
 613
 614                         /* Try the drv-GENERIC.so form, _then_ die */
 615                         bzero(filename, strlen(filename) + 1);
 616                         (void) snprintf(filename, MAXPATHLEN,
 617                             "%s/%s-GENERIC.so", fwvrfydirpath, drv);
 618
 619                         if ((vrfy->handle = dlopen(filename, RTLD_NOW))
 620                             == NULL) {
 621                                 logmsg(MSG_INFO, gettext(dlerror()));
 622                                 logmsg(MSG_ERROR,
 623                                     gettext("\nUnable to open either "
 624                                     "verification plugin %s/%s-%s.so or "
 625                                     "generic plugin %s.\nUnable to verify "
 626                                     "firmware image. Aborting.\n"),
 627                                     fwvrfydirpath, drv, clean, filename);
 628                                 free(filename);
 629                                 free(fwvrfydirpath);
 630                                 return (rv);
 631                         }
 632                 }
 633
 634                 if ((vrfy->filename = calloc(1, strlen(filename) + 1))
 635                     == NULL) {
 636                         logmsg(MSG_ERROR,
 637                             gettext("Unable to allocate space to store "
 638                             "a verifier filename\n"));
 639                         free(filename);
 640                         free(fwvrfydirpath);
 641                         free(vrfy->handle);
 642                         return (rv);
 643                 }
 644                 (void) strlcpy(vrfy->filename, filename, strlen(filename) + 1);
 645
 646                 if ((vrfysym = dlsym(vrfy->handle, "vendorvrfy")) == NULL) {
 647                         logmsg(MSG_ERROR,
 648                             gettext("%s is an invalid firmware verification "
 649                             "plugin."), filename);
 650                         (void) dlclose(vrfy->handle);
 651                         free(filename);
 652                         free(fwvrfydirpath);
 653                         free(vrfy);
 654                         return (rv);
 655                 } else {
 656                         vrfy->vendorvrfy =
 657                             (int (*)(struct devicelist *))vrfysym;
 658                 }
 659
 660                 vrfysym = dlsym(vrfy->handle, "vendor");
 661
 662                 if (vrfysym == NULL) {
 663                         logmsg(MSG_ERROR,
 664                             gettext("Invalid vendor (null) in verification "
 665                             "plugin %s\n"), filename);
 666                         (void) dlclose(vrfy->handle);
 667                         free(vrfy);
 668                         return (rv);
 669                 } else {
 670                         if (strncmp(vendorid, (char *)vrfysym,
 671                             strlen(vendorid)) != 0) {
 672                                 logmsg(MSG_INFO,
 673                                     "Using a sym-linked (%s -> %s) "
 674                                     "verification plugin\n",
 675                                     vendorid, vrfysym);
 676                                 vrfy->vendor = calloc(1, strlen(vendorid) + 1);
 677                         } else {
 678                                 vrfy->vendor = calloc(1, strlen(vrfysym) + 1);
 679                         }
 680                         (void) strlcpy(vrfy->vendor, (char *)vrfysym,
 681                             strlen(vendorid) + 1);
 682                 }
 683
 684                 verifier = vrfy; /* a convenience variable */
 685                 free(filename);
 686                 free(fwvrfydirpath);
 687         }
 688
 689         /*
 690          * We don't do any verification that the fw image file is in
 691          * an approved location, but it's easy enough to modify this
 692          * function to do so. The verification plugin should provide
 693          * sufficient protection.
 694          */
 695
 696         if ((imgfd = open(fwimg, O_RDONLY)) < 0) {
 697                 logmsg(MSG_ERROR,
 698                     gettext("Unable to open designated firmware "
 699                     "image file %s: %s\n"),
 700                     (fwimg != NULL) ? fwimg : "(null)",
 701                     strerror(errno));
 702                 rv = FWFLASH_FAILURE;
 703                 goto cleanup;
 704         }
 705
 706         if (stat(fwimg, &fwstat) == -1) {
 707                 logmsg(MSG_ERROR,
 708                     gettext("Unable to stat() firmware image file "
 709                     "%s: %s\n"),
 710                     fwimg, strerror(errno));
 711                 rv = FWFLASH_FAILURE;
 712                 goto cleanup;
 713         } else {
 714                 verifier->imgsize = fwstat.st_size;
 715                 if ((verifier->fwimage = calloc(1, verifier->imgsize))
 716                     == NULL) {
 717                         logmsg(MSG_ERROR,
 718                             gettext("Unable to load firmware image "
 719                             "%s: %s\n"),
 720                             fwimg, strerror(errno));
 721                         rv = FWFLASH_FAILURE;
 722                         goto cleanup;
 723                 }
 724         }
 725
 726         errno = 0;
 727         if ((rv = read(imgfd, verifier->fwimage,
 728             (size_t)verifier->imgsize)) < verifier->imgsize) {
 729                 /* we haven't read enough data, bail */
 730                 logmsg(MSG_ERROR,
 731                     gettext("Failed to read sufficient data "
 732                     "(got %d bytes, expected %d bytes) from "
 733                     "firmware image file %s: %s\n"),
 734                     rv, verifier->imgsize,
 735                     verifier->filename, strerror(errno));
 736                 rv = FWFLASH_FAILURE;
 737         } else {
 738                 rv = FWFLASH_SUCCESS;
 739         }
 740
 741         if ((verifier->imgfile = calloc(1, strlen(fwimg) + 1)) == NULL) {
 742                 logmsg(MSG_ERROR,
 743                     gettext("Unable to save name of firmware image\n"));
 744                 rv = FWFLASH_FAILURE;
 745         } else {
 746                 (void) strlcpy(verifier->imgfile, fwimg, strlen(fwimg) + 1);
 747         }
 748
 749         if (rv != FWFLASH_SUCCESS) {
 750                 /* cleanup and let's get outta here */
 751 cleanup:
 752                 free(verifier->filename);
 753                 free(verifier->vendor);
 754
 755                 if (!(fwflash_arg_list & FWFLASH_READ_FLAG) &&
 756                     verifier->fwimage)
 757                         free(verifier->fwimage);
 758
 759                 verifier->filename = NULL;
 760                 verifier->vendor = NULL;
 761                 verifier->vendorvrfy = NULL;
 762                 verifier->fwimage = NULL;
 763                 (void) dlclose(verifier->handle);
 764                 verifier->handle = NULL;
 765                 free(verifier);
 766                 if (imgfd >= 0) {
 767                         (void) close(imgfd);
 768                 }
 769                 verifier = NULL;
 770         }
 771
 772         return (rv);
 773 }
 774
 775 /*
 776  * cycles through the global list of plugins to find
 777  * each flashable device, which is added to fw_devices
 778  *
 779  * Each plugin's identify routine must allocated storage
 780  * as required.
 781  *
 782  * Each plugin's identify routine must return
 783  * FWFLASH_FAILURE if it cannot find any devices
 784  * which it handles.
 785  */
 786 static int
 787 flash_device_list()
 788 {
 789         int rv = FWFLASH_FAILURE;
 790         int startidx = 0;
 791         int sumrv = 0;
 792         struct pluginlist *plugins;
 793
 794         /* we open rootnode here, and close it in fwflash_intr */
 795         if ((rootnode = di_init("/", DINFOCPYALL|DINFOFORCE)) == DI_NODE_NIL) {
 796                 logmsg(MSG_ERROR,
 797                     gettext("Unable to take device tree snapshot: %s\n"),
 798                     strerror(errno));
 799                 return (rv);
 800         }
 801
 802         if ((fw_devices = calloc(1, sizeof (struct devicelist))) == NULL) {
 803                 logmsg(MSG_ERROR,
 804                     gettext("Unable to malloc %d bytes while "
 805                     "trying to find devices: %s\n"),
 806                     sizeof (struct devicelist), strerror(errno));
 807                 return (FWFLASH_FAILURE);
 808         }
 809
 810         /* CONSTCOND */
 811         TAILQ_INIT(fw_devices);
 812
 813         TAILQ_FOREACH(plugins, fw_pluginlist, nextplugin) {
 814                 self = plugins->plugin;
 815                 rv = plugins->plugin->fw_identify(startidx);
 816
 817                 logmsg(MSG_INFO,
 818                     gettext("fwflash:flash_device_list() got %d from "
 819                     "identify routine\n"), rv);
 820
 821                 /* only bump startidx if we've found at least one device */
 822                 if (rv == FWFLASH_SUCCESS) {
 823                         startidx += 100;
 824                         sumrv++;
 825                 } else {
 826                         logmsg(MSG_INFO,
 827                             gettext("No flashable devices attached with "
 828                             "the %s driver in this system\n"),
 829                             plugins->drvname);
 830                 }
 831         }
 832
 833         if (sumrv > 0)
 834                 rv = FWFLASH_SUCCESS;
 835
 836         return (rv);
 837 }
 838
 839 static int
 840 fwflash_list_fw(char *class)
 841 {
 842         int rv = 0;
 843         struct devicelist *curdev;
 844         int header = 1;
 845
 846         TAILQ_FOREACH(curdev, fw_devices, nextdev) {
 847
 848                 /* we're either class-conscious, or we're not */
 849                 if (((class != NULL) &&
 850                     ((strncmp(curdev->classname, "ALL", 3) == 0) ||
 851                     (strcmp(curdev->classname, class) == 0))) ||
 852                     (class == NULL)) {
 853
 854                         if (header != 0) {
 855                                 (void) fprintf(stdout,
 856                                     gettext("List of available devices:\n"));
 857                                 header--;
 858                         }
 859                         /*
 860                          * If any plugin's fw_devinfo() function returns
 861                          * FWFLASH_FAILURE then we want to keep track of
 862                          * it. _Most_ plugins should always return
 863                          * FWFLASH_SUCCESS from this function. The only
 864                          * exception known at this point is the tavor plugin.
 865                          */
 866                         rv += curdev->plugin->fw_devinfo(curdev);
 867                 }
 868         }
 869         return (rv);
 870 }
 871
 872 static int
 873 fwflash_update(char *device, char *filename, int flags)
 874 {
 875
 876         int rv = FWFLASH_FAILURE;
 877         int needsfree = 0;
 878         int found = 0;
 879         struct devicelist *curdev;
 880         char *realfile;
 881
 882         /*
 883          * Here's how we operate:
 884          *
 885          * We perform some basic checks on the args, then walk
 886          * through the device list looking for the device which
 887          * matches. We then load the appropriate verifier for the
 888          * image file and device, verify the image, then call the
 889          * fw_writefw() function of the appropriate plugin.
 890          *
 891          * There is no "force" flag to enable you to flash a firmware
 892          * image onto an incompatible device because the verifier
 893          * will return FWFLASH_FAILURE if the image doesn't match.
 894          */
 895
 896         /* new firmware filename and device desc */
 897         if (filename == NULL) {
 898                 logmsg(MSG_ERROR,
 899                     gettext("Invalid firmware filename (null)\n"));
 900                 return (FWFLASH_FAILURE);
 901         }
 902
 903         if (device == NULL) {
 904                 logmsg(MSG_ERROR,
 905                     gettext("Invalid device requested (null)\n"));
 906                 return (FWFLASH_FAILURE);
 907         }
 908
 909         if ((realfile = calloc(1, PATH_MAX + 1)) == NULL) {
 910                 logmsg(MSG_ERROR,
 911                     gettext("Unable to allocate space for device "
 912                     "filename, operation might fail if %s is"
 913                     "a symbolic link\n"),
 914                     device);
 915                 realfile = device;
 916         } else {
 917                 /*
 918                  * If realpath() succeeds, then we have a valid
 919                  * device filename in realfile.
 920                  */
 921                 if (realpath(device, realfile) == NULL) {
 922                         logmsg(MSG_ERROR,
 923                             gettext("Unable to resolve device filename"
 924                             ": %s\n"),
 925                             strerror(errno));
 926                         /* tidy up */
 927                         free(realfile);
 928                         /* realpath didn't succeed, use fallback */
 929                         realfile = device;
 930                 } else {
 931                         needsfree = 1;
 932                 }
 933         }
 934
 935         logmsg(MSG_INFO,
 936             gettext("fwflash_update: fw_filename (%s) device (%s)\n"),
 937             filename, device);
 938
 939         TAILQ_FOREACH(curdev, fw_devices, nextdev) {
 940                 if (strcmp(curdev->access_devname, realfile) == 0) {
 941                         found++;
 942                         rv = fwflash_load_verifier(curdev->drvname,
 943                             curdev->ident->vid, filename);
 944                         if (rv == FWFLASH_FAILURE) {
 945                                 logmsg(MSG_ERROR,
 946                                     gettext("Unable to load verifier "
 947                                     "for device %s\n"),
 948                                     curdev->access_devname);
 949                                 return (FWFLASH_FAILURE);
 950                         }
 951                         rv = verifier->vendorvrfy(curdev);
 952                         if (rv == FWFLASH_FAILURE) {
 953                                 /* the verifier prints a message */
 954                                 logmsg(MSG_INFO,
 955                                     "verifier (%s) for %s :: %s returned "
 956                                     "FWFLASH_FAILURE\n",
 957                                     verifier->filename,
 958                                     filename, curdev->access_devname);
 959                                 return (rv);
 960                         }
 961
 962                         if (((flags & FWFLASH_YES_FLAG) == FWFLASH_YES_FLAG) ||
 963                             (rv = confirm_target(curdev, filename)) ==
 964                             FWFLASH_YES_FLAG) {
 965                                 logmsg(MSG_INFO,
 966                                     "about to flash using plugin %s\n",
 967                                     curdev->plugin->filename);
 968                                 rv = curdev->plugin->fw_writefw(curdev,
 969                                     filename);
 970                                 if (rv == FWFLASH_FAILURE) {
 971                                         logmsg(MSG_ERROR,
 972                                             gettext("Failed to flash "
 973                                             "firmware file %s on "
 974                                             "device %s: %d\n"),
 975                                             filename,
 976                                             curdev->access_devname, rv);
 977                                 }
 978                         } else {
 979                                 logmsg(MSG_ERROR,
 980                                     gettext("Flash operation not confirmed "
 981                                     "by user\n"),
 982                                     curdev->access_devname);
 983                                 rv = FWFLASH_FAILURE;
 984                         }
 985                 }
 986         }
 987
 988         if (!found)
 989                 /* report the same device that the user passed in */
 990                 logmsg(MSG_ERROR,
 991                     gettext("Device %s does not appear "
 992                     "to be flashable\n"),
 993                     ((strncmp(device, realfile, strlen(device)) == 0) ?
 994                     realfile : device));
 995
 996         if (needsfree)
 997                 free(realfile);
 998
 999         return (rv);
1000 }
1001
1002 /*
1003  * We validate that the device path is in our global device list and
1004  * that the filename exists, then palm things off to the relevant plugin.
1005  */
1006 static int
1007 fwflash_read_file(char *device, char *filename)
1008 {
1009         struct devicelist *curdev;
1010         int rv;
1011         int found = 0;
1012
1013         /* new firmware filename and device desc */
1014
1015         TAILQ_FOREACH(curdev, fw_devices, nextdev) {
1016                 if (strncmp(curdev->access_devname, device,
1017                     MAXPATHLEN) == 0) {
1018                         rv = curdev->plugin->fw_readfw(curdev, filename);
1019
1020                         if (rv != FWFLASH_SUCCESS)
1021                                 logmsg(MSG_ERROR,
1022                                     gettext("Unable to write out firmware "
1023                                     "image for %s to file %s\n"),
1024                                     curdev->access_devname, filename);
1025                         found++;
1026                 }
1027
1028         }
1029
1030         if (!found) {
1031                 logmsg(MSG_ERROR,
1032                     gettext("No device matching %s was found.\n"),
1033                     device);
1034                 rv = FWFLASH_FAILURE;
1035         }
1036
1037         return (rv);
1038 }
1039
1040 static void
1041 fwflash_usage(char *arg)
1042 {
1043
1044         (void) fprintf(stderr, "\n");
1045         if (arg != NULL) {
1046                 logmsg(MSG_ERROR,
1047                     gettext("Invalid argument (%s) supplied\n"), arg);
1048         }
1049
1050         (void) fprintf(stderr, "\n");
1051
1052         (void) fprintf(stdout, gettext("Usage:\n\t"));
1053         (void) fprintf(stdout, gettext("fwflash [-l [-c device_class "
1054             "| ALL]] | [-v] | [-h]\n\t"));
1055         (void) fprintf(stdout, gettext("fwflash [-f file1,file2,file3"
1056             ",... | -r file] [-y] -d device_path\n\n"));
1057         (void) fprintf(stdout, "\n"); /* workaround for xgettext */
1058
1059         (void) fprintf(stdout,
1060             gettext("\t-l\t\tlist flashable devices in this system\n"
1061             "\t-c device_class limit search to a specific class\n"
1062             "\t\t\teg IB for InfiniBand, ses for SCSI Enclosures\n"
1063             "\t-v\t\tprint version number of fwflash utility\n"
1064             "\t-h\t\tprint this usage message\n\n"));
1065         (void) fprintf(stdout,
1066             gettext("\t-f file1,file2,file3,...\n"
1067             "\t\t\tfirmware image file list to flash\n"
1068             "\t-r file\t\tfile to dump device firmware to\n"
1069             "\t-y\t\tanswer Yes/Y/y to prompts\n"
1070             "\t-d device_path\tpathname of device to be flashed\n\n"));
1071
1072         (void) fprintf(stdout,
1073             gettext("\tIf -d device_path is specified, then one of -f "
1074             "<files>\n"
1075             "\tor -r <file> must also be specified\n\n"));
1076
1077         (void) fprintf(stdout,
1078             gettext("\tIf multiple firmware images are required to be "
1079             "flashed\n"
1080             "\tthey must be listed together, separated by commas. The\n"
1081             "\timages will be flashed in the order specified.\n\n"));
1082
1083         (void) fprintf(stdout, "\n");
1084 }
1085
1086 static void
1087 fwflash_version(void)
1088 {
1089         (void) fprintf(stdout, gettext("\n%s: "), FWFLASH_PROG_NAME);
1090         (void) fprintf(stdout, gettext("version %s\n"),
1091             FWFLASH_VERSION);
1092 }
1093
1094 static void
1095 fwflash_intr(int sig)
1096 {
1097
1098         struct devicelist *thisdev;
1099         struct pluginlist *thisplug;
1100
1101         (void) signal(SIGINT, SIG_IGN);
1102         (void) signal(SIGTERM, SIG_IGN);
1103         (void) signal(SIGABRT, SIG_IGN);
1104
1105         if (fwflash_in_write) {
1106                 (void) fprintf(stderr,
1107                     gettext("WARNING: firmware image may be corrupted\n\t"));
1108                 (void) fprintf(stderr,
1109                     gettext("Reflash firmware before rebooting!\n"));
1110         }
1111
1112         if (sig > 0) {
1113                 (void) logmsg(MSG_ERROR, gettext("\n"));
1114                 (void) logmsg(MSG_ERROR,
1115                     gettext("fwflash exiting due to signal (%d)\n"), sig);
1116         }
1117
1118         /*
1119          * we need to close everything down properly, so
1120          * call the plugin closure routines
1121          */
1122         if (fw_devices != NULL) {
1123                 TAILQ_FOREACH(thisdev, fw_devices, nextdev) {
1124                         if (thisdev->plugin->fw_cleanup != NULL) {
1125                                 /*
1126                                  * If we've got a cleanup routine, it
1127                                  * cleans up _everything_ for thisdev
1128                                  */
1129                                 thisdev->plugin->fw_cleanup(thisdev);
1130                         } else {
1131                                 /* free the components first */
1132                                 free(thisdev->access_devname);
1133                                 free(thisdev->drvname);
1134                                 free(thisdev->classname);
1135                                 if (thisdev->ident != NULL)
1136                                         free(thisdev->ident);
1137                                 /* We don't free address[] for old plugins */
1138                                 thisdev->ident = NULL;
1139                                 thisdev->plugin = NULL;
1140                         }
1141                         /* CONSTCOND */
1142                         TAILQ_REMOVE(fw_devices, thisdev, nextdev);
1143                 }
1144         }
1145
1146         if (fw_pluginlist != NULL) {
1147                 TAILQ_FOREACH(thisplug, fw_pluginlist, nextplugin) {
1148                         free(thisplug->filename);
1149                         free(thisplug->drvname);
1150                         free(thisplug->plugin->filename);
1151                         free(thisplug->plugin->drvname);
1152                         thisplug->filename = NULL;
1153                         thisplug->drvname = NULL;
1154                         thisplug->plugin->filename = NULL;
1155                         thisplug->plugin->drvname = NULL;
1156                         thisplug->plugin->fw_readfw = NULL;
1157                         thisplug->plugin->fw_writefw = NULL;
1158                         thisplug->plugin->fw_identify = NULL;
1159                         thisplug->plugin->fw_devinfo = NULL;
1160                         thisplug->plugin->fw_cleanup = NULL;
1161                         (void) dlclose(thisplug->plugin->handle);
1162                         thisplug->plugin->handle = NULL;
1163                         free(thisplug->plugin);
1164                         thisplug->plugin = NULL;
1165                         /* CONSTCOND */
1166                         TAILQ_REMOVE(fw_pluginlist, thisplug, nextplugin);
1167                 }
1168         }
1169
1170         if (verifier != NULL) {
1171                 free(verifier->filename);
1172                 free(verifier->vendor);
1173                 free(verifier->imgfile);
1174                 free(verifier->fwimage);
1175                 verifier->filename = NULL;
1176                 verifier->vendor = NULL;
1177                 verifier->vendorvrfy = NULL;
1178                 verifier->imgfile = NULL;
1179                 verifier->fwimage = NULL;
1180                 (void) dlclose(verifier->handle);
1181                 verifier->handle = NULL;
1182                 free(verifier);
1183         }
1184         di_fini(rootnode);
1185
1186         if (sig > 0)
1187                 exit(FWFLASH_FAILURE);
1188 }
1189
1190 static void
1191 fwflash_handle_signals(void)
1192 {
1193         if (signal(SIGINT, fwflash_intr) == SIG_ERR) {
1194                 perror("signal");
1195                 exit(FWFLASH_FAILURE);
1196         }
1197
1198         if (signal(SIGTERM, fwflash_intr) == SIG_ERR) {
1199                 perror("signal");
1200                 exit(FWFLASH_FAILURE);
1201         }
1202 }
1203
1204 static int
1205 confirm_target(struct devicelist *thisdev, char *file)
1206 {
1207         int resp;
1208
1209         (void) fflush(stdin);
1210         (void) printf(gettext("About to update firmware on %s\n"),
1211             thisdev->access_devname);
1212         (void) printf(gettext("with file %s.\n"
1213             "Do you want to continue? (Y/N): "), file);
1214
1215         resp = getchar();
1216         if (resp == 'Y' || resp == 'y') {
1217                 return (FWFLASH_YES_FLAG);
1218         } else {
1219                 logmsg(MSG_INFO, "flash operation NOT confirmed.\n");
1220         }
1221
1222         (void) fflush(stdin);
1223         return (FWFLASH_FAILURE);
1224 }
1225
1226 int
1227 get_fileopts(char *options)
1228 {
1229
1230         int i;
1231         char *files;
1232
1233         if (files = strtok(options, ",")) {
1234                 /* we have more than one */
1235                 if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) {
1236                         logmsg(MSG_ERROR,
1237                             gettext("Unable to allocate space for "
1238                             "a firmware image filename\n"));
1239                         return (FWFLASH_FAILURE);
1240                 }
1241                 (void) strlcpy(filelist[0], files, strlen(files) + 1);
1242                 i = 1;
1243
1244                 logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n",
1245                     filelist[0]);
1246
1247
1248                 while (files = strtok(NULL, ",")) {
1249                         if ((filelist[i] = calloc(1, MAXPATHLEN + 1))
1250                             == NULL) {
1251                                 logmsg(MSG_ERROR,
1252                                     gettext("Unable to allocate space for "
1253                                     "a firmware image filename\n"));
1254                                 return (FWFLASH_FAILURE);
1255                         }
1256                         (void) strlcpy(filelist[i], files,
1257                             strlen(files) + 1);
1258                         logmsg(MSG_INFO, "fwflash: filelist[%d]: %s\n",
1259                             i, filelist[i]);
1260                         ++i;
1261                 }
1262         } else {
1263                 if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) {
1264                         logmsg(MSG_ERROR,
1265                             gettext("Unable to allocate space for "
1266                             "a firmware image filename\n"));
1267                         return (FWFLASH_FAILURE);
1268                 }
1269                 (void) strlcpy(filelist[0], options, strlen(files) + 1);
1270                 logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n",
1271                     filelist[0]);
1272         }
1273         return (FWFLASH_SUCCESS);
1274 }
1275
1276 /*
1277  * code reuse - cheerfully borrowed from stmsboot_util.c
1278  */
1279 void
1280 logmsg(int severity, const char *msg, ...)
1281 {
1282         va_list ap;
1283
1284         if ((severity > MSG_INFO) ||
1285             ((severity == MSG_INFO) && (fwflash_debug > 0))) {
1286                 (void) fprintf(stderr, "%s: ", FWFLASH_PROG_NAME);
1287                 va_start(ap, msg);
1288                 (void) vfprintf(stderr, msg, ap);
1289                 va_end(ap);
1290         }
1291 }