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