Attachment #157719 for bug #200746

Lines 4-10 Link Here

(-)b/usr.sbin/jls/Makefile (-1 / +1 lines)
4		4
5	PROG= jls	5	PROG= jls
6	MAN= jls.8	6	MAN= jls.8
7	LIBADD= jail	7	LIBADD= jail xo
8		8
9	.if ${MK_INET6_SUPPORT} != "no"	9	.if ${MK_INET6_SUPPORT} != "no"
10	CFLAGS+= -DINET6	10	CFLAGS+= -DINET6

Lines 33-38 Link Here

(-)b/usr.sbin/jls/jls.8 (+1 lines)
33	.Nd "list jails"	33	.Nd "list jails"
34	.Sh SYNOPSIS	34	.Sh SYNOPSIS
35	.Nm	35	.Nm
		36	.Op Fl -libxo
36	.Op Fl dhNnqsv	37	.Op Fl dhNnqsv
37	.Op Fl j Ar jail	38	.Op Fl j Ar jail
38	.Op Ar parameter ...	39	.Op Ar parameter ...




 * Copyright (c) 2003 Mike Barcroft <mike@FreeBSD.org>
 * Copyright (c) 2008 Bjoern A. Zeeb <bz@FreeBSD.org>
 * Copyright (c) 2009 James Gritton <jamie@FreeBSD.org>
 * Copyright (c) 2015 Emmanuel Vadot <manu@bocal.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libxo/xo.h>

#define	JP_USER		0x01000000
#define	JP_OPT		0x02000000

static char *noname(const char *name);
static char *nononame(const char *name);
static int print_jail(int pflags, int jflags);
static void quoted_print(int pflags, char *name, char *value);

int
main(int argc, char **argv)

	char *dot, *ep, *jname, *pname;
	int c, i, jflags, jid, lastjid, pflags, spc;

	argc = xo_parse_args(argc, argv);
	if (argc < 0)
		exit(1);

	jname = NULL;
	pflags = jflags = jid = 0;
	while ((c = getopt(argc, argv, "adj:hNnqsv")) >= 0)

			    PRINT_VERBOSE;
			break;
		default:
			xo_errx(1, "usage: jls [-dhNnqv] [-j jail] [param ...]");
		}

#ifdef INET6

		add_param("lastjid", &lastjid, sizeof(lastjid), NULL, 0);

	/* Print a header line if requested. */
	if (pflags & PRINT_VERBOSE) {
		xo_emit("{P:   }{T:JID}{P:  }{T:Hostname}{P:/%22s}{T:Path}\n", "");
		xo_emit("{P:/%8s}{T:Name}{Pd:/%26s}{T:State}\n", "", "");
		xo_emit("{P:/%8s}{T:CPUSetID}\n", "");
		xo_emit("{P:/%8s}{T:IP Address(es)}\n", "");
	}
	else if (pflags & PRINT_DEFAULT)
		if (pflags & PRINT_JAIL_NAME)
			xo_emit("{P: }{T:JID}{P:/%13s}{T:IP Address}{P:/%6s}"
			        "{T:Hostname}{P:/%22s}{T:Path}\n", "", "", "");
		else
			xo_emit("{P:   }{T:JID}{P:  }{T:IP Address}{P:/%6s}"
			        "{T:Hostname}{P:/%22s}{T:Path}\n", "", "");
	else if (pflags & PRINT_HEADER) {
		for (i = spc = 0; i < nparams; i++)
			if (params[i].jp_flags & JP_USER) {
				if (spc)
					xo_emit("{P: }");
				else
					spc = 1;
				xo_emit(params[i].jp_name, stdout);
			}
		xo_emit("{P:\n}");
	}

	xo_open_list("jails");
	/* Fetch the jail(s) and print the paramters. */
	if (jid != 0 || jname != NULL) {
		if (print_jail(pflags, jflags) < 0)
			xo_errx(1, "%s", jail_errmsg);
	} else {
		for (lastjid = 0;
		     (lastjid = print_jail(pflags, jflags)) >= 0; )
			;
		if (errno != 0 && errno != ENOENT)
			xo_errx(1, "%s", jail_errmsg);
	}
	xo_close_list("jails");
	xo_finish();
	return (0);
}


	if (!strcmp(name, "all")) {
		tnparams = jailparam_all(&tparams);
		if (tnparams < 0)
			xo_errx(1, "%s", jail_errmsg);
		qsort(tparams, (size_t)tnparams, sizeof(struct jailparam),
		    sort_param);
		for (i = 0; i < tnparams; i++)

		if (!strcmp(name, params[i].jp_name)) {
			if (value != NULL && jailparam_import_raw(params + i,
			    value, valuelen) < 0)
				xo_errx(1, "%s", jail_errmsg);
			params[i].jp_flags |= flags;
			if (source != NULL)
				jailparam_free(source, 1);

			nparams--;
			return (-1);
		}
		xo_errx(1, "%s", jail_errmsg);
	}
	param->jp_flags = flags;
	return param - params;

static int
print_jail(int pflags, int jflags)
{
	char *nname, *xo_nname;
	char **param_values;
	int i, ai, jid, count, n, spc;
	char ipbuf[INET6_ADDRSTRLEN];

	jid = jailparam_get(params, nparams, jflags);
	if (jid < 0)
		return jid;

	xo_open_instance("jails");

	if (pflags & PRINT_VERBOSE) {
		xo_emit("{:jid/%6d}{P:  }{e:hostname/%s}{d:hostname/%-29.29s}{P: }{:path/%.74s}\n",
			*(int *)params[0].jp_value,
			(char *)params[1].jp_value,
			(char *)params[1].jp_value,
			(char *)params[2].jp_value);
		xo_emit("{P:        }{e:name/%s}{d:name/%-29.29s}{P: }{:state/%.74s}\n",
			(char *)params[3].jp_value,
			(char *)params[3].jp_value,
			*(int *)params[4].jp_value ? "DYING" : "ACTIVE");
		xo_emit("{P:        }{:cpusetid/%d}\n", *(int *)params[5].jp_value);
		    *(int *)params[5].jp_value);
		n = 6;
#ifdef INET
		if (ip4_ok && !strcmp(params[n].jp_name, "ip4.addr")) {

				    &((struct in_addr *)params[n].jp_value)[ai],
				    ipbuf, sizeof(ipbuf)) == NULL)
					err(1, "inet_ntop");
				else {
					xo_emit("{P:        }{l:ipv4_addrs}{P:\n}", ipbuf);
				}
			n++;
		}
#endif

				    ipbuf, sizeof(ipbuf)) == NULL)
					err(1, "inet_ntop");
				else
					xo_emit("{P:        }{l:ipv6_addrs}{P:\n}", ipbuf);
			n++;
		}
#endif
	} else if (pflags & PRINT_DEFAULT) {
		if (pflags & PRINT_JAIL_NAME)
			xo_emit("{P: }{e:name/%s}{d:name/%-15s}{P: }",
				(char *)params[0].jp_value,
				(char *)params[0].jp_value);
		else
			xo_emit("{:jid/%6d}{P:  }", *(int *)params[0].jp_value);
		xo_emit("{e:ipv4/%s}{d:ipv4/%-15.15s}{P: }{e:hostname/%s}{d:hostname/%-29.29s}{P: }{:path/%.74s}\n",
#ifdef INET
		    (!ip4_ok || params[1].jp_valuelen == 0) ? ""
		    : inet_ntoa(*(struct in_addr *)params[1].jp_value),
		    (!ip4_ok || params[1].jp_valuelen == 0) ? "-"
		    : inet_ntoa(*(struct in_addr *)params[1].jp_value),
		    (char *)params[2-!ip4_ok].jp_value,
		    (char *)params[2-!ip4_ok].jp_value,
		    (char *)params[3-!ip4_ok].jp_value);
#else
		    "-",
		    "-",
		    (char *)params[1].jp_value,
		    (char *)params[1].jp_value,
		    (char *)params[2].jp_value);
#endif

				continue;
			param_values[i] = jailparam_export(params + i);
			if (param_values[i] == NULL)
				xo_errx(1, "%s", jail_errmsg);
		}
		for (i = spc = 0; i < nparams; i++) {
			if (!(params[i].jp_flags & JP_USER))

			      JAIL_SYS_NEW)))
				continue;
			if (spc)
				xo_emit("{P: }");
			else
				spc = 1;
			if (pflags & PRINT_NAMEVAL) {

				 */
				if (params[i].jp_flags &
				    (JP_BOOL | JP_NOBOOL)) {
					if (*(int *)params[i].jp_value) {
						asprintf(&xo_nname, "{en:%s/true}", params[i].jp_name);
						xo_emit(xo_nname);
						xo_emit("{d:/%s}", params[i].jp_name);
					}
					else {
						nname = (params[i].jp_flags &
						    JP_NOBOOL) ?
						    nononame(params[i].jp_name)
						    : noname(params[i].jp_name);
						if (params[i].jp_flags & JP_NOBOOL) {
							asprintf(&xo_nname, "{en:%s/true}", params[i].jp_name);
							xo_emit(xo_nname);
						} else {
							asprintf(&xo_nname, "{en:%s/false}", params[i].jp_name);
							xo_emit(xo_nname);
						}
						xo_emit("{d:/%s}", nname);
						free(nname);
					}
					free(xo_nname);
					continue;
				}
				xo_emit("{d:%s}=", params[i].jp_name);
			}
			if (params[i].jp_valuelen == 0) {
				if (pflags & PRINT_QUOTED)
					xo_emit("{P:\"\"}");
				else if (!(pflags & PRINT_NAMEVAL))
					xo_emit("{P:-}");
			} else {
				quoted_print(pflags, params[i].jp_name, param_values[i]);
			}
		}
		xo_emit("{P:\n}");
		for (i = 0; i < nparams; i++)
			if (params[i].jp_flags & JP_USER)
				free(param_values[i]);
	}

	xo_close_instance("jails");
	return (jid);
}

static void
quoted_print(int pflags, char *name, char *value)
{
	int qc;
	char *p = value;
	char *param_name_value;


	/* An empty string needs quoting. */
	if (!*p) {
		asprintf(&param_name_value, "{k:%s}{d:%s/\"\"}", name, name);
		xo_emit(param_name_value);
		free(param_name_value);
		return;
	}

	asprintf(&param_name_value, "{:%s/%%s}", name);

	 * or quotes.
	 */
	qc = strchr(p, '\'') ? '"'
		: strchr(p, '"') ? '\''
		: strchr(p, ' ') || strchr(p, '\t') ? '"'
		: 0;

	if (qc && pflags & PRINT_QUOTED)
		xo_emit("{P:/%c}", qc);

	xo_emit(param_name_value, value);

	free(param_name_value);

	if (qc && pflags & PRINT_QUOTED)
		xo_emit("{P:/%c}", qc);
}

Return to bug 200746

Lines 2-7 Link Here

(-)b/usr.sbin/jls/jls.c (-70 / +105 lines)
2	* Copyright (c) 2003 Mike Barcroft <mike@FreeBSD.org>	2	* Copyright (c) 2003 Mike Barcroft <mike@FreeBSD.org>
3	* Copyright (c) 2008 Bjoern A. Zeeb <bz@FreeBSD.org>	3	* Copyright (c) 2008 Bjoern A. Zeeb <bz@FreeBSD.org>
4	* Copyright (c) 2009 James Gritton <jamie@FreeBSD.org>	4	* Copyright (c) 2009 James Gritton <jamie@FreeBSD.org>
		5	* Copyright (c) 2015 Emmanuel Vadot <manu@bocal.org>
5	* All rights reserved.	6	* All rights reserved.
6	*	7	*
7	* Redistribution and use in source and binary forms, with or without	8	* Redistribution and use in source and binary forms, with or without
Lines 45-50 __FBSDID("$FreeBSD$"); Link Here
45	#include <stdlib.h>	46	#include <stdlib.h>
46	#include <string.h>	47	#include <string.h>
47	#include <unistd.h>	48	#include <unistd.h>
		49	#include <libxo/xo.h>
48		50
49	#define JP_USER 0x01000000	51	#define JP_USER 0x01000000
50	#define JP_OPT 0x02000000	52	#define JP_OPT 0x02000000
Lines 73-79 static int sort_param(const void a, const void b); Link Here
73	static char noname(const char name);	75	static char noname(const char name);
74	static char nononame(const char name);	76	static char nononame(const char name);
75	static int print_jail(int pflags, int jflags);	77	static int print_jail(int pflags, int jflags);
76	static void quoted_print(char *str);	78	static void quoted_print(int pflags, char name, char value);
77		79
78	int	80	int
79	main(int argc, char **argv)	81	main(int argc, char **argv)
Lines 81-86 main(int argc, char **argv) Link Here
81	char dot, ep, jname, pname;	83	char dot, ep, jname, pname;
82	int c, i, jflags, jid, lastjid, pflags, spc;	84	int c, i, jflags, jid, lastjid, pflags, spc;
83		85
		86	argc = xo_parse_args(argc, argv);
		87	if (argc < 0)
		88	exit(1);
		89
84	jname = NULL;	90	jname = NULL;
85	pflags = jflags = jid = 0;	91	pflags = jflags = jid = 0;
86	while ((c = getopt(argc, argv, "adj:hNnqsv")) >= 0)	92	while ((c = getopt(argc, argv, "adj:hNnqsv")) >= 0)
Lines 119-125 main(int argc, char **argv) Link Here
119	PRINT_VERBOSE;	125	PRINT_VERBOSE;
120	break;	126	break;
121	default:	127	default:
122	errx(1, "usage: jls [-dhNnqv] [-j jail] [param ...]");	128	xo_errx(1, "usage: jls [-dhNnqv] [-j jail] [param ...]");
123	}	129	}
124		130
125	#ifdef INET6	131	#ifdef INET6
Lines 196-237 main(int argc, char **argv) Link Here
196	add_param("lastjid", &lastjid, sizeof(lastjid), NULL, 0);	202	add_param("lastjid", &lastjid, sizeof(lastjid), NULL, 0);
197		203
198	/* Print a header line if requested. */	204	/* Print a header line if requested. */
199	if (pflags & PRINT_VERBOSE)	205	if (pflags & PRINT_VERBOSE) {
200	printf(" JID Hostname Path\n"	206	xo_emit("{P: }{T:JID}{P: }{T:Hostname}{P:/%22s}{T:Path}\n", "");
201	" Name State\n"	207	xo_emit("{P:/%8s}{T:Name}{Pd:/%26s}{T:State}\n", "", "");
202	" CPUSetID\n"	208	xo_emit("{P:/%8s}{T:CPUSetID}\n", "");
203	" IP Address(es)\n");	209	xo_emit("{P:/%8s}{T:IP Address(es)}\n", "");
		210	}
204	else if (pflags & PRINT_DEFAULT)	211	else if (pflags & PRINT_DEFAULT)
205	if (pflags & PRINT_JAIL_NAME)	212	if (pflags & PRINT_JAIL_NAME)
206	printf(" JID IP Address "	213	xo_emit("{P: }{T:JID}{P:/%13s}{T:IP Address}{P:/%6s}"
207	"Hostname Path\n");	214	"{T:Hostname}{P:/%22s}{T:Path}\n", "", "", "");
208	else	215	else
209	printf(" JID IP Address "	216	xo_emit("{P: }{T:JID}{P: }{T:IP Address}{P:/%6s}"
210	"Hostname Path\n");	217	"{T:Hostname}{P:/%22s}{T:Path}\n", "", "");
211	else if (pflags & PRINT_HEADER) {	218	else if (pflags & PRINT_HEADER) {
212	for (i = spc = 0; i < nparams; i++)	219	for (i = spc = 0; i < nparams; i++)
213	if (params[i].jp_flags & JP_USER) {	220	if (params[i].jp_flags & JP_USER) {
214	if (spc)	221	if (spc)
215	putchar(' ');	222	xo_emit("{P: }");
216	else	223	else
217	spc = 1;	224	spc = 1;
218	fputs(params[i].jp_name, stdout);	225	xo_emit(params[i].jp_name, stdout);
219	}	226	}
220	putchar('\n');	227	xo_emit("{P:\n}");
221	}	228	}
222		229
		230	xo_open_list("jails");
223	/* Fetch the jail(s) and print the paramters. */	231	/* Fetch the jail(s) and print the paramters. */
224	if (jid != 0 \|\| jname != NULL) {	232	if (jid != 0 \|\| jname != NULL) {
225	if (print_jail(pflags, jflags) < 0)	233	if (print_jail(pflags, jflags) < 0)
226	errx(1, "%s", jail_errmsg);	234	xo_errx(1, "%s", jail_errmsg);
227	} else {	235	} else {
228	for (lastjid = 0;	236	for (lastjid = 0;
229	(lastjid = print_jail(pflags, jflags)) >= 0; )	237	(lastjid = print_jail(pflags, jflags)) >= 0; )
230	;	238	;
231	if (errno != 0 && errno != ENOENT)	239	if (errno != 0 && errno != ENOENT)
232	errx(1, "%s", jail_errmsg);	240	xo_errx(1, "%s", jail_errmsg);
233	}	241	}
234		242	xo_close_list("jails");
		243	xo_finish();
235	return (0);	244	return (0);
236	}	245	}
237		246
Lines 248-254 add_param(const char name, void value, size_t valuelen, Link Here
248	if (!strcmp(name, "all")) {	257	if (!strcmp(name, "all")) {
249	tnparams = jailparam_all(&tparams);	258	tnparams = jailparam_all(&tparams);
250	if (tnparams < 0)	259	if (tnparams < 0)
251	errx(1, "%s", jail_errmsg);	260	xo_errx(1, "%s", jail_errmsg);
252	qsort(tparams, (size_t)tnparams, sizeof(struct jailparam),	261	qsort(tparams, (size_t)tnparams, sizeof(struct jailparam),
253	sort_param);	262	sort_param);
254	for (i = 0; i < tnparams; i++)	263	for (i = 0; i < tnparams; i++)
Lines 263-269 add_param(const char name, void value, size_t valuelen, Link Here
263	if (!strcmp(name, params[i].jp_name)) {	272	if (!strcmp(name, params[i].jp_name)) {
264	if (value != NULL && jailparam_import_raw(params + i,	273	if (value != NULL && jailparam_import_raw(params + i,
265	value, valuelen) < 0)	274	value, valuelen) < 0)
266	errx(1, "%s", jail_errmsg);	275	xo_errx(1, "%s", jail_errmsg);
267	params[i].jp_flags \|= flags;	276	params[i].jp_flags \|= flags;
268	if (source != NULL)	277	if (source != NULL)
269	jailparam_free(source, 1);	278	jailparam_free(source, 1);
Lines 301-307 add_param(const char name, void value, size_t valuelen, Link Here
301	nparams--;	310	nparams--;
302	return (-1);	311	return (-1);
303	}	312	}
304	errx(1, "%s", jail_errmsg);	313	xo_errx(1, "%s", jail_errmsg);
305	}	314	}
306	param->jp_flags = flags;	315	param->jp_flags = flags;
307	return param - params;	316	return param - params;
Lines 362-368 nononame(const char *name) Link Here
362	static int	371	static int
363	print_jail(int pflags, int jflags)	372	print_jail(int pflags, int jflags)
364	{	373	{
365	char *nname;	374	char nname, xo_nname;
366	char **param_values;	375	char **param_values;
367	int i, ai, jid, count, n, spc;	376	int i, ai, jid, count, n, spc;
368	char ipbuf[INET6_ADDRSTRLEN];	377	char ipbuf[INET6_ADDRSTRLEN];
Lines 370-387 print_jail(int pflags, int jflags) Link Here
370	jid = jailparam_get(params, nparams, jflags);	379	jid = jailparam_get(params, nparams, jflags);
371	if (jid < 0)	380	if (jid < 0)
372	return jid;	381	return jid;
		382
		383	xo_open_instance("jails");
		384
373	if (pflags & PRINT_VERBOSE) {	385	if (pflags & PRINT_VERBOSE) {
374	printf("%6d %-29.29s %.74s\n"	386	xo_emit("{:jid/%6d}{P: }{e:hostname/%s}{d:hostname/%-29.29s}{P: }{:path/%.74s}\n",
375	"%6s %-29.29s %.74s\n"	387	(int )params[0].jp_value,
376	"%6s %-6d\n",	388	(char *)params[1].jp_value,
377	(int )params[0].jp_value,	389	(char *)params[1].jp_value,
378	(char *)params[1].jp_value,	390	(char *)params[2].jp_value);
379	(char *)params[2].jp_value,	391	xo_emit("{P: }{e:name/%s}{d:name/%-29.29s}{P: }{:state/%.74s}\n",
380	"",	392	(char *)params[3].jp_value,
381	(char *)params[3].jp_value,	393	(char *)params[3].jp_value,
382	(int )params[4].jp_value ? "DYING" : "ACTIVE",	394	(int )params[4].jp_value ? "DYING" : "ACTIVE");
383	"",	395	xo_emit("{P: }{:cpusetid/%d}\n", (int )params[5].jp_value);
384	(int )params[5].jp_value);
385	n = 6;	396	n = 6;
386	#ifdef INET	397	#ifdef INET
387	if (ip4_ok && !strcmp(params[n].jp_name, "ip4.addr")) {	398	if (ip4_ok && !strcmp(params[n].jp_name, "ip4.addr")) {
Lines 391-398 print_jail(int pflags, int jflags) Link Here
391	&((struct in_addr *)params[n].jp_value)[ai],	402	&((struct in_addr *)params[n].jp_value)[ai],
392	ipbuf, sizeof(ipbuf)) == NULL)	403	ipbuf, sizeof(ipbuf)) == NULL)
393	err(1, "inet_ntop");	404	err(1, "inet_ntop");
394	else	405	else {
395	printf("%6s %-15.15s\n", "", ipbuf);	406	xo_emit("{P: }{l:ipv4_addrs}{P:\n}", ipbuf);
		407	}
396	n++;	408	n++;
397	}	409	}
398	#endif	410	#endif
Lines 406-428 print_jail(int pflags, int jflags) Link Here
406	ipbuf, sizeof(ipbuf)) == NULL)	418	ipbuf, sizeof(ipbuf)) == NULL)
407	err(1, "inet_ntop");	419	err(1, "inet_ntop");
408	else	420	else
409	printf("%6s %s\n", "", ipbuf);	421	xo_emit("{P: }{l:ipv6_addrs}{P:\n}", ipbuf);
410	n++;	422	n++;
411	}	423	}
412	#endif	424	#endif
413	} else if (pflags & PRINT_DEFAULT) {	425	} else if (pflags & PRINT_DEFAULT) {
414	if (pflags & PRINT_JAIL_NAME)	426	if (pflags & PRINT_JAIL_NAME)
415	printf(" %-15s ", (char *)params[0].jp_value);	427	xo_emit("{P: }{e:name/%s}{d:name/%-15s}{P: }",
		428	(char *)params[0].jp_value,
		429	(char *)params[0].jp_value);
416	else	430	else
417	printf("%6d ", (int )params[0].jp_value);	431	xo_emit("{:jid/%6d}{P: }", (int )params[0].jp_value);
418	printf("%-15.15s %-29.29s %.74s\n",	432	xo_emit("{e:ipv4/%s}{d:ipv4/%-15.15s}{P: }{e:hostname/%s}{d:hostname/%-29.29s}{P: }{:path/%.74s}\n",
419	#ifdef INET	433	#ifdef INET
		434	(!ip4_ok \|\| params[1].jp_valuelen == 0) ? ""
		435	: inet_ntoa((struct in_addr )params[1].jp_value),
420	(!ip4_ok \|\| params[1].jp_valuelen == 0) ? "-"	436	(!ip4_ok \|\| params[1].jp_valuelen == 0) ? "-"
421	: inet_ntoa((struct in_addr )params[1].jp_value),	437	: inet_ntoa((struct in_addr )params[1].jp_value),
422	(char *)params[2-!ip4_ok].jp_value,	438	(char *)params[2-!ip4_ok].jp_value,
		439	(char *)params[2-!ip4_ok].jp_value,
423	(char *)params[3-!ip4_ok].jp_value);	440	(char *)params[3-!ip4_ok].jp_value);
424	#else	441	#else
425	"-",	442	"-",
		443	"-",
		444	(char *)params[1].jp_value,
426	(char *)params[1].jp_value,	445	(char *)params[1].jp_value,
427	(char *)params[2].jp_value);	446	(char *)params[2].jp_value);
428	#endif	447	#endif
Lines 433-439 print_jail(int pflags, int jflags) Link Here
433	continue;	452	continue;
434	param_values[i] = jailparam_export(params + i);	453	param_values[i] = jailparam_export(params + i);
435	if (param_values[i] == NULL)	454	if (param_values[i] == NULL)
436	errx(1, "%s", jail_errmsg);	455	xo_errx(1, "%s", jail_errmsg);
437	}	456	}
438	for (i = spc = 0; i < nparams; i++) {	457	for (i = spc = 0; i < nparams; i++) {
439	if (!(params[i].jp_flags & JP_USER))	458	if (!(params[i].jp_flags & JP_USER))
Lines 446-452 print_jail(int pflags, int jflags) Link Here
446	JAIL_SYS_NEW)))	465	JAIL_SYS_NEW)))
447	continue;	466	continue;
448	if (spc)	467	if (spc)
449	putchar(' ');	468	xo_emit("{P: }");
450	else	469	else
451	spc = 1;	470	spc = 1;
452	if (pflags & PRINT_NAMEVAL) {	471	if (pflags & PRINT_NAMEVAL) {
Lines 456-518 print_jail(int pflags, int jflags) Link Here
456	*/	475	*/
457	if (params[i].jp_flags &	476	if (params[i].jp_flags &
458	(JP_BOOL \| JP_NOBOOL)) {	477	(JP_BOOL \| JP_NOBOOL)) {
459	if ((int )params[i].jp_value)	478	if ((int )params[i].jp_value) {
460	printf("%s", params[i].jp_name);	479	asprintf(&xo_nname, "{en:%s/true}", params[i].jp_name);
		480	xo_emit(xo_nname);
		481	xo_emit("{d:/%s}", params[i].jp_name);
		482	}
461	else {	483	else {
462	nname = (params[i].jp_flags &	484	nname = (params[i].jp_flags &
463	JP_NOBOOL) ?	485	JP_NOBOOL) ?
464	nononame(params[i].jp_name)	486	nononame(params[i].jp_name)
465	: noname(params[i].jp_name);	487	: noname(params[i].jp_name);
466	printf("%s", nname);	488	if (params[i].jp_flags & JP_NOBOOL) {
		489	asprintf(&xo_nname, "{en:%s/true}", params[i].jp_name);
		490	xo_emit(xo_nname);
		491	} else {
		492	asprintf(&xo_nname, "{en:%s/false}", params[i].jp_name);
		493	xo_emit(xo_nname);
		494	}
		495	xo_emit("{d:/%s}", nname);
467	free(nname);	496	free(nname);
468	}	497	}
		498	free(xo_nname);
469	continue;	499	continue;
470	}	500	}
471	printf("%s=", params[i].jp_name);	501	xo_emit("{d:%s}=", params[i].jp_name);
472	}	502	}
473	if (params[i].jp_valuelen == 0) {	503	if (params[i].jp_valuelen == 0) {
474	if (pflags & PRINT_QUOTED)	504	if (pflags & PRINT_QUOTED)
475	printf("\"\"");	505	xo_emit("{P:\"\"}");
476	else if (!(pflags & PRINT_NAMEVAL))	506	else if (!(pflags & PRINT_NAMEVAL))
477	putchar('-');	507	xo_emit("{P:-}");
478	} else	508	} else {
479	quoted_print(param_values[i]);	509	quoted_print(pflags, params[i].jp_name, param_values[i]);
		510	}
480	}	511	}
481	putchar('\n');	512	xo_emit("{P:\n}");
482	for (i = 0; i < nparams; i++)	513	for (i = 0; i < nparams; i++)
483	if (params[i].jp_flags & JP_USER)	514	if (params[i].jp_flags & JP_USER)
484	free(param_values[i]);	515	free(param_values[i]);
485	}	516	}
		517
		518	xo_close_instance("jails");
486	return (jid);	519	return (jid);
487	}	520	}
488		521
489	static void	522	static void
490	quoted_print(char *str)	523	quoted_print(int pflags, char name, char value)
491	{	524	{
492	int c, qc;	525	int qc;
493	char *p = str;	526	char *p = value;
		527	char *param_name_value;
		528
494		529
495	/* An empty string needs quoting. */
496	if (!*p) {	530	if (!*p) {
497	fputs("\"\"", stdout);	531	asprintf(&param_name_value, "{k:%s}{d:%s/\"\"}", name, name);
		532	xo_emit(param_name_value);
		533	free(param_name_value);
498	return;	534	return;
499	}	535	}
500		536
501	/*	537	asprintf(&param_name_value, "{:%s/%%s}", name);
502	* The value will be surrounded by quotes if it contains spaces	538
503	* or quotes.
504	*/
505	qc = strchr(p, '\'') ? '"'	539	qc = strchr(p, '\'') ? '"'
506	: strchr(p, '"') ? '\''	540	: strchr(p, '"') ? '\''
507	: strchr(p, ' ') \|\| strchr(p, '\t') ? '"'	541	: strchr(p, ' ') \|\| strchr(p, '\t') ? '"'
508	: 0;	542	: 0;
509	if (qc)	543
510	putchar(qc);	544	if (qc && pflags & PRINT_QUOTED)
511	while ((c = *p++)) {	545	xo_emit("{P:/%c}", qc);
512	if (c == '\\' \|\| c == qc)	546
513	putchar('\\');	547	xo_emit(param_name_value, value);
514	putchar(c);	548
515	}	549	free(param_name_value);
516	if (qc)	550
517	putchar(qc);	551	if (qc && pflags & PRINT_QUOTED)
		552	xo_emit("{P:/%c}", qc);
518	}	553	}