svccfg_engine.c revision 7887:b6618727fabf 
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/*
23 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27
28/*
29 * svccfg(1) interpreter and command execution engine.
30 */
31
32#include <sys/mman.h>
33#include <sys/stat.h>
34#include <sys/types.h>
35#include <assert.h>
36#include <errno.h>
37#include <libintl.h>
38#include <libtecla.h>
39#include <md5.h>
40#include <string.h>
41#include <stdlib.h>
42#include <unistd.h>
43
44#include "manifest_hash.h"
45#include "svccfg.h"
46
47#define	MS_PER_US		1000
48
49engine_state_t *est;
50
51/*
52 * Replacement lex(1) character retrieval routines.
53 */
54int
55engine_cmd_getc(engine_state_t *E)
56{
57	if (E->sc_cmd_file != NULL)
58		return (getc(E->sc_cmd_file));
59
60	if (E->sc_cmd_flags & SC_CMD_EOF)
61		return (EOF);
62
63	if (E->sc_cmd_bufoff < E->sc_cmd_bufsz)
64		return (*(E->sc_cmd_buf + E->sc_cmd_bufoff++));
65
66	if (!(E->sc_cmd_flags & SC_CMD_IACTIVE)) {
67		E->sc_cmd_flags |= SC_CMD_EOF;
68
69		return (EOF);
70	} else {
71#ifdef NATIVE_BUILD
72		return (EOF);
73#else
74		extern int parens;
75
76		if (parens <= 0) {
77			E->sc_cmd_flags |= SC_CMD_EOF;
78			return (EOF);
79		}
80
81		for (;;) {
82			E->sc_cmd_buf = gl_get_line(E->sc_gl, "> ", NULL, -1);
83			if (E->sc_cmd_buf != NULL)
84				break;
85
86			switch (gl_return_status(E->sc_gl)) {
87			case GLR_SIGNAL:
88				gl_abandon_line(E->sc_gl);
89				continue;
90
91			case GLR_EOF:
92				E->sc_cmd_flags |= SC_CMD_EOF;
93				return (EOF);
94
95			case GLR_ERROR:
96				uu_die(gettext("Error reading terminal: %s.\n"),
97				    gl_error_message(E->sc_gl, NULL, 0));
98				/* NOTREACHED */
99
100			default:
101#ifndef NDEBUG
102				(void) fprintf(stderr, "%s:%d: gl_get_line() "
103				    "returned unexpected value %d.\n", __FILE__,
104				    __LINE__, gl_return_status(E->sc_gl));
105#endif
106				abort();
107			}
108		}
109
110		E->sc_cmd_bufsz = strlen(E->sc_cmd_buf);
111		E->sc_cmd_bufoff = 1;
112
113		return (E->sc_cmd_buf[0]);
114#endif	/* NATIVE_BUILD */
115	}
116}
117
118int
119engine_cmd_ungetc(engine_state_t *E, char c)
120{
121	if (E->sc_cmd_file != NULL)
122		return (ungetc(c, E->sc_cmd_file));
123
124	if (E->sc_cmd_buf != NULL)
125		*(E->sc_cmd_buf + --E->sc_cmd_bufoff) = c;
126
127	return (c);
128}
129
130/*ARGSUSED*/
131void
132engine_cmd_nputs(engine_state_t *E, char *c, size_t n)
133{
134	/* our lexer shouldn't need this state */
135	exit(11);
136}
137
138int
139engine_exec(char *cmd)
140{
141	est->sc_cmd_buf = cmd;
142	est->sc_cmd_bufsz = strlen(cmd) + 1;
143	est->sc_cmd_bufoff = 0;
144
145	(void) yyparse();
146
147	return (0);
148}
149
150#ifndef NATIVE_BUILD
151/* ARGSUSED */
152static
153CPL_CHECK_FN(check_xml)
154{
155	const char *ext;
156
157	if (strlen(pathname) < 4)
158		return (0);
159
160	ext = pathname + strlen(pathname) - 4;
161
162	return (strcmp(ext, ".xml") == 0 ? 1 : 0);
163}
164
165static const char * const whitespace = " \t";
166
167static
168CPL_MATCH_FN(complete_single_xml_file_arg)
169{
170	const char *arg1 = data;
171	int arg1end_i, ret;
172	CplFileConf *cfc;
173
174	arg1end_i = arg1 + strcspn(arg1, whitespace) - line;
175	if (arg1end_i < word_end)
176		return (0);
177
178	cfc = new_CplFileConf();
179	if (cfc == NULL) {
180		cpl_record_error(cpl, "Out of memory.");
181		return (1);
182	}
183
184	cfc_set_check_fn(cfc, check_xml, NULL);
185
186	ret = cpl_file_completions(cpl, cfc, line, word_end);
187
188	(void) del_CplFileConf(cfc);
189	return (ret);
190}
191
192static struct cmd_info {
193	const char	*name;
194	uint32_t	flags;
195	CplMatchFn	*complete_args_f;
196} cmds[] = {
197	{ "validate", CS_GLOBAL, complete_single_xml_file_arg },
198	{ "import", CS_GLOBAL, complete_single_xml_file_arg },
199	{ "export", CS_GLOBAL, NULL },
200	{ "archive", CS_GLOBAL, NULL },
201	{ "apply", CS_GLOBAL, complete_single_xml_file_arg },
202	{ "extract", CS_GLOBAL, NULL },
203	{ "repository", CS_GLOBAL, NULL },
204	{ "inventory", CS_GLOBAL, complete_single_xml_file_arg },
205	{ "set", CS_GLOBAL, NULL },
206	{ "end", CS_GLOBAL, NULL },
207	{ "exit", CS_GLOBAL, NULL },
208	{ "quit", CS_GLOBAL, NULL },
209	{ "help", CS_GLOBAL, NULL },
210	{ "delete", CS_GLOBAL, NULL },
211	{ "select", CS_GLOBAL, complete_select },
212	{ "unselect", CS_SVC | CS_INST | CS_SNAP, NULL },
213	{ "list", CS_SCOPE | CS_SVC | CS_SNAP, NULL },
214	{ "add", CS_SCOPE | CS_SVC, NULL },
215	{ "listpg", CS_SVC | CS_INST | CS_SNAP, NULL },
216	{ "addpg", CS_SVC | CS_INST, NULL },
217	{ "delpg", CS_SVC | CS_INST, NULL },
218	{ "delhash", CS_GLOBAL, complete_single_xml_file_arg },
219	{ "listprop", CS_SVC | CS_INST | CS_SNAP, NULL },
220	{ "setprop", CS_SVC | CS_INST, NULL },
221	{ "delprop", CS_SVC | CS_INST, NULL },
222	{ "editprop", CS_SVC | CS_INST, NULL },
223	{ "describe", CS_SVC | CS_INST | CS_SNAP, NULL },
224	{ "listsnap", CS_INST | CS_SNAP, NULL },
225	{ "selectsnap", CS_INST | CS_SNAP, NULL },
226	{ "revert", CS_INST | CS_SNAP, NULL },
227	{ "refresh", CS_INST, NULL },
228	{ NULL }
229};
230
231int
232add_cmd_matches(WordCompletion *cpl, const char *line, int word_end,
233    uint32_t scope)
234{
235	int word_start, err;
236	size_t len;
237	const char *bol;
238	struct cmd_info *cip;
239
240	word_start = strspn(line, whitespace);
241	len = word_end - word_start;
242	bol = line + word_end - len;
243
244	for (cip = cmds; cip->name != NULL; ++cip) {
245		if ((cip->flags & scope) == 0)
246			continue;
247
248		if (strncmp(cip->name, bol, len) == 0) {
249			err = cpl_add_completion(cpl, line, word_start,
250			    word_end, cip->name + len, "", " ");
251			if (err != 0)
252				return (err);
253		}
254	}
255
256	return (0);
257}
258
259/*
260 * Suggest completions.  We must first determine if the cursor is in command
261 * position or in argument position.  If the former, complete_command() finds
262 * matching commands.  If the latter, we tail-call the command-specific
263 * argument-completion routine in the cmds table.
264 */
265/* ARGSUSED */
266static
267CPL_MATCH_FN(complete)
268{
269	const char *arg0, *arg1;
270	size_t arg0len;
271	struct cmd_info *cip;
272
273	arg0 = line + strspn(line, whitespace);
274	arg0len = strcspn(arg0, whitespace);
275	if ((arg0 + arg0len) - line >= word_end ||
276	    (arg0[arg0len] != ' ' && arg0[arg0len] != '\t'))
277		return (complete_command(cpl, (void *)arg0, line, word_end));
278
279	arg1 = arg0 + arg0len;
280	arg1 += strspn(arg1, whitespace);
281
282	for (cip = cmds; cip->name != NULL; ++cip) {
283		if (strlen(cip->name) != arg0len)
284			continue;
285
286		if (strncmp(cip->name, arg0, arg0len) != 0)
287			continue;
288
289		if (cip->complete_args_f == NULL)
290			break;
291
292		return (cip->complete_args_f(cpl, (void *)arg1, line,
293		    word_end));
294	}
295
296	return (0);
297}
298#endif	/* NATIVE_BUILD */
299
300int
301engine_interp()
302{
303#ifdef NATIVE_BUILD
304	uu_die("native build does not support interactive mode.");
305#else
306	char *selfmri;
307	size_t sfsz;
308	int r;
309
310	extern int parens;
311
312	(void) sigset(SIGINT, SIG_IGN);
313
314	est->sc_gl = new_GetLine(512, 8000);
315	if (est->sc_gl == NULL)
316		uu_die(gettext("Out of memory.\n"));
317
318	/* The longest string is "[snapname]fmri[:instname]> ". */
319	sfsz = 1 + max_scf_name_len + 1 + max_scf_fmri_len + 2 +
320	    max_scf_name_len + 1 + 2 + 1;
321	selfmri = safe_malloc(sfsz);
322
323	r = gl_customize_completion(est->sc_gl, NULL, complete);
324	assert(r == 0);
325
326	for (;;) {
327		lscf_get_selection_str(selfmri, sfsz - 2);
328		(void) strcat(selfmri, "> ");
329		est->sc_cmd_buf = gl_get_line(est->sc_gl, selfmri, NULL, -1);
330
331		if (est->sc_cmd_buf == NULL) {
332			switch (gl_return_status(est->sc_gl)) {
333			case GLR_SIGNAL:
334				gl_abandon_line(est->sc_gl);
335				continue;
336
337			case GLR_EOF:
338				break;
339
340			case GLR_ERROR:
341				uu_die(gettext("Error reading terminal: %s.\n"),
342				    gl_error_message(est->sc_gl, NULL, 0));
343				/* NOTREACHED */
344
345			default:
346#ifndef NDEBUG
347				(void) fprintf(stderr, "%s:%d: gl_get_line() "
348				    "returned unexpected value %d.\n", __FILE__,
349				    __LINE__, gl_return_status(est->sc_gl));
350#endif
351				abort();
352			}
353
354			break;
355		}
356
357		parens = 0;
358		est->sc_cmd_bufsz = strlen(est->sc_cmd_buf);
359		est->sc_cmd_bufoff = 0;
360		est->sc_cmd_flags = SC_CMD_IACTIVE;
361
362		(void) yyparse();
363	}
364
365	free(selfmri);
366	est->sc_gl = del_GetLine(est->sc_gl);	/* returns NULL */
367
368#endif	/* NATIVE_BUILD */
369	return (0);
370}
371
372int
373engine_source(const char *name, boolean_t dont_exit)
374{
375	engine_state_t *old = est;
376	struct stat st;
377	int ret;
378
379	est = uu_zalloc(sizeof (engine_state_t));
380
381	/* first, copy the stuff set up in engine_init */
382	est->sc_repo_pid = old->sc_repo_pid;
383	if (old->sc_repo_filename != NULL)
384		est->sc_repo_filename = safe_strdup(old->sc_repo_filename);
385	if (old->sc_repo_doordir != NULL)
386		est->sc_repo_doordir = safe_strdup(old->sc_repo_doordir);
387	if (old->sc_repo_doorname != NULL)
388		est->sc_repo_doorname = safe_strdup(old->sc_repo_doorname);
389	if (old->sc_repo_server != NULL)
390		est->sc_repo_server = safe_strdup(old->sc_repo_server);
391
392	/* set up the new guy */
393	est->sc_cmd_lineno = 1;
394
395	if (dont_exit)
396		est->sc_cmd_flags |= SC_CMD_DONT_EXIT;
397
398	if (strcmp(name, "-") == 0) {
399		est->sc_cmd_file = stdin;
400		est->sc_cmd_filename = "<stdin>";
401	} else {
402		errno = 0;
403		est->sc_cmd_filename = name;
404		est->sc_cmd_file = fopen(name, "r");
405		if (est->sc_cmd_file == NULL) {
406			if (errno == 0)
407				semerr(gettext("No free stdio streams.\n"));
408			else
409				semerr(gettext("Could not open %s"), name);
410
411			ret = -1;
412			goto fail;
413		}
414
415		do {
416			ret = fstat(fileno(est->sc_cmd_file), &st);
417		} while (ret != 0 && errno == EINTR);
418		if (ret != 0) {
419			(void) fclose(est->sc_cmd_file);
420			est->sc_cmd_file = NULL;	/* for semerr() */
421
422			semerr(gettext("Could not stat %s"), name);
423
424			ret = -1;
425			goto fail;
426		}
427
428		if (!S_ISREG(st.st_mode)) {
429			(void) fclose(est->sc_cmd_file);
430			est->sc_cmd_file = NULL;	/* for semerr() */
431
432			semerr(gettext("%s is not a regular file.\n"), name);
433
434			ret = -1;
435			goto fail;
436		}
437	}
438
439	(void) yyparse();
440
441	if (est->sc_cmd_file != stdin)
442		(void) fclose(est->sc_cmd_file);
443
444	ret = 0;
445
446fail:
447	if (est->sc_repo_pid != old->sc_repo_pid)
448		lscf_cleanup();		/* clean up any new repository */
449
450	if (est->sc_repo_filename != NULL)
451		free((void *)est->sc_repo_filename);
452	if (est->sc_repo_doordir != NULL)
453		free((void *)est->sc_repo_doordir);
454	if (est->sc_repo_doorname != NULL)
455		free((void *)est->sc_repo_doorname);
456	if (est->sc_repo_server != NULL)
457		free((void *)est->sc_repo_server);
458	free(est);
459
460	est = old;
461
462	return (ret);
463}
464
465/*
466 * Initialize svccfg state.  We recognize four environment variables:
467 *
468 * SVCCFG_REPOSITORY	Create a private instance of svc.configd(1M) to answer
469 *			requests for the specified repository file.
470 * SVCCFG_DOOR_PATH	Directory for door creation.
471 *
472 * SVCCFG_DOOR		Rendezvous via an alternative repository door.
473 *
474 * SVCCFG_CONFIGD_PATH	Resolvable path to alternative svc.configd(1M) binary.
475 */
476void
477engine_init()
478{
479	const char *cp;
480
481	est = uu_zalloc(sizeof (engine_state_t));
482
483	est->sc_cmd_lineno = 1;
484	est->sc_repo_pid = -1;
485
486	cp = getenv("SVCCFG_REPOSITORY");
487	est->sc_repo_filename = cp ? safe_strdup(cp) : NULL;
488
489	cp = getenv("SVCCFG_DOOR_PATH");
490	est->sc_repo_doordir = cp ? cp : "/var/run";
491
492	cp = getenv("SVCCFG_DOOR");
493	if (cp != NULL) {
494		if (est->sc_repo_filename != NULL) {
495			uu_warn(gettext("SVCCFG_DOOR unused when "
496			    "SVCCFG_REPOSITORY specified\n"));
497		} else {
498			est->sc_repo_doorname = safe_strdup(cp);
499		}
500	}
501
502	cp = getenv("SVCCFG_CONFIGD_PATH");
503	est->sc_repo_server = cp ? cp : "/lib/svc/bin/svc.configd";
504}
505
506int
507engine_import(uu_list_t *args)
508{
509	int ret, argc, i, o;
510	bundle_t *b;
511	char *file, *pname;
512	uchar_t hash[MHASH_SIZE];
513	char **argv;
514	string_list_t *slp;
515	boolean_t validate = B_FALSE;
516	tmpl_validate_status_t vr;
517	uint_t flags = SCI_GENERALLAST;
518	tmpl_errors_t *errs;
519
520	argc = uu_list_numnodes(args);
521	if (argc < 1)
522		return (-2);
523
524	argv = calloc(argc + 1, sizeof (char *));
525	if (argv == NULL)
526		uu_die(gettext("Out of memory.\n"));
527
528	for (slp = uu_list_first(args), i = 0;
529	    slp != NULL;
530	    slp = uu_list_next(args, slp), ++i)
531		argv[i] = slp->str;
532
533	argv[i] = NULL;
534
535	opterr = 0;
536	optind = 0;				/* Remember, no argv[0]. */
537	for (;;) {
538		o = getopt(argc, argv, "nV");
539		if (o == -1)
540			break;
541
542		switch (o) {
543		case 'n':
544			flags |= SCI_NOREFRESH;
545			break;
546
547		case 'V':
548			validate = B_TRUE;
549			break;
550
551		case '?':
552			free(argv);
553			return (-2);
554
555		default:
556			bad_error("getopt", o);
557		}
558	}
559
560	argc -= optind;
561	if (argc != 1) {
562		free(argv);
563		return (-2);
564	}
565
566	file = argv[optind];
567	free(argv);
568
569	/* If we're in interactive mode, force strict validation. */
570	if (est->sc_cmd_flags & SC_CMD_IACTIVE)
571		validate = B_TRUE;
572
573	lscf_prep_hndl();
574
575	ret = mhash_test_file(g_hndl, file, 0, &pname, hash);
576	if (ret != MHASH_NEWFILE) {
577		if (ret == MHASH_FAILURE)
578			semerr(gettext("Could not hash file %s\n"), file);
579		else if (g_verbose && ret == MHASH_RECONCILED)
580			warn(gettext("No changes were necessary.\n"));
581		return (ret);
582	}
583
584	/* Load */
585	b = internal_bundle_new();
586
587	if (lxml_get_bundle_file(b, file, SVCCFG_OP_IMPORT) != 0) {
588		internal_bundle_free(b);
589		return (-1);
590	}
591
592	/* Validate */
593	if ((vr = tmpl_validate_bundle(b, &errs)) != TVS_SUCCESS) {
594		char *prefix;
595
596		if ((validate == 0) || (vr == TVS_WARN)) {
597			prefix = gettext("Warning: ");
598		} else {
599			prefix = "";
600		}
601		tmpl_errors_print(stderr, errs, prefix);
602		if (validate && (vr != TVS_WARN)) {
603			tmpl_errors_destroy(errs);
604			semerr(gettext("Import failed.\n"));
605			return (-1);
606		}
607	}
608	tmpl_errors_destroy(errs);
609
610	/* Import */
611	if (lscf_bundle_import(b, file, flags) != 0) {
612		internal_bundle_free(b);
613		semerr(gettext("Import failed.\n"));
614		return (-1);
615	}
616
617	internal_bundle_free(b);
618
619	if (g_verbose)
620		warn(gettext("Successful import.\n"));
621
622	if (pname) {
623		char *errstr;
624
625		if (mhash_store_entry(g_hndl, pname, hash, &errstr)) {
626			if (errstr)
627				semerr(errstr);
628			else
629				semerr(gettext("Unknown error from "
630				    "mhash_store_entry()\n"));
631		}
632
633		free(pname);
634	}
635
636	return (0);
637}
638
639int
640engine_apply(const char *file)
641{
642	int ret;
643	bundle_t *b;
644	char *pname;
645	uchar_t hash[MHASH_SIZE];
646
647	lscf_prep_hndl();
648
649	ret = mhash_test_file(g_hndl, file, 1, &pname, hash);
650	if (ret != MHASH_NEWFILE)
651		return (ret);
652
653	b = internal_bundle_new();
654
655	if (lxml_get_bundle_file(b, file, SVCCFG_OP_APPLY) != 0) {
656		internal_bundle_free(b);
657		return (-1);
658	}
659
660	if (lscf_bundle_apply(b, file) != 0) {
661		internal_bundle_free(b);
662		return (-1);
663	}
664
665	internal_bundle_free(b);
666
667	if (pname) {
668		char *errstr;
669		if (mhash_store_entry(g_hndl, pname, hash, &errstr))
670			semerr(errstr);
671
672		free(pname);
673	}
674
675	return (0);
676}
677
678int
679engine_restore(const char *file)
680{
681	bundle_t *b;
682
683	lscf_prep_hndl();
684
685	b = internal_bundle_new();
686
687	if (lxml_get_bundle_file(b, file, SVCCFG_OP_RESTORE) != 0) {
688		internal_bundle_free(b);
689		return (-1);
690	}
691
692	if (lscf_bundle_import(b, file, SCI_NOSNAP) != 0) {
693		internal_bundle_free(b);
694		return (-1);
695	}
696
697	internal_bundle_free(b);
698
699	return (0);
700}
701
702int
703engine_set(uu_list_t *args)
704{
705	uu_list_walk_t *walk;
706	string_list_t *slp;
707
708	if (uu_list_first(args) == NULL) {
709		/* Display current options. */
710		if (!g_verbose)
711			(void) fputs("no", stdout);
712		(void) puts("verbose");
713
714		return (0);
715	}
716
717	walk = uu_list_walk_start(args, UU_DEFAULT);
718	if (walk == NULL)
719		uu_die(gettext("Couldn't read arguments"));
720
721	/* Use getopt? */
722	for (slp = uu_list_walk_next(walk);
723	    slp != NULL;
724	    slp = uu_list_walk_next(walk)) {
725		if (slp->str[0] == '-') {
726			char *op;
727
728			for (op = &slp->str[1]; *op != '\0'; ++op) {
729				switch (*op) {
730				case 'v':
731					g_verbose = 1;
732					break;
733
734				case 'V':
735					g_verbose = 0;
736					break;
737
738				default:
739					warn(gettext("Unknown option -%c.\n"),
740					    *op);
741				}
742			}
743		} else {
744			warn(gettext("No non-flag arguments defined.\n"));
745		}
746	}
747
748	return (0);
749}
750
751void
752help(int com)
753{
754	int i;
755
756	if (com == 0) {
757		warn(gettext("General commands:	 help set repository end\n"
758		    "Manifest commands:	 inventory validate import export "
759		    "archive\n"
760		    "Profile commands:	 apply extract\n"
761		    "Entity commands:	 list select unselect add delete "
762		    "describe\n"
763		    "Snapshot commands:	 listsnap selectsnap revert\n"
764		    "Instance commands:	 refresh\n"
765		    "Property group commands: listpg addpg delpg\n"
766		    "Property commands:	 listprop setprop delprop editprop\n"
767		    "Property value commands: addpropvalue delpropvalue "
768		    "setenv unsetenv\n"));
769		return;
770	}
771
772	for (i = 0; help_messages[i].message != NULL; ++i) {
773		if (help_messages[i].token == com) {
774			warn(gettext("Usage: %s\n"),
775			    gettext(help_messages[i].message));
776			return;
777		}
778	}
779
780	warn(gettext("Unknown command.\n"));
781}
782