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(struct json_script_ctx *ctx, const char *name,
 557                      struct blob_attr *vars)
 558 {
 559         struct json_script_file *file;
 560         static unsigned int _seq = 0;
 561         struct json_call call = {
 562                 .ctx = ctx,
 563                 .vars = vars,
 564                 .seq = ++_seq,
 565         };
 566
 567         /* overflow */
 568         if (!call.seq)
 569                 call.seq = ++_seq;
 570
 571         file = json_script_get_file(ctx, name);
 572         if (!file)
 573                 return;
 574
 575         __json_script_run(&call, file, NULL);
 576 }
 577
 578 static void __json_script_file_free(struct json_script_ctx *ctx, struct json_script_file *f)
 579 {
 580         struct json_script_file *next;
 581
 582         for (next = f->next; f; f = next, next = f->next)
 583                 free(f);
 584 }
 585
 586 void
 587 json_script_free(struct json_script_ctx *ctx)
 588 {
 589         struct json_script_file *f, *next;
 590
 591         avl_remove_all_elements(&ctx->files, f, avl, next)
 592                 __json_script_file_free(ctx, f);
 593
 594         blob_buf_free(&ctx->buf);
 595 }
 596
 597 static void
 598 __default_handle_error(struct json_script_ctx *ctx, const char *msg,
 599                        struct blob_attr *context)
 600 {
 601 }
 602
 603 static const char *
 604 __default_handle_var(struct json_script_ctx *ctx, const char *name,
 605                      struct blob_attr *vars)
 606 {
 607         return NULL;
 608 }
 609
 610 static int
 611 __default_handle_expr(struct json_script_ctx *ctx, const char *name,
 612                       struct blob_attr *expr, struct blob_attr *vars)
 613 {
 614         return -1;
 615 }
 616
 617 static struct json_script_file *
 618 __default_handle_file(struct json_script_ctx *ctx, const char *name)
 619 {
 620         return NULL;
 621 }
 622
 623 void json_script_init(struct json_script_ctx *ctx)
 624 {
 625         avl_init(&ctx->files, avl_strcmp, false, NULL);
 626
 627         if (!ctx->handle_error)
 628                 ctx->handle_error = __default_handle_error;
 629
 630         if (!ctx->handle_var)
 631                 ctx->handle_var = __default_handle_var;
 632
 633         if (!ctx->handle_expr)
 634                 ctx->handle_expr = __default_handle_expr;
 635
 636         if (!ctx->handle_file)
 637                 ctx->handle_file = __default_handle_file;
 638 }