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_lua_context *f;
 107         struct uci_element *e = NULL;
 108         struct uci_package *p = NULL;
 109         char *package = NULL;
 110         char *section = NULL;
 111         char *option = NULL;
 112         char *s;
 113         int err = UCI_ERR_MEM;
 114
 115         luaL_checkstring(L, 1);
 116         s = strdup(lua_tostring(L, -1));
 117         if (!s)
 118                 goto error;
 119
 120         if ((err = uci_parse_tuple(ctx, s, &package, &section, &option, NULL)))
 121                 goto error;
 122
 123         if (section == NULL) {
 124                 err = UCI_ERR_INVAL;
 125                 goto error;
 126         }
 127
 128         p = find_package(package);
 129         if (!p) {
 130                 err = UCI_ERR_NOTFOUND;
 131                 goto error;
 132         }
 133
 134         if ((err = uci_lookup(ctx, &e, p, section, option)))
 135                 goto error;
 136
 137         switch(e->type) {
 138                 case UCI_TYPE_SECTION:
 139                         lua_pushstring(L, uci_to_section(e)->type);
 140                         break;
 141                 case UCI_TYPE_OPTION:
 142                         lua_pushstring(L, uci_to_option(e)->value);
 143                         break;
 144                 default:
 145                         err = UCI_ERR_INVAL;
 146                         goto error;
 147         }
 148 error:
 149         if (s)
 150                 free(s);
 151
 152         switch(err) {
 153         default:
 154                 ctx->err = err;
 155                 uci_lua_perror(L, "uci.get");
 156                 /* fall through */
 157         case UCI_ERR_NOTFOUND:
 158                 lua_pushnil(L);
 159                 /* fall through */
 160         case 0:
 161                 return 1;
 162         }
 163 }
 164
 165
 166 static int
 167 uci_lua_set_confdir(lua_State *L)
 168 {
 169         int ret;
 170
 171         luaL_checkstring(L, 1);
 172         ret = uci_set_confdir(ctx, lua_tostring(L, -1));
 173         lua_pushboolean(L, (ret == 0));
 174         return 1;
 175 }
 176
 177 static int
 178 uci_lua_set_savedir(lua_State *L)
 179 {
 180         int ret;
 181
 182         luaL_checkstring(L, 1);
 183         ret = uci_set_savedir(ctx, lua_tostring(L, -1));
 184         lua_pushboolean(L, (ret == 0));
 185
 186         return 1;
 187 }
 188
 189 static const luaL_Reg uci[] = {
 190         { "load", uci_lua_load },
 191         { "unload", uci_lua_unload },
 192         { "get", uci_lua_get },
 193         { "set_confdir", uci_lua_set_confdir },
 194         { "set_savedir", uci_lua_set_savedir },
 195         { NULL, NULL },
 196 };
 197
 198
 199 int
 200 luaopen_uci(lua_State *L)
 201 {
 202         ctx = uci_alloc_context();
 203         if (!ctx)
 204                 luaL_error(L, "Cannot allocate UCI context\n");
 205         luaL_register(L, MODNAME, uci);
 206         return 0;
 207 }