release/src/router/libnfsidmap/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 /* Return the string value denoted by TAG in section SECTION
 449    returns DEF if not found .  */
 450 char *
 451 conf_get_str_with_def(char *section, char *tag, char *def)
 452 {
 453   struct conf_binding *cb;
 454
 455   for (cb = LIST_FIRST (&conf_bindings[conf_hash (section)]); cb;
 456        cb = LIST_NEXT (cb, link))
 457     if (strcasecmp (section, cb->section) == 0
 458         && strcasecmp (tag, cb->tag) == 0)
 459       {
 460         return cb->value;
 461       }
 462   return def;
 463 }
 464
 465 /*
 466  * Build a list of string values out of the comma separated value denoted by
 467  * TAG in SECTION.
 468  */
 469 struct conf_list *
 470 conf_get_list (char *section, char *tag)
 471 {
 472   char *liststr = 0, *p, *field, *t;
 473   struct conf_list *list = 0;
 474   struct conf_list_node *node;
 475
 476   list = malloc (sizeof *list);
 477   if (!list)
 478     goto cleanup;
 479   TAILQ_INIT (&list->fields);
 480   list->cnt = 0;
 481   liststr = conf_get_str (section, tag);
 482   if (!liststr)
 483     goto cleanup;
 484   liststr = strdup (liststr);
 485   if (!liststr)
 486     goto cleanup;
 487   p = liststr;
 488   while ((field = strsep (&p, ",")) != NULL)
 489     {
 490       /* Skip leading whitespace */
 491       while (isspace (*field))
 492         field++;
 493       /* Skip trailing whitespace */
 494       if (p)
 495         for (t = p - 1; t > field && isspace (*t); t--)
 496           *t = '\0';
 497       if (*field == '\0')
 498         {
 499           warnx("conf_get_list: empty field, ignoring...");
 500           continue;
 501         }
 502       list->cnt++;
 503       node = calloc (1, sizeof *node);
 504       if (!node)
 505         goto cleanup;
 506       node->field = strdup (field);
 507       if (!node->field)
 508         goto cleanup;
 509       TAILQ_INSERT_TAIL (&list->fields, node, link);
 510     }
 511   free (liststr);
 512   return list;
 513
 514  cleanup:
 515   if (list)
 516     conf_free_list (list);
 517   if (liststr)
 518     free (liststr);
 519   return 0;
 520 }
 521
 522 struct conf_list *
 523 conf_get_tag_list (char *section)
 524 {
 525   struct conf_list *list = 0;
 526   struct conf_list_node *node;
 527   struct conf_binding *cb;
 528
 529   list = malloc (sizeof *list);
 530   if (!list)
 531     goto cleanup;
 532   TAILQ_INIT (&list->fields);
 533   list->cnt = 0;
 534   for (cb = LIST_FIRST (&conf_bindings[conf_hash (section)]); cb;
 535        cb = LIST_NEXT (cb, link))
 536     if (strcasecmp (section, cb->section) == 0)
 537       {
 538         list->cnt++;
 539         node = calloc (1, sizeof *node);
 540         if (!node)
 541           goto cleanup;
 542         node->field = strdup (cb->tag);
 543         if (!node->field)
 544           goto cleanup;
 545         TAILQ_INSERT_TAIL (&list->fields, node, link);
 546       }
 547   return list;
 548
 549  cleanup:
 550   if (list)
 551     conf_free_list (list);
 552   return 0;
 553 }
 554
 555 /* Decode a PEM encoded buffer.  */
 556 int
 557 conf_decode_base64 (u_int8_t *out, u_int32_t *len, u_char *buf)
 558 {
 559   u_int32_t c = 0;
 560   u_int8_t c1, c2, c3, c4;
 561
 562   while (*buf)
 563     {
 564       if (*buf > 127 || (c1 = asc2bin[*buf]) == 255)
 565         return 0;
 566       buf++;
 567
 568       if (*buf > 127 || (c2 = asc2bin[*buf]) == 255)
 569         return 0;
 570       buf++;
 571
 572       if (*buf == '=')
 573         {
 574           c3 = c4 = 0;
 575           c++;
 576
 577           /* Check last four bit */
 578           if (c2 & 0xF)
 579             return 0;
 580
 581           if (strcmp ((char *)buf, "==") == 0)
 582             buf++;
 583           else
 584             return 0;
 585         }
 586       else if (*buf > 127 || (c3 = asc2bin[*buf]) == 255)
 587         return 0;
 588       else
 589         {
 590           if (*++buf == '=')
 591             {
 592               c4 = 0;
 593               c += 2;
 594
 595               /* Check last two bit */
 596               if (c3 & 3)
 597                 return 0;
 598
 599               if (strcmp ((char *)buf, "="))
 600                 return 0;
 601
 602             }
 603           else if (*buf > 127 || (c4 = asc2bin[*buf]) == 255)
 604               return 0;
 605           else
 606               c += 3;
 607         }
 608
 609       buf++;
 610       *out++ = (c1 << 2) | (c2 >> 4);
 611       *out++ = (c2 << 4) | (c3 >> 2);
 612       *out++ = (c3 << 6) | c4;
 613     }
 614
 615   *len = c;
 616   return 1;
 617
 618 }
 619
 620 void
 621 conf_free_list (struct conf_list *list)
 622 {
 623   struct conf_list_node *node = TAILQ_FIRST (&list->fields);
 624
 625   while (node)
 626     {
 627       TAILQ_REMOVE (&list->fields, node, link);
 628       if (node->field)
 629         free (node->field);
 630       free (node);
 631       node = TAILQ_FIRST (&list->fields);
 632     }
 633   free (list);
 634 }
 635
 636 int
 637 conf_begin (void)
 638 {
 639   static int seq = 0;
 640
 641   return ++seq;
 642 }
 643
 644 static struct conf_trans *
 645 conf_trans_node (int transaction, enum conf_op op)
 646 {
 647   struct conf_trans *node;
 648
 649   node = calloc (1, sizeof *node);
 650   if (!node)
 651     {
 652       warnx("conf_trans_node: calloc (1, %lu) failed",
 653         (unsigned long)sizeof *node);
 654       return 0;
 655     }
 656   node->trans = transaction;
 657   node->op = op;
 658   TAILQ_INSERT_TAIL (&conf_trans_queue, node, link);
 659   return node;
 660 }
 661
 662 /* Queue a set operation.  */
 663 int
 664 conf_set (int transaction, char *section, char *tag, char *value, int override,
 665           int is_default)
 666 {
 667   struct conf_trans *node;
 668
 669   node = conf_trans_node (transaction, CONF_SET);
 670   if (!node)
 671     return 1;
 672   node->section = strdup (section);
 673   if (!node->section)
 674     {
 675       warnx("conf_set: strdup (\"%s\") failed", section);
 676       goto fail;
 677     }
 678   node->tag = strdup (tag);
 679   if (!node->tag)
 680     {
 681       warnx("conf_set: strdup (\"%s\") failed", tag);
 682       goto fail;
 683     }
 684   node->value = strdup (value);
 685   if (!node->value)
 686     {
 687       warnx("conf_set: strdup (\"%s\") failed", value);
 688       goto fail;
 689     }
 690   node->override = override;
 691   node->is_default = is_default;
 692   return 0;
 693
 694  fail:
 695   if (node->tag)
 696     free (node->tag);
 697   if (node->section)
 698     free (node->section);
 699   if (node)
 700     free (node);
 701   return 1;
 702 }
 703
 704 /* Queue a remove operation.  */
 705 int
 706 conf_remove (int transaction, char *section, char *tag)
 707 {
 708   struct conf_trans *node;
 709
 710   node = conf_trans_node (transaction, CONF_REMOVE);
 711   if (!node)
 712     goto fail;
 713   node->section = strdup (section);
 714   if (!node->section)
 715     {
 716       warnx("conf_remove: strdup (\"%s\") failed", section);
 717       goto fail;
 718     }
 719   node->tag = strdup (tag);
 720   if (!node->tag)
 721     {
 722       warnx("conf_remove: strdup (\"%s\") failed", tag);
 723       goto fail;
 724     }
 725   return 0;
 726
 727  fail:
 728   if (node->section)
 729     free (node->section);
 730   if (node)
 731     free (node);
 732   return 1;
 733 }
 734
 735 /* Queue a remove section operation.  */
 736 int
 737 conf_remove_section (int transaction, char *section)
 738 {
 739   struct conf_trans *node;
 740
 741   node = conf_trans_node (transaction, CONF_REMOVE_SECTION);
 742   if (!node)
 743     goto fail;
 744   node->section = strdup (section);
 745   if (!node->section)
 746     {
 747       warnx("conf_remove_section: strdup (\"%s\") failed", section);
 748       goto fail;
 749     }
 750   return 0;
 751
 752  fail:
 753   if (node)
 754     free (node);
 755   return 1;
 756 }
 757
 758 /* Execute all queued operations for this transaction.  Cleanup.  */
 759 int
 760 conf_end (int transaction, int commit)
 761 {
 762   struct conf_trans *node, *next;
 763
 764   for (node = TAILQ_FIRST (&conf_trans_queue); node; node = next)
 765     {
 766       next = TAILQ_NEXT (node, link);
 767       if (node->trans == transaction)
 768         {
 769           if (commit)
 770             switch (node->op)
 771               {
 772               case CONF_SET:
 773                 conf_set_now (node->section, node->tag, node->value,
 774                               node->override, node->is_default);
 775                 break;
 776               case CONF_REMOVE:
 777                 conf_remove_now (node->section, node->tag);
 778                 break;
 779               case CONF_REMOVE_SECTION:
 780                 conf_remove_section_now (node->section);
 781                 break;
 782               default:
 783                 warnx("conf_end: unknown operation: %d", node->op);
 784               }
 785           TAILQ_REMOVE (&conf_trans_queue, node, link);
 786           if (node->section)
 787             free (node->section);
 788           if (node->tag)
 789             free (node->tag);
 790           if (node->value)
 791             free (node->value);
 792           free (node);
 793         }
 794     }
 795   return 0;
 796 }
 797
 798 /*
 799  * Dump running configuration upon SIGUSR1.
 800  * Configuration is "stored in reverse order", so reverse it again.
 801  */
 802 struct dumper {
 803   char *s, *v;
 804   struct dumper *next;
 805 };
 806
 807 static void
 808 conf_report_dump (struct dumper *node)
 809 {
 810   /* Recursive, cleanup when we're done.  */
 811
 812   if (node->next)
 813     conf_report_dump (node->next);
 814
 815   if (node->v)
 816     warnx("%s=\t%s", node->s, node->v);
 817   else if (node->s)
 818     {
 819       warnx("%s", node->s);
 820       if (strlen (node->s) > 0)
 821         free (node->s);
 822     }
 823
 824   free (node);
 825 }
 826
 827 void
 828 conf_report (void)
 829 {
 830   struct conf_binding *cb, *last = 0;
 831   unsigned int i, len;
 832   char *current_section = (char *)0;
 833   struct dumper *dumper, *dnode;
 834
 835   dumper = dnode = (struct dumper *)calloc (1, sizeof *dumper);
 836   if (!dumper)
 837     goto mem_fail;
 838
 839   warnx("conf_report: dumping running configuration");
 840
 841   for (i = 0; i < sizeof conf_bindings / sizeof conf_bindings[0]; i++)
 842     for (cb = LIST_FIRST (&conf_bindings[i]); cb;
 843          cb = LIST_NEXT (cb, link))
 844       {
 845         if (!cb->is_default)
 846           {
 847             /* Dump this entry.  */
 848             if (!current_section || strcmp (cb->section, current_section))
 849               {
 850                 if (current_section)
 851                   {
 852                     len = strlen (current_section) + 3;
 853                     dnode->s = malloc (len);
 854                     if (!dnode->s)
 855                       goto mem_fail;
 856
 857                     snprintf (dnode->s, len, "[%s]", current_section);
 858                     dnode->next
 859                       = (struct dumper *)calloc (1, sizeof (struct dumper));
 860                     dnode = dnode->next;
 861                     if (!dnode)
 862                       goto mem_fail;
 863
 864                     dnode->s = "";
 865                     dnode->next
 866                       = (struct dumper *)calloc (1, sizeof (struct dumper));
 867                     dnode = dnode->next;
 868                     if (!dnode)
 869                       goto mem_fail;
 870                   }
 871                 current_section = cb->section;
 872               }
 873             dnode->s = cb->tag;
 874             dnode->v = cb->value;
 875             dnode->next = (struct dumper *)calloc (1, sizeof (struct dumper));
 876             dnode = dnode->next;
 877             if (!dnode)
 878               goto mem_fail;
 879             last = cb;
 880           }
 881       }
 882
 883   if (last)
 884     {
 885       len = strlen (last->section) + 3;
 886       dnode->s = malloc (len);
 887       if (!dnode->s)
 888         goto mem_fail;
 889       snprintf (dnode->s, len, "[%s]", last->section);
 890     }
 891
 892   conf_report_dump (dumper);
 893
 894   return;
 895
 896  mem_fail:
 897   warnx("conf_report: malloc/calloc failed");
 898   while ((dnode = dumper) != 0)
 899     {
 900       dumper = dumper->next;
 901       if (dnode->s)
 902         free (dnode->s);
 903       free (dnode);
 904     }
 905   return;
 906 }