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