OpenSolaris_b135/cmd/syseventadm/syseventadm.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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* syseventadm - command to administer the sysevent.conf registry
* - administers the general purpose event framework
*
* The current implementation of the registry using files in
* /etc/sysevent/config, files are named as event specifications
* are added with the combination of the vendor, publisher, event
* class and subclass strings:
*
* [<vendor>,][<publisher>,][<class>,]sysevent.conf
*
*/
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <dirent.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <door.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <strings.h>
#include <unistd.h>
#include <synch.h>
#include <syslog.h>
#include <thread.h>
#include <limits.h>
#include <locale.h>
#include <assert.h>
#include <libsysevent.h>
#include <zone.h>
#include <sys/sysevent_impl.h>
#include <sys/modctl.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/systeminfo.h>
#include <sys/wait.h>
#include "syseventadm.h"
#include "syseventadm_msg.h"
#ifndef DEBUG
#undef assert
#define assert(EX) ((void)0)
#endif
static char *whoami = NULL;
static char *root_dir = "";
static char *arg_vendor = NULL;
static char *arg_publisher = NULL;
static char *arg_class = NULL;
static char *arg_subclass = NULL;
static char *arg_username = NULL;
static char *arg_path = NULL;
static int arg_nargs = 0;
static char **arg_args = NULL;
static int lock_fd;
static char lock_file[PATH_MAX + 1];
extern char *optarg;
extern int optind;
static int
usage_gen()
{
(void) fprintf(stderr, MSG_USAGE_INTRO);
(void) fprintf(stderr, MSG_USAGE_OPTIONS);
(void) fprintf(stderr, "\n"
"\tsyseventadm add ...\n"
"\tsyseventadm remove ...\n"
"\tsyseventadm list ...\n"
"\tsyseventadm restart\n"
"\tsyseventadm help\n");
return (EXIT_USAGE);
}
static int
serve_syseventdotconf(int argc, char **argv, char *cmd)
{
int c;
int rval;
while ((c = getopt(argc, argv, "R:v:p:c:s:u:")) != EOF) {
switch (c) {
case 'R':
/*
* Alternate root path for install, etc.
*/
set_root_dir(optarg);
break;
case 'v':
arg_vendor = optarg;
break;
case 'p':
arg_publisher = optarg;
break;
case 'c':
arg_class = optarg;
break;
case 's':
arg_subclass = optarg;
break;
case 'u':
arg_username = optarg;
break;
default:
return (usage());
}
}
if (optind < argc) {
arg_path = argv[optind++];
if (optind < argc) {
arg_nargs = argc - optind;
arg_args = argv + optind;
}
}
enter_lock(root_dir);
if (strcmp(cmd, "add") == 0) {
rval = add_cmd();
} else if (strcmp(cmd, "list") == 0) {
rval = list_remove_cmd(CMD_LIST);
} else if (strcmp(cmd, "remove") == 0) {
rval = list_remove_cmd(CMD_REMOVE);
} else if (strcmp(cmd, "restart") == 0) {
rval = restart_cmd();
} else {
rval = usage();
}
exit_lock();
return (rval);
}
int
main(int argc, char **argv)
{
char *cmd;
int rval;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
if ((whoami = strrchr(argv[0], '/')) == NULL) {
whoami = argv[0];
} else {
whoami++;
}
if (argc == 1) {
return (usage_gen());
}
cmd = argv[optind++];
/* Allow non-privileged users to get the help messages */
if (strcmp(cmd, "help") == 0) {
rval = usage_gen();
return (rval);
}
if (getuid() != 0) {
(void) fprintf(stderr, MSG_NOT_ROOT, whoami);
exit(EXIT_PERM);
}
if (strcmp(cmd, "evc") != 0 && getzoneid() != GLOBAL_ZONEID) {
(void) fprintf(stderr, MSG_NOT_GLOBAL, whoami);
exit(EXIT_PERM);
}
if (strcmp(cmd, "add") == 0 ||
strcmp(cmd, "remove") == 0 || strcmp(cmd, "list") == 0 ||
strcmp(cmd, "restart") == 0) {
rval = serve_syseventdotconf(argc, argv, cmd);
} else {
rval = usage_gen();
}
return (rval);
}
static void
enter_lock(char *root_dir)
{
struct flock lock;
if (snprintf(lock_file, sizeof (lock_file), "%s%s", root_dir,
LOCK_FILENAME) >= sizeof (lock_file)) {
(void) fprintf(stderr, MSG_LOCK_PATH_ERR, whoami, lock_file);
exit(EXIT_CMD_FAILED);
}
lock_fd = open(lock_file, O_CREAT|O_RDWR, 0644);
if (lock_fd < 0) {
(void) fprintf(stderr, MSG_LOCK_CREATE_ERR,
whoami, lock_file, strerror(errno));
exit(EXIT_CMD_FAILED);
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
retry:
if (fcntl(lock_fd, F_SETLKW, &lock) == -1) {
if (errno == EAGAIN || errno == EINTR)
goto retry;
(void) close(lock_fd);
(void) fprintf(stderr, MSG_LOCK_SET_ERR,
whoami, lock_file, strerror(errno));
exit(EXIT_CMD_FAILED);
}
}
static void
exit_lock()
{
struct flock lock;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if (fcntl(lock_fd, F_SETLK, &lock) == -1) {
(void) fprintf(stderr, MSG_LOCK_CLR_ERR,
whoami, lock_file, strerror(errno));
}
if (close(lock_fd) == -1) {
(void) fprintf(stderr, MSG_LOCK_CLOSE_ERR,
whoami, lock_file, strerror(errno));
}
}
static void
set_root_dir(char *dir)
{
root_dir = sc_strdup(dir);
}
static char *usage_msg[] = {
"\n"
"\tsyseventadm add [-R <rootdir>] [-v vendor] [-p publisher]\n"
"\t[-c class] [-s subclass] [-u username] path [args]\n"
"\n"
"\tsyseventadm remove [-R <rootdir>] [-v vendor] [-p publisher]\n"
"\t[-c class] [-s subclass] [-u username] [path [args]]\n"
"\n"
"\tsyseventadm list [-R <rootdir>] [-v vendor] [-p publisher]\n"
"\t[-c class] [-s subclass] [-u username] [path [args]]\n"
};
static int
usage()
{
char **msgs;
int i;
msgs = usage_msg;
for (i = 0; i < sizeof (usage_msg)/sizeof (char *); i++) {
(void) fputs(*msgs++, stderr);
}
return (EXIT_USAGE);
}
static int
add_cmd(void)
{
char fname[MAXPATHLEN+1];
int need_comma = 0;
int noptions = 0;
struct stat st;
FILE *fp;
str_t *line;
int i;
/*
* At least one of vendor/publisher/class must be specified.
* Subclass is only defined within the context of class.
* For add, path must also be specified.
*/
if (arg_vendor)
noptions++;
if (arg_publisher)
noptions++;
if (arg_class)
noptions++;
if (noptions == 0 || (arg_subclass && arg_class == NULL)) {
return (usage());
}
if (arg_path == NULL)
return (usage());
/*
* Generate the sysevent.conf file name
*/
(void) strcpy(fname, root_dir);
(void) strcat(fname, SYSEVENT_CONFIG_DIR);
(void) strcat(fname, "/");
if (arg_vendor) {
(void) strcat(fname, arg_vendor);
need_comma = 1;
}
if (arg_publisher) {
if (need_comma)
(void) strcat(fname, ",");
(void) strcat(fname, arg_publisher);
need_comma = 1;
}
if (arg_class) {
if (need_comma)
(void) strcat(fname, ",");
(void) strcat(fname, arg_class);
}
(void) strcat(fname, SYSEVENT_CONF_SUFFIX);
/*
* Prepare the line to be written to the sysevent.conf file
*/
line = initstr(128);
strcats(line, arg_class == NULL ? "-" : arg_class);
strcatc(line, ' ');
strcats(line, arg_subclass == NULL ? "-" : arg_subclass);
strcatc(line, ' ');
strcats(line, arg_vendor == NULL ? "-" : arg_vendor);
strcatc(line, ' ');
strcats(line, arg_publisher == NULL ? "-" : arg_publisher);
strcatc(line, ' ');
strcats(line, arg_username == NULL ? "-" : arg_username);
strcatc(line, ' ');
strcats(line, "- - ");
strcats(line, arg_path);
if (arg_nargs) {
for (i = 0; i < arg_nargs; i++) {
strcatc(line, ' ');
strcats(line, arg_args[i]);
}
}
if (stat(fname, &st) == -1) {
if (creat(fname, 0644) == -1) {
(void) fprintf(stderr, MSG_CANNOT_CREATE,
whoami, fname, strerror(errno));
freestr(line);
return (EXIT_CMD_FAILED);
}
}
fp = fopen(fname, "a");
if (fp == NULL) {
(void) fprintf(stderr, MSG_CANNOT_OPEN,
whoami, fname, strerror(errno));
freestr(line);
return (EXIT_CMD_FAILED);
}
(void) fprintf(fp, "%s\n", line->s_str);
freestr(line);
if (fclose(fp) == -1) {
(void) fprintf(stderr, MSG_CLOSE_ERROR,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
if (chmod(fname, 0444) == -1) {
(void) fprintf(stderr, MSG_CHMOD_ERROR,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
return (EXIT_OK);
}
static int
list_remove_cmd(int cmd)
{
struct dirent *dp;
DIR *dir;
char path[MAXPATHLEN+1];
char fname[MAXPATHLEN+1];
char *suffix;
char **dirlist = NULL;
int list_size = 0;
int list_alloc = 0;
char **p;
int rval;
int result;
/*
* For the remove cmd, at least one of vendor/publisher/class/username
* path must be specified. Subclass is only defined within the
* context of a class.
*/
if (cmd == CMD_REMOVE) {
int noptions = 0;
if (arg_vendor)
noptions++;
if (arg_publisher)
noptions++;
if (arg_class)
noptions++;
if (arg_username)
noptions++;
if (arg_path)
noptions++;
if (noptions == 0 || (arg_subclass && arg_class == NULL)) {
return (usage());
}
}
(void) strcpy(path, root_dir);
(void) strcat(path, SYSEVENT_CONFIG_DIR);
if ((dir = opendir(path)) == NULL) {
(void) fprintf(stderr, MSG_CANNOT_OPEN_DIR,
whoami, path, strerror(errno));
return (EXIT_CMD_FAILED);
}
while ((dp = readdir(dir)) != NULL) {
if (dp->d_name[0] == '.')
continue;
if ((strlen(dp->d_name) == 0) ||
(strcmp(dp->d_name, "lost+found") == 0))
continue;
suffix = strrchr(dp->d_name, ',');
if (suffix && strcmp(suffix, SYSEVENT_CONF_SUFFIX) == 0) {
(void) strcpy(fname, path);
(void) strcat(fname, "/");
(void) strcat(fname, dp->d_name);
dirlist = build_strlist(dirlist,
&list_size, &list_alloc, fname);
}
}
if (closedir(dir) == -1) {
(void) fprintf(stderr, MSG_CLOSE_DIR_ERROR,
whoami, path, strerror(errno));
return (EXIT_CMD_FAILED);
}
rval = EXIT_NO_MATCH;
if (dirlist) {
for (p = dirlist; *p != NULL; p++) {
switch (cmd) {
case CMD_LIST:
result = list_file(*p);
break;
case CMD_REMOVE:
result = remove_file(*p);
break;
}
if (rval == EXIT_NO_MATCH &&
result != EXIT_NO_MATCH)
rval = result;
}
}
return (rval);
}
static int
list_file(char *fname)
{
FILE *fp;
str_t *line;
serecord_t *sep;
int rval = EXIT_NO_MATCH;
fp = fopen(fname, "r");
if (fp == NULL) {
(void) fprintf(stderr, MSG_CANNOT_OPEN,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
for (;;) {
line = read_next_line(fp);
if (line == NULL)
break;
sep = parse_line(line);
if (sep != NULL) {
if (matches_serecord(sep)) {
print_serecord(stdout, sep);
rval = EXIT_OK;
}
free_serecord(sep);
}
freestr(line);
}
(void) fclose(fp);
return (rval);
}
static int
remove_file(char *fname)
{
FILE *fp;
FILE *tmp_fp;
str_t *line;
char *raw_line;
serecord_t *sep;
char tmp_name[MAXPATHLEN+1];
int is_empty = 1;
fp = fopen(fname, "r");
if (fp == NULL) {
(void) fprintf(stderr, MSG_CANNOT_OPEN,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
if (check_for_removes(fp) == 0) {
(void) fclose(fp);
return (EXIT_NO_MATCH);
}
rewind(fp);
(void) strcpy(tmp_name, root_dir);
(void) strcat(tmp_name, SYSEVENT_CONFIG_DIR);
(void) strcat(tmp_name, "/tmp.XXXXXX");
if (mktemp(tmp_name) == NULL) {
(void) fprintf(stderr, "unable to make tmp file name\n");
return (EXIT_CMD_FAILED);
}
if (creat(tmp_name, 0644) == -1) {
(void) fprintf(stderr, MSG_CANNOT_CREATE,
whoami, tmp_name, strerror(errno));
return (EXIT_CMD_FAILED);
}
tmp_fp = fopen(tmp_name, "a");
if (tmp_fp == NULL) {
(void) fprintf(stderr, MSG_CANNOT_OPEN,
whoami, tmp_name, strerror(errno));
(void) unlink(tmp_name);
(void) fclose(fp);
return (EXIT_CMD_FAILED);
}
for (;;) {
line = read_next_line(fp);
if (line == NULL)
break;
raw_line = sc_strdup(line->s_str);
sep = parse_line(line);
if (sep == NULL) {
(void) fputs(line->s_str, tmp_fp);
} else {
if (!matches_serecord(sep)) {
is_empty = 0;
(void) fprintf(tmp_fp, "%s\n", raw_line);
}
free_serecord(sep);
}
freestr(line);
sc_strfree(raw_line);
}
(void) fclose(fp);
if (fclose(tmp_fp) == -1) {
(void) fprintf(stderr, MSG_CLOSE_ERROR,
whoami, tmp_name, strerror(errno));
}
if (is_empty) {
if (unlink(tmp_name) == -1) {
(void) fprintf(stderr, MSG_CANNOT_UNLINK,
whoami, tmp_name, strerror(errno));
return (EXIT_CMD_FAILED);
}
if (unlink(fname) == -1) {
(void) fprintf(stderr, MSG_CANNOT_UNLINK,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
} else {
if (unlink(fname) == -1) {
(void) fprintf(stderr, MSG_CANNOT_UNLINK,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
if (rename(tmp_name, fname) == -1) {
(void) fprintf(stderr, MSG_CANNOT_RENAME,
whoami, tmp_name, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
if (chmod(fname, 0444) == -1) {
(void) fprintf(stderr, MSG_CHMOD_ERROR,
whoami, fname, strerror(errno));
return (EXIT_CMD_FAILED);
}
}
return (EXIT_OK);
}
static int
check_for_removes(FILE *fp)
{
str_t *line;
serecord_t *sep;
for (;;) {
line = read_next_line(fp);
if (line == NULL)
break;
sep = parse_line(line);
if (sep != NULL) {
if (matches_serecord(sep)) {
free_serecord(sep);
freestr(line);
return (1);
}
free_serecord(sep);
}
freestr(line);
}
return (0);
}
static int
matches_serecord(serecord_t *sep)
{
char *line;
char *lp;
char *token;
int i;
if (arg_vendor &&
strcmp(arg_vendor, sep->se_vendor) != 0) {
return (0);
}
if (arg_publisher &&
strcmp(arg_publisher, sep->se_publisher) != 0) {
return (0);
}
if (arg_class &&
strcmp(arg_class, sep->se_class) != 0) {
return (0);
}
if (arg_subclass &&
strcmp(arg_subclass, sep->se_subclass) != 0) {
return (0);
}
if (arg_username &&
strcmp(arg_username, sep->se_user) != 0) {
return (0);
}
if (arg_path &&
strcmp(arg_path, sep->se_path) != 0) {
return (0);
}
if (arg_nargs > 0) {
line = sc_strdup(sep->se_args);
lp = line;
for (i = 0; i < arg_nargs; i++) {
token = next_field(&lp);
if (strcmp(arg_args[i], token) != 0) {
sc_strfree(line);
return (0);
}
}
sc_strfree(line);
}
return (1);
}
static void
print_serecord(FILE *fp, serecord_t *sep)
{
str_t *line;
line = initstr(128);
if (strcmp(sep->se_vendor, "-") != 0) {
strcats(line, "vendor=");
strcats(line, sep->se_vendor);
strcats(line, " ");
}
if (strcmp(sep->se_publisher, "-") != 0) {
strcats(line, "publisher=");
strcats(line, sep->se_publisher);
strcats(line, " ");
}
if (strcmp(sep->se_class, "-") != 0) {
strcats(line, "class=");
strcats(line, sep->se_class);
strcats(line, " ");
if (strcmp(sep->se_subclass, "-") != 0) {
strcats(line, "subclass=");
strcats(line, sep->se_subclass);
strcats(line, " ");
}
}
if (strcmp(sep->se_user, "-") != 0) {
strcats(line, "username=");
strcats(line, sep->se_user);
strcats(line, " ");
}
strcats(line, sep->se_path);
if (sep->se_args) {
strcats(line, " ");
strcats(line, sep->se_args);
}
strcats(line, "\n");
(void) fputs(line->s_str, fp);
freestr(line);
}
static int
restart_cmd(void)
{
if (system("pkill -HUP syseventd") == -1) {
(void) fprintf(stderr, MSG_RESTART_FAILED,
whoami, strerror(errno));
return (EXIT_CMD_FAILED);
}
return (EXIT_OK);
}
static str_t *
read_next_line(FILE *fp)
{
char *lp;
str_t *line;
line = initstr(128);
lp = fstrgets(line, fp);
if (lp == NULL) {
freestr(line);
return (NULL);
}
*(lp + strlen(lp)-1) = 0;
return (line);
}
static serecord_t *
parse_line(str_t *line)
{
char *lp;
char *vendor, *publisher;
char *class, *subclass;
char *user;
char *reserved1, *reserved2;
char *path, *args;
serecord_t *sep;
lp = line->s_str;
if (*lp == 0 || *lp == '#') {
return (NULL);
}
if ((class = next_field(&lp)) != NULL) {
subclass = next_field(&lp);
if (lp == NULL)
return (NULL);
vendor = next_field(&lp);
if (lp == NULL)
return (NULL);
publisher = next_field(&lp);
if (lp == NULL)
return (NULL);
user = next_field(&lp);
if (lp == NULL)
return (NULL);
reserved1 = next_field(&lp);
if (lp == NULL)
return (NULL);
reserved2 = next_field(&lp);
if (lp == NULL)
return (NULL);
path = next_field(&lp);
if (lp == NULL)
return (NULL);
args = skip_spaces(&lp);
}
sep = sc_malloc(sizeof (serecord_t));
sep->se_vendor = sc_strdup(vendor);
sep->se_publisher = sc_strdup(publisher);
sep->se_class = sc_strdup(class);
sep->se_subclass = sc_strdup(subclass);
sep->se_user = sc_strdup(user);
sep->se_reserved1 = sc_strdup(reserved1);
sep->se_reserved2 = sc_strdup(reserved2);
sep->se_path = sc_strdup(path);
sep->se_args = (args == NULL) ? NULL : sc_strdup(args);
return (sep);
}
static void
free_serecord(serecord_t *sep)
{
sc_strfree(sep->se_vendor);
sc_strfree(sep->se_publisher);
sc_strfree(sep->se_class);
sc_strfree(sep->se_subclass);
sc_strfree(sep->se_user);
sc_strfree(sep->se_reserved1);
sc_strfree(sep->se_reserved2);
sc_strfree(sep->se_path);
sc_strfree(sep->se_args);
sc_free(sep, sizeof (serecord_t));
}
/*
* skip_spaces() - skip to next non-space character
*/
static char *
skip_spaces(char **cpp)
{
char *cp = *cpp;
while (*cp == ' ' || *cp == '\t')
cp++;
if (*cp == 0) {
*cpp = 0;
return (NULL);
}
return (cp);
}
/*
* Get next white-space separated field.
* next_field() will not check any characters on next line.
* Each entry is composed of a single line.
*/
static char *
next_field(char **cpp)
{
char *cp = *cpp;
char *start;
while (*cp == ' ' || *cp == '\t')
cp++;
if (*cp == 0) {
*cpp = 0;
return (NULL);
}
start = cp;
while (*cp && *cp != ' ' && *cp != '\t')
cp++;
if (*cp != 0)
*cp++ = 0;
*cpp = cp;
return (start);
}
/*
* The following functions are simple wrappers/equivalents
* for malloc, realloc, free, strdup and a special free
* for strdup.
*/
static void *
sc_malloc(size_t n)
{
void *p;
p = malloc(n);
if (p == NULL) {
no_mem_err();
}
return (p);
}
/*ARGSUSED*/
static void *
sc_realloc(void *p, size_t current, size_t n)
{
p = realloc(p, n);
if (p == NULL) {
no_mem_err();
}
return (p);
}
/*ARGSUSED*/
static void
sc_free(void *p, size_t n)
{
free(p);
}
static char *
sc_strdup(char *cp)
{
char *new;
new = malloc((unsigned)(strlen(cp) + 1));
if (new == NULL) {
no_mem_err();
}
(void) strcpy(new, cp);
return (new);
}
static void
sc_strfree(char *s)
{
if (s)
free(s);
}
/*
* The following functions provide some simple dynamic string
* capability. This module has no hard-coded maximum string
* lengths and should be able to parse and generate arbitrarily
* long strings, macro expansion and command lines.
*
* Each string must be explicitly allocated and freed.
*/
/*
* Allocate a dynamic string, with a hint to indicate how
* much memory to dynamically add to the string as it grows
* beyond its existing bounds, so as to avoid excessive
* reallocs as a string grows.
*/
static str_t *
initstr(int hint)
{
str_t *str;
str = sc_malloc(sizeof (str_t));
str->s_str = NULL;
str->s_len = 0;
str->s_alloc = 0;
str->s_hint = hint;
return (str);
}
/*
* Free a dynamically-allocated string
*/
static void
freestr(str_t *str)
{
if (str->s_str) {
sc_free(str->s_str, str->s_alloc);
}
sc_free(str, sizeof (str_t));
}
/*
* Reset a dynamically-allocated string, allows reuse
* rather than freeing the old and allocating a new one.
*/
static void
resetstr(str_t *str)
{
str->s_len = 0;
}
/*
* Concatenate a (simple) string onto a dynamically-allocated string
*/
static void
strcats(str_t *str, char *s)
{
char *new_str;
int len = str->s_len + strlen(s) + 1;
if (str->s_alloc < len) {
new_str = (str->s_str == NULL) ? sc_malloc(len+str->s_hint) :
sc_realloc(str->s_str, str->s_alloc, len+str->s_hint);
str->s_str = new_str;
str->s_alloc = len + str->s_hint;
}
(void) strcpy(str->s_str + str->s_len, s);
str->s_len = len - 1;
}
/*
* Concatenate a character onto a dynamically-allocated string
*/
static void
strcatc(str_t *str, int c)
{
char *new_str;
int len = str->s_len + 2;
if (str->s_alloc < len) {
new_str = (str->s_str == NULL) ? sc_malloc(len+str->s_hint) :
sc_realloc(str->s_str, str->s_alloc, len+str->s_hint);
str->s_str = new_str;
str->s_alloc = len + str->s_hint;
}
*(str->s_str + str->s_len) = (char)c;
*(str->s_str + str->s_len + 1) = 0;
str->s_len++;
}
/*
* fgets() equivalent using a dynamically-allocated string
*/
static char *
fstrgets(str_t *line, FILE *fp)
{
int c;
resetstr(line);
while ((c = fgetc(fp)) != EOF) {
strcatc(line, c);
if (c == '\n')
break;
}
if (line->s_len == 0)
return (NULL);
return (line->s_str);
}
#define INITIAL_LISTSIZE 4
#define INCR_LISTSIZE 4
static char **
build_strlist(
char **argvlist,
int *size,
int *alloc,
char *str)
{
int n;
if (*size + 1 > *alloc) {
if (*alloc == 0) {
*alloc = INITIAL_LISTSIZE;
n = sizeof (char *) * (*alloc + 1);
argvlist = (char **)malloc(n);
if (argvlist == NULL)
no_mem_err();
} else {
*alloc += INCR_LISTSIZE;
n = sizeof (char *) * (*alloc + 1);
argvlist = (char **)realloc(argvlist, n);
if (argvlist == NULL)
no_mem_err();
}
}
argvlist[*size] = strdup(str);
*size += 1;
argvlist[*size] = NULL;
return (argvlist);
}
static void
no_mem_err()
{
(void) fprintf(stderr, MSG_NO_MEM, whoami);
exit_lock();
exit(EXIT_NO_MEM);
/*NOTREACHED*/
}