libs/lucittpd/src/lib/uci.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; either version 2 of the License, or
   5  *   (at your option) any later version.
   6  *
   7  *   This program is distributed in the hope that it will be useful,
   8  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *   GNU General Public License for more details.
  11  *
  12  *   You should have received a copy of the GNU General Public License
  13  *   along with this program; if not, write to the Free Software
  14  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  15  *
  16  *   Copyright (C) 2008 John Crispin <blogic@openwrt.org>
  17  */
  18
  19 #include <string.h>
  20 #include <stdlib.h>
  21
  22 #include <uci.h>
  23 #include <lib/list.h>
  24 #include <lib/log.h>
  25 #include <lib/uci.h>
  26
  27 static struct uci_ptr ptr;
  28 static struct uci_package *p = NULL;
  29
  30 static inline int ucix_get_ptr(struct uci_context *ctx, const char *p, const char *s, const char *o, const char *t)
  31 {
  32         memset(&ptr, 0, sizeof(ptr));
  33         ptr.package = p;
  34         ptr.section = s;
  35         ptr.option = o;
  36         ptr.value = t;
  37         return uci_lookup_ptr(ctx, &ptr, NULL, true);
  38 }
  39
  40 struct uci_context* ucix_init(const char *config_file)
  41 {
  42         struct uci_context *ctx = uci_alloc_context();
  43         uci_add_history_path(ctx, "/var/state");
  44         uci_set_savedir(ctx, "/var/state/");
  45         if(uci_load(ctx, config_file, &p) != UCI_OK)
  46         {
  47                 log_printf("%s/%s is missing or corrupt\n", ctx->savedir, config_file);
  48                 return NULL;
  49         }
  50         return ctx;
  51 }
  52
  53 struct uci_context* ucix_init_path(const char *path, const char *config_file)
  54 {
  55         struct uci_context *ctx = uci_alloc_context();
  56         if(path)
  57                 uci_set_confdir(ctx, path);
  58         if(uci_load(ctx, config_file, NULL) != UCI_OK)
  59         {
  60                 log_printf("%s/%s is missing or corrupt\n", ctx->savedir, config_file);
  61                 return NULL;
  62         }
  63         return ctx;
  64 }
  65
  66 void ucix_cleanup(struct uci_context *ctx)
  67 {
  68         uci_free_context(ctx);
  69 }
  70
  71 void ucix_save(struct uci_context *ctx)
  72 {
  73         uci_set_savedir(ctx, "/tmp/.uci");
  74         uci_save(ctx, p);
  75 }
  76
  77 void ucix_save_state(struct uci_context *ctx)
  78 {
  79         uci_save(ctx, p);
  80 }
  81
  82 int ucix_get_option_list(struct uci_context *ctx, const char *p,
  83         const char *s, const char *o, struct list_head *l)
  84 {
  85         struct uci_element *e = NULL;
  86         if(ucix_get_ptr(ctx, p, s, o, NULL))
  87                 return 1;
  88         if (!(ptr.flags & UCI_LOOKUP_COMPLETE))
  89                 return 1;
  90         e = ptr.last;
  91         switch (e->type)
  92         {
  93         case UCI_TYPE_OPTION:
  94                 switch(ptr.o->type) {
  95                         case UCI_TYPE_LIST:
  96                                 uci_foreach_element(&ptr.o->v.list, e)
  97                                 {
  98                                         struct ucilist *ul = malloc(sizeof(struct ucilist));
  99                                         ul->val = strdup((e->name)?(e->name):(""));
 100                                         INIT_LIST_HEAD(&ul->list);
 101                                         list_add(&ul->list, l);
 102                                 }
 103                                 break;
 104                         default:
 105                                 break;
 106                 }
 107                 break;
 108         default:
 109                 return 1;
 110         }
 111
 112         return 0;
 113 }
 114
 115 const char* ucix_get_option(struct uci_context *ctx, const char *p, const char *s, const char *o)
 116 {
 117         struct uci_element *e = NULL;
 118         const char *value = NULL;
 119         if(ucix_get_ptr(ctx, p, s, o, NULL))
 120                 return NULL;
 121         if (!(ptr.flags & UCI_LOOKUP_COMPLETE))
 122                 return NULL;
 123         e = ptr.last;
 124         switch (e->type)
 125         {
 126         case UCI_TYPE_SECTION:
 127                 value = uci_to_section(e)->type;
 128                 break;
 129         case UCI_TYPE_OPTION:
 130                 switch(ptr.o->type) {
 131                         case UCI_TYPE_STRING:
 132                                 value = ptr.o->v.string;
 133                                 break;
 134                         default:
 135                                 value = NULL;
 136                                 break;
 137                 }
 138                 break;
 139         default:
 140                 return 0;
 141         }
 142
 143         return value;
 144 }
 145
 146 int ucix_get_option_int(struct uci_context *ctx, const char *p, const char *s, const char *o, int def)
 147 {
 148         const char *tmp = ucix_get_option(ctx, p, s, o);
 149         int ret = def;
 150
 151         if (tmp)
 152                 ret = atoi(tmp);
 153         return ret;
 154 }
 155
 156 void ucix_add_section(struct uci_context *ctx, const char *p, const char *s, const char *t)
 157 {
 158         if(ucix_get_ptr(ctx, p, s, NULL, t))
 159                 return;
 160         uci_set(ctx, &ptr);
 161 }
 162
 163 void ucix_add_option(struct uci_context *ctx, const char *p, const char *s, const char *o, const char *t)
 164 {
 165         if(ucix_get_ptr(ctx, p, s, o, (t)?(t):("")))
 166                 return;
 167         uci_set(ctx, &ptr);
 168 }
 169
 170 void ucix_add_option_int(struct uci_context *ctx, const char *p, const char *s, const char *o, int t)
 171 {
 172         char tmp[64];
 173         snprintf(tmp, 64, "%d", t);
 174         ucix_add_option(ctx, p, s, o, tmp);
 175 }
 176
 177 void ucix_del(struct uci_context *ctx, const char *p, const char *s, const char *o)
 178 {
 179         if(!ucix_get_ptr(ctx, p, s, o, NULL))
 180                 uci_delete(ctx, &ptr);
 181 }
 182
 183 void ucix_revert(struct uci_context *ctx, const char *p, const char *s, const char *o)
 184 {
 185         if(!ucix_get_ptr(ctx, p, s, o, NULL))
 186                 uci_revert(ctx, &ptr);
 187 }
 188
 189 void ucix_for_each_section_type(struct uci_context *ctx,
 190         const char *p, const char *t,
 191         void (*cb)(const char*, void*), void *priv)
 192 {
 193         struct uci_element *e;
 194         if(ucix_get_ptr(ctx, p, NULL, NULL, NULL))
 195                 return;
 196         uci_foreach_element(&ptr.p->sections, e)
 197                 if (!strcmp(t, uci_to_section(e)->type))
 198                         cb(e->name, priv);
 199 }
 200
 201 int ucix_commit(struct uci_context *ctx, const char *p)
 202 {
 203         if(ucix_get_ptr(ctx, p, NULL, NULL, NULL))
 204                 return 1;
 205         return uci_commit(ctx, &ptr.p, false);
 206 }