1: /*************************************************************************
2: * (C) 2017 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
6: * $Id: json.c,v 1.13 2025/08/25 13:00:37 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004 - 2025
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /* JSON error strings */
50: const char *jerrstr[] = {
51: "No error",
52: "Not enough tokens were provided",
53: "Invalid character",
54: "JSON string isn't full",
55: "Invalid parameter",
56: NULL
57: };
58:
59:
60: /*
61: * json_init() - Initialize JSON handler
62: *
63: * @json = JSON handler, if there is NULL then dynamically will be allocated
64: * @jstrict = JSON strict mode, when we select strict mode every unquoted value is error
65: * return: =NULL error or !=NULL ready for use JSON handler and should be free with json_free()
66: */
67: json_t *
68: json_init(json_t * __restrict json, int jstrict)
69: {
70: json_t *j = json;
71:
72: if (!j) {
73: j = e_malloc(sizeof(json_t));
74: if (!j) {
75: LOGERR;
76: return NULL;
77: }
78: }
79:
80: memset(j, 0, sizeof(json_t));
81: j->h_parent = -1;
82: j->h_strict = jstrict;
83:
84: /* handler is dynamically allocated! */
85: if (!json)
86: j->h_alloc = j;
87:
88: return j;
89: }
90:
91: /*
92: * json_free() - Free JSON handler
93: *
94: * @json = JSON handler
95: * return: none
96: */
97: void
98: json_free(json_t * __restrict json)
99: {
100: if (json) {
101: if (json->h_alloc)
102: e_free(json);
103: else
104: memset(json, 0, sizeof(json_t));
105: }
106: }
107:
108: static jtok_t *
109: json_gettoken(json_t * __restrict json, jtok_t * __restrict jtoks, u_int toksnum)
110: {
111: jtok_t *tok;
112:
113: assert(json || !(!jtoks && toksnum));
114:
115: if (json->h_next >= toksnum) {
116: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
117: return NULL;
118: } else
119: tok = &jtoks[json->h_next];
120: tok->tok_idx = json->h_next++;
121: tok->tok_start = tok->tok_end = tok->tok_parent = -1;
122: tok->tok_size = 0;
123:
124: return tok;
125: }
126:
127: inline void
128: json_filltoken(jtok_t * __restrict tok, jtype_t type, long start, long end, long parent)
129: {
130: assert(tok);
131:
132: tok->tok_type = type;
133: tok->tok_start = start;
134: tok->tok_end = end;
135: tok->tok_parent = parent;
136: tok->tok_size = 0;
137: }
138:
139: static int
140: json_parse_string(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
141: {
142: jtok_t *tok;
143: u_long pos;
144: char ch;
145: register int i;
146:
147: assert(json || jstr || !(!jtoks && toksnum));
148:
149: for (pos = json->h_pos++; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
150: ch = jstr[json->h_pos];
151:
152: if (ch == '\"') {
153: if (!jtoks)
154: return 0;
155: if (!(tok = json_gettoken(json, jtoks, toksnum))) {
156: json->h_pos = pos;
157: return -1;
158: } else
159: json_filltoken(tok, J_STRING, pos + 1, json->h_pos, json->h_parent);
160: return 0;
161: }
162:
163: if (ch == '\\' && json->h_pos + 1 < jlen) {
164: switch (jstr[++json->h_pos]) {
165: case '\"':
166: case '/':
167: case '\\':
168: case 'b':
169: case 'f':
170: case 'r':
171: case 'n':
172: case 't':
173: /* Allowed escaped symbols */
174: break;
175: case 'u':
176: /* Allows escaped symbol \uXXXX */
177: json->h_pos++;
178: for (i = 0; i < 4 && json->h_pos < jlen && jstr[json->h_pos]; i++, json->h_pos++) {
179: /* If it isn't a hex character we have an error */
180: if (!((jstr[json->h_pos] >= 48 && jstr[json->h_pos] <= 57) || /* 0-9 */
181: (jstr[json->h_pos] >= 65 && jstr[json->h_pos] <= 70) || /* A-F */
182: (jstr[json->h_pos] >= 97 && jstr[json->h_pos] <= 102))) { /* a-f */
183: json->h_pos = pos;
184: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
185: return -1;
186: }
187: }
188: json->h_pos--;
189: break;
190: default:
191: /* Unexpected symbol */
192: json->h_pos = pos;
193: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
194: return -1;
195: }
196: }
197: }
198:
199: json->h_pos = pos;
200: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
201: return -1;
202: }
203:
204: static int
205: json_parse_value(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
206: {
207: jtok_t *tok;
208: u_long pos;
209:
210: assert(json || jstr || !(!jtoks && toksnum));
211:
212: for (pos = json->h_pos; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
213: switch (jstr[json->h_pos]) {
214: case ':':
215: if (json->h_strict)
216: goto found;
217: break;
218: case '\t':
219: case '\r':
220: case '\n':
221: case ' ':
222: case ',':
223: case ']':
224: case '}':
225: goto found;
226: }
227: if (jstr[json->h_pos] < 32 || (u_char) jstr[json->h_pos] > 127) {
228: json->h_pos = pos;
229: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
230: return -1;
231: }
232: }
233:
234: if (json->h_strict) {
235: json->h_pos = pos;
236: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
237: return -1;
238: }
239: found:
240: if (jtoks) {
241: if (!(tok = json_gettoken(json, jtoks, toksnum))) {
242: json->h_pos = pos;
243: return -1;
244: } else
245: json_filltoken(tok, J_VALUE, pos, json->h_pos, json->h_parent);
246: }
247:
248: json->h_pos--;
249: return 0;
250: }
251:
252: /*
253: * json_parse() - Parse JSON string
254: *
255: * @json = JSON handler
256: * @jstr = JSON string
257: * @jlen = JSON string length
258: * @jtoks = Token array
259: * @toksnum = Token array size, return number of allocated tokens in array
260: * return: -1 error or number of found tokens
261: */
262: u_int
263: json_parse(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
264: {
265: register int i;
266: register u_int cx;
267: jtype_t type;
268: jtok_t *tok;
269: char ch;
270:
271: if (!json || !jstr || (!jtoks && toksnum)) {
272: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
273: return (u_int) -1;
274: }
275:
276: for (cx = json->h_next; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
277: switch ((ch = jstr[json->h_pos])) {
278: case '{':
279: case '[':
280: cx++; /* start new object/array token */
281: if (!jtoks)
282: break;
283:
284: tok = json_gettoken(json, jtoks, toksnum);
285: if (!tok)
286: return (u_int) -1;
287: if (json->h_parent != -1) {
288: jtoks[json->h_parent].tok_size++;
289: tok->tok_parent = json->h_parent;
290: }
291: tok->tok_type = (ch == '{' ? J_OBJECT : J_ARRAY);
292: tok->tok_start = json->h_pos;
293: json->h_parent = json->h_next - 1;
294: break;
295: case '}':
296: case ']':
297: if (!jtoks)
298: break;
299:
300: if (json->h_next < 1) {
301: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
302: return (u_int) -1;
303: }
304:
305: type = (ch == '}' ? J_OBJECT : J_ARRAY);
306: tok = &jtoks[json->h_next - 1];
307: while (42) {
308: if (tok->tok_start != -1 && tok->tok_end == -1) {
309: if (tok->tok_type != type) {
310: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
311: return (u_int) -1;
312: }
313: tok->tok_end = json->h_pos + 1;
314: json->h_parent = tok->tok_parent;
315: break;
316: }
317: if (tok->tok_parent == -1) {
318: if (tok->tok_type != type || json->h_parent == -1) {
319: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
320: return (u_int) -1;
321: }
322: break;
323: }
324: tok = &jtoks[tok->tok_parent];
325: }
326: break;
327: case '\"':
328: if (json_parse_string(json, jstr, jlen, jtoks, toksnum) == -1)
329: return (u_int) -1;
330: cx++; /* start new string token */
331: if (jtoks && json->h_parent != -1)
332: jtoks[json->h_parent].tok_size++;
333: break;
334: case '\t':
335: case '\r':
336: case '\n':
337: case ' ':
338: /* whitespace, skip */
339: break;
340: case ':':
341: json->h_parent = json->h_next - 1;
342: break;
343: case ',':
344: if (jtoks && json->h_parent != -1 &&
345: jtoks[json->h_parent].tok_type != J_OBJECT &&
346: jtoks[json->h_parent].tok_type != J_ARRAY)
347: json->h_parent = jtoks[json->h_parent].tok_parent;
348: break;
349: case '-':
350: case '0':
351: case '1':
352: case '2':
353: case '3':
354: case '4':
355: case '5':
356: case '6':
357: case '7':
358: case '8':
359: case '9':
360: case 't':
361: case 'f':
362: case 'n':
363: if (json->h_strict) {
364: if (jtoks && json->h_parent != -1) {
365: /* they must not be keys of the object */
366: if (jtoks[json->h_parent].tok_type == J_OBJECT ||
367: (jtoks[json->h_parent].tok_type == J_STRING &&
368: jtoks[json->h_parent].tok_size)) {
369: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
370: return (u_int) -1;
371: }
372: }
373:
374: if (json_parse_value(json, jstr, jlen, jtoks, toksnum) == -1)
375: return (u_int) -1;
376: cx++; /* start new value token */
377: if (jtoks && json->h_parent != -1)
378: jtoks[json->h_parent].tok_size++;
379: break;
380: }
381: default:
382: if (json->h_strict) {
383: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
384: return (u_int) -1;
385: }
386:
387: if (json_parse_value(json, jstr, jlen, jtoks, toksnum) == -1)
388: return (u_int) -1;
389: cx++; /* start new value token */
390: if (jtoks && json->h_parent != -1)
391: jtoks[json->h_parent].tok_size++;
392: break;
393: }
394: }
395:
396: if (jtoks) {
397: for (i = json->h_next - 1; i >= 0; i--) {
398: /* unmatched opened object or array */
399: if (jtoks[i].tok_start != -1 && jtoks[i].tok_end == -1) {
400: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
401: return (u_int) -1;
402: }
403: }
404: } else
405: cx++; /* increment needed tokens number for termination empty token */
406:
407: return cx;
408: }
409:
410: /*
411: * json_token2val() - Return token to AIT variable
412: *
413: * @jstr = JSON string
414: * @tok = Token for convert
415: * @return =NULL error or !=NULL allocated variable, after use should be ait_freeVar()
416: */
417: ait_val_t *
418: json_token2val(const char *jstr, jtok_t * __restrict tok)
419: {
420: ait_val_t *v = NULL;
421:
422: if (!jstr || !tok)
423: return NULL;
424:
425: v = ait_allocVar();
426: if (!v)
427: return NULL;
428:
429: AIT_SET_STRSIZ(v, json_toklen(tok));
430: if (AIT_GET_STR(v))
431: strncpy(AIT_GET_STR(v), json_tokstr(jstr, tok), AIT_LEN(v) - 1);
432: else
433: ait_freeVar(&v);
434:
435: return v;
436: }
437:
438: /*
439: * json_token2str() - Return token to string
440: *
441: * @jstr = JSON string
442: * @tok = Token for convert
443: * @return =NULL error or !=NULL allocated str, after use should be json_freestr()|e_free()
444: */
445: char *
446: json_token2str(const char *jstr, jtok_t * __restrict tok)
447: {
448: char *s, *s2, *wrk, *str = NULL;
449: size_t len;
450:
451: if (!jstr || !tok)
452: return NULL;
453:
454:
455: len = json_toklen(tok);
456: str = e_malloc(len + 1);
457: if (!str)
458: return NULL;
459: else {
460: memset(str, 0, len + 1);
461:
462: wrk = e_strdup(json_tokstr(jstr, tok));
463: wrk[len] = 0;
464: for (s = wrk, s2 = str; *s; s++)
465: *s2++ = (*s != '\\') ? *s : *++s;
466: e_free(wrk);
467: }
468:
469: return str;
470: }
471:
472: /*
473: * json_token2num() - Return token to numeric
474: *
475: * @jstr = JSON string
476: * @tok = Token for convert
477: * @return number
478: */
479: long
480: json_token2num(const char *jstr, jtok_t * __restrict tok)
481: {
482: long ret = 0;
483: char *str;
484:
485: str = json_token2str(jstr, tok);
486: if (!str)
487: return 0;
488:
489: ret = strtol(str, NULL, 0);
490: e_free(str);
491: return ret;
492: }
493:
494: /*
495: * json_token2dbl() - Return token to double
496: *
497: * @jstr = JSON string
498: * @tok = Token for convert
499: * @return number
500: */
501: double
502: json_token2dbl(const char *jstr, jtok_t * __restrict tok)
503: {
504: double ret = 0;
505: char *str;
506:
507: str = json_token2str(jstr, tok);
508: if (!str)
509: return 0;
510:
511: ret = strtod(str, NULL);
512: e_free(str);
513: return ret;
514: }
515:
516: /*
517: * json_token2bool() - Return token to bool int
518: *
519: * @jstr = JSON string
520: * @tok = Token for convert
521: * @return 0 for FALSE and !=0 for TRUE
522: */
523: int
524: json_token2bool(const char *jstr, jtok_t * __restrict tok)
525: {
526: double ret = 0;
527: char *str;
528:
529: str = json_token2str(jstr, tok);
530: if (!str)
531: return 0;
532:
533: switch (*str) {
534: case 't':
535: case 'T':
536: ret = 1;
537: break;
538: case 'f':
539: case 'F':
540: ret = 0;
541: break;
542: default:
543: ret = (int) strtol(str, NULL, 10);
544: break;
545: }
546: e_free(str);
547: return ret;
548: }
549:
550: /*
551: * json_findbykey() - Find token data by key
552: *
553: * @jstr = JSON string
554: * @key = Search key
555: * @type = Search key for particular token type, if is J_UNDEF this mean any type
556: * @toks = Parsed tokens
557: * @toksnum = Number of parsed tokens
558: * return: =NULL error or !=NULL data token found
559: */
560: jtok_t *
561: json_findbykey(const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
562: {
563: jtok_t *tok = NULL;
564: register int i;
565: int klen;
566:
567: if (!jstr || !key || !toks)
568: return NULL;
569: else
570: klen = strlen(key);
571:
572: for (i = 1; i < toksnum; i++) {
573: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
574: klen == toks[i].tok_end - toks[i].tok_start &&
575: !strncmp(jstr + toks[i].tok_start, key, klen)) {
576: if (type != J_UNDEF) {
577: if (toks[i + 1].tok_type == type) {
578: tok = toks + i + 1;
579: break;
580: }
581: } else {
582: tok = toks + i + 1;
583: break;
584: }
585: }
586: }
587:
588: return tok;
589: }
590:
591: /*
592: * json_findbykeyatscope() - Find token data by key at particular scope
593: *
594: * @scope = Search at object scope, =0 main object scope
595: * @jstr = JSON string
596: * @key = Search key
597: * @type = Search key for particular token type, if is J_UNDEF this mean any type
598: * @toks = Parsed tokens
599: * @toksnum = Number of parsed tokens
600: * return: =NULL error or !=NULL data token found
601: */
602: jtok_t *
603: json_findbykeyatscope(long scope, const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
604: {
605: jtok_t *tok = NULL;
606: register int i;
607: int klen;
608:
609: if (!jstr || !key || !toks)
610: return NULL;
611: else
612: klen = strlen(key);
613:
614: for (i = 1; i < toksnum; i++) {
615: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
616: toks[i].tok_parent == scope &&
617: klen == toks[i].tok_end - toks[i].tok_start &&
618: !strncmp(jstr + toks[i].tok_start, key, klen)) {
619: if (type != J_UNDEF) {
620: if (toks[i + 1].tok_type == type) {
621: tok = toks + i + 1;
622: break;
623: }
624: } else {
625: tok = toks + i + 1;
626: break;
627: }
628: }
629: }
630:
631: return tok;
632: }
633:
634: /*
635: * json_findbypos() - Find token by position on JSON string
636: *
637: * @pos = Offset from begin of JSON string
638: * @toks = Parsed tokens
639: * @toksnum = Number of parsed tokens
640: * return: =NULL error or !=NULL token found
641: */
642: jtok_t *
643: json_findbypos(u_long pos, jtok_t * __restrict toks, int toksnum)
644: {
645: jtok_t *tok = NULL;
646: register int i;
647:
648: if (!toks)
649: return NULL;
650:
651: for (i = 1; i < toksnum; i++)
652: if (pos <= toks[i].tok_end && pos >= toks[i].tok_start) {
653: tok = toks + i;
654: break;
655: }
656:
657: return tok;
658: }
659:
660: /*
661: * json_token2vars() - Convert token to string variable array
662: *
663: * @jstr = JSON string
664: * @tok = Token for convert
665: * return: =NULL error or !=NULL allocated array with string variables,
666: * after use should be ait_freeVars()
667: */
668: array_t *
669: json_token2vars(const char *jstr, jtok_t * __restrict tok)
670: {
671: array_t *arr = NULL;
672: register int i, j;
673: int siz;
674: ait_val_t *v;
675: jtok_t *t;
676:
677: if (!jstr || !tok)
678: return NULL;
679:
680: siz = tok->tok_size;
681: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
682: siz++;
683:
684: arr = ait_allocVars(siz);
685: if (!arr)
686: return NULL;
687:
688: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
689: v = ait_getVars(&arr, 0);
690: AIT_SET_STRSIZ(v, json_toklen(tok) + 1);
691: if (AIT_GET_STR(v)) {
692: json_tokstrcpy(AIT_GET_STR(v), jstr, tok);
693: } else {
694: ait_freeVar(&v);
695: }
696: } else if (tok->tok_type == J_ARRAY) {
697: for (i = 0, j = 1; i < tok->tok_size; i++) {
698: t = &tok[i + j];
699: v = ait_getVars(&arr, i);
700: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
701: if (AIT_GET_STR(v)) {
702: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
703: } else {
704: ait_freeVar(&v);
705: }
706:
707: /* if there we have array from objects should parse all object tokens */
708: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
709: j++;
710: }
711: } else if (tok->tok_type == J_OBJECT) {
712: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
713: t = &tok[i + 1];
714: v = ait_getVars(&arr, i);
715: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
716: if (AIT_GET_STR(v)) {
717: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
718: } else {
719: ait_freeVar(&v);
720: }
721: }
722: } else {
723: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
724: ait_freeVars(&arr);
725: return NULL;
726: }
727:
728: return arr;
729: }
730:
731: /*
732: * json_token2array() - Convert token to string array
733: *
734: * @jstr = JSON string
735: * @tok = Token for convert
736: * return: =NULL error or !=NULL allocated array with strings,
737: * after use should be ait_freearray()
738: */
739: array_t *
740: json_token2array(const char *jstr, jtok_t * __restrict tok)
741: {
742: array_t *arr = NULL;
743: register int i, j;
744: int siz;
745: char *str;
746: jtok_t *t;
747:
748: if (!jstr || !tok)
749: return NULL;
750:
751: siz = tok->tok_size;
752: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
753: siz++;
754:
755: arr = array_Init(siz);
756: if (!arr)
757: return NULL;
758:
759: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
760: str = e_malloc(json_toklen(tok) + 1);
761: if (!str) {
762: array_Destroy(&arr);
763: return NULL;
764: } else
765: json_tokstrcpy(str, jstr, tok);
766: if (array_Push(arr, str, 0) == -1) {
767: e_free(str);
768: array_Destroy(&arr);
769: return NULL;
770: }
771: } else if (tok->tok_type == J_ARRAY) {
772: for (i = 0, j = 1; i < tok->tok_size; i++) {
773: t = &tok[i + j];
774: str = e_malloc(json_toklen(t) + 1);
775: if (!str) {
776: json_freearray(&arr);
777: return NULL;
778: } else
779: json_tokstrcpy(str, jstr, t);
780: if (array_Push(arr, str, 0) == -1) {
781: e_free(str);
782: json_freearray(&arr);
783: return NULL;
784: }
785:
786: /* if there we have array from objects should parse all object tokens */
787: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
788: j++;
789: }
790: } else if (tok->tok_type == J_OBJECT) {
791: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
792: t = &tok[i + 1];
793: str = e_malloc(json_toklen(t) + 1);
794: if (!str) {
795: json_freearray(&arr);
796: return NULL;
797: } else
798: json_tokstrcpy(str, jstr, t);
799: if (array_Push(arr, str, 0) == -1) {
800: e_free(str);
801: json_freearray(&arr);
802: return NULL;
803: }
804: }
805: } else {
806: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
807: array_Destroy(&arr);
808: return NULL;
809: }
810:
811: return arr;
812: }
813:
814: /*
815: * json_freearray() - Free & destroy allocated array from json_token2array function
816: *
817: * @parr = Array
818: * return -1 error or 0 ok
819: */
820: int
821: json_freearray(array_t **parr)
822: {
823: if (!parr)
824: return -1;
825:
826: array_Free(*parr);
827: array_Destroy(parr);
828: return 0;
829: }
830:
831:
832: /*
833: * json_add_begin_object() - Adds begin of object {
834: *
835: * @jstr = JSON string
836: * @jlen = JSON string length
837: * @wspace = whitespace include
838: * return: -1 error or !=-1 actual JSON string length
839: */
840: int
841: json_add_begin_object(char * __restrict jstr, int jlen, int wspace)
842: {
843: int len;
844: size_t eos;
845:
846: if (!jstr)
847: return -1;
848: else
849: eos = strlen(jstr);
850:
851:
852: if (wspace)
853: len = strlcat(jstr, "{ ", jlen);
854: else
855: len = strlcat(jstr, "{", jlen);
856:
857: if (len >= jlen) {
858: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
859: jstr[eos] = 0;
860: return -1;
861: }
862:
863: return len;
864: }
865:
866: /*
867: * json_add_end_object() - Adds end of object }
868: *
869: * @jstr = JSON string
870: * @jlen = JSON string length
871: * @wspace = whitespace include
872: * return: -1 error or !=-1 actual JSON string length
873: */
874: int
875: json_add_end_object(char * __restrict jstr, int jlen, int wspace)
876: {
877: int len;
878: size_t eos;
879:
880: if (!jstr)
881: return -1;
882: else
883: eos = strlen(jstr);
884:
885: if (wspace)
886: len = strlcat(jstr, " }", jlen);
887: else
888: len = strlcat(jstr, "}", jlen);
889:
890: if (len >= jlen) {
891: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
892: jstr[eos] = 0;
893: return -1;
894: }
895:
896: return len;
897: }
898:
899: /*
900: * json_add_begin_array() - Adds begin of array [
901: *
902: * @jstr = JSON string
903: * @jlen = JSON string length
904: * @wspace = whitespace include
905: * return: -1 error or !=-1 actual JSON string length
906: */
907: int
908: json_add_begin_array(char * __restrict jstr, int jlen, int wspace)
909: {
910: int len;
911: size_t eos;
912:
913: if (!jstr)
914: return -1;
915: else
916: eos = strlen(jstr);
917:
918: if (wspace)
919: len = strlcat(jstr, "[ ", jlen);
920: else
921: len = strlcat(jstr, "[", jlen);
922:
923: if (len >= jlen) {
924: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
925: jstr[eos] = 0;
926: return -1;
927: }
928:
929: return len;
930: }
931:
932: /*
933: * json_add_end_array() - Adds end of array ]
934: *
935: * @jstr = JSON string
936: * @jlen = JSON string length
937: * @wspace = whitespace include
938: * return: -1 error or !=-1 actual JSON string length
939: */
940: int
941: json_add_end_array(char * __restrict jstr, int jlen, int wspace)
942: {
943: int len;
944: size_t eos;
945:
946: if (!jstr)
947: return -1;
948: else
949: eos = strlen(jstr);
950:
951: if (wspace)
952: len = strlcat(jstr, " ]", jlen);
953: else
954: len = strlcat(jstr, "]", jlen);
955:
956: if (len >= jlen) {
957: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
958: jstr[eos] = 0;
959: return -1;
960: }
961:
962: return len;
963: }
964:
965: /*
966: * json_add_char() - Adds character
967: *
968: * @jstr = JSON string
969: * @jlen = JSON string length
970: * @ch = Character
971: * return: -1 error or !=-1 actual JSON string length
972: */
973: int
974: json_add_char(char * __restrict jstr, int jlen, u_char ch)
975: {
976: int len;
977:
978: if (!jstr)
979: return -1;
980:
981: len = strlen(jstr) + 1;
982: if (len >= jlen) {
983: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
984: return -1;
985: } else {
986: jstr[len++] = (char) ch;
987: jstr[len] = 0;
988: }
989:
990: return len;
991: }
992:
993: /*
994: * json_add_colon() - Adds key/value pair delimiter colon :
995: *
996: * @jstr = JSON string
997: * @jlen = JSON string length
998: * @wspace = whitespace include
999: * return: -1 error or !=-1 actual JSON string length
1000: */
1001: int
1002: json_add_colon(char * __restrict jstr, int jlen, int wspace)
1003: {
1004: int len;
1005: size_t eos;
1006:
1007: if (!jstr)
1008: return -1;
1009: else
1010: eos = strlen(jstr);
1011:
1012: if (wspace)
1013: len = strlcat(jstr, ": ", jlen);
1014: else
1015: len = strlcat(jstr, ":", jlen);
1016:
1017: if (len >= jlen) {
1018: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1019: jstr[eos] = 0;
1020: return -1;
1021: }
1022:
1023: return len;
1024: }
1025:
1026: /*
1027: * json_add_comma() - Adds value delimiter comma ,
1028: *
1029: * @jstr = JSON string
1030: * @jlen = JSON string length
1031: * @wspace = whitespace include
1032: * return: -1 error or !=-1 actual JSON string length
1033: */
1034: int
1035: json_add_comma(char * __restrict jstr, int jlen, int wspace)
1036: {
1037: int len;
1038: size_t eos;
1039:
1040: if (!jstr)
1041: return -1;
1042: else
1043: eos = strlen(jstr);
1044:
1045: if (wspace)
1046: len = strlcat(jstr, ", ", jlen);
1047: else
1048: len = strlcat(jstr, ",", jlen);
1049:
1050: if (len >= jlen) {
1051: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1052: jstr[eos] = 0;
1053: return -1;
1054: }
1055:
1056: return len;
1057: }
1058:
1059: /*
1060: * json_add_string() - Adds string
1061: *
1062: * @jstr = JSON string
1063: * @jlen = JSON string length
1064: * @unquot = Unquoted string
1065: * @str = String, it can't be NULL
1066: * return: -1 error or !=-1 actual JSON string length
1067: */
1068: int
1069: json_add_string(char * __restrict jstr, int jlen, int unquot, const char *str)
1070: {
1071: int len;
1072: size_t eos;
1073:
1074: if (!jstr || !str)
1075: return -1;
1076: else
1077: eos = strlen(jstr);
1078:
1079: if (!unquot) {
1080: len = strlcat(jstr, "\"", jlen);
1081: if (len >= jlen) {
1082: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1083: jstr[eos] = 0;
1084: return -1;
1085: }
1086: }
1087: len = strlcat(jstr, str, jlen);
1088: if (len >= jlen) {
1089: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1090: jstr[eos] = 0;
1091: return -1;
1092: }
1093: if (!unquot) {
1094: len = strlcat(jstr, "\"", jlen);
1095: if (len >= jlen) {
1096: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1097: jstr[eos] = 0;
1098: return -1;
1099: }
1100: }
1101:
1102: return len;
1103: }
1104:
1105: /*
1106: * json_add_value() - Adds value
1107: *
1108: * @jstr = JSON string
1109: * @jlen = JSON string length
1110: * @unquot = Unquoted number
1111: * @num = Number
1112: * return: -1 error or !=-1 actual JSON string length
1113: */
1114: int
1115: json_add_value(char * __restrict jstr, int jlen, int unquot, long num)
1116: {
1117: int len;
1118: char wrk[STRSIZ] = { [0 ... STRSIZ - 1] = 0 };
1119: size_t eos;
1120:
1121: if (!jstr)
1122: return -1;
1123: else
1124: eos = strlen(jstr);
1125:
1126: if (!unquot) {
1127: len = strlcat(jstr, "\"", jlen);
1128: if (len >= jlen) {
1129: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1130: jstr[eos] = 0;
1131: return -1;
1132: }
1133: }
1134: snprintf(wrk, sizeof wrk, "%ld", num);
1135: len = strlcat(jstr, wrk, jlen);
1136: if (len >= jlen) {
1137: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1138: jstr[eos] = 0;
1139: return -1;
1140: }
1141: if (!unquot) {
1142: len = strlcat(jstr, "\"", jlen);
1143: if (len >= jlen) {
1144: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1145: jstr[eos] = 0;
1146: return -1;
1147: }
1148: }
1149:
1150: return len;
1151: }
1152:
1153: /*
1154: * json_add_pair() - Adds key/value pair
1155: *
1156: * @jstr = JSON string
1157: * @jlen = JSON string length
1158: * @wspace = whitespace include
1159: * @key = Key string
1160: * @val = Value string
1161: * return: -1 error or !=-1 actual JSON string length
1162: */
1163: int
1164: json_add_pair(char * __restrict jstr, int jlen, int wspace, const char *key, const char *val)
1165: {
1166: int len = -1;
1167: size_t eos;
1168:
1169: if (!jstr || !key || !val)
1170: return -1;
1171: else
1172: eos = strlen(jstr);
1173:
1174: if (json_add_string(jstr, jlen, 0, key) == -1) {
1175: jstr[eos] = 0;
1176: return -1;
1177: }
1178: if (json_add_colon(jstr, jlen, wspace) == -1) {
1179: jstr[eos] = 0;
1180: return -1;
1181: }
1182: if ((len = json_add_string(jstr, jlen, 0, val)) == -1) {
1183: jstr[eos] = 0;
1184: return -1;
1185: }
1186:
1187: return len;
1188: }
1189:
1190: /*
1191: * json_add_pair2() - Adds key/value pair with formated args
1192: *
1193: * @jstr = JSON string
1194: * @jlen = JSON string length
1195: * @wspace = whitespace include
1196: * @key = Key string
1197: * @fmt = Format string for values
1198: * return: -1 error or !=-1 actual JSON string length
1199: */
1200: int
1201: json_add_pair2(char * __restrict jstr, int jlen, int wspace, const char *key, const char *fmt, ...)
1202: {
1203: int len = -1;
1204: size_t eos;
1205: va_list lst;
1206: char szStr[BUFSIZ] = { [0 ... BUFSIZ - 1] = 0 };
1207:
1208: if (!jstr || !key || !fmt)
1209: return -1;
1210: else
1211: eos = strlen(jstr);
1212:
1213: if (json_add_string(jstr, jlen, 0, key) == -1) {
1214: jstr[eos] = 0;
1215: return -1;
1216: }
1217: if (json_add_colon(jstr, jlen, wspace) == -1) {
1218: jstr[eos] = 0;
1219: return -1;
1220: }
1221: va_start(lst, fmt);
1222: vsnprintf(szStr, sizeof szStr, fmt, lst);
1223: va_end(lst);
1224: if ((len = json_add_string(jstr, jlen, 0, szStr)) == -1) {
1225: jstr[eos] = 0;
1226: return -1;
1227: }
1228:
1229: return len;
1230: }
1231:
1232: /*
1233: * json_add_array() - Adds array
1234: *
1235: * @jstr = JSON string
1236: * @jlen = JSON string length
1237: * @wspace = whitespace include
1238: * @arr = Array with variables
1239: * return: -1 error or !=-1 actual JSON string length
1240: */
1241: int
1242: json_add_array(char * __restrict jstr, int jlen, int wspace, array_t * __restrict arr)
1243: {
1244: int len = -1;
1245: register int i;
1246: ait_val_t *v;
1247: size_t eos;
1248:
1249: if (!jstr || !arr)
1250: return -1;
1251: else
1252: eos = strlen(jstr);
1253:
1254: if (json_add_begin_array(jstr, jlen, wspace) == -1) {
1255: jstr[eos] = 0;
1256: return -1;
1257: }
1258: for (i = 0; i < array_Size(arr); i++) {
1259: v = array(arr, i, ait_val_t*);
1260: if (v) {
1261: if (AIT_TYPE(v) == string) {
1262: if (json_add_string(jstr, jlen, 0, AIT_GET_STR(v)) == -1) {
1263: jstr[eos] = 0;
1264: return -1;
1265: }
1266: } else {
1267: if (json_add_value(jstr, jlen, 0, AIT_GET_LIKE(v, long)) == -1) {
1268: jstr[eos] = 0;
1269: return -1;
1270: }
1271: }
1272: if (i < array_Size(arr) - 1 && json_add_comma(jstr, jlen, wspace) == -1) {
1273: jstr[eos] = 0;
1274: return -1;
1275: }
1276: }
1277: }
1278: if ((len = json_add_end_array(jstr, jlen, wspace)) == -1) {
1279: jstr[eos] = 0;
1280: return -1;
1281: }
1282:
1283: return len;
1284: }
1285:
1286: /*
1287: * json_dump_yaml() - Dump parsed JSON string to YAML format
1288: *
1289: * @f = Output handler
1290: * @jstr = JSON string
1291: * @toks = JSON tokens
1292: * @toksnum = Number of tokens
1293: * @indent = Start indent spaces
1294: * return: 0 done and 1 added one more item
1295: */
1296: int
1297: json_dump_yaml(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1298: {
1299: register int i, j, k;
1300:
1301: if (!toksnum || !toks)
1302: return 0;
1303:
1304: if (toks->tok_type == J_VALUE) {
1305: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1306: return 1;
1307: } else if (toks->tok_type == J_STRING) {
1308: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1309: return 1;
1310: } else if (toks->tok_type == J_OBJECT) {
1311: fprintf(f, "\n");
1312: for (j = i = 0; i < json_toksize(toks); i++) {
1313: for (k = 0; k < indent; k++)
1314: fprintf(f, " ");
1315: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1316: fprintf(f, ": ");
1317: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1318: fprintf(f, "\n");
1319: }
1320: return j + 1;
1321: } else if (toks->tok_type == J_ARRAY) {
1322: fprintf(f, "\n");
1323: for (j = i = 0; i < json_toksize(toks); i++) {
1324: for (k = 0; k < indent - 1; k++)
1325: fprintf(f, " ");
1326: fprintf(f, " - ");
1327: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1328: fprintf(f, "\n");
1329: }
1330: return j + 1;
1331: }
1332:
1333: return 0;
1334: }
1335:
1336: /*
1337: * json_dump() - Dump parsed JSON string to structure format
1338: *
1339: * @f = Output handler
1340: * @jstr = JSON string
1341: * @toks = JSON tokens
1342: * @toksnum = Number of tokens
1343: * @indent = Start indent spaces
1344: * return: 0 done and 1 added one more item
1345: */
1346: int
1347: json_dump(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1348: {
1349: register int i, j, k;
1350:
1351: if (!toksnum)
1352: return 0;
1353:
1354: if (toks->tok_type == J_VALUE) {
1355: fprintf(f, "[idx=%ld type=VALUE start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1356: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1357: (int) json_toklen(toks), json_tokstr(jstr, toks));
1358: return 1;
1359: } else if (toks->tok_type == J_STRING) {
1360: fprintf(f, "[idx=%ld type=STRING start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1361: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1362: (int) json_toklen(toks), json_tokstr(jstr, toks));
1363: return 1;
1364: } else if (toks->tok_type == J_OBJECT) {
1365: fprintf(f, "\n");
1366: fprintf(f, "object:: [idx=%ld type=OBJECT start=%ld end=%ld size=%ld parent=%ld]\n",
1367: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1368: for (j = i = 0; i < json_toksize(toks); i++) {
1369: for (k = 0; k < indent; k++)
1370: fprintf(f, " ");
1371: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1372: fprintf(f, ": ");
1373: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1374: fprintf(f, "\n");
1375: }
1376: return j + 1;
1377: } else if (toks->tok_type == J_ARRAY) {
1378: fprintf(f, "\n");
1379: fprintf(f, "array[] [idx=%ld type=ARRAY start=%ld end=%ld size=%ld parent=%ld]",
1380: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1381: for (j = i = 0; i < json_toksize(toks); i++) {
1382: for (k = 0; k < indent - 1; k++)
1383: fprintf(f, " ");
1384: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1385: fprintf(f, "\n");
1386: }
1387: return j + 1;
1388: }
1389:
1390: return 0;
1391: }
1392:
1393: /*
1394: * json_objscope() - Find object scope of key
1395: *
1396: * @key = Key of object, if it is =NULL, then return 0 (default scope)
1397: * @jstr = JSON string
1398: * @toks = JSON tokens
1399: * @toksnum = Number of tokens
1400: * return: -1 on error or >=0 scope of object
1401: */
1402: long
1403: json_objscope(const char *key, const char *jstr, jtok_t * __restrict toks, int toksnum)
1404: {
1405: long scope = 0;
1406: register int i;
1407: int klen;
1408:
1409: if (!key)
1410: return 0; /* default scope */
1411:
1412: if (!jstr || !toks)
1413: return -1;
1414: else
1415: klen = strlen(key);
1416:
1417: for (i = 1; i < toksnum; i++)
1418: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
1419: klen == toks[i].tok_end - toks[i].tok_start &&
1420: !strncmp(jstr + toks[i].tok_start, key, klen))
1421: if (toks[i + 1].tok_type == J_OBJECT) {
1422: scope = toks[i + 1].tok_idx;
1423: break;
1424: }
1425:
1426: return scope;
1427: }
1428:
1429: /*
1430: * json_validate() - Validate JSON
1431: *
1432: * @jstr = JSON string
1433: * @started = if started != NULL then here will return start position of found JSON
1434: * return: -1 error or >=0 where valid JSON ends
1435: */
1436: int
1437: json_validate(const char *jstr, int *started)
1438: {
1439: register int o = 0, a = 0, q = 0, pos = 0;
1440:
1441: if (!jstr)
1442: return -1;
1443:
1444: if (started)
1445: *started = 0;
1446:
1447: while (jstr[pos] && jstr[pos] != '{' && jstr[pos] != '[') {
1448: pos++;
1449: if (started)
1450: (*started)++;
1451: }
1452:
1453: do {
1454: switch (jstr[pos++]) {
1455: case '{':
1456: o++;
1457: break;
1458: case '}':
1459: o--;
1460: break;
1461: case '[':
1462: a++;
1463: break;
1464: case ']':
1465: a--;
1466: break;
1467: case '"':
1468: q = ~q;
1469: break;
1470: case '\\':
1471: pos++;
1472: break;
1473: case 0: /* string ends without valid JSON */
1474: if (started)
1475: *started = 0;
1476: return 0;
1477: }
1478: } while (q || a || o);
1479:
1480: return pos;
1481: }
1482:
1483: /*
1484: * json_marshaling() - Prepare JSON to one continues line
1485: *
1486: * @jstr = JSON string
1487: * @space = if it is 0 then spaces will be removed
1488: * return NULL error or !=NULL ready JSON for proceeding
1489: */
1490: char *
1491: json_marshaling(char * __restrict jstr, int space)
1492: {
1493: int started, ended, len;
1494: char *str, *pos, *js;
1495: register int q = 0;
1496:
1497: if (!jstr)
1498: return NULL;
1499: else
1500: js = jstr;
1501:
1502: ended = json_validate(jstr, &started);
1503: if (!ended)
1504: return NULL;
1505: len = ended - started + 1;
1506: str = e_malloc(len);
1507: if (!str)
1508: return NULL;
1509: else {
1510: memset(str, 0, len);
1511: pos = str;
1512: }
1513:
1514: js += started;
1515: while (*js && js < jstr + ended && --len) {
1516: if (*js < 0x20) {
1517: js++;
1518: continue;
1519: }
1520: if (space && !q && *js == 0x20) {
1521: js++;
1522: continue;
1523: }
1524: if (*js == '"')
1525: q = ~q;
1526: *pos++ = *js++;
1527: }
1528: *pos = 0;
1529:
1530: len = strlen(jstr) + 1;
1531: strlcpy(jstr, str, len);
1532: e_free(str);
1533: return jstr;
1534: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to json.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src