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