chiark / gitweb /
build-sys: restructure logind parts in Makefile.am and add --disable-logind
[elogind.git] / src / conf-parser.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <string.h>
23 #include <stdio.h>
24 #include <errno.h>
25 #include <assert.h>
26 #include <stdlib.h>
27
28 #include "conf-parser.h"
29 #include "util.h"
30 #include "macro.h"
31 #include "strv.h"
32 #include "log.h"
33
34 int config_item_table_lookup(
35                 void *table,
36                 const char *section,
37                 const char *lvalue,
38                 ConfigParserCallback *func,
39                 int *ltype,
40                 void **data,
41                 void *userdata) {
42
43         ConfigTableItem *t;
44
45         assert(table);
46         assert(lvalue);
47         assert(func);
48         assert(ltype);
49         assert(data);
50
51         for (t = table; t->lvalue; t++) {
52
53                 if (!streq(lvalue, t->lvalue))
54                         continue;
55
56                 if (!streq_ptr(section, t->section))
57                         continue;
58
59                 *func = t->parse;
60                 *ltype = t->ltype;
61                 *data = t->data;
62                 return 1;
63         }
64
65         return 0;
66 }
67
68 int config_item_perf_lookup(
69                 void *table,
70                 const char *section,
71                 const char *lvalue,
72                 ConfigParserCallback *func,
73                 int *ltype,
74                 void **data,
75                 void *userdata) {
76
77         ConfigPerfItemLookup lookup = (ConfigPerfItemLookup) table;
78         const ConfigPerfItem *p;
79
80         assert(table);
81         assert(lvalue);
82         assert(func);
83         assert(ltype);
84         assert(data);
85
86         if (!section)
87                 p = lookup(lvalue, strlen(lvalue));
88         else {
89                 char *key;
90
91                 key = join(section, ".", lvalue, NULL);
92                 if (!key)
93                         return -ENOMEM;
94
95                 p = lookup(key, strlen(key));
96                 free(key);
97         }
98
99         if (!p)
100                 return 0;
101
102         *func = p->parse;
103         *ltype = p->ltype;
104         *data = (uint8_t*) userdata + p->offset;
105         return 1;
106 }
107
108 /* Run the user supplied parser for an assignment */
109 static int next_assignment(
110                 const char *filename,
111                 unsigned line,
112                 ConfigItemLookup lookup,
113                 void *table,
114                 const char *section,
115                 const char *lvalue,
116                 const char *rvalue,
117                 bool relaxed,
118                 void *userdata) {
119
120         ConfigParserCallback func = NULL;
121         int ltype = 0;
122         void *data = NULL;
123         int r;
124
125         assert(filename);
126         assert(line > 0);
127         assert(lookup);
128         assert(lvalue);
129         assert(rvalue);
130
131         r = lookup(table, section, lvalue, &func, &ltype, &data, userdata);
132         if (r < 0)
133                 return r;
134
135         if (r > 0) {
136                 if (func)
137                         return func(filename, line, section, lvalue, ltype, rvalue, data, userdata);
138
139                 return 0;
140         }
141
142         /* Warn about unknown non-extension fields. */
143         if (!relaxed && !startswith(lvalue, "X-"))
144                 log_info("[%s:%u] Unknown lvalue '%s' in section '%s'. Ignoring.", filename, line, lvalue, section);
145
146         return 0;
147 }
148
149 /* Parse a variable assignment line */
150 static int parse_line(
151                 const char *filename,
152                 unsigned line,
153                 const char *sections,
154                 ConfigItemLookup lookup,
155                 void *table,
156                 bool relaxed,
157                 char **section,
158                 char *l,
159                 void *userdata) {
160
161         char *e;
162
163         assert(filename);
164         assert(line > 0);
165         assert(lookup);
166         assert(l);
167
168         l = strstrip(l);
169
170         if (!*l)
171                 return 0;
172
173         if (strchr(COMMENTS, *l))
174                 return 0;
175
176         if (startswith(l, ".include ")) {
177                 char *fn;
178                 int r;
179
180                 fn = file_in_same_dir(filename, strstrip(l+9));
181                 if (!fn)
182                         return -ENOMEM;
183
184                 r = config_parse(fn, NULL, sections, lookup, table, relaxed, userdata);
185                 free(fn);
186
187                 return r;
188         }
189
190         if (*l == '[') {
191                 size_t k;
192                 char *n;
193
194                 k = strlen(l);
195                 assert(k > 0);
196
197                 if (l[k-1] != ']') {
198                         log_error("[%s:%u] Invalid section header.", filename, line);
199                         return -EBADMSG;
200                 }
201
202                 n = strndup(l+1, k-2);
203                 if (!n)
204                         return -ENOMEM;
205
206                 if (sections && !nulstr_contains(sections, n)) {
207
208                         if (!relaxed)
209                                 log_info("[%s:%u] Unknown section '%s'. Ignoring.", filename, line, n);
210
211                         free(n);
212                         *section = NULL;
213                 } else {
214                         free(*section);
215                         *section = n;
216                 }
217
218                 return 0;
219         }
220
221         if (sections && !*section)
222                 return 0;
223
224         e = strchr(l, '=');
225         if (!e) {
226                 log_error("[%s:%u] Missing '='.", filename, line);
227                 return -EBADMSG;
228         }
229
230         *e = 0;
231         e++;
232
233         return next_assignment(
234                         filename,
235                         line,
236                         lookup,
237                         table,
238                         *section,
239                         strstrip(l),
240                         strstrip(e),
241                         relaxed,
242                         userdata);
243 }
244
245 /* Go through the file and parse each line */
246 int config_parse(
247                 const char *filename,
248                 FILE *f,
249                 const char *sections,
250                 ConfigItemLookup lookup,
251                 void *table,
252                 bool relaxed,
253                 void *userdata) {
254
255         unsigned line = 0;
256         char *section = NULL;
257         int r;
258         bool ours = false;
259         char *continuation = NULL;
260
261         assert(filename);
262         assert(lookup);
263
264         if (!f) {
265                 f = fopen(filename, "re");
266                 if (!f) {
267                         r = -errno;
268                         log_error("Failed to open configuration file '%s': %s", filename, strerror(-r));
269                         goto finish;
270                 }
271
272                 ours = true;
273         }
274
275         while (!feof(f)) {
276                 char l[LINE_MAX], *p, *c = NULL, *e;
277                 bool escaped = false;
278
279                 if (!fgets(l, sizeof(l), f)) {
280                         if (feof(f))
281                                 break;
282
283                         r = -errno;
284                         log_error("Failed to read configuration file '%s': %s", filename, strerror(-r));
285                         goto finish;
286                 }
287
288                 truncate_nl(l);
289
290                 if (continuation) {
291                         c = strappend(continuation, l);
292                         if (!c) {
293                                 r = -ENOMEM;
294                                 goto finish;
295                         }
296
297                         free(continuation);
298                         continuation = NULL;
299                         p = c;
300                 } else
301                         p = l;
302
303                 for (e = p; *e; e++) {
304                         if (escaped)
305                                 escaped = false;
306                         else if (*e == '\\')
307                                 escaped = true;
308                 }
309
310                 if (escaped) {
311                         *(e-1) = ' ';
312
313                         if (c)
314                                 continuation = c;
315                         else {
316                                 continuation = strdup(l);
317                                 if (!continuation) {
318                                         r = -ENOMEM;
319                                         goto finish;
320                                 }
321                         }
322
323                         continue;
324                 }
325
326                 r = parse_line(filename,
327                                 ++line,
328                                 sections,
329                                 lookup,
330                                 table,
331                                 relaxed,
332                                 &section,
333                                 p,
334                                 userdata);
335                 free(c);
336
337                 if (r < 0)
338                         goto finish;
339         }
340
341         r = 0;
342
343 finish:
344         free(section);
345         free(continuation);
346
347         if (f && ours)
348                 fclose(f);
349
350         return r;
351 }
352
353 int config_parse_int(
354                 const char *filename,
355                 unsigned line,
356                 const char *section,
357                 const char *lvalue,
358                 int ltype,
359                 const char *rvalue,
360                 void *data,
361                 void *userdata) {
362
363         int *i = data;
364         int r;
365
366         assert(filename);
367         assert(lvalue);
368         assert(rvalue);
369         assert(data);
370
371         if ((r = safe_atoi(rvalue, i)) < 0) {
372                 log_error("[%s:%u] Failed to parse numeric value, ingoring: %s", filename, line, rvalue);
373                 return 0;
374         }
375
376         return 0;
377 }
378
379 int config_parse_long(
380                 const char *filename,
381                 unsigned line,
382                 const char *section,
383                 const char *lvalue,
384                 int ltype,
385                 const char *rvalue,
386                 void *data,
387                 void *userdata) {
388
389         long *i = data;
390         int r;
391
392         assert(filename);
393         assert(lvalue);
394         assert(rvalue);
395         assert(data);
396
397         if ((r = safe_atoli(rvalue, i)) < 0) {
398                 log_error("[%s:%u] Failed to parse numeric value, ignoring: %s", filename, line, rvalue);
399                 return 0;
400         }
401
402         return 0;
403 }
404
405 int config_parse_uint64(
406                 const char *filename,
407                 unsigned line,
408                 const char *section,
409                 const char *lvalue,
410                 int ltype,
411                 const char *rvalue,
412                 void *data,
413                 void *userdata) {
414
415         uint64_t *u = data;
416         int r;
417
418         assert(filename);
419         assert(lvalue);
420         assert(rvalue);
421         assert(data);
422
423         if ((r = safe_atou64(rvalue, u)) < 0) {
424                 log_error("[%s:%u] Failed to parse numeric value, ignoring: %s", filename, line, rvalue);
425                 return 0;
426         }
427
428         return 0;
429 }
430
431 int config_parse_unsigned(
432                 const char *filename,
433                 unsigned line,
434                 const char *section,
435                 const char *lvalue,
436                 int ltype,
437                 const char *rvalue,
438                 void *data,
439                 void *userdata) {
440
441         unsigned *u = data;
442         int r;
443
444         assert(filename);
445         assert(lvalue);
446         assert(rvalue);
447         assert(data);
448
449         if ((r = safe_atou(rvalue, u)) < 0) {
450                 log_error("[%s:%u] Failed to parse numeric value: %s", filename, line, rvalue);
451                 return r;
452         }
453
454         return 0;
455 }
456
457 int config_parse_size(
458                 const char *filename,
459                 unsigned line,
460                 const char *section,
461                 const char *lvalue,
462                 int ltype,
463                 const char *rvalue,
464                 void *data,
465                 void *userdata) {
466
467         size_t *sz = data;
468         unsigned u;
469         int r;
470
471         assert(filename);
472         assert(lvalue);
473         assert(rvalue);
474         assert(data);
475
476         if ((r = safe_atou(rvalue, &u)) < 0) {
477                 log_error("[%s:%u] Failed to parse numeric value, ignoring: %s", filename, line, rvalue);
478                 return 0;
479         }
480
481         *sz = (size_t) u;
482         return 0;
483 }
484
485 int config_parse_bool(
486                 const char *filename,
487                 unsigned line,
488                 const char *section,
489                 const char *lvalue,
490                 int ltype,
491                 const char *rvalue,
492                 void *data,
493                 void *userdata) {
494
495         int k;
496         bool *b = data;
497
498         assert(filename);
499         assert(lvalue);
500         assert(rvalue);
501         assert(data);
502
503         if ((k = parse_boolean(rvalue)) < 0) {
504                 log_error("[%s:%u] Failed to parse boolean value, ignoring: %s", filename, line, rvalue);
505                 return 0;
506         }
507
508         *b = !!k;
509         return 0;
510 }
511
512 int config_parse_string(
513                 const char *filename,
514                 unsigned line,
515                 const char *section,
516                 const char *lvalue,
517                 int ltype,
518                 const char *rvalue,
519                 void *data,
520                 void *userdata) {
521
522         char **s = data;
523         char *n;
524
525         assert(filename);
526         assert(lvalue);
527         assert(rvalue);
528         assert(data);
529
530         if (*rvalue) {
531                 if (!(n = strdup(rvalue)))
532                         return -ENOMEM;
533         } else
534                 n = NULL;
535
536         free(*s);
537         *s = n;
538
539         return 0;
540 }
541
542 int config_parse_path(
543                 const char *filename,
544                 unsigned line,
545                 const char *section,
546                 const char *lvalue,
547                 int ltype,
548                 const char *rvalue,
549                 void *data,
550                 void *userdata) {
551
552         char **s = data;
553         char *n;
554
555         assert(filename);
556         assert(lvalue);
557         assert(rvalue);
558         assert(data);
559
560         if (!path_is_absolute(rvalue)) {
561                 log_error("[%s:%u] Not an absolute path, ignoring: %s", filename, line, rvalue);
562                 return 0;
563         }
564
565         if (!(n = strdup(rvalue)))
566                 return -ENOMEM;
567
568         path_kill_slashes(n);
569
570         free(*s);
571         *s = n;
572
573         return 0;
574 }
575
576 int config_parse_strv(
577                 const char *filename,
578                 unsigned line,
579                 const char *section,
580                 const char *lvalue,
581                 int ltype,
582                 const char *rvalue,
583                 void *data,
584                 void *userdata) {
585
586         char*** sv = data;
587         char **n;
588         char *w;
589         unsigned k;
590         size_t l;
591         char *state;
592
593         assert(filename);
594         assert(lvalue);
595         assert(rvalue);
596         assert(data);
597
598         k = strv_length(*sv);
599         FOREACH_WORD_QUOTED(w, l, rvalue, state)
600                 k++;
601
602         if (!(n = new(char*, k+1)))
603                 return -ENOMEM;
604
605         if (*sv)
606                 for (k = 0; (*sv)[k]; k++)
607                         n[k] = (*sv)[k];
608         else
609                 k = 0;
610
611         FOREACH_WORD_QUOTED(w, l, rvalue, state)
612                 if (!(n[k++] = cunescape_length(w, l)))
613                         goto fail;
614
615         n[k] = NULL;
616         free(*sv);
617         *sv = n;
618
619         return 0;
620
621 fail:
622         for (; k > 0; k--)
623                 free(n[k-1]);
624         free(n);
625
626         return -ENOMEM;
627 }
628
629 int config_parse_path_strv(
630                 const char *filename,
631                 unsigned line,
632                 const char *section,
633                 const char *lvalue,
634                 int ltype,
635                 const char *rvalue,
636                 void *data,
637                 void *userdata) {
638
639         char*** sv = data;
640         char **n;
641         char *w;
642         unsigned k;
643         size_t l;
644         char *state;
645         int r;
646
647         assert(filename);
648         assert(lvalue);
649         assert(rvalue);
650         assert(data);
651
652         k = strv_length(*sv);
653         FOREACH_WORD_QUOTED(w, l, rvalue, state)
654                 k++;
655
656         if (!(n = new(char*, k+1)))
657                 return -ENOMEM;
658
659         k = 0;
660         if (*sv)
661                 for (; (*sv)[k]; k++)
662                         n[k] = (*sv)[k];
663
664         FOREACH_WORD_QUOTED(w, l, rvalue, state) {
665                 if (!(n[k] = cunescape_length(w, l))) {
666                         r = -ENOMEM;
667                         goto fail;
668                 }
669
670                 if (!path_is_absolute(n[k])) {
671                         log_error("[%s:%u] Not an absolute path, ignoring: %s", filename, line, rvalue);
672                         free(n[k]);
673                         continue;
674                 }
675
676                 path_kill_slashes(n[k]);
677
678                 k++;
679         }
680
681         n[k] = NULL;
682         free(*sv);
683         *sv = n;
684
685         return 0;
686
687 fail:
688         free(n[k]);
689         for (; k > 0; k--)
690                 free(n[k-1]);
691         free(n);
692
693         return r;
694 }
695
696 int config_parse_usec(
697                 const char *filename,
698                 unsigned line,
699                 const char *section,
700                 const char *lvalue,
701                 int ltype,
702                 const char *rvalue,
703                 void *data,
704                 void *userdata) {
705
706         usec_t *usec = data;
707
708         assert(filename);
709         assert(lvalue);
710         assert(rvalue);
711         assert(data);
712
713         if (parse_usec(rvalue, usec) < 0) {
714                 log_error("[%s:%u] Failed to parse time value, ignoring: %s", filename, line, rvalue);
715                 return 0;
716         }
717
718         return 0;
719 }
720
721 int config_parse_mode(
722                 const char *filename,
723                 unsigned line,
724                 const char *section,
725                 const char *lvalue,
726                 int ltype,
727                 const char *rvalue,
728                 void *data,
729                 void *userdata) {
730
731         mode_t *m = data;
732         long l;
733         char *x = NULL;
734
735         assert(filename);
736         assert(lvalue);
737         assert(rvalue);
738         assert(data);
739
740         errno = 0;
741         l = strtol(rvalue, &x, 8);
742         if (!x || *x || errno) {
743                 log_error("[%s:%u] Failed to parse mode value, ignoring: %s", filename, line, rvalue);
744                 return 0;
745         }
746
747         if (l < 0000 || l > 07777) {
748                 log_error("[%s:%u] mode value out of range, ignoring: %s", filename, line, rvalue);
749                 return 0;
750         }
751
752         *m = (mode_t) l;
753         return 0;
754 }