eeprom/i386/benv.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "benv.h"
#include "message.h"
#include <ctype.h>
#include <stdarg.h>
#include <sys/mman.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

/*
 * Usage:  % eeprom [-v] [-f prom_dev] [-]
 *	   % eeprom [-v] [-f prom_dev] field[=value] ...
 */

extern void get_kbenv(void);
extern void close_kbenv(void);
extern caddr_t get_propval(char *name, char *node);
extern void setprogname(char *prog);
extern char *getbootcmd(void);

char *boottree;
struct utsname uts_buf;

static int test;
int verbose;

/*
 * Concatenate a NULL terminated list of strings into
 * a single string.
 */
char *
strcats(char *s, ...)
{
	char *cp, *ret;
	size_t len;
	va_list ap;

	va_start(ap, s);
	for (ret = NULL, cp = s; cp; cp = va_arg(ap, char *)) {
		if (ret == NULL) {
			ret = strdup(s);
			len = strlen(ret) + 1;
		} else {
			len += strlen(cp);
			ret = realloc(ret, len);
			(void) strcat(ret, cp);
		}
	}
	va_end(ap);

	return (ret);
}

eplist_t *
new_list(void)
{
	eplist_t *list;

	list = (eplist_t *)malloc(sizeof (eplist_t));
	(void) memset(list, 0, sizeof (eplist_t));

	list->next = list;
	list->prev = list;
	list->item = NULL;

	return (list);
}

void
add_item(void *item, eplist_t *list)
{
	eplist_t *entry;

	entry = (eplist_t *)malloc(sizeof (eplist_t));
	(void) memset(entry, 0, sizeof (eplist_t));
	entry->item = item;

	entry->next = list;
	entry->prev = list->prev;
	list->prev->next = entry;
	list->prev = entry;
}

typedef struct benv_ent {
	char *cmd;
	char *name;
	char *val;
} benv_ent_t;

typedef struct benv_des {
	char *name;
	int fd;
	caddr_t adr;
	size_t len;
	eplist_t *elist;
} benv_des_t;

static benv_des_t *
new_bd(void)
{

	benv_des_t *bd;

	bd = (benv_des_t *)malloc(sizeof (benv_des_t));
	(void) memset(bd, 0, sizeof (benv_des_t));

	bd->elist = new_list();

	return (bd);
}

/*
 * Create a new entry.  Comment entries have NULL names.
 */
static benv_ent_t *
new_bent(char *comm, char *cmd, char *name, char *val)
{
	benv_ent_t *bent;

	bent = (benv_ent_t *)malloc(sizeof (benv_ent_t));
	(void) memset(bent, 0, sizeof (benv_ent_t));

	if (comm) {
		bent->cmd = strdup(comm);
		comm = NULL;
	} else {
		bent->cmd = strdup(cmd);
		bent->name = strdup(name);
		if (val)
			bent->val = strdup(val);
	}

	return (bent);
}

/*
 * Add a new entry to the benv entry list.  Entries can be
 * comments or commands.
 */
static void
add_bent(eplist_t *list, char *comm, char *cmd, char *name, char *val)
{
	benv_ent_t *bent;

	bent = new_bent(comm, cmd, name, val);
	add_item((void *)bent, list);
}

static benv_ent_t *
get_var(char *name, eplist_t *list)
{
	eplist_t *e;
	benv_ent_t *p;

	for (e = list->next; e != list; e = e->next) {
		p = (benv_ent_t *)e->item;
		if (p->name != NULL && strcmp(p->name, name) == 0)
			return (p);
	}

	return (NULL);
}

/*PRINTFLIKE1*/
static void
eeprom_error(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	(void) fprintf(stderr, "eeprom: ");
	(void) vfprintf(stderr, format, ap);
	va_end(ap);
}

static int
exec_cmd(char *cmdline, char *output, int64_t osize)
{
	char buf[BUFSIZ];
	int ret;
	size_t len;
	FILE *ptr;
	sigset_t set;
	void (*disp)(int);

	if (output)
		output[0] = '\0';

	/*
	 * For security
	 * - only absolute paths are allowed
	 * - set IFS to space and tab
	 */
	if (*cmdline != '/') {
		eeprom_error(ABS_PATH_REQ, cmdline);
		return (-1);
	}
	(void) putenv("IFS= \t");

	/*
	 * We may have been exec'ed with SIGCHLD blocked
	 * unblock it here
	 */
	(void) sigemptyset(&set);
	(void) sigaddset(&set, SIGCHLD);
	if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) {
		eeprom_error(FAILED_SIG, strerror(errno));
		return (-1);
	}

	/*
	 * Set SIGCHLD disposition to SIG_DFL for popen/pclose
	 */
	disp = sigset(SIGCHLD, SIG_DFL);
	if (disp == SIG_ERR) {
		eeprom_error(FAILED_SIG, strerror(errno));
		return (-1);
	}
	if (disp == SIG_HOLD) {
		eeprom_error(BLOCKED_SIG, cmdline);
		return (-1);
	}

	ptr = popen(cmdline, "r");
	if (ptr == NULL) {
		eeprom_error(POPEN_FAIL, cmdline, strerror(errno));
		return (-1);
	}

	/*
	 * If we simply do a pclose() following a popen(), pclose()
	 * will close the reader end of the pipe immediately even
	 * if the child process has not started/exited. pclose()
	 * does wait for cmd to terminate before returning though.
	 * When the executed command writes its output to the pipe
	 * there is no reader process and the command dies with
	 * SIGPIPE. To avoid this we read repeatedly until read
	 * terminates with EOF. This indicates that the command
	 * (writer) has closed the pipe and we can safely do a
	 * pclose().
	 *
	 * Since pclose() does wait for the command to exit,
	 * we can safely reap the exit status of the command
	 * from the value returned by pclose()
	 */
	while (fgets(buf, sizeof (buf), ptr) != NULL) {
		if (output && osize > 0) {
			(void) snprintf(output, osize, "%s", buf);
			len = strlen(buf);
			output += len;
			osize -= len;
		}
	}

	/*
	 * If there's a "\n" at the end, we want to chop it off
	 */
	if (output) {
		len = strlen(output) - 1;
		if (output[len] == '\n')
			output[len] = '\0';
	}

	ret = pclose(ptr);
	if (ret == -1) {
		eeprom_error(PCLOSE_FAIL, cmdline, strerror(errno));
		return (-1);
	}

	if (WIFEXITED(ret)) {
		return (WEXITSTATUS(ret));
	} else {
		eeprom_error(EXEC_FAIL, cmdline, ret);
		return (-1);
	}
}

#define	BOOTADM_STR	"bootadm: "

/*
 * bootadm starts all error messages with "bootadm: ".
 * Add a note so users don't get confused on how they ran bootadm.
 */
static void
output_error_msg(const char *msg)
{
	size_t len = sizeof (BOOTADM_STR) - 1;

	if (strncmp(msg, BOOTADM_STR, len) == 0) {
		eeprom_error("error returned from %s\n", msg);
	} else if (msg[0] != '\0') {
		eeprom_error("%s\n", msg);
	}
}

static char *
get_bootadm_value(char *name, const int quiet)
{
	char *ptr, *ret_str, *end_ptr, *orig_ptr;
	char output[BUFSIZ];
	int is_console, is_kernel = 0;
	size_t len;

	is_console = (strcmp(name, "console") == 0);

	if (strcmp(name, "boot-file") == 0) {
		is_kernel = 1;
		ptr = "/sbin/bootadm set-menu kernel 2>&1";
	} else if (is_console || (strcmp(name, "boot-args") == 0)) {
		ptr = "/sbin/bootadm set-menu args 2>&1";
	} else {
		eeprom_error("Unknown value in get_bootadm_value: %s\n", name);
		return (NULL);
	}

	if (exec_cmd(ptr, output, BUFSIZ) != 0) {
		if (quiet == 0) {
			output_error_msg(output);
		}
		return (NULL);
	}

	if (is_console) {
		if ((ptr = strstr(output, "console=")) == NULL) {
			return (NULL);
		}
		ptr += strlen("console=");

		/*
		 * -B may have comma-separated values.  It may also be
		 * followed by other flags.
		 */
		len = strcspn(ptr, " \t,");
		ret_str = calloc(len + 1, 1);
		if (ret_str == NULL) {
			eeprom_error(NO_MEM, len + 1);
			return (NULL);
		}
		(void) strncpy(ret_str, ptr, len);
		return (ret_str);
	} else if (is_kernel) {
		ret_str = strdup(output);
		if (ret_str == NULL)
			eeprom_error(NO_MEM, strlen(output) + 1);
		return (ret_str);
	} else {
		/* If there's no console setting, we can return */
		if ((orig_ptr = strstr(output, "console=")) == NULL) {
			return (strdup(output));
		}
		len = strcspn(orig_ptr, " \t,");
		ptr = orig_ptr;
		end_ptr = orig_ptr + len + 1;

		/* Eat up any white space */
		while ((*end_ptr == ' ') || (*end_ptr == '\t'))
			end_ptr++;

		/*
		 * If there's data following the console string, copy it.
		 * If not, cut off the new string.
		 */
		if (*end_ptr == '\0')
			*ptr = '\0';

		while (*end_ptr != '\0') {
			*ptr = *end_ptr;
			ptr++;
			end_ptr++;
		}
		*ptr = '\0';
		if ((strchr(output, '=') == NULL) &&
		    (strncmp(output, "-B ", 3) == 0)) {
			/*
			 * Since we removed the console setting, we no
			 * longer need the initial "-B "
			 */
			orig_ptr = output + 3;
		} else {
			orig_ptr = output;
		}

		ret_str = strdup(orig_ptr);
		if (ret_str == NULL)
			eeprom_error(NO_MEM, strlen(orig_ptr) + 1);
		return (ret_str);
	}
}

/*
 * If quiet is 1, print nothing if there is no value.  If quiet is 0, print
 * a message.  Return 1 if the value is printed, 0 otherwise.
 */
static int
print_bootadm_value(char *name, const int quiet)
{
	int rv = 0;
	char *value = get_bootadm_value(name, quiet);

	if ((value != NULL) && (value[0] != '\0')) {
		(void) printf("%s=%s\n", name, value);
		rv = 1;
	} else if (quiet == 0) {
		(void) printf("%s: data not available.\n", name);
	}

	if (value != NULL)
		free(value);
	return (rv);
}

static void
print_var(char *name, eplist_t *list)
{
	benv_ent_t *p;

	/*
	 * The console property is kept in both menu.lst and bootenv.rc.  The
	 * menu.lst value takes precedence.
	 */
	if (strcmp(name, "console") == 0) {
		if (print_bootadm_value(name, 1) == 0) {
			if ((p = get_var(name, list)) != NULL) {
				(void) printf("%s=%s\n", name, p->val ?
				    p->val : "");
			} else {
				(void) printf("%s: data not available.\n",
				    name);
			}
		}
	} else if ((strcmp(name, "boot-file") == 0) ||
	    (strcmp(name, "boot-args") == 0)) {
		(void) print_bootadm_value(name, 0);
	} else if ((p = get_var(name, list)) == NULL)
		(void) printf("%s: data not available.\n", name);
	else
		(void) printf("%s=%s\n", name, p->val ? p->val : "");
}

static void
print_vars(eplist_t *list)
{
	eplist_t *e;
	benv_ent_t *p;
	int console_printed = 0;

	/*
	 * The console property is kept both in menu.lst and bootenv.rc.
	 * The menu.lst value takes precedence, so try printing that one
	 * first.
	 */
	console_printed = print_bootadm_value("console", 1);

	for (e = list->next; e != list; e = e->next) {
		p = (benv_ent_t *)e->item;
		if (p->name != NULL) {
			if (((strcmp(p->name, "console") == 0) &&
			    (console_printed == 1)) ||
			    ((strcmp(p->name, "boot-file") == 0) ||
			    (strcmp(p->name, "boot-args") == 0))) {
				/* handle these separately */
				continue;
			}
			(void) printf("%s=%s\n", p->name, p->val ? p->val : "");
		}
	}
	(void) print_bootadm_value("boot-file", 1);
	(void) print_bootadm_value("boot-args", 1);
}

/*
 * Write a string to a file, quoted appropriately.  We use single
 * quotes to prevent any variable expansion.  Of course, we backslash-quote
 * any single quotes or backslashes.
 */
static void
put_quoted(FILE *fp, char *val)
{
	(void) putc('\'', fp);
	while (*val) {
		switch (*val) {
		case '\'':
		case '\\':
			(void) putc('\\', fp);
			/* FALLTHROUGH */
		default:
			(void) putc(*val, fp);
			break;
		}
		val++;
	}
	(void) putc('\'', fp);
}

static void
set_bootadm_var(char *name, char *value)
{
	char buf[BUFSIZ];
	char output[BUFSIZ] = "";
	char *console, *args;
	int is_console;

	if (verbose) {
		(void) printf("old:");
		(void) print_bootadm_value(name, 0);
	}

	/*
	 * For security, we single-quote whatever we run on the command line,
	 * and we don't allow single quotes in the string.
	 */
	if (strchr(value, '\'') != NULL) {
		eeprom_error("Single quotes are not allowed "
		    "in the %s property.\n", name);
		return;
	}

	is_console = (strcmp(name, "console") == 0);
	if (strcmp(name, "boot-file") == 0) {
		(void) snprintf(buf, BUFSIZ, "/sbin/bootadm set-menu "
		    "kernel='%s' 2>&1", value);
	} else if (is_console || (strcmp(name, "boot-args") == 0)) {
		if (is_console) {
			args = get_bootadm_value("boot-args", 1);
			console = value;
		} else {
			args = value;
			console = get_bootadm_value("console", 1);
		}
		if (((args == NULL) || (args[0] == '\0')) &&
		    ((console == NULL) || (console[0] == '\0'))) {
			(void) snprintf(buf, BUFSIZ, "/sbin/bootadm set-menu "
			    "args= 2>&1");
		} else if ((args == NULL) || (args[0] == '\0')) {
			(void) snprintf(buf, BUFSIZ, "/sbin/bootadm "
			    "set-menu args='-B console=%s' 2>&1",
			    console);
		} else if ((console == NULL) || (console[0] == '\0')) {
			(void) snprintf(buf, BUFSIZ, "/sbin/bootadm "
			    "set-menu args='%s' 2>&1", args);
		} else if (strncmp(args, "-B ", 3) != 0) {
			(void) snprintf(buf, BUFSIZ, "/sbin/bootadm "
			    "set-menu args='-B console=%s %s' 2>&1",
			    console, args);
		} else {
			(void) snprintf(buf, BUFSIZ, "/sbin/bootadm "
			    "set-menu args='-B console=%s,%s' 2>&1",
			    console, args + 3);
		}
	} else {
		eeprom_error("Unknown value in set_bootadm_value: %s\n", name);
		return;
	}

	if (exec_cmd(buf, output, BUFSIZ) != 0) {
		output_error_msg(output);
		return;
	}

	if (verbose) {
		(void) printf("new:");
		(void) print_bootadm_value(name, 0);
	}
}

/*
 * Returns 1 if bootenv.rc was modified, 0 otherwise.
 */
static int
set_var(char *name, char *val, eplist_t *list)
{
	benv_ent_t *p;
	int old_verbose;

	if ((strcmp(name, "boot-file") == 0) ||
	    (strcmp(name, "boot-args") == 0)) {
		set_bootadm_var(name, val);
		return (0);
	}

	/*
	 * The console property is kept in two places: menu.lst and bootenv.rc.
	 * Update them both.  We clear verbose to prevent duplicate messages.
	 */
	if (strcmp(name, "console") == 0) {
		old_verbose = verbose;
		verbose = 0;
		set_bootadm_var(name, val);
		verbose = old_verbose;
	}

	if (verbose) {
		(void) printf("old:");
		print_var(name, list);
	}

	if ((p = get_var(name, list)) != NULL) {
		free(p->val);
		p->val = strdup(val);
	} else
		add_bent(list, NULL, "setprop", name, val);

	if (verbose) {
		(void) printf("new:");
		print_var(name, list);
	}
	return (1);
}

/*
 * Returns 1 if bootenv.rc is modified or 0 if no modification was
 * necessary.  This allows us to implement non super-user look-up of
 * variables by name without the user being yelled at for trying to
 * modify the bootenv.rc file.
 */
static int
proc_var(char *name, eplist_t *list)
{
	register char *val;

	if ((val = strchr(name, '=')) == NULL) {
		print_var(name, list);
		return (0);
	} else {
		*val++ = '\0';
		return (set_var(name, val, list));
	}
}

static void
init_benv(benv_des_t *bd, char *file)
{
	get_kbenv();

	if (test)
		boottree = "/tmp";
	else if ((boottree = (char *)get_propval("boottree", "chosen")) == NULL)
		boottree = strcats("/boot", NULL);

	if (file != NULL)
		bd->name = file;
	else
		bd->name = strcats(boottree, "/solaris/bootenv.rc", NULL);
}

static void
map_benv(benv_des_t *bd)
{
	if ((bd->fd = open(bd->name, O_RDONLY)) == -1)
		if (errno == ENOENT)
			return;
		else
			exit(_error(PERROR, "cannot open %s", bd->name));

	if ((bd->len = (size_t)lseek(bd->fd, 0, SEEK_END)) == 0) {
		if (close(bd->fd) == -1)
			exit(_error(PERROR, "close error on %s", bd->name));
		return;
	}

	(void) lseek(bd->fd, 0, SEEK_SET);

	if ((bd->adr = mmap((caddr_t)0, bd->len, (PROT_READ | PROT_WRITE),
	    MAP_PRIVATE, bd->fd, 0)) == MAP_FAILED)
		exit(_error(PERROR, "cannot map %s", bd->name));
}

static void
unmap_benv(benv_des_t *bd)
{
	if (munmap(bd->adr, bd->len) == -1)
		exit(_error(PERROR, "unmap error on %s", bd->name));

	if (close(bd->fd) == -1)
		exit(_error(PERROR, "close error on %s", bd->name));
}

#define	NL	'\n'
#define	COMM	'#'

/*
 * Add a comment block to the benv list.
 */
static void
add_comm(benv_des_t *bd, char *base, char *last, char **next, int *line)
{
	int nl, lines;
	char *p;

	nl = 0;
	for (p = base, lines = 0; p < last; p++) {
		if (*p == NL) {
			nl++;
			lines++;
		} else if (nl) {
			if (*p != COMM)
				break;
			nl = 0;
		}
	}
	*(p - 1) = NULL;
	add_bent(bd->elist, base, NULL, NULL, NULL);
	*next = p;
	*line += lines;
}

/*
 * Parse out an operator (setprop) from the boot environment
 */
static char *
parse_cmd(benv_des_t *bd, char **next, int *line)
{
	char *strbegin;
	char *badeof = "unexpected EOF in %s line %d";
	char *syntax = "syntax error in %s line %d";
	char *c = *next;

	/*
	 * Skip spaces or tabs. New lines increase the line count.
	 */
	while (isspace(*c)) {
		if (*c++ == '\n')
			(*line)++;
	}

	/*
	 * Check for a the setprop command.  Currently that's all we
	 * seem to support.
	 *
	 * XXX need support for setbinprop?
	 */

	/*
	 * Check first for end of file.  Finding one now would be okay.
	 * We should also bail if we are at the start of a comment.
	 */
	if (*c == '\0' || *c == COMM) {
		*next = c;
		return (NULL);
	}

	strbegin = c;
	while (*c && !isspace(*c))
		c++;

	/*
	 * Check again for end of file.  Finding one now would NOT be okay.
	 */
	if (*c == '\0') {
		exit(_error(NO_PERROR, badeof, bd->name, *line));
	}

	*c++ = '\0';
	*next = c;

	/*
	 * Last check is to make sure the command is a setprop!
	 */
	if (strcmp(strbegin, "setprop") != 0) {
		exit(_error(NO_PERROR, syntax, bd->name, *line));
		/* NOTREACHED */
	}
	return (strbegin);
}

/*
 * Parse out the name (LHS) of a setprop from the boot environment
 */
static char *
parse_name(benv_des_t *bd, char **next, int *line)
{
	char *strbegin;
	char *badeof = "unexpected EOF in %s line %d";
	char *syntax = "syntax error in %s line %d";
	char *c = *next;

	/*
	 * Skip spaces or tabs. No tolerance for new lines now.
	 */
	while (isspace(*c)) {
		if (*c++ == '\n')
			exit(_error(NO_PERROR, syntax, bd->name, *line));
	}

	/*
	 * Grab a name for the property to set.
	 */

	/*
	 * Check first for end of file.  Finding one now would NOT be okay.
	 */
	if (*c == '\0') {
		exit(_error(NO_PERROR, badeof, bd->name, *line));
	}

	strbegin = c;
	while (*c && !isspace(*c))
		c++;

	/*
	 * At this point in parsing we have 'setprop name'.  What follows
	 * is a newline, other whitespace, or EOF.  Most of the time we
	 * want to replace a white space character with a NULL to terminate
	 * the name, and then continue on processing.  A newline here provides
	 * the most grief.  If we just replace it with a null we'll
	 * potentially get the setprop on the next line as the value of this
	 * setprop! So, if the last thing we see is a newline we'll have to
	 * dup the string.
	 */
	if (isspace(*c)) {
		if (*c == '\n') {
			*c = '\0';
			strbegin = strdup(strbegin);
			*c = '\n';
		} else {
			*c++ = '\0';
		}
	}

	*next = c;
	return (strbegin);
}

/*
 * Parse out the value (RHS) of a setprop line from the boot environment
 */
static char *
parse_value(benv_des_t *bd, char **next, int *line)
{
	char *strbegin;
	char *badeof = "unexpected EOF in %s line %d";
	char *result;
	char *c = *next;
	char quote;

	/*
	 * Skip spaces or tabs. A newline here would indicate a
	 * NULL property value.
	 */
	while (isspace(*c)) {
		if (*c++ == '\n') {
			(*line)++;
			*next = c;
			return (NULL);
		}
	}

	/*
	 * Grab the value of the property to set.
	 */

	/*
	 * Check first for end of file.  Finding one now would
	 * also indicate a NULL property.
	 */
	if (*c == '\0') {
		*next = c;
		return (NULL);
	}

	/*
	 * Value may be quoted, in which case we assume the end of the value
	 * comes with a closing quote.
	 *
	 * We also allow escaped quote characters inside the quoted value.
	 *
	 * For obvious reasons we do not attempt to parse variable references.
	 */
	if (*c == '"' || *c == '\'') {
		quote = *c;
		c++;
		strbegin = c;
		result = c;
		while (*c != quote) {
			if (*c == '\\') {
				c++;
			}
			if (*c == '\0') {
				break;
			}
			*result++ = *c++;
		}

		/*
		 *  Throw fatal exception if no end quote found.
		 */
		if (*c != quote) {
			exit(_error(NO_PERROR, badeof, bd->name, *line));
		}

		*result = '\0';		/* Terminate the result */
		c++;			/* and step past the close quote */
	} else {
		strbegin = c;
		while (*c && !isspace(*c))
			c++;
	}

	/*
	 * Check again for end of file.  Finding one now is okay.
	 */
	if (*c == '\0') {
		*next = c;
		return (strbegin);
	}

	*c++ = '\0';
	*next = c;
	return (strbegin);
}

/*
 * Add a command to the benv list.
 */
static void
add_cmd(benv_des_t *bd, char *last, char **next, int *line)
{
	char *cmd, *name, *val;

	while (*next <= last && **next != COMM) {
		if ((cmd = parse_cmd(bd, next, line)) == NULL)
			break;
		name = parse_name(bd, next, line);
		val = parse_value(bd, next, line);
		add_bent(bd->elist, NULL, cmd, name, val);
		(*line)++;
	};

	add_bent(bd->elist, NULL, "getprop", "bootcmd", getbootcmd());
}

/*
 * Parse the benv (bootenv.rc) file and break it into a benv
 * list.  List entries may be comment blocks or commands.
 */
static void
parse_benv(benv_des_t *bd)
{
	int line;
	char *pbase, *pend;
	char *tok, *tnext;

	line = 1;
	pbase = (char *)bd->adr;
	pend = pbase + bd->len;

	for (tok = tnext = pbase; tnext < pend && '\0' != *tnext; tok = tnext)
		if (*tok == COMM)
			add_comm(bd, tok, pend, &tnext, &line);
		else
			add_cmd(bd, pend, &tnext, &line);
}

static void
write_benv(benv_des_t *bd)
{
	FILE *fp;
	eplist_t *list, *e;
	benv_ent_t *bent;
	char *name;

	list = bd->elist;

	if (list->next == list)
		return;

	if ((fp = fopen(bd->name, "w")) == NULL)
		exit(_error(PERROR, "cannot open %s", bd->name));

	for (e = list->next; e != list; e = e->next) {
		bent = (benv_ent_t *)e->item;
		name = bent->name;
		if (name) {
			if (bent->val) {
				(void) fprintf(fp, "%s %s ",
				    bent->cmd, bent->name);
				put_quoted(fp, bent->val);
				(void) fprintf(fp, "\n");
			} else {
				(void) fprintf(fp, "%s %s\n",
				    bent->cmd, bent->name);
			}
		} else {
			(void) fprintf(fp, "%s\n", bent->cmd);
		}
	}

	(void) fclose(fp);
}

static char *
get_line(void)
{
	int c;
	char *nl;
	static char line[256];

	if (fgets(line, sizeof (line), stdin) != NULL) {
		/*
		 * Remove newline if present,
		 * otherwise discard rest of line.
		 */
		if (nl = strchr(line, '\n'))
			*nl = 0;
		else
			while ((c = getchar()) != '\n' && c != EOF)
				;
		return (line);
	} else
		return (NULL);
}

int
main(int argc, char **argv)
{
	int c;
	int updates = 0;
	char *usage = "Usage: %s [-v] [-f prom-device]"
	    " [variable[=value] ...]";
	eplist_t *elist;
	benv_des_t *bd;
	char *file = NULL;

	setprogname(argv[0]);

	while ((c = getopt(argc, argv, "f:Itv")) != -1)
		switch (c) {
		case 'v':
			verbose++;
			break;
		case 'f':
			file = optarg;
			break;
		case 't':
			test++;
			break;
		default:
			exit(_error(NO_PERROR, usage, argv[0]));
		}

	(void) uname(&uts_buf);
	bd = new_bd();
	init_benv(bd, file);

	map_benv(bd);
	if (bd->len) {
		parse_benv(bd);
		unmap_benv(bd);
	}

	elist = bd->elist;

	if (optind >= argc) {
		print_vars(elist);
		return (0);
	} else
		while (optind < argc) {
			/*
			 * If "-" specified, read variables from stdin;
			 * otherwise, process each argument as a variable
			 * print or set request.
			 */
			if (strcmp(argv[optind], "-") == 0) {
				char *line;

				while ((line = get_line()) != NULL)
					updates += proc_var(line, elist);
				clearerr(stdin);
			} else
				updates += proc_var(argv[optind], elist);

			optind++;
		}

	/*
	 * don't write benv if we are processing delayed writes since
	 * it is likely that the delayed writes changes bootenv.rc anyway...
	 */
	if (updates)
		write_benv(bd);
	close_kbenv();

	return (0);
}