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