[mirror_iproute2.git] / lib / json_writer.c

/* SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) */
/*
 * Simple streaming JSON writer
 *
 * This takes care of the annoying bits of JSON syntax like the commas
 * after elements
 *
 * Authors:	Stephen Hemminger <stephen@networkplumber.org>
 */

#include <stdio.h>
#include <stdbool.h>
#include <stdarg.h>
#include <assert.h>
#include <malloc.h>
#include <inttypes.h>
#include <stdint.h>

#include "json_writer.h"

struct json_writer {
	FILE		*out;	/* output file */
	unsigned	depth;  /* nesting */
	bool		pretty; /* optional whitepace */
	char		sep;	/* either nul or comma */
};

/* indentation for pretty print */
static void jsonw_indent(json_writer_t *self)
{
	unsigned i;
	for (i = 0; i < self->depth; ++i)
		fputs("    ", self->out);
}

/* end current line and indent if pretty printing */
static void jsonw_eol(json_writer_t *self)
{
	if (!self->pretty)
		return;

	putc('\n', self->out);
	jsonw_indent(self);
}

/* If current object is not empty print a comma */
static void jsonw_eor(json_writer_t *self)
{
	if (self->sep != '\0')
		putc(self->sep, self->out);
	self->sep = ',';
}


/* Output JSON encoded string */
/* Handles C escapes, does not do Unicode */
static void jsonw_puts(json_writer_t *self, const char *str)
{
	putc('"', self->out);
	for (; *str; ++str)
		switch (*str) {
		case '\t':
			fputs("\\t", self->out);
			break;
		case '\n':
			fputs("\\n", self->out);
			break;
		case '\r':
			fputs("\\r", self->out);
			break;
		case '\f':
			fputs("\\f", self->out);
			break;
		case '\b':
			fputs("\\b", self->out);
			break;
		case '\\':
			fputs("\\n", self->out);
			break;
		case '"':
			fputs("\\\"", self->out);
			break;
		case '\'':
			fputs("\\\'", self->out);
			break;
		default:
			putc(*str, self->out);
		}
	putc('"', self->out);
}

/* Create a new JSON stream */
json_writer_t *jsonw_new(FILE *f)
{
	json_writer_t *self = malloc(sizeof(*self));
	if (self) {
		self->out = f;
		self->depth = 0;
		self->pretty = false;
		self->sep = '\0';
	}
	return self;
}

/* End output to JSON stream */
void jsonw_destroy(json_writer_t **self_p)
{
	json_writer_t *self = *self_p;

	assert(self->depth == 0);
	fputs("\n", self->out);
	fflush(self->out);
	free(self);
	*self_p = NULL;
}

void jsonw_pretty(json_writer_t *self, bool on)
{
	self->pretty = on;
}

/* Basic blocks */
static void jsonw_begin(json_writer_t *self, int c)
{
	jsonw_eor(self);
	putc(c, self->out);
	++self->depth;
	self->sep = '\0';
}

static void jsonw_end(json_writer_t *self, int c)
{
	assert(self->depth > 0);

	--self->depth;
	if (self->sep != '\0')
		jsonw_eol(self);
	putc(c, self->out);
	self->sep = ',';
}


/* Add a JSON property name */
void jsonw_name(json_writer_t *self, const char *name)
{
	jsonw_eor(self);
	jsonw_eol(self);
	self->sep = '\0';
	jsonw_puts(self, name);
	putc(':', self->out);
	if (self->pretty)
		putc(' ', self->out);
}

__attribute__((format(printf, 2, 3)))
void jsonw_printf(json_writer_t *self, const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	jsonw_eor(self);
	vfprintf(self->out, fmt, ap);
	va_end(ap);
}

/* Collections */
void jsonw_start_object(json_writer_t *self)
{
	jsonw_begin(self, '{');
}

void jsonw_end_object(json_writer_t *self)
{
	jsonw_end(self, '}');
}

void jsonw_start_array(json_writer_t *self)
{
	jsonw_begin(self, '[');
	if (self->pretty)
		putc(' ', self->out);
}

void jsonw_end_array(json_writer_t *self)
{
	if (self->pretty && self->sep)
		putc(' ', self->out);
	self->sep = '\0';
	jsonw_end(self, ']');
}

/* JSON value types */
void jsonw_string(json_writer_t *self, const char *value)
{
	jsonw_eor(self);
	jsonw_puts(self, value);
}

void jsonw_bool(json_writer_t *self, bool val)
{
	jsonw_printf(self, "%s", val ? "true" : "false");
}

void jsonw_null(json_writer_t *self)
{
	jsonw_printf(self, "null");
}

void jsonw_float(json_writer_t *self, double num)
{
	jsonw_printf(self, "%g", num);
}

void jsonw_hhu(json_writer_t *self, unsigned char num)
{
	jsonw_printf(self, "%hhu", num);
}

void jsonw_hu(json_writer_t *self, unsigned short num)
{
	jsonw_printf(self, "%hu", num);
}

void jsonw_uint(json_writer_t *self, unsigned int num)
{
	jsonw_printf(self, "%u", num);
}

void jsonw_u64(json_writer_t *self, uint64_t num)
{
	jsonw_printf(self, "%"PRIu64, num);
}

void jsonw_xint(json_writer_t *self, uint64_t num)
{
	jsonw_printf(self, "%"PRIx64, num);
}

void jsonw_luint(json_writer_t *self, unsigned long num)
{
	jsonw_printf(self, "%lu", num);
}

void jsonw_lluint(json_writer_t *self, unsigned long long num)
{
	jsonw_printf(self, "%llu", num);
}

void jsonw_int(json_writer_t *self, int num)
{
	jsonw_printf(self, "%d", num);
}

void jsonw_s64(json_writer_t *self, int64_t num)
{
	jsonw_printf(self, "%"PRId64, num);
}

/* Basic name/value objects */
void jsonw_string_field(json_writer_t *self, const char *prop, const char *val)
{
	jsonw_name(self, prop);
	jsonw_string(self, val);
}

void jsonw_bool_field(json_writer_t *self, const char *prop, bool val)
{
	jsonw_name(self, prop);
	jsonw_bool(self, val);
}

void jsonw_float_field(json_writer_t *self, const char *prop, double val)
{
	jsonw_name(self, prop);
	jsonw_float(self, val);
}

void jsonw_uint_field(json_writer_t *self, const char *prop, unsigned int num)
{
	jsonw_name(self, prop);
	jsonw_uint(self, num);
}

void jsonw_u64_field(json_writer_t *self, const char *prop, uint64_t num)
{
	jsonw_name(self, prop);
	jsonw_u64(self, num);
}

void jsonw_xint_field(json_writer_t *self, const char *prop, uint64_t num)
{
	jsonw_name(self, prop);
	jsonw_xint(self, num);
}

void jsonw_hhu_field(json_writer_t *self, const char *prop, unsigned char num)
{
	jsonw_name(self, prop);
	jsonw_hhu(self, num);
}

void jsonw_hu_field(json_writer_t *self, const char *prop, unsigned short num)
{
	jsonw_name(self, prop);
	jsonw_hu(self, num);
}

void jsonw_luint_field(json_writer_t *self,
			const char *prop,
			unsigned long num)
{
	jsonw_name(self, prop);
	jsonw_luint(self, num);
}

void jsonw_lluint_field(json_writer_t *self,
			const char *prop,
			unsigned long long num)
{
	jsonw_name(self, prop);
	jsonw_lluint(self, num);
}

void jsonw_int_field(json_writer_t *self, const char *prop, int num)
{
	jsonw_name(self, prop);
	jsonw_int(self, num);
}

void jsonw_s64_field(json_writer_t *self, const char *prop, int64_t num)
{
	jsonw_name(self, prop);
	jsonw_s64(self, num);
}

void jsonw_null_field(json_writer_t *self, const char *prop)
{
	jsonw_name(self, prop);
	jsonw_null(self);
}

#ifdef TEST
int main(int argc, char **argv)
{
	json_writer_t *wr = jsonw_new(stdout);

	jsonw_start_object(wr);
	jsonw_pretty(wr, true);
	jsonw_name(wr, "Vyatta");
	jsonw_start_object(wr);
	jsonw_string_field(wr, "url", "http://vyatta.com");
	jsonw_uint_field(wr, "downloads", 2000000ul);
	jsonw_float_field(wr, "stock", 8.16);

	jsonw_name(wr, "ARGV");
	jsonw_start_array(wr);
	while (--argc)
		jsonw_string(wr, *++argv);
	jsonw_end_array(wr);

	jsonw_name(wr, "empty");
	jsonw_start_array(wr);
	jsonw_end_array(wr);

	jsonw_name(wr, "NIL");
	jsonw_start_object(wr);
	jsonw_end_object(wr);

	jsonw_null_field(wr, "my_null");

	jsonw_name(wr, "special chars");
	jsonw_start_array(wr);
	jsonw_string_field(wr, "slash", "/");
	jsonw_string_field(wr, "newline", "\n");
	jsonw_string_field(wr, "tab", "\t");
	jsonw_string_field(wr, "ff", "\f");
	jsonw_string_field(wr, "quote", "\"");
	jsonw_string_field(wr, "tick", "\'");
	jsonw_string_field(wr, "backslash", "\\");
	jsonw_end_array(wr);

	jsonw_end_object(wr);

	jsonw_end_object(wr);
	jsonw_destroy(&wr);
	return 0;
}

#endif
Commit	Line	Data
d9d8c839	1	/* SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) */
fcc16c22 SH	2	/*
	3	* Simple streaming JSON writer
	4	*
	5	* This takes care of the annoying bits of JSON syntax like the commas
	6	* after elements
	7	*
fcc16c22 SH	8	* Authors: Stephen Hemminger <stephen@networkplumber.org>
	9	*/
	10
	11	#include <stdio.h>
	12	#include <stdbool.h>
	13	#include <stdarg.h>
	14	#include <assert.h>
	15	#include <malloc.h>
	16	#include <inttypes.h>
	17	#include <stdint.h>
	18
	19	#include "json_writer.h"
	20
	21	struct json_writer {
	22	FILE out; / output file */
	23	unsigned depth; /* nesting */
	24	bool pretty; /* optional whitepace */
	25	char sep; /* either nul or comma */
	26	};
	27
	28	/* indentation for pretty print */
	29	static void jsonw_indent(json_writer_t *self)
	30	{
	31	unsigned i;
d721a145	32	for (i = 0; i < self->depth; ++i)
fcc16c22 SH	33	fputs(" ", self->out);
	34	}
	35
	36	/* end current line and indent if pretty printing */
	37	static void jsonw_eol(json_writer_t *self)
	38	{
	39	if (!self->pretty)
	40	return;
	41
	42	putc('\n', self->out);
	43	jsonw_indent(self);
	44	}
	45
	46	/* If current object is not empty print a comma */
	47	static void jsonw_eor(json_writer_t *self)
	48	{
	49	if (self->sep != '\0')
	50	putc(self->sep, self->out);
	51	self->sep = ',';
	52	}
	53
	54
	55	/* Output JSON encoded string */
	56	/* Handles C escapes, does not do Unicode */
	57	static void jsonw_puts(json_writer_t self, const char str)
	58	{
	59	putc('"', self->out);
	60	for (; *str; ++str)
	61	switch (*str) {
	62	case '\t':
	63	fputs("\\t", self->out);
	64	break;
	65	case '\n':
	66	fputs("\\n", self->out);
	67	break;
	68	case '\r':
	69	fputs("\\r", self->out);
	70	break;
	71	case '\f':
	72	fputs("\\f", self->out);
	73	break;
	74	case '\b':
	75	fputs("\\b", self->out);
	76	break;
	77	case '\\':
	78	fputs("\\n", self->out);
	79	break;
	80	case '"':
	81	fputs("\\\"", self->out);
	82	break;
	83	case '\'':
	84	fputs("\\\'", self->out);
	85	break;
	86	default:
	87	putc(*str, self->out);
	88	}
	89	putc('"', self->out);
	90	}
	91
	92	/* Create a new JSON stream */
	93	json_writer_t jsonw_new(FILE f)
	94	{
	95	json_writer_t self = malloc(sizeof(self));
	96	if (self) {
97	self->out = f;
98	self->depth = 0;
99	self->pretty = false;
100	self->sep = '\0';
fcc16c22 SH	101	}
	102	return self;
	103	}
	104
	105	/* End output to JSON stream */
	106	void jsonw_destroy(json_writer_t **self_p)
	107	{
	108	json_writer_t self = self_p;
	109
	110	assert(self->depth == 0);
d721a145	111	fputs("\n", self->out);
fcc16c22 SH	112	fflush(self->out);
	113	free(self);
	114	*self_p = NULL;
	115	}
	116
	117	void jsonw_pretty(json_writer_t *self, bool on)
	118	{
	119	self->pretty = on;
	120	}
	121
	122	/* Basic blocks */
	123	static void jsonw_begin(json_writer_t *self, int c)
	124	{
	125	jsonw_eor(self);
	126	putc(c, self->out);
	127	++self->depth;
	128	self->sep = '\0';
	129	}
	130
	131	static void jsonw_end(json_writer_t *self, int c)
	132	{
	133	assert(self->depth > 0);
	134
	135	--self->depth;
	136	if (self->sep != '\0')
	137	jsonw_eol(self);
	138	putc(c, self->out);
	139	self->sep = ',';
	140	}
	141
	142
	143	/* Add a JSON property name */
	144	void jsonw_name(json_writer_t self, const char name)
	145	{
	146	jsonw_eor(self);
	147	jsonw_eol(self);
	148	self->sep = '\0';
	149	jsonw_puts(self, name);
	150	putc(':', self->out);
	151	if (self->pretty)
	152	putc(' ', self->out);
	153	}
	154
5d5586b0	155	__attribute__((format(printf, 2, 3)))
7252f16b	156	void jsonw_printf(json_writer_t self, const char fmt, ...)
fcc16c22 SH	157	{
	158	va_list ap;
	159
	160	va_start(ap, fmt);
	161	jsonw_eor(self);
	162	vfprintf(self->out, fmt, ap);
	163	va_end(ap);
	164	}
	165
	166	/* Collections */
	167	void jsonw_start_object(json_writer_t *self)
	168	{
	169	jsonw_begin(self, '{');
	170	}
	171
	172	void jsonw_end_object(json_writer_t *self)
	173	{
	174	jsonw_end(self, '}');
	175	}
	176
	177	void jsonw_start_array(json_writer_t *self)
	178	{
	179	jsonw_begin(self, '[');
6cbd9465 SH	180	if (self->pretty)
6cbd9465 SH	181	putc(' ', self->out);
fcc16c22 SH	182	}
	183
	184	void jsonw_end_array(json_writer_t *self)
	185	{
6cbd9465 SH	186	if (self->pretty && self->sep)
	187	putc(' ', self->out);
	188	self->sep = '\0';
fcc16c22 SH	189	jsonw_end(self, ']');
	190	}
	191
	192	/* JSON value types */
	193	void jsonw_string(json_writer_t self, const char value)
	194	{
	195	jsonw_eor(self);
	196	jsonw_puts(self, value);
	197	}
	198
	199	void jsonw_bool(json_writer_t *self, bool val)
	200	{
	201	jsonw_printf(self, "%s", val ? "true" : "false");
	202	}
	203
fcc16c22 SH	204	void jsonw_null(json_writer_t *self)
	205	{
	206	jsonw_printf(self, "null");
	207	}
	208
	209	void jsonw_float(json_writer_t *self, double num)
	210	{
	211	jsonw_printf(self, "%g", num);
	212	}
fcc16c22	213
b640e85d JK	214	void jsonw_hhu(json_writer_t *self, unsigned char num)
	215	{
	216	jsonw_printf(self, "%hhu", num);
	217	}
	218
7252f16b JF	219	void jsonw_hu(json_writer_t *self, unsigned short num)
	220	{
	221	jsonw_printf(self, "%hu", num);
	222	}
	223
4db2ff0d THJ	224	void jsonw_uint(json_writer_t *self, unsigned int num)
	225	{
	226	jsonw_printf(self, "%u", num);
	227	}
	228
	229	void jsonw_u64(json_writer_t *self, uint64_t num)
fcc16c22 SH	230	{
	231	jsonw_printf(self, "%"PRIu64, num);
	232	}
	233
8958a15c SW	234	void jsonw_xint(json_writer_t *self, uint64_t num)
	235	{
	236	jsonw_printf(self, "%"PRIx64, num);
	237	}
	238
3a1f602a	239	void jsonw_luint(json_writer_t *self, unsigned long num)
4db2ff0d THJ	240	{
	241	jsonw_printf(self, "%lu", num);
	242	}
	243
3a1f602a	244	void jsonw_lluint(json_writer_t *self, unsigned long long num)
7252f16b JF	245	{
	246	jsonw_printf(self, "%llu", num);
	247	}
	248
4db2ff0d THJ	249	void jsonw_int(json_writer_t *self, int num)
	250	{
	251	jsonw_printf(self, "%d", num);
	252	}
	253
	254	void jsonw_s64(json_writer_t *self, int64_t num)
fcc16c22 SH	255	{
	256	jsonw_printf(self, "%"PRId64, num);
	257	}
	258
	259	/* Basic name/value objects */
	260	void jsonw_string_field(json_writer_t self, const char prop, const char *val)
	261	{
	262	jsonw_name(self, prop);
	263	jsonw_string(self, val);
	264	}
	265
	266	void jsonw_bool_field(json_writer_t self, const char prop, bool val)
	267	{
	268	jsonw_name(self, prop);
	269	jsonw_bool(self, val);
	270	}
	271
fcc16c22 SH	272	void jsonw_float_field(json_writer_t self, const char prop, double val)
	273	{
	274	jsonw_name(self, prop);
	275	jsonw_float(self, val);
	276	}
fcc16c22	277
4db2ff0d	278	void jsonw_uint_field(json_writer_t self, const char prop, unsigned int num)
fcc16c22 SH	279	{
	280	jsonw_name(self, prop);
	281	jsonw_uint(self, num);
	282	}
	283
4db2ff0d THJ	284	void jsonw_u64_field(json_writer_t self, const char prop, uint64_t num)
	285	{
	286	jsonw_name(self, prop);
	287	jsonw_u64(self, num);
	288	}
	289
8958a15c SW	290	void jsonw_xint_field(json_writer_t self, const char prop, uint64_t num)
	291	{
	292	jsonw_name(self, prop);
	293	jsonw_xint(self, num);
	294	}
	295
b640e85d JK	296	void jsonw_hhu_field(json_writer_t self, const char prop, unsigned char num)
	297	{
	298	jsonw_name(self, prop);
	299	jsonw_hhu(self, num);
	300	}
	301
7252f16b JF	302	void jsonw_hu_field(json_writer_t self, const char prop, unsigned short num)
	303	{
	304	jsonw_name(self, prop);
	305	jsonw_hu(self, num);
	306	}
	307
4db2ff0d THJ	308	void jsonw_luint_field(json_writer_t *self,
4db2ff0d THJ	309	const char *prop,
3a1f602a	310	unsigned long num)
4db2ff0d THJ	311	{
	312	jsonw_name(self, prop);
	313	jsonw_luint(self, num);
	314	}
	315
7252f16b JF	316	void jsonw_lluint_field(json_writer_t *self,
7252f16b JF	317	const char *prop,
3a1f602a	318	unsigned long long num)
7252f16b JF	319	{
	320	jsonw_name(self, prop);
	321	jsonw_lluint(self, num);
	322	}
	323
4db2ff0d	324	void jsonw_int_field(json_writer_t self, const char prop, int num)
fcc16c22 SH	325	{
	326	jsonw_name(self, prop);
	327	jsonw_int(self, num);
	328	}
	329
4db2ff0d THJ	330	void jsonw_s64_field(json_writer_t self, const char prop, int64_t num)
	331	{
	332	jsonw_name(self, prop);
	333	jsonw_s64(self, num);
	334	}
	335
fcc16c22 SH	336	void jsonw_null_field(json_writer_t self, const char prop)
	337	{
	338	jsonw_name(self, prop);
	339	jsonw_null(self);
	340	}
fcc16c22 SH	341
	342	#ifdef TEST
	343	int main(int argc, char **argv)
	344	{
	345	json_writer_t *wr = jsonw_new(stdout);
	346
d721a145	347	jsonw_start_object(wr);
fcc16c22 SH	348	jsonw_pretty(wr, true);
	349	jsonw_name(wr, "Vyatta");
	350	jsonw_start_object(wr);
	351	jsonw_string_field(wr, "url", "http://vyatta.com");
	352	jsonw_uint_field(wr, "downloads", 2000000ul);
	353	jsonw_float_field(wr, "stock", 8.16);
	354
	355	jsonw_name(wr, "ARGV");
	356	jsonw_start_array(wr);
	357	while (--argc)
	358	jsonw_string(wr, *++argv);
	359	jsonw_end_array(wr);
	360
	361	jsonw_name(wr, "empty");
	362	jsonw_start_array(wr);
	363	jsonw_end_array(wr);
	364
	365	jsonw_name(wr, "NIL");
	366	jsonw_start_object(wr);
	367	jsonw_end_object(wr);
	368
	369	jsonw_null_field(wr, "my_null");
	370
	371	jsonw_name(wr, "special chars");
	372	jsonw_start_array(wr);
	373	jsonw_string_field(wr, "slash", "/");
	374	jsonw_string_field(wr, "newline", "\n");
	375	jsonw_string_field(wr, "tab", "\t");
	376	jsonw_string_field(wr, "ff", "\f");
	377	jsonw_string_field(wr, "quote", "\"");
	378	jsonw_string_field(wr, "tick", "\'");
	379	jsonw_string_field(wr, "backslash", "\\");
	380	jsonw_end_array(wr);
	381
	382	jsonw_end_object(wr);
	383
d721a145	384	jsonw_end_object(wr);
fcc16c22 SH	385	jsonw_destroy(&wr);
	386	return 0;
	387	}
	388
	389	#endif