• source navigation  • diff markup  • identifier search  • freetext search  • 

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

This page was automatically generated by LXR 0.3.1.  •  OpenWrt