Attachment #157601 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 a header line if requested. */
	if (pflags & PRINT_VERBOSE)
		xo_emit("{Pd:   }{T:JID}{Pd:  }{T:Hostname}{Pd:                      }{T:Path}\n"
		        "{Pd:        }{T:Name}{Pd:                          }{T:State}\n"
		        "{Pd:        }{T:CPUSetID}\n"
		        "{Pd:        }{T:IP Address(es)}\n");
	else if (pflags & PRINT_DEFAULT)
		if (pflags & PRINT_JAIL_NAME)
			xo_emit("{P: }{T:JID}{P:             }{T:IP Address}{P:      }"
			        "{T:Hostname}{P:                      }{T:Path}\n");
		else
			xo_emit("{P:   }{T:JID}{P:  }{T:IP Address}{P:      }"
			        "{T:Hostname}{P:                      }{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(" ");
				else
					spc = 1;
				xo_emit(params[i].jp_name, stdout);
			}
		xo_emit("\n");
	}

	xo_open_list("jails");
	/* Fetch the jail(s) and print the paramters. */
	if (jid != 0 || jname != NULL) {
		if (print_jail(pflags, jflags) < 0)

		if (errno != 0 && errno != ENOENT)
			errx(1, "%s", jail_errmsg);
	}
	xo_close_list("jails");
	xo_finish();
	return (0);
}


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}\n", ipbuf);
				}
			n++;
		}
#endif

				    ipbuf, sizeof(ipbuf)) == NULL)
					err(1, "inet_ntop");
				else
					xo_emit("{P:        }{e:ipv6_addrs}\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:ip/%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
		    "-",

			      JAIL_SYS_NEW)))
				continue;
			if (spc)
				xo_emit(" ");
			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("\"\"");
				else if (!(pflags & PRINT_NAMEVAL))
					xo_emit("-");
			} else {
				quoted_print(pflags, params[i].jp_name, param_values[i]);
			}
		}
		xo_emit("\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 (-62 / +94 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 197-225 main(int argc, char **argv) Link Here
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("{Pd: }{T:JID}{Pd: }{T:Hostname}{Pd: }{T:Path}\n"
201	" Name State\n"	207	"{Pd: }{T:Name}{Pd: }{T:State}\n"
202	" CPUSetID\n"	208	"{Pd: }{T:CPUSetID}\n"
203	" IP Address(es)\n");	209	"{Pd: }{T:IP Address(es)}\n");
204	else if (pflags & PRINT_DEFAULT)	210	else if (pflags & PRINT_DEFAULT)
205	if (pflags & PRINT_JAIL_NAME)	211	if (pflags & PRINT_JAIL_NAME)
206	printf(" JID IP Address "	212	xo_emit("{P: }{T:JID}{P: }{T:IP Address}{P: }"
207	"Hostname Path\n");	213	"{T:Hostname}{P: }{T:Path}\n");
208	else	214	else
209	printf(" JID IP Address "	215	xo_emit("{P: }{T:JID}{P: }{T:IP Address}{P: }"
210	"Hostname Path\n");	216	"{T:Hostname}{P: }{T:Path}\n");
211	else if (pflags & PRINT_HEADER) {	217	else if (pflags & PRINT_HEADER) {
212	for (i = spc = 0; i < nparams; i++)	218	for (i = spc = 0; i < nparams; i++)
213	if (params[i].jp_flags & JP_USER) {	219	if (params[i].jp_flags & JP_USER) {
214	if (spc)	220	if (spc)
215	putchar(' ');	221	xo_emit(" ");
216	else	222	else
217	spc = 1;	223	spc = 1;
218	fputs(params[i].jp_name, stdout);	224	xo_emit(params[i].jp_name, stdout);
219	}	225	}
220	putchar('\n');	226	xo_emit("\n");
221	}	227	}
222		228
		229	xo_open_list("jails");
223	/* Fetch the jail(s) and print the paramters. */	230	/* Fetch the jail(s) and print the paramters. */
224	if (jid != 0 \|\| jname != NULL) {	231	if (jid != 0 \|\| jname != NULL) {
225	if (print_jail(pflags, jflags) < 0)	232	if (print_jail(pflags, jflags) < 0)
Lines 231-237 main(int argc, char **argv) Link Here
231	if (errno != 0 && errno != ENOENT)	238	if (errno != 0 && errno != ENOENT)
232	errx(1, "%s", jail_errmsg);	239	errx(1, "%s", jail_errmsg);
233	}	240	}
234		241	xo_close_list("jails");
		242	xo_finish();
235	return (0);	243	return (0);
236	}	244	}
237		245
Lines 362-368 nononame(const char *name) Link Here
362	static int	370	static int
363	print_jail(int pflags, int jflags)	371	print_jail(int pflags, int jflags)
364	{	372	{
365	char *nname;	373	char nname, xo_nname;
366	char **param_values;	374	char **param_values;
367	int i, ai, jid, count, n, spc;	375	int i, ai, jid, count, n, spc;
368	char ipbuf[INET6_ADDRSTRLEN];	376	char ipbuf[INET6_ADDRSTRLEN];
Lines 370-387 print_jail(int pflags, int jflags) Link Here
370	jid = jailparam_get(params, nparams, jflags);	378	jid = jailparam_get(params, nparams, jflags);
371	if (jid < 0)	379	if (jid < 0)
372	return jid;	380	return jid;
		381
		382	xo_open_instance("jails");
		383
373	if (pflags & PRINT_VERBOSE) {	384	if (pflags & PRINT_VERBOSE) {
374	printf("%6d %-29.29s %.74s\n"	385	xo_emit("{:jid/%6d}{P: }{e:hostname/%s}{d:hostname/%-29.29s}{P: }{:path/%.74s}\n",
375	"%6s %-29.29s %.74s\n"	386	(int )params[0].jp_value,
376	"%6s %-6d\n",	387	(char *)params[1].jp_value,
377	(int )params[0].jp_value,	388	(char *)params[1].jp_value,
378	(char *)params[1].jp_value,	389	(char *)params[2].jp_value);
379	(char *)params[2].jp_value,	390	xo_emit("{P: }{e:name/%s}{d:name/%-29.29s}{P: }{:state/%.74s}\n",
380	"",	391	(char *)params[3].jp_value,
381	(char *)params[3].jp_value,	392	(char *)params[3].jp_value,
382	(int )params[4].jp_value ? "DYING" : "ACTIVE",	393	(int )params[4].jp_value ? "DYING" : "ACTIVE");
383	"",	394	xo_emit("{P: }{:cpusetid/%d}\n", (int )params[5].jp_value);
384	(int )params[5].jp_value);
385	n = 6;	395	n = 6;
386	#ifdef INET	396	#ifdef INET
387	if (ip4_ok && !strcmp(params[n].jp_name, "ip4.addr")) {	397	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],	401	&((struct in_addr *)params[n].jp_value)[ai],
392	ipbuf, sizeof(ipbuf)) == NULL)	402	ipbuf, sizeof(ipbuf)) == NULL)
393	err(1, "inet_ntop");	403	err(1, "inet_ntop");
394	else	404	else {
395	printf("%6s %-15.15s\n", "", ipbuf);	405	xo_emit("{P: }{l:ipv4_addrs}\n", ipbuf);
		406	}
396	n++;	407	n++;
397	}	408	}
398	#endif	409	#endif
Lines 406-425 print_jail(int pflags, int jflags) Link Here
406	ipbuf, sizeof(ipbuf)) == NULL)	417	ipbuf, sizeof(ipbuf)) == NULL)
407	err(1, "inet_ntop");	418	err(1, "inet_ntop");
408	else	419	else
409	printf("%6s %s\n", "", ipbuf);	420	xo_emit("{P: }{e:ipv6_addrs}\n", ipbuf);
410	n++;	421	n++;
411	}	422	}
412	#endif	423	#endif
413	} else if (pflags & PRINT_DEFAULT) {	424	} else if (pflags & PRINT_DEFAULT) {
414	if (pflags & PRINT_JAIL_NAME)	425	if (pflags & PRINT_JAIL_NAME)
415	printf(" %-15s ", (char *)params[0].jp_value);	426	xo_emit("{P: }{e:name/%s}{d:name/%-15s}{P: }",
		427	(char *)params[0].jp_value,
		428	(char *)params[0].jp_value);
416	else	429	else
417	printf("%6d ", (int )params[0].jp_value);	430	xo_emit("{:jid/%6d}{P: }", (int )params[0].jp_value);
418	printf("%-15.15s %-29.29s %.74s\n",	431	xo_emit("{e:ip/%s}{d:ipv4/%-15.15s}{P: }{e:hostname/%s}{d:hostname/%-29.29s}{P: }{:path/%.74s}\n",
419	#ifdef INET	432	#ifdef INET
		433	(!ip4_ok \|\| params[1].jp_valuelen == 0) ? ""
		434	: inet_ntoa((struct in_addr )params[1].jp_value),
420	(!ip4_ok \|\| params[1].jp_valuelen == 0) ? "-"	435	(!ip4_ok \|\| params[1].jp_valuelen == 0) ? "-"
421	: inet_ntoa((struct in_addr )params[1].jp_value),	436	: inet_ntoa((struct in_addr )params[1].jp_value),
422	(char *)params[2-!ip4_ok].jp_value,	437	(char *)params[2-!ip4_ok].jp_value,
		438	(char *)params[2-!ip4_ok].jp_value,
423	(char *)params[3-!ip4_ok].jp_value);	439	(char *)params[3-!ip4_ok].jp_value);
424	#else	440	#else
425	"-",	441	"-",
Lines 446-452 print_jail(int pflags, int jflags) Link Here
446	JAIL_SYS_NEW)))	462	JAIL_SYS_NEW)))
447	continue;	463	continue;
448	if (spc)	464	if (spc)
449	putchar(' ');	465	xo_emit(" ");
450	else	466	else
451	spc = 1;	467	spc = 1;
452	if (pflags & PRINT_NAMEVAL) {	468	if (pflags & PRINT_NAMEVAL) {
Lines 456-518 print_jail(int pflags, int jflags) Link Here
456	*/	472	*/
457	if (params[i].jp_flags &	473	if (params[i].jp_flags &
458	(JP_BOOL \| JP_NOBOOL)) {	474	(JP_BOOL \| JP_NOBOOL)) {
459	if ((int )params[i].jp_value)	475	if ((int )params[i].jp_value) {
460	printf("%s", params[i].jp_name);	476	asprintf(&xo_nname, "{en:%s/true}", params[i].jp_name);
		477	xo_emit(xo_nname);
		478	xo_emit("{d:/%s}", params[i].jp_name);
		479	}
461	else {	480	else {
462	nname = (params[i].jp_flags &	481	nname = (params[i].jp_flags &
463	JP_NOBOOL) ?	482	JP_NOBOOL) ?
464	nononame(params[i].jp_name)	483	nononame(params[i].jp_name)
465	: noname(params[i].jp_name);	484	: noname(params[i].jp_name);
466	printf("%s", nname);	485	if (params[i].jp_flags & JP_NOBOOL) {
		486	asprintf(&xo_nname, "{en:%s/true}", params[i].jp_name);
		487	xo_emit(xo_nname);
		488	} else {
		489	asprintf(&xo_nname, "{en:%s/false}", params[i].jp_name);
		490	xo_emit(xo_nname);
		491	}
		492	xo_emit("{d:/%s}", nname);
467	free(nname);	493	free(nname);
468	}	494	}
		495	free(xo_nname);
469	continue;	496	continue;
470	}	497	}
471	printf("%s=", params[i].jp_name);	498	xo_emit("{d:%s}=", params[i].jp_name);
472	}	499	}
473	if (params[i].jp_valuelen == 0) {	500	if (params[i].jp_valuelen == 0) {
474	if (pflags & PRINT_QUOTED)	501	if (pflags & PRINT_QUOTED)
475	printf("\"\"");	502	xo_emit("\"\"");
476	else if (!(pflags & PRINT_NAMEVAL))	503	else if (!(pflags & PRINT_NAMEVAL))
477	putchar('-');	504	xo_emit("-");
478	} else	505	} else {
479	quoted_print(param_values[i]);	506	quoted_print(pflags, params[i].jp_name, param_values[i]);
		507	}
480	}	508	}
481	putchar('\n');	509	xo_emit("\n");
482	for (i = 0; i < nparams; i++)	510	for (i = 0; i < nparams; i++)
483	if (params[i].jp_flags & JP_USER)	511	if (params[i].jp_flags & JP_USER)
484	free(param_values[i]);	512	free(param_values[i]);
485	}	513	}
		514
		515	xo_close_instance("jails");
486	return (jid);	516	return (jid);
487	}	517	}
488		518
489	static void	519	static void
490	quoted_print(char *str)	520	quoted_print(int pflags, char name, char value)
491	{	521	{
492	int c, qc;	522	int qc;
493	char *p = str;	523	char *p = value;
		524	char *param_name_value;
		525
494		526
495	/* An empty string needs quoting. */
496	if (!*p) {	527	if (!*p) {
497	fputs("\"\"", stdout);	528	asprintf(&param_name_value, "{k:%s}{d:%s/\"\"}", name, name);
		529	xo_emit(param_name_value);
		530	free(param_name_value);
498	return;	531	return;
499	}	532	}
500		533
501	/*	534	asprintf(&param_name_value, "{:%s/%%s}", name);
502	* The value will be surrounded by quotes if it contains spaces	535
503	* or quotes.
504	*/
505	qc = strchr(p, '\'') ? '"'	536	qc = strchr(p, '\'') ? '"'
506	: strchr(p, '"') ? '\''	537	: strchr(p, '"') ? '\''
507	: strchr(p, ' ') \|\| strchr(p, '\t') ? '"'	538	: strchr(p, ' ') \|\| strchr(p, '\t') ? '"'
508	: 0;	539	: 0;
509	if (qc)	540
510	putchar(qc);	541	if (qc && pflags & PRINT_QUOTED)
511	while ((c = *p++)) {	542	xo_emit("{P:/%c}", qc);
512	if (c == '\\' \|\| c == qc)	543
513	putchar('\\');	544	xo_emit(param_name_value, value);
514	putchar(c);	545
515	}	546	free(param_name_value);
516	if (qc)	547
517	putchar(qc);	548	if (qc && pflags & PRINT_QUOTED)
		549	xo_emit("{P:/%c}", qc);
518	}	550	}