xref: /freebsd/usr.sbin/jail/jail.c (revision f1951fd745b894fe6586c298874af98544a5e272)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 1999 Poul-Henning Kamp.
5  * Copyright (c) 2009-2012 James Gritton
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <sys/socket.h>
36 #include <sys/sysctl.h>
37 
38 #include <arpa/inet.h>
39 #include <netinet/in.h>
40 
41 #include <err.h>
42 #include <errno.h>
43 #include <stdarg.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
48 
49 #include "jailp.h"
50 
51 #define JP_RDTUN(jp)	(((jp)->jp_ctltype & CTLFLAG_RDTUN) == CTLFLAG_RDTUN)
52 
53 struct permspec {
54 	const char	*name;
55 	enum intparam	ipnum;
56 	int		rev;
57 };
58 
59 const char *cfname;
60 int iflag;
61 int note_remove;
62 int verbose;
63 
64 static void clear_persist(struct cfjail *j);
65 static int update_jail(struct cfjail *j);
66 static int rdtun_params(struct cfjail *j, int dofail);
67 static void running_jid(struct cfjail *j, int dflag);
68 static void jail_quoted_warnx(const struct cfjail *j, const char *name_msg,
69     const char *noname_msg);
70 static int jailparam_set_note(const struct cfjail *j, struct jailparam *jp,
71     unsigned njp, int flags);
72 static void print_jail(FILE *fp, struct cfjail *j, int oldcl);
73 static void print_param(FILE *fp, const struct cfparam *p, int sep, int doname);
74 static void quoted_print(FILE *fp, char *str);
75 static void usage(void);
76 
77 static struct permspec perm_sysctl[] = {
78     { "security.jail.set_hostname_allowed", KP_ALLOW_SET_HOSTNAME, 0 },
79     { "security.jail.sysvipc_allowed", KP_ALLOW_SYSVIPC, 0 },
80     { "security.jail.allow_raw_sockets", KP_ALLOW_RAW_SOCKETS, 0 },
81     { "security.jail.chflags_allowed", KP_ALLOW_CHFLAGS, 0 },
82     { "security.jail.mount_allowed", KP_ALLOW_MOUNT, 0 },
83     { "security.jail.socket_unixiproute_only", KP_ALLOW_SOCKET_AF, 1 },
84 };
85 
86 static const enum intparam startcommands[] = {
87     IP__NULL,
88 #ifdef INET
89     IP__IP4_IFADDR,
90 #endif
91 #ifdef INET6
92     IP__IP6_IFADDR,
93 #endif
94     IP_MOUNT,
95     IP__MOUNT_FROM_FSTAB,
96     IP_MOUNT_DEVFS,
97     IP_MOUNT_FDESCFS,
98     IP_MOUNT_PROCFS,
99     IP_EXEC_PRESTART,
100     IP__OP,
101     IP_VNET_INTERFACE,
102     IP_EXEC_START,
103     IP_COMMAND,
104     IP_EXEC_POSTSTART,
105     IP__NULL
106 };
107 
108 static const enum intparam stopcommands[] = {
109     IP__NULL,
110     IP_EXEC_PRESTOP,
111     IP_EXEC_STOP,
112     IP_STOP_TIMEOUT,
113     IP__OP,
114     IP_EXEC_POSTSTOP,
115     IP_MOUNT_PROCFS,
116     IP_MOUNT_FDESCFS,
117     IP_MOUNT_DEVFS,
118     IP__MOUNT_FROM_FSTAB,
119     IP_MOUNT,
120 #ifdef INET6
121     IP__IP6_IFADDR,
122 #endif
123 #ifdef INET
124     IP__IP4_IFADDR,
125 #endif
126     IP__NULL
127 };
128 
129 int
130 main(int argc, char **argv)
131 {
132 	struct stat st;
133 	FILE *jfp;
134 	struct cfjail *j;
135 	char *JidFile;
136 	size_t sysvallen;
137 	unsigned op, pi;
138 	int ch, docf, error, i, oldcl, sysval;
139 	int dflag, Rflag;
140 	char enforce_statfs[4];
141 #if defined(INET) || defined(INET6)
142 	char *cs, *ncs;
143 #endif
144 #if defined(INET) && defined(INET6)
145 	struct in6_addr addr6;
146 #endif
147 
148 	op = 0;
149 	dflag = Rflag = 0;
150 	docf = 1;
151 	cfname = CONF_FILE;
152 	JidFile = NULL;
153 
154 	while ((ch = getopt(argc, argv, "cdf:hiJ:lmn:p:qrRs:u:U:v")) != -1) {
155 		switch (ch) {
156 		case 'c':
157 			op |= JF_START;
158 			break;
159 		case 'd':
160 			dflag = 1;
161 			break;
162 		case 'f':
163 			cfname = optarg;
164 			break;
165 		case 'h':
166 #if defined(INET) || defined(INET6)
167 			add_param(NULL, NULL, IP_IP_HOSTNAME, NULL);
168 #endif
169 			docf = 0;
170 			break;
171 		case 'i':
172 			iflag = 1;
173 			verbose = -1;
174 			break;
175 		case 'J':
176 			JidFile = optarg;
177 			break;
178 		case 'l':
179 			add_param(NULL, NULL, IP_EXEC_CLEAN, NULL);
180 			docf = 0;
181 			break;
182 		case 'm':
183 			op |= JF_SET;
184 			break;
185 		case 'n':
186 			add_param(NULL, NULL, KP_NAME, optarg);
187 			docf = 0;
188 			break;
189 		case 'p':
190 			paralimit = strtol(optarg, NULL, 10);
191 			if (paralimit == 0)
192 				paralimit = -1;
193 			break;
194 		case 'q':
195 			verbose = -1;
196 			break;
197 		case 'r':
198 			op |= JF_STOP;
199 			break;
200 		case 'R':
201 			op |= JF_STOP;
202 			Rflag = 1;
203 			break;
204 		case 's':
205 			add_param(NULL, NULL, KP_SECURELEVEL, optarg);
206 			docf = 0;
207 			break;
208 		case 'u':
209 			add_param(NULL, NULL, IP_EXEC_JAIL_USER, optarg);
210 			add_param(NULL, NULL, IP_EXEC_SYSTEM_JAIL_USER, NULL);
211 			docf = 0;
212 			break;
213 		case 'U':
214 			add_param(NULL, NULL, IP_EXEC_JAIL_USER, optarg);
215 			add_param(NULL, NULL, IP_EXEC_SYSTEM_JAIL_USER,
216 			    "false");
217 			docf = 0;
218 			break;
219 		case 'v':
220 			verbose = 1;
221 			break;
222 		default:
223 			usage();
224 		}
225 	}
226 	argc -= optind;
227 	argv += optind;
228 
229 	/* Find out which of the four command line styles this is. */
230 	oldcl = 0;
231 	if (!op) {
232 		/* Old-style command line with four fixed parameters */
233 		if (argc < 4 || argv[0][0] != '/')
234 			usage();
235 		op = JF_START;
236 		docf = 0;
237 		oldcl = 1;
238 		add_param(NULL, NULL, KP_PATH, argv[0]);
239 		add_param(NULL, NULL, KP_HOST_HOSTNAME, argv[1]);
240 #if defined(INET) || defined(INET6)
241 		if (argv[2][0] != '\0') {
242 			for (cs = argv[2];; cs = ncs + 1) {
243 				ncs = strchr(cs, ',');
244 				if (ncs)
245 					*ncs = '\0';
246 				add_param(NULL, NULL,
247 #if defined(INET) && defined(INET6)
248 				    inet_pton(AF_INET6, cs, &addr6) == 1
249 				    ? KP_IP6_ADDR : KP_IP4_ADDR,
250 #elif defined(INET)
251 				    KP_IP4_ADDR,
252 #elif defined(INET6)
253 				    KP_IP6_ADDR,
254 #endif
255 				    cs);
256 				if (!ncs)
257 					break;
258 			}
259 		}
260 #endif
261 		for (i = 3; i < argc; i++)
262 			add_param(NULL, NULL, IP_COMMAND, argv[i]);
263 		/* Emulate the defaults from security.jail.* sysctls. */
264 		sysvallen = sizeof(sysval);
265 		if (sysctlbyname("security.jail.jailed", &sysval, &sysvallen,
266 		    NULL, 0) == 0 && sysval == 0) {
267 			for (pi = 0; pi < sizeof(perm_sysctl) /
268 			     sizeof(perm_sysctl[0]); pi++) {
269 				sysvallen = sizeof(sysval);
270 				if (sysctlbyname(perm_sysctl[pi].name,
271 				    &sysval, &sysvallen, NULL, 0) == 0)
272 					add_param(NULL, NULL,
273 					    perm_sysctl[pi].ipnum,
274 					    (sysval ? 1 : 0) ^
275 					    perm_sysctl[pi].rev
276 					    ? NULL : "false");
277 			}
278 			sysvallen = sizeof(sysval);
279 			if (sysctlbyname("security.jail.enforce_statfs",
280 			    &sysval, &sysvallen, NULL, 0) == 0) {
281 				snprintf(enforce_statfs,
282 				    sizeof(enforce_statfs), "%d", sysval);
283 				add_param(NULL, NULL, KP_ENFORCE_STATFS,
284 				    enforce_statfs);
285 			}
286 		}
287 	} else if (op == JF_STOP) {
288 		/* Jail remove, perhaps using the config file */
289 		if (!docf || argc == 0)
290 			usage();
291 		if (!Rflag)
292 			for (i = 0; i < argc; i++)
293 				if (strchr(argv[i], '='))
294 					usage();
295 		if ((docf = !Rflag &&
296 		     (!strcmp(cfname, "-") || stat(cfname, &st) == 0)))
297 			load_config();
298 		note_remove = docf || argc > 1 || wild_jail_name(argv[0]);
299 	} else if (argc > 1 || (argc == 1 && strchr(argv[0], '='))) {
300 		/* Single jail specified on the command line */
301 		if (Rflag)
302 			usage();
303 		docf = 0;
304 		for (i = 0; i < argc; i++) {
305 			if (!strncmp(argv[i], "command", 7) &&
306 			    (argv[i][7] == '\0' || argv[i][7] == '=')) {
307 				if (argv[i][7]  == '=')
308 					add_param(NULL, NULL, IP_COMMAND,
309 					    argv[i] + 8);
310 				for (i++; i < argc; i++)
311 					add_param(NULL, NULL, IP_COMMAND,
312 					    argv[i]);
313 			}
314 #ifdef INET
315 			else if (!strncmp(argv[i], "ip4.addr=", 9)) {
316 				for (cs = argv[i] + 9;; cs = ncs + 1) {
317 					ncs = strchr(cs, ',');
318 					if (ncs)
319 						*ncs = '\0';
320 					add_param(NULL, NULL, KP_IP4_ADDR, cs);
321 					if (!ncs)
322 						break;
323 				}
324 			}
325 #endif
326 #ifdef INET6
327 			else if (!strncmp(argv[i], "ip6.addr=", 9)) {
328 				for (cs = argv[i] + 9;; cs = ncs + 1) {
329 					ncs = strchr(cs, ',');
330 					if (ncs)
331 						*ncs = '\0';
332 					add_param(NULL, NULL, KP_IP6_ADDR, cs);
333 					if (!ncs)
334 						break;
335 				}
336 			}
337 #endif
338 			else
339 				add_param(NULL, NULL, 0, argv[i]);
340 		}
341 	} else {
342 		/* From the config file, perhaps with a specified jail */
343 		if (Rflag || !docf)
344 			usage();
345 		load_config();
346 	}
347 
348 	/* Find out which jails will be run. */
349 	dep_setup(docf);
350 	error = 0;
351 	if (op == JF_STOP) {
352 		for (i = 0; i < argc; i++)
353 			if (start_state(argv[i], docf, op, Rflag) < 0)
354 				error = 1;
355 	} else {
356 		if (start_state(argv[0], docf, op, 0) < 0)
357 			exit(1);
358 	}
359 
360 	jfp = NULL;
361 	if (JidFile != NULL) {
362 		jfp = fopen(JidFile, "w");
363 		if (jfp == NULL)
364 			err(1, "open %s", JidFile);
365 		setlinebuf(jfp);
366 	}
367 	setlinebuf(stdout);
368 
369 	/*
370 	 * The main loop: Get an available jail and perform the required
371 	 * operation on it.  When that is done, the jail may be finished,
372 	 * or it may go back for the next step.
373 	 */
374 	while ((j = next_jail()))
375 	{
376 		if (j->flags & JF_FAILED) {
377 			error = 1;
378 			if (j->comparam == NULL) {
379 				dep_done(j, 0);
380 				continue;
381 			}
382 		}
383 		if (!(j->flags & JF_PARAMS))
384 		{
385 			j->flags |= JF_PARAMS;
386 			if (dflag)
387 				add_param(j, NULL, IP_ALLOW_DYING, NULL);
388 			if (check_intparams(j) < 0)
389 				continue;
390 			if ((j->flags & (JF_START | JF_SET)) &&
391 			    import_params(j) < 0)
392 				continue;
393 		}
394 		if (!j->jid)
395 			running_jid(j,
396 			    (j->flags & (JF_SET | JF_DEPEND)) == JF_SET
397 			    ? dflag || bool_param(j->intparams[IP_ALLOW_DYING])
398 			    : 0);
399 		if (finish_command(j))
400 			continue;
401 
402 		switch (j->flags & JF_OP_MASK) {
403 			/*
404 			 * These operations just turn into a different op
405 			 * depending on the jail's current status.
406 			 */
407 		case JF_START_SET:
408 			j->flags = j->jid < 0 ? JF_START : JF_SET;
409 			break;
410 		case JF_SET_RESTART:
411 			if (j->jid < 0) {
412 				jail_quoted_warnx(j, "not found",
413 				    "no jail specified");
414 				failed(j);
415 				continue;
416 			}
417 			j->flags = rdtun_params(j, 0) ? JF_RESTART : JF_SET;
418 			if (j->flags == JF_RESTART)
419 				dep_reset(j);
420 			break;
421 		case JF_START_SET_RESTART:
422 			j->flags = j->jid < 0 ? JF_START
423 			    : rdtun_params(j, 0) ? JF_RESTART : JF_SET;
424 			if (j->flags == JF_RESTART)
425 				dep_reset(j);
426 		}
427 
428 		switch (j->flags & JF_OP_MASK) {
429 		case JF_START:
430 			if (j->comparam == NULL) {
431 				if (j->jid > 0 &&
432 				    !(j->flags & (JF_DEPEND | JF_WILD))) {
433 					jail_quoted_warnx(j, "already exists",
434 					    NULL);
435 					failed(j);
436 					continue;
437 				}
438 				if (dep_check(j))
439 					continue;
440 				if (j->jid > 0)
441 					goto jail_create_done;
442 				j->comparam = startcommands;
443 				j->comstring = NULL;
444 			}
445 			if (next_command(j))
446 				continue;
447 		jail_create_done:
448 			clear_persist(j);
449 			if (jfp != NULL)
450 				print_jail(jfp, j, oldcl);
451 			dep_done(j, 0);
452 			break;
453 
454 		case JF_SET:
455 			if (j->jid < 0 && !(j->flags & JF_DEPEND)) {
456 				jail_quoted_warnx(j, "not found",
457 				    "no jail specified");
458 				failed(j);
459 				continue;
460 			}
461 			if (dep_check(j))
462 				continue;
463 			if (!(j->flags & JF_DEPEND)) {
464 				if (rdtun_params(j, 1) < 0 ||
465 				    update_jail(j) < 0)
466 					continue;
467 				if (verbose >= 0 && (j->name || verbose > 0))
468 					jail_note(j, "updated\n");
469 			}
470 			dep_done(j, 0);
471 			break;
472 
473 		case JF_STOP:
474 		case JF_RESTART:
475 			if (j->comparam == NULL) {
476 				if (dep_check(j))
477 					continue;
478 				if (j->jid < 0) {
479 					if (!(j->flags & (JF_DEPEND|JF_WILD))) {
480 						if (verbose >= 0)
481 							jail_quoted_warnx(j,
482 							    "not found", NULL);
483 						failed(j);
484 					}
485 					goto jail_remove_done;
486 				}
487 				j->comparam = stopcommands;
488 				j->comstring = NULL;
489 			} else if ((j->flags & JF_FAILED) && j->jid > 0)
490 				goto jail_remove_done;
491 			if (next_command(j))
492 				continue;
493 		jail_remove_done:
494 			dep_done(j, 0);
495 			if ((j->flags & (JF_START | JF_FAILED)) == JF_START) {
496 				j->comparam = NULL;
497 				j->flags &= ~JF_STOP;
498 				dep_reset(j);
499 				requeue(j, j->ndeps ? &depend : &ready);
500 			}
501 			break;
502 		}
503 	}
504 
505 	if (jfp != NULL)
506 		fclose(jfp);
507 	exit(error);
508 }
509 
510 /*
511  * Mark a jail's failure for future handling.
512  */
513 void
514 failed(struct cfjail *j)
515 {
516 	j->flags |= JF_FAILED;
517 	TAILQ_REMOVE(j->queue, j, tq);
518 	TAILQ_INSERT_HEAD(&ready, j, tq);
519 	j->queue = &ready;
520 }
521 
522 /*
523  * Exit slightly more gracefully when out of memory.
524  */
525 void *
526 emalloc(size_t size)
527 {
528 	void *p;
529 
530 	p = malloc(size);
531 	if (!p)
532 		err(1, "malloc");
533 	return p;
534 }
535 
536 void *
537 erealloc(void *ptr, size_t size)
538 {
539 	void *p;
540 
541 	p = realloc(ptr, size);
542 	if (!p)
543 		err(1, "malloc");
544 	return p;
545 }
546 
547 char *
548 estrdup(const char *str)
549 {
550 	char *ns;
551 
552 	ns = strdup(str);
553 	if (!ns)
554 		err(1, "malloc");
555 	return ns;
556 }
557 
558 /*
559  * Print a message including an optional jail name.
560  */
561 void
562 jail_note(const struct cfjail *j, const char *fmt, ...)
563 {
564 	va_list ap, tap;
565 	char *cs;
566 	size_t len;
567 
568 	va_start(ap, fmt);
569 	va_copy(tap, ap);
570 	len = vsnprintf(NULL, 0, fmt, tap);
571 	va_end(tap);
572 	cs = alloca(len + 1);
573 	(void)vsnprintf(cs, len + 1, fmt, ap);
574 	va_end(ap);
575 	if (j->name)
576 		printf("%s: %s", j->name, cs);
577 	else
578 		printf("%s", cs);
579 }
580 
581 /*
582  * Print a warning message including an optional jail name.
583  */
584 void
585 jail_warnx(const struct cfjail *j, const char *fmt, ...)
586 {
587 	va_list ap, tap;
588 	char *cs;
589 	size_t len;
590 
591 	va_start(ap, fmt);
592 	va_copy(tap, ap);
593 	len = vsnprintf(NULL, 0, fmt, tap);
594 	va_end(tap);
595 	cs = alloca(len + 1);
596 	(void)vsnprintf(cs, len + 1, fmt, ap);
597 	va_end(ap);
598 	if (j->name)
599 		warnx("%s: %s", j->name, cs);
600 	else
601 		warnx("%s", cs);
602 }
603 
604 /*
605  * Create a new jail.
606  */
607 int
608 create_jail(struct cfjail *j)
609 {
610 	struct iovec jiov[4];
611 	struct stat st;
612 	struct jailparam *jp, *setparams, *setparams2, *sjp;
613 	const char *path;
614 	int dopersist, ns, jid, dying, didfail;
615 
616 	/*
617 	 * Check the jail's path, with a better error message than jail_set
618 	 * gives.
619 	 */
620 	if ((path = string_param(j->intparams[KP_PATH]))) {
621 		if (j->name != NULL && path[0] != '/') {
622 			jail_warnx(j, "path %s: not an absolute pathname",
623 			    path);
624 			return -1;
625 		}
626 		if (stat(path, &st) < 0) {
627 			jail_warnx(j, "path %s: %s", path, strerror(errno));
628 			return -1;
629 		}
630 		if (!S_ISDIR(st.st_mode)) {
631 			jail_warnx(j, "path %s: %s", path, strerror(ENOTDIR));
632 			return -1;
633 		}
634 	}
635 
636 	/*
637 	 * Copy all the parameters, except that "persist" is always set when
638 	 * there are commands to run later.
639 	 */
640 	dopersist = !bool_param(j->intparams[KP_PERSIST]) &&
641 	    (j->intparams[IP_EXEC_START] || j->intparams[IP_COMMAND] ||
642 	     j->intparams[IP_EXEC_POSTSTART]);
643 	sjp = setparams =
644 	    alloca((j->njp + dopersist) * sizeof(struct jailparam));
645 	if (dopersist && jailparam_init(sjp++, "persist") < 0) {
646 		jail_warnx(j, "%s", jail_errmsg);
647 		return -1;
648 	}
649 	for (jp = j->jp; jp < j->jp + j->njp; jp++)
650 		if (!dopersist || !equalopts(jp->jp_name, "persist"))
651 			*sjp++ = *jp;
652 	ns = sjp - setparams;
653 
654 	didfail = 0;
655 	j->jid = jailparam_set_note(j, setparams, ns, JAIL_CREATE);
656 	if (j->jid < 0 && errno == EEXIST &&
657 	    bool_param(j->intparams[IP_ALLOW_DYING]) &&
658 	    int_param(j->intparams[KP_JID], &jid) && jid != 0) {
659 		/*
660 		 * The jail already exists, but may be dying.
661 		 * Make sure it is, in which case an update is appropriate.
662 		 */
663 		jiov[0].iov_base = __DECONST(char *, "jid");
664 		jiov[0].iov_len = sizeof("jid");
665 		jiov[1].iov_base = &jid;
666 		jiov[1].iov_len = sizeof(jid);
667 		jiov[2].iov_base = __DECONST(char *, "dying");
668 		jiov[2].iov_len = sizeof("dying");
669 		jiov[3].iov_base = &dying;
670 		jiov[3].iov_len = sizeof(dying);
671 		if (jail_get(jiov, 4, JAIL_DYING) < 0) {
672 			/*
673 			 * It could be that the jail just barely finished
674 			 * dying, or it could be that the jid never existed
675 			 * but the name does.  In either case, another try
676 			 * at creating the jail should do the right thing.
677 			 */
678 			if (errno == ENOENT)
679 				j->jid = jailparam_set_note(j, setparams, ns,
680 				    JAIL_CREATE);
681 		} else if (dying) {
682 			j->jid = jid;
683 			if (rdtun_params(j, 1) < 0) {
684 				j->jid = -1;
685 				didfail = 1;
686 			} else {
687 				sjp = setparams2 = alloca((j->njp + dopersist) *
688 				    sizeof(struct jailparam));
689 				for (jp = setparams; jp < setparams + ns; jp++)
690 					if (!JP_RDTUN(jp) ||
691 					    !strcmp(jp->jp_name, "jid"))
692 						*sjp++ = *jp;
693 				j->jid = jailparam_set_note(j, setparams2,
694 				    sjp - setparams2, JAIL_UPDATE | JAIL_DYING);
695 				/*
696 				 * Again, perhaps the jail just finished dying.
697 				 */
698 				if (j->jid < 0 && errno == ENOENT)
699 					j->jid = jailparam_set_note(j,
700 					    setparams, ns, JAIL_CREATE);
701 			}
702 		}
703 	}
704 	if (j->jid < 0 && !didfail) {
705 		jail_warnx(j, "%s", jail_errmsg);
706 		failed(j);
707 	}
708 	if (dopersist) {
709 		jailparam_free(setparams, 1);
710 		if (j->jid > 0)
711 			j->flags |= JF_PERSIST;
712 	}
713 	return j->jid;
714 }
715 
716 /*
717  * Remove a temporarily set "persist" parameter.
718  */
719 static void
720 clear_persist(struct cfjail *j)
721 {
722 	struct iovec jiov[4];
723 	int jid;
724 
725 	if (!(j->flags & JF_PERSIST))
726 		return;
727 	j->flags &= ~JF_PERSIST;
728 	jiov[0].iov_base = __DECONST(char *, "jid");
729 	jiov[0].iov_len = sizeof("jid");
730 	jiov[1].iov_base = &j->jid;
731 	jiov[1].iov_len = sizeof(j->jid);
732 	jiov[2].iov_base = __DECONST(char *, "nopersist");
733 	jiov[2].iov_len = sizeof("nopersist");
734 	jiov[3].iov_base = NULL;
735 	jiov[3].iov_len = 0;
736 	jid = jail_set(jiov, 4, JAIL_UPDATE);
737 	if (verbose > 0)
738 		jail_note(j, "jail_set(JAIL_UPDATE) jid=%d nopersist%s%s\n",
739 		    j->jid, jid < 0 ? ": " : "",
740 		    jid < 0 ? strerror(errno) : "");
741 }
742 
743 /*
744  * Set a jail's parameters.
745  */
746 static int
747 update_jail(struct cfjail *j)
748 {
749 	struct jailparam *jp, *setparams, *sjp;
750 	int ns, jid;
751 
752 	ns = 0;
753 	for (jp = j->jp; jp < j->jp + j->njp; jp++)
754 		if (!JP_RDTUN(jp))
755 			ns++;
756 	if (ns == 0)
757 		return 0;
758 	sjp = setparams = alloca(++ns * sizeof(struct jailparam));
759 	if (jailparam_init(sjp, "jid") < 0 ||
760 	    jailparam_import_raw(sjp, &j->jid, sizeof j->jid) < 0) {
761 		jail_warnx(j, "%s", jail_errmsg);
762 		failed(j);
763 		return -1;
764 	}
765 	for (jp = j->jp; jp < j->jp + j->njp; jp++)
766 		if (!JP_RDTUN(jp))
767 			*++sjp = *jp;
768 
769 	jid = jailparam_set_note(j, setparams, ns,
770 	    bool_param(j->intparams[IP_ALLOW_DYING])
771 	    ? JAIL_UPDATE | JAIL_DYING : JAIL_UPDATE);
772 	if (jid < 0) {
773 		jail_warnx(j, "%s", jail_errmsg);
774 		failed(j);
775 	}
776 	jailparam_free(setparams, 1);
777 	return jid;
778 }
779 
780 /*
781  * Return if a jail set would change any create-only parameters.
782  */
783 static int
784 rdtun_params(struct cfjail *j, int dofail)
785 {
786 	struct jailparam *jp, *rtparams, *rtjp;
787 	int nrt, rval;
788 
789 	if (j->flags & JF_RDTUN)
790 		return 0;
791 	j->flags |= JF_RDTUN;
792 	nrt = 0;
793 	for (jp = j->jp; jp < j->jp + j->njp; jp++)
794 		if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid"))
795 			nrt++;
796 	if (nrt == 0)
797 		return 0;
798 	rtjp = rtparams = alloca(++nrt * sizeof(struct jailparam));
799 	if (jailparam_init(rtjp, "jid") < 0 ||
800 	    jailparam_import_raw(rtjp, &j->jid, sizeof j->jid) < 0) {
801 		jail_warnx(j, "%s", jail_errmsg);
802 		exit(1);
803 	}
804 	for (jp = j->jp; jp < j->jp + j->njp; jp++)
805 		if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid"))
806 			*++rtjp = *jp;
807 	rval = 0;
808 	if (jailparam_get(rtparams, nrt,
809 	    bool_param(j->intparams[IP_ALLOW_DYING]) ? JAIL_DYING : 0) > 0) {
810 		rtjp = rtparams + 1;
811 		for (jp = j->jp; rtjp < rtparams + nrt; jp++) {
812 			if (JP_RDTUN(jp) && strcmp(jp->jp_name, "jid")) {
813 				if (!((jp->jp_flags & (JP_BOOL | JP_NOBOOL)) &&
814 				    jp->jp_valuelen == 0 &&
815 				    *(int *)jp->jp_value) &&
816 				    !(rtjp->jp_valuelen == jp->jp_valuelen &&
817 				    !memcmp(rtjp->jp_value, jp->jp_value,
818 				    jp->jp_valuelen))) {
819 					if (dofail) {
820 						jail_warnx(j, "%s cannot be "
821 						    "changed after creation",
822 						    jp->jp_name);
823 						failed(j);
824 						rval = -1;
825 					} else
826 						rval = 1;
827 					break;
828 				}
829 				rtjp++;
830 			}
831 		}
832 	}
833 	for (rtjp = rtparams + 1; rtjp < rtparams + nrt; rtjp++)
834 		rtjp->jp_name = NULL;
835 	jailparam_free(rtparams, nrt);
836 	return rval;
837 }
838 
839 /*
840  * Get the jail's jid if it is running.
841  */
842 static void
843 running_jid(struct cfjail *j, int dflag)
844 {
845 	struct iovec jiov[2];
846 	const char *pval;
847 	char *ep;
848 	int jid;
849 
850 	if ((pval = string_param(j->intparams[KP_JID]))) {
851 		if (!(jid = strtol(pval, &ep, 10)) || *ep) {
852 			j->jid = -1;
853 			return;
854 		}
855 		jiov[0].iov_base = __DECONST(char *, "jid");
856 		jiov[0].iov_len = sizeof("jid");
857 		jiov[1].iov_base = &jid;
858 		jiov[1].iov_len = sizeof(jid);
859 	} else if ((pval = string_param(j->intparams[KP_NAME]))) {
860 		jiov[0].iov_base = __DECONST(char *, "name");
861 		jiov[0].iov_len = sizeof("name");
862 		jiov[1].iov_len = strlen(pval) + 1;
863 		jiov[1].iov_base = alloca(jiov[1].iov_len);
864 		strcpy(jiov[1].iov_base, pval);
865 	} else {
866 		j->jid = -1;
867 		return;
868 	}
869 	j->jid = jail_get(jiov, 2, dflag ? JAIL_DYING : 0);
870 }
871 
872 static void
873 jail_quoted_warnx(const struct cfjail *j, const char *name_msg,
874     const char *noname_msg)
875 {
876 	const char *pval;
877 
878 	if ((pval = j->name) || (pval = string_param(j->intparams[KP_JID])) ||
879 	    (pval = string_param(j->intparams[KP_NAME])))
880 		warnx("\"%s\" %s", pval, name_msg);
881 	else
882 		warnx("%s", noname_msg);
883 }
884 
885 /*
886  * Set jail parameters and possibly print them out.
887  */
888 static int
889 jailparam_set_note(const struct cfjail *j, struct jailparam *jp, unsigned njp,
890     int flags)
891 {
892 	char *value;
893 	int jid;
894 	unsigned i;
895 
896 	jid = jailparam_set(jp, njp, flags);
897 	if (verbose > 0) {
898 		jail_note(j, "jail_set(%s%s)",
899 		    (flags & (JAIL_CREATE | JAIL_UPDATE)) == JAIL_CREATE
900 		    ? "JAIL_CREATE" : "JAIL_UPDATE",
901 		    (flags & JAIL_DYING) ? " | JAIL_DYING" : "");
902 		for (i = 0; i < njp; i++) {
903 			printf(" %s", jp[i].jp_name);
904 			if (jp[i].jp_value == NULL)
905 				continue;
906 			putchar('=');
907 			value = jailparam_export(jp + i);
908 			if (value == NULL)
909 				err(1, "jailparam_export");
910 			quoted_print(stdout, value);
911 			free(value);
912 		}
913 		if (jid < 0)
914 			printf(": %s", strerror(errno));
915 		printf("\n");
916 	}
917 	return jid;
918 }
919 
920 /*
921  * Print a jail record.
922  */
923 static void
924 print_jail(FILE *fp, struct cfjail *j, int oldcl)
925 {
926 	struct cfparam *p;
927 
928 	if (oldcl) {
929 		fprintf(fp, "%d\t", j->jid);
930 		print_param(fp, j->intparams[KP_PATH], ',', 0);
931 		putc('\t', fp);
932 		print_param(fp, j->intparams[KP_HOST_HOSTNAME], ',', 0);
933 		putc('\t', fp);
934 #ifdef INET
935 		print_param(fp, j->intparams[KP_IP4_ADDR], ',', 0);
936 #ifdef INET6
937 		if (j->intparams[KP_IP4_ADDR] &&
938 		    !TAILQ_EMPTY(&j->intparams[KP_IP4_ADDR]->val) &&
939 		    j->intparams[KP_IP6_ADDR] &&
940 		    !TAILQ_EMPTY(&j->intparams[KP_IP6_ADDR]->val))
941 		    putc(',', fp);
942 #endif
943 #endif
944 #ifdef INET6
945 		print_param(fp, j->intparams[KP_IP6_ADDR], ',', 0);
946 #endif
947 		putc('\t', fp);
948 		print_param(fp, j->intparams[IP_COMMAND], ' ', 0);
949 	} else {
950 		fprintf(fp, "jid=%d", j->jid);
951 		TAILQ_FOREACH(p, &j->params, tq)
952 			if (strcmp(p->name, "jid")) {
953 				putc(' ', fp);
954 				print_param(fp, p, ',', 1);
955 			}
956 	}
957 	putc('\n', fp);
958 }
959 
960 /*
961  * Print a parameter value, or a name=value pair.
962  */
963 static void
964 print_param(FILE *fp, const struct cfparam *p, int sep, int doname)
965 {
966 	const struct cfstring *s, *ts;
967 
968 	if (doname)
969 		fputs(p->name, fp);
970 	if (p == NULL || TAILQ_EMPTY(&p->val))
971 		return;
972 	if (doname)
973 		putc('=', fp);
974 	TAILQ_FOREACH_SAFE(s, &p->val, tq, ts) {
975 		quoted_print(fp, s->s);
976 		if (ts != NULL)
977 			putc(sep, fp);
978 	}
979 }
980 
981 /*
982  * Print a string with quotes around spaces.
983  */
984 static void
985 quoted_print(FILE *fp, char *str)
986 {
987 	int c, qc;
988 	char *p = str;
989 
990 	qc = !*p ? '"'
991 	    : strchr(p, '\'') ? '"'
992 	    : strchr(p, '"') ? '\''
993 	    : strchr(p, ' ') || strchr(p, '\t') ? '"'
994 	    : 0;
995 	if (qc)
996 		putc(qc, fp);
997 	while ((c = *p++)) {
998 		if (c == '\\' || c == qc)
999 			putc('\\', fp);
1000 		putc(c, fp);
1001 	}
1002 	if (qc)
1003 		putc(qc, fp);
1004 }
1005 
1006 static void
1007 usage(void)
1008 {
1009 
1010 	(void)fprintf(stderr,
1011 	    "usage: jail [-dhilqv] [-J jid_file] [-u username] [-U username]\n"
1012 	    "            -[cmr] param=value ... [command=command ...]\n"
1013 	    "       jail [-dqv] [-f file] -[cmr] [jail]\n"
1014 	    "       jail [-qv] [-f file] -[rR] ['*' | jail ...]\n"
1015 	    "       jail [-dhilqv] [-J jid_file] [-u username] [-U username]\n"
1016 	    "            [-n jailname] [-s securelevel]\n"
1017 	    "            path hostname [ip[,...]] command ...\n");
1018 	exit(1);
1019 }
1020