util.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 wrappers to standard functions, which
  17  * throw exceptions upon failure.
  18  */
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <sys/file.h>
  22 #include <stdbool.h>
  23 #include <unistd.h>
  24 #include <ctype.h>
  25 #include <fcntl.h>
  26
  27 #define LINEBUF 32
  28 #define LINEBUF_MAX     4096
  29
  30 static void *uci_malloc(struct uci_context *ctx, size_t size)
  31 {
  32         void *ptr;
  33
  34         ptr = malloc(size);
  35         if (!ptr)
  36                 UCI_THROW(ctx, UCI_ERR_MEM);
  37         memset(ptr, 0, size);
  38
  39         return ptr;
  40 }
  41
  42 static void *uci_realloc(struct uci_context *ctx, void *ptr, size_t size)
  43 {
  44         ptr = realloc(ptr, size);
  45         if (!ptr)
  46                 UCI_THROW(ctx, UCI_ERR_MEM);
  47
  48         return ptr;
  49 }
  50
  51 static char *uci_strdup(struct uci_context *ctx, const char *str)
  52 {
  53         char *ptr;
  54
  55         ptr = strdup(str);
  56         if (!ptr)
  57                 UCI_THROW(ctx, UCI_ERR_MEM);
  58
  59         return ptr;
  60 }
  61
  62 /*
  63  * validate strings for names and types, reject special characters
  64  * for names, only alphanum and _ is allowed (shell compatibility)
  65  * for types, we allow more characters
  66  */
  67 static bool uci_validate_str(const char *str, bool name)
  68 {
  69         if (!*str)
  70                 return false;
  71
  72         while (*str) {
  73                 char c = *str;
  74                 if (!isalnum(c) && c != '_') {
  75                         if (name || (c < 33) || (c > 126))
  76                                 return false;
  77                 }
  78                 str++;
  79         }
  80         return true;
  81 }
  82
  83 static inline bool uci_validate_name(const char *str)
  84 {
  85         return uci_validate_str(str, true);
  86 }
  87
  88 static void uci_alloc_parse_context(struct uci_context *ctx)
  89 {
  90         ctx->pctx = (struct uci_parse_context *) uci_malloc(ctx, sizeof(struct uci_parse_context));
  91 }
  92
  93 int uci_parse_tuple(struct uci_context *ctx, char *str, char **package, char **section, char **option, char **value)
  94 {
  95         char *last = NULL;
  96
  97         UCI_HANDLE_ERR(ctx);
  98         UCI_ASSERT(ctx, str && package && section && option);
  99
 100         *package = strtok(str, ".");
 101         if (!*package || !uci_validate_name(*package))
 102                 goto error;
 103
 104         last = *package;
 105         *section = strtok(NULL, ".");
 106         if (!*section)
 107                 goto lastval;
 108
 109         last = *section;
 110         *option = strtok(NULL, ".");
 111         if (!*option)
 112                 goto lastval;
 113
 114         last = *option;
 115
 116 lastval:
 117         last = strchr(last, '=');
 118         if (last) {
 119                 if (!value)
 120                         goto error;
 121
 122                 *last = 0;
 123                 last++;
 124                 if (!*last)
 125                         goto error;
 126                 *value = last;
 127         }
 128
 129         if (*section && !uci_validate_name(*section))
 130                 goto error;
 131         if (*option && !uci_validate_name(*option))
 132                 goto error;
 133
 134         goto done;
 135
 136 error:
 137         UCI_THROW(ctx, UCI_ERR_PARSE);
 138
 139 done:
 140         return 0;
 141 }
 142
 143
 144 static void uci_parse_error(struct uci_context *ctx, char *pos, char *reason)
 145 {
 146         struct uci_parse_context *pctx = ctx->pctx;
 147
 148         pctx->reason = reason;
 149         if ((pos < pctx->buf) || (pos > pctx->buf + pctx->bufsz))
 150                 pctx->byte = 0;
 151         else
 152                 pctx->byte = pos - pctx->buf;
 153         UCI_THROW(ctx, UCI_ERR_PARSE);
 154 }
 155
 156
 157 /*
 158  * Fetch a new line from the input stream and resize buffer if necessary
 159  */
 160 static void uci_getln(struct uci_context *ctx, int offset)
 161 {
 162         struct uci_parse_context *pctx = ctx->pctx;
 163         char *p;
 164         int ofs;
 165
 166         if (pctx->buf == NULL) {
 167                 pctx->buf = uci_malloc(ctx, LINEBUF);
 168                 pctx->bufsz = LINEBUF;
 169         }
 170
 171         ofs = offset;
 172         do {
 173                 p = &pctx->buf[ofs];
 174                 p[ofs] = 0;
 175
 176                 p = fgets(p, pctx->bufsz - ofs, pctx->file);
 177                 if (!p || !*p)
 178                         return;
 179
 180                 ofs += strlen(p);
 181                 if (pctx->buf[ofs - 1] == '\n') {
 182                         pctx->line++;
 183                         pctx->buf[ofs - 1] = 0;
 184                         return;
 185                 }
 186
 187                 if (pctx->bufsz > LINEBUF_MAX/2)
 188                         uci_parse_error(ctx, p, "line too long");
 189
 190                 pctx->bufsz *= 2;
 191                 pctx->buf = uci_realloc(ctx, pctx->buf, pctx->bufsz);
 192         } while (1);
 193 }
 194
 195 /*
 196  * parse a character escaped by '\'
 197  * returns true if the escaped character is to be parsed
 198  * returns false if the escaped character is to be ignored
 199  */
 200 static inline bool parse_backslash(struct uci_context *ctx, char **str)
 201 {
 202         /* skip backslash */
 203         *str += 1;
 204
 205         /* undecoded backslash at the end of line, fetch the next line */
 206         if (!**str) {
 207                 *str += 1;
 208                 uci_getln(ctx, *str - ctx->pctx->buf);
 209                 return false;
 210         }
 211
 212         /* FIXME: decode escaped char, necessary? */
 213         return true;
 214 }
 215
 216 /*
 217  * move the string pointer forward until a non-whitespace character or
 218  * EOL is reached
 219  */
 220 static void skip_whitespace(struct uci_context *ctx, char **str)
 221 {
 222 restart:
 223         while (**str && isspace(**str))
 224                 *str += 1;
 225
 226         if (**str == '\\') {
 227                 if (!parse_backslash(ctx, str))
 228                         goto restart;
 229         }
 230 }
 231
 232 static inline void addc(char **dest, char **src)
 233 {
 234         **dest = **src;
 235         *dest += 1;
 236         *src += 1;
 237 }
 238
 239 /*
 240  * parse a double quoted string argument from the command line
 241  */
 242 static void parse_double_quote(struct uci_context *ctx, char **str, char **target)
 243 {
 244         char c;
 245
 246         /* skip quote character */
 247         *str += 1;
 248
 249         while ((c = **str)) {
 250                 switch(c) {
 251                 case '"':
 252                         **target = 0;
 253                         *str += 1;
 254                         return;
 255                 case '\\':
 256                         if (!parse_backslash(ctx, str))
 257                                 continue;
 258                         /* fall through */
 259                 default:
 260                         addc(target, str);
 261                         break;
 262                 }
 263         }
 264         uci_parse_error(ctx, *str, "unterminated \"");
 265 }
 266
 267 /*
 268  * parse a single quoted string argument from the command line
 269  */
 270 static void parse_single_quote(struct uci_context *ctx, char **str, char **target)
 271 {
 272         char c;
 273         /* skip quote character */
 274         *str += 1;
 275
 276         while ((c = **str)) {
 277                 switch(c) {
 278                 case '\'':
 279                         **target = 0;
 280                         *str += 1;
 281                         return;
 282                 default:
 283                         addc(target, str);
 284                 }
 285         }
 286         uci_parse_error(ctx, *str, "unterminated '");
 287 }
 288
 289 /*
 290  * parse a string from the command line and detect the quoting style
 291  */
 292 static void parse_str(struct uci_context *ctx, char **str, char **target)
 293 {
 294         do {
 295                 switch(**str) {
 296                 case '\'':
 297                         parse_single_quote(ctx, str, target);
 298                         break;
 299                 case '"':
 300                         parse_double_quote(ctx, str, target);
 301                         break;
 302                 case '#':
 303                         **str = 0;
 304                         /* fall through */
 305                 case 0:
 306                         goto done;
 307                 case '\\':
 308                         if (!parse_backslash(ctx, str))
 309                                 continue;
 310                         /* fall through */
 311                 default:
 312                         addc(target, str);
 313                         break;
 314                 }
 315         } while (**str && !isspace(**str));
 316 done:
 317
 318         /*
 319          * if the string was unquoted and we've stopped at a whitespace
 320          * character, skip to the next one, because the whitespace will
 321          * be overwritten by a null byte here
 322          */
 323         if (**str)
 324                 *str += 1;
 325
 326         /* terminate the parsed string */
 327         **target = 0;
 328 }
 329
 330 /*
 331  * extract the next argument from the command line
 332  */
 333 static char *next_arg(struct uci_context *ctx, char **str, bool required, bool name)
 334 {
 335         char *val;
 336         char *ptr;
 337
 338         val = ptr = *str;
 339         skip_whitespace(ctx, str);
 340         parse_str(ctx, str, &ptr);
 341         if (!*val) {
 342                 if (required)
 343                         uci_parse_error(ctx, *str, "insufficient arguments");
 344                 goto done;
 345         }
 346
 347         if (name && !uci_validate_name(val))
 348                 uci_parse_error(ctx, val, "invalid character in field");
 349
 350 done:
 351         return val;
 352 }
 353
 354 int uci_parse_argument(struct uci_context *ctx, char **str, char **result)
 355 {
 356         UCI_HANDLE_ERR(ctx);
 357         UCI_ASSERT(ctx, (str != NULL) && (*str != NULL));
 358         UCI_ASSERT(ctx, result != NULL);
 359
 360         *result = next_arg(ctx, str, false, false);
 361         return 0;
 362 }
 363
 364
 365 /*
 366  * open a stream and go to the right position
 367  *
 368  * note: when opening for write and seeking to the beginning of
 369  * the stream, truncate the file
 370  */
 371 static FILE *uci_open_stream(struct uci_context *ctx, const char *filename, int pos, bool write, bool create)
 372 {
 373         struct stat statbuf;
 374         FILE *file = NULL;
 375         int fd, ret;
 376         int mode = (write ? O_RDWR : O_RDONLY);
 377
 378         if (create)
 379                 mode |= O_CREAT;
 380
 381         if (!write && ((stat(filename, &statbuf) < 0) ||
 382                 ((statbuf.st_mode &  S_IFMT) != S_IFREG))) {
 383                 UCI_THROW(ctx, UCI_ERR_NOTFOUND);
 384         }
 385
 386         fd = open(filename, mode, UCI_FILEMODE);
 387         if (fd <= 0)
 388                 goto error;
 389
 390         if (flock(fd, (write ? LOCK_EX : LOCK_SH)) < 0)
 391                 goto error;
 392
 393         ret = lseek(fd, 0, pos);
 394
 395         if (ret < 0)
 396                 goto error;
 397
 398         file = fdopen(fd, (write ? "w+" : "r"));
 399         if (file)
 400                 goto done;
 401
 402 error:
 403         UCI_THROW(ctx, UCI_ERR_IO);
 404 done:
 405         return file;
 406 }
 407
 408 static void uci_close_stream(FILE *stream)
 409 {
 410         int fd;
 411
 412         if (!stream)
 413                 return;
 414
 415         fd = fileno(stream);
 416         flock(fd, LOCK_UN);
 417         fclose(stream);
 418 }
 419
 420