1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 /*
12  * Copyright (c) 2014, Joyent, Inc.
13  */
14 
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <strings.h>
18 #include <wchar.h>
19 #include <sys/debug.h>
20 
21 #include "libnvpair.h"
22 
23 #define	FPRINTF(fp, ...)				\
24 	do {						\
25 		if (fprintf(fp, __VA_ARGS__) < 0)	\
26 			return (-1);			\
27 	} while (0)
28 
29 /*
30  * When formatting a string for JSON output we must escape certain characters,
31  * as described in RFC4627.  This applies to both member names and
32  * DATA_TYPE_STRING values.
33  *
34  * This function will only operate correctly if the following conditions are
35  * met:
36  *
37  *       1. The input String is encoded in the current locale.
38  *
39  *       2. The current locale includes the Basic Multilingual Plane (plane 0)
40  *          as defined in the Unicode standard.
41  *
42  * The output will be entirely 7-bit ASCII (as a subset of UTF-8) with all
43  * representable Unicode characters included in their escaped numeric form.
44  */
45 static int
46 nvlist_print_json_string(FILE *fp, const char *input)
47 {
48 	mbstate_t mbr;
49 	wchar_t c;
50 	size_t sz;
51 
52 	bzero(&mbr, sizeof (mbr));
53 
54 	FPRINTF(fp, "\"");
55 	while ((sz = mbrtowc(&c, input, MB_CUR_MAX, &mbr)) > 0) {
56 		switch (c) {
57 		case '"':
58 			FPRINTF(fp, "\\\"");
59 			break;
60 		case '\n':
61 			FPRINTF(fp, "\\n");
62 			break;
63 		case '\r':
64 			FPRINTF(fp, "\\r");
65 			break;
66 		case '\\':
67 			FPRINTF(fp, "\\\\");
68 			break;
69 		case '\f':
70 			FPRINTF(fp, "\\f");
71 			break;
72 		case '\t':
73 			FPRINTF(fp, "\\t");
74 			break;
75 		case '\b':
76 			FPRINTF(fp, "\\b");
77 			break;
78 		default:
79 			if ((c >= 0x00 && c <= 0x1f) ||
80 			    (c > 0x7f && c <= 0xffff)) {
81 				/*
82 				 * Render both Control Characters and Unicode
83 				 * characters in the Basic Multilingual Plane
84 				 * as JSON-escaped multibyte characters.
85 				 */
86 				FPRINTF(fp, "\\u%04x", (int)(0xffff & c));
87 			} else if (c >= 0x20 && c <= 0x7f) {
88 				/*
89 				 * Render other 7-bit ASCII characters directly
90 				 * and drop other, unrepresentable characters.
91 				 */
92 				FPRINTF(fp, "%c", (int)(0xff & c));
93 			}
94 			break;
95 		}
96 		input += sz;
97 	}
98 
99 	if (sz == (size_t)-1 || sz == (size_t)-2) {
100 		/*
101 		 * We last read an invalid multibyte character sequence,
102 		 * so return an error.
103 		 */
104 		return (-1);
105 	}
106 
107 	FPRINTF(fp, "\"");
108 	return (0);
109 }
110 
111 /*
112  * Dump a JSON-formatted representation of an nvlist to the provided FILE *.
113  * This routine does not output any new-lines or additional whitespace other
114  * than that contained in strings, nor does it call fflush(3C).
115  */
116 int
117 nvlist_print_json(FILE *fp, nvlist_t *nvl)
118 {
119 	nvpair_t *curr;
120 	boolean_t first = B_TRUE;
121 
122 	FPRINTF(fp, "{");
123 
124 	for (curr = nvlist_next_nvpair(nvl, NULL); curr;
125 	    curr = nvlist_next_nvpair(nvl, curr)) {
126 		data_type_t type = nvpair_type(curr);
127 
128 		if (!first)
129 			FPRINTF(fp, ",");
130 		else
131 			first = B_FALSE;
132 
133 		if (nvlist_print_json_string(fp, nvpair_name(curr)) == -1)
134 			return (-1);
135 		FPRINTF(fp, ":");
136 
137 		switch (type) {
138 		case DATA_TYPE_STRING: {
139 			char *string = fnvpair_value_string(curr);
140 			if (nvlist_print_json_string(fp, string) == -1)
141 				return (-1);
142 			break;
143 		}
144 
145 		case DATA_TYPE_BOOLEAN: {
146 			FPRINTF(fp, "true");
147 			break;
148 		}
149 
150 		case DATA_TYPE_BOOLEAN_VALUE: {
151 			FPRINTF(fp, "%s", fnvpair_value_boolean_value(curr) ==
152 			    B_TRUE ? "true" : "false");
153 			break;
154 		}
155 
156 		case DATA_TYPE_BYTE: {
157 			FPRINTF(fp, "%hhu", fnvpair_value_byte(curr));
158 			break;
159 		}
160 
161 		case DATA_TYPE_INT8: {
162 			FPRINTF(fp, "%hhd", fnvpair_value_int8(curr));
163 			break;
164 		}
165 
166 		case DATA_TYPE_UINT8: {
167 			FPRINTF(fp, "%hhu", fnvpair_value_uint8_t(curr));
168 			break;
169 		}
170 
171 		case DATA_TYPE_INT16: {
172 			FPRINTF(fp, "%hd", fnvpair_value_int16(curr));
173 			break;
174 		}
175 
176 		case DATA_TYPE_UINT16: {
177 			FPRINTF(fp, "%hu", fnvpair_value_uint16(curr));
178 			break;
179 		}
180 
181 		case DATA_TYPE_INT32: {
182 			FPRINTF(fp, "%d", fnvpair_value_int32(curr));
183 			break;
184 		}
185 
186 		case DATA_TYPE_UINT32: {
187 			FPRINTF(fp, "%u", fnvpair_value_uint32(curr));
188 			break;
189 		}
190 
191 		case DATA_TYPE_INT64: {
192 			FPRINTF(fp, "%lld",
193 			    (long long)fnvpair_value_int64(curr));
194 			break;
195 		}
196 
197 		case DATA_TYPE_UINT64: {
198 			FPRINTF(fp, "%llu",
199 			    (unsigned long long)fnvpair_value_uint64(curr));
200 			break;
201 		}
202 
203 		case DATA_TYPE_HRTIME: {
204 			hrtime_t val;
205 			VERIFY0(nvpair_value_hrtime(curr, &val));
206 			FPRINTF(fp, "%llu", (unsigned long long)val);
207 			break;
208 		}
209 
210 		case DATA_TYPE_DOUBLE: {
211 			double val;
212 			VERIFY0(nvpair_value_double(curr, &val));
213 			FPRINTF(fp, "%f", val);
214 			break;
215 		}
216 
217 		case DATA_TYPE_NVLIST: {
218 			if (nvlist_print_json(fp,
219 			    fnvpair_value_nvlist(curr)) == -1)
220 				return (-1);
221 			break;
222 		}
223 
224 		case DATA_TYPE_STRING_ARRAY: {
225 			char **val;
226 			uint_t valsz, i;
227 			VERIFY0(nvpair_value_string_array(curr, &val, &valsz));
228 			FPRINTF(fp, "[");
229 			for (i = 0; i < valsz; i++) {
230 				if (i > 0)
231 					FPRINTF(fp, ",");
232 				if (nvlist_print_json_string(fp, val[i]) == -1)
233 					return (-1);
234 			}
235 			FPRINTF(fp, "]");
236 			break;
237 		}
238 
239 		case DATA_TYPE_NVLIST_ARRAY: {
240 			nvlist_t **val;
241 			uint_t valsz, i;
242 			VERIFY0(nvpair_value_nvlist_array(curr, &val, &valsz));
243 			FPRINTF(fp, "[");
244 			for (i = 0; i < valsz; i++) {
245 				if (i > 0)
246 					FPRINTF(fp, ",");
247 				if (nvlist_print_json(fp, val[i]) == -1)
248 					return (-1);
249 			}
250 			FPRINTF(fp, "]");
251 			break;
252 		}
253 
254 		case DATA_TYPE_BOOLEAN_ARRAY: {
255 			boolean_t *val;
256 			uint_t valsz, i;
257 			VERIFY0(nvpair_value_boolean_array(curr, &val, &valsz));
258 			FPRINTF(fp, "[");
259 			for (i = 0; i < valsz; i++) {
260 				if (i > 0)
261 					FPRINTF(fp, ",");
262 				FPRINTF(fp, val[i] == B_TRUE ?
263 				    "true" : "false");
264 			}
265 			FPRINTF(fp, "]");
266 			break;
267 		}
268 
269 		case DATA_TYPE_BYTE_ARRAY: {
270 			uchar_t *val;
271 			uint_t valsz, i;
272 			VERIFY0(nvpair_value_byte_array(curr, &val, &valsz));
273 			FPRINTF(fp, "[");
274 			for (i = 0; i < valsz; i++) {
275 				if (i > 0)
276 					FPRINTF(fp, ",");
277 				FPRINTF(fp, "%hhu", val[i]);
278 			}
279 			FPRINTF(fp, "]");
280 			break;
281 		}
282 
283 		case DATA_TYPE_UINT8_ARRAY: {
284 			uint8_t *val;
285 			uint_t valsz, i;
286 			VERIFY0(nvpair_value_uint8_array(curr, &val, &valsz));
287 			FPRINTF(fp, "[");
288 			for (i = 0; i < valsz; i++) {
289 				if (i > 0)
290 					FPRINTF(fp, ",");
291 				FPRINTF(fp, "%hhu", val[i]);
292 			}
293 			FPRINTF(fp, "]");
294 			break;
295 		}
296 
297 		case DATA_TYPE_INT8_ARRAY: {
298 			int8_t *val;
299 			uint_t valsz, i;
300 			VERIFY0(nvpair_value_int8_array(curr, &val, &valsz));
301 			FPRINTF(fp, "[");
302 			for (i = 0; i < valsz; i++) {
303 				if (i > 0)
304 					FPRINTF(fp, ",");
305 				FPRINTF(fp, "%hd", val[i]);
306 			}
307 			FPRINTF(fp, "]");
308 			break;
309 		}
310 
311 		case DATA_TYPE_UINT16_ARRAY: {
312 			uint16_t *val;
313 			uint_t valsz, i;
314 			VERIFY0(nvpair_value_uint16_array(curr, &val, &valsz));
315 			FPRINTF(fp, "[");
316 			for (i = 0; i < valsz; i++) {
317 				if (i > 0)
318 					FPRINTF(fp, ",");
319 				FPRINTF(fp, "%hu", val[i]);
320 			}
321 			FPRINTF(fp, "]");
322 			break;
323 		}
324 
325 		case DATA_TYPE_INT16_ARRAY: {
326 			int16_t *val;
327 			uint_t valsz, i;
328 			VERIFY0(nvpair_value_int16_array(curr, &val, &valsz));
329 			FPRINTF(fp, "[");
330 			for (i = 0; i < valsz; i++) {
331 				if (i > 0)
332 					FPRINTF(fp, ",");
333 				FPRINTF(fp, "%hd", val[i]);
334 			}
335 			FPRINTF(fp, "]");
336 			break;
337 		}
338 
339 		case DATA_TYPE_UINT32_ARRAY: {
340 			uint32_t *val;
341 			uint_t valsz, i;
342 			VERIFY0(nvpair_value_uint32_array(curr, &val, &valsz));
343 			FPRINTF(fp, "[");
344 			for (i = 0; i < valsz; i++) {
345 				if (i > 0)
346 					FPRINTF(fp, ",");
347 				FPRINTF(fp, "%u", val[i]);
348 			}
349 			FPRINTF(fp, "]");
350 			break;
351 		}
352 
353 		case DATA_TYPE_INT32_ARRAY: {
354 			int32_t *val;
355 			uint_t valsz, i;
356 			VERIFY0(nvpair_value_int32_array(curr, &val, &valsz));
357 			FPRINTF(fp, "[");
358 			for (i = 0; i < valsz; i++) {
359 				if (i > 0)
360 					FPRINTF(fp, ",");
361 				FPRINTF(fp, "%d", val[i]);
362 			}
363 			FPRINTF(fp, "]");
364 			break;
365 		}
366 
367 		case DATA_TYPE_UINT64_ARRAY: {
368 			uint64_t *val;
369 			uint_t valsz, i;
370 			VERIFY0(nvpair_value_uint64_array(curr, &val, &valsz));
371 			FPRINTF(fp, "[");
372 			for (i = 0; i < valsz; i++) {
373 				if (i > 0)
374 					FPRINTF(fp, ",");
375 				FPRINTF(fp, "%llu",
376 				    (unsigned long long)val[i]);
377 			}
378 			FPRINTF(fp, "]");
379 			break;
380 		}
381 
382 		case DATA_TYPE_INT64_ARRAY: {
383 			int64_t *val;
384 			uint_t valsz, i;
385 			VERIFY0(nvpair_value_int64_array(curr, &val, &valsz));
386 			FPRINTF(fp, "[");
387 			for (i = 0; i < valsz; i++) {
388 				if (i > 0)
389 					FPRINTF(fp, ",");
390 				FPRINTF(fp, "%lld", (long long)val[i]);
391 			}
392 			FPRINTF(fp, "]");
393 			break;
394 		}
395 
396 		case DATA_TYPE_UNKNOWN:
397 			return (-1);
398 		}
399 	}
400 
401 	FPRINTF(fp, "}");
402 	return (0);
403 }
404