blobmsg_json: avoid redefinition of json_object
[project/libubox.git] / json_script.c
1 /*
2  * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 #include <sys/stat.h>
17 #include <regex.h>
18
19 #include "avl-cmp.h"
20 #include "json_script.h"
21
22 struct json_call {
23         struct json_script_ctx *ctx;
24         struct blob_attr *vars;
25         unsigned int seq;
26 };
27
28 struct json_handler {
29         const char *name;
30         int (*cb)(struct json_call *call, struct blob_attr *cur);
31 };
32
33 static int json_process_expr(struct json_call *call, struct blob_attr *cur);
34 static int json_process_cmd(struct json_call *call, struct blob_attr *cur);
35
36 struct json_script_file *
37 json_script_file_from_blobmsg(const char *name, void *data, int len)
38 {
39         struct json_script_file *f;
40         char *new_name;
41         int name_len = 0;
42
43         if (name)
44                 name_len = strlen(name) + 1;
45
46         f = calloc_a(sizeof(*f) + len, &new_name, name_len);
47         memcpy(f->data, data, len);
48         if (name)
49                 f->avl.key = strcpy(new_name, name);
50
51         return f;
52 }
53
54 static struct json_script_file *
55 json_script_get_file(struct json_script_ctx *ctx, const char *filename)
56 {
57         struct json_script_file *f;
58
59         f = avl_find_element(&ctx->files, filename, f, avl);
60         if (f)
61                 return f;
62
63         f = ctx->handle_file(ctx, filename);
64         if (!f)
65                 return NULL;
66
67         avl_insert(&ctx->files, &f->avl);
68         return f;
69 }
70
71 static void __json_script_run(struct json_call *call, struct json_script_file *file,
72                               struct blob_attr *context)
73 {
74         struct json_script_ctx *ctx = call->ctx;
75
76         if (file->seq == call->seq) {
77                 if (context)
78                         ctx->handle_error(ctx, "Recursive include", context);
79
80                 return;
81         }
82
83         file->seq = call->seq;
84         while (file) {
85                 json_process_cmd(call, file->data);
86                 file = file->next;
87         }
88 }
89
90 const char *json_script_find_var(struct json_script_ctx *ctx, struct blob_attr *vars,
91                                  const char *name)
92 {
93         struct blob_attr *cur;
94         int rem;
95
96         blobmsg_for_each_attr(cur, vars, rem) {
97                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
98                         continue;
99
100                 if (strcmp(blobmsg_name(cur), name) != 0)
101                         continue;
102
103                 return blobmsg_data(cur);
104         }
105
106         return ctx->handle_var(ctx, name, vars);
107 }
108
109 static const char *
110 msg_find_var(struct json_call *call, const char *name)
111 {
112         return json_script_find_var(call->ctx, call->vars, name);
113 }
114
115 static void
116 json_get_tuple(struct blob_attr *cur, struct blob_attr **tb, int t1, int t2)
117 {
118         static struct blobmsg_policy expr_tuple[3] = {
119                 { .type = BLOBMSG_TYPE_STRING },
120                 {},
121                 {},
122         };
123
124         expr_tuple[1].type = t1;
125         expr_tuple[2].type = t2;
126         blobmsg_parse_array(expr_tuple, 3, tb, blobmsg_data(cur), blobmsg_data_len(cur));
127 }
128
129 static int handle_if(struct json_call *call, struct blob_attr *expr)
130 {
131         struct blob_attr *tb[4];
132         int ret;
133
134         static const struct blobmsg_policy if_tuple[4] = {
135                 { .type = BLOBMSG_TYPE_STRING },
136                 { .type = BLOBMSG_TYPE_ARRAY },
137                 { .type = BLOBMSG_TYPE_ARRAY },
138                 { .type = BLOBMSG_TYPE_ARRAY },
139         };
140
141         blobmsg_parse_array(if_tuple, 4, tb, blobmsg_data(expr), blobmsg_data_len(expr));
142
143         if (!tb[1] || !tb[2])
144                 return 0;
145
146         ret = json_process_expr(call, tb[1]);
147         if (ret < 0)
148                 return 0;
149
150         if (ret)
151                 return json_process_cmd(call, tb[2]);
152
153         if (!tb[3])
154                 return 0;
155
156         return json_process_cmd(call, tb[3]);
157 }
158
159 static int handle_case(struct json_call *call, struct blob_attr *expr)
160 {
161         struct blob_attr *tb[3], *cur;
162         const char *var;
163         int rem;
164
165         json_get_tuple(expr, tb, BLOBMSG_TYPE_STRING, BLOBMSG_TYPE_TABLE);
166         if (!tb[1] || !tb[2])
167                 return 0;
168
169         var = msg_find_var(call, blobmsg_data(tb[1]));
170         if (!var)
171                 return 0;
172
173         blobmsg_for_each_attr(cur, tb[2], rem) {
174                 if (!strcmp(var, blobmsg_name(cur)))
175                         return json_process_cmd(call, cur);
176         }
177
178         return 0;
179 }
180
181 static int handle_return(struct json_call *call, struct blob_attr *expr)
182 {
183         return -2;
184 }
185
186 static int handle_include(struct json_call *call, struct blob_attr *expr)
187 {
188         struct blob_attr *tb[3];
189         struct json_script_file *f;
190
191         json_get_tuple(expr, tb, BLOBMSG_TYPE_STRING, 0);
192         if (!tb[1])
193                 return 0;
194
195         f = json_script_get_file(call->ctx, blobmsg_data(tb[1]));
196         if (!f)
197                 return 0;
198
199         __json_script_run(call, f, expr);
200         return 0;
201 }
202
203 static const struct json_handler cmd[] = {
204         { "if", handle_if },
205         { "case", handle_case },
206         { "return", handle_return },
207         { "include", handle_include },
208 };
209
210 static int eq_regex_cmp(const char *str, const char *pattern, bool regex)
211 {
212         regex_t reg;
213         int ret;
214
215         if (!regex)
216                 return !strcmp(str, pattern);
217
218         if (regcomp(&reg, pattern, REG_EXTENDED | REG_NOSUB))
219                 return 0;
220
221         ret = !regexec(&reg, str, 0, NULL, 0);
222         regfree(&reg);
223
224         return ret;
225 }
226
227 static int expr_eq_regex(struct json_call *call, struct blob_attr *expr, bool regex)
228 {
229         struct json_script_ctx *ctx = call->ctx;
230         struct blob_attr *tb[3], *cur;
231         const char *var;
232         int rem;
233
234         json_get_tuple(expr, tb, BLOBMSG_TYPE_STRING, 0);
235         if (!tb[1] || !tb[2])
236                 return -1;
237
238         var = msg_find_var(call, blobmsg_data(tb[1]));
239         if (!var)
240                 return 0;
241
242         switch(blobmsg_type(tb[2])) {
243         case BLOBMSG_TYPE_STRING:
244                 return eq_regex_cmp(var, blobmsg_data(tb[2]), regex);
245         case BLOBMSG_TYPE_ARRAY:
246                 blobmsg_for_each_attr(cur, tb[2], rem) {
247                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) {
248                                 ctx->handle_error(ctx, "Unexpected element type", cur);
249                                 return -1;
250                         }
251
252                         if (eq_regex_cmp(var, blobmsg_data(cur), regex))
253                                 return 1;
254                 }
255                 return 0;
256         default:
257                 ctx->handle_error(ctx, "Unexpected element type", tb[2]);
258                 return -1;
259         }
260 }
261
262 static int handle_expr_eq(struct json_call *call, struct blob_attr *expr)
263 {
264         return expr_eq_regex(call, expr, false);
265 }
266
267 static int handle_expr_regex(struct json_call *call, struct blob_attr *expr)
268 {
269         return expr_eq_regex(call, expr, true);
270 }
271
272 static int handle_expr_has(struct json_call *call, struct blob_attr *expr)
273 {
274         struct json_script_ctx *ctx = call->ctx;
275         struct blob_attr *tb[3], *cur;
276         int rem;
277
278         json_get_tuple(expr, tb, 0, 0);
279         if (!tb[1])
280                 return -1;
281
282         switch(blobmsg_type(tb[1])) {
283         case BLOBMSG_TYPE_STRING:
284                 return !!msg_find_var(call, blobmsg_data(tb[1]));
285         case BLOBMSG_TYPE_ARRAY:
286                 blobmsg_for_each_attr(cur, tb[1], rem) {
287                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) {
288                                 ctx->handle_error(ctx, "Unexpected element type", cur);
289                                 return -1;
290                         }
291
292                         if (msg_find_var(call, blobmsg_data(cur)))
293                                 return 1;
294                 }
295                 return 0;
296         default:
297                 ctx->handle_error(ctx, "Unexpected element type", tb[1]);
298                 return -1;
299         }
300 }
301
302 static int expr_and_or(struct json_call *call, struct blob_attr *expr, bool and)
303 {
304         struct blob_attr *cur;
305         int ret, rem;
306         int i = 0;
307
308         blobmsg_for_each_attr(cur, expr, rem) {
309                 if (i++ < 1)
310                         continue;
311
312                 ret = json_process_expr(call, cur);
313                 if (ret < 0)
314                         return ret;
315
316                 if (ret != and)
317                         return ret;
318         }
319
320         return and;
321 }
322
323 static int handle_expr_and(struct json_call *call, struct blob_attr *expr)
324 {
325         return expr_and_or(call, expr, 1);
326 }
327
328 static int handle_expr_or(struct json_call *call, struct blob_attr *expr)
329 {
330         return expr_and_or(call, expr, 0);
331 }
332
333 static int handle_expr_not(struct json_call *call, struct blob_attr *expr)
334 {
335         struct blob_attr *tb[3];
336
337         json_get_tuple(expr, tb, BLOBMSG_TYPE_ARRAY, 0);
338         if (!tb[1])
339                 return -1;
340
341         return json_process_expr(call, tb[1]);
342 }
343
344 static const struct json_handler expr[] = {
345         { "eq", handle_expr_eq },
346         { "regex", handle_expr_regex },
347         { "has", handle_expr_has },
348         { "and", handle_expr_and },
349         { "or", handle_expr_or },
350         { "not", handle_expr_not },
351 };
352
353 static int
354 __json_process_type(struct json_call *call, struct blob_attr *cur,
355                     const struct json_handler *h, int n, bool *found)
356 {
357         const char *name = blobmsg_data(blobmsg_data(cur));
358         int i;
359
360         for (i = 0; i < n; i++) {
361                 if (strcmp(name, h[i].name) != 0)
362                         continue;
363
364                 *found = true;
365                 return h[i].cb(call, cur);
366         }
367
368         *found = false;
369         return -1;
370 }
371
372 static int json_process_expr(struct json_call *call, struct blob_attr *cur)
373 {
374         struct json_script_ctx *ctx = call->ctx;
375         bool found;
376         int ret;
377
378         if (blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY ||
379             blobmsg_type(blobmsg_data(cur)) != BLOBMSG_TYPE_STRING) {
380                 ctx->handle_error(ctx, "Unexpected element type", cur);
381                 return -1;
382         }
383
384         ret = __json_process_type(call, cur, expr, ARRAY_SIZE(expr), &found);
385         if (!found)
386                 ctx->handle_error(ctx, "Unknown expression type", cur);
387
388         return ret;
389 }
390
391 static int eval_string(struct json_call *call, struct blob_buf *buf, const char *name, const char *pattern)
392 {
393         char *dest, *next, *str;
394         int len = 0;
395         bool var = false;
396         char c = '%';
397
398         dest = blobmsg_alloc_string_buffer(buf, name, 1);
399         next = alloca(strlen(pattern) + 1);
400         strcpy(next, pattern);
401
402         for (str = next; str; str = next) {
403                 const char *cur;
404                 char *end;
405                 int cur_len = 0;
406                 bool cur_var = var;
407
408                 end = strchr(str, '%');
409                 if (end) {
410                         *end = 0;
411                         next = end + 1;
412                         var = !var;
413                 } else {
414                         end = str + strlen(str);
415                         next = NULL;
416                 }
417
418                 if (cur_var) {
419                         if (next > str) {
420                                 cur = msg_find_var(call, str);
421                                 if (!cur)
422                                         continue;
423
424                                 cur_len = strlen(cur);
425                         } else {
426                                 cur = &c;
427                                 cur_len = 1;
428                         }
429                 } else {
430                         if (str == end)
431                                 continue;
432
433                         cur = str;
434                         cur_len = end - str;
435                 }
436
437                 dest = blobmsg_realloc_string_buffer(buf, cur_len + 1);
438                 memcpy(dest + len, cur, cur_len);
439                 len += cur_len;
440         }
441
442         dest[len] = 0;
443         blobmsg_add_string_buffer(buf);
444
445         if (var)
446                 return -1;
447
448         return 0;
449 }
450
451 static int cmd_add_string(struct json_call *call, const char *pattern)
452 {
453         return eval_string(call, &call->ctx->buf, NULL, pattern);
454 }
455
456 int json_script_eval_string(struct json_script_ctx *ctx, struct blob_attr *vars,
457                             struct blob_buf *buf, const char *name,
458                             const char *pattern)
459 {
460         struct json_call call = {
461                 .ctx = ctx,
462                 .vars = vars,
463         };
464
465         return eval_string(&call, buf, name, pattern);
466 }
467
468 static int cmd_process_strings(struct json_call *call, struct blob_attr *attr)
469 {
470         struct json_script_ctx *ctx = call->ctx;
471         struct blob_attr *cur;
472         int args = -1;
473         int rem, ret;
474         void *c;
475
476         blob_buf_init(&ctx->buf, 0);
477         c = blobmsg_open_array(&ctx->buf, NULL);
478         blobmsg_for_each_attr(cur, attr, rem) {
479                 if (args++ < 0)
480                         continue;
481
482                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) {
483                         ctx->handle_error(ctx, "Invalid argument in command", attr);
484                         return -1;
485                 }
486
487                 ret = cmd_add_string(call, blobmsg_data(cur));
488                 if (ret) {
489                         ctx->handle_error(ctx, "Unterminated variable reference in string", attr);
490                         return ret;
491                 }
492         }
493
494         blobmsg_close_array(&ctx->buf, c);
495
496         return 0;
497 }
498
499 static int __json_process_cmd(struct json_call *call, struct blob_attr *cur)
500 {
501         struct json_script_ctx *ctx = call->ctx;
502         const char *name;
503         bool found;
504         int ret;
505
506         if (blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY ||
507             blobmsg_type(blobmsg_data(cur)) != BLOBMSG_TYPE_STRING) {
508                 ctx->handle_error(ctx, "Unexpected element type", cur);
509                 return -1;
510         }
511
512         ret = __json_process_type(call, cur, cmd, ARRAY_SIZE(cmd), &found);
513         if (found)
514                 return ret;
515
516         name = blobmsg_data(blobmsg_data(cur));
517         ret = cmd_process_strings(call, cur);
518         if (ret)
519                 return ret;
520
521         ctx->handle_command(ctx, name, blob_data(ctx->buf.head), call->vars);
522
523         return 0;
524 }
525
526 static int json_process_cmd(struct json_call *call, struct blob_attr *block)
527 {
528         struct json_script_ctx *ctx = call->ctx;
529         struct blob_attr *cur;
530         int rem;
531         int ret;
532         int i = 0;
533
534         if (blobmsg_type(block) != BLOBMSG_TYPE_ARRAY) {
535                 ctx->handle_error(ctx, "Unexpected element type", block);
536                 return -1;
537         }
538
539         blobmsg_for_each_attr(cur, block, rem) {
540                 switch(blobmsg_type(cur)) {
541                 case BLOBMSG_TYPE_STRING:
542                         if (!i)
543                                 return __json_process_cmd(call, block);
544                 default:
545                         ret = json_process_cmd(call, cur);
546                         if (ret < -1)
547                                 return ret;
548                         break;
549                 }
550                 i++;
551         }
552
553         return 0;
554 }
555
556 void json_script_run_file(struct json_script_ctx *ctx, struct json_script_file *file,
557                           struct blob_attr *vars)
558 {
559         static unsigned int _seq = 0;
560         struct json_call call = {
561                 .ctx = ctx,
562                 .vars = vars,
563                 .seq = ++_seq,
564         };
565
566         /* overflow */
567         if (!call.seq)
568                 call.seq = ++_seq;
569
570         __json_script_run(&call, file, NULL);
571 }
572
573 void json_script_run(struct json_script_ctx *ctx, const char *name,
574                      struct blob_attr *vars)
575 {
576         struct json_script_file *file;
577
578         file = json_script_get_file(ctx, name);
579         if (!file)
580                 return;
581
582         json_script_run_file(ctx, file, vars);
583 }
584
585 static void __json_script_file_free(struct json_script_file *f)
586 {
587         struct json_script_file *next;
588
589         if (!f)
590                 return;
591
592         next = f->next;
593         free(f);
594
595         if (next)
596                 return __json_script_file_free(next);
597 }
598
599 void
600 json_script_free(struct json_script_ctx *ctx)
601 {
602         struct json_script_file *f, *next;
603
604         avl_remove_all_elements(&ctx->files, f, avl, next)
605                 __json_script_file_free(f);
606
607         blob_buf_free(&ctx->buf);
608 }
609
610 static void
611 __default_handle_error(struct json_script_ctx *ctx, const char *msg,
612                        struct blob_attr *context)
613 {
614 }
615
616 static const char *
617 __default_handle_var(struct json_script_ctx *ctx, const char *name,
618                      struct blob_attr *vars)
619 {
620         return NULL;
621 }
622
623 static int
624 __default_handle_expr(struct json_script_ctx *ctx, const char *name,
625                       struct blob_attr *expr, struct blob_attr *vars)
626 {
627         return -1;
628 }
629
630 static struct json_script_file *
631 __default_handle_file(struct json_script_ctx *ctx, const char *name)
632 {
633         return NULL;
634 }
635
636 void json_script_init(struct json_script_ctx *ctx)
637 {
638         avl_init(&ctx->files, avl_strcmp, false, NULL);
639
640         if (!ctx->handle_error)
641                 ctx->handle_error = __default_handle_error;
642
643         if (!ctx->handle_var)
644                 ctx->handle_var = __default_handle_var;
645
646         if (!ctx->handle_expr)
647                 ctx->handle_expr = __default_handle_expr;
648
649         if (!ctx->handle_file)
650                 ctx->handle_file = __default_handle_file;
651 }