delta.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 Lesser General Public License for more details.
  13  */
  14
  15 /*
  16  * This file contains the code for handling uci config delta files
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <sys/file.h>
  23 #include <stdbool.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <ctype.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30
  31 #include "uci.h"
  32 #include "uci_internal.h"
  33
  34 /* record a change that was done to a package */
  35 void
  36 uci_add_delta(struct uci_context *ctx, struct uci_list *list, int cmd, const char *section, const char *option, const char *value)
  37 {
  38         struct uci_delta *h;
  39         int size = strlen(section) + 1;
  40         char *ptr;
  41
  42         if (value)
  43                 size += strlen(value) + 1;
  44
  45         h = uci_alloc_element(ctx, delta, option, size);
  46         ptr = uci_dataptr(h);
  47         h->cmd = cmd;
  48         h->section = strcpy(ptr, section);
  49         if (value) {
  50                 ptr += strlen(ptr) + 1;
  51                 h->value = strcpy(ptr, value);
  52         }
  53         uci_list_add(list, &h->e.list);
  54 }
  55
  56 void
  57 uci_free_delta(struct uci_delta *h)
  58 {
  59         if (!h)
  60                 return;
  61         if ((h->section != NULL) &&
  62                 (h->section != uci_dataptr(h))) {
  63                 free(h->section);
  64                 free(h->value);
  65         }
  66         uci_free_element(&h->e);
  67 }
  68
  69
  70 int uci_set_savedir(struct uci_context *ctx, const char *dir)
  71 {
  72         char *sdir;
  73
  74         UCI_HANDLE_ERR(ctx);
  75         UCI_ASSERT(ctx, dir != NULL);
  76
  77         sdir = uci_strdup(ctx, dir);
  78         if (ctx->savedir != uci_savedir)
  79                 free(ctx->savedir);
  80         ctx->savedir = sdir;
  81         return 0;
  82 }
  83
  84 int uci_add_delta_path(struct uci_context *ctx, const char *dir)
  85 {
  86         struct uci_element *e;
  87
  88         UCI_HANDLE_ERR(ctx);
  89         UCI_ASSERT(ctx, dir != NULL);
  90         if (!strcmp(dir, ctx->savedir))
  91                 return -1;
  92         e = uci_alloc_generic(ctx, UCI_TYPE_PATH, dir, sizeof(struct uci_element));
  93         uci_list_add(&ctx->delta_path, &e->list);
  94
  95         return 0;
  96 }
  97
  98 static inline int uci_parse_delta_tuple(struct uci_context *ctx, struct uci_ptr *ptr)
  99 {
 100         struct uci_parse_context *pctx = ctx->pctx;
 101         char *str = pctx_cur_str(pctx), *arg;
 102         int c = UCI_CMD_CHANGE;
 103
 104         UCI_INTERNAL(uci_parse_argument, ctx, ctx->pctx->file, &str, &arg);
 105         switch(*arg) {
 106         case '^':
 107                 c = UCI_CMD_REORDER;
 108                 break;
 109         case '-':
 110                 c = UCI_CMD_REMOVE;
 111                 break;
 112         case '@':
 113                 c = UCI_CMD_RENAME;
 114                 break;
 115         case '+':
 116                 /* UCI_CMD_ADD is used for anonymous sections or list values */
 117                 c = UCI_CMD_ADD;
 118                 break;
 119         case '|':
 120                 c = UCI_CMD_LIST_ADD;
 121                 break;
 122         case '~':
 123                 c = UCI_CMD_LIST_DEL;
 124                 break;
 125         }
 126
 127         if (c != UCI_CMD_CHANGE)
 128                 arg += 1;
 129
 130         UCI_INTERNAL(uci_parse_ptr, ctx, ptr, arg);
 131
 132         if (!ptr->section)
 133                 goto error;
 134         if (ptr->flags & UCI_LOOKUP_EXTENDED)
 135                 goto error;
 136
 137         switch(c) {
 138         case UCI_CMD_REORDER:
 139                 if (!ptr->value || ptr->option)
 140                         goto error;
 141                 break;
 142         case UCI_CMD_RENAME:
 143                 if (!ptr->value || !uci_validate_name(ptr->value))
 144                         goto error;
 145                 break;
 146         case UCI_CMD_LIST_ADD:
 147                 if (!ptr->option)
 148                         goto error;
 149         case UCI_CMD_LIST_DEL:
 150                 if (!ptr->option)
 151                         goto error;
 152         }
 153
 154         return c;
 155
 156 error:
 157         UCI_THROW(ctx, UCI_ERR_INVAL);
 158         return 0;
 159 }
 160
 161 static void uci_parse_delta_line(struct uci_context *ctx, struct uci_package *p)
 162 {
 163         struct uci_element *e = NULL;
 164         struct uci_ptr ptr;
 165         int cmd;
 166
 167         cmd = uci_parse_delta_tuple(ctx, &ptr);
 168         if (strcmp(ptr.package, p->e.name) != 0)
 169                 goto error;
 170
 171         if (ctx->flags & UCI_FLAG_SAVED_DELTA)
 172                 uci_add_delta(ctx, &p->saved_delta, cmd, ptr.section, ptr.option, ptr.value);
 173
 174         switch(cmd) {
 175         case UCI_CMD_REORDER:
 176                 uci_expand_ptr(ctx, &ptr, true);
 177                 if (!ptr.s)
 178                         UCI_THROW(ctx, UCI_ERR_NOTFOUND);
 179                 UCI_INTERNAL(uci_reorder_section, ctx, ptr.s, strtoul(ptr.value, NULL, 10));
 180                 break;
 181         case UCI_CMD_RENAME:
 182                 UCI_INTERNAL(uci_rename, ctx, &ptr);
 183                 break;
 184         case UCI_CMD_REMOVE:
 185                 UCI_INTERNAL(uci_delete, ctx, &ptr);
 186                 break;
 187         case UCI_CMD_LIST_ADD:
 188                 UCI_INTERNAL(uci_add_list, ctx, &ptr);
 189                 break;
 190         case UCI_CMD_LIST_DEL:
 191                 UCI_INTERNAL(uci_del_list, ctx, &ptr);
 192                 break;
 193         case UCI_CMD_ADD:
 194         case UCI_CMD_CHANGE:
 195                 UCI_INTERNAL(uci_set, ctx, &ptr);
 196                 e = ptr.last;
 197                 if (!ptr.option && e && (cmd == UCI_CMD_ADD))
 198                         uci_to_section(e)->anonymous = true;
 199                 break;
 200         }
 201         return;
 202 error:
 203         UCI_THROW(ctx, UCI_ERR_PARSE);
 204 }
 205
 206 /* returns the number of changes that were successfully parsed */
 207 static int uci_parse_delta(struct uci_context *ctx, FILE *stream, struct uci_package *p)
 208 {
 209         struct uci_parse_context *pctx;
 210         int changes = 0;
 211
 212         /* make sure no memory from previous parse attempts is leaked */
 213         uci_cleanup(ctx);
 214
 215         pctx = (struct uci_parse_context *) uci_malloc(ctx, sizeof(struct uci_parse_context));
 216         ctx->pctx = pctx;
 217         pctx->file = stream;
 218
 219         while (!feof(pctx->file)) {
 220                 pctx->pos = 0;
 221                 uci_getln(ctx, 0);
 222                 if (!pctx->buf[0])
 223                         continue;
 224
 225                 /*
 226                  * ignore parse errors in single lines, we want to preserve as much
 227                  * delta as possible
 228                  */
 229                 UCI_TRAP_SAVE(ctx, error);
 230                 uci_parse_delta_line(ctx, p);
 231                 UCI_TRAP_RESTORE(ctx);
 232                 changes++;
 233 error:
 234                 continue;
 235         }
 236
 237         /* no error happened, we can get rid of the parser context now */
 238         uci_cleanup(ctx);
 239         return changes;
 240 }
 241
 242 /* returns the number of changes that were successfully parsed */
 243 static int uci_load_delta_file(struct uci_context *ctx, struct uci_package *p, char *filename, FILE **f, bool flush)
 244 {
 245         FILE *stream = NULL;
 246         int changes = 0;
 247
 248         UCI_TRAP_SAVE(ctx, done);
 249         stream = uci_open_stream(ctx, filename, NULL, SEEK_SET, flush, false);
 250         if (p)
 251                 changes = uci_parse_delta(ctx, stream, p);
 252         UCI_TRAP_RESTORE(ctx);
 253 done:
 254         if (f)
 255                 *f = stream;
 256         else if (stream)
 257                 uci_close_stream(stream);
 258         return changes;
 259 }
 260
 261 /* returns the number of changes that were successfully parsed */
 262 __private int uci_load_delta(struct uci_context *ctx, struct uci_package *p, bool flush)
 263 {
 264         struct uci_element *e;
 265         char *filename = NULL;
 266         FILE *f = NULL;
 267         int changes = 0;
 268
 269         if (!p->has_delta)
 270                 return 0;
 271
 272         uci_foreach_element(&ctx->delta_path, e) {
 273                 if ((asprintf(&filename, "%s/%s", e->name, p->e.name) < 0) || !filename)
 274                         UCI_THROW(ctx, UCI_ERR_MEM);
 275
 276                 uci_load_delta_file(ctx, p, filename, NULL, false);
 277                 free(filename);
 278         }
 279
 280         if ((asprintf(&filename, "%s/%s", ctx->savedir, p->e.name) < 0) || !filename)
 281                 UCI_THROW(ctx, UCI_ERR_MEM);
 282
 283         changes = uci_load_delta_file(ctx, p, filename, &f, flush);
 284         if (flush && f && (changes > 0)) {
 285                 rewind(f);
 286                 if (ftruncate(fileno(f), 0) < 0) {
 287                         uci_close_stream(f);
 288                         UCI_THROW(ctx, UCI_ERR_IO);
 289                 }
 290         }
 291         free(filename);
 292         uci_close_stream(f);
 293         ctx->err = 0;
 294         return changes;
 295 }
 296
 297 static void uci_filter_delta(struct uci_context *ctx, const char *name, const char *section, const char *option)
 298 {
 299         struct uci_parse_context *pctx;
 300         struct uci_element *e, *tmp;
 301         struct uci_list list;
 302         char *filename = NULL;
 303         struct uci_ptr ptr;
 304         FILE *f = NULL;
 305
 306         uci_list_init(&list);
 307         uci_alloc_parse_context(ctx);
 308         pctx = ctx->pctx;
 309
 310         if ((asprintf(&filename, "%s/%s", ctx->savedir, name) < 0) || !filename)
 311                 UCI_THROW(ctx, UCI_ERR_MEM);
 312
 313         UCI_TRAP_SAVE(ctx, done);
 314         f = uci_open_stream(ctx, filename, NULL, SEEK_SET, true, false);
 315         pctx->file = f;
 316         while (!feof(f)) {
 317                 struct uci_element *e;
 318
 319                 pctx->pos = 0;
 320                 uci_getln(ctx, 0);
 321                 if (!pctx->buf[0])
 322                         continue;
 323
 324                 /* NB: need to allocate the element before the call to
 325                  * uci_parse_delta_tuple, otherwise the original string
 326                  * gets modified before it is saved */
 327                 e = uci_alloc_generic(ctx, UCI_TYPE_DELTA, pctx->buf, sizeof(struct uci_element));
 328                 uci_list_add(&list, &e->list);
 329
 330                 uci_parse_delta_tuple(ctx, &ptr);
 331                 if (section) {
 332                         if (!ptr.section || (strcmp(section, ptr.section) != 0))
 333                                 continue;
 334                 }
 335                 if (option) {
 336                         if (!ptr.option || (strcmp(option, ptr.option) != 0))
 337                                 continue;
 338                 }
 339                 /* match, drop this element again */
 340                 uci_free_element(e);
 341         }
 342
 343         /* rebuild the delta file */
 344         rewind(f);
 345         if (ftruncate(fileno(f), 0) < 0)
 346                 UCI_THROW(ctx, UCI_ERR_IO);
 347         uci_foreach_element_safe(&list, tmp, e) {
 348                 fprintf(f, "%s\n", e->name);
 349                 uci_free_element(e);
 350         }
 351         UCI_TRAP_RESTORE(ctx);
 352
 353 done:
 354         free(filename);
 355         uci_close_stream(pctx->file);
 356         uci_foreach_element_safe(&list, tmp, e) {
 357                 uci_free_element(e);
 358         }
 359         uci_cleanup(ctx);
 360 }
 361
 362 int uci_revert(struct uci_context *ctx, struct uci_ptr *ptr)
 363 {
 364         char *package = NULL;
 365         char *section = NULL;
 366         char *option = NULL;
 367
 368         UCI_HANDLE_ERR(ctx);
 369         uci_expand_ptr(ctx, ptr, false);
 370         UCI_ASSERT(ctx, ptr->p->has_delta);
 371
 372         /*
 373          * - flush unwritten changes
 374          * - save the package name
 375          * - unload the package
 376          * - filter the delta
 377          * - reload the package
 378          */
 379         UCI_TRAP_SAVE(ctx, error);
 380         UCI_INTERNAL(uci_save, ctx, ptr->p);
 381
 382         /* NB: need to clone package, section and option names,
 383          * as they may get freed on uci_free_package() */
 384         package = uci_strdup(ctx, ptr->p->e.name);
 385         if (ptr->section)
 386                 section = uci_strdup(ctx, ptr->section);
 387         if (ptr->option)
 388                 option = uci_strdup(ctx, ptr->option);
 389
 390         uci_free_package(&ptr->p);
 391         uci_filter_delta(ctx, package, section, option);
 392
 393         UCI_INTERNAL(uci_load, ctx, package, &ptr->p);
 394         UCI_TRAP_RESTORE(ctx);
 395         ctx->err = 0;
 396
 397 error:
 398         free(package);
 399         free(section);
 400         free(option);
 401         if (ctx->err)
 402                 UCI_THROW(ctx, ctx->err);
 403         return 0;
 404 }
 405
 406 int uci_save(struct uci_context *ctx, struct uci_package *p)
 407 {
 408         FILE *f = NULL;
 409         char *filename = NULL;
 410         struct uci_element *e, *tmp;
 411         struct stat statbuf;
 412
 413         UCI_HANDLE_ERR(ctx);
 414         UCI_ASSERT(ctx, p != NULL);
 415
 416         /*
 417          * if the config file was outside of the /etc/config path,
 418          * don't save the delta to a file, update the real file
 419          * directly.
 420          * does not modify the uci_package pointer
 421          */
 422         if (!p->has_delta)
 423                 return uci_commit(ctx, &p, false);
 424
 425         if (uci_list_empty(&p->delta))
 426                 return 0;
 427
 428         if (stat(ctx->savedir, &statbuf) < 0) {
 429                 if (stat(ctx->confdir, &statbuf) == 0) {
 430                         mkdir(ctx->savedir, statbuf.st_mode);
 431                 } else {
 432                         mkdir(ctx->savedir, UCI_DIRMODE);
 433                 }
 434         } else if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
 435                 UCI_THROW(ctx, UCI_ERR_IO);
 436         }
 437
 438         if ((asprintf(&filename, "%s/%s", ctx->savedir, p->e.name) < 0) || !filename)
 439                 UCI_THROW(ctx, UCI_ERR_MEM);
 440
 441         ctx->err = 0;
 442         UCI_TRAP_SAVE(ctx, done);
 443         f = uci_open_stream(ctx, filename, NULL, SEEK_END, true, true);
 444         UCI_TRAP_RESTORE(ctx);
 445
 446         uci_foreach_element_safe(&p->delta, tmp, e) {
 447                 struct uci_delta *h = uci_to_delta(e);
 448                 char *prefix = "";
 449
 450                 switch(h->cmd) {
 451                 case UCI_CMD_REMOVE:
 452                         prefix = "-";
 453                         break;
 454                 case UCI_CMD_RENAME:
 455                         prefix = "@";
 456                         break;
 457                 case UCI_CMD_ADD:
 458                         prefix = "+";
 459                         break;
 460                 case UCI_CMD_REORDER:
 461                         prefix = "^";
 462                         break;
 463                 case UCI_CMD_LIST_ADD:
 464                         prefix = "|";
 465                         break;
 466                 case UCI_CMD_LIST_DEL:
 467                         prefix = "~";
 468                         break;
 469                 default:
 470                         break;
 471                 }
 472
 473                 fprintf(f, "%s%s.%s", prefix, p->e.name, h->section);
 474                 if (e->name)
 475                         fprintf(f, ".%s", e->name);
 476
 477                 if (h->cmd == UCI_CMD_REMOVE && !h->value)
 478                         fprintf(f, "\n");
 479                 else {
 480                         int i;
 481
 482                         fprintf(f, "='");
 483                         for (i = 0; h->value[i]; i++) {
 484                                 unsigned char c = h->value[i];
 485                                 if (c != '\'')
 486                                         fputc(c, f);
 487                                 else
 488                                         fprintf(f, "'\\''");
 489                         }
 490                         fprintf(f, "'\n");
 491                 }
 492                 uci_free_delta(h);
 493         }
 494
 495 done:
 496         uci_close_stream(f);
 497         free(filename);
 498         if (ctx->err)
 499                 UCI_THROW(ctx, ctx->err);
 500
 501         return 0;
 502 }
 503
 504