src/rcfile.c

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