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 <stdlib.h>
  18 #include <string.h>
  19 #include <unistd.h>
  20 #include <stdio.h>
  21 #include <errno.h>
  22
  23 #include <lauxlib.h>
  24 #include <uci.h>
  25
  26 #define MODNAME        "uci"
  27 //#define DEBUG 1
  28
  29 #ifdef DEBUG
  30 #define DPRINTF(...) fprintf(stderr, __VA_ARGS__)
  31 #else
  32 #define DPRINTF(...) do {} while (0)
  33 #endif
  34
  35 static struct uci_context *ctx = NULL;
  36
  37 static struct uci_package *
  38 find_package(const char *name)
  39 {
  40         struct uci_package *p = NULL;
  41         struct uci_element *e;
  42         uci_foreach_element(&ctx->root, e) {
  43                 if (strcmp(e->name, name) != 0)
  44                         continue;
  45
  46                 p = uci_to_package(e);
  47                 break;
  48         }
  49         return p;
  50 }
  51
  52 static void uci_lua_perror(lua_State *L, char *name)
  53 {
  54         lua_getfield(L, LUA_GLOBALSINDEX, "uci");
  55         lua_getfield(L, -1, "warn");
  56         if (!lua_isboolean(L, -1))
  57                 goto done;
  58         if (lua_toboolean(L, -1) != 1)
  59                 goto done;
  60         uci_perror(ctx, name);
  61 done:
  62         lua_pop(L, 2);
  63 }
  64
  65 static int
  66 uci_lua_unload(lua_State *L)
  67 {
  68         struct uci_package *p;
  69         const char *s;
  70
  71         luaL_checkstring(L, 1);
  72         s = lua_tostring(L, -1);
  73         p = find_package(s);
  74         if (p) {
  75                 uci_unload(ctx, p);
  76                 lua_pushboolean(L, 1);
  77         } else {
  78                 lua_pushboolean(L, 0);
  79         }
  80         return 1;
  81 }
  82
  83 static int
  84 uci_lua_load(lua_State *L)
  85 {
  86         struct uci_package *p = NULL;
  87         const char *s;
  88
  89         uci_lua_unload(L);
  90         lua_pop(L, 1); /* bool ret value of unload */
  91         s = lua_tostring(L, -1);
  92
  93         if (uci_load(ctx, s, &p)) {
  94                 uci_lua_perror(L, "uci.load");
  95                 lua_pushboolean(L, 0);
  96         } else {
  97                 lua_pushboolean(L, 1);
  98         }
  99
 100         return 1;
 101 }
 102
 103 static int
 104 uci_lua_get(lua_State *L)
 105 {
 106         struct uci_element *e = NULL;
 107         struct uci_package *p = NULL;
 108         char *package = NULL;
 109         char *section = NULL;
 110         char *option = NULL;
 111         char *s;
 112         int err = UCI_ERR_MEM;
 113
 114         luaL_checkstring(L, 1);
 115         s = strdup(lua_tostring(L, -1));
 116         if (!s)
 117                 goto error;
 118
 119         if ((err = uci_parse_tuple(ctx, s, &package, &section, &option, NULL)))
 120                 goto error;
 121
 122         if (section == NULL) {
 123                 err = UCI_ERR_INVAL;
 124                 goto error;
 125         }
 126
 127         p = find_package(package);
 128         if (!p) {
 129                 err = UCI_ERR_NOTFOUND;
 130                 goto error;
 131         }
 132
 133         if ((err = uci_lookup(ctx, &e, p, section, option)))
 134                 goto error;
 135
 136         switch(e->type) {
 137                 case UCI_TYPE_SECTION:
 138                         lua_pushstring(L, uci_to_section(e)->type);
 139                         break;
 140                 case UCI_TYPE_OPTION:
 141                         lua_pushstring(L, uci_to_option(e)->value);
 142                         break;
 143                 default:
 144                         err = UCI_ERR_INVAL;
 145                         goto error;
 146         }
 147 error:
 148         if (s)
 149                 free(s);
 150
 151         switch(err) {
 152         default:
 153                 ctx->err = err;
 154                 uci_lua_perror(L, "uci.get");
 155                 /* fall through */
 156         case UCI_ERR_NOTFOUND:
 157                 lua_pushnil(L);
 158                 /* fall through */
 159         case 0:
 160                 return 1;
 161         }
 162 }
 163
 164
 165 static int
 166 uci_lua_set(lua_State *L)
 167 {
 168         struct uci_package *p;
 169         char *package = NULL;
 170         char *section = NULL;
 171         char *option = NULL;
 172         char *value = NULL;
 173         char *s;
 174         int err = UCI_ERR_MEM;
 175
 176         luaL_checkstring(L, 1);
 177         s = strdup(lua_tostring(L, -1));
 178         if (!s)
 179                 goto error;
 180
 181         if ((err = uci_parse_tuple(ctx, s, &package, &section, &option, &value)))
 182                 goto error;
 183
 184         if ((section == NULL) || (value == NULL)) {
 185                 err = UCI_ERR_INVAL;
 186                 goto error;
 187         }
 188
 189         p = find_package(package);
 190         if (!p) {
 191                 err = UCI_ERR_NOTFOUND;
 192                 goto error;
 193         }
 194         err = uci_set(ctx, p, section, option, value, NULL);
 195
 196 error:
 197         if (err)
 198                 uci_lua_perror(L, "uci.set");
 199         lua_pushboolean(L, (err == 0));
 200         return 1;
 201 }
 202
 203 static int
 204 uci_lua_commit(lua_State *L)
 205 {
 206         struct uci_element *e, *tmp;
 207         const char *s = NULL;
 208         int failed = 0;
 209
 210         if (!lua_isnoneornil(L, -1)) {
 211                 luaL_checkstring(L, 1);
 212                 s = lua_tostring(L, -1);
 213         }
 214
 215         uci_foreach_element_safe(&ctx->root, tmp, e) {
 216                 struct uci_package *p = uci_to_package(e);
 217
 218                 if (s && (strcmp(s, e->name) != 0))
 219                         continue;
 220
 221                 if (uci_commit(ctx, &p, false) != 0)
 222                         failed = 1;
 223         }
 224         lua_pushboolean(L, !failed);
 225         return 1;
 226 }
 227
 228 static int
 229 uci_lua_save(lua_State *L)
 230 {
 231         struct uci_element *e;
 232         const char *s = NULL;
 233         int failed = 0;
 234
 235         if (!lua_isnoneornil(L, -1)) {
 236                 luaL_checkstring(L, 1);
 237                 s = lua_tostring(L, -1);
 238         }
 239
 240         uci_foreach_element(&ctx->root, e) {
 241                 if (s && (strcmp(s, e->name) != 0))
 242                         continue;
 243
 244                 if (uci_save(ctx, uci_to_package(e)) != 0)
 245                         failed = 1;
 246         }
 247         lua_pushboolean(L, !failed);
 248         return 1;
 249 }
 250
 251 static int
 252 uci_lua_set_confdir(lua_State *L)
 253 {
 254         int ret;
 255
 256         luaL_checkstring(L, 1);
 257         ret = uci_set_confdir(ctx, lua_tostring(L, -1));
 258         lua_pushboolean(L, (ret == 0));
 259         return 1;
 260 }
 261
 262 static int
 263 uci_lua_set_savedir(lua_State *L)
 264 {
 265         int ret;
 266
 267         luaL_checkstring(L, 1);
 268         ret = uci_set_savedir(ctx, lua_tostring(L, -1));
 269         lua_pushboolean(L, (ret == 0));
 270
 271         return 1;
 272 }
 273
 274 static const luaL_Reg uci[] = {
 275         { "load", uci_lua_load },
 276         { "unload", uci_lua_unload },
 277         { "get", uci_lua_get },
 278         { "set", uci_lua_set },
 279         { "save", uci_lua_save },
 280         { "commit", uci_lua_commit },
 281         { "set_confdir", uci_lua_set_confdir },
 282         { "set_savedir", uci_lua_set_savedir },
 283         { NULL, NULL },
 284 };
 285
 286
 287 int
 288 luaopen_uci(lua_State *L)
 289 {
 290         ctx = uci_alloc_context();
 291         if (!ctx)
 292                 luaL_error(L, "Cannot allocate UCI context\n");
 293         luaL_register(L, MODNAME, uci);
 294         return 0;
 295 }