X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fuci.git;a=blobdiff_plain;f=lua%2Fuci.c;h=ac04c11ca6dc628584755ca4e5f1b92b9292f3a3;hp=f2be5d5ca3bba253b29865e9045b3d91d79d8124;hb=ef5f4ae3252cb067db9d73afca3f5f72c72126d0;hpb=b809dbd44309be056a7ce96b18a418fb51641cce diff --git a/lua/uci.c b/lua/uci.c index f2be5d5..ac04c11 100644 --- a/lua/uci.c +++ b/lua/uci.c @@ -25,6 +25,7 @@ #include #define MODNAME "uci" +#define METANAME MODNAME ".meta" //#define DEBUG 1 #ifdef DEBUG @@ -33,18 +34,54 @@ #define DPRINTF(...) do {} while (0) #endif -static struct uci_context *ctx = NULL; -enum autoload { - AUTOLOAD_OFF = 0, - AUTOLOAD_ON = 1, - AUTOLOAD_FORCE = 2 -}; +static struct uci_context *global_ctx = NULL; + +static struct uci_context * +find_context(lua_State *L, int *offset) +{ + struct uci_context **ctx; + if (!lua_isuserdata(L, 1)) { + if (!global_ctx) { + global_ctx = uci_alloc_context(); + if (!global_ctx) { + luaL_error(L, "failed to allocate UCI context"); + return NULL; + } + } + if (offset) + *offset = 0; + return global_ctx; + } + if (offset) + *offset = 1; + ctx = luaL_checkudata(L, 1, METANAME); + if (!ctx || !*ctx) { + luaL_error(L, "failed to get UCI context"); + return NULL; + } + + return *ctx; +} static struct uci_package * -find_package(lua_State *L, const char *name, enum autoload al) +find_package(lua_State *L, struct uci_context *ctx, const char *str, bool al) { struct uci_package *p = NULL; struct uci_element *e; + char *sep; + char *name; + + sep = strchr(str, '.'); + if (sep) { + name = malloc(1 + sep - str); + if (!name) { + luaL_error(L, "out of memory"); + return NULL; + } + strncpy(name, str, sep - str); + name[sep - str] = 0; + } else + name = (char *) str; uci_foreach_element(&ctx->root, e) { if (strcmp(e->name, name) != 0) @@ -54,88 +91,158 @@ find_package(lua_State *L, const char *name, enum autoload al) goto done; } - if (al == AUTOLOAD_FORCE) + if (al == true) uci_load(ctx, name, &p); else if (al) { - do { - lua_getfield(L, LUA_GLOBALSINDEX, "uci"); - lua_getfield(L, -1, "autoload"); - if (!lua_isboolean(L, -1)) - break; - - if (!lua_toboolean(L, -1)) - break; - - uci_load(ctx, name, &p); - } while (0); - lua_pop(L, 2); + uci_load(ctx, name, &p); } done: + if (name != str) + free(name); return p; } -static void uci_lua_perror(lua_State *L, char *name) +static int +lookup_args(lua_State *L, struct uci_context *ctx, int offset, struct uci_ptr *ptr, char **buf) { - lua_getfield(L, LUA_GLOBALSINDEX, "uci"); - lua_getfield(L, -1, "warn"); - if (!lua_isboolean(L, -1)) - goto done; - if (lua_toboolean(L, -1) != 1) - goto done; - uci_perror(ctx, name); -done: - lua_pop(L, 2); + char *s = NULL; + int n; + + n = lua_gettop(L); + luaL_checkstring(L, 1 + offset); + s = strdup(lua_tostring(L, 1 + offset)); + if (!s) + goto error; + + memset(ptr, 0, sizeof(struct uci_ptr)); + if (!find_package(L, ctx, s, true)) + goto error; + + switch (n - offset) { + case 4: + case 3: + ptr->option = luaL_checkstring(L, 3 + offset); + /* fall through */ + case 2: + ptr->section = luaL_checkstring(L, 2 + offset); + ptr->package = luaL_checkstring(L, 1 + offset); + if (uci_lookup_ptr(ctx, ptr, NULL, true) != UCI_OK) + goto error; + break; + case 1: + if (uci_lookup_ptr(ctx, ptr, s, true) != UCI_OK) + goto error; + break; + default: + luaL_error(L, "invalid argument count"); + goto error; + } + + *buf = s; + return 0; + +error: + if (s) + free(s); + return 1; } -static void uci_push_section(lua_State *L, struct uci_section *s) +static int +uci_push_status(lua_State *L, struct uci_context *ctx, bool hasarg) +{ + char *str = NULL; + + if (!hasarg) + lua_pushboolean(L, (ctx->err == UCI_OK)); + if (ctx->err) { + uci_get_errorstr(ctx, &str, MODNAME); + if (str) { + lua_pushstring(L, str); + free(str); + return 2; + } + } + return 1; +} + +static void +uci_push_option(lua_State *L, struct uci_option *o) +{ + struct uci_element *e; + int i = 0; + + switch(o->type) { + case UCI_TYPE_STRING: + lua_pushstring(L, o->v.string); + break; + case UCI_TYPE_LIST: + lua_newtable(L); + uci_foreach_element(&o->v.list, e) { + i++; + lua_pushstring(L, e->name); + lua_rawseti(L, -2, i); + } + break; + default: + lua_pushnil(L); + break; + } +} + +static void +uci_push_section(lua_State *L, struct uci_section *s, int index) { struct uci_element *e; lua_newtable(L); + lua_pushboolean(L, s->anonymous); + lua_setfield(L, -2, ".anonymous"); lua_pushstring(L, s->type); - lua_setfield(L, -2, "type"); + lua_setfield(L, -2, ".type"); lua_pushstring(L, s->e.name); - lua_setfield(L, -2, "name"); - - lua_newtable(L); - lua_pushvalue(L, -1); - lua_setfield(L, -3, "options"); + lua_setfield(L, -2, ".name"); + if (index >= 0) { + lua_pushinteger(L, index); + lua_setfield(L, -2, ".index"); + } uci_foreach_element(&s->options, e) { struct uci_option *o = uci_to_option(e); - lua_pushstring(L, o->value); + uci_push_option(L, o); lua_setfield(L, -2, o->e.name); } - lua_pop(L, 1); } -static void uci_push_package(lua_State *L, struct uci_package *p) +static void +uci_push_package(lua_State *L, struct uci_package *p) { struct uci_element *e; int i = 0; lua_newtable(L); uci_foreach_element(&p->sections, e) { + uci_push_section(L, uci_to_section(e), i); + lua_setfield(L, -2, e->name); i++; - luaL_setn(L, -1, i); - uci_push_section(L, uci_to_section(e)); - lua_rawseti(L, -2, i); } } static int uci_lua_unload(lua_State *L) { + struct uci_context *ctx; struct uci_package *p; const char *s; + int offset = 0; - luaL_checkstring(L, 1); - s = lua_tostring(L, -1); - p = find_package(L, s, AUTOLOAD_OFF); + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + s = lua_tostring(L, 1 + offset); + p = find_package(L, ctx, s, false); if (p) { uci_unload(ctx, p); - lua_pushboolean(L, 1); + return uci_push_status(L, ctx, false); } else { lua_pushboolean(L, 0); } @@ -145,56 +252,67 @@ uci_lua_unload(lua_State *L) static int uci_lua_load(lua_State *L) { + struct uci_context *ctx; struct uci_package *p = NULL; const char *s; + int offset = 0; + ctx = find_context(L, &offset); uci_lua_unload(L); lua_pop(L, 1); /* bool ret value of unload */ s = lua_tostring(L, -1); - if (uci_load(ctx, s, &p)) { - uci_lua_perror(L, "uci.load"); - lua_pushboolean(L, 0); - } else { - lua_pushboolean(L, 1); - } - - return 1; + uci_load(ctx, s, &p); + return uci_push_status(L, ctx, false); } static int uci_lua_foreach(lua_State *L) { + struct uci_context *ctx; struct uci_package *p; - struct uci_element *e; + struct uci_element *e, *tmp; const char *package, *type; bool ret = false; + int offset = 0; + int i = 0; - package = luaL_checkstring(L, 1); + ctx = find_context(L, &offset); + package = luaL_checkstring(L, 1 + offset); if (lua_isnil(L, 2)) type = NULL; else - type = luaL_checkstring(L, 2); + type = luaL_checkstring(L, 2 + offset); - if (!lua_isfunction(L, 3) || !package) - luaL_error(L, "Invalid argument"); + if (!lua_isfunction(L, 3 + offset) || !package) + return luaL_error(L, "Invalid argument"); - p = find_package(L, package, AUTOLOAD_ON); + p = find_package(L, ctx, package, true); if (!p) goto done; - uci_foreach_element(&p->sections, e) { + uci_foreach_element_safe(&p->sections, tmp, e) { struct uci_section *s = uci_to_section(e); + i++; + if (type && (strcmp(s->type, type) != 0)) continue; - lua_pushvalue(L, 3); /* iterator function */ - uci_push_section(L, s); - if (lua_pcall(L, 1, 0, 0) == 0) + lua_pushvalue(L, 3 + offset); /* iterator function */ + uci_push_section(L, s, i - 1); + if (lua_pcall(L, 1, 1, 0) == 0) { ret = true; + if (lua_isboolean(L, -1) && !lua_toboolean(L, -1)) + break; + } + else + { + lua_error(L); + break; + } } done: @@ -205,82 +323,56 @@ done: static int uci_lua_get_any(lua_State *L, bool all) { + struct uci_context *ctx; struct uci_element *e = NULL; - struct uci_package *p = NULL; - const char *package = NULL; - const char *section = NULL; - const char *option = NULL; - char *s; - int err = UCI_ERR_MEM; - int n; + struct uci_ptr ptr; + int offset = 0; + char *s = NULL; + int err = UCI_ERR_NOTFOUND; - n = lua_gettop(L); + ctx = find_context(L, &offset); - luaL_checkstring(L, 1); - s = strdup(lua_tostring(L, 1)); - if (!s) + if (lookup_args(L, ctx, offset, &ptr, &s)) goto error; - if (n > 1) { - package = luaL_checkstring(L, 1); - section = luaL_checkstring(L, 2); - if (n > 2) - option = luaL_checkstring(L, 3); - } else { - if ((err = uci_parse_tuple(ctx, s, (char **) &package, (char **) §ion, (char **) &option, NULL))) - goto error; - } - - if (!all && (section == NULL)) { + uci_lookup_ptr(ctx, &ptr, NULL, true); + if (!all && !ptr.s) { err = UCI_ERR_INVAL; goto error; } - - p = find_package(L, package, AUTOLOAD_ON); - if (!p) { + if (!(ptr.flags & UCI_LOOKUP_COMPLETE)) { err = UCI_ERR_NOTFOUND; goto error; } - if (section) { - if ((err = uci_lookup(ctx, &e, p, section, option))) - goto error; - } else { - e = &p->e; - } - + err = UCI_OK; + e = ptr.last; switch(e->type) { case UCI_TYPE_PACKAGE: - uci_push_package(L, p); + uci_push_package(L, ptr.p); break; case UCI_TYPE_SECTION: if (all) - uci_push_section(L, uci_to_section(e)); + uci_push_section(L, ptr.s, -1); else - lua_pushstring(L, uci_to_section(e)->type); + lua_pushstring(L, ptr.s->type); break; case UCI_TYPE_OPTION: - lua_pushstring(L, uci_to_option(e)->value); + uci_push_option(L, ptr.o); break; default: err = UCI_ERR_INVAL; goto error; } + if (!err) + return 1; + error: if (s) free(s); - switch(err) { - default: - ctx->err = err; - uci_lua_perror(L, "uci.get"); - /* fall through */ - case UCI_ERR_NOTFOUND: - lua_pushnil(L); - /* fall through */ - case 0: - return 1; - } + lua_pushnil(L); + return uci_push_status(L, ctx, true); } static int @@ -298,137 +390,233 @@ uci_lua_get_all(lua_State *L) static int uci_lua_add(lua_State *L) { + struct uci_context *ctx; struct uci_section *s = NULL; struct uci_package *p; const char *package; const char *type; const char *name = NULL; + int offset = 0; - do { - package = luaL_checkstring(L, 1); - type = luaL_checkstring(L, 2); - p = find_package(L, package, AUTOLOAD_ON); - if (!p) - break; - - if (uci_add_section(ctx, p, type, &s) || !s) - break; + ctx = find_context(L, &offset); + package = luaL_checkstring(L, 1 + offset); + type = luaL_checkstring(L, 2 + offset); + p = find_package(L, ctx, package, true); + if (!p) + goto fail; - name = s->e.name; - } while (0); + if (uci_add_section(ctx, p, type, &s) || !s) + goto fail; + name = s->e.name; lua_pushstring(L, name); return 1; + +fail: + lua_pushnil(L); + return uci_push_status(L, ctx, true); } static int uci_lua_delete(lua_State *L) { - const char *package = NULL; - const char *section = NULL; - const char *option = NULL; - struct uci_package *p; - const char *s; + struct uci_context *ctx; + struct uci_ptr ptr; + int offset = 0; + char *s = NULL; + + ctx = find_context(L, &offset); + + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; + + uci_delete(ctx, &ptr); + +error: + if (s) + free(s); + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_rename(lua_State *L) +{ + struct uci_context *ctx; + struct uci_ptr ptr; int err = UCI_ERR_MEM; - int nargs; + char *s = NULL; + int nargs, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); - s = luaL_checkstring(L, 1); - switch(nargs) { + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; + + switch(nargs - offset) { case 1: - /* Format: uci.delete("p.s[.o]") */ - s = strdup(s); - if (!s) - goto error; + /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */ + break; + case 4: + /* Format: uci.set("p", "s", "o", "v") */ + ptr.value = luaL_checkstring(L, nargs); + break; + case 3: + /* Format: uci.set("p", "s", "v") */ + ptr.value = ptr.option; + ptr.option = NULL; + break; + default: + err = UCI_ERR_INVAL; + goto error; + } - if ((err = uci_parse_tuple(ctx, (char *) s, (char **) &package, (char **) §ion, (char **) &option, NULL))) + err = uci_lookup_ptr(ctx, &ptr, NULL, true); + if (err) + goto error; + + if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) { + err = UCI_ERR_INVAL; + goto error; + } + + err = uci_rename(ctx, &ptr); + if (err) + goto error; + +error: + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_reorder(lua_State *L) +{ + struct uci_context *ctx; + struct uci_ptr ptr; + int err = UCI_ERR_MEM; + char *s = NULL; + int nargs, offset = 0; + + ctx = find_context(L, &offset); + nargs = lua_gettop(L); + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; + + switch(nargs - offset) { + case 1: + /* Format: uci.set("p.s=v") or uci.set("p.s=v") */ + if (ptr.option) { + err = UCI_ERR_INVAL; goto error; + } break; case 3: - /* Format: uci.delete("p", "s", "o") */ - option = luaL_checkstring(L, 3); - /* fall through */ - case 2: - /* Format: uci.delete("p", "s") */ - section = luaL_checkstring(L, 2); - package = s; + /* Format: uci.set("p", "s", "v") */ + ptr.value = ptr.option; + ptr.option = NULL; break; default: err = UCI_ERR_INVAL; goto error; } - p = find_package(L, package, AUTOLOAD_ON); - if (!p) { - err = UCI_ERR_NOTFOUND; + err = uci_lookup_ptr(ctx, &ptr, NULL, true); + if (err) + goto error; + + if ((ptr.s == NULL) || (ptr.value == NULL)) { + err = UCI_ERR_INVAL; goto error; } - err = uci_delete(ctx, p, section, option); -error: + err = uci_reorder_section(ctx, ptr.s, strtoul(ptr.value, NULL, 10)); if (err) - uci_lua_perror(L, "uci.set"); - lua_pushboolean(L, (err == 0)); - return 1; + goto error; + +error: + return uci_push_status(L, ctx, false); } + static int uci_lua_set(lua_State *L) { - struct uci_package *p; - const char *package = NULL; - const char *section = NULL; - const char *option = NULL; - const char *value = NULL; - const char *s; + struct uci_context *ctx; + struct uci_ptr ptr; + bool istable = false; int err = UCI_ERR_MEM; - int nargs; + char *s = NULL; + int i, nargs, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; - s = luaL_checkstring(L, 1); - switch(nargs) { + switch(nargs - offset) { case 1: /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */ - s = strdup(s); - if (!s) - goto error; - - if ((err = uci_parse_tuple(ctx, (char *) s, (char **) &package, (char **) §ion, (char **) &option, (char **) &value))) - goto error; break; case 4: /* Format: uci.set("p", "s", "o", "v") */ - option = luaL_checkstring(L, 3); - /* fall through */ + if (lua_istable(L, nargs)) { + if (lua_objlen(L, nargs) < 1) + return luaL_error(L, "Cannot set an uci option to an empty table value"); + lua_rawgeti(L, nargs, 1); + ptr.value = luaL_checkstring(L, -1); + lua_pop(L, 1); + istable = true; + } else { + ptr.value = luaL_checkstring(L, nargs); + } + break; case 3: /* Format: uci.set("p", "s", "v") */ - package = s; - section = luaL_checkstring(L, 2); - value = luaL_checkstring(L, nargs); + ptr.value = ptr.option; + ptr.option = NULL; break; default: err = UCI_ERR_INVAL; goto error; } - if ((section == NULL) || (value == NULL)) { + err = uci_lookup_ptr(ctx, &ptr, NULL, true); + if (err) + goto error; + + if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) { err = UCI_ERR_INVAL; goto error; } - p = find_package(L, package, AUTOLOAD_ON); - if (!p) { - err = UCI_ERR_NOTFOUND; - goto error; + if (istable) { + if (lua_objlen(L, nargs) == 1) { + i = 1; + if (ptr.o) + err = uci_delete(ctx, &ptr); + } else { + i = 2; + err = uci_set(ctx, &ptr); + if (err) + goto error; + } + + for (; i <= lua_objlen(L, nargs); i++) { + lua_rawgeti(L, nargs, i); + ptr.value = luaL_checkstring(L, -1); + err = uci_add_list(ctx, &ptr); + lua_pop(L, 1); + if (err) + goto error; + } + } else { + err = uci_set(ctx, &ptr); + if (err) + goto error; } - err = uci_set(ctx, p, section, option, value, NULL); + error: - if (err) - uci_lua_perror(L, "uci.set"); - lua_pushboolean(L, (err == 0)); - return 1; + return uci_push_status(L, ctx, false); } enum pkg_cmd { @@ -440,67 +628,44 @@ enum pkg_cmd { static int uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd) { + struct uci_context *ctx; struct uci_element *e, *tmp; - const char *s = NULL; - const char *section = NULL; - const char *option = NULL; - int failed = 0; - int nargs; + struct uci_ptr ptr; + char *s = NULL; + int nargs, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); - switch(nargs) { - case 3: - if (cmd != CMD_REVERT) - goto err; - luaL_checkstring(L, 1); - option = lua_tostring(L, -1); - lua_pop(L, 1); - /* fall through */ - case 2: - if (cmd != CMD_REVERT) - goto err; - luaL_checkstring(L, 1); - section = lua_tostring(L, -1); - lua_pop(L, 1); - /* fall through */ - case 1: - luaL_checkstring(L, 1); - s = lua_tostring(L, -1); - lua_pop(L, 1); - break; - case 0: - break; - default: - err: - luaL_error(L, "Invalid argument count"); - break; - } + if ((cmd != CMD_REVERT) && (nargs - offset > 1)) + goto err; + + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto err; + + uci_lookup_ptr(ctx, &ptr, NULL, true); uci_foreach_element_safe(&ctx->root, tmp, e) { struct uci_package *p = uci_to_package(e); - int ret = UCI_ERR_INVAL; - if (s && (strcmp(s, e->name) != 0)) + if (ptr.p && (ptr.p != p)) continue; + ptr.p = p; switch(cmd) { case CMD_COMMIT: - ret = uci_commit(ctx, &p, false); + uci_commit(ctx, &p, false); break; case CMD_SAVE: - ret = uci_save(ctx, p); + uci_save(ctx, p); break; case CMD_REVERT: - ret = uci_revert(ctx, &p, section, option); + uci_revert(ctx, &ptr); break; } - - if (ret != 0) - failed = 1; } - lua_pushboolean(L, !failed); - return 1; +err: + return uci_push_status(L, ctx, false); } static int @@ -524,53 +689,82 @@ uci_lua_revert(lua_State *L) static void uci_lua_add_change(lua_State *L, struct uci_element *e) { - struct uci_history *h; + struct uci_delta *h; const char *name; + const char *value; - h = uci_to_history(e); + h = uci_to_delta(e); if (!h->section) return; lua_getfield(L, -1, h->section); if (lua_isnil(L, -1)) { lua_pop(L, 1); - lua_createtable(L, 0, 0); + lua_newtable(L); lua_pushvalue(L, -1); /* copy for setfield */ lua_setfield(L, -3, h->section); } - name = (h->e.name ? h->e.name : ".TYPE"); - if (h->value) - lua_pushstring(L, h->value); - else - lua_pushstring(L, ""); - lua_setfield(L, -2, name); + name = h->e.name; + value = h->value ? h->value : ""; + + if (name) { + lua_getfield(L, -1, name); + + /* there seems to be no value yet so simply push it as string */ + if (lua_isnil(L, -1)) { + lua_pushstring(L, value); + lua_setfield(L, -3, name); + + /* there is already a value, so this change is a list_add, + * coerce string into one-element array and append new value */ + } else if (lua_isstring(L, -1)) { + lua_newtable(L); + lua_pushvalue(L, -2); + lua_rawseti(L, -2, 1); + lua_pushstring(L, value); + lua_rawseti(L, -2, 2); + lua_setfield(L, -3, name); + + /* a table is on the top of the stack so this is a subsequent, + * list_add, append this value to table */ + } else if (lua_istable(L, -1)) { + lua_pushstring(L, value); + lua_rawseti(L, -2, lua_objlen(L, -2) + 1); + } + + lua_pop(L, 1); + } else { + lua_pushstring(L, value); + lua_setfield(L, -2, ".type"); + } + lua_pop(L, 1); } static void -uci_lua_changes_pkg(lua_State *L, const char *package) +uci_lua_changes_pkg(lua_State *L, struct uci_context *ctx, const char *package) { struct uci_package *p = NULL; struct uci_element *e; bool autoload = false; - p = find_package(L, package, AUTOLOAD_OFF); + p = find_package(L, ctx, package, false); if (!p) { autoload = true; - p = find_package(L, package, AUTOLOAD_FORCE); + p = find_package(L, ctx, package, true); if (!p) return; } - if (uci_list_empty(&p->history) && uci_list_empty(&p->saved_history)) + if (uci_list_empty(&p->delta) && uci_list_empty(&p->saved_delta)) goto done; - lua_createtable(L, 0, 0); - uci_foreach_element(&p->saved_history, e) { + lua_newtable(L); + uci_foreach_element(&p->saved_delta, e) { uci_lua_add_change(L, e); } - uci_foreach_element(&p->history, e) { + uci_foreach_element(&p->delta, e) { uci_lua_add_change(L, e); } lua_setfield(L, -2, p->e.name); @@ -583,30 +777,32 @@ done: static int uci_lua_changes(lua_State *L) { + struct uci_context *ctx; const char *package = NULL; char **config = NULL; int nargs; - int i; + int i, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); - switch(nargs) { + switch(nargs - offset) { case 1: - package = luaL_checkstring(L, 1); + package = luaL_checkstring(L, 1 + offset); case 0: break; default: - luaL_error(L, "invalid argument count"); + return luaL_error(L, "invalid argument count"); } - lua_createtable(L, 0, 0); + lua_newtable(L); if (package) { - uci_lua_changes_pkg(L, package); + uci_lua_changes_pkg(L, ctx, package); } else { if (uci_list_configs(ctx, &config) != 0) goto done; for(i = 0; config[i] != NULL; i++) { - uci_lua_changes_pkg(L, config[i]); + uci_lua_changes_pkg(L, ctx, config[i]); } } @@ -615,42 +811,132 @@ done: } static int +uci_lua_get_confdir(lua_State *L) +{ + struct uci_context *ctx = find_context(L, NULL); + lua_pushstring(L, ctx->confdir); + return 1; +} + +static int uci_lua_set_confdir(lua_State *L) { - int ret; + struct uci_context *ctx; + int offset = 0; - luaL_checkstring(L, 1); - ret = uci_set_confdir(ctx, lua_tostring(L, -1)); - lua_pushboolean(L, (ret == 0)); + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + uci_set_confdir(ctx, lua_tostring(L, -1)); + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_get_savedir(lua_State *L) +{ + struct uci_context *ctx = find_context(L, NULL); + lua_pushstring(L, ctx->savedir); return 1; } static int +uci_lua_add_delta(lua_State *L) +{ + struct uci_context *ctx; + int offset = 0; + + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + uci_add_delta_path(ctx, lua_tostring(L, -1)); + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_load_plugins(lua_State *L) +{ + struct uci_context *ctx; + int offset = 0; + const char *str = NULL; + + ctx = find_context(L, &offset); + if (lua_isstring(L, -1)) + str = lua_tostring(L, -1); + uci_load_plugins(ctx, str); + return uci_push_status(L, ctx, false); +} + +static int uci_lua_set_savedir(lua_State *L) { - int ret; + struct uci_context *ctx; + int offset = 0; - luaL_checkstring(L, 1); - ret = uci_set_savedir(ctx, lua_tostring(L, -1)); - lua_pushboolean(L, (ret == 0)); + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + uci_set_savedir(ctx, lua_tostring(L, -1)); + return uci_push_status(L, ctx, false); +} +static int +uci_lua_gc(lua_State *L) +{ + struct uci_context *ctx = find_context(L, NULL); + uci_free_context(ctx); + return 0; +} + +static int +uci_lua_cursor(lua_State *L) +{ + struct uci_context **u; + int argc = lua_gettop(L); + + u = lua_newuserdata(L, sizeof(struct uci_context *)); + luaL_getmetatable(L, METANAME); + lua_setmetatable(L, -2); + + *u = uci_alloc_context(); + if (!*u) + return luaL_error(L, "Cannot allocate UCI context"); + switch (argc) { + case 2: + if (lua_isstring(L, 2) && + (uci_set_savedir(*u, luaL_checkstring(L, 2)) != UCI_OK)) + return luaL_error(L, "Unable to set savedir"); + /* fall through */ + case 1: + if (lua_isstring(L, 1) && + (uci_set_confdir(*u, luaL_checkstring(L, 1)) != UCI_OK)) + return luaL_error(L, "Unable to set savedir"); + break; + default: + break; + } return 1; } static const luaL_Reg uci[] = { + { "__gc", uci_lua_gc }, + { "cursor", uci_lua_cursor }, { "load", uci_lua_load }, { "unload", uci_lua_unload }, { "get", uci_lua_get }, { "get_all", uci_lua_get_all }, { "add", uci_lua_add }, { "set", uci_lua_set }, + { "rename", uci_lua_rename }, { "save", uci_lua_save }, { "delete", uci_lua_delete }, { "commit", uci_lua_commit }, { "revert", uci_lua_revert }, + { "reorder", uci_lua_reorder }, { "changes", uci_lua_changes }, { "foreach", uci_lua_foreach }, + { "add_history", uci_lua_add_delta }, + { "add_delta", uci_lua_add_delta }, + { "load_plugins", uci_lua_load_plugins }, + { "get_confdir", uci_lua_get_confdir }, { "set_confdir", uci_lua_set_confdir }, + { "get_savedir", uci_lua_get_savedir }, { "set_savedir", uci_lua_set_savedir }, { NULL, NULL }, }; @@ -659,16 +945,19 @@ static const luaL_Reg uci[] = { int luaopen_uci(lua_State *L) { - ctx = uci_alloc_context(); - if (!ctx) - luaL_error(L, "Cannot allocate UCI context\n"); - luaL_register(L, MODNAME, uci); + /* create metatable */ + luaL_newmetatable(L, METANAME); - /* enable autoload by default */ - lua_getfield(L, LUA_GLOBALSINDEX, "uci"); - lua_pushboolean(L, 1); - lua_setfield(L, -2, "autoload"); + /* metatable.__index = metatable */ + lua_pushvalue(L, -1); + lua_setfield(L, -2, "__index"); + + /* fill metatable */ + luaL_register(L, NULL, uci); lua_pop(L, 1); + /* create module */ + luaL_register(L, MODNAME, uci); + return 0; }