X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fuci.git;a=blobdiff_plain;f=file.c;h=169cf6ee7190bffbff69ee24a454238bf6fb9ae3;hp=601fef5939380ca049480c20d599450171470dea;hb=cf66ea9067d3e9ffe77f42723c5b2f9d38b05ecf;hpb=57b39c44a303280bf94e4b68401b8d0d49c050ce diff --git a/file.c b/file.c index 601fef5..169cf6e 100644 --- a/file.c +++ b/file.c @@ -2,9 +2,9 @@ * 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 @@ -16,56 +16,15 @@ * This file contains the code for parsing uci config files */ +#define _GNU_SOURCE #include -#include +#include #include +#include +#include #include #include -#define LINEBUF 32 -#define LINEBUF_MAX 4096 - -/* - * Fetch a new line from the input stream and resize buffer if necessary - */ -static void uci_getln(struct uci_context *ctx, int offset) -{ - struct uci_parse_context *pctx = ctx->pctx; - char *p; - int ofs; - - if (pctx->buf == NULL) { - pctx->buf = uci_malloc(ctx, LINEBUF); - pctx->bufsz = LINEBUF; - } - - ofs = offset; - do { - p = &pctx->buf[ofs]; - p[ofs] = 0; - - p = fgets(p, pctx->bufsz - ofs, pctx->file); - if (!p || !*p) - return; - - ofs += strlen(p); - if (pctx->buf[ofs - 1] == '\n') { - pctx->line++; - 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); - } - - 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 */ @@ -85,16 +44,15 @@ static void uci_file_cleanup(struct uci_context *ctx) ctx->pctx = NULL; if (pctx->package) - uci_free_package(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 @@ -164,9 +122,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 \""); } /* @@ -188,9 +144,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 '"); } /* @@ -206,6 +160,9 @@ 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 '\\': @@ -234,7 +191,7 @@ 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; @@ -242,12 +199,16 @@ static char *next_arg(struct uci_context *ctx, char **str, bool required) 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 (!*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; } @@ -259,12 +220,9 @@ 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); - } + tmp = next_arg(ctx, str, false, false); + if (tmp && *tmp && (ctx->flags & UCI_FLAG_STRICT)) + uci_parse_error(ctx, *str, "too many arguments"); } /* @@ -274,6 +232,7 @@ static void assert_eol(struct uci_context *ctx, char **str) static void uci_switch_config(struct uci_context *ctx) { struct uci_parse_context *pctx; + struct uci_element *e; const char *name; pctx = ctx->pctx; @@ -294,55 +253,108 @@ 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); - uci_unload(ctx, name); - UCI_TRAP_RESTORE(ctx); -ignore: - ctx->errno = 0; - + e = uci_lookup_list(ctx, &ctx->root, name); + if (e) + 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); } +/* Based on an efficient hash function published by D. J. Bernstein */ +static unsigned int djbhash(unsigned int hash, char *str) +{ + int len = strlen(str); + int i; + + /* initial value */ + if (hash == ~0) + hash = 5381; + + for(i = 0; i < len; i++) { + hash = ((hash << 5) + hash) + str[i]; + } + return (hash & 0x7FFFFFFF); +} + +/* fix up an unnamed section */ +static void uci_fixup_section(struct uci_context *ctx, struct uci_section *s) +{ + unsigned int hash = ~0; + struct uci_element *e; + char buf[16]; + + if (!s || s->e.name) + return; + + /* + * Generate a name for unnamed sections. This is used as reference + * when locating or updating the section from apps/scripts. + * To make multiple concurrent versions somewhat safe for updating, + * the name is generated from a hash of its type and name/value + * pairs of its option, and it is prefixed by a counter value. + * If the order of the unnamed sections changes for some reason, + * updates to them will be rejected. + */ + hash = djbhash(hash, s->type); + uci_foreach_element(&s->options, e) { + hash = djbhash(hash, e->name); + hash = djbhash(hash, uci_to_option(e)->value); + } + sprintf(buf, "cfg%02x%04x", ++s->package->n_section, hash % (1 << 16)); + s->e.name = uci_strdup(ctx, buf); +} + /* * parse the 'config' uci command (open a section) */ static void uci_parse_config(struct uci_context *ctx, char **str) { + struct uci_parse_context *pctx = ctx->pctx; 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, true); + name = next_arg(ctx, str, false, true); assert_eol(ctx, str); - ctx->pctx->section = uci_alloc_section(ctx->pctx->package, type, name); + + if (pctx->merge) { + UCI_TRAP_SAVE(ctx, error); + uci_set(ctx, pctx->package, name, NULL, type); + UCI_TRAP_RESTORE(ctx); + return; +error: + UCI_THROW(ctx, ctx->errno); + } else + pctx->section = uci_alloc_section(pctx->package, type, name); } /* @@ -350,28 +362,36 @@ static void uci_parse_config(struct uci_context *ctx, char **str) */ static void uci_parse_option(struct uci_context *ctx, char **str) { + struct uci_parse_context *pctx = ctx->pctx; 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 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, true, false); assert_eol(ctx, str); - uci_alloc_option(ctx->pctx->section, name, value); + + if (pctx->merge) { + UCI_TRAP_SAVE(ctx, error); + uci_set(ctx, pctx->package, pctx->section->e.name, name, value); + UCI_TRAP_RESTORE(ctx); + return; +error: + UCI_THROW(ctx, ctx->errno); + } else + uci_alloc_option(pctx->section, name, value); } /* * 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; @@ -383,10 +403,15 @@ static void uci_parse_line(struct uci_context *ctx) char *pbrk = NULL; word = strtok_r(word, " \t", &pbrk); + if (!word) + continue; + switch(word[0]) { + case '#': + return; case 'p': if ((word[1] == 0) || !strcmp(word + 1, "ackage")) - uci_parse_package(ctx, &word); + uci_parse_package(ctx, &word, single); break; case 'c': if ((word[1] == 0) || !strcmp(word + 1, "onfig")) @@ -397,16 +422,14 @@ static void uci_parse_line(struct uci_context *ctx) uci_parse_option(ctx, &word); break; default: - pctx->reason = "unterminated command"; - pctx->byte = word - pctx->buf; - UCI_THROW(ctx, UCI_ERR_PARSE); + uci_parse_error(ctx, word, "unterminated command"); break; } } } /* max number of characters that escaping adds to the string */ -#define UCI_QUOTE_ESCAPE "'\\'" +#define UCI_QUOTE_ESCAPE "'\\''" /* * escape an uci string for export @@ -450,16 +473,19 @@ static char *uci_escape(struct uci_context *ctx, char *str) /* * 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; - 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)); + 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)); @@ -469,52 +495,70 @@ static void uci_export_package(struct uci_package *p, FILE *stream) 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); - 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 && 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_name(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->errno != UCI_ERR_PARSE) || + (ctx->flags & UCI_FLAG_STRICT)) + UCI_THROW(ctx, ctx->errno); } + uci_fixup_section(ctx, ctx->pctx->section); if (package) *package = pctx->package; + if (pctx->merge) + pctx->package = NULL; pctx->name = NULL; uci_switch_config(ctx); @@ -525,45 +569,137 @@ int uci_import(struct uci_context *ctx, FILE *stream, const char *name, struct u return 0; } + +static char *uci_config_path(struct uci_context *ctx, const char *name) +{ + char *filename; + + UCI_ASSERT(ctx, uci_validate_name(name)); + filename = uci_malloc(ctx, strlen(name) + strlen(ctx->confdir) + 2); + sprintf(filename, "%s/%s", ctx->confdir, name); + + return filename; +} + int uci_load(struct uci_context *ctx, const char *name, struct uci_package **package) { - struct stat statbuf; char *filename; - bool confpath; - FILE *file; + bool confdir; + FILE *file = NULL; UCI_HANDLE_ERR(ctx); - UCI_ASSERT(ctx, name != NULL); switch (name[0]) { case '.': + /* relative path outside of /etc/config */ + if (name[1] != '/') + UCI_THROW(ctx, UCI_ERR_NOTFOUND); + /* fall through */ case '/': - /* absolute/relative path outside of /etc/config */ - filename = (char *) name; - confpath = false; + /* absolute 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); - confpath = true; + /* config in /etc/config */ + filename = uci_config_path(ctx, name); + confdir = true; break; } - if ((stat(filename, &statbuf) < 0) || - ((statbuf.st_mode & S_IFMT) != S_IFREG)) { - UCI_THROW(ctx, UCI_ERR_NOTFOUND); + file = uci_open_stream(ctx, filename, SEEK_SET, false, false); + ctx->errno = 0; + UCI_TRAP_SAVE(ctx, done); + UCI_INTERNAL(uci_import, ctx, file, name, package, true); + UCI_TRAP_RESTORE(ctx); + + if (*package) { + (*package)->path = filename; + (*package)->confdir = confdir; + uci_load_history(ctx, *package, false); } - file = fopen(filename, "r"); - if (filename != name) - free(filename); +done: + uci_close_stream(file); + return ctx->errno; +} + +int uci_commit(struct uci_context *ctx, struct uci_package **package, bool overwrite) +{ + struct uci_package *p; + FILE *f = NULL; + char *name = NULL; + char *path = NULL; + + UCI_HANDLE_ERR(ctx); + UCI_ASSERT(ctx, package != NULL); + p = *package; + + UCI_ASSERT(ctx, p != NULL); + if (!p->path) { + if (overwrite) + p->path = uci_config_path(ctx, p->e.name); + else + UCI_THROW(ctx, UCI_ERR_INVAL); + } - if (!file) - UCI_THROW(ctx, UCI_ERR_IO); - return uci_import(ctx, file, name, package); + /* open the config file for writing now, so that it is locked */ + f = uci_open_stream(ctx, p->path, SEEK_SET, true, true); + + /* flush unsaved changes and reload from history file */ + UCI_TRAP_SAVE(ctx, done); + if (p->confdir) { + if (!overwrite) { + name = uci_strdup(ctx, p->e.name); + path = uci_strdup(ctx, p->path); + /* dump our own changes to the history file */ + if (!uci_list_empty(&p->history)) + UCI_INTERNAL(uci_save, ctx, p); + + /* + * other processes might have modified the config + * as well. dump and reload + */ + uci_free_package(&p); + uci_file_cleanup(ctx); + UCI_INTERNAL(uci_import, ctx, f, name, &p, true); + + p->path = path; + p->confdir = true; + *package = p; + + /* freed together with the uci_package */ + path = NULL; + + /* check for updated history, flush */ + uci_load_history(ctx, p, true); + } else { + /* flush history */ + uci_load_history(ctx, NULL, true); + } + } + + rewind(f); + ftruncate(fileno(f), 0); + + uci_export(ctx, f, p, false); + UCI_TRAP_RESTORE(ctx); + +done: + if (name) + free(name); + if (path) + free(path); + uci_close_stream(f); + if (ctx->errno) + UCI_THROW(ctx, ctx->errno); + + return 0; } + /* * This function returns the filename by returning the string * after the last '/' character. By checking for a non-'\0' @@ -581,15 +717,20 @@ static inline char *get_filename(char *path) return p; } -char **uci_list_configs(struct uci_context *ctx) +int uci_list_configs(struct uci_context *ctx, char ***list) { char **configs; glob_t globbuf; int size, i; char *buf; + char *dir; - if (glob(UCI_CONFDIR "/*", GLOB_MARK, NULL, &globbuf) != 0) - return NULL; + UCI_HANDLE_ERR(ctx); + + dir = uci_malloc(ctx, strlen(ctx->confdir) + 1 + sizeof("/*")); + sprintf(dir, "%s/*", ctx->confdir); + if (glob(dir, GLOB_MARK, NULL, &globbuf) != 0) + UCI_THROW(ctx, UCI_ERR_NOTFOUND); size = sizeof(char *) * (globbuf.gl_pathc + 1); for(i = 0; i < globbuf.gl_pathc; i++) { @@ -602,11 +743,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; @@ -619,7 +756,9 @@ char **uci_list_configs(struct uci_context *ctx) strcpy(buf, p); buf += strlen(buf) + 1; } - return configs; -} + *list = configs; + free(dir); + return 0; +}