X-Git-Url: http://git.openwrt.org/?p=project%2Fuci.git;a=blobdiff_plain;f=file.c;h=d104933e8d4f9fb30d7380c72a1a39938bca75f2;hp=6eaa5ecb3589be5b3393d34f55417655bd50f2c3;hb=6c71e7ee00c98eec9bd1cc92b903738863aebd57;hpb=7e840cf19ac6c867b9708257efd93e4a7efaa97e diff --git a/file.c b/file.c index 6eaa5ec..d104933 100644 --- a/file.c +++ b/file.c @@ -2,26 +2,34 @@ * libuci - Library for the Unified Configuration Interface * Copyright (C) 2008 Felix Fietkau * - * this program is free software; you can redistribute it and/or modify - * it under the terms of the gnu lesser general public license version 2.1 - * as published by the free software foundation + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 + * as published by the Free Software Foundation * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU Lesser General Public License for more details. */ /* * This file contains the code for parsing uci config files */ +#define _GNU_SOURCE #include -#include +#include #include +#include #include #include #include +#include +#include +#include + +#include "uci.h" +#include "uci_internal.h" #define LINEBUF 32 #define LINEBUF_MAX 4096 @@ -29,7 +37,7 @@ /* * Fetch a new line from the input stream and resize buffer if necessary */ -static void uci_getln(struct uci_context *ctx, int offset) +__private void uci_getln(struct uci_context *ctx, int offset) { struct uci_parse_context *pctx = ctx->pctx; char *p; @@ -52,51 +60,23 @@ static void uci_getln(struct uci_context *ctx, int offset) ofs += strlen(p); if (pctx->buf[ofs - 1] == '\n') { pctx->line++; - pctx->buf[ofs - 1] = 0; + if (ofs >= 2 && pctx->buf[ofs - 2] == '\r') + pctx->buf[ofs - 2] = 0; + else + pctx->buf[ofs - 1] = 0; return; } - if (pctx->bufsz > LINEBUF_MAX/2) { - pctx->reason = "line too long"; - pctx->byte = LINEBUF_MAX; - UCI_THROW(ctx, UCI_ERR_PARSE); - } + if (pctx->bufsz > LINEBUF_MAX/2) + uci_parse_error(ctx, p, "line too long"); pctx->bufsz *= 2; pctx->buf = uci_realloc(ctx, pctx->buf, pctx->bufsz); } while (1); } -/* - * Clean up all extra memory used by the parser and exporter - */ -static void uci_file_cleanup(struct uci_context *ctx) -{ - struct uci_parse_context *pctx; - - if (ctx->buf) { - free(ctx->buf); - ctx->buf = NULL; - ctx->bufsz = 0; - } - - pctx = ctx->pctx; - if (!pctx) - return; - - ctx->pctx = NULL; - if (pctx->package) - uci_free_package(pctx->package); - - if (pctx->buf) - free(pctx->buf); - if (pctx->file) - fclose(pctx->file); - - free(pctx); -} -/* +/* * parse a character escaped by '\' * returns true if the escaped character is to be parsed * returns false if the escaped character is to be ignored @@ -165,9 +145,7 @@ static void parse_double_quote(struct uci_context *ctx, char **str, char **targe break; } } - ctx->pctx->reason = "unterminated \""; - ctx->pctx->byte = *str - ctx->pctx->buf; - UCI_THROW(ctx, UCI_ERR_PARSE); + uci_parse_error(ctx, *str, "unterminated \""); } /* @@ -189,9 +167,7 @@ static void parse_single_quote(struct uci_context *ctx, char **str, char **targe addc(target, str); } } - ctx->pctx->reason = "unterminated '"; - ctx->pctx->byte = *str - ctx->pctx->buf; - UCI_THROW(ctx, UCI_ERR_PARSE); + uci_parse_error(ctx, *str, "unterminated '"); } /* @@ -199,6 +175,7 @@ static void parse_single_quote(struct uci_context *ctx, char **str, char **targe */ static void parse_str(struct uci_context *ctx, char **str, char **target) { + bool next = true; do { switch(**str) { case '\'': @@ -207,8 +184,14 @@ static void parse_str(struct uci_context *ctx, char **str, char **target) case '"': parse_double_quote(ctx, str, target); break; + case '#': + **str = 0; + /* fall through */ case 0: goto done; + case ';': + next = false; + goto done; case '\\': if (!parse_backslash(ctx, str)) continue; @@ -225,7 +208,7 @@ done: * character, skip to the next one, because the whitespace will * be overwritten by a null byte here */ - if (**str) + if (**str && next) *str += 1; /* terminate the parsed string */ @@ -235,23 +218,93 @@ done: /* * extract the next argument from the command line */ -static char *next_arg(struct uci_context *ctx, char **str, bool required) +static char *next_arg(struct uci_context *ctx, char **str, bool required, bool name) { char *val; char *ptr; val = ptr = *str; skip_whitespace(ctx, str); - parse_str(ctx, str, &ptr); - if (required && !*val) { - ctx->pctx->reason = "insufficient arguments"; - ctx->pctx->byte = *str - ctx->pctx->buf; - UCI_THROW(ctx, UCI_ERR_PARSE); + if(*str[0] == ';') { + *str[0] = 0; + *str += 1; + } else { + parse_str(ctx, str, &ptr); + } + if (!*val) { + if (required) + uci_parse_error(ctx, *str, "insufficient arguments"); + goto done; } + if (name && !uci_validate_name(val)) + uci_parse_error(ctx, val, "invalid character in field"); + +done: return val; } +int uci_parse_argument(struct uci_context *ctx, FILE *stream, char **str, char **result) +{ + UCI_HANDLE_ERR(ctx); + UCI_ASSERT(ctx, str != NULL); + UCI_ASSERT(ctx, result != NULL); + + if (ctx->pctx && (ctx->pctx->file != stream)) + uci_cleanup(ctx); + + if (!ctx->pctx) + uci_alloc_parse_context(ctx); + + ctx->pctx->file = stream; + + if (!*str) { + uci_getln(ctx, 0); + *str = ctx->pctx->buf; + } + + *result = next_arg(ctx, str, false, false); + + return 0; +} + +static int +uci_fill_ptr(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_element *e) +{ + UCI_ASSERT(ctx, ptr != NULL); + UCI_ASSERT(ctx, e != NULL); + + memset(ptr, 0, sizeof(struct uci_ptr)); + switch(e->type) { + case UCI_TYPE_OPTION: + ptr->o = uci_to_option(e); + goto fill_option; + case UCI_TYPE_SECTION: + ptr->s = uci_to_section(e); + goto fill_section; + case UCI_TYPE_PACKAGE: + ptr->p = uci_to_package(e); + goto fill_package; + default: + UCI_THROW(ctx, UCI_ERR_INVAL); + } + +fill_option: + ptr->option = ptr->o->e.name; + ptr->s = ptr->o->section; +fill_section: + ptr->section = ptr->s->e.name; + ptr->p = ptr->s->package; +fill_package: + ptr->package = ptr->p->e.name; + + ptr->flags |= UCI_LOOKUP_DONE; + + return 0; +} + + + /* * verify that the end of the line or command is reached. * throw an error if extra arguments are given on the command line @@ -260,12 +313,10 @@ static void assert_eol(struct uci_context *ctx, char **str) { char *tmp; - tmp = next_arg(ctx, str, false); - if (tmp && *tmp) { - ctx->pctx->reason = "too many arguments"; - ctx->pctx->byte = tmp - ctx->pctx->buf; - UCI_THROW(ctx, UCI_ERR_PARSE); - } + skip_whitespace(ctx, str); + tmp = next_arg(ctx, str, false, false); + if (*tmp && (ctx->flags & UCI_FLAG_STRICT)) + uci_parse_error(ctx, *str, "too many arguments"); } /* @@ -283,6 +334,7 @@ static void uci_switch_config(struct uci_context *ctx) /* add the last config to main config file list */ if (pctx->package) { + pctx->package->backend = ctx->backend; uci_list_add(&ctx->root, &pctx->package->e.list); pctx->package = NULL; @@ -296,29 +348,27 @@ static void uci_switch_config(struct uci_context *ctx) * if an older config under the same name exists, unload it * ignore errors here, e.g. if the config was not found */ - UCI_TRAP_SAVE(ctx, ignore); - e = uci_lookup_list(ctx, &ctx->root, name); + e = uci_lookup_list(&ctx->root, name); if (e) - uci_unload(ctx, uci_to_package(e)); - UCI_TRAP_RESTORE(ctx); -ignore: - ctx->errno = 0; - + UCI_THROW(ctx, UCI_ERR_DUPLICATE); pctx->package = uci_alloc_package(ctx, name); } /* * parse the 'package' uci command (next config package) */ -static void uci_parse_package(struct uci_context *ctx, char **str) +static void uci_parse_package(struct uci_context *ctx, char **str, bool single) { char *name = NULL; /* command string null-terminated by strtok */ *str += strlen(*str) + 1; - name = next_arg(ctx, str, true); + name = next_arg(ctx, str, true, true); assert_eol(ctx, str); + if (single) + return; + ctx->pctx->name = name; uci_switch_config(ctx); } @@ -328,266 +378,375 @@ static void uci_parse_package(struct uci_context *ctx, char **str) */ static void uci_parse_config(struct uci_context *ctx, char **str) { + struct uci_parse_context *pctx = ctx->pctx; + struct uci_element *e; + struct uci_ptr ptr; char *name = NULL; char *type = NULL; + uci_fixup_section(ctx, ctx->pctx->section); if (!ctx->pctx->package) { - if (!ctx->pctx->name) { - ctx->pctx->byte = *str - ctx->pctx->buf; - ctx->pctx->reason = "attempting to import a file without a package name"; - UCI_THROW(ctx, UCI_ERR_PARSE); - } + if (!ctx->pctx->name) + uci_parse_error(ctx, *str, "attempting to import a file without a package name"); + uci_switch_config(ctx); } /* command string null-terminated by strtok */ *str += strlen(*str) + 1; - type = next_arg(ctx, str, true); - name = next_arg(ctx, str, false); + type = next_arg(ctx, str, true, false); + if (!uci_validate_type(type)) + uci_parse_error(ctx, type, "invalid character in field"); + name = next_arg(ctx, str, false, true); assert_eol(ctx, str); - ctx->pctx->section = uci_alloc_section(ctx->pctx->package, type, name); + + if (!name || !name[0]) { + ctx->internal = !pctx->merge; + UCI_NESTED(uci_add_section, ctx, pctx->package, type, &pctx->section); + } else { + uci_fill_ptr(ctx, &ptr, &pctx->package->e); + e = uci_lookup_list(&pctx->package->sections, name); + if (e) + ptr.s = uci_to_section(e); + ptr.section = name; + ptr.value = type; + + ctx->internal = !pctx->merge; + UCI_NESTED(uci_set, ctx, &ptr); + pctx->section = uci_to_section(ptr.last); + } } /* * parse the 'option' uci command (open a value) */ -static void uci_parse_option(struct uci_context *ctx, char **str) +static void uci_parse_option(struct uci_context *ctx, char **str, bool list) { + struct uci_parse_context *pctx = ctx->pctx; + struct uci_element *e; + struct uci_ptr ptr; char *name = NULL; char *value = NULL; - if (!ctx->pctx->section) { - ctx->pctx->byte = *str - ctx->pctx->buf; - ctx->pctx->reason = "option command found before the first section"; - UCI_THROW(ctx, UCI_ERR_PARSE); - } + if (!pctx->section) + uci_parse_error(ctx, *str, "option/list command found before the first section"); + /* command string null-terminated by strtok */ *str += strlen(*str) + 1; - name = next_arg(ctx, str, true); - value = next_arg(ctx, str, true); + name = next_arg(ctx, str, true, true); + value = next_arg(ctx, str, false, false); assert_eol(ctx, str); - uci_alloc_option(ctx->pctx->section, name, value); -} + uci_fill_ptr(ctx, &ptr, &pctx->section->e); + e = uci_lookup_list(&pctx->section->options, name); + if (e) + ptr.o = uci_to_option(e); + ptr.option = name; + ptr.value = value; + + ctx->internal = !pctx->merge; + if (list) + UCI_NESTED(uci_add_list, ctx, &ptr); + else + UCI_NESTED(uci_set, ctx, &ptr); +} /* * parse a complete input line, split up combined commands by ';' */ -static void uci_parse_line(struct uci_context *ctx) +static void uci_parse_line(struct uci_context *ctx, bool single) { struct uci_parse_context *pctx = ctx->pctx; - char *word, *brk = NULL; - - for (word = strtok_r(pctx->buf, ";", &brk); - word; - word = strtok_r(NULL, ";", &brk)) { + char *word, *brk; - char *pbrk = NULL; - word = strtok_r(word, " \t", &pbrk); + word = pctx->buf; + do { + brk = NULL; + word = strtok_r(word, " \t", &brk); + if (!word) + return; switch(word[0]) { + case 0: + case '#': + return; case 'p': if ((word[1] == 0) || !strcmp(word + 1, "ackage")) - uci_parse_package(ctx, &word); + uci_parse_package(ctx, &word, single); + else + goto invalid; break; case 'c': if ((word[1] == 0) || !strcmp(word + 1, "onfig")) uci_parse_config(ctx, &word); + else + goto invalid; break; case 'o': if ((word[1] == 0) || !strcmp(word + 1, "ption")) - uci_parse_option(ctx, &word); + uci_parse_option(ctx, &word, false); + else + goto invalid; break; - default: - pctx->reason = "unterminated command"; - pctx->byte = word - pctx->buf; - UCI_THROW(ctx, UCI_ERR_PARSE); + case 'l': + if ((word[1] == 0) || !strcmp(word + 1, "ist")) + uci_parse_option(ctx, &word, true); + else + goto invalid; break; + default: + goto invalid; } - } + continue; +invalid: + uci_parse_error(ctx, word, "invalid command"); + } while (1); } /* max number of characters that escaping adds to the string */ -#define UCI_QUOTE_ESCAPE "'\\'" +#define UCI_QUOTE_ESCAPE "'\\''" /* * escape an uci string for export */ -static char *uci_escape(struct uci_context *ctx, char *str) +static const char *uci_escape(struct uci_context *ctx, const char *str) { - char *s, *p; - int pos = 0; + const char *end; + int ofs = 0; if (!ctx->buf) { ctx->bufsz = LINEBUF; ctx->buf = malloc(LINEBUF); + + if (!ctx->buf) + return str; } - s = str; - p = strchr(str, '\''); - if (!p) - return str; + while (1) { + int len; - do { - int len = p - s; - if (len > 0) { - if (p + sizeof(UCI_QUOTE_ESCAPE) - str >= ctx->bufsz) { - ctx->bufsz *= 2; - ctx->buf = realloc(ctx->buf, ctx->bufsz); - if (!ctx->buf) - UCI_THROW(ctx, UCI_ERR_MEM); - } - memcpy(&ctx->buf[pos], s, len); - pos += len; + end = strchr(str, '\''); + if (!end) + end = str + strlen(str); + len = end - str; + + /* make sure that we have enough room in the buffer */ + while (ofs + len + sizeof(UCI_QUOTE_ESCAPE) + 1 > ctx->bufsz) { + ctx->bufsz *= 2; + ctx->buf = uci_realloc(ctx, ctx->buf, ctx->bufsz); } - strcpy(&ctx->buf[pos], UCI_QUOTE_ESCAPE); - pos += sizeof(UCI_QUOTE_ESCAPE); - s = p + 1; - } while ((p = strchr(s, '\''))); + /* copy the string until the character before the quote */ + memcpy(&ctx->buf[ofs], str, len); + ofs += len; + + /* end of string? return the buffer */ + if (*end == 0) + break; + + memcpy(&ctx->buf[ofs], UCI_QUOTE_ESCAPE, sizeof(UCI_QUOTE_ESCAPE)); + ofs += strlen(&ctx->buf[ofs]); + str = end + 1; + } + + ctx->buf[ofs] = 0; return ctx->buf; } - /* * export a single config package to a file stream */ -static void uci_export_package(struct uci_package *p, FILE *stream) +static void uci_export_package(struct uci_package *p, FILE *stream, bool header) { struct uci_context *ctx = p->ctx; - struct uci_element *s, *o; + struct uci_element *s, *o, *i; - fprintf(stream, "package '%s'\n", uci_escape(ctx, p->e.name)); + if (header) + fprintf(stream, "package %s\n", uci_escape(ctx, p->e.name)); uci_foreach_element(&p->sections, s) { struct uci_section *sec = uci_to_section(s); - fprintf(stream, "\nconfig '%s'", uci_escape(ctx, sec->type)); - fprintf(stream, " '%s'\n", uci_escape(ctx, sec->e.name)); + fprintf(stream, "\nconfig %s", uci_escape(ctx, sec->type)); + if (!sec->anonymous || (ctx->flags & UCI_FLAG_EXPORT_NAME)) + fprintf(stream, " '%s'", uci_escape(ctx, sec->e.name)); + fprintf(stream, "\n"); uci_foreach_element(&sec->options, o) { struct uci_option *opt = uci_to_option(o); - fprintf(stream, "\toption '%s'", uci_escape(ctx, opt->e.name)); - fprintf(stream, " '%s'\n", uci_escape(ctx, opt->value)); + switch(opt->type) { + case UCI_TYPE_STRING: + fprintf(stream, "\toption %s", uci_escape(ctx, opt->e.name)); + fprintf(stream, " '%s'\n", uci_escape(ctx, opt->v.string)); + break; + case UCI_TYPE_LIST: + uci_foreach_element(&opt->v.list, i) { + fprintf(stream, "\tlist %s", uci_escape(ctx, opt->e.name)); + fprintf(stream, " '%s'\n", uci_escape(ctx, i->name)); + } + break; + default: + fprintf(stream, "\t# unknown type for option '%s'\n", uci_escape(ctx, opt->e.name)); + break; + } } } fprintf(stream, "\n"); } -int uci_export(struct uci_context *ctx, FILE *stream, struct uci_package *package) +int uci_export(struct uci_context *ctx, FILE *stream, struct uci_package *package, bool header) { struct uci_element *e; UCI_HANDLE_ERR(ctx); UCI_ASSERT(ctx, stream != NULL); - if (package) { - uci_export_package(package, stream); - goto done; + if (package) + uci_export_package(package, stream, header); + else { + uci_foreach_element(&ctx->root, e) { + uci_export_package(uci_to_package(e), stream, header); + } } - uci_foreach_element(&ctx->root, e) { - uci_export_package(uci_to_package(e), stream); - } -done: return 0; } -int uci_import(struct uci_context *ctx, FILE *stream, const char *name, struct uci_package **package) +int uci_import(struct uci_context *ctx, FILE *stream, const char *name, struct uci_package **package, bool single) { struct uci_parse_context *pctx; + UCI_HANDLE_ERR(ctx); /* make sure no memory from previous parse attempts is leaked */ - uci_file_cleanup(ctx); + uci_cleanup(ctx); - pctx = (struct uci_parse_context *) uci_malloc(ctx, sizeof(struct uci_parse_context)); - ctx->pctx = pctx; + uci_alloc_parse_context(ctx); + pctx = ctx->pctx; pctx->file = stream; + if (package && *package && single) { + pctx->package = *package; + pctx->merge = true; + } /* * If 'name' was supplied, assume that the supplied stream does not contain * the appropriate 'package ' string to specify the config name * NB: the config file can still override the package name */ - if (name) + if (name) { + UCI_ASSERT(ctx, uci_validate_package(name)); pctx->name = name; + } while (!feof(pctx->file)) { uci_getln(ctx, 0); + UCI_TRAP_SAVE(ctx, error); if (pctx->buf[0]) - uci_parse_line(ctx); + uci_parse_line(ctx, single); + UCI_TRAP_RESTORE(ctx); + continue; +error: + if (ctx->flags & UCI_FLAG_PERROR) + uci_perror(ctx, NULL); + if ((ctx->err != UCI_ERR_PARSE) || + (ctx->flags & UCI_FLAG_STRICT)) + UCI_THROW(ctx, ctx->err); } + uci_fixup_section(ctx, ctx->pctx->section); + if (!pctx->package && name) + uci_switch_config(ctx); if (package) *package = pctx->package; + if (pctx->merge) + pctx->package = NULL; pctx->name = NULL; uci_switch_config(ctx); /* no error happened, we can get rid of the parser context now */ - uci_file_cleanup(ctx); + uci_cleanup(ctx); return 0; } -int uci_load(struct uci_context *ctx, const char *name, struct uci_package **package) + +static char *uci_config_path(struct uci_context *ctx, const char *name) { - struct stat statbuf; char *filename; - bool confdir; - FILE *file; - int fd; - UCI_HANDLE_ERR(ctx); - UCI_ASSERT(ctx, name != NULL); + UCI_ASSERT(ctx, uci_validate_package(name)); + filename = uci_malloc(ctx, strlen(name) + strlen(ctx->confdir) + 2); + sprintf(filename, "%s/%s", ctx->confdir, name); - switch (name[0]) { - case '.': - if (name[1] != '/') - UCI_THROW(ctx, UCI_ERR_NOTFOUND); - /* fall through */ - case '/': - /* absolute/relative path outside of /etc/config */ - filename = uci_strdup(ctx, name); - name = strrchr(name, '/') + 1; - confdir = false; - break; - default: - filename = uci_malloc(ctx, strlen(name) + sizeof(UCI_CONFDIR) + 2); - sprintf(filename, UCI_CONFDIR "/%s", name); - confdir = true; - break; - } + return filename; +} - if ((stat(filename, &statbuf) < 0) || - ((statbuf.st_mode & S_IFMT) != S_IFREG)) { - UCI_THROW(ctx, UCI_ERR_NOTFOUND); - } +static void uci_file_commit(struct uci_context *ctx, struct uci_package **package, bool overwrite) +{ + struct uci_package *p = *package; + FILE *f = NULL; + char *name = NULL; + char *path = NULL; - fd = open(filename, O_RDONLY); - if (fd <= 0) - UCI_THROW(ctx, UCI_ERR_IO); + if (!p->path) { + if (overwrite) + p->path = uci_config_path(ctx, p->e.name); + else + UCI_THROW(ctx, UCI_ERR_INVAL); + } - flock(fd, LOCK_SH); - file = fdopen(fd, "r"); - if (!file) - UCI_THROW(ctx, UCI_ERR_IO); + /* open the config file for writing now, so that it is locked */ + f = uci_open_stream(ctx, p->path, SEEK_SET, true, true); - ctx->errno = 0; + /* flush unsaved changes and reload from delta file */ UCI_TRAP_SAVE(ctx, done); - uci_import(ctx, file, name, package); - UCI_TRAP_RESTORE(ctx); + if (p->has_delta) { + if (!overwrite) { + name = uci_strdup(ctx, p->e.name); + path = uci_strdup(ctx, p->path); + /* dump our own changes to the delta file */ + if (!uci_list_empty(&p->delta)) + UCI_INTERNAL(uci_save, ctx, p); + + /* + * other processes might have modified the config + * as well. dump and reload + */ + uci_free_package(&p); + uci_cleanup(ctx); + UCI_INTERNAL(uci_import, ctx, f, name, &p, true); + + p->path = path; + p->has_delta = true; + *package = p; + + /* freed together with the uci_package */ + path = NULL; + } - if (*package) { - (*package)->path = filename; - (*package)->confdir = confdir; + /* flush delta */ + if (!uci_load_delta(ctx, p, true)) + goto done; } + rewind(f); + if (ftruncate(fileno(f), 0) < 0) + UCI_THROW(ctx, UCI_ERR_IO); + + uci_export(ctx, f, p, false); + UCI_TRAP_RESTORE(ctx); + done: - flock(fd, LOCK_UN); - fclose(file); - return ctx->errno; + if (name) + free(name); + if (path) + free(path); + uci_close_stream(f); + if (ctx->err) + UCI_THROW(ctx, ctx->err); } + /* * This function returns the filename by returning the string * after the last '/' character. By checking for a non-'\0' @@ -605,15 +764,20 @@ static inline char *get_filename(char *path) return p; } -char **uci_list_configs(struct uci_context *ctx) +static char **uci_list_config_files(struct uci_context *ctx) { char **configs; glob_t globbuf; int size, i; char *buf; + char *dir; - if (glob(UCI_CONFDIR "/*", GLOB_MARK, NULL, &globbuf) != 0) - return NULL; + dir = uci_malloc(ctx, strlen(ctx->confdir) + 1 + sizeof("/*")); + sprintf(dir, "%s/*", ctx->confdir); + if (glob(dir, GLOB_MARK, NULL, &globbuf) != 0) { + free(dir); + UCI_THROW(ctx, UCI_ERR_NOTFOUND); + } size = sizeof(char *) * (globbuf.gl_pathc + 1); for(i = 0; i < globbuf.gl_pathc; i++) { @@ -626,11 +790,7 @@ char **uci_list_configs(struct uci_context *ctx) size += strlen(p) + 1; } - configs = malloc(size); - if (!configs) - return NULL; - - memset(configs, 0, size); + configs = uci_malloc(ctx, size); buf = (char *) &configs[globbuf.gl_pathc + 1]; for(i = 0; i < globbuf.gl_pathc; i++) { char *p; @@ -639,11 +799,67 @@ char **uci_list_configs(struct uci_context *ctx) if (!p) continue; + if (!uci_validate_package(p)) + continue; + configs[i] = buf; strcpy(buf, p); buf += strlen(buf) + 1; } + free(dir); + globfree(&globbuf); return configs; } +static struct uci_package *uci_file_load(struct uci_context *ctx, const char *name) +{ + struct uci_package *package = NULL; + char *filename; + bool confdir; + FILE *file = NULL; + + switch (name[0]) { + case '.': + /* relative path outside of /etc/config */ + if (name[1] != '/') + UCI_THROW(ctx, UCI_ERR_NOTFOUND); + /* fall through */ + case '/': + /* absolute path outside of /etc/config */ + filename = uci_strdup(ctx, name); + name = strrchr(name, '/') + 1; + confdir = false; + break; + default: + /* config in /etc/config */ + filename = uci_config_path(ctx, name); + confdir = true; + break; + } + + UCI_TRAP_SAVE(ctx, done); + file = uci_open_stream(ctx, filename, SEEK_SET, false, false); + ctx->err = 0; + UCI_INTERNAL(uci_import, ctx, file, name, &package, true); + UCI_TRAP_RESTORE(ctx); + + if (package) { + package->path = filename; + package->has_delta = confdir; + uci_load_delta(ctx, package, false); + } + +done: + uci_close_stream(file); + if (ctx->err) { + free(filename); + UCI_THROW(ctx, ctx->err); + } + return package; +} +__private UCI_BACKEND(uci_file_backend, "file", + .load = uci_file_load, + .commit = uci_file_commit, + .list_configs = uci_list_config_files, +);