server/config_init.c

   1 /*
   2  ******************************************************************************
   3  *
   4  * File:    config_init.c
   5  *
   6  * Author:  Damien Stuart
   7  *
   8  * Purpose: Command-line and config file processing for fwknop server.
   9  *
  10  * Copyright 2010 Damien Stuart (dstuart@dstuart.org)
  11  *
  12  *  License (GNU Public License):
  13  *
  14  *  This program is free software; you can redistribute it and/or
  15  *  modify it under the terms of the GNU General Public License
  16  *  as published by the Free Software Foundation; either version 2
  17  *  of the License, or (at your option) any later version.
  18  *
  19  *  This program is distributed in the hope that it will be useful,
  20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program; if not, write to the Free Software
  26  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  27  *  USA
  28  *
  29  ******************************************************************************
  30 */
  31 #include "fwknopd_common.h"
  32 #include "config_init.h"
  33 #include "access.h"
  34 #include "cmd_opts.h"
  35 #include "utils.h"
  36 #include "log_msg.h"
  37
  38 /* Check to see if an integer variable has a value that is within a
  39  * specific range
  40 */
  41 static void
  42 range_check(fko_srv_options_t *opts, char *var, char *val, int low, int high)
  43 {
  44     if (low > atoi(val) || high < atoi(val))
  45     {
  46         fprintf(stderr, "[*] var %s value '%s' not in the range %d-%d\n",
  47             var, val, low, high);
  48         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
  49     }
  50     return;
  51 }
  52
  53 /* Take an index and a string value. malloc the space for the value
  54  * and assign it to the array at the specified index.
  55 */
  56 static void
  57 set_config_entry(fko_srv_options_t *opts, const int var_ndx, const char *value)
  58 {
  59     int space_needed;
  60
  61     /* Sanity check the index value.
  62     */
  63     if(var_ndx < 0 || var_ndx >= NUMBER_OF_CONFIG_ENTRIES)
  64     {
  65         fprintf(stderr, "Index value of %i is not valid\n", var_ndx);
  66         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
  67     }
  68
  69     /* If this particular entry was already set (i.e. not NULL), then
  70      * assume it needs to be freed first.
  71     */
  72     if(opts->config[var_ndx] != NULL)
  73         free(opts->config[var_ndx]);
  74
  75     /* If we are setting it to NULL, do it and be done.
  76     */
  77     if(value == NULL)
  78     {
  79         opts->config[var_ndx] = NULL;
  80         return;
  81     }
  82
  83     /* Otherwise, make the space we need and set it.
  84     */
  85     space_needed = strlen(value) + 1;
  86
  87     opts->config[var_ndx] = malloc(space_needed);
  88
  89     if(opts->config[var_ndx] == NULL)
  90     {
  91         fprintf(stderr, "*Fatal memory allocation error!\n");
  92         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
  93     }
  94
  95     strlcpy(opts->config[var_ndx], value, space_needed);
  96
  97     return;
  98 }
  99
 100 /* Given a config parameter name, return its index or -1 if not found.
 101 */
 102 static int
 103 config_entry_index(const fko_srv_options_t *opts, const char *var)
 104 {
 105     int i;
 106
 107     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
 108         if(opts->config[i] != NULL && CONF_VAR_IS(var, config_map[i]))
 109             return(i);
 110
 111     return(-1);
 112 }
 113
 114 /* Free the config memory
 115 */
 116 void
 117 free_configs(fko_srv_options_t *opts)
 118 {
 119     int i;
 120
 121     free_acc_stanzas(opts);
 122
 123     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
 124         if(opts->config[i] != NULL)
 125             free(opts->config[i]);
 126 }
 127
 128 static void
 129 validate_int_var_ranges(fko_srv_options_t *opts)
 130 {
 131     range_check(opts, "PCAP_LOOP_SLEEP", opts->config[CONF_PCAP_LOOP_SLEEP],
 132         1, RCHK_MAX_PCAP_LOOP_SLEEP);
 133     range_check(opts, "MAX_SPA_PACKET_AGE", opts->config[CONF_MAX_SPA_PACKET_AGE],
 134         1, RCHK_MAX_SPA_PACKET_AGE);
 135     range_check(opts, "MAX_SNIFF_BYTES", opts->config[CONF_MAX_SNIFF_BYTES],
 136         1, RCHK_MAX_SNIFF_BYTES);
 137     range_check(opts, "TCPSERV_PORT", opts->config[CONF_TCPSERV_PORT],
 138         1, RCHK_MAX_TCPSERV_PORT);
 139
 140 #if FIREWALL_IPFW
 141     range_check(opts, "IPFW_START_RULE_NUM", opts->config[CONF_IPFW_START_RULE_NUM],
 142         0, RCHK_MAX_IPFW_START_RULE_NUM);
 143     range_check(opts, "IPFW_MAX_RULES", opts->config[CONF_IPFW_MAX_RULES],
 144         1, RCHK_MAX_IPFW_MAX_RULES);
 145     range_check(opts, "IPFW_ACTIVE_SET_NUM", opts->config[CONF_IPFW_ACTIVE_SET_NUM],
 146         0, RCHK_MAX_IPFW_SET_NUM);
 147     range_check(opts, "IPFW_EXPIRE_SET_NUM", opts->config[CONF_IPFW_EXPIRE_SET_NUM],
 148         0, RCHK_MAX_IPFW_SET_NUM);
 149     range_check(opts, "IPFW_EXPIRE_PURGE_INTERVAL",
 150         opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL],
 151         1, RCHK_MAX_IPFW_PURGE_INTERVAL);
 152
 153     /* Make sure the active and expire sets are not identical whenever
 154      * they are non-zero
 155     */
 156     if((opts->config[CONF_IPFW_ACTIVE_SET_NUM] > 0
 157             && opts->config[CONF_IPFW_EXPIRE_SET_NUM] > 0)
 158             && (opts->config[CONF_IPFW_ACTIVE_SET_NUM]
 159                 == opts->config[CONF_IPFW_EXPIRE_SET_NUM]))
 160     {
 161         fprintf(stderr,
 162                 "[*] Cannot set identical ipfw active and expire sets.\n");
 163         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 164     }
 165
 166 #elif FIREWALL_PF
 167     range_check(opts, "PF_EXPIRE_INTERVAL", opts->config[CONF_PF_EXPIRE_INTERVAL],
 168         1, RCHK_MAX_PF_EXPIRE_INTERVAL);
 169
 170 #endif /* FIREWALL type */
 171
 172     return;
 173 }
 174
 175 /* Parse the config file...
 176 */
 177 static void
 178 parse_config_file(fko_srv_options_t *opts, const char *config_file)
 179 {
 180     FILE           *cfile_ptr;
 181     unsigned int    numLines = 0;
 182     unsigned int    i, good_ent;
 183     int             cndx;
 184
 185     char            conf_line_buf[MAX_LINE_LEN] = {0};
 186     char            var[MAX_LINE_LEN]  = {0};
 187     char            val[MAX_LINE_LEN]  = {0};
 188     char            tmp1[MAX_LINE_LEN] = {0};
 189     char            tmp2[MAX_LINE_LEN] = {0};
 190
 191     struct stat     st;
 192
 193     /* First see if the config file exists.  If it doesn't, complain
 194      * and go on with program defaults.
 195     */
 196     if(stat(config_file, &st) != 0)
 197     {
 198         fprintf(stderr, "[*] Config file: '%s' was not found.\n",
 199             config_file);
 200         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 201     }
 202
 203     if ((cfile_ptr = fopen(config_file, "r")) == NULL)
 204     {
 205         fprintf(stderr, "[*] Could not open config file: %s\n",
 206             config_file);
 207         perror(NULL);
 208
 209         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 210     }
 211
 212     while ((fgets(conf_line_buf, MAX_LINE_LEN, cfile_ptr)) != NULL)
 213     {
 214         numLines++;
 215         conf_line_buf[MAX_LINE_LEN-1] = '\0';
 216
 217         /* Get past comments and empty lines (note: we only look at the
 218          * first character.
 219         */
 220         if(IS_EMPTY_LINE(conf_line_buf[0]))
 221             continue;
 222
 223         if(sscanf(conf_line_buf, "%s %[^;\n\r]", var, val) != 2)
 224         {
 225             fprintf(stderr,
 226                 "*Invalid config file entry in %s at line %i.\n - '%s'",
 227                 config_file, numLines, conf_line_buf
 228             );
 229             continue;
 230         }
 231
 232         /*
 233         fprintf(stderr,
 234             "CONF FILE: %s, LINE: %s\tVar: %s, Val: '%s'\n",
 235             config_file, conf_line_buf, var, val
 236         );
 237         */
 238
 239         good_ent = 0;
 240         for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
 241         {
 242             if(CONF_VAR_IS(config_map[i], var))
 243             {
 244                 /* First check to see if we need to do a varable expansion
 245                  * on this value.  Note: this only supports one expansion and
 246                  * only if the value starts with the variable.
 247                 */
 248                 if(*val == '$')
 249                 {
 250                     if(sscanf((val+1), "%[A-Z_]%s", tmp1, tmp2))
 251                     {
 252                         if((cndx = config_entry_index(opts, tmp1)) >= 0)
 253                         {
 254                             strlcpy(val, opts->config[cndx], MAX_LINE_LEN);
 255                             strlcat(val, tmp2, MAX_LINE_LEN);
 256                         }
 257                     }
 258                 }
 259
 260                 set_config_entry(opts, i, val);
 261                 good_ent++;
 262                 break;
 263             }
 264         }
 265
 266         if(good_ent == 0)
 267             fprintf(stderr,
 268                 "*Ignoring unknown configuration parameter: '%s' in %s\n",
 269                 var, config_file
 270             );
 271     }
 272
 273     fclose(cfile_ptr);
 274
 275     return;
 276 }
 277
 278 /* Set defaults, and do sanity and bounds checks for the various options.
 279 */
 280 static void
 281 validate_options(fko_srv_options_t *opts)
 282 {
 283     char tmp_path[MAX_PATH_LEN];
 284
 285     /* If no conf dir is set in the config file, use the default.
 286     */
 287     if(opts->config[CONF_FWKNOP_CONF_DIR] == NULL)
 288         set_config_entry(opts, CONF_FWKNOP_CONF_DIR, DEF_CONF_DIR);
 289
 290     /* If no access.conf path was specified on the command line or set in
 291      * the config file, use the default.
 292     */
 293     if(opts->config[CONF_ACCESS_FILE] == NULL)
 294         set_config_entry(opts, CONF_ACCESS_FILE, DEF_ACCESS_FILE);
 295
 296     /* If the pid and digest cache files where not set in the config file or
 297      * via command-line, then grab the defaults. Start with RUN_DIR as the
 298      * files may depend on that.
 299     */
 300     if(opts->config[CONF_FWKNOP_RUN_DIR] == NULL)
 301         set_config_entry(opts, CONF_FWKNOP_RUN_DIR, DEF_RUN_DIR);
 302
 303     if(opts->config[CONF_FWKNOP_PID_FILE] == NULL)
 304     {
 305         strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], MAX_PATH_LEN);
 306
 307         if(tmp_path[strlen(tmp_path)-1] != '/')
 308             strlcat(tmp_path, "/", MAX_PATH_LEN);
 309
 310         strlcat(tmp_path, DEF_PID_FILENAME, MAX_PATH_LEN);
 311
 312         set_config_entry(opts, CONF_FWKNOP_PID_FILE, tmp_path);
 313     }
 314
 315 #if USE_FILE_CACHE
 316     if(opts->config[CONF_DIGEST_FILE] == NULL)
 317 #else
 318     if(opts->config[CONF_DIGEST_DB_FILE] == NULL)
 319 #endif
 320     {
 321         strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], MAX_PATH_LEN);
 322
 323         if(tmp_path[strlen(tmp_path)-1] != '/')
 324             strlcat(tmp_path, "/", MAX_PATH_LEN);
 325
 326
 327 #if USE_FILE_CACHE
 328         strlcat(tmp_path, DEF_DIGEST_CACHE_FILENAME, MAX_PATH_LEN);
 329         set_config_entry(opts, CONF_DIGEST_FILE, tmp_path);
 330 #else
 331         strlcat(tmp_path, DEF_DIGEST_CACHE_DB_FILENAME, MAX_PATH_LEN);
 332         set_config_entry(opts, CONF_DIGEST_DB_FILE, tmp_path);
 333 #endif
 334     }
 335
 336     /* Set remaining require CONF_ vars if they are not already set.  */
 337
 338     /* PCAP capture interface.
 339     */
 340     if(opts->config[CONF_PCAP_INTF] == NULL)
 341         set_config_entry(opts, CONF_PCAP_INTF, DEF_INTERFACE);
 342
 343     /* PCAP Promiscuous mode.
 344     */
 345     if(opts->config[CONF_ENABLE_PCAP_PROMISC] == NULL)
 346         set_config_entry(opts, CONF_ENABLE_PCAP_PROMISC,
 347             DEF_ENABLE_PCAP_PROMISC);
 348
 349     /* The packet count argument to pcap_dispatch()
 350     */
 351     if(opts->config[CONF_PCAP_DISPATCH_COUNT] == NULL)
 352         set_config_entry(opts, CONF_PCAP_DISPATCH_COUNT,
 353             DEF_PCAP_DISPATCH_COUNT);
 354
 355     /* Microseconds to sleep between pcap loop iterations
 356     */
 357     if(opts->config[CONF_PCAP_LOOP_SLEEP] == NULL)
 358         set_config_entry(opts, CONF_PCAP_LOOP_SLEEP,
 359             DEF_PCAP_LOOP_SLEEP);
 360
 361     /* PCAP Filter.
 362     */
 363     if(opts->config[CONF_PCAP_FILTER] == NULL)
 364         set_config_entry(opts, CONF_PCAP_FILTER, DEF_PCAP_FILTER);
 365
 366     /* Enable SPA packet aging.
 367     */
 368     if(opts->config[CONF_ENABLE_SPA_PACKET_AGING] == NULL)
 369         set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING,
 370             DEF_ENABLE_SPA_PACKET_AGING);
 371
 372     /* SPA packet age.
 373     */
 374     if(opts->config[CONF_MAX_SPA_PACKET_AGE] == NULL)
 375         set_config_entry(opts, CONF_MAX_SPA_PACKET_AGE,
 376             DEF_MAX_SPA_PACKET_AGE);
 377
 378
 379     /* Enable digest persistence.
 380     */
 381     if(opts->config[CONF_ENABLE_DIGEST_PERSISTENCE] == NULL)
 382         set_config_entry(opts, CONF_ENABLE_DIGEST_PERSISTENCE,
 383             DEF_ENABLE_DIGEST_PERSISTENCE);
 384
 385     /* Max sniff bytes.
 386     */
 387     if(opts->config[CONF_MAX_SNIFF_BYTES] == NULL)
 388         set_config_entry(opts, CONF_MAX_SNIFF_BYTES, DEF_MAX_SNIFF_BYTES);
 389
 390 #if FIREWALL_IPTABLES
 391     /* Enable IPT forwarding.
 392     */
 393     if(opts->config[CONF_ENABLE_IPT_FORWARDING] == NULL)
 394         set_config_entry(opts, CONF_ENABLE_IPT_FORWARDING,
 395             DEF_ENABLE_IPT_FORWARDING);
 396
 397     /* Enable IPT local NAT.
 398     */
 399     if(opts->config[CONF_ENABLE_IPT_LOCAL_NAT] == NULL)
 400         set_config_entry(opts, CONF_ENABLE_IPT_LOCAL_NAT,
 401             DEF_ENABLE_IPT_LOCAL_NAT);
 402
 403     /* Enable IPT SNAT.
 404     */
 405     if(opts->config[CONF_ENABLE_IPT_SNAT] == NULL)
 406         set_config_entry(opts, CONF_ENABLE_IPT_SNAT,
 407             DEF_ENABLE_IPT_SNAT);
 408
 409     /* Enable IPT OUTPUT.
 410     */
 411     if(opts->config[CONF_ENABLE_IPT_OUTPUT] == NULL)
 412         set_config_entry(opts, CONF_ENABLE_IPT_OUTPUT,
 413             DEF_ENABLE_IPT_OUTPUT);
 414
 415     /* Flush IPT at init.
 416     */
 417     if(opts->config[CONF_FLUSH_IPT_AT_INIT] == NULL)
 418         set_config_entry(opts, CONF_FLUSH_IPT_AT_INIT, DEF_FLUSH_IPT_AT_INIT);
 419
 420     /* Flush IPT at exit.
 421     */
 422     if(opts->config[CONF_FLUSH_IPT_AT_EXIT] == NULL)
 423         set_config_entry(opts, CONF_FLUSH_IPT_AT_EXIT, DEF_FLUSH_IPT_AT_EXIT);
 424
 425     /* IPT input access.
 426     */
 427     if(opts->config[CONF_IPT_INPUT_ACCESS] == NULL)
 428         set_config_entry(opts, CONF_IPT_INPUT_ACCESS,
 429             DEF_IPT_INPUT_ACCESS);
 430
 431     /* IPT output access.
 432     */
 433     if(opts->config[CONF_IPT_OUTPUT_ACCESS] == NULL)
 434         set_config_entry(opts, CONF_IPT_OUTPUT_ACCESS,
 435             DEF_IPT_OUTPUT_ACCESS);
 436
 437     /* IPT forward access.
 438     */
 439     if(opts->config[CONF_IPT_FORWARD_ACCESS] == NULL)
 440         set_config_entry(opts, CONF_IPT_FORWARD_ACCESS,
 441             DEF_IPT_FORWARD_ACCESS);
 442
 443     /* IPT dnat access.
 444     */
 445     if(opts->config[CONF_IPT_DNAT_ACCESS] == NULL)
 446         set_config_entry(opts, CONF_IPT_DNAT_ACCESS,
 447             DEF_IPT_DNAT_ACCESS);
 448
 449     /* IPT snat access.
 450     */
 451     if(opts->config[CONF_IPT_SNAT_ACCESS] == NULL)
 452         set_config_entry(opts, CONF_IPT_SNAT_ACCESS,
 453             DEF_IPT_SNAT_ACCESS);
 454
 455     /* IPT masquerade access.
 456     */
 457     if(opts->config[CONF_IPT_MASQUERADE_ACCESS] == NULL)
 458         set_config_entry(opts, CONF_IPT_MASQUERADE_ACCESS,
 459             DEF_IPT_MASQUERADE_ACCESS);
 460
 461 #elif FIREWALL_IPFW
 462
 463     /* Flush ipfw rules at init.
 464     */
 465     if(opts->config[CONF_FLUSH_IPFW_AT_INIT] == NULL)
 466         set_config_entry(opts, CONF_FLUSH_IPFW_AT_INIT, DEF_FLUSH_IPFW_AT_INIT);
 467
 468     /* Flush ipfw rules at exit.
 469     */
 470     if(opts->config[CONF_FLUSH_IPFW_AT_EXIT] == NULL)
 471         set_config_entry(opts, CONF_FLUSH_IPFW_AT_EXIT, DEF_FLUSH_IPFW_AT_EXIT);
 472
 473     /* Set IPFW start rule number.
 474     */
 475     if(opts->config[CONF_IPFW_START_RULE_NUM] == NULL)
 476         set_config_entry(opts, CONF_IPFW_START_RULE_NUM,
 477             DEF_IPFW_START_RULE_NUM);
 478
 479     /* Set IPFW max rules.
 480     */
 481     if(opts->config[CONF_IPFW_MAX_RULES] == NULL)
 482         set_config_entry(opts, CONF_IPFW_MAX_RULES,
 483             DEF_IPFW_MAX_RULES);
 484
 485     /* Set IPFW active set number.
 486     */
 487     if(opts->config[CONF_IPFW_ACTIVE_SET_NUM] == NULL)
 488         set_config_entry(opts, CONF_IPFW_ACTIVE_SET_NUM,
 489             DEF_IPFW_ACTIVE_SET_NUM);
 490
 491     /* Set IPFW expire set number.
 492     */
 493     if(opts->config[CONF_IPFW_EXPIRE_SET_NUM] == NULL)
 494         set_config_entry(opts, CONF_IPFW_EXPIRE_SET_NUM,
 495             DEF_IPFW_EXPIRE_SET_NUM);
 496
 497     /* Set IPFW Dynamic rule expiry interval.
 498     */
 499     if(opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL] == NULL)
 500         set_config_entry(opts, CONF_IPFW_EXPIRE_PURGE_INTERVAL,
 501             DEF_IPFW_EXPIRE_PURGE_INTERVAL);
 502
 503     /* Set IPFW Dynamic rule expiry interval.
 504     */
 505     if(opts->config[CONF_IPFW_ADD_CHECK_STATE] == NULL)
 506         set_config_entry(opts, CONF_IPFW_ADD_CHECK_STATE,
 507             DEF_IPFW_ADD_CHECK_STATE);
 508
 509 #elif FIREWALL_PF
 510     /* Set PF anchor name
 511     */
 512     if(opts->config[CONF_PF_ANCHOR_NAME] == NULL)
 513         set_config_entry(opts, CONF_PF_ANCHOR_NAME,
 514             DEF_PF_ANCHOR_NAME);
 515
 516     /* Set PF rule expiry interval.
 517     */
 518     if(opts->config[CONF_PF_EXPIRE_INTERVAL] == NULL)
 519         set_config_entry(opts, CONF_PF_EXPIRE_INTERVAL,
 520             DEF_PF_EXPIRE_INTERVAL);
 521
 522 #elif FIREWALL_IPF
 523     /* --DSS Place-holder */
 524
 525 #endif /* FIREWALL type */
 526
 527     /* GPG Home dir.
 528     */
 529     if(opts->config[CONF_GPG_HOME_DIR] == NULL)
 530         set_config_entry(opts, CONF_GPG_HOME_DIR, DEF_GPG_HOME_DIR);
 531
 532     /* Enable SPA over HTTP.
 533     */
 534     if(opts->config[CONF_ENABLE_SPA_OVER_HTTP] == NULL)
 535         set_config_entry(opts, CONF_ENABLE_SPA_OVER_HTTP,
 536             DEF_ENABLE_SPA_OVER_HTTP);
 537
 538     /* Enable TCP server.
 539     */
 540     if(opts->config[CONF_ENABLE_TCP_SERVER] == NULL)
 541         set_config_entry(opts, CONF_ENABLE_TCP_SERVER, DEF_ENABLE_TCP_SERVER);
 542
 543     /* TCP Server port.
 544     */
 545     if(opts->config[CONF_TCPSERV_PORT] == NULL)
 546         set_config_entry(opts, CONF_TCPSERV_PORT, DEF_TCPSERV_PORT);
 547
 548     /* Syslog identity.
 549     */
 550     if(opts->config[CONF_SYSLOG_IDENTITY] == NULL)
 551         set_config_entry(opts, CONF_SYSLOG_IDENTITY, DEF_SYSLOG_IDENTITY);
 552
 553     /* Syslog facility.
 554     */
 555     if(opts->config[CONF_SYSLOG_FACILITY] == NULL)
 556         set_config_entry(opts, CONF_SYSLOG_FACILITY, DEF_SYSLOG_FACILITY);
 557
 558
 559     /* Validate integer variable ranges
 560     */
 561     validate_int_var_ranges(opts);
 562
 563     /* Some options just trigger some output of information, or trigger an
 564      * external function, but do not actually start fwknopd.  If any of those
 565      * are set, we can return here an skip the validation routines as all
 566      * other options will be ignored anyway.
 567      *
 568      * These are also mutually exclusive (for now).
 569     */
 570     if((opts->dump_config + opts->kill + opts->restart + opts->status) == 1)
 571         return;
 572
 573     if((opts->dump_config + opts->kill + opts->restart + opts->status) > 1)
 574     {
 575         fprintf(stderr,
 576             "The -D, -K, -R, and -S options are mutually exclusive.  Pick only one.\n"
 577         );
 578         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 579     }
 580
 581     if(opts->config[CONF_FIREWALL_EXE] == NULL)
 582     {
 583         fprintf(stderr,
 584             "No firewall command executable is set. Please check FIREWALL_EXE in fwknopd.conf.\n"
 585         );
 586         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 587     }
 588
 589     return;
 590 }
 591
 592 void
 593 set_preconfig_entries(fko_srv_options_t *opts)
 594 {
 595     /* First, set any default or otherwise static settings here.  Some may
 596      * end up being overwritten via config file or command-line.
 597     */
 598
 599     /* Setup the firewall executable based on build-time info.
 600      * --DSS Note: We will want to either force external script mode, or
 601      *             error out if we do not have a firewall executable defined.
 602     */
 603 #ifdef FIREWALL_EXE
 604     set_config_entry(opts, CONF_FIREWALL_EXE, FIREWALL_EXE);
 605 #endif
 606
 607 }
 608
 609 /* Initialize program configuration via config file and/or command-line
 610  * switches.
 611 */
 612 void
 613 config_init(fko_srv_options_t *opts, int argc, char **argv)
 614 {
 615     int             cmd_arg, index;
 616     unsigned char   got_conf_file = 0, got_override_config = 0;
 617
 618     char            override_file[MAX_LINE_LEN];
 619     char           *ndx, *cmrk;
 620
 621     /* Zero out options and opts_track.
 622     */
 623     memset(opts, 0x00, sizeof(fko_srv_options_t));
 624
 625     /* Set some preconfiguration options (i.e. build-time defaults)
 626     */
 627     set_preconfig_entries(opts);
 628
 629     /* In case this is a re-config.
 630     */
 631     optind = 0;
 632
 633     /* First, scan the command-line args for -h/--help or an alternate
 634      * configuration file. If we find an alternate config file, use it,
 635      * otherwise use the default.  We also grab any override config files
 636      * as well.
 637     */
 638     while ((cmd_arg = getopt_long(argc, argv,
 639             GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
 640
 641         /* If help is wanted, give it and exit.
 642         */
 643         switch(cmd_arg) {
 644             case 'h':
 645                 usage();
 646                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
 647                 break;
 648
 649         /* Look for configuration file arg.
 650         */
 651         case 'c':
 652             set_config_entry(opts, CONF_CONFIG_FILE, optarg);
 653             got_conf_file++;
 654
 655             /* If we already have the config_override option, we are done.
 656             */
 657             if(got_override_config > 0)
 658                 break;
 659
 660         /* Look for override configuration file arg.
 661         */
 662         case 'O':
 663             set_config_entry(opts, CONF_OVERRIDE_CONFIG, optarg);
 664             got_override_config++;
 665
 666             /* If we already have the conf_file option, we are done.
 667             */
 668             if(got_conf_file > 0)
 669                 break;
 670         }
 671     }
 672
 673     /* If no alternate configuration file was specified, we use the
 674      * default.
 675     */
 676     if(opts->config[CONF_CONFIG_FILE] == NULL)
 677         set_config_entry(opts, CONF_CONFIG_FILE, DEF_CONFIG_FILE);
 678
 679     /* Parse configuration file to populate any params not already specified
 680      * via command-line options.
 681     */
 682     parse_config_file(opts, opts->config[CONF_CONFIG_FILE]);
 683
 684     /* If there are override configuration entries, process them
 685      * here.
 686     */
 687     if(opts->config[CONF_OVERRIDE_CONFIG] != NULL)
 688     {
 689         /* Make a copy of the override_config string so we can munge it.
 690         */
 691         strlcpy(override_file, opts->config[CONF_OVERRIDE_CONFIG], MAX_LINE_LEN);
 692
 693         ndx  = override_file;
 694         cmrk = strchr(ndx, ',');
 695
 696         if(cmrk == NULL)
 697         {
 698             /* Only one to process...
 699             */
 700             parse_config_file(opts, ndx);
 701
 702         } else {
 703             /* Walk the string pulling the next config override
 704              * at the comma delimiters.
 705             */
 706             while(cmrk != NULL) {
 707                 *cmrk = '\0';
 708                 parse_config_file(opts, ndx);
 709                 ndx = cmrk + 1;
 710                 cmrk = strchr(ndx, ',');
 711             }
 712
 713             /* Process the last entry
 714             */
 715             parse_config_file(opts, ndx);
 716         }
 717     }
 718
 719     /* Reset the options index so we can run through them again.
 720     */
 721     optind = 0;
 722
 723     /* Last, but not least, we process command-line options (some of which
 724      * may override configuration file options.
 725     */
 726     while ((cmd_arg = getopt_long(argc, argv,
 727             GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
 728
 729         switch(cmd_arg) {
 730             case 'a':
 731                 set_config_entry(opts, CONF_ACCESS_FILE, optarg);
 732                 break;
 733             case 'c':
 734                 /* This was handled earlier */
 735                 break;
 736             case 'C':
 737                 opts->packet_ctr_limit = atoi(optarg);
 738                 break;
 739             case 'd':
 740 #if USE_FILE_CACHE
 741                 set_config_entry(opts, CONF_DIGEST_FILE, optarg);
 742 #else
 743                 set_config_entry(opts, CONF_DIGEST_DB_FILE, optarg);
 744 #endif
 745                 break;
 746             case 'D':
 747                 opts->dump_config = 1;
 748                 break;
 749             case 'f':
 750                 opts->foreground = 1;
 751                 break;
 752             case FW_LIST:
 753                 opts->fw_list = 1;
 754                 break;
 755             case FW_LIST_ALL:
 756                 opts->fw_list = 1;
 757                 opts->fw_list_all = 1;
 758                 break;
 759             case FW_FLUSH:
 760                 opts->fw_flush = 1;
 761                 break;
 762             case GPG_HOME_DIR:
 763                 if (is_valid_dir(optarg))
 764                 {
 765                     set_config_entry(opts, CONF_GPG_HOME_DIR, optarg);
 766                 }
 767                 else
 768                 {
 769                     fprintf(stderr,
 770                         "[*] Directory '%s' could not stat()/does not exist?\n",
 771                         optarg);
 772                     clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 773                 }
 774                 break;
 775             case 'i':
 776                 set_config_entry(opts, CONF_PCAP_INTF, optarg);
 777                 break;
 778             case 'K':
 779                 opts->kill = 1;
 780                 break;
 781             case 'l':
 782                 set_config_entry(opts, CONF_LOCALE, optarg);
 783                 break;
 784             case 'O':
 785                 /* This was handled earlier */
 786                 break;
 787             case 'p':
 788                 set_config_entry(opts, CONF_FWKNOP_PID_FILE, optarg);
 789                 break;
 790             case 'P':
 791                 set_config_entry(opts, CONF_PCAP_FILTER, optarg);
 792                 break;
 793             case ROTATE_DIGEST_CACHE:
 794                 opts->rotate_digest_cache = 1;
 795                 break;
 796             case 'R':
 797                 opts->restart = 1;
 798                 break;
 799             case 'S':
 800                 opts->status = 1;
 801                 break;
 802             case 'v':
 803                 opts->verbose++;
 804                 break;
 805             case 'V':
 806                 fprintf(stdout, "fwknopd server %s\n", MY_VERSION);
 807                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
 808                 break;
 809             default:
 810                 usage();
 811                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 812         }
 813     }
 814
 815     /* Now that we have all of our options set, and we are actually going to
 816      * start fwknopd, we can validate them.
 817     */
 818     validate_options(opts);
 819
 820     return;
 821 }
 822
 823 /* Dump the configuration
 824 */
 825 void
 826 dump_config(const fko_srv_options_t *opts)
 827 {
 828     int i;
 829
 830     fprintf(stdout, "Current fwknopd config settings:\n");
 831
 832     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
 833         fprintf(stdout, "%3i. %-28s =  '%s'\n",
 834             i,
 835             config_map[i],
 836             (opts->config[i] == NULL) ? "<not set>" : opts->config[i]
 837         );
 838
 839     fprintf(stdout, "\n");
 840     fflush(stdout);
 841 }
 842
 843 /* Print usage message...
 844 */
 845 void
 846 usage(void)
 847 {
 848     fprintf(stdout, "\n%s server version %s\n%s\n\n", MY_NAME, MY_VERSION, MY_DESC);
 849     fprintf(stdout,
 850       "Usage: fwknopd [options]\n\n"
 851       " -h, --help              - Print this usage message and exit.\n"
 852       " -a, --access-file       - Specify an alternate access.conf file.\n"
 853       " -c, --config-file       - Specify an alternate configuration file.\n"
 854       " -C, --packet-limit      - Limit the number of candidate SPA packets to\n"
 855       "                           process and exit when this limit is reached.\n"
 856       " -d, --digest-file       - Specify an alternate digest.cache file.\n"
 857       " -D, --dump-config       - Dump the current fwknop configuration values.\n"
 858       " -f, --foreground        - Run fwknopd in the foreground (do not become\n"
 859       "                           a background daemon).\n"
 860       " -i, --interface         - Specify interface to listen for incoming SPA\n"
 861       "                           packets.\n"
 862       " -K, --kill              - Kill the currently running fwknopd.\n"
 863       "     --gpg-home-dir      - Specify the GPG home directory.\n"
 864       " -l, --locale            - Provide a locale setting other than the system\n"
 865       "                           default.\n"
 866       " -O, --override-config   - Specify a file with configuration entries that will\n"
 867       "                           overide those in fwknopd.conf\n"
 868       " -p, --pid-file          - Specify an alternate fwknopd.pid file.\n"
 869       " -P, --pcap-filter       - Specify a Berkeley packet filter statement to\n"
 870       "                           override the PCAP_FILTER variable in fwknopd.conf.\n"
 871       " -R, --restart           - Force the currently running fwknopd to restart.\n"
 872       "     --rotate-digest-cache\n"
 873       "                         - Rotate the digest cache file by renaming it to\n"
 874       "                           '<name>-old', and starting a new one.\n"
 875       " -S, --status            - Display the status of any running fwknopd process.\n"
 876       " -v, --verbose           - Set verbose mode.\n"
 877       " -V, --version           - Print version number.\n"
 878       "     --fw-list           - List all firewall rules that fwknop has created\n"
 879       "                           and then exit.\n"
 880       "     --fw-list-all       - List all firewall rules in the complete policy,\n"
 881       "                           including those that have nothing to do with\n"
 882       "                           fwknop.\n"
 883       "     --fw-flush          - Flush all firewall rules created by fwknop.\n"
 884       "\n"
 885     );
 886
 887     return;
 888 }
 889
 890 /***EOF***/