![[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|
Return to json.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src |
1.1.2.1 misho 1: /*************************************************************************
2: * (C) 2017 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
1.1.2.5 ! misho 6: * $Id: json.c,v 1.1.2.4 2017/11/28 00:46:53 misho Exp $
1.1.2.1 misho 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 - 2017
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:
1.1.2.2 misho 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:
1.1.2.3 misho 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_start = tok->tok_end = tok->tok_parent = -1;
121: tok->tok_size = 0;
122:
123: return tok;
124: }
125:
126: inline void
127: json_filltoken(jtok_t * __restrict tok, jtype_t type, long start, long end, long parent)
128: {
129: assert(tok);
130:
131: tok->tok_type = type;
132: tok->tok_start = start;
133: tok->tok_end = end;
134: tok->tok_parent = parent;
135: tok->tok_size = 0;
136: }
137:
138: static int
139: json_parse_string(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
140: {
141: jtok_t *tok;
142: u_long pos;
143: char ch;
144: register int i;
145:
146: assert(json || jstr || !(!jtoks && toksnum));
147:
148: for (pos = json->h_pos++; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
149: ch = jstr[json->h_pos];
150:
151: if (ch == '\"') {
152: if (!jtoks)
153: return 0;
154: if (!(tok = json_gettoken(json, jtoks, toksnum))) {
155: json->h_pos = pos;
156: return -1;
157: } else
158: json_filltoken(tok, J_STRING, pos + 1, json->h_pos, json->h_parent);
159: return 0;
160: }
161:
162: if (ch == '\\' && json->h_pos + 1 < jlen) {
163: switch (jstr[++json->h_pos]) {
164: case '\"':
165: case '/':
166: case '\\':
167: case 'b':
168: case 'f':
169: case 'r':
170: case 'n':
171: case 't':
172: /* Allowed escaped symbols */
173: break;
174: case 'u':
175: /* Allows escaped symbol \uXXXX */
176: json->h_pos++;
177: for (i = 0; i < 4 && json->h_pos < jlen && jstr[json->h_pos]; i++, json->h_pos++) {
178: /* If it isn't a hex character we have an error */
179: if (!((jstr[json->h_pos] >= 48 && jstr[json->h_pos] <= 57) || /* 0-9 */
180: (jstr[json->h_pos] >= 65 && jstr[json->h_pos] <= 70) || /* A-F */
181: (jstr[json->h_pos] >= 97 && jstr[json->h_pos] <= 102))) { /* a-f */
182: json->h_pos = pos;
183: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
184: return -1;
185: }
186: }
187: json->h_pos--;
188: break;
189: default:
190: /* Unexpected symbol */
191: json->h_pos = pos;
192: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
193: return -1;
194: }
195: }
196: }
197:
198: json->h_pos = pos;
199: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
200: return -1;
201: }
202:
203: static int
204: json_parse_value(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
205: {
206: jtok_t *tok;
207: u_long pos;
208:
209: assert(json || jstr || !(!jtoks && toksnum));
210:
211: for (pos = json->h_pos; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
212: switch (jstr[json->h_pos]) {
213: case ':':
214: if (json->h_strict)
215: goto found;
216: break;
217: case '\t':
218: case '\r':
219: case '\n':
220: case ' ':
221: case ',':
222: case ']':
223: case '}':
224: goto found;
225: }
226: if (jstr[json->h_pos] < 32 || jstr[json->h_pos] > 127) {
227: json->h_pos = pos;
228: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
229: return -1;
230: }
231: }
232:
233: if (json->h_strict) {
234: json->h_pos = pos;
235: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
236: return -1;
237: }
238: found:
239: if (jtoks) {
240: if (!(tok = json_gettoken(json, jtoks, toksnum))) {
241: json->h_pos = pos;
242: return -1;
243: } else
244: json_filltoken(tok, J_VALUE, pos, json->h_pos, json->h_parent);
245: }
246:
247: json->h_pos--;
248: return 0;
249: }
250:
1.1.2.2 misho 251: /*
252: * json_parse() - Parse JSON string
253: *
254: * @json = JSON handler
255: * @jstr = JSON string
256: * @jlen = JSON string length
257: * @jtoks = Token array
258: * @toksnum = Token array size, return number of allocated tokens in array
259: * return: -1 error or number of found tokens
260: */
261: u_int
262: json_parse(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
263: {
264: register int i;
265: register u_int cx;
266: jtype_t type;
267: jtok_t *tok;
268: char ch;
269:
270: if (!json || !jstr || (!jtoks && toksnum)) {
271: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
272: return (u_int) -1;
273: }
274:
275: for (cx = json->h_next; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
276: switch ((ch = jstr[json->h_pos])) {
277: case '{':
278: case '[':
279: cx++; /* start new token */
280: if (!jtoks)
281: break;
282:
283: tok = json_gettoken(json, jtoks, toksnum);
1.1.2.3 misho 284: if (!tok)
1.1.2.2 misho 285: return (u_int) -1;
286: if (json->h_parent != -1) {
287: jtoks[json->h_parent].tok_size++;
288: tok->tok_parent = json->h_parent;
289: }
290: tok->tok_type = (ch == '{' ? J_OBJECT : J_ARRAY);
291: tok->tok_start = json->h_pos;
292: json->h_parent = json->h_next - 1;
293: break;
294: case '}':
295: case ']':
296: if (!jtoks)
297: break;
298:
299: if (json->h_next < 1) {
300: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
301: return (u_int) -1;
302: }
303:
304: type = (ch == '}' ? J_OBJECT : J_ARRAY);
305: tok = &jtoks[json->h_next - 1];
306: while (42) {
307: if (tok->tok_start != -1 && tok->tok_end == -1) {
308: if (tok->tok_type != type) {
309: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
310: return (u_int) -1;
311: }
312: tok->tok_end = json->h_pos + 1;
313: json->h_parent = tok->tok_parent;
314: break;
315: }
316: if (tok->tok_parent == -1) {
317: if (tok->tok_type != type || json->h_parent == -1) {
318: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
319: return (u_int) -1;
320: }
321: break;
322: }
323: tok = &jtoks[tok->tok_parent];
324: }
325: break;
326: case '\"':
327: if (json_parse_string(json, jstr, jlen, jtoks, toksnum) == -1) {
328: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
329: return (u_int) -1;
330: }
331: cx++;
332: if (jtoks && json->h_parent != -1)
333: jtoks[json->h_parent].tok_size++;
334: break;
335: case '\t':
336: case '\r':
337: case '\n':
338: case ' ':
339: /* whitespace, skip */
340: break;
341: case ':':
342: json->h_parent = json->h_next - 1;
343: break;
344: case ',':
345: if (jtoks && json->h_parent != -1 &&
346: jtoks[json->h_parent].tok_type != J_OBJECT &&
347: jtoks[json->h_parent].tok_type != J_ARRAY)
348: json->h_parent = jtoks[json->h_parent].tok_parent;
349: break;
350: case '-':
351: case '0':
352: case '1':
353: case '2':
354: case '3':
355: case '4':
356: case '5':
357: case '6':
358: case '7':
359: case '8':
360: case '9':
361: case 't':
362: case 'f':
363: case 'n':
1.1.2.3 misho 364: if (json->h_strict) {
365: if (jtoks && json->h_parent != -1) {
366: /* they must not be keys of the object */
367: if (jtoks[json->h_parent].tok_type == J_OBJECT ||
368: (jtoks[json->h_parent].tok_type == J_STRING &&
369: jtoks[json->h_parent].tok_size)) {
370: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
371: return (u_int) -1;
372: }
373: }
1.1.2.2 misho 374:
1.1.2.3 misho 375: if (json_parse_value(json, jstr, jlen, jtoks, toksnum) == -1)
1.1.2.2 misho 376: return (u_int) -1;
1.1.2.3 misho 377: cx++;
378: if (jtoks && json->h_parent != -1)
379: jtoks[json->h_parent].tok_size++;
380: break;
1.1.2.2 misho 381: }
382: default:
383: if (json->h_strict) {
384: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
385: return (u_int) -1;
386: }
387:
388: if (json_parse_value(json, jstr, jlen, jtoks, toksnum) == -1)
389: return (u_int) -1;
390: cx++;
391: if (jtoks && json->h_parent != -1)
392: jtoks[json->h_parent].tok_size++;
393: break;
394: }
395: }
396:
397: if (jtoks) {
398: for (i = json->h_next - 1; i >= 0; i--) {
399: /* unmatched opened object or array */
400: if (jtoks[i].tok_start != -1 && jtoks[i].tok_end == -1) {
401: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
402: return (u_int) -1;
403: }
404: }
405: }
406:
407: return cx;
1.1.2.4 misho 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, tok->tok_end - tok->tok_start);
430: strncpy(AIT_GET_STR(v), jstr + tok->tok_start, AIT_LEN(v) - 1);
431:
432: return v;
433: }
434:
435: /*
436: * json_token2str() - Return token to string
437: *
438: * @jstr = JSON string
439: * @tok = Token for convert
440: * @return =NULL error or !=NULL allocated str, after use should be e_free()
441: */
442: char *
443: json_token2str(const char *jstr, jtok_t * __restrict tok)
444: {
445: char *str = NULL;
446: size_t len;
447:
448: if (!jstr || !tok)
449: return NULL;
450:
451: len = tok->tok_end - tok->tok_start;
452: str = e_malloc(len + 1);
453: if (!str)
454: return NULL;
455: else {
456: strncpy(str, jstr + tok->tok_start, len);
457: str[len] = 0;
458: }
459:
460: return str;
461: }
462:
463: /*
464: * json_token2num() - Return token to numeric
465: *
466: * @jstr = JSON string
467: * @tok = Token for convert
468: * @return number
469: */
470: long
471: json_token2num(const char *jstr, jtok_t * __restrict tok)
472: {
473: long ret = 0;
474: char *str;
475:
476: str = json_token2str(jstr, tok);
477: if (!str)
478: return 0;
479:
480: ret = strtol(str, NULL, 0);
481: e_free(str);
482: return ret;
483: }
484:
485: /*
486: * json_findbykey() - Find data by key
487: *
488: * @jstr = JSON string
489: * @key = Search key
490: * @toks = Parsed tokens
491: * @toksnum = Number of parsed tokens
492: * return: =NULL error or !=NULL data token found
493: */
494: jtok_t *
495: json_findbykey(const char *jstr, const char *key, jtok_t * __restrict toks, int toksnum)
496: {
497: jtok_t *tok = NULL;
498: register int i;
499: int klen;
500:
501: if (!jstr || !key || !toks)
502: return NULL;
503: else
504: klen = strlen(key);
505:
506: for (i = 1; i < toksnum; i++) {
507: if (toks[i].tok_type == J_STRING &&
508: klen == toks[i].tok_end - toks[i].tok_start &&
509: !strncmp(jstr + toks[i].tok_start, key, klen)) {
510: tok = toks + i + 1;
511: break;
512: }
513: }
514:
515: return tok;
516: }
517:
518: /*
519: * json_token2array() - Convert token to array
520: *
521: * @jstr = JSON string
522: * @tok = Token for convert
523: * return: =NULL error or !=NULL allocated array with variables,
524: * after use should be ait_freeVars()
525: */
526: array_t *
527: json_token2array(const char *jstr, jtok_t * __restrict tok)
528: {
529: array_t *arr = NULL;
530: register int i;
531: int siz;
532: ait_val_t *v;
533: jtok_t *t;
534:
535: if (!jstr || !tok)
536: return NULL;
537:
538: siz = tok->tok_size;
1.1.2.5 ! misho 539: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
1.1.2.4 misho 540: siz++;
541:
542: arr = ait_allocVars(siz);
543: if (!arr)
544: return NULL;
545:
546: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
547: v = ait_getVars(&arr, 0);
1.1.2.5 ! misho 548: AIT_SET_STRSIZ(v, json_toklen(tok));
! 549: json_tokstrcpy(AIT_GET_STR(v), jstr, tok);
1.1.2.4 misho 550: } else if (tok->tok_type == J_ARRAY) {
551: for (i = 0; i < tok->tok_size; i++) {
552: t = &tok[i + 1];
553: v = ait_getVars(&arr, i);
1.1.2.5 ! misho 554: AIT_SET_STRSIZ(v, json_toklen(t));
! 555: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
1.1.2.4 misho 556: }
557: } else {
558: /* todo for object */
559: }
560:
561: return arr;
1.1.2.2 misho 562: }