list.c

   1 /*
   2  * libuci - Library for the Unified Configuration Interface
   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 lesser general public license version 2.1
   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 <glob.h>
  16
  17 /* initialize a list head/item */
  18 static inline void uci_list_init(struct uci_list *ptr)
  19 {
  20         ptr->prev = ptr;
  21         ptr->next = ptr;
  22 }
  23
  24 /* inserts a new list entry between two consecutive entries */
  25 static inline void __uci_list_add(struct uci_list *prev, struct uci_list *next, struct uci_list *ptr)
  26 {
  27         next->prev = ptr;
  28         ptr->prev = prev;
  29         ptr->next = next;
  30         prev->next = ptr;
  31 }
  32
  33 /* inserts a new list entry at the tail of the list */
  34 static inline void uci_list_add(struct uci_list *head, struct uci_list *ptr)
  35 {
  36         /* NB: head->prev points at the tail */
  37         __uci_list_add(head->prev, head, ptr);
  38 }
  39
  40 static inline void uci_list_del(struct uci_list *ptr)
  41 {
  42         struct uci_list *next, *prev;
  43
  44         next = ptr->next;
  45         prev = ptr->prev;
  46
  47         prev->next = next;
  48         next->prev = prev;
  49 }
  50
  51 static void uci_drop_option(struct uci_option *option)
  52 {
  53         if (!option)
  54                 return;
  55         if (option->name)
  56                 free(option->name);
  57         if (option->value)
  58                 free(option->value);
  59         free(option);
  60 }
  61
  62 static struct uci_option *uci_add_option(struct uci_section *section, const char *name, const char *value)
  63 {
  64         struct uci_config *cfg = section->config;
  65         struct uci_context *ctx = cfg->ctx;
  66         struct uci_option *option = NULL;
  67
  68         UCI_TRAP_SAVE(ctx, error);
  69         option = (struct uci_option *) uci_malloc(ctx, sizeof(struct uci_option));
  70         option->name = uci_strdup(ctx, name);
  71         option->value = uci_strdup(ctx, value);
  72         uci_list_add(&section->options, &option->list);
  73         UCI_TRAP_RESTORE(ctx);
  74         return option;
  75
  76 error:
  77         uci_drop_option(option);
  78         UCI_THROW(ctx, ctx->errno);
  79         return NULL;
  80 }
  81
  82 static void uci_drop_section(struct uci_section *section)
  83 {
  84         struct uci_option *opt;
  85
  86         if (!section)
  87                 return;
  88
  89         uci_foreach_entry(option, &section->options, opt) {
  90                 uci_list_del(&opt->list);
  91                 uci_drop_option(opt);
  92         }
  93
  94         if (section->name)
  95                 free(section->name);
  96         if (section->type)
  97                 free(section->type);
  98         free(section);
  99 }
 100
 101 static struct uci_section *uci_add_section(struct uci_config *cfg, const char *type, const char *name)
 102 {
 103         struct uci_section *section = NULL;
 104         struct uci_context *ctx = cfg->ctx;
 105
 106         UCI_TRAP_SAVE(ctx, error);
 107         section = (struct uci_section *) uci_malloc(ctx, sizeof(struct uci_section));
 108         section->config = cfg;
 109         uci_list_init(&section->list);
 110         uci_list_init(&section->options);
 111         section->type = uci_strdup(ctx, type);
 112         if (name)
 113                 section->name = uci_strdup(ctx, name);
 114         uci_list_add(&cfg->sections, &section->list);
 115         UCI_TRAP_RESTORE(ctx);
 116
 117         return section;
 118
 119 error:
 120         uci_drop_section(section);
 121         UCI_THROW(ctx, ctx->errno);
 122         return NULL;
 123 }
 124
 125 static void uci_drop_config(struct uci_config *cfg)
 126 {
 127         struct uci_section *s;
 128
 129         if(!cfg)
 130                 return;
 131
 132         uci_foreach_entry(section, &cfg->sections, s) {
 133                 uci_list_del(&s->list);
 134                 uci_drop_section(s);
 135         }
 136
 137         if (cfg->name)
 138                 free(cfg->name);
 139         free(cfg);
 140 }
 141
 142
 143 static struct uci_config *uci_alloc_config(struct uci_context *ctx, const char *name)
 144 {
 145         struct uci_config *cfg = NULL;
 146
 147         UCI_TRAP_SAVE(ctx, error);
 148         cfg = (struct uci_config *) uci_malloc(ctx, sizeof(struct uci_config));
 149         uci_list_init(&cfg->list);
 150         uci_list_init(&cfg->sections);
 151         cfg->name = uci_strdup(ctx, name);
 152         cfg->ctx = ctx;
 153         UCI_TRAP_RESTORE(ctx);
 154         return cfg;
 155
 156 error:
 157         uci_drop_config(cfg);
 158         UCI_THROW(ctx, ctx->errno);
 159         return NULL;
 160 }
 161
 162 int uci_unload(struct uci_context *ctx, const char *name)
 163 {
 164         struct uci_config *cfg;
 165
 166         UCI_HANDLE_ERR(ctx);
 167         UCI_ASSERT(ctx, name != NULL);
 168
 169         uci_foreach_entry(config, &ctx->root, cfg) {
 170                 if (!strcmp(cfg->name, name))
 171                         goto found;
 172         }
 173         UCI_THROW(ctx, UCI_ERR_NOTFOUND);
 174
 175 found:
 176         uci_list_del(&cfg->list);
 177         uci_drop_config(cfg);
 178
 179         return 0;
 180 }
 181
 182 static inline char *get_filename(char *path)
 183 {
 184         char *p;
 185
 186         p = strrchr(path, '/');
 187         p++;
 188         if (!*p)
 189                 return NULL;
 190         return p;
 191 }
 192
 193 char **uci_list_configs()
 194 {
 195         char **configs;
 196         glob_t globbuf;
 197         int size, i;
 198         char *buf;
 199
 200         if (glob(UCI_CONFDIR "/*", GLOB_MARK, NULL, &globbuf) != 0)
 201                 return NULL;
 202
 203         size = sizeof(char *) * (globbuf.gl_pathc + 1);
 204         for(i = 0; i < globbuf.gl_pathc; i++) {
 205                 char *p;
 206
 207                 p = get_filename(globbuf.gl_pathv[i]);
 208                 if (!p)
 209                         continue;
 210
 211                 size += strlen(p) + 1;
 212         }
 213
 214         configs = malloc(size);
 215         if (!configs)
 216                 return NULL;
 217
 218         memset(configs, 0, size);
 219         buf = (char *) &configs[globbuf.gl_pathc + 1];
 220         for(i = 0; i < globbuf.gl_pathc; i++) {
 221                 char *p;
 222
 223                 p = get_filename(globbuf.gl_pathv[i]);
 224                 if (!p)
 225                         continue;
 226
 227                 configs[i] = buf;
 228                 strcpy(buf, p);
 229                 buf += strlen(buf) + 1;
 230         }
 231         return configs;
 232 }
 233