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                 ctx->handle_error(ctx, "Unknown expression type", cur);
 420
 421         return ret;
 422 }
 423
 424 static int eval_string(struct json_call *call, struct blob_buf *buf, const char *name, const char *pattern)
 425 {
 426         char *dest, *next, *str;
 427         int len = 0;
 428         bool var = false;
 429         char c = '%';
 430
 431         dest = blobmsg_alloc_string_buffer(buf, name, 1);
 432         if (!dest)
 433                 return -1;
 434
 435         next = alloca(strlen(pattern) + 1);
 436         strcpy(next, pattern);
 437
 438         for (str = next; str; str = next) {
 439                 const char *cur;
 440                 char *end, *new_buf;
 441                 int cur_len = 0;
 442                 bool cur_var = var;
 443
 444                 end = strchr(str, '%');
 445                 if (end) {
 446                         *end = 0;
 447                         next = end + 1;
 448                         var = !var;
 449                 } else {
 450                         end = str + strlen(str);
 451                         next = NULL;
 452                 }
 453
 454                 if (cur_var) {
 455                         if (end > str) {
 456                                 cur = msg_find_var(call, str);
 457                                 if (!cur)
 458                                         continue;
 459
 460                                 cur_len = strlen(cur);
 461                         } else {
 462                                 cur = &c;
 463                                 cur_len = 1;
 464                         }
 465                 } else {
 466                         if (str == end)
 467                                 continue;
 468
 469                         cur = str;
 470                         cur_len = end - str;
 471                 }
 472
 473                 new_buf = blobmsg_realloc_string_buffer(buf, len + cur_len + 1);
 474                 if (!new_buf) {
 475                         /* Make eval_string return -1 */
 476                         var = true;
 477                         break;
 478                 }
 479
 480                 dest = new_buf;
 481                 memcpy(dest + len, cur, cur_len);
 482                 len += cur_len;
 483         }
 484
 485         dest[len] = 0;
 486         blobmsg_add_string_buffer(buf);
 487
 488         if (var)
 489                 return -1;
 490
 491         return 0;
 492 }
 493
 494 static int cmd_add_string(struct json_call *call, const char *pattern)
 495 {
 496         return eval_string(call, &call->ctx->buf, NULL, pattern);
 497 }
 498
 499 int json_script_eval_string(struct json_script_ctx *ctx, struct blob_attr *vars,
 500                             struct blob_buf *buf, const char *name,
 501                             const char *pattern)
 502 {
 503         struct json_call call = {
 504                 .ctx = ctx,
 505                 .vars = vars,
 506         };
 507
 508         return eval_string(&call, buf, name, pattern);
 509 }
 510
 511 static int cmd_process_strings(struct json_call *call, struct blob_attr *attr)
 512 {
 513         struct json_script_ctx *ctx = call->ctx;
 514         struct blob_attr *cur;
 515         int args = -1;
 516         int rem, ret;
 517         void *c;
 518
 519         blob_buf_init(&ctx->buf, 0);
 520         c = blobmsg_open_array(&ctx->buf, NULL);
 521         blobmsg_for_each_attr(cur, attr, rem) {
 522                 if (args++ < 0)
 523                         continue;
 524
 525                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) {
 526                         blobmsg_add_blob(&ctx->buf, cur);
 527                         continue;
 528                 }
 529
 530                 ret = cmd_add_string(call, blobmsg_data(cur));
 531                 if (ret) {
 532                         ctx->handle_error(ctx, "Unterminated variable reference in string", attr);
 533                         return ret;
 534                 }
 535         }
 536
 537         blobmsg_close_array(&ctx->buf, c);
 538
 539         return 0;
 540 }
 541
 542 static int __json_process_cmd(struct json_call *call, struct blob_attr *cur)
 543 {
 544         struct json_script_ctx *ctx = call->ctx;
 545         const char *name;
 546         bool found;
 547         int ret;
 548
 549         if (blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY ||
 550             blobmsg_type(blobmsg_data(cur)) != BLOBMSG_TYPE_STRING) {
 551                 ctx->handle_error(ctx, "Unexpected element type", cur);
 552                 return -1;
 553         }
 554
 555         ret = __json_process_type(call, cur, cmd, ARRAY_SIZE(cmd), &found);
 556         if (found)
 557                 return ret;
 558
 559         name = blobmsg_data(blobmsg_data(cur));
 560         ret = cmd_process_strings(call, cur);
 561         if (ret)
 562                 return ret;
 563
 564         ctx->handle_command(ctx, name, blob_data(ctx->buf.head), call->vars);
 565
 566         return 0;
 567 }
 568
 569 static int json_process_cmd(struct json_call *call, struct blob_attr *block)
 570 {
 571         struct json_script_ctx *ctx = call->ctx;
 572         struct blob_attr *cur;
 573         int rem;
 574         int ret;
 575         int i = 0;
 576
 577         if (blobmsg_type(block) != BLOBMSG_TYPE_ARRAY) {
 578                 ctx->handle_error(ctx, "Unexpected element type", block);
 579                 return -1;
 580         }
 581
 582         blobmsg_for_each_attr(cur, block, rem) {
 583                 if (ctx->abort)
 584                         break;
 585
 586                 switch(blobmsg_type(cur)) {
 587                 case BLOBMSG_TYPE_STRING:
 588                         if (!i)
 589                                 return __json_process_cmd(call, block);
 590                 default:
 591                         ret = json_process_cmd(call, cur);
 592                         if (ret < -1)
 593                                 return ret;
 594                         break;
 595                 }
 596                 i++;
 597         }
 598
 599         return 0;
 600 }
 601
 602 void json_script_run_file(struct json_script_ctx *ctx, struct json_script_file *file,
 603                           struct blob_attr *vars)
 604 {
 605         static unsigned int _seq = 0;
 606         struct json_call call = {
 607                 .ctx = ctx,
 608                 .vars = vars,
 609                 .seq = ++_seq,
 610         };
 611
 612         /* overflow */
 613         if (!call.seq)
 614                 call.seq = ++_seq;
 615
 616         ctx->abort = false;
 617
 618         __json_script_run(&call, file, NULL);
 619 }
 620
 621 void json_script_run(struct json_script_ctx *ctx, const char *name,
 622                      struct blob_attr *vars)
 623 {
 624         struct json_script_file *file;
 625
 626         file = json_script_get_file(ctx, name);
 627         if (!file)
 628                 return;
 629
 630         json_script_run_file(ctx, file, vars);
 631 }
 632
 633 static void __json_script_file_free(struct json_script_file *f)
 634 {
 635         struct json_script_file *next;
 636
 637         if (!f)
 638                 return;
 639
 640         next = f->next;
 641         free(f);
 642
 643         __json_script_file_free(next);
 644 }
 645
 646 void
 647 json_script_free(struct json_script_ctx *ctx)
 648 {
 649         struct json_script_file *f, *next;
 650
 651         avl_remove_all_elements(&ctx->files, f, avl, next)
 652                 __json_script_file_free(f);
 653
 654         blob_buf_free(&ctx->buf);
 655 }
 656
 657 static void
 658 __default_handle_error(struct json_script_ctx *ctx, const char *msg,
 659                        struct blob_attr *context)
 660 {
 661 }
 662
 663 static const char *
 664 __default_handle_var(struct json_script_ctx *ctx, const char *name,
 665                      struct blob_attr *vars)
 666 {
 667         return NULL;
 668 }
 669
 670 static int
 671 __default_handle_expr(struct json_script_ctx *ctx, const char *name,
 672                       struct blob_attr *expr, struct blob_attr *vars)
 673 {
 674         return -1;
 675 }
 676
 677 static struct json_script_file *
 678 __default_handle_file(struct json_script_ctx *ctx, const char *name)
 679 {
 680         return NULL;
 681 }
 682
 683 void json_script_init(struct json_script_ctx *ctx)
 684 {
 685         avl_init(&ctx->files, avl_strcmp, false, NULL);
 686
 687         if (!ctx->handle_error)
 688                 ctx->handle_error = __default_handle_error;
 689
 690         if (!ctx->handle_var)
 691                 ctx->handle_var = __default_handle_var;
 692
 693         if (!ctx->handle_expr)
 694                 ctx->handle_expr = __default_handle_expr;
 695
 696         if (!ctx->handle_file)
 697                 ctx->handle_file = __default_handle_file;
 698 }