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