Debian Codegraph @

src/decrypters/widevine/jsmn.c

raw
1 /*
2 * Copyright (C) 2017 peak3d (http://www.peak3d.de)
3 * This file is part of Kodi - https://kodi.tv
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later
6 * See LICENSES/README.md for more information.
7 */
8
9 #include "jsmn.h"
10
11 /**
12 * Allocates a fresh unused token from the token pull.
13 */
14 static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
15 jsmntok_t *tokens, size_t num_tokens) {
16 jsmntok_t *tok;
17 if (parser->toknext >= num_tokens) {
18 return NULL;
19 }
20 tok = &tokens[parser->toknext++];
21 tok->start = tok->end = -1;
22 tok->size = 0;
23 #ifdef JSMN_PARENT_LINKS
24 tok->parent = -1;
25 #endif
26 return tok;
27 }
28
29 /**
30 * Fills token type and boundaries.
31 */
32 static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
33 int start, int end) {
34 token->type = type;
35 token->start = start;
36 token->end = end;
37 token->size = 0;
38 }
39
40 /**
41 * Fills next available token with JSON primitive.
42 */
43 static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
44 size_t len, jsmntok_t *tokens, size_t num_tokens) {
45 jsmntok_t *token;
46 int start;
47
48 start = parser->pos;
49
50 for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
51 switch (js[parser->pos]) {
52 #ifndef JSMN_STRICT
53 /* In strict mode primitive must be followed by "," or "}" or "]" */
54 case ':':
55 #endif
56 case '\t' : case '\r' : case '\n' : case ' ' :
57 case ',' : case ']' : case '}' :
58 goto found;
59 }
60 if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
61 parser->pos = start;
62 return JSMN_ERROR_INVAL;
63 }
64 }
65 #ifdef JSMN_STRICT
66 /* In strict mode primitive must be followed by a comma/object/array */
67 parser->pos = start;
68 return JSMN_ERROR_PART;
69 #endif
70
71 found:
72 if (tokens == NULL) {
73 parser->pos--;
74 return 0;
75 }
76 token = jsmn_alloc_token(parser, tokens, num_tokens);
77 if (token == NULL) {
78 parser->pos = start;
79 return JSMN_ERROR_NOMEM;
80 }
81 jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
82 #ifdef JSMN_PARENT_LINKS
83 token->parent = parser->toksuper;
84 #endif
85 parser->pos--;
86 return 0;
87 }
88
89 /**
90 * Fills next token with JSON string.
91 */
92 static int jsmn_parse_string(jsmn_parser *parser, const char *js,
93 size_t len, jsmntok_t *tokens, size_t num_tokens) {
94 jsmntok_t *token;
95
96 int start = parser->pos;
97
98 parser->pos++;
99
100 /* Skip starting quote */
101 for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
102 char c = js[parser->pos];
103
104 /* Quote: end of string */
105 if (c == '\"') {
106 if (tokens == NULL) {
107 return 0;
108 }
109 token = jsmn_alloc_token(parser, tokens, num_tokens);
110 if (token == NULL) {
111 parser->pos = start;
112 return JSMN_ERROR_NOMEM;
113 }
114 jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
115 #ifdef JSMN_PARENT_LINKS
116 token->parent = parser->toksuper;
117 #endif
118 return 0;
119 }
120
121 /* Backslash: Quoted symbol expected */
122 if (c == '\\' && parser->pos + 1 < len) {
123 int i;
124 parser->pos++;
125 switch (js[parser->pos]) {
126 /* Allowed escaped symbols */
127 case '\"': case '/' : case '\\' : case 'b' :
128 case 'f' : case 'r' : case 'n' : case 't' :
129 break;
130 /* Allows escaped symbol \uXXXX */
131 case 'u':
132 parser->pos++;
133 for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
134 /* If it isn't a hex character we have an error */
135 if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
136 (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
137 (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
138 parser->pos = start;
139 return JSMN_ERROR_INVAL;
140 }
141 parser->pos++;
142 }
143 parser->pos--;
144 break;
145 /* Unexpected symbol */
146 default:
147 parser->pos = start;
148 return JSMN_ERROR_INVAL;
149 }
150 }
151 }
152 parser->pos = start;
153 return JSMN_ERROR_PART;
154 }
155
156 /**
157 * Parse JSON string and fill tokens.
158 */
159 int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
160 jsmntok_t *tokens, unsigned int num_tokens) {
161 int r;
162 int i;
163 jsmntok_t *token;
164 int count = parser->toknext;
165
166 for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
167 char c;
168 jsmntype_t type;
169
170 c = js[parser->pos];
171 switch (c) {
172 case '{': case '[':
173 count++;
174 if (tokens == NULL) {
175 break;
176 }
177 token = jsmn_alloc_token(parser, tokens, num_tokens);
178 if (token == NULL)
179 return JSMN_ERROR_NOMEM;
180 if (parser->toksuper != -1) {
181 tokens[parser->toksuper].size++;
182 #ifdef JSMN_PARENT_LINKS
183 token->parent = parser->toksuper;
184 #endif
185 }
186 token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
187 token->start = parser->pos;
188 parser->toksuper = parser->toknext - 1;
189 break;
190 case '}': case ']':
191 if (tokens == NULL)
192 break;
193 type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
194 #ifdef JSMN_PARENT_LINKS
195 if (parser->toknext < 1) {
196 return JSMN_ERROR_INVAL;
197 }
198 token = &tokens[parser->toknext - 1];
199 for (;;) {
200 if (token->start != -1 && token->end == -1) {
201 if (token->type != type) {
202 return JSMN_ERROR_INVAL;
203 }
204 token->end = parser->pos + 1;
205 parser->toksuper = token->parent;
206 break;
207 }
208 if (token->parent == -1) {
209 break;
210 }
211 token = &tokens[token->parent];
212 }
213 #else
214 for (i = parser->toknext - 1; i >= 0; i--) {
215 token = &tokens[i];
216 if (token->start != -1 && token->end == -1) {
217 if (token->type != type) {
218 return JSMN_ERROR_INVAL;
219 }
220 parser->toksuper = -1;
221 token->end = parser->pos + 1;
222 break;
223 }
224 }
225 /* Error if unmatched closing bracket */
226 if (i == -1) return JSMN_ERROR_INVAL;
227 for (; i >= 0; i--) {
228 token = &tokens[i];
229 if (token->start != -1 && token->end == -1) {
230 parser->toksuper = i;
231 break;
232 }
233 }
234 #endif
235 break;
236 case '\"':
237 r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
238 if (r < 0) return r;
239 count++;
240 if (parser->toksuper != -1 && tokens != NULL)
241 tokens[parser->toksuper].size++;
242 break;
243 case '\t' : case '\r' : case '\n' : case ' ':
244 break;
245 case ':':
246 parser->toksuper = parser->toknext - 1;
247 break;
248 case ',':
249 if (tokens != NULL && parser->toksuper != -1 &&
250 tokens[parser->toksuper].type != JSMN_ARRAY &&
251 tokens[parser->toksuper].type != JSMN_OBJECT) {
252 #ifdef JSMN_PARENT_LINKS
253 parser->toksuper = tokens[parser->toksuper].parent;
254 #else
255 for (i = parser->toknext - 1; i >= 0; i--) {
256 if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
257 if (tokens[i].start != -1 && tokens[i].end == -1) {
258 parser->toksuper = i;
259 break;
260 }
261 }
262 }
263 #endif
264 }
265 break;
266 #ifdef JSMN_STRICT
267 /* In strict mode primitives are: numbers and booleans */
268 case '-': case '0': case '1' : case '2': case '3' : case '4':
269 case '5': case '6': case '7' : case '8': case '9':
270 case 't': case 'f': case 'n' :
271 /* And they must not be keys of the object */
272 if (tokens != NULL && parser->toksuper != -1) {
273 jsmntok_t *t = &tokens[parser->toksuper];
274 if (t->type == JSMN_OBJECT ||
275 (t->type == JSMN_STRING && t->size != 0)) {
276 return JSMN_ERROR_INVAL;
277 }
278 }
279 #else
280 /* In non-strict mode every unquoted value is a primitive */
281 default:
282 #endif
283 r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
284 if (r < 0) return r;
285 count++;
286 if (parser->toksuper != -1 && tokens != NULL)
287 tokens[parser->toksuper].size++;
288 break;
289
290 #ifdef JSMN_STRICT
291 /* Unexpected char in strict mode */
292 default:
293 return JSMN_ERROR_INVAL;
294 #endif
295 }
296 }
297
298 if (tokens != NULL) {
299 for (i = parser->toknext - 1; i >= 0; i--) {
300 /* Unmatched opened object or array */
301 if (tokens[i].start != -1 && tokens[i].end == -1) {
302 return JSMN_ERROR_PART;
303 }
304 }
305 }
306
307 return count;
308 }
309
310 /**
311 * Creates a new parser based over a given buffer with an array of tokens
312 * available.
313 */
314 void jsmn_init(jsmn_parser *parser) {
315 parser->pos = 0;
316 parser->toknext = 0;
317 parser->toksuper = -1;
318 }
319