lua/uci.c

   1 /*
   2  * libuci plugin for Lua
   3  * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <sys/types.h>
  16 #include <sys/time.h>
  17 #include <stdbool.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21 #include <stdio.h>
  22 #include <errno.h>
  23
  24 #include <lauxlib.h>
  25 #include <uci.h>
  26
  27 #define MODNAME        "uci"
  28 #define METANAME       MODNAME ".meta"
  29 //#define DEBUG 1
  30
  31 #ifdef DEBUG
  32 #define DPRINTF(...) fprintf(stderr, __VA_ARGS__)
  33 #else
  34 #define DPRINTF(...) do {} while (0)
  35 #endif
  36
  37 #if !defined LUA_VERSION_NUM || LUA_VERSION_NUM==501
  38
  39 /*
  40  * ** Adapted from Lua 5.2.0
  41  * */
  42 static void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
  43         luaL_checkstack(L, nup+1, "too many upvalues");
  44         for (; l->name != NULL; l++) {  /* fill the table with given functions */
  45                 int i;
  46                 lua_pushstring(L, l->name);
  47                 for (i = 0; i < nup; i++)  /* copy upvalues to the top */
  48                         lua_pushvalue(L, -(nup+1));
  49                 lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
  50                 lua_settable(L, -(nup + 3));
  51         }
  52         lua_pop(L, nup);  /* remove upvalues */
  53 }
  54
  55 #define lua_rawlen(L, i) lua_objlen(L, i)
  56
  57 #endif
  58
  59 static struct uci_context *global_ctx = NULL;
  60
  61 static struct uci_context *
  62 find_context(lua_State *L, int *offset)
  63 {
  64         struct uci_context **ctx;
  65         if (!lua_isuserdata(L, 1)) {
  66                 if (!global_ctx) {
  67                         global_ctx = uci_alloc_context();
  68                         if (!global_ctx) {
  69                                 luaL_error(L, "failed to allocate UCI context");
  70                                 return NULL;
  71                         }
  72                 }
  73                 if (offset)
  74                         *offset = 0;
  75                 return global_ctx;
  76         }
  77         if (offset)
  78                 *offset = 1;
  79         ctx = luaL_checkudata(L, 1, METANAME);
  80         if (!ctx || !*ctx) {
  81                 luaL_error(L, "failed to get UCI context");
  82                 return NULL;
  83         }
  84
  85         return *ctx;
  86 }
  87
  88 static struct uci_package *
  89 find_package(lua_State *L, struct uci_context *ctx, const char *str, bool al)
  90 {
  91         struct uci_package *p = NULL;
  92         struct uci_element *e;
  93         char *sep;
  94         char *name;
  95
  96         sep = strchr(str, '.');
  97         if (sep) {
  98                 name = malloc(1 + sep - str);
  99                 if (!name) {
 100                         luaL_error(L, "out of memory");
 101                         return NULL;
 102                 }
 103                 strncpy(name, str, sep - str);
 104                 name[sep - str] = 0;
 105         } else
 106                 name = (char *) str;
 107
 108         uci_foreach_element(&ctx->root, e) {
 109                 if (strcmp(e->name, name) != 0)
 110                         continue;
 111
 112                 p = uci_to_package(e);
 113                 goto done;
 114         }
 115
 116         if (al)
 117                 uci_load(ctx, name, &p);
 118
 119 done:
 120         if (name != str)
 121                 free(name);
 122         return p;
 123 }
 124
 125 static int
 126 lookup_extended(struct uci_context *ctx, struct uci_ptr *ptr, char *str, bool extended)
 127 {
 128         int rv;
 129         struct uci_ptr lookup;
 130
 131         /* use a copy of the passed ptr since failing lookups will
 132          * clobber the state */
 133         lookup = *ptr;
 134         lookup.flags |= UCI_LOOKUP_EXTENDED;
 135
 136         rv = uci_lookup_ptr(ctx, &lookup, str, extended);
 137
 138         /* copy to passed ptr on success */
 139         if (!rv)
 140                 *ptr = lookup;
 141
 142         return rv;
 143 }
 144
 145 static int
 146 lookup_ptr(struct uci_context *ctx, struct uci_ptr *ptr, char *str, bool extended)
 147 {
 148         if (ptr && !ptr->s && ptr->section && *ptr->section == '@')
 149                 return lookup_extended(ctx, ptr, str, extended);
 150
 151         return uci_lookup_ptr(ctx, ptr, str, extended);
 152 }
 153
 154 static int
 155 lookup_args(lua_State *L, struct uci_context *ctx, int offset, struct uci_ptr *ptr, char **buf)
 156 {
 157         char *s = NULL;
 158         int n;
 159
 160         n = lua_gettop(L);
 161         luaL_checkstring(L, 1 + offset);
 162         s = strdup(lua_tostring(L, 1 + offset));
 163         if (!s)
 164                 goto error;
 165
 166         memset(ptr, 0, sizeof(struct uci_ptr));
 167         if (!find_package(L, ctx, s, true))
 168                 goto error;
 169
 170         switch (n - offset) {
 171         case 4:
 172         case 3:
 173                 ptr->option = luaL_checkstring(L, 3 + offset);
 174                 /* fall through */
 175         case 2:
 176                 ptr->section = luaL_checkstring(L, 2 + offset);
 177                 ptr->package = luaL_checkstring(L, 1 + offset);
 178                 if (lookup_ptr(ctx, ptr, NULL, true) != UCI_OK)
 179                         goto error;
 180                 break;
 181         case 1:
 182                 if (lookup_ptr(ctx, ptr, s, true) != UCI_OK)
 183                         goto error;
 184                 break;
 185         default:
 186                 luaL_error(L, "invalid argument count");
 187                 goto error;
 188         }
 189
 190         *buf = s;
 191         return 0;
 192
 193 error:
 194         if (s)
 195                 free(s);
 196         return 1;
 197 }
 198
 199 static int
 200 uci_push_status(lua_State *L, struct uci_context *ctx, bool hasarg)
 201 {
 202         char *str = NULL;
 203
 204         if (!hasarg)
 205                 lua_pushboolean(L, (ctx->err == UCI_OK));
 206         if (ctx->err) {
 207                 uci_get_errorstr(ctx, &str, MODNAME);
 208                 if (str) {
 209                         lua_pushstring(L, str);
 210                         free(str);
 211                         return 2;
 212                 }
 213         }
 214         return 1;
 215 }
 216
 217 static void
 218 uci_push_option(lua_State *L, struct uci_option *o)
 219 {
 220         struct uci_element *e;
 221         int i = 0;
 222
 223         switch(o->type) {
 224         case UCI_TYPE_STRING:
 225                 lua_pushstring(L, o->v.string);
 226                 break;
 227         case UCI_TYPE_LIST:
 228                 lua_newtable(L);
 229                 uci_foreach_element(&o->v.list, e) {
 230                         i++;
 231                         lua_pushstring(L, e->name);
 232                         lua_rawseti(L, -2, i);
 233                 }
 234                 break;
 235         default:
 236                 lua_pushnil(L);
 237                 break;
 238         }
 239 }
 240
 241 static void
 242 uci_push_section(lua_State *L, struct uci_section *s, int index)
 243 {
 244         struct uci_element *e;
 245
 246         lua_newtable(L);
 247         lua_pushboolean(L, s->anonymous);
 248         lua_setfield(L, -2, ".anonymous");
 249         lua_pushstring(L, s->type);
 250         lua_setfield(L, -2, ".type");
 251         lua_pushstring(L, s->e.name);
 252         lua_setfield(L, -2, ".name");
 253         if (index >= 0) {
 254                 lua_pushinteger(L, index);
 255                 lua_setfield(L, -2, ".index");
 256         }
 257
 258         uci_foreach_element(&s->options, e) {
 259                 struct uci_option *o = uci_to_option(e);
 260                 uci_push_option(L, o);
 261                 lua_setfield(L, -2, o->e.name);
 262         }
 263 }
 264
 265 static void
 266 uci_push_package(lua_State *L, struct uci_package *p)
 267 {
 268         struct uci_element *e;
 269         int i = 0;
 270
 271         lua_newtable(L);
 272         uci_foreach_element(&p->sections, e) {
 273                 uci_push_section(L, uci_to_section(e), i);
 274                 lua_setfield(L, -2, e->name);
 275                 i++;
 276         }
 277 }
 278
 279 static int
 280 uci_lua_unload(lua_State *L)
 281 {
 282         struct uci_context *ctx;
 283         struct uci_package *p;
 284         const char *s;
 285         int offset = 0;
 286
 287         ctx = find_context(L, &offset);
 288         luaL_checkstring(L, 1 + offset);
 289         s = lua_tostring(L, 1 + offset);
 290         p = find_package(L, ctx, s, false);
 291         if (p) {
 292                 uci_unload(ctx, p);
 293                 return uci_push_status(L, ctx, false);
 294         } else {
 295                 lua_pushboolean(L, 0);
 296         }
 297         return 1;
 298 }
 299
 300 static int
 301 uci_lua_load(lua_State *L)
 302 {
 303         struct uci_context *ctx;
 304         struct uci_package *p = NULL;
 305         const char *s;
 306         int offset = 0;
 307
 308         ctx = find_context(L, &offset);
 309         uci_lua_unload(L);
 310         lua_pop(L, 1); /* bool ret value of unload */
 311         s = lua_tostring(L, -1);
 312
 313         uci_load(ctx, s, &p);
 314         return uci_push_status(L, ctx, false);
 315 }
 316
 317
 318 static int
 319 uci_lua_foreach(lua_State *L)
 320 {
 321         struct uci_context *ctx;
 322         struct uci_package *p;
 323         struct uci_element *e, *tmp;
 324         const char *package, *type;
 325         bool ret = false;
 326         int offset = 0;
 327         int i = 0;
 328
 329         ctx = find_context(L, &offset);
 330         package = luaL_checkstring(L, 1 + offset);
 331
 332         if (lua_isnil(L, 2 + offset))
 333                 type = NULL;
 334         else
 335                 type = luaL_checkstring(L, 2 + offset);
 336
 337         if (!lua_isfunction(L, 3 + offset) || !package)
 338                 return luaL_error(L, "Invalid argument");
 339
 340         p = find_package(L, ctx, package, true);
 341         if (!p)
 342                 goto done;
 343
 344         uci_foreach_element_safe(&p->sections, tmp, e) {
 345                 struct uci_section *s = uci_to_section(e);
 346
 347                 i++;
 348
 349                 if (type && (strcmp(s->type, type) != 0))
 350                         continue;
 351
 352                 lua_pushvalue(L, 3 + offset); /* iterator function */
 353                 uci_push_section(L, s, i - 1);
 354                 if (lua_pcall(L, 1, 1, 0) == 0) {
 355                         ret = true;
 356                         if (lua_isboolean(L, -1) && !lua_toboolean(L, -1))
 357                                 break;
 358                 }
 359                 else
 360                 {
 361                         lua_error(L);
 362                         break;
 363                 }
 364         }
 365
 366 done:
 367         lua_pushboolean(L, ret);
 368         return 1;
 369 }
 370
 371 static int
 372 uci_lua_get_any(lua_State *L, bool all)
 373 {
 374         struct uci_context *ctx;
 375         struct uci_element *e = NULL;
 376         struct uci_ptr ptr;
 377         int offset = 0;
 378         int nret = 1;
 379         char *s = NULL;
 380         int err = UCI_ERR_NOTFOUND;
 381
 382         ctx = find_context(L, &offset);
 383
 384         if (lookup_args(L, ctx, offset, &ptr, &s))
 385                 goto error;
 386
 387         lookup_ptr(ctx, &ptr, NULL, true);
 388         if (!all && !ptr.s) {
 389                 err = UCI_ERR_INVAL;
 390                 goto error;
 391         }
 392         if (!(ptr.flags & UCI_LOOKUP_COMPLETE)) {
 393                 err = UCI_ERR_NOTFOUND;
 394                 goto error;
 395         }
 396
 397         err = UCI_OK;
 398         e = ptr.last;
 399         switch(e->type) {
 400                 case UCI_TYPE_PACKAGE:
 401                         uci_push_package(L, ptr.p);
 402                         break;
 403                 case UCI_TYPE_SECTION:
 404                         if (all) {
 405                                 uci_push_section(L, ptr.s, -1);
 406                         }
 407                         else {
 408                                 lua_pushstring(L, ptr.s->type);
 409                                 lua_pushstring(L, ptr.s->e.name);
 410                                 nret++;
 411                         }
 412                         break;
 413                 case UCI_TYPE_OPTION:
 414                         uci_push_option(L, ptr.o);
 415                         break;
 416                 default:
 417                         err = UCI_ERR_INVAL;
 418                         goto error;
 419         }
 420         if (s)
 421                 free(s);
 422         if (!err)
 423                 return nret;
 424
 425 error:
 426         if (s)
 427                 free(s);
 428
 429         lua_pushnil(L);
 430         return uci_push_status(L, ctx, true);
 431 }
 432
 433 static int
 434 uci_lua_get(lua_State *L)
 435 {
 436         return uci_lua_get_any(L, false);
 437 }
 438
 439 static int
 440 uci_lua_get_all(lua_State *L)
 441 {
 442         return uci_lua_get_any(L, true);
 443 }
 444
 445 static int
 446 uci_lua_add(lua_State *L)
 447 {
 448         struct uci_context *ctx;
 449         struct uci_section *s = NULL;
 450         struct uci_package *p;
 451         const char *package;
 452         const char *type;
 453         const char *name = NULL;
 454         int offset = 0;
 455
 456         ctx = find_context(L, &offset);
 457         package = luaL_checkstring(L, 1 + offset);
 458         type = luaL_checkstring(L, 2 + offset);
 459         p = find_package(L, ctx, package, true);
 460         if (!p)
 461                 goto fail;
 462
 463         if (uci_add_section(ctx, p, type, &s) || !s)
 464                 goto fail;
 465
 466         name = s->e.name;
 467         lua_pushstring(L, name);
 468         return 1;
 469
 470 fail:
 471         lua_pushnil(L);
 472         return uci_push_status(L, ctx, true);
 473 }
 474
 475 static int
 476 uci_lua_delete(lua_State *L)
 477 {
 478         struct uci_context *ctx;
 479         struct uci_ptr ptr;
 480         int offset = 0;
 481         char *s = NULL;
 482
 483         ctx = find_context(L, &offset);
 484
 485         if (lookup_args(L, ctx, offset, &ptr, &s))
 486                 goto error;
 487
 488         uci_delete(ctx, &ptr);
 489
 490 error:
 491         if (s)
 492                 free(s);
 493         return uci_push_status(L, ctx, false);
 494 }
 495
 496 static int
 497 uci_lua_rename(lua_State *L)
 498 {
 499         struct uci_context *ctx;
 500         struct uci_ptr ptr;
 501         int err = UCI_ERR_MEM;
 502         char *s = NULL;
 503         int nargs, offset = 0;
 504
 505         ctx = find_context(L, &offset);
 506         nargs = lua_gettop(L);
 507         if (lookup_args(L, ctx, offset, &ptr, &s))
 508                 goto error;
 509
 510         switch(nargs - offset) {
 511         case 1:
 512                 /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */
 513                 break;
 514         case 4:
 515                 /* Format: uci.set("p", "s", "o", "v") */
 516                 ptr.value = luaL_checkstring(L, nargs);
 517                 break;
 518         case 3:
 519                 /* Format: uci.set("p", "s", "v") */
 520                 ptr.value = ptr.option;
 521                 ptr.option = NULL;
 522                 break;
 523         default:
 524                 err = UCI_ERR_INVAL;
 525                 goto error;
 526         }
 527
 528         err = lookup_ptr(ctx, &ptr, NULL, true);
 529         if (err)
 530                 goto error;
 531
 532         if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) {
 533                 err = UCI_ERR_INVAL;
 534                 goto error;
 535         }
 536
 537         err = uci_rename(ctx, &ptr);
 538         if (err)
 539                 goto error;
 540
 541 error:
 542         if (s)
 543                 free(s);
 544         return uci_push_status(L, ctx, false);
 545 }
 546
 547 static int
 548 uci_lua_reorder(lua_State *L)
 549 {
 550         struct uci_context *ctx;
 551         struct uci_ptr ptr;
 552         int err = UCI_ERR_MEM;
 553         char *s = NULL;
 554         int nargs, offset = 0;
 555
 556         ctx = find_context(L, &offset);
 557         nargs = lua_gettop(L);
 558         if (lookup_args(L, ctx, offset, &ptr, &s))
 559                 goto error;
 560
 561         switch(nargs - offset) {
 562         case 1:
 563                 /* Format: uci.set("p.s=v") or uci.set("p.s=v") */
 564                 if (ptr.option) {
 565                         err = UCI_ERR_INVAL;
 566                         goto error;
 567                 }
 568                 break;
 569         case 3:
 570                 /* Format: uci.set("p", "s", "v") */
 571                 ptr.value = ptr.option;
 572                 ptr.option = NULL;
 573                 break;
 574         default:
 575                 err = UCI_ERR_INVAL;
 576                 goto error;
 577         }
 578
 579         err = lookup_ptr(ctx, &ptr, NULL, true);
 580         if (err)
 581                 goto error;
 582
 583         if ((ptr.s == NULL) || (ptr.value == NULL)) {
 584                 err = UCI_ERR_INVAL;
 585                 goto error;
 586         }
 587
 588         err = uci_reorder_section(ctx, ptr.s, strtoul(ptr.value, NULL, 10));
 589         if (err)
 590                 goto error;
 591
 592 error:
 593         if (s)
 594                 free(s);
 595         return uci_push_status(L, ctx, false);
 596 }
 597
 598
 599 static int
 600 uci_lua_set(lua_State *L)
 601 {
 602         struct uci_context *ctx;
 603         struct uci_ptr ptr;
 604         bool istable = false;
 605         int err = UCI_ERR_MEM;
 606         char *s = NULL;
 607         const char *v;
 608         unsigned int i;
 609         int nargs, offset = 0;
 610
 611         ctx = find_context(L, &offset);
 612         nargs = lua_gettop(L);
 613         if (lookup_args(L, ctx, offset, &ptr, &s))
 614                 goto error;
 615
 616         switch(nargs - offset) {
 617         case 1:
 618                 /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */
 619                 break;
 620         case 4:
 621                 /* Format: uci.set("p", "s", "o", "v") */
 622                 if (lua_istable(L, nargs)) {
 623                         if (lua_rawlen(L, nargs) < 1)
 624                                 return luaL_error(L, "Cannot set an uci option to an empty table value");
 625                         lua_rawgeti(L, nargs, 1);
 626                         ptr.value = luaL_checkstring(L, -1);
 627                         lua_pop(L, 1);
 628                         istable = true;
 629                 } else {
 630                         ptr.value = luaL_checkstring(L, nargs);
 631                 }
 632                 break;
 633         case 3:
 634                 /* Format: uci.set("p", "s", "v") */
 635                 ptr.value = ptr.option;
 636                 ptr.option = NULL;
 637                 break;
 638         default:
 639                 err = UCI_ERR_INVAL;
 640                 goto error;
 641         }
 642
 643         err = lookup_ptr(ctx, &ptr, NULL, true);
 644         if (err)
 645                 goto error;
 646
 647         if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) {
 648                 err = UCI_ERR_INVAL;
 649                 goto error;
 650         }
 651
 652         if (istable) {
 653                 if (lua_rawlen(L, nargs) == 1) {
 654                         i = 1;
 655                         if (ptr.o) {
 656                                 v = ptr.value;
 657                                 ptr.value = NULL;
 658                                 err = uci_delete(ctx, &ptr);
 659                                 if (err)
 660                                         goto error;
 661                                 ptr.value = v;
 662                         }
 663                 } else {
 664                         i = 2;
 665                         err = uci_set(ctx, &ptr);
 666                         if (err)
 667                                 goto error;
 668                 }
 669
 670                 for (; i <= lua_rawlen(L, nargs); i++) {
 671                         lua_rawgeti(L, nargs, i);
 672                         ptr.value = luaL_checkstring(L, -1);
 673                         err = uci_add_list(ctx, &ptr);
 674                         lua_pop(L, 1);
 675                         if (err)
 676                                 goto error;
 677                 }
 678         } else {
 679                 err = uci_set(ctx, &ptr);
 680                 if (err)
 681                         goto error;
 682         }
 683
 684
 685 error:
 686         if (s)
 687                 free(s);
 688         return uci_push_status(L, ctx, false);
 689 }
 690
 691 enum pkg_cmd {
 692         CMD_SAVE,
 693         CMD_COMMIT,
 694         CMD_REVERT
 695 };
 696
 697 static int
 698 uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd)
 699 {
 700         struct uci_context *ctx;
 701         struct uci_element *e, *tmp;
 702         struct uci_ptr ptr;
 703         char *s = NULL;
 704         int nargs, offset = 0;
 705
 706         ctx = find_context(L, &offset);
 707         nargs = lua_gettop(L);
 708         if ((cmd != CMD_REVERT) && (nargs - offset > 1))
 709                 goto err;
 710
 711         if (lookup_args(L, ctx, offset, &ptr, &s))
 712                 goto err;
 713
 714         lookup_ptr(ctx, &ptr, NULL, true);
 715
 716         uci_foreach_element_safe(&ctx->root, tmp, e) {
 717                 struct uci_package *p = uci_to_package(e);
 718
 719                 if (ptr.p && (ptr.p != p))
 720                         continue;
 721
 722                 ptr.p = p;
 723                 switch(cmd) {
 724                 case CMD_COMMIT:
 725                         uci_commit(ctx, &p, false);
 726                         break;
 727                 case CMD_SAVE:
 728                         uci_save(ctx, p);
 729                         break;
 730                 case CMD_REVERT:
 731                         uci_revert(ctx, &ptr);
 732                         break;
 733                 }
 734         }
 735
 736 err:
 737         if (s)
 738                 free(s);
 739         return uci_push_status(L, ctx, false);
 740 }
 741
 742 static int
 743 uci_lua_save(lua_State *L)
 744 {
 745         return uci_lua_package_cmd(L, CMD_SAVE);
 746 }
 747
 748 static int
 749 uci_lua_commit(lua_State *L)
 750 {
 751         return uci_lua_package_cmd(L, CMD_COMMIT);
 752 }
 753
 754 static int
 755 uci_lua_revert(lua_State *L)
 756 {
 757         return uci_lua_package_cmd(L, CMD_REVERT);
 758 }
 759
 760 static void
 761 uci_lua_add_change(lua_State *L, struct uci_element *e)
 762 {
 763         struct uci_delta *h;
 764         const char *name;
 765         const char *value;
 766
 767         h = uci_to_delta(e);
 768         if (!h->section)
 769                 return;
 770
 771         lua_getfield(L, -1, h->section);
 772         if (lua_isnil(L, -1)) {
 773                 lua_pop(L, 1);
 774                 lua_newtable(L);
 775                 lua_pushvalue(L, -1); /* copy for setfield */
 776                 lua_setfield(L, -3, h->section);
 777         }
 778
 779         name = h->e.name;
 780         value = h->value ? h->value : "";
 781
 782         if (name) {
 783                 lua_getfield(L, -1, name);
 784
 785                 /* this delta is a list add operation */
 786                 if (h->cmd == UCI_CMD_LIST_ADD) {
 787                         /* there seems to be no table yet */
 788                         if (!lua_istable(L, -1)) {
 789                                 lua_newtable(L);
 790
 791                                 /* if there is a value on the stack already, add */
 792                                 if (!lua_isnil(L, -2)) {
 793                                         lua_pushvalue(L, -2);
 794                                         lua_rawseti(L, -2, 1);
 795                                         lua_pushstring(L, value);
 796                                         lua_rawseti(L, -2, 2);
 797
 798                                 /* this is the first table item */
 799                                 } else {
 800                                         lua_pushstring(L, value);
 801                                         lua_rawseti(L, -2, 1);
 802                                 }
 803
 804                                 lua_setfield(L, -3, name);
 805
 806                         /* a table is on the top of the stack and this is a subsequent,
 807                          * list_add, append this value to table */
 808                         } else {
 809                                 lua_pushstring(L, value);
 810                                 lua_rawseti(L, -2, lua_rawlen(L, -2) + 1);
 811                         }
 812
 813                 /* non-list change, simply set/replace field */
 814                 } else {
 815                         lua_pushstring(L, value);
 816                         lua_setfield(L, -3, name);
 817                 }
 818
 819                 lua_pop(L, 1);
 820         } else {
 821                 lua_pushstring(L, value);
 822                 lua_setfield(L, -2, ".type");
 823         }
 824
 825         lua_pop(L, 1);
 826 }
 827
 828 static void
 829 uci_lua_changes_pkg(lua_State *L, struct uci_context *ctx, const char *package)
 830 {
 831         struct uci_package *p = NULL;
 832         struct uci_element *e;
 833         bool autoload = false;
 834
 835         p = find_package(L, ctx, package, false);
 836         if (!p) {
 837                 autoload = true;
 838                 p = find_package(L, ctx, package, true);
 839                 if (!p)
 840                         return;
 841         }
 842
 843         if (uci_list_empty(&p->delta) && uci_list_empty(&p->saved_delta))
 844                 goto done;
 845
 846         lua_newtable(L);
 847         uci_foreach_element(&p->saved_delta, e) {
 848                 uci_lua_add_change(L, e);
 849         }
 850         uci_foreach_element(&p->delta, e) {
 851                 uci_lua_add_change(L, e);
 852         }
 853         lua_setfield(L, -2, p->e.name);
 854
 855 done:
 856         if (autoload)
 857                 uci_unload(ctx, p);
 858 }
 859
 860 static int
 861 uci_lua_changes(lua_State *L)
 862 {
 863         struct uci_context *ctx;
 864         const char *package = NULL;
 865         char **config = NULL;
 866         int nargs;
 867         int i, offset = 0;
 868
 869         ctx = find_context(L, &offset);
 870         nargs = lua_gettop(L);
 871         switch(nargs - offset) {
 872         case 1:
 873                 package = luaL_checkstring(L, 1 + offset);
 874         case 0:
 875                 break;
 876         default:
 877                 return luaL_error(L, "invalid argument count");
 878         }
 879
 880         lua_newtable(L);
 881         if (package) {
 882                 uci_lua_changes_pkg(L, ctx, package);
 883         } else {
 884                 if (uci_list_configs(ctx, &config) != 0)
 885                         goto done;
 886
 887                 for(i = 0; config[i] != NULL; i++) {
 888                         uci_lua_changes_pkg(L, ctx, config[i]);
 889                 }
 890         }
 891
 892 done:
 893         return 1;
 894 }
 895
 896 static int
 897 uci_lua_get_confdir(lua_State *L)
 898 {
 899         struct uci_context *ctx = find_context(L, NULL);
 900         lua_pushstring(L, ctx->confdir);
 901         return 1;
 902 }
 903
 904 static int
 905 uci_lua_set_confdir(lua_State *L)
 906 {
 907         struct uci_context *ctx;
 908         int offset = 0;
 909
 910         ctx = find_context(L, &offset);
 911         luaL_checkstring(L, 1 + offset);
 912         uci_set_confdir(ctx, lua_tostring(L, -1));
 913         return uci_push_status(L, ctx, false);
 914 }
 915
 916 static int
 917 uci_lua_get_savedir(lua_State *L)
 918 {
 919         struct uci_context *ctx = find_context(L, NULL);
 920         lua_pushstring(L, ctx->savedir);
 921         return 1;
 922 }
 923
 924 static int
 925 uci_lua_add_delta(lua_State *L)
 926 {
 927         struct uci_context *ctx;
 928         int offset = 0;
 929
 930         ctx = find_context(L, &offset);
 931         luaL_checkstring(L, 1 + offset);
 932         uci_add_delta_path(ctx, lua_tostring(L, -1));
 933         return uci_push_status(L, ctx, false);
 934 }
 935
 936 static int
 937 uci_lua_set_savedir(lua_State *L)
 938 {
 939         struct uci_context *ctx;
 940         int offset = 0;
 941
 942         ctx = find_context(L, &offset);
 943         luaL_checkstring(L, 1 + offset);
 944         uci_set_savedir(ctx, lua_tostring(L, -1));
 945         return uci_push_status(L, ctx, false);
 946 }
 947
 948 static int
 949 uci_lua_list_configs(lua_State *L)
 950 {
 951         struct uci_context *ctx;
 952         char **configs = NULL;
 953         char **ptr;
 954         int i = 1;
 955
 956         ctx = find_context(L, NULL);
 957         if ((uci_list_configs(ctx, &configs) != UCI_OK) || !configs)
 958                 return uci_push_status(L, ctx, false);
 959         lua_newtable(L);
 960         for (ptr = configs; *ptr; ptr++) {
 961                 lua_pushstring(L, *ptr);
 962                 lua_rawseti(L, -2, i++);
 963         }
 964         free(configs);
 965         return 1;
 966 }
 967
 968 static int
 969 uci_lua_gc(lua_State *L)
 970 {
 971         struct uci_context **ctx;
 972
 973         if (!lua_isuserdata(L, 1)) {
 974                 if (!global_ctx)
 975                         return 0;
 976                 ctx = &global_ctx;
 977         } else {
 978                 ctx = luaL_checkudata(L, 1, METANAME);
 979                 if (!*ctx)
 980                         return 0;
 981         }
 982         uci_free_context(*ctx);
 983         *ctx = NULL;
 984         return 0;
 985 }
 986
 987 static int
 988 uci_lua_cursor(lua_State *L)
 989 {
 990         struct uci_context **u;
 991         int argc = lua_gettop(L);
 992
 993         u = lua_newuserdata(L, sizeof(struct uci_context *));
 994         luaL_getmetatable(L, METANAME);
 995         lua_setmetatable(L, -2);
 996
 997         *u = uci_alloc_context();
 998         if (!*u)
 999                 return luaL_error(L, "Cannot allocate UCI context");
1000         switch (argc) {
1001                 case 2:
1002                         if (lua_isstring(L, 2) &&
1003                                 (uci_set_savedir(*u, luaL_checkstring(L, 2)) != UCI_OK))
1004                                 return luaL_error(L, "Unable to set savedir");
1005                         /* fall through */
1006                 case 1:
1007                         if (lua_isstring(L, 1) &&
1008                                 (uci_set_confdir(*u, luaL_checkstring(L, 1)) != UCI_OK))
1009                                 return luaL_error(L, "Unable to set savedir");
1010                         break;
1011                 default:
1012                         break;
1013         }
1014         return 1;
1015 }
1016
1017 static const luaL_Reg uci[] = {
1018         { "__gc", uci_lua_gc },
1019         { "close", uci_lua_gc },
1020         { "cursor", uci_lua_cursor },
1021         { "load", uci_lua_load },
1022         { "unload", uci_lua_unload },
1023         { "get", uci_lua_get },
1024         { "get_all", uci_lua_get_all },
1025         { "add", uci_lua_add },
1026         { "set", uci_lua_set },
1027         { "rename", uci_lua_rename },
1028         { "save", uci_lua_save },
1029         { "delete", uci_lua_delete },
1030         { "commit", uci_lua_commit },
1031         { "revert", uci_lua_revert },
1032         { "reorder", uci_lua_reorder },
1033         { "changes", uci_lua_changes },
1034         { "foreach", uci_lua_foreach },
1035         { "add_history", uci_lua_add_delta },
1036         { "add_delta", uci_lua_add_delta },
1037         { "get_confdir", uci_lua_get_confdir },
1038         { "set_confdir", uci_lua_set_confdir },
1039         { "get_savedir", uci_lua_get_savedir },
1040         { "set_savedir", uci_lua_set_savedir },
1041         { "list_configs", uci_lua_list_configs },
1042         { NULL, NULL },
1043 };
1044
1045
1046 int
1047 luaopen_uci(lua_State *L)
1048 {
1049         /* create metatable */
1050         luaL_newmetatable(L, METANAME);
1051
1052         /* metatable.__index = metatable */
1053         lua_pushvalue(L, -1);
1054         lua_setfield(L, -2, "__index");
1055
1056         /* fill metatable */
1057         luaL_setfuncs(L, uci, 0);
1058         lua_pop(L, 1);
1059
1060         /* create module */
1061         lua_newtable(L);
1062         lua_pushvalue(L, -1);
1063         luaL_setfuncs(L, uci, 0);
1064         lua_setglobal(L, MODNAME);
1065
1066         return 1;
1067 }