xref: /titanic_52/usr/src/cmd/syseventadm/syseventadm.c (revision c6fc6ddd482fa5c17788a38bd238258f2c22597c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  *	syseventadm - command to administer the sysevent.conf registry
28  *		    - administers the general purpose event framework
29  *
30  *	The current implementation of the registry using files in
31  *	/etc/sysevent/config, files are named as event specifications
32  *	are added with the combination of the vendor, publisher, event
33  *	class and subclass strings:
34  *
35  *	[<vendor>,][<publisher>,][<class>,]sysevent.conf
36  *
37  */
38 #include <stdio.h>
39 #include <ctype.h>
40 #include <sys/types.h>
41 #include <dirent.h>
42 #include <stdarg.h>
43 #include <stddef.h>
44 #include <stdlib.h>
45 #include <dlfcn.h>
46 #include <door.h>
47 #include <errno.h>
48 #include <fcntl.h>
49 #include <signal.h>
50 #include <strings.h>
51 #include <unistd.h>
52 #include <synch.h>
53 #include <syslog.h>
54 #include <thread.h>
55 #include <limits.h>
56 #include <locale.h>
57 #include <assert.h>
58 #include <libsysevent.h>
59 #include <zone.h>
60 #include <sys/sysevent_impl.h>
61 #include <sys/modctl.h>
62 #include <sys/param.h>
63 #include <sys/stat.h>
64 #include <sys/systeminfo.h>
65 #include <sys/wait.h>
66 
67 #include "syseventadm.h"
68 #include "syseventadm_msg.h"
69 
70 #ifndef DEBUG
71 #undef	assert
72 #define	assert(EX) ((void)0)
73 #endif
74 
75 static char	*whoami		= NULL;
76 static char	*root_dir	= "";
77 
78 static char	*arg_vendor	= NULL;
79 static char	*arg_publisher	= NULL;
80 static char	*arg_class	= NULL;
81 static char	*arg_subclass	= NULL;
82 static char	*arg_username	= NULL;
83 static char	*arg_path	= NULL;
84 static int	arg_nargs	= 0;
85 static char	**arg_args	= NULL;
86 
87 static	int	lock_fd;
88 static	char 	lock_file[PATH_MAX + 1];
89 
90 extern char	*optarg;
91 extern int	optind;
92 
93 static int
94 usage_gen()
95 {
96 	(void) fprintf(stderr, MSG_USAGE_INTRO);
97 	(void) fprintf(stderr, MSG_USAGE_OPTIONS);
98 	(void) fprintf(stderr, "\n"
99 	    "\tsyseventadm add ...\n"
100 	    "\tsyseventadm remove ...\n"
101 	    "\tsyseventadm list ...\n"
102 	    "\tsyseventadm restart\n"
103 	    "\tsyseventadm help\n");
104 
105 	return (EXIT_USAGE);
106 }
107 
108 static int
109 serve_syseventdotconf(int argc, char **argv, char *cmd)
110 {
111 	int	c;
112 	int	rval;
113 
114 	while ((c = getopt(argc, argv, "R:v:p:c:s:u:")) != EOF) {
115 		switch (c) {
116 		case 'R':
117 			/*
118 			 * Alternate root path for install, etc.
119 			 */
120 			set_root_dir(optarg);
121 			break;
122 		case 'v':
123 			arg_vendor = optarg;
124 			break;
125 		case 'p':
126 			arg_publisher = optarg;
127 			break;
128 		case 'c':
129 			arg_class = optarg;
130 			break;
131 		case 's':
132 			arg_subclass = optarg;
133 			break;
134 		case 'u':
135 			arg_username = optarg;
136 			break;
137 		default:
138 			return (usage());
139 		}
140 	}
141 
142 	if (optind < argc) {
143 		arg_path = argv[optind++];
144 		if (optind < argc) {
145 			arg_nargs = argc - optind;
146 			arg_args = argv + optind;
147 		}
148 	}
149 
150 	enter_lock(root_dir);
151 
152 	if (strcmp(cmd, "add") == 0) {
153 		rval = add_cmd();
154 	} else if (strcmp(cmd, "list") == 0) {
155 		rval = list_remove_cmd(CMD_LIST);
156 	} else if (strcmp(cmd, "remove") == 0) {
157 		rval = list_remove_cmd(CMD_REMOVE);
158 	} else if (strcmp(cmd, "restart") == 0) {
159 		rval = restart_cmd();
160 	} else {
161 		rval = usage();
162 	}
163 
164 	exit_lock();
165 
166 	return (rval);
167 }
168 
169 
170 int
171 main(int argc, char **argv)
172 {
173 	char	*cmd;
174 	int	rval;
175 
176 
177 	(void) setlocale(LC_ALL, "");
178 	(void) textdomain(TEXT_DOMAIN);
179 
180 	if ((whoami = strrchr(argv[0], '/')) == NULL) {
181 		whoami = argv[0];
182 	} else {
183 		whoami++;
184 	}
185 
186 	if (argc == 1) {
187 		return (usage_gen());
188 	}
189 
190 	cmd = argv[optind++];
191 
192 	/* Allow non-privileged users to get the help messages */
193 	if (strcmp(cmd, "help") == 0) {
194 		rval = usage_gen();
195 		return (rval);
196 	}
197 
198 	if (getuid() != 0) {
199 		(void) fprintf(stderr, MSG_NOT_ROOT, whoami);
200 		exit(EXIT_PERM);
201 	}
202 
203 	if (strcmp(cmd, "evc") != 0 && getzoneid() != GLOBAL_ZONEID) {
204 		(void) fprintf(stderr, MSG_NOT_GLOBAL, whoami);
205 		exit(EXIT_PERM);
206 	}
207 
208 	if (strcmp(cmd, "add") == 0 ||
209 	    strcmp(cmd, "remove") == 0 || strcmp(cmd, "list") == 0 ||
210 	    strcmp(cmd, "restart") == 0) {
211 		rval = serve_syseventdotconf(argc, argv, cmd);
212 	} else {
213 		rval = usage_gen();
214 	}
215 	return (rval);
216 }
217 
218 
219 static void
220 enter_lock(char *root_dir)
221 {
222 	struct flock	lock;
223 
224 	if (snprintf(lock_file, sizeof (lock_file), "%s%s", root_dir,
225 	    LOCK_FILENAME) >= sizeof (lock_file)) {
226 		(void) fprintf(stderr, MSG_LOCK_PATH_ERR, whoami, lock_file);
227 		exit(EXIT_CMD_FAILED);
228 	}
229 	lock_fd = open(lock_file, O_CREAT|O_RDWR, 0644);
230 	if (lock_fd < 0) {
231 		(void) fprintf(stderr, MSG_LOCK_CREATE_ERR,
232 			whoami, lock_file, strerror(errno));
233 		exit(EXIT_CMD_FAILED);
234 	}
235 
236 	lock.l_type = F_WRLCK;
237 	lock.l_whence = SEEK_SET;
238 	lock.l_start = 0;
239 	lock.l_len = 0;
240 
241 retry:
242 	if (fcntl(lock_fd, F_SETLKW, &lock) == -1) {
243 		if (errno == EAGAIN || errno == EINTR)
244 			goto retry;
245 		(void) close(lock_fd);
246 		(void) fprintf(stderr, MSG_LOCK_SET_ERR,
247 			whoami, lock_file, strerror(errno));
248 		exit(EXIT_CMD_FAILED);
249 	}
250 }
251 
252 
253 static void
254 exit_lock()
255 {
256 	struct flock	lock;
257 
258 	lock.l_type = F_UNLCK;
259 	lock.l_whence = SEEK_SET;
260 	lock.l_start = 0;
261 	lock.l_len = 0;
262 
263 	if (fcntl(lock_fd, F_SETLK, &lock) == -1) {
264 		(void) fprintf(stderr, MSG_LOCK_CLR_ERR,
265 			whoami, lock_file, strerror(errno));
266 	}
267 
268 	if (close(lock_fd) == -1) {
269 		(void) fprintf(stderr, MSG_LOCK_CLOSE_ERR,
270 			whoami, lock_file, strerror(errno));
271 	}
272 }
273 
274 
275 static void
276 set_root_dir(char *dir)
277 {
278 	root_dir = sc_strdup(dir);
279 }
280 
281 
282 static char *usage_msg[] = {
283 	"\n"
284 	"\tsyseventadm add [-R <rootdir>] [-v vendor] [-p publisher]\n"
285 	"\t[-c class] [-s subclass] [-u username] path [args]\n"
286 	"\n"
287 	"\tsyseventadm remove [-R <rootdir>] [-v vendor] [-p publisher]\n"
288 	"\t[-c class] [-s subclass] [-u username] [path [args]]\n"
289 	"\n"
290 	"\tsyseventadm list [-R <rootdir>] [-v vendor] [-p publisher]\n"
291 	"\t[-c class] [-s subclass] [-u username] [path [args]]\n"
292 };
293 
294 static int
295 usage()
296 {
297 	char	**msgs;
298 	int	i;
299 
300 	msgs = usage_msg;
301 	for (i = 0; i < sizeof (usage_msg)/sizeof (char *); i++) {
302 		(void) fputs(*msgs++, stderr);
303 	}
304 
305 	return (EXIT_USAGE);
306 }
307 
308 
309 static int
310 add_cmd(void)
311 {
312 	char	fname[MAXPATHLEN+1];
313 	int	need_comma = 0;
314 	int	noptions = 0;
315 	struct stat st;
316 	FILE	*fp;
317 	str_t	*line;
318 	int	i;
319 
320 	/*
321 	 * At least one of vendor/publisher/class must be specified.
322 	 * Subclass is only defined within the context of class.
323 	 * For add, path must also be specified.
324 	 */
325 	if (arg_vendor)
326 		noptions++;
327 	if (arg_publisher)
328 		noptions++;
329 	if (arg_class)
330 		noptions++;
331 
332 	if (noptions == 0 || (arg_subclass && arg_class == NULL)) {
333 		return (usage());
334 	}
335 
336 	if (arg_path == NULL)
337 		return (usage());
338 
339 	/*
340 	 * Generate the sysevent.conf file name
341 	 */
342 	(void) strcpy(fname, root_dir);
343 	(void) strcat(fname, SYSEVENT_CONFIG_DIR);
344 	(void) strcat(fname, "/");
345 
346 	if (arg_vendor) {
347 		(void) strcat(fname, arg_vendor);
348 		need_comma = 1;
349 	}
350 	if (arg_publisher) {
351 		if (need_comma)
352 			(void) strcat(fname, ",");
353 		(void) strcat(fname, arg_publisher);
354 		need_comma = 1;
355 	}
356 	if (arg_class) {
357 		if (need_comma)
358 			(void) strcat(fname, ",");
359 		(void) strcat(fname, arg_class);
360 	}
361 	(void) strcat(fname, SYSEVENT_CONF_SUFFIX);
362 
363 	/*
364 	 * Prepare the line to be written to the sysevent.conf file
365 	 */
366 	line = initstr(128);
367 
368 	strcats(line, arg_class == NULL ? "-" : arg_class);
369 	strcatc(line, ' ');
370 
371 	strcats(line, arg_subclass == NULL ? "-" : arg_subclass);
372 	strcatc(line, ' ');
373 
374 	strcats(line, arg_vendor == NULL ? "-" : arg_vendor);
375 	strcatc(line, ' ');
376 
377 	strcats(line, arg_publisher == NULL ? "-" : arg_publisher);
378 	strcatc(line, ' ');
379 
380 	strcats(line, arg_username == NULL ? "-" : arg_username);
381 	strcatc(line, ' ');
382 
383 	strcats(line, "- - ");
384 	strcats(line, arg_path);
385 
386 	if (arg_nargs) {
387 		for (i = 0; i < arg_nargs; i++) {
388 			strcatc(line, ' ');
389 			strcats(line, arg_args[i]);
390 		}
391 	}
392 
393 	if (stat(fname, &st) == -1) {
394 		if (creat(fname, 0644) == -1) {
395 			(void) fprintf(stderr, MSG_CANNOT_CREATE,
396 				whoami, fname, strerror(errno));
397 			freestr(line);
398 			return (EXIT_CMD_FAILED);
399 		}
400 	}
401 
402 	fp = fopen(fname, "a");
403 	if (fp == NULL) {
404 		(void) fprintf(stderr, MSG_CANNOT_OPEN,
405 			whoami, fname, strerror(errno));
406 		freestr(line);
407 		return (EXIT_CMD_FAILED);
408 	}
409 
410 	(void) fprintf(fp, "%s\n", line->s_str);
411 	freestr(line);
412 
413 	if (fclose(fp) == -1) {
414 		(void) fprintf(stderr, MSG_CLOSE_ERROR,
415 			whoami, fname, strerror(errno));
416 		return (EXIT_CMD_FAILED);
417 	}
418 
419 	if (chmod(fname, 0444) == -1) {
420 		(void) fprintf(stderr, MSG_CHMOD_ERROR,
421 			whoami, fname, strerror(errno));
422 		return (EXIT_CMD_FAILED);
423 	}
424 	return (EXIT_OK);
425 }
426 
427 
428 static int
429 list_remove_cmd(int cmd)
430 {
431 	struct dirent	*dp;
432 	DIR		*dir;
433 	char		path[MAXPATHLEN+1];
434 	char		fname[MAXPATHLEN+1];
435 	char		*suffix;
436 	char		**dirlist = NULL;
437 	int		list_size = 0;
438 	int		list_alloc = 0;
439 	char		**p;
440 	int		rval;
441 	int		result;
442 
443 	/*
444 	 * For the remove cmd, at least one of vendor/publisher/class/username
445 	 * path must be specified.  Subclass is only defined within the
446 	 * context of a class.
447 	 */
448 	if (cmd == CMD_REMOVE) {
449 		int	noptions = 0;
450 		if (arg_vendor)
451 			noptions++;
452 		if (arg_publisher)
453 			noptions++;
454 		if (arg_class)
455 			noptions++;
456 		if (arg_username)
457 			noptions++;
458 		if (arg_path)
459 			noptions++;
460 		if (noptions == 0 || (arg_subclass && arg_class == NULL)) {
461 			return (usage());
462 		}
463 	}
464 
465 	(void) strcpy(path, root_dir);
466 	(void) strcat(path, SYSEVENT_CONFIG_DIR);
467 
468 	if ((dir = opendir(path)) == NULL) {
469 		(void) fprintf(stderr, MSG_CANNOT_OPEN_DIR,
470 			whoami, path, strerror(errno));
471 		return (EXIT_CMD_FAILED);
472 	}
473 
474 	while ((dp = readdir(dir)) != NULL) {
475 		if (dp->d_name[0] == '.')
476 			continue;
477 		if ((strlen(dp->d_name) == 0) ||
478 		    (strcmp(dp->d_name, "lost+found") == 0))
479 			continue;
480 		suffix = strrchr(dp->d_name, ',');
481 		if (suffix && strcmp(suffix, SYSEVENT_CONF_SUFFIX) == 0) {
482 			(void) strcpy(fname, path);
483 			(void) strcat(fname, "/");
484 			(void) strcat(fname, dp->d_name);
485 			dirlist = build_strlist(dirlist,
486 				&list_size, &list_alloc, fname);
487 		}
488 	}
489 
490 	if (closedir(dir) == -1) {
491 		(void) fprintf(stderr, MSG_CLOSE_DIR_ERROR,
492 			whoami, path, strerror(errno));
493 		return (EXIT_CMD_FAILED);
494 	}
495 
496 	rval = EXIT_NO_MATCH;
497 	if (dirlist) {
498 		for (p = dirlist; *p != NULL; p++) {
499 			switch (cmd) {
500 			case CMD_LIST:
501 				result = list_file(*p);
502 				break;
503 			case CMD_REMOVE:
504 				result = remove_file(*p);
505 				break;
506 			}
507 			if (rval == EXIT_NO_MATCH &&
508 			    result != EXIT_NO_MATCH)
509 				rval = result;
510 		}
511 	}
512 	return (rval);
513 }
514 
515 
516 static int
517 list_file(char *fname)
518 {
519 	FILE		*fp;
520 	str_t		*line;
521 	serecord_t	*sep;
522 	int		rval = EXIT_NO_MATCH;
523 
524 	fp = fopen(fname, "r");
525 	if (fp == NULL) {
526 		(void) fprintf(stderr, MSG_CANNOT_OPEN,
527 			whoami, fname, strerror(errno));
528 		return (EXIT_CMD_FAILED);
529 	}
530 	for (;;) {
531 		line = read_next_line(fp);
532 		if (line == NULL)
533 			break;
534 		sep = parse_line(line);
535 		if (sep != NULL) {
536 			if (matches_serecord(sep)) {
537 				print_serecord(stdout, sep);
538 				rval = EXIT_OK;
539 			}
540 			free_serecord(sep);
541 		}
542 		freestr(line);
543 	}
544 	(void) fclose(fp);
545 
546 	return (rval);
547 }
548 
549 
550 static int
551 remove_file(char *fname)
552 {
553 	FILE		*fp;
554 	FILE		*tmp_fp;
555 	str_t		*line;
556 	char		*raw_line;
557 	serecord_t	*sep;
558 	char		tmp_name[MAXPATHLEN+1];
559 	int		is_empty = 1;
560 
561 	fp = fopen(fname, "r");
562 	if (fp == NULL) {
563 		(void) fprintf(stderr, MSG_CANNOT_OPEN,
564 			whoami, fname, strerror(errno));
565 		return (EXIT_CMD_FAILED);
566 	}
567 
568 	if (check_for_removes(fp) == 0) {
569 		(void) fclose(fp);
570 		return (EXIT_NO_MATCH);
571 	}
572 
573 	rewind(fp);
574 
575 	(void) strcpy(tmp_name, root_dir);
576 	(void) strcat(tmp_name, SYSEVENT_CONFIG_DIR);
577 	(void) strcat(tmp_name, "/tmp.XXXXXX");
578 	if (mktemp(tmp_name) == NULL) {
579 		(void) fprintf(stderr, "unable to make tmp file name\n");
580 		return (EXIT_CMD_FAILED);
581 	}
582 
583 	if (creat(tmp_name, 0644) == -1) {
584 		(void) fprintf(stderr, MSG_CANNOT_CREATE,
585 			whoami, tmp_name, strerror(errno));
586 		return (EXIT_CMD_FAILED);
587 	}
588 
589 	tmp_fp = fopen(tmp_name, "a");
590 	if (tmp_fp == NULL) {
591 		(void) fprintf(stderr, MSG_CANNOT_OPEN,
592 			whoami, tmp_name, strerror(errno));
593 		(void) unlink(tmp_name);
594 		(void) fclose(fp);
595 		return (EXIT_CMD_FAILED);
596 	}
597 
598 	for (;;) {
599 		line = read_next_line(fp);
600 		if (line == NULL)
601 			break;
602 		raw_line = sc_strdup(line->s_str);
603 		sep = parse_line(line);
604 		if (sep == NULL) {
605 			(void) fputs(line->s_str, tmp_fp);
606 		} else {
607 			if (!matches_serecord(sep)) {
608 				is_empty = 0;
609 				(void) fprintf(tmp_fp, "%s\n", raw_line);
610 			}
611 			free_serecord(sep);
612 		}
613 		freestr(line);
614 		sc_strfree(raw_line);
615 	}
616 	(void) fclose(fp);
617 	if (fclose(tmp_fp) == -1) {
618 		(void) fprintf(stderr, MSG_CLOSE_ERROR,
619 			whoami, tmp_name, strerror(errno));
620 	}
621 
622 	if (is_empty) {
623 		if (unlink(tmp_name) == -1) {
624 			(void) fprintf(stderr, MSG_CANNOT_UNLINK,
625 				whoami, tmp_name, strerror(errno));
626 			return (EXIT_CMD_FAILED);
627 		}
628 		if (unlink(fname) == -1) {
629 			(void) fprintf(stderr, MSG_CANNOT_UNLINK,
630 				whoami, fname, strerror(errno));
631 			return (EXIT_CMD_FAILED);
632 		}
633 	} else {
634 		if (unlink(fname) == -1) {
635 			(void) fprintf(stderr, MSG_CANNOT_UNLINK,
636 				whoami, fname, strerror(errno));
637 			return (EXIT_CMD_FAILED);
638 		}
639 		if (rename(tmp_name, fname) == -1) {
640 			(void) fprintf(stderr, MSG_CANNOT_RENAME,
641 				whoami, tmp_name, fname, strerror(errno));
642 			return (EXIT_CMD_FAILED);
643 		}
644 		if (chmod(fname, 0444) == -1) {
645 			(void) fprintf(stderr, MSG_CHMOD_ERROR,
646 				whoami, fname, strerror(errno));
647 			return (EXIT_CMD_FAILED);
648 		}
649 	}
650 
651 	return (EXIT_OK);
652 }
653 
654 static int
655 check_for_removes(FILE *fp)
656 {
657 	str_t		*line;
658 	serecord_t	*sep;
659 
660 	for (;;) {
661 		line = read_next_line(fp);
662 		if (line == NULL)
663 			break;
664 		sep = parse_line(line);
665 		if (sep != NULL) {
666 			if (matches_serecord(sep)) {
667 				free_serecord(sep);
668 				freestr(line);
669 				return (1);
670 			}
671 			free_serecord(sep);
672 		}
673 		freestr(line);
674 	}
675 
676 	return (0);
677 }
678 
679 
680 static int
681 matches_serecord(serecord_t *sep)
682 {
683 	char	*line;
684 	char	*lp;
685 	char	*token;
686 	int	i;
687 
688 	if (arg_vendor &&
689 	    strcmp(arg_vendor, sep->se_vendor) != 0) {
690 		return (0);
691 	}
692 
693 	if (arg_publisher &&
694 	    strcmp(arg_publisher, sep->se_publisher) != 0) {
695 		return (0);
696 	}
697 
698 	if (arg_class &&
699 	    strcmp(arg_class, sep->se_class) != 0) {
700 		return (0);
701 	}
702 
703 	if (arg_subclass &&
704 	    strcmp(arg_subclass, sep->se_subclass) != 0) {
705 		return (0);
706 	}
707 
708 	if (arg_username &&
709 	    strcmp(arg_username, sep->se_user) != 0) {
710 		return (0);
711 	}
712 
713 	if (arg_path &&
714 	    strcmp(arg_path, sep->se_path) != 0) {
715 		return (0);
716 	}
717 
718 	if (arg_nargs > 0) {
719 		line = sc_strdup(sep->se_args);
720 		lp = line;
721 		for (i = 0; i < arg_nargs; i++) {
722 			token = next_field(&lp);
723 			if (strcmp(arg_args[i], token) != 0) {
724 				sc_strfree(line);
725 				return (0);
726 			}
727 		}
728 		sc_strfree(line);
729 	}
730 
731 	return (1);
732 }
733 
734 static void
735 print_serecord(FILE *fp, serecord_t *sep)
736 {
737 	str_t	*line;
738 
739 	line = initstr(128);
740 
741 	if (strcmp(sep->se_vendor, "-") != 0) {
742 		strcats(line, "vendor=");
743 		strcats(line, sep->se_vendor);
744 		strcats(line, " ");
745 	}
746 	if (strcmp(sep->se_publisher, "-") != 0) {
747 		strcats(line, "publisher=");
748 		strcats(line, sep->se_publisher);
749 		strcats(line, " ");
750 	}
751 	if (strcmp(sep->se_class, "-") != 0) {
752 		strcats(line, "class=");
753 		strcats(line, sep->se_class);
754 		strcats(line, " ");
755 		if (strcmp(sep->se_subclass, "-") != 0) {
756 			strcats(line, "subclass=");
757 			strcats(line, sep->se_subclass);
758 			strcats(line, " ");
759 		}
760 	}
761 	if (strcmp(sep->se_user, "-") != 0) {
762 		strcats(line, "username=");
763 		strcats(line, sep->se_user);
764 		strcats(line, " ");
765 	}
766 	strcats(line, sep->se_path);
767 	if (sep->se_args) {
768 		strcats(line, " ");
769 		strcats(line, sep->se_args);
770 	}
771 	strcats(line, "\n");
772 
773 	(void) fputs(line->s_str, fp);
774 	freestr(line);
775 }
776 
777 
778 
779 
780 static int
781 restart_cmd(void)
782 {
783 	if (system("pkill -HUP syseventd") == -1) {
784 		(void) fprintf(stderr, MSG_RESTART_FAILED,
785 			whoami, strerror(errno));
786 		return (EXIT_CMD_FAILED);
787 	}
788 	return (EXIT_OK);
789 }
790 
791 
792 static str_t *
793 read_next_line(FILE *fp)
794 {
795 	char	*lp;
796 	str_t	*line;
797 
798 	line = initstr(128);
799 
800 	lp = fstrgets(line, fp);
801 	if (lp == NULL) {
802 		freestr(line);
803 		return (NULL);
804 	}
805 
806 	*(lp + strlen(lp)-1) = 0;
807 	return (line);
808 }
809 
810 
811 static serecord_t *
812 parse_line(str_t *line)
813 {
814 	char	*lp;
815 	char	*vendor, *publisher;
816 	char	*class, *subclass;
817 	char	*user;
818 	char	*reserved1, *reserved2;
819 	char	*path, *args;
820 	serecord_t *sep;
821 
822 	lp = line->s_str;
823 	if (*lp == 0 || *lp == '#') {
824 		return (NULL);
825 	}
826 
827 	if ((class = next_field(&lp)) != NULL) {
828 		subclass = next_field(&lp);
829 		if (lp == NULL)
830 			return (NULL);
831 		vendor = next_field(&lp);
832 		if (lp == NULL)
833 			return (NULL);
834 		publisher = next_field(&lp);
835 		if (lp == NULL)
836 			return (NULL);
837 		user = next_field(&lp);
838 		if (lp == NULL)
839 			return (NULL);
840 		reserved1 = next_field(&lp);
841 		if (lp == NULL)
842 			return (NULL);
843 		reserved2 = next_field(&lp);
844 		if (lp == NULL)
845 			return (NULL);
846 		path = next_field(&lp);
847 		if (lp == NULL)
848 			return (NULL);
849 		args = skip_spaces(&lp);
850 	}
851 
852 	sep = sc_malloc(sizeof (serecord_t));
853 
854 	sep->se_vendor = sc_strdup(vendor);
855 	sep->se_publisher = sc_strdup(publisher);
856 	sep->se_class = sc_strdup(class);
857 	sep->se_subclass = sc_strdup(subclass);
858 	sep->se_user = sc_strdup(user);
859 	sep->se_reserved1 = sc_strdup(reserved1);
860 	sep->se_reserved2 = sc_strdup(reserved2);
861 	sep->se_path = sc_strdup(path);
862 	sep->se_args = (args == NULL) ? NULL : sc_strdup(args);
863 
864 	return (sep);
865 }
866 
867 
868 static void
869 free_serecord(serecord_t *sep)
870 {
871 	sc_strfree(sep->se_vendor);
872 	sc_strfree(sep->se_publisher);
873 	sc_strfree(sep->se_class);
874 	sc_strfree(sep->se_subclass);
875 	sc_strfree(sep->se_user);
876 	sc_strfree(sep->se_reserved1);
877 	sc_strfree(sep->se_reserved2);
878 	sc_strfree(sep->se_path);
879 	sc_strfree(sep->se_args);
880 	sc_free(sep, sizeof (serecord_t));
881 }
882 
883 
884 /*
885  * skip_spaces() - skip to next non-space character
886  */
887 static char *
888 skip_spaces(char **cpp)
889 {
890 	char *cp = *cpp;
891 
892 	while (*cp == ' ' || *cp == '\t')
893 		cp++;
894 	if (*cp == 0) {
895 		*cpp = 0;
896 		return (NULL);
897 	}
898 	return (cp);
899 }
900 
901 
902 /*
903  * Get next white-space separated field.
904  * next_field() will not check any characters on next line.
905  * Each entry is composed of a single line.
906  */
907 static char *
908 next_field(char **cpp)
909 {
910 	char *cp = *cpp;
911 	char *start;
912 
913 	while (*cp == ' ' || *cp == '\t')
914 		cp++;
915 	if (*cp == 0) {
916 		*cpp = 0;
917 		return (NULL);
918 	}
919 	start = cp;
920 	while (*cp && *cp != ' ' && *cp != '\t')
921 		cp++;
922 	if (*cp != 0)
923 		*cp++ = 0;
924 	*cpp = cp;
925 	return (start);
926 }
927 
928 
929 
930 /*
931  * The following functions are simple wrappers/equivalents
932  * for malloc, realloc, free, strdup and a special free
933  * for strdup.
934  */
935 
936 static void *
937 sc_malloc(size_t n)
938 {
939 	void *p;
940 
941 	p = malloc(n);
942 	if (p == NULL) {
943 		no_mem_err();
944 	}
945 	return (p);
946 }
947 
948 /*ARGSUSED*/
949 static void *
950 sc_realloc(void *p, size_t current, size_t n)
951 {
952 	p = realloc(p, n);
953 	if (p == NULL) {
954 		no_mem_err();
955 	}
956 	return (p);
957 }
958 
959 
960 /*ARGSUSED*/
961 static void
962 sc_free(void *p, size_t n)
963 {
964 	free(p);
965 }
966 
967 
968 static char *
969 sc_strdup(char *cp)
970 {
971 	char *new;
972 
973 	new = malloc((unsigned)(strlen(cp) + 1));
974 	if (new == NULL) {
975 		no_mem_err();
976 	}
977 	(void) strcpy(new, cp);
978 	return (new);
979 }
980 
981 
982 static void
983 sc_strfree(char *s)
984 {
985 	if (s)
986 		free(s);
987 }
988 
989 
990 /*
991  * The following functions provide some simple dynamic string
992  * capability.  This module has no hard-coded maximum string
993  * lengths and should be able to parse and generate arbitrarily
994  * long strings, macro expansion and command lines.
995  *
996  * Each string must be explicitly allocated and freed.
997  */
998 
999 /*
1000  * Allocate a dynamic string, with a hint to indicate how
1001  * much memory to dynamically add to the string as it grows
1002  * beyond its existing bounds, so as to avoid excessive
1003  * reallocs as a string grows.
1004  */
1005 static str_t *
1006 initstr(int hint)
1007 {
1008 	str_t	*str;
1009 
1010 	str = sc_malloc(sizeof (str_t));
1011 	str->s_str = NULL;
1012 	str->s_len = 0;
1013 	str->s_alloc = 0;
1014 	str->s_hint = hint;
1015 	return (str);
1016 }
1017 
1018 
1019 /*
1020  * Free a dynamically-allocated string
1021  */
1022 static void
1023 freestr(str_t *str)
1024 {
1025 	if (str->s_str) {
1026 		sc_free(str->s_str, str->s_alloc);
1027 	}
1028 	sc_free(str, sizeof (str_t));
1029 }
1030 
1031 
1032 /*
1033  * Reset a dynamically-allocated string, allows reuse
1034  * rather than freeing the old and allocating a new one.
1035  */
1036 static void
1037 resetstr(str_t *str)
1038 {
1039 	str->s_len = 0;
1040 }
1041 
1042 
1043 /*
1044  * Concatenate a (simple) string onto a dynamically-allocated string
1045  */
1046 static void
1047 strcats(str_t *str, char *s)
1048 {
1049 	char	*new_str;
1050 	int	len = str->s_len + strlen(s) + 1;
1051 
1052 	if (str->s_alloc < len) {
1053 		new_str = (str->s_str == NULL) ? sc_malloc(len+str->s_hint) :
1054 			sc_realloc(str->s_str, str->s_alloc, len+str->s_hint);
1055 		str->s_str = new_str;
1056 		str->s_alloc = len + str->s_hint;
1057 	}
1058 	(void) strcpy(str->s_str + str->s_len, s);
1059 	str->s_len = len - 1;
1060 }
1061 
1062 
1063 /*
1064  * Concatenate a character onto a dynamically-allocated string
1065  */
1066 static void
1067 strcatc(str_t *str, int c)
1068 {
1069 	char	*new_str;
1070 	int	len = str->s_len + 2;
1071 
1072 	if (str->s_alloc < len) {
1073 		new_str = (str->s_str == NULL) ? sc_malloc(len+str->s_hint) :
1074 			sc_realloc(str->s_str, str->s_alloc, len+str->s_hint);
1075 		str->s_str = new_str;
1076 		str->s_alloc = len + str->s_hint;
1077 	}
1078 	*(str->s_str + str->s_len) = (char)c;
1079 	*(str->s_str + str->s_len + 1) = 0;
1080 	str->s_len++;
1081 }
1082 
1083 /*
1084  * fgets() equivalent using a dynamically-allocated string
1085  */
1086 static char *
1087 fstrgets(str_t *line, FILE *fp)
1088 {
1089 	int	c;
1090 
1091 	resetstr(line);
1092 	while ((c = fgetc(fp)) != EOF) {
1093 		strcatc(line, c);
1094 		if (c == '\n')
1095 			break;
1096 	}
1097 	if (line->s_len == 0)
1098 		return (NULL);
1099 	return (line->s_str);
1100 }
1101 
1102 
1103 
1104 #define	INITIAL_LISTSIZE	4
1105 #define	INCR_LISTSIZE		4
1106 
1107 static char **
1108 build_strlist(
1109 	char 	**argvlist,
1110 	int	*size,
1111 	int	*alloc,
1112 	char	*str)
1113 {
1114 	int	n;
1115 
1116 	if (*size + 1 > *alloc) {
1117 		if (*alloc == 0) {
1118 			*alloc = INITIAL_LISTSIZE;
1119 			n = sizeof (char *) * (*alloc + 1);
1120 			argvlist = (char **)malloc(n);
1121 			if (argvlist == NULL)
1122 				no_mem_err();
1123 		} else {
1124 			*alloc += INCR_LISTSIZE;
1125 			n = sizeof (char *) * (*alloc + 1);
1126 			argvlist = (char **)realloc(argvlist, n);
1127 			if (argvlist == NULL)
1128 				no_mem_err();
1129 		}
1130 	}
1131 
1132 	argvlist[*size] = strdup(str);
1133 	*size += 1;
1134 	argvlist[*size] = NULL;
1135 
1136 	return (argvlist);
1137 }
1138 
1139 static void
1140 no_mem_err()
1141 {
1142 	(void) fprintf(stderr, MSG_NO_MEM, whoami);
1143 	exit_lock();
1144 	exit(EXIT_NO_MEM);
1145 	/*NOTREACHED*/
1146 }
1147