X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fuci.git;a=blobdiff_plain;f=lua%2Fuci.c;h=f98a9c97a4c256420889d5ea1f71ec365d5a4392;hp=0a751d677a7d6193d1aad1368de93c6535cf8736;hb=08889fee7780facfb6a1550372a6f78c3f885224;hpb=4837364113f30c793b373073d27508fec6234ed3 diff --git a/lua/uci.c b/lua/uci.c index 0a751d6..f98a9c9 100644 --- a/lua/uci.c +++ b/lua/uci.c @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -35,17 +36,35 @@ static struct uci_context *ctx = NULL; static struct uci_package * -find_package(const char *name) +find_package(lua_State *L, const char *name, bool autoload) { struct uci_package *p = NULL; struct uci_element *e; + uci_foreach_element(&ctx->root, e) { if (strcmp(e->name, name) != 0) continue; p = uci_to_package(e); - break; + goto done; + } + + if (autoload) { + 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); } + +done: return p; } @@ -62,15 +81,51 @@ done: lua_pop(L, 2); } +static void uci_push_section(lua_State *L, struct uci_section *s) +{ + struct uci_element *e; + + lua_newtable(L); + lua_pushstring(L, s->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"); + + uci_foreach_element(&s->options, e) { + struct uci_option *o = uci_to_option(e); + lua_pushstring(L, o->value); + lua_setfield(L, -2, o->e.name); + } + lua_pop(L, 1); +} + +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) { + 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_package *p; const char *s; - luaL_checkany(L, 1); + luaL_checkstring(L, 1); s = lua_tostring(L, -1); - p = find_package(s); + p = find_package(L, s, false); if (p) { uci_unload(ctx, p); lua_pushboolean(L, 1); @@ -100,43 +155,102 @@ uci_lua_load(lua_State *L) return 1; } + static int -uci_lua_get(lua_State *L) +uci_lua_foreach(lua_State *L) +{ + struct uci_package *p; + struct uci_element *e; + const char *package, *type; + bool ret = false; + + package = luaL_checkstring(L, 1); + + if (lua_isnil(L, 2)) + type = NULL; + else + type = luaL_checkstring(L, 2); + + if (!lua_isfunction(L, 3) || !package) + luaL_error(L, "Invalid argument"); + + p = find_package(L, package, true); + if (!p) + goto done; + + uci_foreach_element(&p->sections, e) { + struct uci_section *s = uci_to_section(e); + + 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) + ret = true; + } + +done: + lua_pushboolean(L, ret); + return 1; +} + +static int +uci_lua_get_any(lua_State *L, bool all) { - struct uci_lua_context *f; struct uci_element *e = NULL; struct uci_package *p = NULL; - char *package = NULL; - char *section = NULL; - char *option = NULL; + const char *package = NULL; + const char *section = NULL; + const char *option = NULL; char *s; int err = UCI_ERR_MEM; + int n; + + n = lua_gettop(L); - luaL_checkany(L, 1); - s = strdup(lua_tostring(L, -1)); + luaL_checkstring(L, 1); + s = strdup(lua_tostring(L, 1)); if (!s) goto error; - if ((err = uci_parse_tuple(ctx, s, &package, §ion, &option, NULL))) - 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 (section == NULL) { + if (!all && (section == NULL)) { err = UCI_ERR_INVAL; goto error; } - p = find_package(package); + p = find_package(L, package, true); if (!p) { err = UCI_ERR_NOTFOUND; goto error; } - if ((err = uci_lookup(ctx, &e, p, section, option))) - goto error; + if (section) { + if ((err = uci_lookup(ctx, &e, p, section, option))) + goto error; + } else { + e = &p->e; + } switch(e->type) { + case UCI_TYPE_PACKAGE: + uci_push_package(L, p); + break; case UCI_TYPE_SECTION: - lua_pushstring(L, uci_to_section(e)->type); + if (all) + uci_push_section(L, uci_to_section(e)); + else + lua_pushstring(L, uci_to_section(e)->type); break; case UCI_TYPE_OPTION: lua_pushstring(L, uci_to_option(e)->value); @@ -162,11 +276,229 @@ error: } } +static int +uci_lua_get(lua_State *L) +{ + return uci_lua_get_any(L, false); +} + +static int +uci_lua_get_all(lua_State *L) +{ + return uci_lua_get_any(L, true); +} + +static int +uci_lua_add(lua_State *L) +{ + struct uci_section *s = NULL; + struct uci_package *p; + const char *package; + const char *type; + const char *name = NULL; + + do { + package = luaL_checkstring(L, 1); + type = luaL_checkstring(L, 2); + p = find_package(L, package, true); + if (!p) + break; + + if (uci_add_section(ctx, p, type, &s) || !s) + break; + + name = s->e.name; + } while (0); + + lua_pushstring(L, name); + return 1; +} + +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; + int err = UCI_ERR_MEM; + int nargs; + + nargs = lua_gettop(L); + + s = luaL_checkstring(L, 1); + switch(nargs) { + 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 */ + case 3: + /* Format: uci.set("p", "s", "v") */ + package = s; + section = luaL_checkstring(L, 2); + value = luaL_checkstring(L, nargs); + break; + default: + err = UCI_ERR_INVAL; + goto error; + } + + if ((section == NULL) || (value == NULL)) { + err = UCI_ERR_INVAL; + goto error; + } + + p = find_package(L, package, true); + if (!p) { + err = UCI_ERR_NOTFOUND; + 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; +} + +enum pkg_cmd { + CMD_SAVE, + CMD_COMMIT, + CMD_REVERT +}; + +static int +uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd) +{ + struct uci_element *e, *tmp; + const char *s = NULL; + const char *section = NULL; + const char *option = NULL; + int failed = 0; + int nargs; + + 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; + } + + 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)) + continue; + + switch(cmd) { + case CMD_COMMIT: + ret = uci_commit(ctx, &p, false); + break; + case CMD_SAVE: + ret = uci_save(ctx, p); + break; + case CMD_REVERT: + ret = uci_revert(ctx, &p, section, option); + break; + } + + if (ret != 0) + failed = 1; + } + + lua_pushboolean(L, !failed); + return 1; +} + +static int +uci_lua_save(lua_State *L) +{ + return uci_lua_package_cmd(L, CMD_SAVE); +} + +static int +uci_lua_commit(lua_State *L) +{ + return uci_lua_package_cmd(L, CMD_COMMIT); +} + +static int +uci_lua_revert(lua_State *L) +{ + return uci_lua_package_cmd(L, CMD_REVERT); +} + +static int +uci_lua_set_confdir(lua_State *L) +{ + int ret; + + luaL_checkstring(L, 1); + ret = uci_set_confdir(ctx, lua_tostring(L, -1)); + lua_pushboolean(L, (ret == 0)); + return 1; +} + +static int +uci_lua_set_savedir(lua_State *L) +{ + int ret; + + luaL_checkstring(L, 1); + ret = uci_set_savedir(ctx, lua_tostring(L, -1)); + lua_pushboolean(L, (ret == 0)); + + return 1; +} static const luaL_Reg uci[] = { { "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 }, + { "save", uci_lua_save }, + { "commit", uci_lua_commit }, + { "revert", uci_lua_revert }, + { "foreach", uci_lua_foreach }, + { "set_confdir", uci_lua_set_confdir }, + { "set_savedir", uci_lua_set_savedir }, { NULL, NULL }, }; @@ -178,5 +510,12 @@ luaopen_uci(lua_State *L) if (!ctx) luaL_error(L, "Cannot allocate UCI context\n"); luaL_register(L, MODNAME, uci); + + /* enable autoload by default */ + lua_getfield(L, LUA_GLOBALSINDEX, "uci"); + lua_pushboolean(L, 1); + lua_setfield(L, -2, "autoload"); + lua_pop(L, 1); + return 0; }