uci: fix Lua finding
[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 METANAME       MODNAME ".meta"
29 //#define DEBUG 1
30
31 #ifdef DEBUG
32 #define DPRINTF(...) fprintf(stderr, __VA_ARGS__)
33 #else
34 #define DPRINTF(...) do {} while (0)
35 #endif
36
37 static struct uci_context *global_ctx = NULL;
38
39 static struct uci_context *
40 find_context(lua_State *L, int *offset)
41 {
42         struct uci_context **ctx;
43         if (!lua_isuserdata(L, 1)) {
44                 if (!global_ctx) {
45                         global_ctx = uci_alloc_context();
46                         if (!global_ctx) {
47                                 luaL_error(L, "failed to allocate UCI context");
48                                 return NULL;
49                         }
50                 }
51                 if (offset)
52                         *offset = 0;
53                 return global_ctx;
54         }
55         if (offset)
56                 *offset = 1;
57         ctx = luaL_checkudata(L, 1, METANAME);
58         if (!ctx || !*ctx) {
59                 luaL_error(L, "failed to get UCI context");
60                 return NULL;
61         }
62
63         return *ctx;
64 }
65
66 static struct uci_package *
67 find_package(lua_State *L, struct uci_context *ctx, const char *str, bool al)
68 {
69         struct uci_package *p = NULL;
70         struct uci_element *e;
71         char *sep;
72         char *name;
73
74         sep = strchr(str, '.');
75         if (sep) {
76                 name = malloc(1 + sep - str);
77                 if (!name) {
78                         luaL_error(L, "out of memory");
79                         return NULL;
80                 }
81                 strncpy(name, str, sep - str);
82                 name[sep - str] = 0;
83         } else
84                 name = (char *) str;
85
86         uci_foreach_element(&ctx->root, e) {
87                 if (strcmp(e->name, name) != 0)
88                         continue;
89
90                 p = uci_to_package(e);
91                 goto done;
92         }
93
94         if (al == true)
95                 uci_load(ctx, name, &p);
96         else if (al) {
97                 uci_load(ctx, name, &p);
98         }
99
100 done:
101         if (name != str)
102                 free(name);
103         return p;
104 }
105
106 static int
107 lookup_args(lua_State *L, struct uci_context *ctx, int offset, struct uci_ptr *ptr, char **buf)
108 {
109         char *s = NULL;
110         int n;
111
112         n = lua_gettop(L);
113         luaL_checkstring(L, 1 + offset);
114         s = strdup(lua_tostring(L, 1 + offset));
115         if (!s)
116                 goto error;
117
118         memset(ptr, 0, sizeof(struct uci_ptr));
119         if (!find_package(L, ctx, s, true))
120                 goto error;
121
122         switch (n - offset) {
123         case 4:
124         case 3:
125                 ptr->option = luaL_checkstring(L, 3 + offset);
126                 /* fall through */
127         case 2:
128                 ptr->section = luaL_checkstring(L, 2 + offset);
129                 ptr->package = luaL_checkstring(L, 1 + offset);
130                 if (uci_lookup_ptr(ctx, ptr, NULL, true) != UCI_OK)
131                         goto error;
132                 break;
133         case 1:
134                 if (uci_lookup_ptr(ctx, ptr, s, true) != UCI_OK)
135                         goto error;
136                 break;
137         default:
138                 luaL_error(L, "invalid argument count");
139                 goto error;
140         }
141
142         *buf = s;
143         return 0;
144
145 error:
146         if (s)
147                 free(s);
148         return 1;
149 }
150
151 static int
152 uci_push_status(lua_State *L, struct uci_context *ctx, bool hasarg)
153 {
154         char *str = NULL;
155
156         if (!hasarg)
157                 lua_pushboolean(L, (ctx->err == UCI_OK));
158         if (ctx->err) {
159                 uci_get_errorstr(ctx, &str, MODNAME);
160                 if (str) {
161                         lua_pushstring(L, str);
162                         free(str);
163                         return 2;
164                 }
165         }
166         return 1;
167 }
168
169 static void
170 uci_push_option(lua_State *L, struct uci_option *o)
171 {
172         struct uci_element *e;
173         int i = 0;
174
175         switch(o->type) {
176         case UCI_TYPE_STRING:
177                 lua_pushstring(L, o->v.string);
178                 break;
179         case UCI_TYPE_LIST:
180                 lua_newtable(L);
181                 uci_foreach_element(&o->v.list, e) {
182                         i++;
183                         lua_pushstring(L, e->name);
184                         lua_rawseti(L, -2, i);
185                 }
186                 break;
187         default:
188                 lua_pushnil(L);
189                 break;
190         }
191 }
192
193 static void
194 uci_push_section(lua_State *L, struct uci_section *s, int index)
195 {
196         struct uci_element *e;
197
198         lua_newtable(L);
199         lua_pushboolean(L, s->anonymous);
200         lua_setfield(L, -2, ".anonymous");
201         lua_pushstring(L, s->type);
202         lua_setfield(L, -2, ".type");
203         lua_pushstring(L, s->e.name);
204         lua_setfield(L, -2, ".name");
205         if (index >= 0) {
206                 lua_pushinteger(L, index);
207                 lua_setfield(L, -2, ".index");
208         }
209
210         uci_foreach_element(&s->options, e) {
211                 struct uci_option *o = uci_to_option(e);
212                 uci_push_option(L, o);
213                 lua_setfield(L, -2, o->e.name);
214         }
215 }
216
217 static void
218 uci_push_package(lua_State *L, struct uci_package *p)
219 {
220         struct uci_element *e;
221         int i = 0;
222
223         lua_newtable(L);
224         uci_foreach_element(&p->sections, e) {
225                 uci_push_section(L, uci_to_section(e), i);
226                 lua_setfield(L, -2, e->name);
227                 i++;
228         }
229 }
230
231 static int
232 uci_lua_unload(lua_State *L)
233 {
234         struct uci_context *ctx;
235         struct uci_package *p;
236         const char *s;
237         int offset = 0;
238
239         ctx = find_context(L, &offset);
240         luaL_checkstring(L, 1 + offset);
241         s = lua_tostring(L, 1 + offset);
242         p = find_package(L, ctx, s, false);
243         if (p) {
244                 uci_unload(ctx, p);
245                 return uci_push_status(L, ctx, false);
246         } else {
247                 lua_pushboolean(L, 0);
248         }
249         return 1;
250 }
251
252 static int
253 uci_lua_load(lua_State *L)
254 {
255         struct uci_context *ctx;
256         struct uci_package *p = NULL;
257         const char *s;
258         int offset = 0;
259
260         ctx = find_context(L, &offset);
261         uci_lua_unload(L);
262         lua_pop(L, 1); /* bool ret value of unload */
263         s = lua_tostring(L, -1);
264
265         uci_load(ctx, s, &p);
266         return uci_push_status(L, ctx, false);
267 }
268
269
270 static int
271 uci_lua_foreach(lua_State *L)
272 {
273         struct uci_context *ctx;
274         struct uci_package *p;
275         struct uci_element *e, *tmp;
276         const char *package, *type;
277         bool ret = false;
278         int offset = 0;
279         int i = 0;
280
281         ctx = find_context(L, &offset);
282         package = luaL_checkstring(L, 1 + offset);
283
284         if (lua_isnil(L, 2))
285                 type = NULL;
286         else
287                 type = luaL_checkstring(L, 2 + offset);
288
289         if (!lua_isfunction(L, 3 + offset) || !package)
290                 return luaL_error(L, "Invalid argument");
291
292         p = find_package(L, ctx, package, true);
293         if (!p)
294                 goto done;
295
296         uci_foreach_element_safe(&p->sections, tmp, e) {
297                 struct uci_section *s = uci_to_section(e);
298
299                 i++;
300
301                 if (type && (strcmp(s->type, type) != 0))
302                         continue;
303
304                 lua_pushvalue(L, 3 + offset); /* iterator function */
305                 uci_push_section(L, s, i - 1);
306                 if (lua_pcall(L, 1, 1, 0) == 0) {
307                         ret = true;
308                         if (lua_isboolean(L, -1) && !lua_toboolean(L, -1))
309                                 break;
310                 }
311                 else
312                 {
313                         lua_error(L);
314                         break;
315                 }
316         }
317
318 done:
319         lua_pushboolean(L, ret);
320         return 1;
321 }
322
323 static int
324 uci_lua_get_any(lua_State *L, bool all)
325 {
326         struct uci_context *ctx;
327         struct uci_element *e = NULL;
328         struct uci_ptr ptr;
329         int offset = 0;
330         char *s = NULL;
331         int err = UCI_ERR_NOTFOUND;
332
333         ctx = find_context(L, &offset);
334
335         if (lookup_args(L, ctx, offset, &ptr, &s))
336                 goto error;
337
338         uci_lookup_ptr(ctx, &ptr, NULL, true);
339         if (!all && !ptr.s) {
340                 err = UCI_ERR_INVAL;
341                 goto error;
342         }
343         if (!(ptr.flags & UCI_LOOKUP_COMPLETE)) {
344                 err = UCI_ERR_NOTFOUND;
345                 goto error;
346         }
347
348         err = UCI_OK;
349         e = ptr.last;
350         switch(e->type) {
351                 case UCI_TYPE_PACKAGE:
352                         uci_push_package(L, ptr.p);
353                         break;
354                 case UCI_TYPE_SECTION:
355                         if (all)
356                                 uci_push_section(L, ptr.s, -1);
357                         else
358                                 lua_pushstring(L, ptr.s->type);
359                         break;
360                 case UCI_TYPE_OPTION:
361                         uci_push_option(L, ptr.o);
362                         break;
363                 default:
364                         err = UCI_ERR_INVAL;
365                         goto error;
366         }
367         if (s)
368                 free(s);
369         if (!err)
370                 return 1;
371
372 error:
373         if (s)
374                 free(s);
375
376         lua_pushnil(L);
377         return uci_push_status(L, ctx, true);
378 }
379
380 static int
381 uci_lua_get(lua_State *L)
382 {
383         return uci_lua_get_any(L, false);
384 }
385
386 static int
387 uci_lua_get_all(lua_State *L)
388 {
389         return uci_lua_get_any(L, true);
390 }
391
392 static int
393 uci_lua_add(lua_State *L)
394 {
395         struct uci_context *ctx;
396         struct uci_section *s = NULL;
397         struct uci_package *p;
398         const char *package;
399         const char *type;
400         const char *name = NULL;
401         int offset = 0;
402
403         ctx = find_context(L, &offset);
404         package = luaL_checkstring(L, 1 + offset);
405         type = luaL_checkstring(L, 2 + offset);
406         p = find_package(L, ctx, package, true);
407         if (!p)
408                 goto fail;
409
410         if (uci_add_section(ctx, p, type, &s) || !s)
411                 goto fail;
412
413         name = s->e.name;
414         lua_pushstring(L, name);
415         return 1;
416
417 fail:
418         lua_pushnil(L);
419         return uci_push_status(L, ctx, true);
420 }
421
422 static int
423 uci_lua_delete(lua_State *L)
424 {
425         struct uci_context *ctx;
426         struct uci_ptr ptr;
427         int offset = 0;
428         char *s = NULL;
429
430         ctx = find_context(L, &offset);
431
432         if (lookup_args(L, ctx, offset, &ptr, &s))
433                 goto error;
434
435         uci_delete(ctx, &ptr);
436
437 error:
438         if (s)
439                 free(s);
440         return uci_push_status(L, ctx, false);
441 }
442
443 static int
444 uci_lua_rename(lua_State *L)
445 {
446         struct uci_context *ctx;
447         struct uci_ptr ptr;
448         int err = UCI_ERR_MEM;
449         char *s = NULL;
450         int nargs, offset = 0;
451
452         ctx = find_context(L, &offset);
453         nargs = lua_gettop(L);
454         if (lookup_args(L, ctx, offset, &ptr, &s))
455                 goto error;
456
457         switch(nargs - offset) {
458         case 1:
459                 /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */
460                 break;
461         case 4:
462                 /* Format: uci.set("p", "s", "o", "v") */
463                 ptr.value = luaL_checkstring(L, nargs);
464                 break;
465         case 3:
466                 /* Format: uci.set("p", "s", "v") */
467                 ptr.value = ptr.option;
468                 ptr.option = NULL;
469                 break;
470         default:
471                 err = UCI_ERR_INVAL;
472                 goto error;
473         }
474
475         err = uci_lookup_ptr(ctx, &ptr, NULL, true);
476         if (err)
477                 goto error;
478
479         if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) {
480                 err = UCI_ERR_INVAL;
481                 goto error;
482         }
483
484         err = uci_rename(ctx, &ptr);
485         if (err)
486                 goto error;
487
488 error:
489         if (s)
490                 free(s);
491         return uci_push_status(L, ctx, false);
492 }
493
494 static int
495 uci_lua_reorder(lua_State *L)
496 {
497         struct uci_context *ctx;
498         struct uci_ptr ptr;
499         int err = UCI_ERR_MEM;
500         char *s = NULL;
501         int nargs, offset = 0;
502
503         ctx = find_context(L, &offset);
504         nargs = lua_gettop(L);
505         if (lookup_args(L, ctx, offset, &ptr, &s))
506                 goto error;
507
508         switch(nargs - offset) {
509         case 1:
510                 /* Format: uci.set("p.s=v") or uci.set("p.s=v") */
511                 if (ptr.option) {
512                         err = UCI_ERR_INVAL;
513                         goto error;
514                 }
515                 break;
516         case 3:
517                 /* Format: uci.set("p", "s", "v") */
518                 ptr.value = ptr.option;
519                 ptr.option = NULL;
520                 break;
521         default:
522                 err = UCI_ERR_INVAL;
523                 goto error;
524         }
525
526         err = uci_lookup_ptr(ctx, &ptr, NULL, true);
527         if (err)
528                 goto error;
529
530         if ((ptr.s == NULL) || (ptr.value == NULL)) {
531                 err = UCI_ERR_INVAL;
532                 goto error;
533         }
534
535         err = uci_reorder_section(ctx, ptr.s, strtoul(ptr.value, NULL, 10));
536         if (err)
537                 goto error;
538
539 error:
540         if (s)
541                 free(s);
542         return uci_push_status(L, ctx, false);
543 }
544
545
546 static int
547 uci_lua_set(lua_State *L)
548 {
549         struct uci_context *ctx;
550         struct uci_ptr ptr;
551         bool istable = false;
552         int err = UCI_ERR_MEM;
553         char *s = NULL;
554         const char *v;
555         int i, nargs, offset = 0;
556
557         ctx = find_context(L, &offset);
558         nargs = lua_gettop(L);
559         if (lookup_args(L, ctx, offset, &ptr, &s))
560                 goto error;
561
562         switch(nargs - offset) {
563         case 1:
564                 /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */
565                 break;
566         case 4:
567                 /* Format: uci.set("p", "s", "o", "v") */
568                 if (lua_istable(L, nargs)) {
569                         if (lua_objlen(L, nargs) < 1)
570                                 return luaL_error(L, "Cannot set an uci option to an empty table value");
571                         lua_rawgeti(L, nargs, 1);
572                         ptr.value = luaL_checkstring(L, -1);
573                         lua_pop(L, 1);
574                         istable = true;
575                 } else {
576                         ptr.value = luaL_checkstring(L, nargs);
577                 }
578                 break;
579         case 3:
580                 /* Format: uci.set("p", "s", "v") */
581                 ptr.value = ptr.option;
582                 ptr.option = NULL;
583                 break;
584         default:
585                 err = UCI_ERR_INVAL;
586                 goto error;
587         }
588
589         err = uci_lookup_ptr(ctx, &ptr, NULL, true);
590         if (err)
591                 goto error;
592
593         if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) {
594                 err = UCI_ERR_INVAL;
595                 goto error;
596         }
597
598         if (istable) {
599                 if (lua_objlen(L, nargs) == 1) {
600                         i = 1;
601                         if (ptr.o) {
602                                 v = ptr.value;
603                                 ptr.value = NULL;
604                                 err = uci_delete(ctx, &ptr);
605                                 if (err)
606                                         goto error;
607                                 ptr.value = v;
608                         }
609                 } else {
610                         i = 2;
611                         err = uci_set(ctx, &ptr);
612                         if (err)
613                                 goto error;
614                 }
615
616                 for (; i <= lua_objlen(L, nargs); i++) {
617                         lua_rawgeti(L, nargs, i);
618                         ptr.value = luaL_checkstring(L, -1);
619                         err = uci_add_list(ctx, &ptr);
620                         lua_pop(L, 1);
621                         if (err)
622                                 goto error;
623                 }
624         } else {
625                 err = uci_set(ctx, &ptr);
626                 if (err)
627                         goto error;
628         }
629
630
631 error:
632         if (s)
633                 free(s);
634         return uci_push_status(L, ctx, false);
635 }
636
637 enum pkg_cmd {
638         CMD_SAVE,
639         CMD_COMMIT,
640         CMD_REVERT
641 };
642
643 static int
644 uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd)
645 {
646         struct uci_context *ctx;
647         struct uci_element *e, *tmp;
648         struct uci_ptr ptr;
649         char *s = NULL;
650         int nargs, offset = 0;
651
652         ctx = find_context(L, &offset);
653         nargs = lua_gettop(L);
654         if ((cmd != CMD_REVERT) && (nargs - offset > 1))
655                 goto err;
656
657         if (lookup_args(L, ctx, offset, &ptr, &s))
658                 goto err;
659
660         uci_lookup_ptr(ctx, &ptr, NULL, true);
661
662         uci_foreach_element_safe(&ctx->root, tmp, e) {
663                 struct uci_package *p = uci_to_package(e);
664
665                 if (ptr.p && (ptr.p != p))
666                         continue;
667
668                 ptr.p = p;
669                 switch(cmd) {
670                 case CMD_COMMIT:
671                         uci_commit(ctx, &p, false);
672                         break;
673                 case CMD_SAVE:
674                         uci_save(ctx, p);
675                         break;
676                 case CMD_REVERT:
677                         uci_revert(ctx, &ptr);
678                         break;
679                 }
680         }
681
682 err:
683         if (s)
684                 free(s);
685         return uci_push_status(L, ctx, false);
686 }
687
688 static int
689 uci_lua_save(lua_State *L)
690 {
691         return uci_lua_package_cmd(L, CMD_SAVE);
692 }
693
694 static int
695 uci_lua_commit(lua_State *L)
696 {
697         return uci_lua_package_cmd(L, CMD_COMMIT);
698 }
699
700 static int
701 uci_lua_revert(lua_State *L)
702 {
703         return uci_lua_package_cmd(L, CMD_REVERT);
704 }
705
706 static void
707 uci_lua_add_change(lua_State *L, struct uci_element *e)
708 {
709         struct uci_delta *h;
710         const char *name;
711         const char *value;
712
713         h = uci_to_delta(e);
714         if (!h->section)
715                 return;
716
717         lua_getfield(L, -1, h->section);
718         if (lua_isnil(L, -1)) {
719                 lua_pop(L, 1);
720                 lua_newtable(L);
721                 lua_pushvalue(L, -1); /* copy for setfield */
722                 lua_setfield(L, -3, h->section);
723         }
724
725         name = h->e.name;
726         value = h->value ? h->value : "";
727
728         if (name) {
729                 lua_getfield(L, -1, name);
730
731                 /* this delta is a list add operation */
732                 if (h->cmd == UCI_CMD_LIST_ADD) {
733                         /* there seems to be no table yet */
734                         if (!lua_istable(L, -1)) {
735                                 lua_newtable(L);
736
737                                 /* if there is a value on the stack already, add */
738                                 if (!lua_isnil(L, -2)) {
739                                         lua_pushvalue(L, -2);
740                                         lua_rawseti(L, -2, 1);
741                                         lua_pushstring(L, value);
742                                         lua_rawseti(L, -2, 2);
743
744                                 /* this is the first table item */
745                                 } else {
746                                         lua_pushstring(L, value);
747                                         lua_rawseti(L, -2, 1);
748                                 }
749
750                                 lua_setfield(L, -3, name);
751
752                         /* a table is on the top of the stack and this is a subsequent,
753                          * list_add, append this value to table */
754                         } else {
755                                 lua_pushstring(L, value);
756                                 lua_rawseti(L, -2, lua_objlen(L, -2) + 1);
757                         }
758
759                 /* non-list change, simply set/replace field */
760                 } else {
761                         lua_pushstring(L, value);
762                         lua_setfield(L, -3, name);
763                 }
764
765                 lua_pop(L, 1);
766         } else {
767                 lua_pushstring(L, value);
768                 lua_setfield(L, -2, ".type");
769         }
770
771         lua_pop(L, 1);
772 }
773
774 static void
775 uci_lua_changes_pkg(lua_State *L, struct uci_context *ctx, const char *package)
776 {
777         struct uci_package *p = NULL;
778         struct uci_element *e;
779         bool autoload = false;
780
781         p = find_package(L, ctx, package, false);
782         if (!p) {
783                 autoload = true;
784                 p = find_package(L, ctx, package, true);
785                 if (!p)
786                         return;
787         }
788
789         if (uci_list_empty(&p->delta) && uci_list_empty(&p->saved_delta))
790                 goto done;
791
792         lua_newtable(L);
793         uci_foreach_element(&p->saved_delta, e) {
794                 uci_lua_add_change(L, e);
795         }
796         uci_foreach_element(&p->delta, e) {
797                 uci_lua_add_change(L, e);
798         }
799         lua_setfield(L, -2, p->e.name);
800
801 done:
802         if (autoload)
803                 uci_unload(ctx, p);
804 }
805
806 static int
807 uci_lua_changes(lua_State *L)
808 {
809         struct uci_context *ctx;
810         const char *package = NULL;
811         char **config = NULL;
812         int nargs;
813         int i, offset = 0;
814
815         ctx = find_context(L, &offset);
816         nargs = lua_gettop(L);
817         switch(nargs - offset) {
818         case 1:
819                 package = luaL_checkstring(L, 1 + offset);
820         case 0:
821                 break;
822         default:
823                 return luaL_error(L, "invalid argument count");
824         }
825
826         lua_newtable(L);
827         if (package) {
828                 uci_lua_changes_pkg(L, ctx, package);
829         } else {
830                 if (uci_list_configs(ctx, &config) != 0)
831                         goto done;
832
833                 for(i = 0; config[i] != NULL; i++) {
834                         uci_lua_changes_pkg(L, ctx, config[i]);
835                 }
836         }
837
838 done:
839         return 1;
840 }
841
842 static int
843 uci_lua_get_confdir(lua_State *L)
844 {
845         struct uci_context *ctx = find_context(L, NULL);
846         lua_pushstring(L, ctx->confdir);
847         return 1;
848 }
849
850 static int
851 uci_lua_set_confdir(lua_State *L)
852 {
853         struct uci_context *ctx;
854         int offset = 0;
855
856         ctx = find_context(L, &offset);
857         luaL_checkstring(L, 1 + offset);
858         uci_set_confdir(ctx, lua_tostring(L, -1));
859         return uci_push_status(L, ctx, false);
860 }
861
862 static int
863 uci_lua_get_savedir(lua_State *L)
864 {
865         struct uci_context *ctx = find_context(L, NULL);
866         lua_pushstring(L, ctx->savedir);
867         return 1;
868 }
869
870 static int
871 uci_lua_add_delta(lua_State *L)
872 {
873         struct uci_context *ctx;
874         int offset = 0;
875
876         ctx = find_context(L, &offset);
877         luaL_checkstring(L, 1 + offset);
878         uci_add_delta_path(ctx, lua_tostring(L, -1));
879         return uci_push_status(L, ctx, false);
880 }
881
882 static int
883 uci_lua_set_savedir(lua_State *L)
884 {
885         struct uci_context *ctx;
886         int offset = 0;
887
888         ctx = find_context(L, &offset);
889         luaL_checkstring(L, 1 + offset);
890         uci_set_savedir(ctx, lua_tostring(L, -1));
891         return uci_push_status(L, ctx, false);
892 }
893
894 static int
895 uci_lua_gc(lua_State *L)
896 {
897         struct uci_context *ctx = find_context(L, NULL);
898         uci_free_context(ctx);
899         return 0;
900 }
901
902 static int
903 uci_lua_cursor(lua_State *L)
904 {
905         struct uci_context **u;
906         int argc = lua_gettop(L);
907
908         u = lua_newuserdata(L, sizeof(struct uci_context *));
909         luaL_getmetatable(L, METANAME);
910         lua_setmetatable(L, -2);
911
912         *u = uci_alloc_context();
913         if (!*u)
914                 return luaL_error(L, "Cannot allocate UCI context");
915         switch (argc) {
916                 case 2:
917                         if (lua_isstring(L, 2) &&
918                                 (uci_set_savedir(*u, luaL_checkstring(L, 2)) != UCI_OK))
919                                 return luaL_error(L, "Unable to set savedir");
920                         /* fall through */
921                 case 1:
922                         if (lua_isstring(L, 1) &&
923                                 (uci_set_confdir(*u, luaL_checkstring(L, 1)) != UCI_OK))
924                                 return luaL_error(L, "Unable to set savedir");
925                         break;
926                 default:
927                         break;
928         }
929         return 1;
930 }
931
932 static const luaL_Reg uci[] = {
933         { "__gc", uci_lua_gc },
934         { "cursor", uci_lua_cursor },
935         { "load", uci_lua_load },
936         { "unload", uci_lua_unload },
937         { "get", uci_lua_get },
938         { "get_all", uci_lua_get_all },
939         { "add", uci_lua_add },
940         { "set", uci_lua_set },
941         { "rename", uci_lua_rename },
942         { "save", uci_lua_save },
943         { "delete", uci_lua_delete },
944         { "commit", uci_lua_commit },
945         { "revert", uci_lua_revert },
946         { "reorder", uci_lua_reorder },
947         { "changes", uci_lua_changes },
948         { "foreach", uci_lua_foreach },
949         { "add_history", uci_lua_add_delta },
950         { "add_delta", uci_lua_add_delta },
951         { "get_confdir", uci_lua_get_confdir },
952         { "set_confdir", uci_lua_set_confdir },
953         { "get_savedir", uci_lua_get_savedir },
954         { "set_savedir", uci_lua_set_savedir },
955         { NULL, NULL },
956 };
957
958
959 int
960 luaopen_uci(lua_State *L)
961 {
962         /* create metatable */
963         luaL_newmetatable(L, METANAME);
964
965         /* metatable.__index = metatable */
966         lua_pushvalue(L, -1);
967         lua_setfield(L, -2, "__index");
968
969         /* fill metatable */
970         luaL_register(L, NULL, uci);
971         lua_pop(L, 1);
972
973         /* create module */
974         luaL_register(L, MODNAME, uci);
975
976         return 0;
977 }