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