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                                 free(s);
 625                                 return luaL_error(L, "Cannot set an uci option to an empty table value");
 626                         }
 627                         lua_rawgeti(L, nargs, 1);
 628                         ptr.value = luaL_checkstring(L, -1);
 629                         lua_pop(L, 1);
 630                         istable = true;
 631                 } else {
 632                         ptr.value = luaL_checkstring(L, nargs);
 633                 }
 634                 break;
 635         case 3:
 636                 /* Format: uci.set("p", "s", "v") */
 637                 ptr.value = ptr.option;
 638                 ptr.option = NULL;
 639                 break;
 640         default:
 641                 err = UCI_ERR_INVAL;
 642                 goto error;
 643         }
 644
 645         err = lookup_ptr(ctx, &ptr, NULL, true);
 646         if (err)
 647                 goto error;
 648
 649         if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) {
 650                 err = UCI_ERR_INVAL;
 651                 goto error;
 652         }
 653
 654         if (istable) {
 655                 if (lua_rawlen(L, nargs) == 1) {
 656                         i = 1;
 657                         if (ptr.o) {
 658                                 v = ptr.value;
 659                                 ptr.value = NULL;
 660                                 err = uci_delete(ctx, &ptr);
 661                                 if (err)
 662                                         goto error;
 663                                 ptr.value = v;
 664                         }
 665                 } else {
 666                         i = 2;
 667                         err = uci_set(ctx, &ptr);
 668                         if (err)
 669                                 goto error;
 670                 }
 671
 672                 for (; i <= lua_rawlen(L, nargs); i++) {
 673                         lua_rawgeti(L, nargs, i);
 674                         ptr.value = luaL_checkstring(L, -1);
 675                         err = uci_add_list(ctx, &ptr);
 676                         lua_pop(L, 1);
 677                         if (err)
 678                                 goto error;
 679                 }
 680         } else {
 681                 err = uci_set(ctx, &ptr);
 682                 if (err)
 683                         goto error;
 684         }
 685
 686
 687 error:
 688         if (s)
 689                 free(s);
 690         return uci_push_status(L, ctx, false);
 691 }
 692
 693 enum pkg_cmd {
 694         CMD_SAVE,
 695         CMD_COMMIT,
 696         CMD_REVERT
 697 };
 698
 699 static int
 700 uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd)
 701 {
 702         struct uci_context *ctx;
 703         struct uci_element *e, *tmp;
 704         struct uci_ptr ptr;
 705         char *s = NULL;
 706         int nargs, offset = 0;
 707
 708         ctx = find_context(L, &offset);
 709         nargs = lua_gettop(L);
 710         if ((cmd != CMD_REVERT) && (nargs - offset > 1))
 711                 goto err;
 712
 713         if (lookup_args(L, ctx, offset, &ptr, &s))
 714                 goto err;
 715
 716         lookup_ptr(ctx, &ptr, NULL, true);
 717
 718         uci_foreach_element_safe(&ctx->root, tmp, e) {
 719                 struct uci_package *p = uci_to_package(e);
 720
 721                 if (ptr.p && (ptr.p != p))
 722                         continue;
 723
 724                 ptr.p = p;
 725                 switch(cmd) {
 726                 case CMD_COMMIT:
 727                         uci_commit(ctx, &p, false);
 728                         break;
 729                 case CMD_SAVE:
 730                         uci_save(ctx, p);
 731                         break;
 732                 case CMD_REVERT:
 733                         uci_revert(ctx, &ptr);
 734                         break;
 735                 }
 736         }
 737
 738 err:
 739         if (s)
 740                 free(s);
 741         return uci_push_status(L, ctx, false);
 742 }
 743
 744 static int
 745 uci_lua_save(lua_State *L)
 746 {
 747         return uci_lua_package_cmd(L, CMD_SAVE);
 748 }
 749
 750 static int
 751 uci_lua_commit(lua_State *L)
 752 {
 753         return uci_lua_package_cmd(L, CMD_COMMIT);
 754 }
 755
 756 static int
 757 uci_lua_revert(lua_State *L)
 758 {
 759         return uci_lua_package_cmd(L, CMD_REVERT);
 760 }
 761
 762 static void
 763 uci_lua_add_change(lua_State *L, struct uci_element *e)
 764 {
 765         struct uci_delta *h;
 766         const char *name;
 767         const char *value;
 768
 769         h = uci_to_delta(e);
 770         if (!h->section)
 771                 return;
 772
 773         lua_getfield(L, -1, h->section);
 774         if (lua_isnil(L, -1)) {
 775                 lua_pop(L, 1);
 776                 lua_newtable(L);
 777                 lua_pushvalue(L, -1); /* copy for setfield */
 778                 lua_setfield(L, -3, h->section);
 779         }
 780
 781         name = h->e.name;
 782         value = h->value ? h->value : "";
 783
 784         if (name) {
 785                 lua_getfield(L, -1, name);
 786
 787                 /* this delta is a list add operation */
 788                 if (h->cmd == UCI_CMD_LIST_ADD) {
 789                         /* there seems to be no table yet */
 790                         if (!lua_istable(L, -1)) {
 791                                 lua_newtable(L);
 792
 793                                 /* if there is a value on the stack already, add */
 794                                 if (!lua_isnil(L, -2)) {
 795                                         lua_pushvalue(L, -2);
 796                                         lua_rawseti(L, -2, 1);
 797                                         lua_pushstring(L, value);
 798                                         lua_rawseti(L, -2, 2);
 799
 800                                 /* this is the first table item */
 801                                 } else {
 802                                         lua_pushstring(L, value);
 803                                         lua_rawseti(L, -2, 1);
 804                                 }
 805
 806                                 lua_setfield(L, -3, name);
 807
 808                         /* a table is on the top of the stack and this is a subsequent,
 809                          * list_add, append this value to table */
 810                         } else {
 811                                 lua_pushstring(L, value);
 812                                 lua_rawseti(L, -2, lua_rawlen(L, -2) + 1);
 813                         }
 814
 815                 /* non-list change, simply set/replace field */
 816                 } else {
 817                         lua_pushstring(L, value);
 818                         lua_setfield(L, -3, name);
 819                 }
 820
 821                 lua_pop(L, 1);
 822         } else {
 823                 lua_pushstring(L, value);
 824                 lua_setfield(L, -2, ".type");
 825         }
 826
 827         lua_pop(L, 1);
 828 }
 829
 830 static void
 831 uci_lua_changes_pkg(lua_State *L, struct uci_context *ctx, const char *package)
 832 {
 833         struct uci_package *p = NULL;
 834         struct uci_element *e;
 835         bool autoload = false;
 836
 837         p = find_package(L, ctx, package, false);
 838         if (!p) {
 839                 autoload = true;
 840                 p = find_package(L, ctx, package, true);
 841                 if (!p)
 842                         return;
 843         }
 844
 845         if (uci_list_empty(&p->delta) && uci_list_empty(&p->saved_delta))
 846                 goto done;
 847
 848         lua_newtable(L);
 849         uci_foreach_element(&p->saved_delta, e) {
 850                 uci_lua_add_change(L, e);
 851         }
 852         uci_foreach_element(&p->delta, e) {
 853                 uci_lua_add_change(L, e);
 854         }
 855         lua_setfield(L, -2, p->e.name);
 856
 857 done:
 858         if (autoload)
 859                 uci_unload(ctx, p);
 860 }
 861
 862 static int
 863 uci_lua_changes(lua_State *L)
 864 {
 865         struct uci_context *ctx;
 866         const char *package = NULL;
 867         char **config = NULL;
 868         int nargs;
 869         int i, offset = 0;
 870
 871         ctx = find_context(L, &offset);
 872         nargs = lua_gettop(L);
 873         switch(nargs - offset) {
 874         case 1:
 875                 package = luaL_checkstring(L, 1 + offset);
 876         case 0:
 877                 break;
 878         default:
 879                 return luaL_error(L, "invalid argument count");
 880         }
 881
 882         lua_newtable(L);
 883         if (package) {
 884                 uci_lua_changes_pkg(L, ctx, package);
 885                 return 1;
 886         }
 887
 888         if ((uci_list_configs(ctx, &config) != UCI_OK) || !config)
 889                 return 1;
 890
 891         for (i = 0; config[i] != NULL; i++) {
 892                 uci_lua_changes_pkg(L, ctx, config[i]);
 893         }
 894
 895         free(config);
 896         return 1;
 897 }
 898
 899 static int
 900 uci_lua_get_confdir(lua_State *L)
 901 {
 902         struct uci_context *ctx = find_context(L, NULL);
 903         lua_pushstring(L, ctx->confdir);
 904         return 1;
 905 }
 906
 907 static int
 908 uci_lua_set_confdir(lua_State *L)
 909 {
 910         struct uci_context *ctx;
 911         int offset = 0;
 912
 913         ctx = find_context(L, &offset);
 914         luaL_checkstring(L, 1 + offset);
 915         uci_set_confdir(ctx, lua_tostring(L, -1));
 916         return uci_push_status(L, ctx, false);
 917 }
 918
 919 static int
 920 uci_lua_get_savedir(lua_State *L)
 921 {
 922         struct uci_context *ctx = find_context(L, NULL);
 923         lua_pushstring(L, ctx->savedir);
 924         return 1;
 925 }
 926
 927 static int
 928 uci_lua_add_delta(lua_State *L)
 929 {
 930         struct uci_context *ctx;
 931         int offset = 0;
 932
 933         ctx = find_context(L, &offset);
 934         luaL_checkstring(L, 1 + offset);
 935         uci_add_delta_path(ctx, lua_tostring(L, -1));
 936         return uci_push_status(L, ctx, false);
 937 }
 938
 939 static int
 940 uci_lua_set_savedir(lua_State *L)
 941 {
 942         struct uci_context *ctx;
 943         int offset = 0;
 944
 945         ctx = find_context(L, &offset);
 946         luaL_checkstring(L, 1 + offset);
 947         uci_set_savedir(ctx, lua_tostring(L, -1));
 948         return uci_push_status(L, ctx, false);
 949 }
 950
 951 static int
 952 uci_lua_list_configs(lua_State *L)
 953 {
 954         struct uci_context *ctx;
 955         char **configs = NULL;
 956         char **ptr;
 957         int i = 1;
 958
 959         ctx = find_context(L, NULL);
 960         if ((uci_list_configs(ctx, &configs) != UCI_OK) || !configs)
 961                 return uci_push_status(L, ctx, false);
 962         lua_newtable(L);
 963         for (ptr = configs; *ptr; ptr++) {
 964                 lua_pushstring(L, *ptr);
 965                 lua_rawseti(L, -2, i++);
 966         }
 967         free(configs);
 968         return 1;
 969 }
 970
 971 static int
 972 uci_lua_gc(lua_State *L)
 973 {
 974         struct uci_context **ctx;
 975
 976         if (!lua_isuserdata(L, 1)) {
 977                 if (!global_ctx)
 978                         return 0;
 979                 ctx = &global_ctx;
 980         } else {
 981                 ctx = luaL_checkudata(L, 1, METANAME);
 982                 if (!*ctx)
 983                         return 0;
 984         }
 985         uci_free_context(*ctx);
 986         *ctx = NULL;
 987         return 0;
 988 }
 989
 990 static int
 991 uci_lua_cursor(lua_State *L)
 992 {
 993         struct uci_context **u;
 994         int argc = lua_gettop(L);
 995
 996         u = lua_newuserdata(L, sizeof(struct uci_context *));
 997         luaL_getmetatable(L, METANAME);
 998         lua_setmetatable(L, -2);
 999
1000         *u = uci_alloc_context();
1001         if (!*u)
1002                 return luaL_error(L, "Cannot allocate UCI context");
1003         switch (argc) {
1004                 case 2:
1005                         if (lua_isstring(L, 2) &&
1006                                 (uci_set_savedir(*u, luaL_checkstring(L, 2)) != UCI_OK))
1007                                 return luaL_error(L, "Unable to set savedir");
1008                         /* fall through */
1009                 case 1:
1010                         if (lua_isstring(L, 1) &&
1011                                 (uci_set_confdir(*u, luaL_checkstring(L, 1)) != UCI_OK))
1012                                 return luaL_error(L, "Unable to set confdir");
1013                         break;
1014                 default:
1015                         break;
1016         }
1017         return 1;
1018 }
1019
1020 static const luaL_Reg uci[] = {
1021         { "__gc", uci_lua_gc },
1022         { "close", uci_lua_gc },
1023         { "cursor", uci_lua_cursor },
1024         { "load", uci_lua_load },
1025         { "unload", uci_lua_unload },
1026         { "get", uci_lua_get },
1027         { "get_all", uci_lua_get_all },
1028         { "add", uci_lua_add },
1029         { "set", uci_lua_set },
1030         { "rename", uci_lua_rename },
1031         { "save", uci_lua_save },
1032         { "delete", uci_lua_delete },
1033         { "commit", uci_lua_commit },
1034         { "revert", uci_lua_revert },
1035         { "reorder", uci_lua_reorder },
1036         { "changes", uci_lua_changes },
1037         { "foreach", uci_lua_foreach },
1038         { "add_history", uci_lua_add_delta },
1039         { "add_delta", uci_lua_add_delta },
1040         { "get_confdir", uci_lua_get_confdir },
1041         { "set_confdir", uci_lua_set_confdir },
1042         { "get_savedir", uci_lua_get_savedir },
1043         { "set_savedir", uci_lua_set_savedir },
1044         { "list_configs", uci_lua_list_configs },
1045         { NULL, NULL },
1046 };
1047
1048
1049 int
1050 luaopen_uci(lua_State *L)
1051 {
1052         /* create metatable */
1053         luaL_newmetatable(L, METANAME);
1054
1055         /* metatable.__index = metatable */
1056         lua_pushvalue(L, -1);
1057         lua_setfield(L, -2, "__index");
1058
1059         /* fill metatable */
1060         luaL_setfuncs(L, uci, 0);
1061         lua_pop(L, 1);
1062
1063         /* create module */
1064         lua_newtable(L);
1065         lua_pushvalue(L, -1);
1066         luaL_setfuncs(L, uci, 0);
1067         lua_setglobal(L, MODNAME);
1068
1069         return 1;
1070 }