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