parse.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 /*
  16  * This file contains the code for parsing uci config files
  17  */
  18
  19 #include <ctype.h>
  20
  21 #define LINEBUF 128
  22 #define LINEBUF_MAX     4096
  23
  24 /*
  25  * Fetch a new line from the input stream and resize buffer if necessary
  26  */
  27 static void uci_getln(struct uci_context *ctx)
  28 {
  29         struct uci_parse_context *pctx = ctx->pctx;
  30         char *p;
  31         int ofs;
  32
  33         if (pctx->buf == NULL) {
  34                 pctx->buf = uci_malloc(ctx, LINEBUF);
  35                 pctx->bufsz = LINEBUF;
  36         }
  37
  38         ofs = 0;
  39         do {
  40                 p = &pctx->buf[ofs];
  41                 p[ofs] = 0;
  42
  43                 p = fgets(p, pctx->bufsz - ofs, pctx->file);
  44                 if (!p || !p[ofs])
  45                         return;
  46
  47                 ofs += strlen(p);
  48                 if (pctx->buf[ofs - 1] == '\n') {
  49                         pctx->line++;
  50                         pctx->buf[ofs - 1] = 0;
  51                         return;
  52                 }
  53
  54                 if (pctx->bufsz > LINEBUF_MAX/2) {
  55                         pctx->byte = LINEBUF_MAX;
  56                         UCI_THROW(ctx, UCI_ERR_PARSE);
  57                 }
  58
  59                 pctx->bufsz *= 2;
  60                 pctx->buf = uci_realloc(ctx, pctx->buf, pctx->bufsz);
  61         } while (1);
  62 }
  63
  64 /*
  65  * Clean up all extra memory used by the parser
  66  */
  67 static void uci_parse_cleanup(struct uci_context *ctx)
  68 {
  69         struct uci_parse_context *pctx;
  70
  71         pctx = ctx->pctx;
  72         if (!pctx)
  73                 return;
  74
  75         if (pctx->cfg) {
  76                 uci_list_del(&pctx->cfg->list);
  77                 uci_drop_file(pctx->cfg);
  78         }
  79         if (pctx->buf)
  80                 free(pctx->buf);
  81         if (pctx->file)
  82                 fclose(pctx->file);
  83
  84         free(pctx);
  85 }
  86
  87 /*
  88  * move the string pointer forward until a non-whitespace character or
  89  * EOL is reached
  90  */
  91 static void skip_whitespace(char **str)
  92 {
  93         while (**str && isspace(**str))
  94                 *str += 1;
  95 }
  96
  97 /*
  98  * parse a double quoted string argument from the command line
  99  */
 100 static char *parse_double_quote(char **str)
 101 {
 102         char *val;
 103
 104         *str += 1;
 105         val = *str;
 106         while (**str) {
 107
 108                 /* skip escaped characters */
 109                 if (**str == '\\') {
 110                         *str += 2;
 111                         continue;
 112                 }
 113
 114                 /* check for the end of the quoted string */
 115                 if (**str == '"') {
 116                         **str = 0;
 117                         *str += 1;
 118                         return val;
 119                 }
 120                 *str += 1;
 121         }
 122
 123         return NULL;
 124 }
 125
 126 /*
 127  * parse a single quoted string argument from the command line
 128  */
 129 static char *parse_single_quote(char **str)
 130 {
 131         /* TODO: implement */
 132         return NULL;
 133 }
 134
 135 /*
 136  * extract the next word from the command line (unquoted argument)
 137  */
 138 static char *parse_unquoted(char **str)
 139 {
 140         char *val;
 141
 142         val = *str;
 143
 144         while (**str && !isspace(**str))
 145                 *str += 1;
 146
 147         if (**str) {
 148                 **str = 0;
 149                 *str += 1;
 150         }
 151
 152         return val;
 153 }
 154
 155 /*
 156  * extract the next argument from the command line
 157  */
 158 static char *next_arg(struct uci_context *ctx, char **str, bool required)
 159 {
 160         char *val;
 161
 162         skip_whitespace(str);
 163         switch (**str) {
 164                 case '"':
 165                         val = parse_double_quote(str);
 166                 case '\'':
 167                         val = parse_single_quote(str);
 168                 case 0:
 169                         val = NULL;
 170                 default:
 171                         val = parse_unquoted(str);
 172         }
 173
 174         if (required && !val) {
 175                 ctx->pctx->byte = *str - ctx->pctx->buf;
 176                 UCI_THROW(ctx, UCI_ERR_PARSE);
 177         }
 178
 179         return val;
 180 }
 181
 182 /*
 183  * verify that the end of the line or command is reached.
 184  * throw an error if extra arguments are given on the command line
 185  */
 186 static void assert_eol(struct uci_context *ctx, char **str)
 187 {
 188         char *tmp;
 189
 190         tmp = next_arg(ctx, str, false);
 191         if (tmp && *tmp) {
 192                 ctx->pctx->byte = tmp - ctx->pctx->buf;
 193                 UCI_THROW(ctx, UCI_ERR_PARSE);
 194         }
 195 }
 196
 197 /*
 198  * parse the 'config' uci command (open a section)
 199  */
 200 static void uci_parse_config(struct uci_context *ctx, char **str)
 201 {
 202         char *type, *name;
 203
 204         *str += strlen(*str) + 1;
 205
 206         if (!*str) {
 207                 ctx->pctx->byte = *str - ctx->pctx->buf;
 208                 UCI_THROW(ctx, UCI_ERR_PARSE);
 209         }
 210
 211         type = next_arg(ctx, str, true);
 212         name = next_arg(ctx, str, false);
 213         assert_eol(ctx, str);
 214
 215         DPRINTF("Section<%s>: %s\n", type, name);
 216 }
 217
 218 /*
 219  * parse the 'option' uci command (open a value)
 220  */
 221 static void uci_parse_option(struct uci_context *ctx, char **str)
 222 {
 223         char *name, *value;
 224
 225         *str += strlen(*str) + 1;
 226
 227         name = next_arg(ctx, str, true);
 228         value = next_arg(ctx, str, true);
 229         assert_eol(ctx, str);
 230
 231         DPRINTF("\tOption: %s=\"%s\"\n", name, value);
 232 }
 233
 234 /*
 235  * parse a complete input line, split up combined commands by ';'
 236  */
 237 static void uci_parse_line(struct uci_context *ctx)
 238 {
 239         struct uci_parse_context *pctx = ctx->pctx;
 240         char *word, *brk;
 241
 242         for (word = strtok_r(pctx->buf, ";", &brk);
 243                  word;
 244                  word = strtok_r(NULL, ";", &brk)) {
 245
 246                 char *pbrk;
 247                 word = strtok_r(word, " \t", &pbrk);
 248
 249                 switch(word[0]) {
 250                         case 'c':
 251                                 if ((word[1] == 0) || !strcmp(word + 1, "onfig"))
 252                                         uci_parse_config(ctx, &word);
 253                                 break;
 254                         case 'o':
 255                                 if ((word[1] == 0) || !strcmp(word + 1, "ption"))
 256                                         uci_parse_option(ctx, &word);
 257                                 break;
 258                         default:
 259                                 pctx->byte = word - pctx->buf;
 260                                 UCI_THROW(ctx, UCI_ERR_PARSE);
 261                                 break;
 262                 }
 263         }
 264 }
 265
 266 int uci_parse(struct uci_context *ctx, const char *name)
 267 {
 268         struct uci_parse_context *pctx;
 269
 270         UCI_HANDLE_ERR(ctx);
 271         UCI_ASSERT(ctx, name != NULL);
 272
 273         /* make sure no memory from previous parse attempts is leaked */
 274         uci_parse_cleanup(ctx);
 275
 276         pctx = (struct uci_parse_context *) uci_malloc(ctx, sizeof(struct uci_parse_context));
 277         ctx->pctx = pctx;
 278
 279         /* TODO: use /etc/config/ */
 280         pctx->file = fopen(name, "r");
 281         if (!pctx->file)
 282                 UCI_THROW(ctx, UCI_ERR_NOTFOUND);
 283
 284         pctx->cfg = uci_alloc_file(ctx, name);
 285
 286         while (!feof(pctx->file)) {
 287                 uci_getln(ctx);
 288                 if (*(pctx->buf))
 289                         uci_parse_line(ctx);
 290         }
 291
 292         /* add to main config file list */
 293         uci_list_add(&ctx->root, &pctx->cfg->list);
 294         pctx->cfg = NULL;
 295
 296         /* if no error happened, we can get rid of the parser context now */
 297         uci_parse_cleanup(ctx);
 298
 299         return 0;
 300 }
 301
 302