more const stuff
[project/uci.git] / 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 DEBUG 1
29
30 #ifdef DEBUG
31 #define DPRINTF(...) fprintf(stderr, __VA_ARGS__)
32 #else
33 #define DPRINTF(...) do {} while (0)
34 #endif
35
36 static struct uci_context *ctx = NULL;
37
38 static struct uci_package *
39 find_package(const char *name)
40 {
41         struct uci_package *p = NULL;
42         struct uci_element *e;
43         uci_foreach_element(&ctx->root, e) {
44                 if (strcmp(e->name, name) != 0)
45                         continue;
46
47                 p = uci_to_package(e);
48                 break;
49         }
50         return p;
51 }
52
53 static void uci_lua_perror(lua_State *L, char *name)
54 {
55         lua_getfield(L, LUA_GLOBALSINDEX, "uci");
56         lua_getfield(L, -1, "warn");
57         if (!lua_isboolean(L, -1))
58                 goto done;
59         if (lua_toboolean(L, -1) != 1)
60                 goto done;
61         uci_perror(ctx, name);
62 done:
63         lua_pop(L, 2);
64 }
65
66 static void uci_push_section(lua_State *L, struct uci_section *s)
67 {
68         struct uci_element *e;
69
70         lua_newtable(L);
71         lua_pushstring(L, s->type);
72         lua_setfield(L, -2, "type");
73         lua_pushstring(L, s->e.name);
74         lua_setfield(L, -2, "name");
75
76         lua_newtable(L);
77         lua_pushvalue(L, -1);
78         lua_setfield(L, -3, "options");
79
80         uci_foreach_element(&s->options, e) {
81                 struct uci_option *o = uci_to_option(e);
82                 lua_pushstring(L, o->value);
83                 lua_setfield(L, -2, o->e.name);
84         }
85         lua_pop(L, 1);
86 }
87
88 static void uci_push_package(lua_State *L, struct uci_package *p)
89 {
90         struct uci_element *e;
91         int i = 0;
92
93         lua_newtable(L);
94         uci_foreach_element(&p->sections, e) {
95                 i++;
96                 luaL_setn(L, -1, i);
97                 uci_push_section(L, uci_to_section(e));
98                 lua_rawseti(L, -2, i);
99         }
100 }
101
102 static int
103 uci_lua_unload(lua_State *L)
104 {
105         struct uci_package *p;
106         const char *s;
107
108         luaL_checkstring(L, 1);
109         s = lua_tostring(L, -1);
110         p = find_package(s);
111         if (p) {
112                 uci_unload(ctx, p);
113                 lua_pushboolean(L, 1);
114         } else {
115                 lua_pushboolean(L, 0);
116         }
117         return 1;
118 }
119
120 static int
121 uci_lua_load(lua_State *L)
122 {
123         struct uci_package *p = NULL;
124         const char *s;
125
126         uci_lua_unload(L);
127         lua_pop(L, 1); /* bool ret value of unload */
128         s = lua_tostring(L, -1);
129
130         if (uci_load(ctx, s, &p)) {
131                 uci_lua_perror(L, "uci.load");
132                 lua_pushboolean(L, 0);
133         } else {
134                 lua_pushboolean(L, 1);
135         }
136
137         return 1;
138 }
139
140
141 static int
142 uci_lua_foreach(lua_State *L)
143 {
144         struct uci_package *p;
145         struct uci_element *e;
146         const char *package, *type;
147         bool ret = false;
148
149         package = luaL_checkstring(L, 1);
150
151         if (lua_isnil(L, 2))
152                 type = NULL;
153         else
154                 type = luaL_checkstring(L, 2);
155
156         if (!lua_isfunction(L, 3) || !package)
157                 luaL_error(L, "Invalid argument");
158
159         p = find_package(package);
160         if (!p)
161                 goto done;
162
163         uci_foreach_element(&p->sections, e) {
164                 struct uci_section *s = uci_to_section(e);
165
166                 if (type && (strcmp(s->type, type) != 0))
167                         continue;
168
169                 lua_pushvalue(L, 3); /* iterator function */
170                 uci_push_section(L, s);
171                 if (lua_pcall(L, 1, 0, 0) == 0)
172                         ret = true;
173         }
174
175 done:
176         lua_pushboolean(L, ret);
177         return 1;
178 }
179
180 static int
181 uci_lua_get_any(lua_State *L, bool all)
182 {
183         struct uci_element *e = NULL;
184         struct uci_package *p = NULL;
185         const char *package = NULL;
186         const char *section = NULL;
187         const char *option = NULL;
188         char *s;
189         int err = UCI_ERR_MEM;
190         int n;
191
192         n = lua_gettop(L);
193
194         luaL_checkstring(L, 1);
195         s = strdup(lua_tostring(L, 1));
196         if (!s)
197                 goto error;
198
199         if (n > 1) {
200                 package = luaL_checkstring(L, 1);
201                 section = luaL_checkstring(L, 2);
202                 if (n > 2)
203                         option = luaL_checkstring(L, 3);
204         } else {
205                 if ((err = uci_parse_tuple(ctx, s, (char **) &package, (char **) &section, (char **) &option, NULL)))
206                         goto error;
207         }
208
209         if (!all && (section == NULL)) {
210                 err = UCI_ERR_INVAL;
211                 goto error;
212         }
213
214         p = find_package(package);
215         if (!p) {
216                 err = UCI_ERR_NOTFOUND;
217                 goto error;
218         }
219
220         if (section) {
221                 if ((err = uci_lookup(ctx, &e, p, section, option)))
222                         goto error;
223         } else {
224                 e = &p->e;
225         }
226
227         switch(e->type) {
228                 case UCI_TYPE_PACKAGE:
229                         uci_push_package(L, p);
230                         break;
231                 case UCI_TYPE_SECTION:
232                         if (all)
233                                 uci_push_section(L, uci_to_section(e));
234                         else
235                                 lua_pushstring(L, uci_to_section(e)->type);
236                         break;
237                 case UCI_TYPE_OPTION:
238                         lua_pushstring(L, uci_to_option(e)->value);
239                         break;
240                 default:
241                         err = UCI_ERR_INVAL;
242                         goto error;
243         }
244 error:
245         if (s)
246                 free(s);
247
248         switch(err) {
249         default:
250                 ctx->err = err;
251                 uci_lua_perror(L, "uci.get");
252                 /* fall through */
253         case UCI_ERR_NOTFOUND:
254                 lua_pushnil(L);
255                 /* fall through */
256         case 0:
257                 return 1;
258         }
259 }
260
261 static int
262 uci_lua_get(lua_State *L)
263 {
264         return uci_lua_get_any(L, false);
265 }
266
267 static int
268 uci_lua_get_all(lua_State *L)
269 {
270         return uci_lua_get_any(L, true);
271 }
272
273 static int
274 uci_lua_set(lua_State *L)
275 {
276         struct uci_package *p;
277         char *package = NULL;
278         char *section = NULL;
279         char *option = NULL;
280         char *value = NULL;
281         char *s;
282         int err = UCI_ERR_MEM;
283
284         luaL_checkstring(L, 1);
285         s = strdup(lua_tostring(L, -1));
286         if (!s)
287                 goto error;
288
289         if ((err = uci_parse_tuple(ctx, s, &package, &section, &option, &value)))
290                 goto error;
291
292         if ((section == NULL) || (value == NULL)) {
293                 err = UCI_ERR_INVAL;
294                 goto error;
295         }
296
297         p = find_package(package);
298         if (!p) {
299                 err = UCI_ERR_NOTFOUND;
300                 goto error;
301         }
302         err = uci_set(ctx, p, section, option, value, NULL);
303
304 error:
305         if (err)
306                 uci_lua_perror(L, "uci.set");
307         lua_pushboolean(L, (err == 0));
308         return 1;
309 }
310
311 enum pkg_cmd {
312         CMD_SAVE,
313         CMD_COMMIT,
314         CMD_REVERT
315 };
316
317 static int
318 uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd)
319 {
320         struct uci_element *e, *tmp;
321         const char *s = NULL;
322         const char *section = NULL;
323         const char *option = NULL;
324         int failed = 0;
325         int nargs;
326
327         nargs = lua_gettop(L);
328         switch(nargs) {
329         case 3:
330                 if (cmd != CMD_REVERT)
331                         goto err;
332                 luaL_checkstring(L, 1);
333                 option = lua_tostring(L, -1);
334                 lua_pop(L, 1);
335                 /* fall through */
336         case 2:
337                 if (cmd != CMD_REVERT)
338                         goto err;
339                 luaL_checkstring(L, 1);
340                 section = lua_tostring(L, -1);
341                 lua_pop(L, 1);
342                 /* fall through */
343         case 1:
344                 luaL_checkstring(L, 1);
345                 s = lua_tostring(L, -1);
346                 lua_pop(L, 1);
347                 break;
348         default:
349                 err:
350                 luaL_error(L, "Invalid argument count");
351                 break;
352         }
353
354         uci_foreach_element_safe(&ctx->root, tmp, e) {
355                 struct uci_package *p = uci_to_package(e);
356                 int ret = UCI_ERR_INVAL;
357
358                 if (s && (strcmp(s, e->name) != 0))
359                         continue;
360
361                 switch(cmd) {
362                 case CMD_COMMIT:
363                         ret = uci_commit(ctx, &p, false);
364                         break;
365                 case CMD_SAVE:
366                         ret = uci_save(ctx, p);
367                         break;
368                 case CMD_REVERT:
369                         ret = uci_revert(ctx, &p, section, option);
370                         break;
371                 }
372
373                 if (ret != 0)
374                         failed = 1;
375         }
376
377         lua_pushboolean(L, !failed);
378         return 1;
379 }
380
381 static int
382 uci_lua_save(lua_State *L)
383 {
384         return uci_lua_package_cmd(L, CMD_SAVE);
385 }
386
387 static int
388 uci_lua_commit(lua_State *L)
389 {
390         return uci_lua_package_cmd(L, CMD_COMMIT);
391 }
392
393 static int
394 uci_lua_revert(lua_State *L)
395 {
396         return uci_lua_package_cmd(L, CMD_REVERT);
397 }
398
399 static int
400 uci_lua_set_confdir(lua_State *L)
401 {
402         int ret;
403
404         luaL_checkstring(L, 1);
405         ret = uci_set_confdir(ctx, lua_tostring(L, -1));
406         lua_pushboolean(L, (ret == 0));
407         return 1;
408 }
409
410 static int
411 uci_lua_set_savedir(lua_State *L)
412 {
413         int ret;
414
415         luaL_checkstring(L, 1);
416         ret = uci_set_savedir(ctx, lua_tostring(L, -1));
417         lua_pushboolean(L, (ret == 0));
418
419         return 1;
420 }
421
422 static const luaL_Reg uci[] = {
423         { "load", uci_lua_load },
424         { "unload", uci_lua_unload },
425         { "get", uci_lua_get },
426         { "get_all", uci_lua_get_all },
427         { "set", uci_lua_set },
428         { "save", uci_lua_save },
429         { "commit", uci_lua_commit },
430         { "revert", uci_lua_revert },
431         { "foreach", uci_lua_foreach },
432         { "set_confdir", uci_lua_set_confdir },
433         { "set_savedir", uci_lua_set_savedir },
434         { NULL, NULL },
435 };
436
437
438 int
439 luaopen_uci(lua_State *L)
440 {
441         ctx = uci_alloc_context();
442         if (!ctx)
443                 luaL_error(L, "Cannot allocate UCI context\n");
444         luaL_register(L, MODNAME, uci);
445         return 0;
446 }