src/rcfile.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014
   3     Ben Kibbey <bjk@luxsci.net>
   4
   5     This file is part of pwmd.
   6
   7     Pwmd is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     Pwmd is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #include <errno.h>
  30 #include <ctype.h>
  31 #include <pwd.h>
  32
  33 #include "pwmd-error.h"
  34 #include "mutex.h"
  35 #include "rcfile.h"
  36 #include "util-misc.h"
  37 #include "common.h"
  38 #include "util-slist.h"
  39 #include "util-string.h"
  40 #include "mem.h"
  41
  42 #define DEFAULT_CACHE_TIMEOUT "600"
  43 #define DEFAULT_KEEPALIVE_INTERVAL "60"
  44
  45 #define INVALID_VALUE(file, line) do {                                  \
  46     if (file)                                                           \
  47       log_write(_("%s(%i): invalid value for parameter."), file, line); \
  48   } while (0);
  49
  50 enum
  51 {
  52   PARAM_INT, PARAM_CHARP, PARAM_LONG, PARAM_LONGLONG, PARAM_CHARPP,
  53   PARAM_BOOL, PARAM_ULONG, PARAM_ULONGLONG
  54 };
  55
  56 static struct config_params_s
  57 {
  58   char *name;
  59   int type;
  60   char *value;
  61 } config_params[] = {
  62   {  "backup",                  PARAM_BOOL,             "true"},
  63   {  "socket_path",             PARAM_CHARP,            NULL},
  64   {  "socket_perms",            PARAM_CHARP,            NULL},
  65   {  "passphrase",              PARAM_CHARP,            NULL},
  66   {  "passphrase_file",         PARAM_CHARP,            NULL},
  67   {  "log_path",                PARAM_CHARP,            "~/.pwmd/log"},
  68   {  "enable_logging",          PARAM_BOOL,             "0"},
  69   {  "log_keepopen",            PARAM_BOOL,             "true"},
  70   {  "log_level",               PARAM_INT,              "0"},
  71   {  "disable_mlockall",        PARAM_BOOL,             "true"},
  72   {  "cache_timeout",           PARAM_INT,              DEFAULT_CACHE_TIMEOUT},
  73   {  "cache_push",              PARAM_CHARPP,           NULL},
  74   {  "disable_list_and_dump",   PARAM_BOOL,             "false"},
  75   {  "recursion_depth",         PARAM_INT,              "100"},
  76   {  "syslog",                  PARAM_BOOL,             "false"},
  77   {  "xfer_progress",           PARAM_INT,              "8196"},
  78   {  "allowed",                 PARAM_CHARPP,           NULL},
  79   {  "allowed_file",            PARAM_CHARP,            NULL},
  80   {  "priority",                PARAM_INT,              INVALID_PRIORITY},
  81   {  "keepalive_interval",      PARAM_INT,              DEFAULT_KEEPALIVE_INTERVAL},
  82   {  "tcp_port",                PARAM_INT,              "6466"},
  83   {  "enable_tcp",              PARAM_BOOL,             "false"},
  84   {  "tcp_require_key",         PARAM_BOOL,             "false"},
  85   {  "tcp_wait",                PARAM_INT,              "0"},
  86   {  "tcp_bind",                PARAM_CHARP,            "any"},
  87   {  "tcp_interface",           PARAM_CHARP,            NULL},
  88   {  "tls_timeout",             PARAM_INT,              "300"},
  89   {  "tls_cipher_suite",        PARAM_CHARP,            "SECURE256"},
  90   {  "require_save_key",        PARAM_BOOL,             "true"},
  91   {  "invoking_user",           PARAM_CHARP,            NULL},
  92   {  "invoking_tls",            PARAM_CHARP,            NULL},
  93   {  "encrypt_to",              PARAM_BOOL,             "false"},
  94   {  "always_trust",            PARAM_BOOL,             "false"},
  95   {  "gpg_homedir",             PARAM_CHARP,            NULL},
  96   { NULL,                       0,                      NULL},
  97 };
  98
  99 struct config_param_s
 100 {
 101   char *name;
 102   int type;
 103   union
 104   {
 105     int itype;
 106     char *cptype;
 107     char **cpptype;
 108     long ltype;
 109     long long lltype;
 110     unsigned long ultype;
 111     unsigned long long ulltype;
 112   } value;
 113 };
 114
 115 static struct config_section_s *config_find_section (struct slist_s *config,
 116                                               const char *name);
 117 static int new_param (struct config_section_s *section, const char *filename,
 118                       int lineno, const char *name, const char *value,
 119                       int type);
 120 static void free_section (struct config_section_s *s);
 121 static int set_defaults (struct slist_s **config);
 122
 123 static void
 124 section_remove_param (struct config_section_s *section, const char *name)
 125 {
 126   unsigned i, t = slist_length (section->params);
 127
 128   for (i = 0; i < t; i++)
 129     {
 130       struct config_param_s *p = slist_nth_data (section->params, i);
 131
 132       if (!p)
 133         continue;
 134
 135       if (!strcmp (p->name, name))
 136         {
 137           switch (p->type)
 138             {
 139             case PARAM_CHARP:
 140               xfree (p->value.cptype);
 141               break;
 142             case PARAM_CHARPP:
 143               strv_free (p->value.cpptype);
 144               break;
 145             }
 146
 147           section->params = slist_remove (section->params, p);
 148           xfree (p->name);
 149           xfree (p);
 150           break;
 151         }
 152     }
 153 }
 154
 155 void
 156 config_clear_keys ()
 157 {
 158   MUTEX_LOCK (&rcfile_mutex);
 159   unsigned i, t = slist_length (global_config);
 160
 161   for (i = 0; i < t; i++)
 162     {
 163       struct config_section_s *s = slist_nth_data (global_config, i);
 164       if (!s)
 165         continue;
 166
 167       section_remove_param (s, "passphrase");
 168     }
 169
 170   MUTEX_UNLOCK (&rcfile_mutex);
 171 }
 172
 173 static struct config_param_s *
 174 config_has_param (struct config_section_s *s, const char *what)
 175 {
 176   unsigned i, t = slist_length (s->params);
 177
 178   for (i = 0; i < t; i++)
 179     {
 180       struct config_param_s *p = slist_nth_data (s->params, i);
 181       if (!p)
 182         break;
 183
 184       if (!strcmp (p->name, what))
 185         return p;
 186     }
 187
 188   return NULL;
 189 }
 190
 191 static struct config_param_s *
 192 config_get_param (struct slist_s *config,
 193                   const char *section, const char *what, int *exists)
 194 {
 195   unsigned i, t = slist_length (config);
 196
 197   *exists = 0;
 198
 199   for (i = 0; i < t; i++)
 200     {
 201       struct config_param_s *p;
 202       struct config_section_s *s = slist_nth_data (config, i);
 203
 204       if (!s)
 205         break;
 206
 207       if (strcmp (s->name, section))
 208         continue;
 209
 210       p = config_has_param (s, what);
 211       if (!p)
 212         return NULL;
 213
 214       *exists = 1;
 215       return p;
 216     }
 217
 218   return NULL;
 219 }
 220
 221 static struct config_section_s *
 222 new_section (struct slist_s **config, const char *name)
 223 {
 224   struct slist_s *tmp;
 225   struct config_section_s *s = xcalloc (1, sizeof (struct config_section_s));
 226
 227   if (!s)
 228     return NULL;
 229
 230   s->name = str_dup (name);
 231   if (!s->name)
 232     {
 233       log_write ("%s", pwmd_strerror (ENOMEM));
 234       xfree (s);
 235       return NULL;
 236     }
 237
 238   tmp = slist_append (*config, s);
 239   if (!tmp)
 240     {
 241       log_write ("%s", pwmd_strerror (ENOMEM));
 242       xfree (s->name);
 243       xfree (s);
 244       return NULL;
 245     }
 246
 247   *config = tmp;
 248   return s;
 249 }
 250
 251 int
 252 config_set_string_param (struct slist_s **config, const char *section,
 253                          const char *name, const char *value)
 254 {
 255   struct config_section_s *s = config_find_section (*config, section);
 256
 257   if (!s)
 258     {
 259       s = new_section (config, section);
 260       if (!s)
 261         return 1;
 262     }
 263
 264   return new_param (s, NULL, 0, name, value, PARAM_CHARP);
 265 }
 266
 267 char *
 268 config_get_string_param (struct slist_s *config, const char *section,
 269                          const char *what, int *exists)
 270 {
 271   struct config_param_s *p = config_get_param (config, section, what, exists);
 272   return *exists && p->value.cptype ? str_dup (p->value.cptype) : NULL;
 273 }
 274
 275 int
 276 config_set_int_param (struct slist_s **config, const char *section,
 277                       const char *name, const char *value)
 278 {
 279   struct config_section_s *s = config_find_section (*config, section);
 280
 281   if (!s)
 282     {
 283       s = new_section (config, section);
 284       if (!s)
 285         return 1;
 286     }
 287
 288   return new_param (s, NULL, 0, name, value, PARAM_INT);
 289 }
 290
 291 int
 292 config_get_int_param (struct slist_s *config, const char *section,
 293                       const char *what, int *exists)
 294 {
 295   struct config_param_s *p = config_get_param (config, section, what, exists);
 296   return *exists ? p->value.itype : -1;
 297 }
 298
 299 int
 300 config_set_bool_param (struct slist_s **config, const char *section,
 301                        const char *name, const char *value)
 302 {
 303   struct config_section_s *s = config_find_section (*config, section);
 304
 305   if (!s)
 306     {
 307       s = new_section (config, section);
 308       if (!s)
 309         return 1;
 310     }
 311
 312   return new_param (s, NULL, 0, name, value, PARAM_BOOL);
 313 }
 314
 315 int
 316 config_get_bool_param (struct slist_s *config, const char *section,
 317                        const char *what, int *exists)
 318 {
 319   return config_get_int_param (config, section, what, exists);
 320 }
 321
 322 int
 323 config_set_long_param (struct slist_s **config, const char *section,
 324                        const char *name, const char *value)
 325 {
 326   struct config_section_s *s = config_find_section (*config, section);
 327
 328   if (!s)
 329     {
 330       s = new_section (config, section);
 331       if (!s)
 332         return 1;
 333     }
 334
 335   return new_param (s, NULL, 0, name, value, PARAM_LONG);
 336 }
 337
 338 unsigned long
 339 config_get_ulong_param (struct slist_s *config, const char *section,
 340                         const char *what, int *exists)
 341 {
 342   struct config_param_s *p = config_get_param (config, section, what, exists);
 343   return *exists ? p->value.ultype : 0;
 344 }
 345
 346 long
 347 config_get_long_param (struct slist_s *config, const char *section,
 348                        const char *what, int *exists)
 349 {
 350   struct config_param_s *p = config_get_param (config, section, what, exists);
 351   return *exists ? p->value.ltype : -1;
 352 }
 353
 354 int
 355 config_set_longlong_param (struct slist_s **config, const char *section,
 356                            const char *name, const char *value)
 357 {
 358   struct config_section_s *s = config_find_section (*config, section);
 359
 360   if (!s)
 361     {
 362       s = new_section (config, section);
 363       if (!s)
 364         return 1;
 365     }
 366
 367   return new_param (s, NULL, 0, name, value, PARAM_LONGLONG);
 368 }
 369
 370 long long
 371 config_get_longlong_param (struct slist_s *config,
 372                            const char *section, const char *what, int *exists)
 373 {
 374   struct config_param_s *p = config_get_param (config, section, what, exists);
 375   return *exists ? p->value.lltype : -1;
 376 }
 377
 378 unsigned long long
 379 config_get_ulonglong_param (struct slist_s *config,
 380                             const char *section,
 381                             const char *what, int *exists)
 382 {
 383   struct config_param_s *p = config_get_param (config, section, what, exists);
 384   return *exists ? p->value.ulltype : 0;
 385 }
 386
 387 int
 388 config_set_list_param (struct slist_s **config, const char *section,
 389                        const char *name, const char *value)
 390 {
 391   struct config_section_s *s = config_find_section (*config, section);
 392
 393   if (!s)
 394     {
 395       s = new_section (config, section);
 396       if (!s)
 397         return 1;
 398     }
 399
 400   return new_param (s, NULL, 0, name, value, PARAM_CHARPP);
 401 }
 402
 403 char **
 404 config_get_list_param (struct slist_s *config, const char *section,
 405                        const char *what, int *exists)
 406 {
 407   struct config_param_s *p = config_get_param (config, section, what, exists);
 408   return *exists && p->value.cpptype ? strv_dup (p->value.cpptype) : NULL;
 409 }
 410
 411 char *
 412 config_get_string (const char *section, const char *what)
 413 {
 414   char *val = NULL;
 415   const char *where = section ? section : "global";
 416   int exists = 0;
 417
 418   MUTEX_LOCK (&rcfile_mutex);
 419   val = config_get_string_param (global_config, where, what, &exists);
 420   if (!exists && strcmp (section ? section : "", "global"))
 421     val = config_get_string_param (global_config, "global", what, &exists);
 422
 423   MUTEX_UNLOCK (&rcfile_mutex);
 424   return val;
 425 }
 426
 427 char **
 428 config_get_list (const char *section, const char *what)
 429 {
 430   char **val = NULL;
 431   const char *where = section ? section : "global";
 432   int exists = 0;
 433
 434   MUTEX_LOCK (&rcfile_mutex);
 435   val = config_get_list_param (global_config, where, what, &exists);
 436   if (!exists && strcmp (section ? section : "", "global"))
 437     val = config_get_list_param (global_config, "global", what, &exists);
 438
 439   MUTEX_UNLOCK (&rcfile_mutex);
 440   return val;
 441 }
 442
 443 int
 444 config_get_integer (const char *section, const char *what)
 445 {
 446   int val = 0;
 447   const char *where = section ? section : "global";
 448   int exists = 0;
 449
 450   MUTEX_LOCK (&rcfile_mutex);
 451   val = config_get_int_param (global_config, where, what, &exists);
 452   if (!exists && strcmp (section ? section : "", "global"))
 453     val = config_get_int_param (global_config, "global", what, &exists);
 454
 455   MUTEX_UNLOCK (&rcfile_mutex);
 456   return val;
 457 }
 458
 459 long long
 460 config_get_longlong (const char *section, const char *what)
 461 {
 462   long long val = 0;
 463   const char *where = section ? section : "global";
 464   int exists = 0;
 465
 466   MUTEX_LOCK (&rcfile_mutex);
 467   val = config_get_longlong_param (global_config, where, what, &exists);
 468   if (!exists && strcmp (section ? section : "", "global"))
 469     val = config_get_longlong_param (global_config, "global", what, &exists);
 470
 471   MUTEX_UNLOCK (&rcfile_mutex);
 472   return val;
 473 }
 474
 475 unsigned long long
 476 config_get_ulonglong (const char *section, const char *what)
 477 {
 478   unsigned long long val = 0;
 479   const char *where = section ? section : "global";
 480   int exists = 0;
 481
 482   MUTEX_LOCK (&rcfile_mutex);
 483   val = config_get_ulonglong_param (global_config, where, what, &exists);
 484   if (!exists && strcmp (section ? section : "", "global"))
 485     val = config_get_ulonglong_param (global_config, "global", what, &exists);
 486
 487   MUTEX_UNLOCK (&rcfile_mutex);
 488   return val;
 489 }
 490
 491 long
 492 config_get_long (const char *section, const char *what)
 493 {
 494   long val = 0;
 495   const char *where = section ? section : "global";
 496   int exists = 0;
 497
 498   MUTEX_LOCK (&rcfile_mutex);
 499   val = config_get_long_param (global_config, where, what, &exists);
 500   if (!exists && strcmp (section ? section : "", "global"))
 501     val = config_get_long_param (global_config, "global", what, &exists);
 502
 503   MUTEX_UNLOCK (&rcfile_mutex);
 504   return val;
 505 }
 506
 507 unsigned long
 508 config_get_ulong (const char *section, const char *what)
 509 {
 510   unsigned long val = 0;
 511   const char *where = section ? section : "global";
 512   int exists = 0;
 513
 514   MUTEX_LOCK (&rcfile_mutex);
 515   val = config_get_ulong_param (global_config, where, what, &exists);
 516   if (!exists && strcmp (section ? section : "", "global"))
 517     val = config_get_ulong_param (global_config, "global", what, &exists);
 518
 519   MUTEX_UNLOCK (&rcfile_mutex);
 520   return val;
 521 }
 522
 523 int
 524 config_get_boolean (const char *section, const char *what)
 525 {
 526   return config_get_integer (section, what);
 527 }
 528
 529 char *
 530 config_get_value (const char *section, const char *what)
 531 {
 532   const char *where = section ? section : "global";
 533   int exists = 0;
 534   int i;
 535   int ival;
 536   long lval;
 537   long long llval;
 538   unsigned long ulval;
 539   unsigned long long ullval;
 540   char *cpval;
 541   char **cppval;
 542   char *result = NULL;
 543
 544   MUTEX_LOCK (&rcfile_mutex);
 545
 546   for (i = 0; config_params[i].name; i++)
 547     {
 548       if (!strcmp (config_params[i].name, what))
 549         {
 550           switch (config_params[i].type)
 551             {
 552             case PARAM_BOOL:
 553             case PARAM_INT:
 554               ival = config_get_int_param (global_config, where, what,
 555                                            &exists);
 556               if (!exists && strcmp (section ? section : "", "global"))
 557                 ival = config_get_int_param (global_config, "global", what,
 558                                              &exists);
 559               result = str_asprintf ("%i", ival);
 560               break;
 561             case PARAM_CHARP:
 562               cpval = config_get_string_param (global_config, where, what,
 563                                                &exists);
 564               if (!exists && strcmp (section ? section : "", "global"))
 565                 cpval =
 566                   config_get_string_param (global_config, "global", what,
 567                                            &exists);
 568               result = cpval;
 569               break;
 570             case PARAM_LONG:
 571               lval = config_get_long_param (global_config, where, what,
 572                                             &exists);
 573               if (!exists && strcmp (section ? section : "", "global"))
 574                 lval = config_get_long_param (global_config, "global", what,
 575                                               &exists);
 576               result = str_asprintf ("%li", lval);
 577               break;
 578             case PARAM_ULONG:
 579               ulval = config_get_ulong_param (global_config, where, what,
 580                                               &exists);
 581               if (!exists && strcmp (section ? section : "", "global"))
 582                 ulval = config_get_ulong_param (global_config, "global", what,
 583                                                 &exists);
 584               result = str_asprintf ("%lu", ulval);
 585               break;
 586             case PARAM_LONGLONG:
 587               llval = config_get_longlong_param (global_config, where, what,
 588                                                  &exists);
 589               if (!exists && strcmp (section ? section : "", "global"))
 590                 llval = config_get_longlong_param (global_config, "global",
 591                                                    what, &exists);
 592               result = str_asprintf ("%lli", llval);
 593               break;
 594             case PARAM_ULONGLONG:
 595               ullval = config_get_ulonglong_param (global_config, where, what,
 596                                                    &exists);
 597               if (!exists && strcmp (section ? section : "", "global"))
 598                 ullval = config_get_ulonglong_param (global_config, "global",
 599                                                      what, &exists);
 600               result = str_asprintf ("%llu", ullval);
 601               break;
 602             case PARAM_CHARPP:
 603               cppval = config_get_list_param (global_config, where, what,
 604                                               &exists);
 605               if (!exists && strcmp (section ? section : "", "global"))
 606                 cppval = config_get_list_param (global_config, "global", what,
 607                                                 &exists);
 608
 609               if (cppval)
 610                 result = strv_join (",", cppval);
 611
 612               strv_free (cppval);
 613               break;
 614             }
 615         }
 616     }
 617
 618   MUTEX_UNLOCK (&rcfile_mutex);
 619   return result;
 620 }
 621
 622 static void
 623 parse_allowed_file (struct slist_s *config, const char *section)
 624 {
 625   FILE *fp;
 626   char buf[LINE_MAX];
 627   int exists;
 628   char **list = NULL;
 629   char *tmp;
 630   char *p = config_get_string_param (config, section, "allowed_file", &exists);
 631
 632   if (!p || !*p)
 633     {
 634       xfree (p);
 635       return;
 636     }
 637
 638   tmp = expand_homedir (p);
 639   xfree (p);
 640   p = tmp;
 641   fp = fopen (p, "r");
 642   if (!fp)
 643     {
 644       log_write ("%s: %s", p, strerror (errno));
 645       xfree (p);
 646       return;
 647     }
 648
 649   xfree (p);
 650   list = config_get_list_param (config, section, "allowed", &exists);
 651   if (!list && exists)
 652     {
 653       fclose (fp);
 654       log_write ("%s", strerror (ENOMEM));
 655       return;
 656     }
 657
 658   while ((p = fgets (buf, sizeof (buf), fp)))
 659     {
 660       char **pp;
 661
 662       if (p[strlen(p)-1] == '\n')
 663         p[strlen(p)-1] = 0;
 664
 665       while (*p && isspace (*p))
 666         p++;
 667
 668       if (!*p)
 669         continue;
 670
 671       tmp = str_dup (p);
 672       if (tmp)
 673         pp = strv_cat (list, str_dup (p));
 674
 675       if (!pp || !tmp)
 676         {
 677           xfree (tmp);
 678           strv_free (list);
 679           fclose (fp);
 680           log_write ("%s", strerror (ENOMEM));
 681           return;
 682         }
 683
 684       xfree (tmp);
 685       list = pp;
 686     }
 687
 688   fclose(fp);
 689   if (!list)
 690     return;
 691
 692   p = strv_join (",", list);
 693   strv_free (list);
 694
 695   if (!p)
 696     {
 697       log_write ("%s", strerror (ENOMEM));
 698       return;
 699     }
 700
 701   config_set_list_param (&config, section, "allowed", p);
 702   xfree (p);
 703 }
 704
 705 static int
 706 fixup_allowed_once (struct slist_s **config, const char *section)
 707 {
 708   char **list, **pp, *p;
 709   int exists;
 710
 711   parse_allowed_file (*config, section);
 712   list = config_get_list_param (*config, section, "allowed", &exists);
 713   for (pp = list; pp && *pp; pp++)
 714     {
 715       if (*(*pp) == '#')
 716         {
 717           for (p = *pp; p && *p; p++)
 718             *p = toupper(*p);
 719         }
 720     }
 721
 722   strv_free (list);
 723   if (!exists)
 724     {
 725       if (!strcmp (section, "global"))
 726         {
 727           p = get_username (getuid());
 728
 729           if (config_set_list_param (config, section, "allowed", p))
 730             {
 731               xfree (p);
 732               return 1;
 733             }
 734
 735           xfree (p);
 736         }
 737       else
 738         {
 739           list = config_get_list_param (*config, "global", "allowed", &exists);
 740           if (list)
 741             {
 742               p = strv_join (",", list);
 743               strv_free (list);
 744               if (config_set_list_param (config, section, "allowed", p))
 745                 {
 746                   xfree (p);
 747                   return 1;
 748                 }
 749
 750               xfree (p);
 751             }
 752         }
 753     }
 754
 755   return 0;
 756 }
 757
 758 static int
 759 fixup_allowed (struct slist_s **config)
 760 {
 761   int n, t = slist_length (*config);
 762
 763   for (n = 0; n < t; n++)
 764     {
 765       struct config_section_s *section;
 766
 767       section = slist_nth_data (*config, n);
 768       if (fixup_allowed_once (config, section->name))
 769         return 1;
 770     }
 771
 772   return 0;
 773 }
 774
 775 static int
 776 set_defaults (struct slist_s **config)
 777 {
 778   char *s = NULL;
 779   char **list;
 780   int exists;
 781   int i;
 782   struct passwd *pwd;
 783
 784   for (i = 0; config_params[i].name; i++)
 785     {
 786       switch (config_params[i].type)
 787         {
 788         case PARAM_BOOL:
 789           config_get_bool_param (*config, "global", config_params[i].name,
 790                                  &exists);
 791           if (!exists)
 792             {
 793               if (config_set_bool_param
 794                   (config, "global", config_params[i].name,
 795                    config_params[i].value))
 796                 goto fail;
 797             }
 798           break;
 799         case PARAM_INT:
 800           config_get_int_param (*config, "global", config_params[i].name,
 801                                 &exists);
 802           if (!exists)
 803             {
 804               if (config_set_int_param
 805                   (config, "global", config_params[i].name,
 806                    config_params[i].value))
 807                 goto fail;
 808             }
 809           break;
 810         case PARAM_CHARP:
 811           s = config_get_string_param (*config, "global",
 812                                         config_params[i].name, &exists);
 813           xfree (s);
 814           if (!exists && config_params[i].value)
 815             {
 816               if (config_set_string_param (config, "global",
 817                                            config_params[i].name,
 818                                            config_params[i].value))
 819                 goto fail;
 820             }
 821           break;
 822         case PARAM_CHARPP:
 823           list = config_get_list_param (*config, "global",
 824                                         config_params[i].name, &exists);
 825           strv_free (list);
 826           if (!exists && config_params[i].value)
 827             {
 828               if (config_set_list_param (config, "global",
 829                                          config_params[i].name,
 830                                          config_params[i].value))
 831                 goto fail;
 832             }
 833           break;
 834         case PARAM_LONG:
 835           config_get_long_param (*config, "global", config_params[i].name,
 836                                  &exists);
 837           if (!exists)
 838             {
 839               if (config_set_long_param
 840                   (config, "global", config_params[i].name,
 841                    config_params[i].value))
 842                 goto fail;
 843             }
 844           break;
 845         case PARAM_LONGLONG:
 846           config_get_longlong_param (*config, "global", config_params[i].name,
 847                                      &exists);
 848           if (!exists)
 849             {
 850               if (config_set_longlong_param (config, "global",
 851                                              config_params[i].name,
 852                                              config_params[i].value))
 853                 goto fail;
 854             }
 855           break;
 856         }
 857     }
 858
 859   s = NULL;
 860   if (fixup_allowed (config))
 861     goto fail;
 862
 863   max_recursion_depth = config_get_int_param (*config, "global",
 864                                               "recursion_depth", &exists);
 865   disable_list_and_dump = config_get_bool_param (*config, "global",
 866                                                  "disable_list_and_dump",
 867                                                  &exists);
 868 #ifdef HAVE_MLOCKALL
 869   disable_mlock =
 870     config_get_bool_param (*config, "global", "disable_mlockall", &exists);
 871 #endif
 872
 873   s = config_get_string_param(*config, "global", "invoking_user", &exists);
 874   errno = 0;
 875   if (!s || !*s)
 876     pwd = getpwuid(getuid());
 877   else
 878     pwd = getpwnam(s);
 879
 880   if (!pwd)
 881     {
 882       log_write (_("could not set invoking user: user '%s' is invalid"), s);
 883       goto fail;
 884     }
 885
 886   xfree (s);
 887   config_set_string_param(config, "global", "invoking_user", pwd->pw_name);
 888 #ifdef WITH_GNUTLS
 889   invoking_tls = config_get_string_param(*config, "global", "invoking_tls",
 890                                          &exists);
 891   for (char *p = invoking_tls; p && *p; p++)
 892     *p = toupper(*p);
 893
 894   config_set_string_param(config, "global", "invoking_tls", invoking_tls);
 895 #endif
 896   invoking_uid = pwd->pw_uid;
 897   invoking_gid = pwd->pw_gid;
 898   return 0;
 899
 900 fail:
 901   xfree (s);
 902   return 1;
 903 }
 904
 905 static struct config_section_s *
 906 config_find_section (struct slist_s *config, const char *name)
 907 {
 908   unsigned i, t = slist_length (config);
 909
 910   for (i = 0; i < t; i++)
 911     {
 912       struct config_section_s *s = slist_nth_data (config, i);
 913
 914       if (!strcmp (s->name, name))
 915         return s;
 916     }
 917
 918   return NULL;
 919 }
 920
 921 /* Append a new parameter to the list of parameters for a file
 922  * section. When an existing parameter of the same name exists, its
 923  * value is updated.
 924  */
 925 static int
 926 new_param (struct config_section_s *section, const char *filename, int lineno,
 927            const char *name, const char *value, int type)
 928 {
 929   struct config_param_s *param = NULL;
 930   struct slist_s *tmp;
 931   char *e;
 932   unsigned i, t = slist_length (section->params);
 933   int dup = 0;
 934
 935   for (i = 0; i < t; i++)
 936     {
 937       struct config_param_s *p = slist_nth_data (section->params, i);
 938       if (!p)
 939         break;
 940
 941       if (!strcmp (name, p->name))
 942         {
 943           param = p;
 944           dup = 1;
 945           break;
 946         }
 947     }
 948
 949   if (!param)
 950     {
 951       param = xcalloc (1, sizeof (struct config_param_s));
 952       if (!param)
 953         {
 954           log_write ("%s", pwmd_strerror (ENOMEM));
 955           return 1;
 956         }
 957
 958       param->name = str_dup (name);
 959       if (!param->name)
 960         {
 961           xfree (param);
 962           log_write ("%s", pwmd_strerror (ENOMEM));
 963           return 1;
 964         }
 965     }
 966
 967   param->type = type;
 968
 969   switch (type)
 970     {
 971     case PARAM_BOOL:
 972       if (!strcasecmp (value, "no") || !strcasecmp (value, "0")
 973           || !strcasecmp (value, "false"))
 974         param->value.itype = 0;
 975       else if (!strcasecmp (value, "yes") || !strcasecmp (value, "1")
 976                || !strcasecmp (value, "true"))
 977         param->value.itype = 1;
 978       else
 979         {
 980           INVALID_VALUE (filename, lineno);
 981           goto fail;
 982         }
 983       param->type = PARAM_INT;
 984       break;
 985     case PARAM_CHARP:
 986       xfree (param->value.cptype);
 987       param->value.cptype = NULL;
 988       param->value.cptype = value && *value ? str_dup (value) : NULL;
 989       if (value && *value && !param->value.cptype)
 990         {
 991           log_write ("%s", pwmd_strerror (ENOMEM));
 992           goto fail;
 993         }
 994       break;
 995     case PARAM_CHARPP:
 996       strv_free (param->value.cpptype);
 997       param->value.cpptype = NULL;
 998       param->value.cpptype = value && *value ? str_split (value, ",", 0) : NULL;
 999       if (value && *value && !param->value.cpptype)
1000         {
1001           log_write ("%s", pwmd_strerror (ENOMEM));
1002           goto fail;
1003         }
1004       break;
1005     case PARAM_INT:
1006       param->value.itype = strtol (value, &e, 10);
1007       if (e && *e)
1008         {
1009           INVALID_VALUE (filename, lineno);
1010           goto fail;
1011         }
1012       break;
1013     case PARAM_LONG:
1014       param->value.ltype = strtol (value, &e, 10);
1015       if (e && *e)
1016         {
1017           INVALID_VALUE (filename, lineno);
1018           goto fail;
1019         }
1020       break;
1021     case PARAM_LONGLONG:
1022       param->value.lltype = strtoll (value, &e, 10);
1023       if (e && *e)
1024         {
1025           INVALID_VALUE (filename, lineno);
1026           goto fail;
1027         }
1028       break;
1029     case PARAM_ULONGLONG:
1030       param->value.ulltype = strtoull (value, &e, 10);
1031       if (e && *e)
1032         {
1033           INVALID_VALUE (filename, lineno);
1034           goto fail;
1035         }
1036       break;
1037     case PARAM_ULONG:
1038       param->value.ultype = strtoul (value, &e, 10);
1039       if (e && *e)
1040         {
1041           INVALID_VALUE (filename, lineno);
1042           goto fail;
1043         }
1044       break;
1045     }
1046
1047   if (dup)
1048     return 0;
1049
1050   tmp = slist_append (section->params, param);
1051   if (!tmp)
1052     {
1053       log_write ("%s", pwmd_strerror (ENOMEM));
1054       goto fail;
1055     }
1056
1057   section->params = tmp;
1058   return 0;
1059
1060 fail:
1061   xfree (param->name);
1062   xfree (param);
1063   return 1;
1064 }
1065
1066 struct slist_s *
1067 config_parse (const char *filename)
1068 {
1069   struct slist_s *tmpconfig = NULL, *tmp;
1070   struct config_section_s *cur_section = NULL;
1071   char buf[LINE_MAX];
1072   char *s;
1073   int lineno = 1;
1074   int have_global = 0;
1075   FILE *fp = fopen (filename, "r");
1076
1077   if (!fp)
1078     {
1079       log_write ("%s: %s", filename,
1080                  pwmd_strerror (gpg_error_from_errno (errno)));
1081
1082       if (errno != ENOENT)
1083         return NULL;
1084
1085       log_write (_("Using defaults!"));
1086       goto defaults;
1087     }
1088
1089   for (; (s = fgets (buf, sizeof (buf), fp)); lineno++)
1090     {
1091       char line[LINE_MAX] = { 0 };
1092       size_t len = 0;
1093
1094       if (*s == '#')
1095         continue;
1096
1097       s = str_chomp (s);
1098       for (; s && *s; s++)
1099         {
1100           int match = 0;
1101
1102           /* New file section. */
1103           if (*s == '[')
1104             {
1105               struct config_section_s *section;
1106               char *p = strchr (++s, ']');
1107
1108               if (!p)
1109                 {
1110                   log_write (_("%s(%i): unbalanced braces"), filename,
1111                              lineno);
1112                   goto fail;
1113                 }
1114
1115               len = strlen (s) - strlen (p);
1116               memcpy (line, s, len);
1117               line[len] = 0;
1118
1119               section = config_find_section (tmpconfig, line);
1120               if (section)
1121                 {
1122                   log_write (_("%s(%i): section '%s' already exists!"),
1123                              filename, lineno, line);
1124                   goto fail;
1125                 }
1126
1127               if (!strcmp (line, "global"))
1128                 have_global = 1;
1129
1130               section = xcalloc (1, sizeof (struct config_section_s));
1131               section->name = str_dup (line);
1132
1133               if (cur_section)
1134                 {
1135                   tmp = slist_append (tmpconfig, cur_section);
1136                   if (!tmp)
1137                     {
1138                       log_write ("%s", pwmd_strerror (ENOMEM));
1139                       goto fail;
1140                     }
1141
1142                   tmpconfig = tmp;
1143                 }
1144
1145               cur_section = section;
1146               break;
1147             }
1148
1149           if (!cur_section)
1150             {
1151               log_write (_("%s(%i): parameter outside of section!"), filename,
1152                          lineno);
1153               goto fail;
1154             }
1155
1156           /* Parameters for each section. */
1157           for (int m = 0; config_params[m].name; m++)
1158             {
1159               size_t len = strlen (config_params[m].name);
1160
1161               if (!strncmp (s, config_params[m].name, len))
1162                 {
1163                   char *p = s + len;
1164
1165                   while (*p && *p == ' ')
1166                     p++;
1167
1168                   if (!*p || *p != '=')
1169                     continue;
1170
1171                   p++;
1172                   while (*p && isspace (*p))
1173                     p++;
1174
1175                   s[len] = 0;
1176                   if (new_param (cur_section, filename, lineno, s, p,
1177                                  config_params[m].type))
1178                     goto fail;
1179
1180                   match = 1;
1181                   break;
1182                 }
1183             }
1184
1185           if (!match)
1186             {
1187               log_write (_("%s(%i): unknown parameter"), filename, lineno);
1188               goto fail;
1189             }
1190
1191           break;
1192         }
1193     }
1194
1195   if (cur_section)
1196     {
1197       tmp = slist_append (tmpconfig, cur_section);
1198       if (!tmp)
1199         {
1200           log_write ("%s", pwmd_strerror (ENOMEM));
1201           goto fail;
1202         }
1203
1204       cur_section = NULL;
1205       tmpconfig = tmp;
1206     }
1207
1208   if (!have_global)
1209     log_write (_
1210                ("WARNING: %s: could not find a [global] configuration section!"),
1211                filename);
1212
1213 defaults:
1214   if (set_defaults (&tmpconfig))
1215     goto fail;
1216
1217   if (fp)
1218     fclose(fp);
1219
1220   return tmpconfig;
1221
1222 fail:
1223   if (fp)
1224     fclose (fp);
1225
1226   config_free (tmpconfig);
1227   free_section (cur_section);
1228   return NULL;
1229 }
1230
1231 static void
1232 free_section (struct config_section_s *s)
1233 {
1234   if (!s)
1235     return;
1236
1237   for (;;)
1238     {
1239       struct config_param_s *p = slist_nth_data (s->params, 0);
1240
1241       if (!p)
1242         break;
1243
1244       section_remove_param (s, p->name);
1245     }
1246
1247   s->params = NULL;
1248   xfree (s->name);
1249   s->name = NULL;
1250 }
1251
1252 void
1253 config_free (struct slist_s *config)
1254 {
1255   for (;;)
1256     {
1257       struct config_section_s *s = slist_nth_data (config, 0);
1258       if (!s)
1259         break;
1260
1261       free_section (s);
1262       config = slist_remove (config, s);
1263       xfree (s);
1264     }
1265 }