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 cmd_add_string(struct json_call *call, const char *pattern)
 392 {
 393         struct json_script_ctx *ctx = call->ctx;
 394         char *dest, *next, *str;
 395         int len = 0;
 396         bool var = false;
 397         char c = '%';
 398
 399         dest = blobmsg_alloc_string_buffer(&ctx->buf, NULL, 1);
 400         next = alloca(strlen(pattern) + 1);
 401         strcpy(next, pattern);
 402
 403         for (str = next; str; str = next) {
 404                 const char *cur;
 405                 char *end;
 406                 int cur_len = 0;
 407                 bool cur_var = var;
 408
 409                 end = strchr(str, '%');
 410                 if (end) {
 411                         *end = 0;
 412                         next = end + 1;
 413                         var = !var;
 414                 } else {
 415                         end = str + strlen(str);
 416                         next = NULL;
 417                 }
 418
 419                 if (cur_var) {
 420                         if (next > str) {
 421                                 cur = msg_find_var(call, str);
 422                                 if (!cur)
 423                                         continue;
 424
 425                                 cur_len = strlen(cur);
 426                         } else {
 427                                 cur = &c;
 428                                 cur_len = 1;
 429                         }
 430                 } else {
 431                         if (str == end)
 432                                 continue;
 433
 434                         cur = str;
 435                         cur_len = end - str;
 436                 }
 437
 438                 dest = blobmsg_realloc_string_buffer(&ctx->buf, cur_len + 1);
 439                 memcpy(dest + len, cur, cur_len);
 440                 len += cur_len;
 441         }
 442
 443         if (var)
 444                 return -1;
 445
 446         dest[len] = 0;
 447         blobmsg_add_string_buffer(&ctx->buf);
 448         return 0;
 449 }
 450
 451 static int cmd_process_strings(struct json_call *call, struct blob_attr *attr)
 452 {
 453         struct json_script_ctx *ctx = call->ctx;
 454         struct blob_attr *cur;
 455         int args = -1;
 456         int rem, ret;
 457         void *c;
 458
 459         blob_buf_init(&ctx->buf, 0);
 460         c = blobmsg_open_array(&ctx->buf, NULL);
 461         blobmsg_for_each_attr(cur, attr, rem) {
 462                 if (args++ < 0)
 463                         continue;
 464
 465                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING) {
 466                         ctx->handle_error(ctx, "Invalid argument in command", attr);
 467                         return -1;
 468                 }
 469
 470                 ret = cmd_add_string(call, blobmsg_data(cur));
 471                 if (ret) {
 472                         ctx->handle_error(ctx, "Unterminated variable reference in string", attr);
 473                         return ret;
 474                 }
 475         }
 476
 477         blobmsg_close_array(&ctx->buf, c);
 478
 479         return 0;
 480 }
 481
 482 static int __json_process_cmd(struct json_call *call, struct blob_attr *cur)
 483 {
 484         struct json_script_ctx *ctx = call->ctx;
 485         const char *name;
 486         bool found;
 487         int ret;
 488
 489         if (blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY ||
 490             blobmsg_type(blobmsg_data(cur)) != BLOBMSG_TYPE_STRING) {
 491                 ctx->handle_error(ctx, "Unexpected element type", cur);
 492                 return -1;
 493         }
 494
 495         ret = __json_process_type(call, cur, cmd, ARRAY_SIZE(cmd), &found);
 496         if (found)
 497                 return ret;
 498
 499         name = blobmsg_data(blobmsg_data(cur));
 500         ret = cmd_process_strings(call, cur);
 501         if (ret)
 502                 return ret;
 503
 504         ctx->handle_command(ctx, name, blob_data(ctx->buf.head), call->vars);
 505
 506         return 0;
 507 }
 508
 509 static int json_process_cmd(struct json_call *call, struct blob_attr *block)
 510 {
 511         struct json_script_ctx *ctx = call->ctx;
 512         struct blob_attr *cur;
 513         int rem;
 514         int ret;
 515         int i = 0;
 516
 517         if (blobmsg_type(block) != BLOBMSG_TYPE_ARRAY) {
 518                 ctx->handle_error(ctx, "Unexpected element type", block);
 519                 return -1;
 520         }
 521
 522         blobmsg_for_each_attr(cur, block, rem) {
 523                 switch(blobmsg_type(cur)) {
 524                 case BLOBMSG_TYPE_STRING:
 525                         if (!i)
 526                                 return __json_process_cmd(call, block);
 527                 default:
 528                         ret = json_process_cmd(call, cur);
 529                         if (ret < -1)
 530                                 return ret;
 531                         break;
 532                 }
 533                 i++;
 534         }
 535
 536         return 0;
 537 }
 538
 539 void json_script_run(struct json_script_ctx *ctx, const char *name,
 540                      struct blob_attr *vars)
 541 {
 542         struct json_script_file *file;
 543         static unsigned int _seq = 0;
 544         struct json_call call = {
 545                 .ctx = ctx,
 546                 .vars = vars,
 547                 .seq = ++_seq,
 548         };
 549
 550         /* overflow */
 551         if (!call.seq)
 552                 call.seq = ++_seq;
 553
 554         file = json_script_get_file(ctx, name);
 555         if (!file)
 556                 return;
 557
 558         __json_script_run(&call, file, NULL);
 559 }
 560
 561 static void __json_script_file_free(struct json_script_ctx *ctx, struct json_script_file *f)
 562 {
 563         struct json_script_file *next;
 564
 565         for (next = f->next; f; f = next, next = f->next)
 566                 free(f);
 567 }
 568
 569 void
 570 json_script_free(struct json_script_ctx *ctx)
 571 {
 572         struct json_script_file *f, *next;
 573
 574         avl_remove_all_elements(&ctx->files, f, avl, next)
 575                 __json_script_file_free(ctx, f);
 576
 577         blob_buf_free(&ctx->buf);
 578 }
 579
 580 static void
 581 __default_handle_error(struct json_script_ctx *ctx, const char *msg,
 582                        struct blob_attr *context)
 583 {
 584 }
 585
 586 static const char *
 587 __default_handle_var(struct json_script_ctx *ctx, const char *name,
 588                      struct blob_attr *vars)
 589 {
 590         return NULL;
 591 }
 592
 593 static int
 594 __default_handle_expr(struct json_script_ctx *ctx, const char *name,
 595                       struct blob_attr *expr, struct blob_attr *vars)
 596 {
 597         return -1;
 598 }
 599
 600 static struct json_script_file *
 601 __default_handle_file(struct json_script_ctx *ctx, const char *name)
 602 {
 603         return NULL;
 604 }
 605
 606 void json_script_init(struct json_script_ctx *ctx)
 607 {
 608         avl_init(&ctx->files, avl_strcmp, false, NULL);
 609
 610         if (!ctx->handle_error)
 611                 ctx->handle_error = __default_handle_error;
 612
 613         if (!ctx->handle_var)
 614                 ctx->handle_var = __default_handle_var;
 615
 616         if (!ctx->handle_expr)
 617                 ctx->handle_expr = __default_handle_expr;
 618
 619         if (!ctx->handle_file)
 620                 ctx->handle_file = __default_handle_file;
 621 }