16489Sjmcp /*
26489Sjmcp  * CDDL HEADER START
36489Sjmcp  *
46489Sjmcp  * The contents of this file are subject to the terms of the
56489Sjmcp  * Common Development and Distribution License (the "License").
66489Sjmcp  * You may not use this file except in compliance with the License.
76489Sjmcp  *
86489Sjmcp  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
96489Sjmcp  * or http://www.opensolaris.org/os/licensing.
106489Sjmcp  * See the License for the specific language governing permissions
116489Sjmcp  * and limitations under the License.
126489Sjmcp  *
136489Sjmcp  * When distributing Covered Code, include this CDDL HEADER in each
146489Sjmcp  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
156489Sjmcp  * If applicable, add the following below this CDDL HEADER, with the
166489Sjmcp  * fields enclosed by brackets "[]" replaced with your own identifying
176489Sjmcp  * information: Portions Copyright [yyyy] [name of copyright owner]
186489Sjmcp  *
196489Sjmcp  * CDDL HEADER END
206489Sjmcp  */
216489Sjmcp /*
226489Sjmcp  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
236489Sjmcp  * Use is subject to license terms.
246489Sjmcp  */
256489Sjmcp 
266489Sjmcp /*
276489Sjmcp  * fwflash.c
286489Sjmcp  */
296489Sjmcp #include <stdio.h>
306489Sjmcp #include <stdlib.h>
316489Sjmcp #include <unistd.h>
326489Sjmcp #include <strings.h>
336489Sjmcp #include <errno.h>
346489Sjmcp #include <sys/queue.h>
356489Sjmcp #include <signal.h>
366489Sjmcp #include <locale.h>
376489Sjmcp #include <sys/stat.h>
386489Sjmcp #include <sys/types.h>
396489Sjmcp #include <sys/param.h>
406489Sjmcp #include <fcntl.h>
416489Sjmcp #include <dlfcn.h>
426489Sjmcp #include <dirent.h>
436489Sjmcp #include <sys/varargs.h>
446489Sjmcp #include <libintl.h> /* for gettext(3c) */
456489Sjmcp #include <libdevinfo.h>
466489Sjmcp #include <fwflash/fwflash.h>
476846Sjmcp #include <sys/modctl.h> /* for MAXMODCONFNAME */
486489Sjmcp 
496489Sjmcp 
506489Sjmcp #if !defined(lint)
516489Sjmcp /* embedded software license agreement */
526489Sjmcp static char *sla [] = { "Copyright 2007 Sun Microsystems, Inc., 4150 Network "
536489Sjmcp "Circle, Santa Clara, California 95054, U.S.A. All rights reserved. U.S. "
546489Sjmcp "Government Rights - Commercial software.  Government users are subject to the "
556489Sjmcp "Sun Microsystems, Inc. standard license agreement and applicable provisions "
566489Sjmcp "of the FAR and its supplements.  Use is subject to license terms.  Parts of "
576489Sjmcp "the product may be derived from Berkeley BSD systems, licensed from the "
586489Sjmcp "University of California. UNIX is a registered trademark in the U.S. and in "
596489Sjmcp "other countries, exclusively licensed through X/Open Company, Ltd.Sun, Sun "
606489Sjmcp "Microsystems, the Sun logo and Solaris are trademarks or registered "
616489Sjmcp "trademarks of Sun Microsystems, Inc. in the U.S. and other countries. This "
626489Sjmcp "product is covered and controlled by U.S. Export Control laws and may be "
636489Sjmcp "subject to the export or import laws in other countries.  Nuclear, missile, "
646489Sjmcp "chemical biological weapons or nuclear maritime end uses or end users, "
656489Sjmcp "whether direct or indirect, are strictly prohibited.  Export or reexport "
666489Sjmcp "to countries subject to U.S. embargo or to entities identified on U.S. export "
676489Sjmcp "exclusion lists, including, but not limited to, the denied persons and "
686489Sjmcp "specially designated nationals lists is strictly prohibited." };
696489Sjmcp #endif	/* lint */
706489Sjmcp 
716489Sjmcp /* global arg list */
726489Sjmcp int	fwflash_arg_list = 0;
736489Sjmcp char	*filelist[10];
746489Sjmcp 
756489Sjmcp /* are we writing to flash? */
766489Sjmcp static int fwflash_in_write = 0;
776489Sjmcp 
786489Sjmcp /*
796489Sjmcp  * If we *must* track the version string for fwflash, then
806489Sjmcp  * we should do so in this common file rather than the header
816489Sjmcp  * file since it will then be in sync with what the customer
82*7317SJames.McPherson@Sun.COM  * sees. We should deprecate the "-v" option since it is not
83*7317SJames.McPherson@Sun.COM  * actually of any use - it doesn't line up with Mercurial's
84*7317SJames.McPherson@Sun.COM  * concept of the changeset.
856489Sjmcp  */
86*7317SJames.McPherson@Sun.COM #define	FWFLASH_VERSION		"v1.6"
876489Sjmcp #define	FWFLASH_PROG_NAME	"fwflash"
886489Sjmcp 
896489Sjmcp static int get_fileopts(char *options);
906489Sjmcp static int flash_device_list();
916489Sjmcp static int flash_load_plugins();
926489Sjmcp static int fwflash_update(char *device, char *filename, int flags);
936489Sjmcp static int fwflash_read_file(char *device, char *filename);
946489Sjmcp static int fwflash_list_fw(char *class);
956489Sjmcp static int fwflash_load_verifier(char *drv, char *vendorid, char *fwimg);
966489Sjmcp static void fwflash_intr(int sig);
976489Sjmcp static void fwflash_handle_signals(void);
98*7317SJames.McPherson@Sun.COM static void fwflash_usage(char *arg);
996489Sjmcp static void fwflash_version(void);
1006489Sjmcp static int confirm_target(struct devicelist *thisdev, char *file);
1016489Sjmcp 
1026489Sjmcp /*
1036489Sjmcp  * FWFlash main code
1046489Sjmcp  */
1056489Sjmcp int
1066489Sjmcp main(int argc, char **argv) {
1076489Sjmcp 	int		rv = FWFLASH_SUCCESS;
1086489Sjmcp 	int		i;
1096489Sjmcp 	char		ch;
1106489Sjmcp 	char		*read_file;
1116489Sjmcp 	extern char	*optarg;
1126489Sjmcp 	char		*devclass = NULL;
1136489Sjmcp 	char		*devpath = NULL;
1146489Sjmcp 
1156489Sjmcp 	/* local variables from env */
1166489Sjmcp 	(void) setlocale(LC_ALL, "");
1176489Sjmcp 
1186489Sjmcp #if !defined(TEXT_DOMAIN)		/* Should be defined by cc -D */
1196489Sjmcp #define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it isn't. */
1206489Sjmcp #endif
1216489Sjmcp 
1226489Sjmcp 	(void) textdomain(TEXT_DOMAIN);
1236489Sjmcp 
1246489Sjmcp 	read_file = NULL;
1256489Sjmcp 
1266489Sjmcp 	if (argc < 2) {
1276489Sjmcp 		/* no args supplied */
1286489Sjmcp 		fwflash_usage(NULL);
1296489Sjmcp 		return (FWFLASH_FAILURE);
1306489Sjmcp 	}
1316489Sjmcp 
1326846Sjmcp 	while ((ch = getopt(argc, argv, "hvylc:f:r:Qd:M")) != EOF) {
1336489Sjmcp 		switch (ch) {
1346489Sjmcp 		case 'h':
1356489Sjmcp 			fwflash_arg_list |= FWFLASH_HELP_FLAG;
1366489Sjmcp 			break;
1376489Sjmcp 		case 'v':
1386489Sjmcp 			fwflash_arg_list |= FWFLASH_VER_FLAG;
1396489Sjmcp 			break;
1406489Sjmcp 		case 'y':
1416489Sjmcp 			fwflash_arg_list |= FWFLASH_YES_FLAG;
1426489Sjmcp 			break;
1436489Sjmcp 		case 'l':
1446489Sjmcp 			fwflash_arg_list |= FWFLASH_LIST_FLAG;
1456489Sjmcp 			break;
1466489Sjmcp 		case 'c':
1476489Sjmcp 			fwflash_arg_list |= FWFLASH_CLASS_FLAG;
1486489Sjmcp 			/* we validate later */
1496489Sjmcp 			devclass = strdup(optarg);
1506489Sjmcp 			break;
1516489Sjmcp 		case 'd':
1526489Sjmcp 			fwflash_arg_list |= FWFLASH_DEVICE_FLAG;
1536489Sjmcp 			devpath = strdup(optarg);
1546489Sjmcp 			break;
1556489Sjmcp 		case 'f':
1566489Sjmcp 			fwflash_arg_list |= FWFLASH_FW_FLAG;
1576489Sjmcp 			if ((rv = get_fileopts(optarg)) != FWFLASH_SUCCESS) {
158*7317SJames.McPherson@Sun.COM 				fwflash_usage(NULL);
1596489Sjmcp 				return (FWFLASH_FAILURE);
1606489Sjmcp 			}
1616489Sjmcp 			break;
1626489Sjmcp 		case 'r':
1636489Sjmcp 			fwflash_arg_list |= FWFLASH_READ_FLAG;
1646489Sjmcp 			read_file = strdup(optarg);
1656489Sjmcp 			break;
1666489Sjmcp 		case 'Q':
1676489Sjmcp 			/* NOT in the manpage */
1686489Sjmcp 			fwflash_debug = 1;
1696489Sjmcp 			break;
1706846Sjmcp 		case 'M':
1716846Sjmcp 			/* NOT in the manpage */
1726846Sjmcp #if (MANUFACTURING_MODE > 0)
1736846Sjmcp 			manufacturing_mode = 1;
1746846Sjmcp 			logmsg(MSG_WARN, "Enabling Manufacturing Mode "
1756846Sjmcp 			    "operations. This can be destructive!\n");
1766846Sjmcp 			break;
1776846Sjmcp #endif
1786846Sjmcp 		/* illegal options */
1796489Sjmcp 		default:
1806489Sjmcp 			fwflash_usage(optarg);
1816489Sjmcp 			return (FWFLASH_FAILURE);
1826489Sjmcp 		}
1836489Sjmcp 	}
1846489Sjmcp 
1856489Sjmcp 	/* Do Help */
1866489Sjmcp 	if ((fwflash_arg_list & FWFLASH_HELP_FLAG) ||
1876489Sjmcp 	    ((fwflash_arg_list & FWFLASH_DEVICE_FLAG) &&
1886489Sjmcp 		!((fwflash_arg_list & FWFLASH_FW_FLAG) ||
1896489Sjmcp 		    (fwflash_arg_list & FWFLASH_READ_FLAG)))) {
190*7317SJames.McPherson@Sun.COM 		fwflash_usage(NULL);
1916489Sjmcp 		return (FWFLASH_SUCCESS);
1926489Sjmcp 	}
1936489Sjmcp 
1946489Sjmcp 	/* Do Version */
1956489Sjmcp 	if (fwflash_arg_list == FWFLASH_VER_FLAG) {
1966489Sjmcp 		fwflash_version();
1976489Sjmcp 		return (FWFLASH_SUCCESS);
1986489Sjmcp 	}
1996489Sjmcp 
2006489Sjmcp 	/* generate global list of devices */
2016489Sjmcp 	if ((rv = flash_load_plugins()) != FWFLASH_SUCCESS) {
2026489Sjmcp 		logmsg(MSG_ERROR,
2036489Sjmcp 		    gettext("Unable to load fwflash plugins\n"));
2046489Sjmcp 		fwflash_intr(0);
2056489Sjmcp 		return (rv);
2066489Sjmcp 	}
2076489Sjmcp 
2086489Sjmcp 	if ((rv = flash_device_list()) != FWFLASH_SUCCESS) {
2096489Sjmcp 		logmsg(MSG_ERROR,
2106489Sjmcp 		    gettext("No flashable devices in this system\n"));
2116489Sjmcp 		fwflash_intr(0);
2126489Sjmcp 		return (rv);
2136489Sjmcp 	}
2146489Sjmcp 
2156489Sjmcp 	/* Do list */
2166489Sjmcp 	if (fwflash_arg_list == (FWFLASH_LIST_FLAG) ||
2176489Sjmcp 	    fwflash_arg_list == (FWFLASH_LIST_FLAG | FWFLASH_CLASS_FLAG)) {
2186489Sjmcp 		rv = fwflash_list_fw(devclass);
2196489Sjmcp 		fwflash_intr(0);
2206489Sjmcp 		return (rv);
2216489Sjmcp 	}
2226489Sjmcp 
2236489Sjmcp 	fwflash_handle_signals();
2246489Sjmcp 
2256489Sjmcp 	/* Do flash update (write) */
2266489Sjmcp 	if ((fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG)) ||
2276489Sjmcp 	    (fwflash_arg_list == (FWFLASH_FW_FLAG | FWFLASH_DEVICE_FLAG |
2286489Sjmcp 		FWFLASH_YES_FLAG))) {
2296489Sjmcp 		/* the update function handles the real arg parsing */
2306489Sjmcp 		i = 0;
2316489Sjmcp 		while (filelist[i] != NULL) {
2326489Sjmcp 			if ((rv = fwflash_update(devpath, filelist[i],
2336489Sjmcp 			    fwflash_arg_list)) == FWFLASH_SUCCESS) {
2346489Sjmcp 				/* failed ops have already been noted */
2356489Sjmcp 				logmsg(MSG_ERROR,
2366489Sjmcp 				    gettext("New firmware will be activated "
2376489Sjmcp 					"after you reboot\n\n"));
2386489Sjmcp 			}
2396489Sjmcp 			++i;
2406489Sjmcp 		}
2416489Sjmcp 
2426489Sjmcp 		fwflash_intr(0);
2436489Sjmcp 		return (rv);
2446489Sjmcp 	}
2456489Sjmcp 
2466489Sjmcp 	/* Do flash read */
2476489Sjmcp 	if ((fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG)) ||
2486489Sjmcp 	    (fwflash_arg_list == (FWFLASH_READ_FLAG | FWFLASH_DEVICE_FLAG |
2496489Sjmcp 		FWFLASH_YES_FLAG))) {
2506489Sjmcp 		rv = fwflash_read_file(devpath, read_file);
2516489Sjmcp 		fwflash_intr(0);
2526489Sjmcp 		return (rv);
2536489Sjmcp 	}
2546489Sjmcp 
2556489Sjmcp 	fwflash_usage(NULL);
2566489Sjmcp 
2576489Sjmcp 	return (FWFLASH_FAILURE);
2586489Sjmcp }
2596489Sjmcp 
2606489Sjmcp 
2616489Sjmcp static int
2626489Sjmcp flash_load_plugins() {
2636489Sjmcp 
2646489Sjmcp 	int rval = FWFLASH_SUCCESS;
2656489Sjmcp 	DIR *dirp;
2666489Sjmcp 	struct dirent *plugdir;
2676489Sjmcp 	char *plugname;
2686489Sjmcp 	struct fw_plugin *tmpplug;
2696489Sjmcp 	struct pluginlist *tmpelem;
2706489Sjmcp 	void *sym;
2716489Sjmcp 	char *fwplugdirpath, *tempdirpath;
2726489Sjmcp 
2736489Sjmcp 
2746489Sjmcp #define	CLOSEFREE()	{			\
2756489Sjmcp 	(void) dlclose(tmpplug->handle);	\
2766489Sjmcp 	free(tmpplug); }
2776489Sjmcp 
2786489Sjmcp 	/*
2796489Sjmcp 	 * Procedure:
2806489Sjmcp 	 *
2816489Sjmcp 	 * cd /usr/lib/fwflash/identify
2826489Sjmcp 	 * open each .so file found therein
2836489Sjmcp 	 * dlopen(.sofile)
2846489Sjmcp 	 * if it's one of our plugins, add it to fw_pluginlist;
2856489Sjmcp 	 *
2866489Sjmcp 	 * functions we need here include dlopen and dlsym.
2876489Sjmcp 	 *
2886489Sjmcp 	 * If we get to the end and fw_pluginlist struct is empty,
2896489Sjmcp 	 * return FWFLASH_FAILURE so we return to the shell.
2906489Sjmcp 	 */
2916489Sjmcp 
2926489Sjmcp 	if ((fwplugdirpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
2936489Sjmcp 		logmsg(MSG_ERROR,
2946489Sjmcp 		    gettext("Unable to malloc %d bytes while "
2956489Sjmcp 		    "trying to load plugins: %s\n"),
2966489Sjmcp 		    MAXPATHLEN + 1, strerror(errno));
2976489Sjmcp 		return (FWFLASH_FAILURE);
2986489Sjmcp 	}
2996489Sjmcp 
3006489Sjmcp 	tempdirpath = getenv("FWPLUGINDIR");
3016489Sjmcp 
3026489Sjmcp 	if ((fwflash_debug > 0) && (tempdirpath != NULL)) {
3036489Sjmcp 		(void) strlcpy(fwplugdirpath, tempdirpath,
3046489Sjmcp 		    strlen(tempdirpath) + 1);
3056489Sjmcp 	} else {
3066489Sjmcp 		(void) strlcpy(fwplugdirpath, FWPLUGINDIR,
3076489Sjmcp 		    strlen(FWPLUGINDIR) + 1);
3086489Sjmcp 	}
3096489Sjmcp 
3106489Sjmcp 	if ((dirp = opendir(fwplugdirpath)) == NULL) {
3116489Sjmcp 		logmsg(MSG_ERROR,
3126846Sjmcp 		    gettext("Unable to open %s\n"),
3136489Sjmcp 		    fwplugdirpath);
3146489Sjmcp 		return (errno);
3156489Sjmcp 	}
3166489Sjmcp 
3176489Sjmcp 	if ((plugdir = calloc(1, sizeof (struct dirent) + MAXPATHLEN + 1))
3186489Sjmcp 	    == NULL) {
3196489Sjmcp 		logmsg(MSG_ERROR,
3206489Sjmcp 		    gettext("Unable to malloc %d bytes while "
3216489Sjmcp 		    "trying to load plugins: %s\n"),
3226489Sjmcp 		    MAXPATHLEN + 1 + sizeof (struct dirent),
3236489Sjmcp 		    strerror(errno));
3246489Sjmcp 		return (FWFLASH_FAILURE);
3256489Sjmcp 	}
3266489Sjmcp 
3276489Sjmcp 	if ((fw_pluginlist = calloc(1, sizeof (struct fw_plugin)))
3286489Sjmcp 	    == NULL) {
3296489Sjmcp 		logmsg(MSG_ERROR,
3306489Sjmcp 		    gettext("Unable to malloc %d bytes while "
3316489Sjmcp 			"trying to load plugins: %s\n"),
3326489Sjmcp 		    sizeof (struct fw_plugin) + 1, strerror(errno));
3336489Sjmcp 		return (FWFLASH_FAILURE);
3346489Sjmcp 	}
3356489Sjmcp 
3366489Sjmcp 	TAILQ_INIT(fw_pluginlist);
3376489Sjmcp 
3386489Sjmcp 	while ((readdir_r(dirp, plugdir, &plugdir) == 0) && (plugdir != NULL)) {
3396489Sjmcp 
3406489Sjmcp 		errno = 0; /* remove chance of false results */
3416489Sjmcp 
3426489Sjmcp 		if ((plugdir->d_name[0] == '.') ||
3436489Sjmcp 		    (strstr(plugdir->d_name, ".so") == NULL)) {
3446489Sjmcp 			continue;
3456489Sjmcp 		}
3466489Sjmcp 
3476489Sjmcp 		if ((plugname = calloc(1, MAXPATHLEN + 1)) == NULL) {
3486489Sjmcp 			logmsg(MSG_ERROR,
3496489Sjmcp 			    gettext("Unable to malloc %d bytes while "
3506489Sjmcp 				"trying to load plugins: %s\n"),
3516489Sjmcp 			    MAXPATHLEN + 1, strerror(errno));
3526489Sjmcp 			return (FWFLASH_FAILURE);
3536489Sjmcp 		}
3546489Sjmcp 
3556489Sjmcp 		(void) snprintf(plugname, MAXPATHLEN, "%s/%s",
3566489Sjmcp 		    fwplugdirpath, plugdir->d_name);
3576489Sjmcp 
3586489Sjmcp 		/* start allocating storage */
3596489Sjmcp 		if ((tmpelem = calloc(1, sizeof (struct pluginlist)))
3606489Sjmcp 		    == NULL) {
3616489Sjmcp 			logmsg(MSG_ERROR,
3626489Sjmcp 			    gettext("Unable to malloc %d bytes while "
3636489Sjmcp 				"trying to load plugins: %s\n"),
3646489Sjmcp 			    sizeof (struct pluginlist), strerror(errno));
3656489Sjmcp 			return (FWFLASH_FAILURE);
3666489Sjmcp 		}
3676489Sjmcp 
3686489Sjmcp 		if ((tmpplug = calloc(1, sizeof (struct fw_plugin)))
3696489Sjmcp 		    == NULL) {
3706489Sjmcp 			logmsg(MSG_ERROR,
3716489Sjmcp 			    gettext("Unable to malloc %d bytes while "
3726489Sjmcp 			    "trying to load plugins: %s\n"),
3736489Sjmcp 			    sizeof (struct fw_plugin), strerror(errno));
3746489Sjmcp 			return (FWFLASH_FAILURE);
3756489Sjmcp 		}
3766489Sjmcp 
3776489Sjmcp 		/* load 'er up! */
3786489Sjmcp 		tmpplug->handle = dlopen(plugname, RTLD_NOW);
3796489Sjmcp 		if (tmpplug->handle == NULL) {
3806489Sjmcp 			free(tmpplug);
3816489Sjmcp 			continue; /* assume there are other plugins */
3826489Sjmcp 		}
3836489Sjmcp 
3846489Sjmcp 		if ((tmpplug->filename = calloc(1, strlen(plugname) + 1))
3856489Sjmcp 		    == NULL) {
3866489Sjmcp 			logmsg(MSG_ERROR,
3876489Sjmcp 			    gettext("Unable to allocate %d bytes for plugin "
3886489Sjmcp 				"filename %s:%s\n"),
3896489Sjmcp 			    strlen(plugname) + 1, plugname,
3906489Sjmcp 			    strerror(errno));
3916489Sjmcp 			return (rval);
3926489Sjmcp 		}
3936489Sjmcp 
3946489Sjmcp 		(void) strlcpy(tmpplug->filename, plugname,
3956489Sjmcp 		    strlen(plugname) + 1);
3966489Sjmcp 
3976489Sjmcp 		/* now sanity check the file */
3986489Sjmcp 		if ((sym = dlsym(tmpplug->handle, "drivername"))
3996489Sjmcp 		    != NULL) {
4006489Sjmcp 			/* max length of drivername */
4016846Sjmcp 			tmpplug->drvname = calloc(1, MAXMODCONFNAME);
4026846Sjmcp 
4036846Sjmcp 			/* are we doing double-time? */
4046846Sjmcp 			if (strncmp((char *)sym, plugdir->d_name,
4056846Sjmcp 			    MAXMODCONFNAME) != 0) {
4066846Sjmcp 				char *tempnm = calloc(1, MAXMODCONFNAME);
4076846Sjmcp 
4086846Sjmcp 				memcpy(tempnm, plugdir->d_name, MAXMODCONFNAME);
4096846Sjmcp 				(void) strlcpy(tmpplug->drvname,
4106846Sjmcp 				    strtok(tempnm, "."),
4116846Sjmcp 				    strlen(plugdir->d_name) + 1);
4126846Sjmcp 				free(tempnm);
4136846Sjmcp 			} else {
4146846Sjmcp 				(void) strlcpy(tmpplug->drvname,
4156846Sjmcp 				    (char *)sym, strlen(sym) + 1);
4166846Sjmcp 			}
4176489Sjmcp 		} else {
4186489Sjmcp 			CLOSEFREE();
4196489Sjmcp 			continue;
4206489Sjmcp 		}
4216489Sjmcp 		if ((sym = dlsym(tmpplug->handle, "fw_readfw"))
4226489Sjmcp 		    != NULL) {
4236489Sjmcp 			tmpplug->fw_readfw = (int (*)())sym;
4246489Sjmcp 		} else {
4256489Sjmcp 			CLOSEFREE();
4266489Sjmcp 			continue;
4276489Sjmcp 		}
4286489Sjmcp 		if ((sym = dlsym(tmpplug->handle, "fw_writefw"))
4296489Sjmcp 		    != NULL) {
4306489Sjmcp 			tmpplug->fw_writefw = (int (*)())sym;
4316489Sjmcp 		} else {
4326489Sjmcp 			CLOSEFREE();
4336489Sjmcp 			continue;
4346489Sjmcp 		}
4356489Sjmcp 
4366489Sjmcp 		if ((sym = dlsym(tmpplug->handle, "fw_identify"))
4376489Sjmcp 		    != NULL) {
4386489Sjmcp 			tmpplug->fw_identify =
4396489Sjmcp 			    (int (*)(int))sym;
4406489Sjmcp 		} else {
4416489Sjmcp 			CLOSEFREE();
4426489Sjmcp 			continue;
4436489Sjmcp 		}
4446489Sjmcp 		if ((sym = dlsym(tmpplug->handle, "fw_devinfo"))
4456489Sjmcp 		    != NULL) {
4466489Sjmcp 			tmpplug->fw_devinfo =
4476489Sjmcp 			    (int (*)(struct devicelist *))sym;
4486489Sjmcp 		} else {
4496489Sjmcp 			CLOSEFREE();
4506489Sjmcp 			continue;
4516489Sjmcp 		}
4526489Sjmcp 
4536846Sjmcp 		if ((tmpelem->drvname = calloc(1, MAXMODCONFNAME))
4546489Sjmcp 		    == NULL) {
4556489Sjmcp 			logmsg(MSG_ERROR,
4566846Sjmcp 			    gettext("Unable to allocate space for a"
4576489Sjmcp 				"drivername %s\n"),
4586489Sjmcp 			    tmpplug->drvname);
4596489Sjmcp 			return (FWFLASH_FAILURE);
4606489Sjmcp 		}
4616489Sjmcp 
4626489Sjmcp 		(void) strlcpy(tmpelem->drvname, tmpplug->drvname,
4636489Sjmcp 		    strlen(tmpplug->drvname) + 1);
4646489Sjmcp 
4656489Sjmcp 		if ((tmpelem->filename = calloc(1,
4666489Sjmcp 		    strlen(tmpplug->filename) + 1)) == NULL) {
4676489Sjmcp 			logmsg(MSG_ERROR,
4686489Sjmcp 			    gettext("Unable to allocate %d bytes for "
4696489Sjmcp 				"filename %s\n"),
4706489Sjmcp 			    strlen(tmpplug->filename) + 1,
4716846Sjmcp 			    tmpplug->filename);
4726489Sjmcp 			return (FWFLASH_FAILURE);
4736489Sjmcp 		}
4746489Sjmcp 
4756489Sjmcp 		(void) strlcpy(tmpelem->filename, plugname,
4766489Sjmcp 		    strlen(plugname) + 1);
4776489Sjmcp 		tmpelem->plugin = tmpplug;
4786489Sjmcp 
4796489Sjmcp 		/* CONSTCOND */
4806489Sjmcp 		TAILQ_INSERT_TAIL(fw_pluginlist, tmpelem, nextplugin);
4816489Sjmcp 	}
4826489Sjmcp 
4836489Sjmcp 	if ((plugdir == NULL) && TAILQ_EMPTY(fw_pluginlist)) {
4846489Sjmcp 		return (FWFLASH_FAILURE);
4856489Sjmcp 	}
4866489Sjmcp 
4876489Sjmcp 	if (errno != 0) {
4886489Sjmcp 		logmsg(MSG_ERROR,
4896489Sjmcp 		    gettext("Error reading directory entry in %s\n"),
4906489Sjmcp 		    fwplugdirpath);
4916489Sjmcp 		(void) closedir(dirp);
4926489Sjmcp 		rval = errno;
4936489Sjmcp 	}
4946489Sjmcp 
4956489Sjmcp 	(void) free(fwplugdirpath);
4966489Sjmcp 	(void) free(plugdir);
4976489Sjmcp 	(void) closedir(dirp);
4986489Sjmcp 	return (rval);
4996489Sjmcp }
5006489Sjmcp 
5016489Sjmcp /*
5026489Sjmcp  * fwflash_load_verifier dlload()s the appropriate firmware image
5036489Sjmcp  * verification plugin, and attaches the designated fwimg's fd to
5046489Sjmcp  * the vrfyplugin structure so we only have to load the image in
5056489Sjmcp  * one place.
5066489Sjmcp  */
5076489Sjmcp int
5086489Sjmcp fwflash_load_verifier(char *drv, char *vendorid, char *fwimg) {
5096489Sjmcp 
5106489Sjmcp 	int rv = FWFLASH_FAILURE;
5116489Sjmcp 	int imgfd;
5126489Sjmcp 	char *fwvrfydirpath, *tempdirpath, *filename;
5136489Sjmcp 	char *clean; /* for the space-removed vid */
5146489Sjmcp 	struct stat fwstat;
5156489Sjmcp 	struct vrfyplugin *vrfy;
5166489Sjmcp 	void *vrfysym;
5176489Sjmcp 
5186489Sjmcp 	/*
5196489Sjmcp 	 * To make flashing multiple firmware images somewhat more
5206489Sjmcp 	 * efficient, we start this function by checking whether a
5216489Sjmcp 	 * verifier for this device has already been loaded. If it
5226489Sjmcp 	 * has been loaded, we replace the imgfile information, and
5236489Sjmcp 	 * then continue as if we were loading for the first time.
5246489Sjmcp 	 */
5256489Sjmcp 
5266489Sjmcp 	if (verifier != NULL) {
5276489Sjmcp 		verifier->imgsize = 0;
5286489Sjmcp 		verifier->flashbuf = 0; /* set by the verifier function */
5296489Sjmcp 
5306489Sjmcp 		if (verifier->imgfile != NULL)
5316489Sjmcp 			(void) free(verifier->imgfile);
5326489Sjmcp 
5336489Sjmcp 		if (verifier->fwimage != NULL)
5346489Sjmcp 			(void) free(verifier->fwimage);
5356489Sjmcp 	} else {
5366489Sjmcp 		if ((fwvrfydirpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
5376489Sjmcp 			logmsg(MSG_ERROR,
5386489Sjmcp 			    gettext("Unable to allocate space for a firmware "
5396489Sjmcp 				"verifier file(1)"));
5406489Sjmcp 			return (rv);
5416489Sjmcp 		}
5426489Sjmcp 
5436489Sjmcp 		if ((filename = calloc(1, MAXPATHLEN + 1)) == NULL) {
5446489Sjmcp 			logmsg(MSG_ERROR,
5456489Sjmcp 			    gettext("Unable to allocate space "
5466489Sjmcp 			    "for a firmware verifier file(2)"));
5476489Sjmcp 			return (rv);
5486489Sjmcp 		}
5496489Sjmcp 
5506489Sjmcp 	/*
5516489Sjmcp 	 * Since SCSI devices can have a vendor id of up to 8 left-aligned
5526489Sjmcp 	 * and _space-padded_ characters, we first need to strip off any
5536489Sjmcp 	 * space characters before we try to make a filename out of it
5546489Sjmcp 	 */
5556489Sjmcp 		clean = strtok(vendorid, " ");
5566489Sjmcp 		if (clean == NULL) {
5576489Sjmcp 			/* invalid vendorid, something's really wrong */
5586489Sjmcp 			logmsg(MSG_ERROR,
5596489Sjmcp 			    gettext("Invalid vendorid (null) specified for "
5606489Sjmcp 				"device\n"));
5616489Sjmcp 			return (rv);
5626489Sjmcp 		}
5636489Sjmcp 
5646489Sjmcp 		tempdirpath = getenv("FWVERIFYPLUGINDIR");
5656489Sjmcp 
5666489Sjmcp 		if ((fwflash_debug > 0) && (tempdirpath != NULL)) {
5676489Sjmcp 			(void) strlcpy(fwvrfydirpath, tempdirpath,
5686489Sjmcp 			    strlen(tempdirpath) + 1);
5696489Sjmcp 		} else {
5706489Sjmcp 			(void) strlcpy(fwvrfydirpath, FWVERIFYPLUGINDIR,
5716489Sjmcp 			    strlen(FWVERIFYPLUGINDIR) + 1);
5726489Sjmcp 		}
5736489Sjmcp 
5746489Sjmcp 		if ((vrfy = calloc(1, sizeof (struct vrfyplugin))) == NULL) {
5756489Sjmcp 			logmsg(MSG_ERROR,
5766489Sjmcp 			    gettext("Unable to allocate space "
5776489Sjmcp 			    "for a firmware verifier structure"));
5786489Sjmcp 			free(filename);
5796489Sjmcp 			free(fwvrfydirpath);
5806489Sjmcp 			return (FWFLASH_FAILURE);
5816489Sjmcp 		}
5826489Sjmcp 
5836489Sjmcp 		errno = 0; /* false positive removal */
5846489Sjmcp 
5856489Sjmcp 		(void) snprintf(filename, strlen(fwvrfydirpath) +
5866489Sjmcp 		    strlen(drv) + 7 + strlen(clean), "%s/%s-%s.so\0",
5876489Sjmcp 		    fwvrfydirpath, drv, clean);
5886489Sjmcp 
5896489Sjmcp 		if ((vrfy->filename = calloc(1, strlen(filename) + 1))
5906489Sjmcp 		    == NULL) {
5916489Sjmcp 			logmsg(MSG_ERROR,
5926489Sjmcp 			    gettext("Unable to allocate space to store "
5936489Sjmcp 				"a verifier filename\n"));
5946489Sjmcp 			free(filename);
5956489Sjmcp 			free(fwvrfydirpath);
5966489Sjmcp 			free(vrfy->handle);
5976489Sjmcp 			return (FWFLASH_FAILURE);
5986489Sjmcp 		}
5996489Sjmcp 
6006489Sjmcp 		(void) strlcpy(vrfy->filename, filename, strlen(filename) + 1);
6016489Sjmcp 
6026489Sjmcp 		if ((vrfy->handle = dlopen(filename, RTLD_NOW)) == NULL) {
6036489Sjmcp 			logmsg(MSG_ERROR, gettext(dlerror()));
6046489Sjmcp 			logmsg(MSG_ERROR,
6056489Sjmcp 			    gettext("Unable to open verification plugin "
6066846Sjmcp 				"%s. Unable to verify firmware image. "
6076489Sjmcp 				"Aborting.\n"),
6086489Sjmcp 			    filename);
6096489Sjmcp 			free(filename);
6106489Sjmcp 			free(fwvrfydirpath);
6116489Sjmcp 			return (FWFLASH_FAILURE);
6126489Sjmcp 		}
6136489Sjmcp 
6146489Sjmcp 		if ((vrfysym = dlsym(vrfy->handle, "vendorvrfy")) == NULL) {
6156489Sjmcp 			logmsg(MSG_ERROR,
6166489Sjmcp 			    gettext("%s is an invalid firmware verification "
6176489Sjmcp 				"plugin."), filename);
6186489Sjmcp 			(void) dlclose(vrfy->handle);
6196489Sjmcp 			free(filename);
6206489Sjmcp 			free(fwvrfydirpath);
6216489Sjmcp 			free(vrfy);
6226489Sjmcp 			return (FWFLASH_FAILURE);
6236489Sjmcp 		} else {
6246489Sjmcp 			vrfy->vendorvrfy =
6256489Sjmcp 			    (int (*)(struct devicelist *))vrfysym;
6266489Sjmcp 		}
6276489Sjmcp 
6286489Sjmcp 		vrfysym = dlsym(vrfy->handle, "vendor");
6296489Sjmcp 
6306489Sjmcp 		if (vrfysym == NULL) {
6316489Sjmcp 			logmsg(MSG_ERROR,
6326489Sjmcp 			    gettext("Invalid vendor (null) in verification "
6336489Sjmcp 				"plugin %s\n"), filename);
6346489Sjmcp 			(void) dlclose(vrfy->handle);
6356489Sjmcp 			free(vrfy);
6366489Sjmcp 			return (NULL);
6376489Sjmcp 		} else {
6386489Sjmcp 			if (strncmp(vendorid, (char *)vrfysym,
6396489Sjmcp 			    strlen(vendorid)) != 0) {
6406489Sjmcp 				logmsg(MSG_INFO,
6416489Sjmcp 				    "Using a sym-linked (%s -> %s) "
6426489Sjmcp 				    "verification plugin",
6436489Sjmcp 				    vendorid, vrfysym);
6446489Sjmcp 				vrfy->vendor = calloc(1, strlen(vendorid) + 1);
6456489Sjmcp 			} else {
6466489Sjmcp 				vrfy->vendor = calloc(1, strlen(vrfysym) + 1);
6476489Sjmcp 			}
6486489Sjmcp 			(void) strlcpy(vrfy->vendor, (char *)vrfysym,
6496489Sjmcp 			    strlen(vendorid) + 1);
6506489Sjmcp 		}
6516489Sjmcp 
6526489Sjmcp 		verifier = vrfy; /* a convenience variable */
6536489Sjmcp 	}
6546489Sjmcp 
6556489Sjmcp 
6566489Sjmcp 	/*
6576489Sjmcp 	 * We don't do any verification that the fw image file is in
6586489Sjmcp 	 * an approved location, but it's easy enough to modify this
6596489Sjmcp 	 * function to do so. The verification plugin should provide
6606489Sjmcp 	 * sufficient protection.
6616489Sjmcp 	 */
6626489Sjmcp 
6636489Sjmcp 	if ((imgfd = open(fwimg, O_RDONLY)) < 0) {
6646489Sjmcp 		logmsg(MSG_ERROR,
6656489Sjmcp 		    gettext("Unable to open designated firmware "
6666489Sjmcp 			"image file %s: %s\n"),
6676489Sjmcp 		    (fwimg != NULL) ? fwimg : "(null)",
6686489Sjmcp 		    strerror(errno));
6696489Sjmcp 		rv = FWFLASH_FAILURE;
6706489Sjmcp 		goto cleanup;
6716489Sjmcp 	}
6726489Sjmcp 
6736489Sjmcp 	if (stat(fwimg, &fwstat) == -1) {
6746489Sjmcp 		logmsg(MSG_ERROR,
6756489Sjmcp 		    gettext("Unable to stat() firmware image file "
6766489Sjmcp 			"%s: %s\n"),
6776489Sjmcp 		    fwimg, strerror(errno));
6786489Sjmcp 		rv = FWFLASH_FAILURE;
6796489Sjmcp 		goto cleanup;
6806489Sjmcp 	} else {
6816489Sjmcp 		verifier->imgsize = fwstat.st_size;
6826489Sjmcp 		if ((verifier->fwimage = calloc(1, verifier->imgsize))
6836489Sjmcp 		    == NULL) {
6846489Sjmcp 			logmsg(MSG_ERROR,
6856489Sjmcp 			    gettext("Unable to load firmware image "
6866489Sjmcp 				"%s: %s\n"),
6876489Sjmcp 			    fwimg, strerror(errno));
6886489Sjmcp 			rv = FWFLASH_FAILURE;
6896489Sjmcp 			goto cleanup;
6906489Sjmcp 		}
6916489Sjmcp 	}
6926489Sjmcp 
6936489Sjmcp 	errno = 0;
6946489Sjmcp 	if ((rv = read(imgfd, verifier->fwimage,
6956489Sjmcp 	    (size_t)verifier->imgsize)) < verifier->imgsize) {
6966489Sjmcp 		/* we haven't read enough data, bail */
6976489Sjmcp 		logmsg(MSG_ERROR,
6986489Sjmcp 		    gettext("Failed to read sufficient data "
6996489Sjmcp 			"(got %d bytes, expected %d bytes) from "
7006489Sjmcp 			"firmware image file %s: %s\n"),
7016489Sjmcp 		    rv, verifier->imgsize,
7026489Sjmcp 		    filename, strerror(errno));
7036489Sjmcp 		rv = FWFLASH_FAILURE;
7046489Sjmcp 	} else {
7056489Sjmcp 		rv = FWFLASH_SUCCESS;
7066489Sjmcp 	}
7076489Sjmcp 
7086489Sjmcp 	if ((verifier->imgfile = calloc(1, strlen(fwimg) + 1)) == NULL) {
7096489Sjmcp 		logmsg(MSG_ERROR,
7106489Sjmcp 		    gettext("Unable to save name of firmware image\n"));
7116489Sjmcp 		rv = FWFLASH_FAILURE;
7126489Sjmcp 	} else {
7136489Sjmcp 		(void) strlcpy(verifier->imgfile, fwimg, strlen(fwimg) + 1);
7146489Sjmcp 	}
7156489Sjmcp 
7166489Sjmcp 	if (rv != FWFLASH_SUCCESS) {
7176489Sjmcp 		/* cleanup and let's get outta here */
7186489Sjmcp cleanup:
7196489Sjmcp 		free(verifier->filename);
7206489Sjmcp 		free(verifier->vendor);
7216489Sjmcp 
7226489Sjmcp 		if (!(fwflash_arg_list & FWFLASH_READ_FLAG))
7236489Sjmcp 			free(verifier->fwimage);
7246489Sjmcp 
7256489Sjmcp 		verifier->filename = NULL;
7266489Sjmcp 		verifier->vendor = NULL;
7276489Sjmcp 		verifier->vendorvrfy = NULL;
7286489Sjmcp 		verifier->fwimage = NULL;
7296489Sjmcp 		(void) dlclose(verifier->handle);
7306489Sjmcp 		verifier->handle = NULL;
7316489Sjmcp 		free(verifier);
7326489Sjmcp 		if (imgfd >= 0) {
7336489Sjmcp 			(void) close(imgfd);
7346489Sjmcp 		}
7356489Sjmcp 		verifier = NULL;
7366489Sjmcp 	}
7376489Sjmcp 
7386489Sjmcp 	return (rv);
7396489Sjmcp }
7406489Sjmcp 
7416489Sjmcp /*
7426489Sjmcp  * cycles through the global list of plugins to find
7436489Sjmcp  * each flashable device, which is added to fw_devices
7446489Sjmcp  *
7456489Sjmcp  * Each plugin's identify routine must allocated storage
7466489Sjmcp  * as required.
7476489Sjmcp  *
7486489Sjmcp  * Each plugin's identify routine must return
7496489Sjmcp  * FWFLASH_FAILURE if it cannot find any devices
7506489Sjmcp  * which it handles.
7516489Sjmcp  */
7526489Sjmcp static int
7536489Sjmcp flash_device_list()
7546489Sjmcp {
7556489Sjmcp 	int rv = FWFLASH_FAILURE;
7566489Sjmcp 	int startidx = 0;
7576489Sjmcp 	int sumrv = 0;
7586489Sjmcp 	struct pluginlist *plugins;
7596489Sjmcp 
7606489Sjmcp 	/* we open rootnode here, and close it in fwflash_intr */
7616489Sjmcp 	if ((rootnode = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
7626489Sjmcp 		logmsg(MSG_ERROR,
7636489Sjmcp 		    gettext("Unable to take device tree snapshot: %s\n"),
7646489Sjmcp 		    strerror(errno));
7656489Sjmcp 		return (rv);
7666489Sjmcp 	}
7676489Sjmcp 
7686489Sjmcp 	if ((fw_devices = calloc(1, sizeof (struct devicelist))) == NULL) {
7696489Sjmcp 		logmsg(MSG_ERROR,
7706489Sjmcp 		    gettext("Unable to malloc %d bytes while "
7716489Sjmcp 		    "trying to find devices: %s\n"),
7726489Sjmcp 		    sizeof (struct devicelist), strerror(errno));
7736489Sjmcp 		return (FWFLASH_FAILURE);
7746489Sjmcp 	}
7756489Sjmcp 
7766489Sjmcp 	/* CONSTCOND */
7776489Sjmcp 	TAILQ_INIT(fw_devices);
7786489Sjmcp 
7796489Sjmcp 	TAILQ_FOREACH(plugins, fw_pluginlist, nextplugin) {
7806489Sjmcp 		self = plugins->plugin;
7816489Sjmcp 		rv = plugins->plugin->fw_identify(startidx);
7826489Sjmcp 
7836489Sjmcp 		logmsg(MSG_INFO,
7846489Sjmcp 		    gettext("fwflash:flash_device_list() got %d from "
7856489Sjmcp 		    "identify routine\n"), rv);
7866489Sjmcp 
7876489Sjmcp 		/* only bump startidx if we've found at least one device */
7886489Sjmcp 		if (rv == FWFLASH_SUCCESS) {
7896489Sjmcp 			startidx += 100;
7906489Sjmcp 			sumrv++;
7916489Sjmcp 		} else {
7926489Sjmcp 			logmsg(MSG_INFO,
7936489Sjmcp 			    gettext("No flashable devices attached with "
7946489Sjmcp 			    "the %s driver in this system\n"),
7956489Sjmcp 			    plugins->drvname);
7966489Sjmcp 		}
7976489Sjmcp 	}
7986489Sjmcp 
7996489Sjmcp 	if (sumrv > 0)
8006489Sjmcp 		rv = FWFLASH_SUCCESS;
8016489Sjmcp 
8026489Sjmcp 	return (rv);
8036489Sjmcp }
8046489Sjmcp 
8056489Sjmcp static int
8066489Sjmcp fwflash_list_fw(char *class)
8076489Sjmcp {
8086489Sjmcp 	int rv = 0;
8096489Sjmcp 	struct devicelist *curdev;
8106489Sjmcp 	int header = 1;
8116489Sjmcp 
8126489Sjmcp 	TAILQ_FOREACH(curdev, fw_devices, nextdev) {
8136489Sjmcp 
8146489Sjmcp 		/* we're either class-conscious, or we're not */
8156489Sjmcp 		if (((class != NULL) &&
8166489Sjmcp 		    ((strncmp(curdev->classname, "ALL", 3) == 0) ||
8176489Sjmcp 		    (strcmp(curdev->classname, class) == 0))) ||
8186489Sjmcp 		    (class == NULL)) {
8196489Sjmcp 
8206489Sjmcp 			if (header != 0) {
8216489Sjmcp 				(void) fprintf(stdout,
8226489Sjmcp 				    gettext("List of available devices:\n"));
8236489Sjmcp 				header--;
8246489Sjmcp 			}
8256489Sjmcp 			/*
8266489Sjmcp 			 * If any plugin's fw_devinfo() function returns
8276489Sjmcp 			 * FWFLASH_FAILURE then we want to keep track of
8286489Sjmcp 			 * it. _Most_ plugins should always return
8296489Sjmcp 			 * FWFLASH_SUCCESS from this function. The only
8306489Sjmcp 			 * exception known at this point is the tavor plugin.
8316489Sjmcp 			 */
8326489Sjmcp 			rv += curdev->plugin->fw_devinfo(curdev);
8336489Sjmcp 		}
8346489Sjmcp 	}
8356489Sjmcp 	return (rv);
8366489Sjmcp }
8376489Sjmcp 
8386489Sjmcp static int
839*7317SJames.McPherson@Sun.COM fwflash_update(char *device, char *filename, int flags)
840*7317SJames.McPherson@Sun.COM {
8416489Sjmcp 
8426489Sjmcp 	int rv = FWFLASH_FAILURE;
8436489Sjmcp 	int needsfree = 0;
8446846Sjmcp 	int found = 0;
8456489Sjmcp 	struct devicelist *curdev;
8466489Sjmcp 	char *realfile;
8476489Sjmcp 
8486489Sjmcp 	/*
8496489Sjmcp 	 * Here's how we operate:
8506489Sjmcp 	 *
8516489Sjmcp 	 * We perform some basic checks on the args, then walk
8526489Sjmcp 	 * through the device list looking for the device which
8536489Sjmcp 	 * matches. We then load the appropriate verifier for the
8546489Sjmcp 	 * image file and device, verify the image, then call the
8556489Sjmcp 	 * fw_writefw() function of the appropriate plugin.
8566489Sjmcp 	 *
8576489Sjmcp 	 * There is no "force" flag to enable you to flash a firmware
8586489Sjmcp 	 * image onto an incompatible device because the verifier
8596489Sjmcp 	 * will return FWFLASH_FAILURE if the image doesn't match.
8606489Sjmcp 	 */
8616489Sjmcp 
8626489Sjmcp 	/* new firmware filename and device desc */
8636489Sjmcp 	if (filename == NULL) {
8646489Sjmcp 		logmsg(MSG_ERROR,
8656489Sjmcp 		    gettext("Invalid firmware filename (null)\n"));
8666489Sjmcp 		return (FWFLASH_FAILURE);
8676489Sjmcp 	}
8686489Sjmcp 
8696489Sjmcp 	if (device == NULL) {
8706489Sjmcp 		logmsg(MSG_ERROR,
8716489Sjmcp 		    gettext("Invalid device requested (null)\n"));
8726489Sjmcp 		return (FWFLASH_FAILURE);
8736489Sjmcp 	}
8746489Sjmcp 
8756489Sjmcp 	if ((realfile = calloc(1, PATH_MAX + 1)) == NULL) {
8766489Sjmcp 		logmsg(MSG_ERROR,
8776489Sjmcp 		    gettext("Unable to allocate space for device "
878*7317SJames.McPherson@Sun.COM 		    "filename, operation might fail if %s is"
879*7317SJames.McPherson@Sun.COM 		    "a symbolic link\n"),
8806489Sjmcp 		    device);
8816489Sjmcp 		realfile = device;
8826489Sjmcp 	} else {
8836489Sjmcp 		/*
8846489Sjmcp 		 * If realpath() succeeds, then we have a valid
8856489Sjmcp 		 * device filename in realfile.
8866489Sjmcp 		 */
8876489Sjmcp 		if (realpath(device, realfile) == NULL) {
8886489Sjmcp 			logmsg(MSG_ERROR,
8896489Sjmcp 			    gettext("Unable to resolve device filename"
890*7317SJames.McPherson@Sun.COM 			    ": %s\n"),
8916489Sjmcp 			    strerror(errno));
8926489Sjmcp 			/* tidy up */
8936489Sjmcp 			free(realfile);
8946489Sjmcp 			/* realpath didn't succeed, use fallback */
8956489Sjmcp 			realfile = device;
8966489Sjmcp 		} else {
8976489Sjmcp 			needsfree = 1;
8986489Sjmcp 		}
8996489Sjmcp 	}
9006489Sjmcp 
9016489Sjmcp 	logmsg(MSG_INFO,
9026489Sjmcp 	    gettext("fwflash_update: fw_filename (%s) device (%s)\n"),
9036489Sjmcp 	    filename, device);
9046489Sjmcp 
9056489Sjmcp 	TAILQ_FOREACH(curdev, fw_devices, nextdev) {
9066489Sjmcp 
9076489Sjmcp 		if (strcmp(curdev->access_devname, realfile) == 0) {
9086846Sjmcp 			found++;
9096489Sjmcp 			rv = fwflash_load_verifier(curdev->drvname,
9106489Sjmcp 			    curdev->ident->vid, filename);
9116489Sjmcp 			if (rv == FWFLASH_FAILURE) {
9126489Sjmcp 				logmsg(MSG_ERROR,
9136489Sjmcp 				    gettext("Unable to load verifier "
914*7317SJames.McPherson@Sun.COM 				    "for device %s\n"),
9156489Sjmcp 				    curdev->access_devname);
9166489Sjmcp 				return (FWFLASH_FAILURE);
9176489Sjmcp 			}
9186489Sjmcp 			rv = verifier->vendorvrfy(curdev);
9196489Sjmcp 			if (rv == FWFLASH_FAILURE) {
9206489Sjmcp 				/* the verifier prints a message */
9216489Sjmcp 				logmsg(MSG_INFO,
9226489Sjmcp 				    "verifier (%s) for %s :: %s returned "
9236489Sjmcp 				    "FWFLASH_FAILURE\n",
9246489Sjmcp 				    verifier->filename,
9256489Sjmcp 				    filename, curdev->access_devname);
9266489Sjmcp 				return (rv);
9276489Sjmcp 			}
9286489Sjmcp 
929*7317SJames.McPherson@Sun.COM 			if (((flags & FWFLASH_YES_FLAG) == FWFLASH_YES_FLAG) ||
9306489Sjmcp 			    (rv = confirm_target(curdev, filename)) ==
9316489Sjmcp 			    FWFLASH_YES_FLAG) {
9326489Sjmcp 				logmsg(MSG_INFO,
9336489Sjmcp 				    "about to flash using plugin %s\n",
9346489Sjmcp 				    curdev->plugin->filename);
9356489Sjmcp 				rv = curdev->plugin->fw_writefw(curdev,
9366489Sjmcp 				    filename);
9376489Sjmcp 				if (rv == FWFLASH_FAILURE) {
9386489Sjmcp 					logmsg(MSG_ERROR,
9396489Sjmcp 					    gettext("Failed to flash "
940*7317SJames.McPherson@Sun.COM 					    "firmware file %s on "
941*7317SJames.McPherson@Sun.COM 					    "device %s: %d\n"),
9426489Sjmcp 					    filename,
9436489Sjmcp 					    curdev->access_devname, rv);
9446489Sjmcp 				}
9456489Sjmcp 			} else {
9466489Sjmcp 				logmsg(MSG_ERROR,
9476489Sjmcp 				    gettext("Flash operation not confirmed "
948*7317SJames.McPherson@Sun.COM 				    "by user\n"),
9496489Sjmcp 				    curdev->access_devname);
9506489Sjmcp 				rv = FWFLASH_FAILURE;
9516489Sjmcp 			}
9526489Sjmcp 		}
9536489Sjmcp 	}
9546489Sjmcp 
9556846Sjmcp 	if (!found)
9566846Sjmcp 		/* report the same device that the user passed in */
9576846Sjmcp 		logmsg(MSG_ERROR,
9586846Sjmcp 		    gettext("Device %s does not appear "
9596846Sjmcp 		    "to be flashable\n"),
9606846Sjmcp 		    ((strncmp(device, realfile, strlen(device)) == 0) ?
9616846Sjmcp 		    device : realfile));
9626846Sjmcp 
9636489Sjmcp 	if (needsfree)
9646489Sjmcp 		free(realfile);
9656489Sjmcp 
9666489Sjmcp 	return (rv);
9676489Sjmcp }
9686489Sjmcp 
9696489Sjmcp /*
9706489Sjmcp  * We validate that the device path is in our global device list and
9716489Sjmcp  * that the filename exists, then palm things off to the relevant plugin.
9726489Sjmcp  */
9736489Sjmcp static int
9746489Sjmcp fwflash_read_file(char *device, char *filename)
9756489Sjmcp {
9766489Sjmcp 	struct devicelist *curdev;
9776489Sjmcp 	int rv;
9786489Sjmcp 	int notfound = 0;
9796489Sjmcp 
9806489Sjmcp 	/* new firmware filename and device desc */
9816489Sjmcp 
9826489Sjmcp 	TAILQ_FOREACH(curdev, fw_devices, nextdev) {
9836489Sjmcp 		if (strncmp(curdev->access_devname, device,
9846489Sjmcp 		    MAXPATHLEN) == 0) {
9856489Sjmcp 			rv = curdev->plugin->fw_readfw(curdev, filename);
9866489Sjmcp 
9876489Sjmcp 			if (rv != FWFLASH_SUCCESS)
9886489Sjmcp 				logmsg(MSG_ERROR,
9896489Sjmcp 				    gettext("Unable to write out firmware "
9906489Sjmcp 				    "image for %s to file %s\n"),
9916489Sjmcp 				    curdev->access_devname, filename);
9926489Sjmcp 		} else {
9936489Sjmcp 			notfound++;
9946489Sjmcp 		}
9956489Sjmcp 
9966489Sjmcp 	}
9976489Sjmcp 	if (notfound) {
9986489Sjmcp 		logmsg(MSG_ERROR,
9996489Sjmcp 		    gettext("No device matching %s was found.\n"),
10006489Sjmcp 		    device);
10016489Sjmcp 		rv = FWFLASH_FAILURE;
10026489Sjmcp 	}
10036489Sjmcp 
10046489Sjmcp 	return (rv);
10056489Sjmcp }
10066489Sjmcp 
10076489Sjmcp static void
10086489Sjmcp fwflash_usage(char *arg)
10096489Sjmcp {
10106489Sjmcp 
10116489Sjmcp 	(void) fprintf(stderr, "\n");
10126489Sjmcp 	if (arg != NULL) {
10136489Sjmcp 		logmsg(MSG_ERROR,
10146489Sjmcp 		    gettext("Invalid argument (%s) supplied\n"), arg);
10156489Sjmcp 	}
10166489Sjmcp 
10176489Sjmcp 	(void) fprintf(stderr, "\n");
10186489Sjmcp 
10196489Sjmcp 	(void) fprintf(stdout, gettext("Usage:\n\t"));
10206489Sjmcp 	(void) fprintf(stdout, gettext("fwflash [-l [-c device_class "
10216489Sjmcp 	    "| ALL]] | [-v] | [-h]\n\t"));
10226489Sjmcp 	(void) fprintf(stdout, gettext("fwflash [-f file1,file2,file3"
10236489Sjmcp 	    ",... | -r file] [-y] -d device_path\n\n"));
10246489Sjmcp 	(void) fprintf(stdout, "\n"); /* workaround for xgettext */
10256489Sjmcp 
10266489Sjmcp 	(void) fprintf(stdout,
10276489Sjmcp 	    gettext("\t-l\t\tlist flashable devices in this system\n"
10286489Sjmcp 	    "\t-c device_class limit search to a specific class\n"
10296489Sjmcp 	    "\t\t\teg IB for InfiniBand, ses for SCSI Enclosures\n"
10306489Sjmcp 	    "\t-v\t\tprint version number of fwflash utility\n"
10316489Sjmcp 	    "\t-h\t\tprint this usage mesage\n\n"));
10326489Sjmcp 	(void) fprintf(stdout,
10336489Sjmcp 	    gettext("\t-f file1,file2,file3,...\n"
10346489Sjmcp 	    "\t\t\tfirmware image file list to flash\n"
10356489Sjmcp 	    "\t-r file\t\tfile to dump device firmware to\n"
10366489Sjmcp 	    "\t-y\t\tanswer Yes/Y/y to prompts\n"
10376489Sjmcp 	    "\t-d device_path\tpathname of device to be flashed\n\n"));
10386489Sjmcp 
10396489Sjmcp 	(void) fprintf(stdout,
10406489Sjmcp 	    gettext("\tIf -d device_path is specified, then one of -f "
10416489Sjmcp 	    "<files>\n"
10426489Sjmcp 	    "\tor -r <file> must also be specified\n\n"));
10436489Sjmcp 
10446489Sjmcp 	(void) fprintf(stdout,
10456489Sjmcp 	    gettext("\tIf multiple firmware images are required to be "
10466489Sjmcp 	    "flashed\n"
10476489Sjmcp 	    "\tthey must be listed together, separated by commas. The\n"
10486489Sjmcp 	    "\timages will be flashed in the order specified.\n\n"));
10496489Sjmcp 
10506489Sjmcp 	(void) fprintf(stdout, "\n");
10516489Sjmcp }
10526489Sjmcp 
10536489Sjmcp static void
10546489Sjmcp fwflash_version(void)
10556489Sjmcp {
10566489Sjmcp 	(void) fprintf(stdout, gettext("\n%s: "), FWFLASH_PROG_NAME);
10576489Sjmcp 	(void) fprintf(stdout, gettext("version %s\n"),
10586489Sjmcp 	    FWFLASH_VERSION);
10596489Sjmcp }
10606489Sjmcp 
10616489Sjmcp static void
10626489Sjmcp fwflash_intr(int sig)
10636489Sjmcp {
10646489Sjmcp 
10656489Sjmcp 	struct devicelist *thisdev;
10666489Sjmcp 	struct pluginlist *thisplug;
10676489Sjmcp 
10686489Sjmcp 
10696489Sjmcp 	(void) signal(SIGINT, SIG_IGN);
10706489Sjmcp 	(void) signal(SIGTERM, SIG_IGN);
10716846Sjmcp 	(void) signal(SIGABRT, SIG_IGN);
10726489Sjmcp 	if (fwflash_in_write) {
10736489Sjmcp 		(void) fprintf(stderr,
10746489Sjmcp 		    gettext("WARNING: firmware image may be corrupted\n\t"));
10756489Sjmcp 		(void) fprintf(stderr,
10766489Sjmcp 		    gettext("Reflash firmware before rebooting!\n"));
10776489Sjmcp 	}
10786489Sjmcp 
10796489Sjmcp 	if (sig > 0) {
10806489Sjmcp 		(void) logmsg(MSG_ERROR, gettext("\n"));
10816489Sjmcp 		(void) logmsg(MSG_ERROR,
10826489Sjmcp 		    gettext("fwflash exiting due to signal (%d)\n"), sig);
10836489Sjmcp 	}
10846489Sjmcp 
10856489Sjmcp 	/*
10866489Sjmcp 	 * we need to close everything down properly, so
10876489Sjmcp 	 * call the plugin closure routines
10886489Sjmcp 	 */
10896489Sjmcp 	if (fw_devices != NULL) {
10906489Sjmcp 		TAILQ_FOREACH(thisdev, fw_devices, nextdev) {
10916489Sjmcp 			/* free the components first */
10926489Sjmcp 			free(thisdev->access_devname);
10936489Sjmcp 			free(thisdev->drvname);
10946489Sjmcp 			free(thisdev->classname);
10956846Sjmcp 			if (thisdev->ident != NULL)
10966489Sjmcp 				free(thisdev->ident);
10976846Sjmcp 
10986489Sjmcp 			thisdev->ident = NULL;
10996489Sjmcp 			thisdev->plugin = NULL; /* we free this elsewhere */
11006489Sjmcp 			/* CONSTCOND */
11016489Sjmcp 			TAILQ_REMOVE(fw_devices, thisdev, nextdev);
11026489Sjmcp 		}
11036489Sjmcp 	}
11046489Sjmcp 
11056489Sjmcp 	if (fw_pluginlist != NULL) {
11066489Sjmcp 		TAILQ_FOREACH(thisplug, fw_pluginlist, nextplugin) {
11076489Sjmcp 			free(thisplug->filename);
11086489Sjmcp 			free(thisplug->drvname);
11096489Sjmcp 			free(thisplug->plugin->filename);
11106489Sjmcp 			free(thisplug->plugin->drvname);
11116489Sjmcp 			thisplug->filename = NULL;
11126489Sjmcp 			thisplug->drvname = NULL;
11136489Sjmcp 			thisplug->plugin->filename = NULL;
11146489Sjmcp 			thisplug->plugin->drvname = NULL;
11156489Sjmcp 			thisplug->plugin->fw_readfw = NULL;
11166489Sjmcp 			thisplug->plugin->fw_writefw = NULL;
11176489Sjmcp 			thisplug->plugin->fw_identify = NULL;
11186489Sjmcp 			thisplug->plugin->fw_devinfo = NULL;
11196489Sjmcp 			(void) dlclose(thisplug->plugin->handle);
11206489Sjmcp 			thisplug->plugin->handle = NULL;
11216489Sjmcp 			free(thisplug->plugin);
11226489Sjmcp 			thisplug->plugin = NULL;
11236489Sjmcp 			/* CONSTCOND */
11246489Sjmcp 			TAILQ_REMOVE(fw_pluginlist, thisplug, nextplugin);
11256489Sjmcp 		}
11266489Sjmcp 	}
11276489Sjmcp 
11286489Sjmcp 	if (verifier != NULL) {
11296489Sjmcp 		free(verifier->filename);
11306489Sjmcp 		free(verifier->vendor);
11316846Sjmcp 		free(verifier->imgfile);
11326846Sjmcp 		free(verifier->fwimage);
11336489Sjmcp 		verifier->filename = NULL;
11346489Sjmcp 		verifier->vendor = NULL;
11356489Sjmcp 		verifier->vendorvrfy = NULL;
11366846Sjmcp 		verifier->imgfile = NULL;
11376846Sjmcp 		verifier->fwimage = NULL;
11386489Sjmcp 		(void) dlclose(verifier->handle);
11396489Sjmcp 		verifier->handle = NULL;
11406489Sjmcp 		free(verifier);
11416489Sjmcp 	}
11426489Sjmcp 	di_fini(rootnode);
11436489Sjmcp }
11446489Sjmcp 
11456489Sjmcp static void
11466489Sjmcp fwflash_handle_signals(void)
11476489Sjmcp {
11486489Sjmcp 	if (signal(SIGINT, fwflash_intr) == SIG_ERR) {
11496489Sjmcp 		perror("signal");
11506489Sjmcp 		exit(FWFLASH_FAILURE);
11516489Sjmcp 	}
11526489Sjmcp 
11536489Sjmcp 	if (signal(SIGTERM, fwflash_intr) == SIG_ERR) {
11546489Sjmcp 		perror("signal");
11556489Sjmcp 		exit(FWFLASH_FAILURE);
11566489Sjmcp 	}
11576489Sjmcp }
11586489Sjmcp 
11596489Sjmcp static int
11606489Sjmcp confirm_target(struct devicelist *thisdev, char *file)
11616489Sjmcp {
11626489Sjmcp 	int resp;
11636489Sjmcp 
11646846Sjmcp 	(void) fflush(stdin);
11656846Sjmcp 	(void) printf(gettext("About to update firmware on %s\n"),
11666846Sjmcp 	    thisdev->access_devname);
11676846Sjmcp 	(void) printf(gettext("with file %s. Do you want to continue? "
11686846Sjmcp 	    "(Y/N): "), file);
11696489Sjmcp 
11706489Sjmcp 	resp = getchar();
11716489Sjmcp 	if (resp == 'Y' || resp == 'y') {
11726489Sjmcp 		return (FWFLASH_YES_FLAG);
11736489Sjmcp 	} else {
11746489Sjmcp 		logmsg(MSG_INFO, "flash operation NOT confirmed.\n");
11756489Sjmcp 	}
11766489Sjmcp 
11776489Sjmcp 	(void) fflush(stdin);
11786489Sjmcp 	return (FWFLASH_FAILURE);
11796489Sjmcp }
11806489Sjmcp 
11816489Sjmcp int
11826489Sjmcp get_fileopts(char *options)
11836489Sjmcp {
11846489Sjmcp 
11856489Sjmcp 	int i;
11866489Sjmcp 	char *files;
11876489Sjmcp 
11886489Sjmcp 	if (files = strtok(options, ",")) {
11896489Sjmcp 		/* we have more than one */
11906489Sjmcp 		if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) {
11916489Sjmcp 			logmsg(MSG_ERROR,
11926489Sjmcp 			    gettext("Unable to allocate space for "
11936489Sjmcp 			    "a firmware image filename\n"));
11946489Sjmcp 			return (FWFLASH_FAILURE);
11956489Sjmcp 		}
11966489Sjmcp 		(void) strlcpy(filelist[0], files, strlen(files) + 1);
11976489Sjmcp 		i = 1;
11986489Sjmcp 
11996489Sjmcp 		logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n",
12006489Sjmcp 		    filelist[0]);
12016489Sjmcp 
12026489Sjmcp 
12036489Sjmcp 		while (files = strtok(NULL, ",")) {
12046489Sjmcp 			if ((filelist[i] = calloc(1, MAXPATHLEN + 1))
12056489Sjmcp 			    == NULL) {
12066489Sjmcp 				logmsg(MSG_ERROR,
12076489Sjmcp 				    gettext("Unable to allocate space for "
12086489Sjmcp 				    "a firmware image filename\n"));
12096489Sjmcp 				return (FWFLASH_FAILURE);
12106489Sjmcp 			}
12116489Sjmcp 			(void) strlcpy(filelist[i], files,
12126489Sjmcp 			    strlen(files) + 1);
12136489Sjmcp 			logmsg(MSG_INFO, "fwflash: filelist[%d]: %s\n",
12146489Sjmcp 			    i, filelist[i]);
12156489Sjmcp 			++i;
12166489Sjmcp 		}
12176489Sjmcp 	} else {
12186489Sjmcp 		if ((filelist[0] = calloc(1, MAXPATHLEN + 1)) == NULL) {
12196489Sjmcp 			logmsg(MSG_ERROR,
12206489Sjmcp 			    gettext("Unable to allocate space for "
12216489Sjmcp 			    "a firmware image filename\n"));
12226489Sjmcp 			return (FWFLASH_FAILURE);
12236489Sjmcp 		}
12246489Sjmcp 		(void) strlcpy(filelist[0], options, strlen(files) + 1);
12256489Sjmcp 		logmsg(MSG_INFO, "fwflash: filelist[0]: %s\n",
12266489Sjmcp 		    filelist[0]);
12276489Sjmcp 	}
12286489Sjmcp 	return (FWFLASH_SUCCESS);
12296489Sjmcp }
12306489Sjmcp 
12316489Sjmcp /*
12326489Sjmcp  * code reuse - cheerfully borrowed from stmsboot_util.c
12336489Sjmcp  */
12346489Sjmcp void
1235*7317SJames.McPherson@Sun.COM logmsg(int severity, const char *msg, ...) {
12366489Sjmcp 
12376489Sjmcp 	va_list ap;
12386489Sjmcp 
12396489Sjmcp 	if ((severity > MSG_INFO) ||
12406489Sjmcp 	    ((severity == MSG_INFO) && (fwflash_debug > 0))) {
12416489Sjmcp 		(void) fprintf(stderr, "%s: ", FWFLASH_PROG_NAME);
12426489Sjmcp 		va_start(ap, msg);
12436489Sjmcp 		(void) vfprintf(stderr, msg, ap);
12446489Sjmcp 		va_end(ap);
12456489Sjmcp 	}
12466489Sjmcp }
1247