xref: /spdk/lib/json/json_util.c (revision 94a84ae98590bea46939eb1dcd7a9876bd393b54) 
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright (c) Intel Corporation.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 
34 #include "spdk/json.h"
35 
36 #include "spdk_internal/utf.h"
37 #include "spdk_internal/log.h"
38 
39 #define SPDK_JSON_DEBUG(...) SPDK_DEBUGLOG(SPDK_LOG_JSON_UTIL, __VA_ARGS__)
40 
41 size_t
42 spdk_json_val_len(const struct spdk_json_val *val)
43 {
44 	if (val == NULL) {
45 		return 0;
46 	}
47 
48 	if (val->type == SPDK_JSON_VAL_ARRAY_BEGIN || val->type == SPDK_JSON_VAL_OBJECT_BEGIN) {
49 		return val->len + 2;
50 	}
51 
52 	return 1;
53 }
54 
55 bool
56 spdk_json_strequal(const struct spdk_json_val *val, const char *str)
57 {
58 	size_t len;
59 
60 	if (val->type != SPDK_JSON_VAL_STRING && val->type != SPDK_JSON_VAL_NAME) {
61 		return false;
62 	}
63 
64 	len = strlen(str);
65 	if (val->len != len) {
66 		return false;
67 	}
68 
69 	return memcmp(val->start, str, len) == 0;
70 }
71 
72 char *
73 spdk_json_strdup(const struct spdk_json_val *val)
74 {
75 	size_t len;
76 	char *s;
77 
78 	if (val->type != SPDK_JSON_VAL_STRING && val->type != SPDK_JSON_VAL_NAME) {
79 		return NULL;
80 	}
81 
82 	len = val->len;
83 
84 	if (memchr(val->start, '\0', len)) {
85 		/* String contains embedded NUL, so it is not a valid C string. */
86 		return NULL;
87 	}
88 
89 	s = malloc(len + 1);
90 	if (s == NULL) {
91 		return s;
92 	}
93 
94 	memcpy(s, val->start, len);
95 	s[len] = '\0';
96 
97 	return s;
98 }
99 
100 struct spdk_json_num {
101 	bool negative;
102 	uint64_t significand;
103 	int64_t exponent;
104 };
105 
106 static int
107 spdk_json_number_split(const struct spdk_json_val *val, struct spdk_json_num *num)
108 {
109 	const char *iter;
110 	size_t remaining;
111 	uint64_t *pval;
112 	uint64_t frac_digits = 0;
113 	uint64_t exponent_u64 = 0;
114 	bool exponent_negative = false;
115 	enum {
116 		NUM_STATE_INT,
117 		NUM_STATE_FRAC,
118 		NUM_STATE_EXP,
119 	} state;
120 
121 	memset(num, 0, sizeof(*num));
122 
123 	if (val->type != SPDK_JSON_VAL_NUMBER) {
124 		return -EINVAL;
125 	}
126 
127 	remaining = val->len;
128 	if (remaining == 0) {
129 		return -EINVAL;
130 	}
131 
132 	iter = val->start;
133 	if (*iter == '-') {
134 		num->negative = true;
135 		iter++;
136 		remaining--;
137 	}
138 
139 	state = NUM_STATE_INT;
140 	pval = &num->significand;
141 	while (remaining--) {
142 		char c = *iter++;
143 
144 		if (c == '.') {
145 			state = NUM_STATE_FRAC;
146 		} else if (c == 'e' || c == 'E') {
147 			state = NUM_STATE_EXP;
148 			pval = &exponent_u64;
149 		} else if (c == '-') {
150 			assert(state == NUM_STATE_EXP);
151 			exponent_negative = true;
152 		} else if (c == '+') {
153 			assert(state == NUM_STATE_EXP);
154 			/* exp_negative = false; */ /* already false by default */
155 		} else {
156 			uint64_t new_val;
157 
158 			assert(c >= '0' && c <= '9');
159 			new_val = *pval * 10 + c - '0';
160 			if (new_val < *pval) {
161 				return -ERANGE;
162 			}
163 
164 			if (state == NUM_STATE_FRAC) {
165 				frac_digits++;
166 			}
167 
168 			*pval = new_val;
169 		}
170 	}
171 
172 	if (exponent_negative) {
173 		if (exponent_u64 > 9223372036854775808ULL) { /* abs(INT64_MIN) */
174 			return -ERANGE;
175 		}
176 		num->exponent = (int64_t) - exponent_u64;
177 	} else {
178 		if (exponent_u64 > INT64_MAX) {
179 			return -ERANGE;
180 		}
181 		num->exponent = exponent_u64;
182 	}
183 	num->exponent -= frac_digits;
184 
185 	/* Apply as much of the exponent as possible without overflow or truncation */
186 	if (num->exponent < 0) {
187 		while (num->exponent && num->significand >= 10 && num->significand % 10 == 0) {
188 			num->significand /= 10;
189 			num->exponent++;
190 		}
191 	} else { /* positive exponent */
192 		while (num->exponent) {
193 			uint64_t new_val = num->significand * 10;
194 
195 			if (new_val < num->significand) {
196 				break;
197 			}
198 
199 			num->significand = new_val;
200 			num->exponent--;
201 		}
202 	}
203 
204 	return 0;
205 }
206 
207 int
208 spdk_json_number_to_uint16(const struct spdk_json_val *val, uint16_t *num)
209 {
210 	struct spdk_json_num split_num;
211 	int rc;
212 
213 	rc = spdk_json_number_split(val, &split_num);
214 	if (rc) {
215 		return rc;
216 	}
217 
218 	if (split_num.exponent || split_num.negative) {
219 		return -ERANGE;
220 	}
221 
222 	if (split_num.significand > UINT16_MAX) {
223 		return -ERANGE;
224 	}
225 	*num = (uint16_t)split_num.significand;
226 	return 0;
227 }
228 
229 int
230 spdk_json_number_to_int32(const struct spdk_json_val *val, int32_t *num)
231 {
232 	struct spdk_json_num split_num;
233 	int rc;
234 
235 	rc = spdk_json_number_split(val, &split_num);
236 	if (rc) {
237 		return rc;
238 	}
239 
240 	if (split_num.exponent) {
241 		return -ERANGE;
242 	}
243 
244 	if (split_num.negative) {
245 		if (split_num.significand > 2147483648) { /* abs(INT32_MIN) */
246 			return -ERANGE;
247 		}
248 		*num = (int32_t) - (int64_t)split_num.significand;
249 		return 0;
250 	}
251 
252 	/* positive */
253 	if (split_num.significand > INT32_MAX) {
254 		return -ERANGE;
255 	}
256 	*num = (int32_t)split_num.significand;
257 	return 0;
258 }
259 
260 int
261 spdk_json_number_to_uint32(const struct spdk_json_val *val, uint32_t *num)
262 {
263 	struct spdk_json_num split_num;
264 	int rc;
265 
266 	rc = spdk_json_number_split(val, &split_num);
267 	if (rc) {
268 		return rc;
269 	}
270 
271 	if (split_num.exponent || split_num.negative) {
272 		return -ERANGE;
273 	}
274 
275 	if (split_num.significand > UINT32_MAX) {
276 		return -ERANGE;
277 	}
278 	*num = (uint32_t)split_num.significand;
279 	return 0;
280 }
281 
282 int
283 spdk_json_number_to_uint64(const struct spdk_json_val *val, uint64_t *num)
284 {
285 	struct spdk_json_num split_num;
286 	int rc;
287 
288 	rc = spdk_json_number_split(val, &split_num);
289 	if (rc) {
290 		return rc;
291 	}
292 
293 	if (split_num.exponent || split_num.negative) {
294 		return -ERANGE;
295 	}
296 
297 	*num = split_num.significand;
298 	return 0;
299 }
300 
301 int
302 spdk_json_decode_object(const struct spdk_json_val *values,
303 			const struct spdk_json_object_decoder *decoders, size_t num_decoders, void *out)
304 {
305 	uint32_t i;
306 	bool invalid = false;
307 	size_t decidx;
308 	bool *seen;
309 
310 	if (values == NULL || values->type != SPDK_JSON_VAL_OBJECT_BEGIN) {
311 		return -1;
312 	}
313 
314 	seen = calloc(sizeof(bool), num_decoders);
315 	if (seen == NULL) {
316 		return -1;
317 	}
318 
319 	for (i = 0; i < values->len;) {
320 		const struct spdk_json_val *name = &values[i + 1];
321 		const struct spdk_json_val *v = &values[i + 2];
322 		bool found = false;
323 
324 		for (decidx = 0; decidx < num_decoders; decidx++) {
325 			const struct spdk_json_object_decoder *dec = &decoders[decidx];
326 			if (spdk_json_strequal(name, dec->name)) {
327 				void *field = (void *)((uintptr_t)out + dec->offset);
328 
329 				found = true;
330 
331 				if (seen[decidx]) {
332 					/* duplicate field name */
333 					invalid = true;
334 					SPDK_JSON_DEBUG("Duplicate key '%s'\n", dec->name);
335 				} else {
336 					seen[decidx] = true;
337 					if (dec->decode_func(v, field)) {
338 						invalid = true;
339 						SPDK_JSON_DEBUG("Decoder failed to decode key '%s'\n", dec->name);
340 						/* keep going to fill out any other valid keys */
341 					}
342 				}
343 				break;
344 			}
345 		}
346 
347 		if (!found) {
348 			invalid = true;
349 			SPDK_JSON_DEBUG("Decoder not found for key '%.*s'\n", name->len, (char *)name->start);
350 		}
351 
352 		i += 1 + spdk_json_val_len(v);
353 	}
354 
355 	for (decidx = 0; decidx < num_decoders; decidx++) {
356 		if (!decoders[decidx].optional && !seen[decidx]) {
357 			/* required field is missing */
358 			invalid = true;
359 			break;
360 		}
361 	}
362 
363 	free(seen);
364 	return invalid ? -1 : 0;
365 }
366 
367 int
368 spdk_json_decode_array(const struct spdk_json_val *values, spdk_json_decode_fn decode_func,
369 		       void *out, size_t max_size, size_t *out_size, size_t stride)
370 {
371 	uint32_t i;
372 	char *field;
373 	char *out_end;
374 
375 	if (values == NULL || values->type != SPDK_JSON_VAL_ARRAY_BEGIN) {
376 		return -1;
377 	}
378 
379 	*out_size = 0;
380 	field = out;
381 	out_end = field + max_size * stride;
382 	for (i = 0; i < values->len;) {
383 		const struct spdk_json_val *v = &values[i + 1];
384 
385 		if (field == out_end) {
386 			return -1;
387 		}
388 
389 		if (decode_func(v, field)) {
390 			return -1;
391 		}
392 
393 		i += spdk_json_val_len(v);
394 		field += stride;
395 		(*out_size)++;
396 	}
397 
398 	return 0;
399 }
400 
401 int
402 spdk_json_decode_bool(const struct spdk_json_val *val, void *out)
403 {
404 	bool *f = out;
405 
406 	if (val->type != SPDK_JSON_VAL_TRUE && val->type != SPDK_JSON_VAL_FALSE) {
407 		return -1;
408 	}
409 
410 	*f = val->type == SPDK_JSON_VAL_TRUE;
411 	return 0;
412 }
413 
414 int
415 spdk_json_decode_uint16(const struct spdk_json_val *val, void *out)
416 {
417 	uint16_t *i = out;
418 
419 	return spdk_json_number_to_uint16(val, i);
420 }
421 
422 int
423 spdk_json_decode_int32(const struct spdk_json_val *val, void *out)
424 {
425 	int32_t *i = out;
426 
427 	return spdk_json_number_to_int32(val, i);
428 }
429 
430 int
431 spdk_json_decode_uint32(const struct spdk_json_val *val, void *out)
432 {
433 	uint32_t *i = out;
434 
435 	return spdk_json_number_to_uint32(val, i);
436 }
437 
438 int
439 spdk_json_decode_uint64(const struct spdk_json_val *val, void *out)
440 {
441 	uint64_t *i = out;
442 
443 	return spdk_json_number_to_uint64(val, i);
444 }
445 
446 int
447 spdk_json_decode_string(const struct spdk_json_val *val, void *out)
448 {
449 	char **s = out;
450 
451 	free(*s);
452 
453 	*s = spdk_json_strdup(val);
454 
455 	if (*s) {
456 		return 0;
457 	} else {
458 		return -1;
459 	}
460 }
461 
462 static struct spdk_json_val *
463 spdk_json_first(struct spdk_json_val *object, enum spdk_json_val_type type)
464 {
465 	/* 'object' must be JSON object or array. 'type' might be combination of these two. */
466 	assert((type & (SPDK_JSON_VAL_ARRAY_BEGIN | SPDK_JSON_VAL_OBJECT_BEGIN)) != 0);
467 
468 	assert(object != NULL);
469 
470 	if ((object->type & type) == 0) {
471 		return NULL;
472 	}
473 
474 	object++;
475 	if (object->len == 0) {
476 		return NULL;
477 	}
478 
479 	return object;
480 }
481 
482 static struct spdk_json_val *
483 spdk_json_value(struct spdk_json_val *key)
484 {
485 	return key->type == SPDK_JSON_VAL_NAME ? key + 1 : NULL;
486 }
487 
488 int
489 spdk_json_find(struct spdk_json_val *object, const char *key_name, struct spdk_json_val **key,
490 	       struct spdk_json_val **val, enum spdk_json_val_type type)
491 {
492 	struct spdk_json_val *_key = NULL;
493 	struct spdk_json_val *_val = NULL;
494 	struct spdk_json_val *it;
495 
496 	assert(object != NULL);
497 
498 	for (it = spdk_json_first(object, SPDK_JSON_VAL_ARRAY_BEGIN | SPDK_JSON_VAL_OBJECT_BEGIN);
499 	     it != NULL;
500 	     it = spdk_json_next(it)) {
501 		if (it->type != SPDK_JSON_VAL_NAME) {
502 			continue;
503 		}
504 
505 		if (spdk_json_strequal(it, key_name) != true) {
506 			continue;
507 		}
508 
509 		if (_key) {
510 			SPDK_JSON_DEBUG("Duplicate key '%s'", key_name);
511 			return -EINVAL;
512 		}
513 
514 		_key = it;
515 		_val = spdk_json_value(_key);
516 
517 		if (type != SPDK_JSON_VAL_INVALID && (_val->type & type) == 0) {
518 			SPDK_JSON_DEBUG("key '%s' type is %#x but expected one of %#x\n", key_name, _val->type, type);
519 			return -EDOM;
520 		}
521 	}
522 
523 	if (key) {
524 		*key = _key;
525 	}
526 
527 	if (val) {
528 		*val = _val;
529 	}
530 
531 	return _val ? 0 : -ENOENT;
532 }
533 
534 int
535 spdk_json_find_string(struct spdk_json_val *object, const char *key_name,
536 		      struct spdk_json_val **key, struct spdk_json_val **val)
537 {
538 	return spdk_json_find(object, key_name, key, val, SPDK_JSON_VAL_STRING);
539 }
540 
541 int
542 spdk_json_find_array(struct spdk_json_val *object, const char *key_name,
543 		     struct spdk_json_val **key, struct spdk_json_val **val)
544 {
545 	return spdk_json_find(object, key_name, key, val, SPDK_JSON_VAL_ARRAY_BEGIN);
546 }
547 
548 struct spdk_json_val *
549 spdk_json_object_first(struct spdk_json_val *object)
550 {
551 	struct spdk_json_val *first = spdk_json_first(object, SPDK_JSON_VAL_OBJECT_BEGIN);
552 
553 	/* Empty object? */
554 	return first && first->type != SPDK_JSON_VAL_OBJECT_END ? first : NULL;
555 }
556 
557 struct spdk_json_val *
558 spdk_json_array_first(struct spdk_json_val *array_begin)
559 {
560 	struct spdk_json_val *first = spdk_json_first(array_begin, SPDK_JSON_VAL_ARRAY_BEGIN);
561 
562 	/* Empty array? */
563 	return first && first->type != SPDK_JSON_VAL_ARRAY_END ? first : NULL;
564 }
565 
566 static struct spdk_json_val *
567 spdk_json_skip_object_or_array(struct spdk_json_val *val)
568 {
569 	unsigned lvl;
570 	enum spdk_json_val_type end_type;
571 	struct spdk_json_val *it;
572 
573 	if (val->type == SPDK_JSON_VAL_OBJECT_BEGIN) {
574 		end_type = SPDK_JSON_VAL_OBJECT_END;
575 	} else if (val->type == SPDK_JSON_VAL_ARRAY_BEGIN) {
576 		end_type = SPDK_JSON_VAL_ARRAY_END;
577 	} else {
578 		SPDK_JSON_DEBUG("Expected JSON object (%#x) or array (%#x) but got %#x\n",
579 				SPDK_JSON_VAL_OBJECT_BEGIN, SPDK_JSON_VAL_ARRAY_BEGIN, val->type);
580 		return NULL;
581 	}
582 
583 	lvl = 1;
584 	for (it = val + 1; it->type != SPDK_JSON_VAL_INVALID && lvl != 0; it++) {
585 		if (it->type == val->type) {
586 			lvl++;
587 		} else if (it->type == end_type) {
588 			lvl--;
589 		}
590 	}
591 
592 	/* if lvl != 0 we have invalid JSON object */
593 	if (lvl != 0) {
594 		SPDK_JSON_DEBUG("Can't find end of object (type: %#x): lvl (%u) != 0)\n", val->type, lvl);
595 		it = NULL;
596 	}
597 
598 	return it;
599 }
600 
601 struct spdk_json_val *
602 spdk_json_next(struct spdk_json_val *it)
603 {
604 	struct spdk_json_val *val, *next;
605 
606 	switch (it->type) {
607 	case SPDK_JSON_VAL_NAME:
608 		val = spdk_json_value(it);
609 		next = spdk_json_next(val);
610 		break;
611 
612 	/* We are in the middle of an array - get to next entry */
613 	case SPDK_JSON_VAL_NULL:
614 	case SPDK_JSON_VAL_TRUE:
615 	case SPDK_JSON_VAL_FALSE:
616 	case SPDK_JSON_VAL_NUMBER:
617 	case SPDK_JSON_VAL_STRING:
618 		val = it + 1;
619 		return val;
620 
621 	case SPDK_JSON_VAL_ARRAY_BEGIN:
622 	case SPDK_JSON_VAL_OBJECT_BEGIN:
623 		next = spdk_json_skip_object_or_array(it);
624 		break;
625 
626 	/* Can't go to the next object if started from the end of array or object */
627 	case SPDK_JSON_VAL_ARRAY_END:
628 	case SPDK_JSON_VAL_OBJECT_END:
629 	case SPDK_JSON_VAL_INVALID:
630 		return NULL;
631 	default:
632 		assert(false);
633 		return NULL;
634 
635 	}
636 
637 	/* EOF ? */
638 	if (next == NULL) {
639 		return NULL;
640 	}
641 
642 	switch (next->type) {
643 	case SPDK_JSON_VAL_ARRAY_END:
644 	case SPDK_JSON_VAL_OBJECT_END:
645 	case SPDK_JSON_VAL_INVALID:
646 		return NULL;
647 	default:
648 		/* Next value */
649 		return next;
650 	}
651 }
652 
653 SPDK_LOG_REGISTER_COMPONENT("json_util", SPDK_LOG_JSON_UTIL)
654