Fix various issues discovered by Coverity
[nfs-utils.git] / utils / idmapd / cfg.c
1 /*      $OpenBSD: conf.c,v 1.55 2003/06/03 14:28:16 ho Exp $    */
2 /*      $EOM: conf.c,v 1.48 2000/12/04 02:04:29 angelos Exp $   */
3
4 /*
5  * Copyright (c) 1998, 1999, 2000, 2001 Niklas Hallqvist.  All rights reserved.
6  * Copyright (c) 2000, 2001, 2002 HÃ¥kan Olsson.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 /*
30  * This code was written under funding by Ericsson Radio Systems.
31  */
32
33 #include <sys/param.h>
34 #include <sys/mman.h>
35 #include <sys/socket.h>
36 #include <sys/stat.h>
37 #include <netinet/in.h>
38 #include <arpa/inet.h>
39 #include <ctype.h>
40 #include <fcntl.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <errno.h>
46 #include <err.h>
47
48 #include "cfg.h"
49
50 static void conf_load_defaults (int);
51 #if 0
52 static int conf_find_trans_xf (int, char *);
53 #endif
54
55 size_t  strlcpy(char *, const char *, size_t);
56
57 struct conf_trans {
58   TAILQ_ENTRY (conf_trans) link;
59   int trans;
60   enum conf_op { CONF_SET, CONF_REMOVE, CONF_REMOVE_SECTION } op;
61   char *section;
62   char *tag;
63   char *value;
64   int override;
65   int is_default;
66 };
67
68 TAILQ_HEAD (conf_trans_head, conf_trans) conf_trans_queue;
69
70 /*
71  * Radix-64 Encoding.
72  */
73 const u_int8_t bin2asc[]
74   = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
75
76 const u_int8_t asc2bin[] =
77 {
78   255, 255, 255, 255, 255, 255, 255, 255,
79   255, 255, 255, 255, 255, 255, 255, 255,
80   255, 255, 255, 255, 255, 255, 255, 255,
81   255, 255, 255, 255, 255, 255, 255, 255,
82   255, 255, 255, 255, 255, 255, 255, 255,
83   255, 255, 255,  62, 255, 255, 255,  63,
84    52,  53,  54,  55,  56,  57,  58,  59,
85    60,  61, 255, 255, 255, 255, 255, 255,
86   255,   0,   1,   2,   3,   4,   5,   6,
87     7,   8,   9,  10,  11,  12,  13,  14,
88    15,  16,  17,  18,  19,  20,  21,  22,
89    23,  24,  25, 255, 255, 255, 255, 255,
90   255,  26,  27,  28,  29,  30,  31,  32,
91    33,  34,  35,  36,  37,  38,  39,  40,
92    41,  42,  43,  44,  45,  46,  47,  48,
93    49,  50,  51, 255, 255, 255, 255, 255
94 };
95
96 struct conf_binding {
97   LIST_ENTRY (conf_binding) link;
98   char *section;
99   char *tag;
100   char *value;
101   int is_default;
102 };
103
104 char *conf_path;
105 LIST_HEAD (conf_bindings, conf_binding) conf_bindings[256];
106
107 static char *conf_addr;
108
109 static __inline__ u_int8_t
110 conf_hash (char *s)
111 {
112   u_int8_t hash = 0;
113
114   while (*s)
115     {
116       hash = ((hash << 1) | (hash >> 7)) ^ tolower (*s);
117       s++;
118     }
119   return hash;
120 }
121
122 /*
123  * Insert a tag-value combination from LINE (the equal sign is at POS)
124  */
125 static int
126 conf_remove_now (char *section, char *tag)
127 {
128   struct conf_binding *cb, *next;
129
130   for (cb = LIST_FIRST (&conf_bindings[conf_hash (section)]); cb; cb = next)
131     {
132       next = LIST_NEXT (cb, link);
133       if (strcasecmp (cb->section, section) == 0
134           && strcasecmp (cb->tag, tag) == 0)
135         {
136           LIST_REMOVE (cb, link);
137           warnx("[%s]:%s->%s removed", section, tag, cb->value);
138           free (cb->section);
139           free (cb->tag);
140           free (cb->value);
141           free (cb);
142           return 0;
143         }
144     }
145   return 1;
146 }
147
148 static int
149 conf_remove_section_now (char *section)
150 {
151   struct conf_binding *cb, *next;
152   int unseen = 1;
153
154   for (cb = LIST_FIRST (&conf_bindings[conf_hash (section)]); cb; cb = next)
155     {
156       next = LIST_NEXT (cb, link);
157       if (strcasecmp (cb->section, section) == 0)
158         {
159           unseen = 0;
160           LIST_REMOVE (cb, link);
161           warnx("[%s]:%s->%s removed", section, cb->tag, cb->value);
162           free (cb->section);
163           free (cb->tag);
164           free (cb->value);
165           free (cb);
166         }
167     }
168   return unseen;
169 }
170
171 /*
172  * Insert a tag-value combination from LINE (the equal sign is at POS)
173  * into SECTION of our configuration database.
174  */
175 static int
176 conf_set_now (char *section, char *tag, char *value, int override,
177               int is_default)
178 {
179   struct conf_binding *node = 0;
180
181   if (override)
182     conf_remove_now (section, tag);
183   else if (conf_get_str (section, tag))
184     {
185       if (!is_default)
186         warnx("conf_set: duplicate tag [%s]:%s, ignoring...\n", section, tag);
187       return 1;
188     }
189
190   node = calloc (1, sizeof *node);
191   if (!node)
192     {
193       warnx("conf_set: calloc (1, %lu) failed", (unsigned long)sizeof *node);
194       return 1;
195     }
196   node->section = strdup (section);
197   node->tag = strdup (tag);
198   node->value = strdup (value);
199   node->is_default = is_default;
200
201   LIST_INSERT_HEAD (&conf_bindings[conf_hash (section)], node, link);
202   return 0;
203 }
204
205 /*
206  * Parse the line LINE of SZ bytes.  Skip Comments, recognize section
207  * headers and feed tag-value pairs into our configuration database.
208  */
209 static void
210 conf_parse_line (int trans, char *line, size_t sz)
211 {
212   char *val;
213   size_t i;
214   int j;
215   static char *section = 0;
216   static int ln = 0;
217
218   ln++;
219
220   /* Lines starting with '#' or ';' are comments.  */
221   if (*line == '#' || *line == ';')
222     return;
223
224   /* '[section]' parsing...  */
225   if (*line == '[')
226     {
227       for (i = 1; i < sz; i++)
228         if (line[i] == ']')
229           break;
230       if (section)
231         free (section);
232       if (i == sz)
233         {
234           warnx("conf_parse_line: %d:"
235                      "non-matched ']', ignoring until next section", ln);
236           section = 0;
237           return;
238         }
239       section = malloc (i);
240       if (!section)
241         {
242           warnx("conf_parse_line: %d: malloc (%lu) failed", ln,
243                 (unsigned long)i);
244           return;
245         }
246       strlcpy (section, line + 1, i);
247       return;
248     }
249
250   /* Deal with assignments.  */
251   for (i = 0; i < sz; i++)
252     if (line[i] == '=')
253       {
254         /* If no section, we are ignoring the lines.  */
255         if (!section)
256           {
257             warnx("conf_parse_line: %d: ignoring line due to no section", ln);
258             return;
259           }
260         line[strcspn (line, " \t=")] = '\0';
261         val = line + i + 1 + strspn (line + i + 1, " \t");
262         /* Skip trailing whitespace, if any */
263         for (j = sz - (val - line) - 1; j > 0 && isspace (val[j]); j--)
264           val[j] = '\0';
265         /* XXX Perhaps should we not ignore errors?  */
266         conf_set (trans, section, line, val, 0, 0);
267         return;
268       }
269
270   /* Other non-empty lines are weird.  */
271   i = strspn (line, " \t");
272   if (line[i])
273     warnx("conf_parse_line: %d: syntax error", ln);
274
275   return;
276 }
277
278 /* Parse the mapped configuration file.  */
279 static void
280 conf_parse (int trans, char *buf, size_t sz)
281 {
282   char *cp = buf;
283   char *bufend = buf + sz;
284   char *line;
285
286   line = cp;
287   while (cp < bufend)
288     {
289       if (*cp == '\n')
290         {
291           /* Check for escaped newlines.  */
292           if (cp > buf && *(cp - 1) == '\\')
293             *(cp - 1) = *cp = ' ';
294           else
295             {
296               *cp = '\0';
297               conf_parse_line (trans, line, cp - line);
298               line = cp + 1;
299             }
300         }
301       cp++;
302     }
303   if (cp != line)
304     warnx("conf_parse: last line non-terminated, ignored.");
305 }
306
307 static void
308 conf_load_defaults (int tr)
309 {
310         /* No defaults */
311         return;
312 }
313
314 void
315 conf_init (void)
316 {
317   unsigned int i;
318
319   for (i = 0; i < sizeof conf_bindings / sizeof conf_bindings[0]; i++)
320     LIST_INIT (&conf_bindings[i]);
321   TAILQ_INIT (&conf_trans_queue);
322   conf_reinit ();
323 }
324
325 /* Open the config file and map it into our address space, then parse it.  */
326 void
327 conf_reinit (void)
328 {
329   struct conf_binding *cb = 0;
330   int fd, trans;
331   unsigned int i;
332   size_t sz;
333   char *new_conf_addr = 0;
334   struct stat sb;
335
336   if ((stat (conf_path, &sb) == 0) || (errno != ENOENT))
337     {
338       sz = sb.st_size;
339       fd = open (conf_path, O_RDONLY, 0);
340       if (fd == -1)
341         {
342           warnx("conf_reinit: open (\"%s\", O_RDONLY) failed", conf_path);
343           return;
344         }
345
346       new_conf_addr = malloc (sz);
347       if (!new_conf_addr)
348         {
349           warnx("conf_reinit: malloc (%lu) failed", (unsigned long)sz);
350           goto fail;
351         }
352
353       /* XXX I assume short reads won't happen here.  */
354       if (read (fd, new_conf_addr, sz) != (int)sz)
355         {
356             warnx("conf_reinit: read (%d, %p, %lu) failed",
357                        fd, new_conf_addr, (unsigned long)sz);
358             goto fail;
359         }
360       close (fd);
361
362       trans = conf_begin ();
363
364       /* XXX Should we not care about errors and rollback?  */
365       conf_parse (trans, new_conf_addr, sz);
366     }
367   else
368     trans = conf_begin ();
369
370   /* Load default configuration values.  */
371   conf_load_defaults (trans);
372
373   /* Free potential existing configuration.  */
374   if (conf_addr)
375     {
376       for (i = 0; i < sizeof conf_bindings / sizeof conf_bindings[0]; i++)
377         for (cb = LIST_FIRST (&conf_bindings[i]); cb;
378              cb = LIST_FIRST (&conf_bindings[i]))
379           conf_remove_now (cb->section, cb->tag);
380       free (conf_addr);
381     }
382
383   conf_end (trans, 1);
384   conf_addr = new_conf_addr;
385   return;
386
387  fail:
388   if (new_conf_addr)
389     free (new_conf_addr);
390   close (fd);
391 }
392
393 /*
394  * Return the numeric value denoted by TAG in section SECTION or DEF
395  * if that tag does not exist.
396  */
397 int
398 conf_get_num (char *section, char *tag, int def)
399 {
400   char *value = conf_get_str (section, tag);
401
402   if (value)
403       return atoi (value);
404   return def;
405 }
406
407 /* Validate X according to the range denoted by TAG in section SECTION.  */
408 int
409 conf_match_num (char *section, char *tag, int x)
410 {
411   char *value = conf_get_str (section, tag);
412   int val, min, max, n;
413
414   if (!value)
415     return 0;
416   n = sscanf (value, "%d,%d:%d", &val, &min, &max);
417   switch (n)
418     {
419     case 1:
420       warnx("conf_match_num: %s:%s %d==%d?", section, tag, val, x);
421       return x == val;
422     case 3:
423       warnx("conf_match_num: %s:%s %d<=%d<=%d?", section, tag, min, x, max);
424       return min <= x && max >= x;
425     default:
426       warnx("conf_match_num: section %s tag %s: invalid number spec %s",
427                  section, tag, value);
428     }
429   return 0;
430 }
431
432 /* Return the string value denoted by TAG in section SECTION.  */
433 char *
434 conf_get_str (char *section, char *tag)
435 {
436   struct conf_binding *cb;
437
438   for (cb = LIST_FIRST (&conf_bindings[conf_hash (section)]); cb;
439        cb = LIST_NEXT (cb, link))
440     if (strcasecmp (section, cb->section) == 0
441         && strcasecmp (tag, cb->tag) == 0)
442       {
443         return cb->value;
444       }
445   return 0;
446 }
447
448 /*
449  * Build a list of string values out of the comma separated value denoted by
450  * TAG in SECTION.
451  */
452 struct conf_list *
453 conf_get_list (char *section, char *tag)
454 {
455   char *liststr = 0, *p, *field, *t;
456   struct conf_list *list = 0;
457   struct conf_list_node *node;
458
459   list = malloc (sizeof *list);
460   if (!list)
461     goto cleanup;
462   TAILQ_INIT (&list->fields);
463   list->cnt = 0;
464   liststr = conf_get_str (section, tag);
465   if (!liststr)
466     goto cleanup;
467   liststr = strdup (liststr);
468   if (!liststr)
469     goto cleanup;
470   p = liststr;
471   while ((field = strsep (&p, ",")) != NULL)
472     {
473       /* Skip leading whitespace */
474       while (isspace (*field))
475         field++;
476       /* Skip trailing whitespace */
477       if (p)
478         for (t = p - 1; t > field && isspace (*t); t--)
479           *t = '\0';
480       if (*field == '\0')
481         {
482           warnx("conf_get_list: empty field, ignoring...");
483           continue;
484         }
485       list->cnt++;
486       node = calloc (1, sizeof *node);
487       if (!node)
488         goto cleanup;
489       node->field = strdup (field);
490       if (!node->field) {
491         free(node);
492         goto cleanup;
493       }
494       TAILQ_INSERT_TAIL (&list->fields, node, link);
495     }
496   free (liststr);
497   return list;
498
499  cleanup:
500   if (list)
501     conf_free_list (list);
502   if (liststr)
503     free (liststr);
504   return 0;
505 }
506
507 struct conf_list *
508 conf_get_tag_list (char *section)
509 {
510   struct conf_list *list = 0;
511   struct conf_list_node *node;
512   struct conf_binding *cb;
513
514   list = malloc (sizeof *list);
515   if (!list)
516     goto cleanup;
517   TAILQ_INIT (&list->fields);
518   list->cnt = 0;
519   for (cb = LIST_FIRST (&conf_bindings[conf_hash (section)]); cb;
520        cb = LIST_NEXT (cb, link))
521     if (strcasecmp (section, cb->section) == 0)
522       {
523         list->cnt++;
524         node = calloc (1, sizeof *node);
525         if (!node)
526           goto cleanup;
527         node->field = strdup (cb->tag);
528         if (!node->field) {
529           free(node);
530           goto cleanup;
531         }
532         TAILQ_INSERT_TAIL (&list->fields, node, link);
533       }
534   return list;
535
536  cleanup:
537   if (list)
538     conf_free_list (list);
539   return 0;
540 }
541
542 /* Decode a PEM encoded buffer.  */
543 int
544 conf_decode_base64 (u_int8_t *out, u_int32_t *len, u_char *buf)
545 {
546   u_int32_t c = 0;
547   u_int8_t c1, c2, c3, c4;
548
549   while (*buf)
550     {
551       if (*buf > 127 || (c1 = asc2bin[*buf]) == 255)
552         return 0;
553       buf++;
554
555       if (*buf > 127 || (c2 = asc2bin[*buf]) == 255)
556         return 0;
557       buf++;
558
559       if (*buf == '=')
560         {
561           c3 = c4 = 0;
562           c++;
563
564           /* Check last four bit */
565           if (c2 & 0xF)
566             return 0;
567
568           if (strcmp ((char *)buf, "==") == 0)
569             buf++;
570           else
571             return 0;
572         }
573       else if (*buf > 127 || (c3 = asc2bin[*buf]) == 255)
574         return 0;
575       else
576         {
577           if (*++buf == '=')
578             {
579               c4 = 0;
580               c += 2;
581
582               /* Check last two bit */
583               if (c3 & 3)
584                 return 0;
585
586               if (strcmp ((char *)buf, "="))
587                 return 0;
588
589             }
590           else if (*buf > 127 || (c4 = asc2bin[*buf]) == 255)
591               return 0;
592           else
593               c += 3;
594         }
595
596       buf++;
597       *out++ = (c1 << 2) | (c2 >> 4);
598       *out++ = (c2 << 4) | (c3 >> 2);
599       *out++ = (c3 << 6) | c4;
600     }
601
602   *len = c;
603   return 1;
604
605 }
606
607 void
608 conf_free_list (struct conf_list *list)
609 {
610   struct conf_list_node *node = TAILQ_FIRST (&list->fields);
611
612   while (node)
613     {
614       TAILQ_REMOVE (&list->fields, node, link);
615       if (node->field)
616         free (node->field);
617       free (node);
618       node = TAILQ_FIRST (&list->fields);
619     }
620   free (list);
621 }
622
623 int
624 conf_begin (void)
625 {
626   static int seq = 0;
627
628   return ++seq;
629 }
630
631 static struct conf_trans *
632 conf_trans_node (int transaction, enum conf_op op)
633 {
634   struct conf_trans *node;
635
636   node = calloc (1, sizeof *node);
637   if (!node)
638     {
639       warnx("conf_trans_node: calloc (1, %lu) failed",
640         (unsigned long)sizeof *node);
641       return 0;
642     }
643   node->trans = transaction;
644   node->op = op;
645   TAILQ_INSERT_TAIL (&conf_trans_queue, node, link);
646   return node;
647 }
648
649 /* Queue a set operation.  */
650 int
651 conf_set (int transaction, char *section, char *tag, char *value, int override,
652           int is_default)
653 {
654   struct conf_trans *node;
655
656   node = conf_trans_node (transaction, CONF_SET);
657   if (!node)
658     return 1;
659   node->section = strdup (section);
660   if (!node->section)
661     {
662       warnx("conf_set: strdup (\"%s\") failed", section);
663       goto fail;
664     }
665   node->tag = strdup (tag);
666   if (!node->tag)
667     {
668       warnx("conf_set: strdup (\"%s\") failed", tag);
669       goto fail;
670     }
671   node->value = strdup (value);
672   if (!node->value)
673     {
674       warnx("conf_set: strdup (\"%s\") failed", value);
675       goto fail;
676     }
677   node->override = override;
678   node->is_default = is_default;
679   return 0;
680
681  fail:
682   if (node->tag)
683     free (node->tag);
684   if (node->section)
685     free (node->section);
686   if (node)
687     free (node);
688   return 1;
689 }
690
691 /* Queue a remove operation.  */
692 int
693 conf_remove (int transaction, char *section, char *tag)
694 {
695   struct conf_trans *node;
696
697   node = conf_trans_node (transaction, CONF_REMOVE);
698   if (!node)
699     goto fail;
700   node->section = strdup (section);
701   if (!node->section)
702     {
703       warnx("conf_remove: strdup (\"%s\") failed", section);
704       goto fail;
705     }
706   node->tag = strdup (tag);
707   if (!node->tag)
708     {
709       warnx("conf_remove: strdup (\"%s\") failed", tag);
710       goto fail;
711     }
712   return 0;
713
714  fail:
715   if (node && node->section)
716     free (node->section);
717   if (node)
718     free (node);
719   return 1;
720 }
721
722 /* Queue a remove section operation.  */
723 int
724 conf_remove_section (int transaction, char *section)
725 {
726   struct conf_trans *node;
727
728   node = conf_trans_node (transaction, CONF_REMOVE_SECTION);
729   if (!node)
730     goto fail;
731   node->section = strdup (section);
732   if (!node->section)
733     {
734       warnx("conf_remove_section: strdup (\"%s\") failed", section);
735       goto fail;
736     }
737   return 0;
738
739  fail:
740   if (node)
741     free (node);
742   return 1;
743 }
744
745 /* Execute all queued operations for this transaction.  Cleanup.  */
746 int
747 conf_end (int transaction, int commit)
748 {
749   struct conf_trans *node, *next;
750
751   for (node = TAILQ_FIRST (&conf_trans_queue); node; node = next)
752     {
753       next = TAILQ_NEXT (node, link);
754       if (node->trans == transaction)
755         {
756           if (commit)
757             switch (node->op)
758               {
759               case CONF_SET:
760                 conf_set_now (node->section, node->tag, node->value,
761                               node->override, node->is_default);
762                 break;
763               case CONF_REMOVE:
764                 conf_remove_now (node->section, node->tag);
765                 break;
766               case CONF_REMOVE_SECTION:
767                 conf_remove_section_now (node->section);
768                 break;
769               default:
770                 warnx("conf_end: unknown operation: %d", node->op);
771               }
772           TAILQ_REMOVE (&conf_trans_queue, node, link);
773           if (node->section)
774             free (node->section);
775           if (node->tag)
776             free (node->tag);
777           if (node->value)
778             free (node->value);
779           free (node);
780         }
781     }
782   return 0;
783 }
784
785 /*
786  * Dump running configuration upon SIGUSR1.
787  * Configuration is "stored in reverse order", so reverse it again.
788  */
789 struct dumper {
790   char *s, *v;
791   struct dumper *next;
792 };
793
794 static void
795 conf_report_dump (struct dumper *node)
796 {
797   /* Recursive, cleanup when we're done.  */
798
799   if (node->next)
800     conf_report_dump (node->next);
801
802   if (node->v)
803     warnx("%s=\t%s", node->s, node->v);
804   else if (node->s)
805     {
806       warnx("%s", node->s);
807       if (strlen (node->s) > 0)
808         free (node->s);
809     }
810
811   free (node);
812 }
813
814 void
815 conf_report (void)
816 {
817   struct conf_binding *cb, *last = 0;
818   unsigned int i, len;
819   char *current_section = (char *)0;
820   struct dumper *dumper, *dnode;
821
822   dumper = dnode = (struct dumper *)calloc (1, sizeof *dumper);
823   if (!dumper)
824     goto mem_fail;
825
826   warnx("conf_report: dumping running configuration");
827
828   for (i = 0; i < sizeof conf_bindings / sizeof conf_bindings[0]; i++)
829     for (cb = LIST_FIRST (&conf_bindings[i]); cb;
830          cb = LIST_NEXT (cb, link))
831       {
832         if (!cb->is_default)
833           {
834             /* Dump this entry.  */
835             if (!current_section || strcmp (cb->section, current_section))
836               {
837                 if (current_section)
838                   {
839                     len = strlen (current_section) + 3;
840                     dnode->s = malloc (len);
841                     if (!dnode->s)
842                       goto mem_fail;
843
844                     snprintf (dnode->s, len, "[%s]", current_section);
845                     dnode->next
846                       = (struct dumper *)calloc (1, sizeof (struct dumper));
847                     dnode = dnode->next;
848                     if (!dnode)
849                       goto mem_fail;
850
851                     dnode->s = "";
852                     dnode->next
853                       = (struct dumper *)calloc (1, sizeof (struct dumper));
854                     dnode = dnode->next;
855                     if (!dnode)
856                       goto mem_fail;
857                   }
858                 current_section = cb->section;
859               }
860             dnode->s = cb->tag;
861             dnode->v = cb->value;
862             dnode->next = (struct dumper *)calloc (1, sizeof (struct dumper));
863             dnode = dnode->next;
864             if (!dnode)
865               goto mem_fail;
866             last = cb;
867           }
868       }
869
870   if (last)
871     {
872       len = strlen (last->section) + 3;
873       dnode->s = malloc (len);
874       if (!dnode->s)
875         goto mem_fail;
876       snprintf (dnode->s, len, "[%s]", last->section);
877     }
878
879   conf_report_dump (dumper);
880
881   return;
882
883  mem_fail:
884   warnx("conf_report: malloc/calloc failed");
885   while ((dnode = dumper) != 0)
886     {
887       dumper = dumper->next;
888       if (dnode->s)
889         free (dnode->s);
890       free (dnode);
891     }
892   return;
893 }