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((atoi(opts->config[CONF_IPFW_ACTIVE_SET_NUM]) > 0
 157             && atoi(opts->config[CONF_IPFW_EXPIRE_SET_NUM]) > 0)
 158             && atoi(opts->config[CONF_IPFW_ACTIVE_SET_NUM])
 159                 == atoi(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     /* Check for the iptables 'comment' match at init time
 462     */
 463     if(opts->config[CONF_ENABLE_IPT_COMMENT_CHECK] == NULL)
 464         set_config_entry(opts, CONF_ENABLE_IPT_COMMENT_CHECK,
 465             DEF_ENABLE_IPT_COMMENT_CHECK);
 466
 467 #elif FIREWALL_IPFW
 468
 469     /* Flush ipfw rules at init.
 470     */
 471     if(opts->config[CONF_FLUSH_IPFW_AT_INIT] == NULL)
 472         set_config_entry(opts, CONF_FLUSH_IPFW_AT_INIT, DEF_FLUSH_IPFW_AT_INIT);
 473
 474     /* Flush ipfw rules at exit.
 475     */
 476     if(opts->config[CONF_FLUSH_IPFW_AT_EXIT] == NULL)
 477         set_config_entry(opts, CONF_FLUSH_IPFW_AT_EXIT, DEF_FLUSH_IPFW_AT_EXIT);
 478
 479     /* Set IPFW start rule number.
 480     */
 481     if(opts->config[CONF_IPFW_START_RULE_NUM] == NULL)
 482         set_config_entry(opts, CONF_IPFW_START_RULE_NUM,
 483             DEF_IPFW_START_RULE_NUM);
 484
 485     /* Set IPFW max rules.
 486     */
 487     if(opts->config[CONF_IPFW_MAX_RULES] == NULL)
 488         set_config_entry(opts, CONF_IPFW_MAX_RULES,
 489             DEF_IPFW_MAX_RULES);
 490
 491     /* Set IPFW active set number.
 492     */
 493     if(opts->config[CONF_IPFW_ACTIVE_SET_NUM] == NULL)
 494         set_config_entry(opts, CONF_IPFW_ACTIVE_SET_NUM,
 495             DEF_IPFW_ACTIVE_SET_NUM);
 496
 497     /* Set IPFW expire set number.
 498     */
 499     if(opts->config[CONF_IPFW_EXPIRE_SET_NUM] == NULL)
 500         set_config_entry(opts, CONF_IPFW_EXPIRE_SET_NUM,
 501             DEF_IPFW_EXPIRE_SET_NUM);
 502
 503     /* Set IPFW Dynamic rule expiry interval.
 504     */
 505     if(opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL] == NULL)
 506         set_config_entry(opts, CONF_IPFW_EXPIRE_PURGE_INTERVAL,
 507             DEF_IPFW_EXPIRE_PURGE_INTERVAL);
 508
 509     /* Set IPFW Dynamic rule expiry interval.
 510     */
 511     if(opts->config[CONF_IPFW_ADD_CHECK_STATE] == NULL)
 512         set_config_entry(opts, CONF_IPFW_ADD_CHECK_STATE,
 513             DEF_IPFW_ADD_CHECK_STATE);
 514
 515 #elif FIREWALL_PF
 516     /* Set PF anchor name
 517     */
 518     if(opts->config[CONF_PF_ANCHOR_NAME] == NULL)
 519         set_config_entry(opts, CONF_PF_ANCHOR_NAME,
 520             DEF_PF_ANCHOR_NAME);
 521
 522     /* Set PF rule expiry interval.
 523     */
 524     if(opts->config[CONF_PF_EXPIRE_INTERVAL] == NULL)
 525         set_config_entry(opts, CONF_PF_EXPIRE_INTERVAL,
 526             DEF_PF_EXPIRE_INTERVAL);
 527
 528 #elif FIREWALL_IPF
 529     /* --DSS Place-holder */
 530
 531 #endif /* FIREWALL type */
 532
 533     /* GPG Home dir.
 534     */
 535     if(opts->config[CONF_GPG_HOME_DIR] == NULL)
 536         set_config_entry(opts, CONF_GPG_HOME_DIR, DEF_GPG_HOME_DIR);
 537
 538     /* Enable SPA over HTTP.
 539     */
 540     if(opts->config[CONF_ENABLE_SPA_OVER_HTTP] == NULL)
 541         set_config_entry(opts, CONF_ENABLE_SPA_OVER_HTTP,
 542             DEF_ENABLE_SPA_OVER_HTTP);
 543
 544     /* Enable TCP server.
 545     */
 546     if(opts->config[CONF_ENABLE_TCP_SERVER] == NULL)
 547         set_config_entry(opts, CONF_ENABLE_TCP_SERVER, DEF_ENABLE_TCP_SERVER);
 548
 549     /* TCP Server port.
 550     */
 551     if(opts->config[CONF_TCPSERV_PORT] == NULL)
 552         set_config_entry(opts, CONF_TCPSERV_PORT, DEF_TCPSERV_PORT);
 553
 554     /* Syslog identity.
 555     */
 556     if(opts->config[CONF_SYSLOG_IDENTITY] == NULL)
 557         set_config_entry(opts, CONF_SYSLOG_IDENTITY, DEF_SYSLOG_IDENTITY);
 558
 559     /* Syslog facility.
 560     */
 561     if(opts->config[CONF_SYSLOG_FACILITY] == NULL)
 562         set_config_entry(opts, CONF_SYSLOG_FACILITY, DEF_SYSLOG_FACILITY);
 563
 564
 565     /* Validate integer variable ranges
 566     */
 567     validate_int_var_ranges(opts);
 568
 569     /* Some options just trigger some output of information, or trigger an
 570      * external function, but do not actually start fwknopd.  If any of those
 571      * are set, we can return here an skip the validation routines as all
 572      * other options will be ignored anyway.
 573      *
 574      * These are also mutually exclusive (for now).
 575     */
 576     if((opts->dump_config + opts->kill + opts->restart + opts->status) == 1)
 577         return;
 578
 579     if((opts->dump_config + opts->kill + opts->restart + opts->status) > 1)
 580     {
 581         fprintf(stderr,
 582             "The -D, -K, -R, and -S options are mutually exclusive.  Pick only one.\n"
 583         );
 584         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 585     }
 586
 587     if(opts->config[CONF_FIREWALL_EXE] == NULL)
 588     {
 589         fprintf(stderr,
 590             "No firewall command executable is set. Please check FIREWALL_EXE in fwknopd.conf.\n"
 591         );
 592         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 593     }
 594
 595     return;
 596 }
 597
 598 void
 599 set_preconfig_entries(fko_srv_options_t *opts)
 600 {
 601     /* First, set any default or otherwise static settings here.  Some may
 602      * end up being overwritten via config file or command-line.
 603     */
 604
 605     /* Setup the firewall executable based on build-time info.
 606      * --DSS Note: We will want to either force external script mode, or
 607      *             error out if we do not have a firewall executable defined.
 608     */
 609 #ifdef FIREWALL_EXE
 610     set_config_entry(opts, CONF_FIREWALL_EXE, FIREWALL_EXE);
 611 #endif
 612
 613 }
 614
 615 /* Initialize program configuration via config file and/or command-line
 616  * switches.
 617 */
 618 void
 619 config_init(fko_srv_options_t *opts, int argc, char **argv)
 620 {
 621     int             cmd_arg, index;
 622     unsigned char   got_conf_file = 0, got_override_config = 0;
 623
 624     char            override_file[MAX_LINE_LEN];
 625     char           *ndx, *cmrk;
 626
 627     /* Zero out options and opts_track.
 628     */
 629     memset(opts, 0x00, sizeof(fko_srv_options_t));
 630
 631     /* Set some preconfiguration options (i.e. build-time defaults)
 632     */
 633     set_preconfig_entries(opts);
 634
 635     /* In case this is a re-config.
 636     */
 637     optind = 0;
 638
 639     /* First, scan the command-line args for -h/--help or an alternate
 640      * configuration file. If we find an alternate config file, use it,
 641      * otherwise use the default.  We also grab any override config files
 642      * as well.
 643     */
 644     while ((cmd_arg = getopt_long(argc, argv,
 645             GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
 646
 647         /* If help is wanted, give it and exit.
 648         */
 649         switch(cmd_arg) {
 650             case 'h':
 651                 usage();
 652                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
 653                 break;
 654
 655         /* Look for configuration file arg.
 656         */
 657         case 'c':
 658             set_config_entry(opts, CONF_CONFIG_FILE, optarg);
 659             got_conf_file++;
 660
 661             /* If we already have the config_override option, we are done.
 662             */
 663             if(got_override_config > 0)
 664                 break;
 665
 666         /* Look for override configuration file arg.
 667         */
 668         case 'O':
 669             set_config_entry(opts, CONF_OVERRIDE_CONFIG, optarg);
 670             got_override_config++;
 671
 672             /* If we already have the conf_file option, we are done.
 673             */
 674             if(got_conf_file > 0)
 675                 break;
 676         }
 677     }
 678
 679     /* If no alternate configuration file was specified, we use the
 680      * default.
 681     */
 682     if(opts->config[CONF_CONFIG_FILE] == NULL)
 683         set_config_entry(opts, CONF_CONFIG_FILE, DEF_CONFIG_FILE);
 684
 685     /* Parse configuration file to populate any params not already specified
 686      * via command-line options.
 687     */
 688     parse_config_file(opts, opts->config[CONF_CONFIG_FILE]);
 689
 690     /* If there are override configuration entries, process them
 691      * here.
 692     */
 693     if(opts->config[CONF_OVERRIDE_CONFIG] != NULL)
 694     {
 695         /* Make a copy of the override_config string so we can munge it.
 696         */
 697         strlcpy(override_file, opts->config[CONF_OVERRIDE_CONFIG], MAX_LINE_LEN);
 698
 699         ndx  = override_file;
 700         cmrk = strchr(ndx, ',');
 701
 702         if(cmrk == NULL)
 703         {
 704             /* Only one to process...
 705             */
 706             parse_config_file(opts, ndx);
 707
 708         } else {
 709             /* Walk the string pulling the next config override
 710              * at the comma delimiters.
 711             */
 712             while(cmrk != NULL) {
 713                 *cmrk = '\0';
 714                 parse_config_file(opts, ndx);
 715                 ndx = cmrk + 1;
 716                 cmrk = strchr(ndx, ',');
 717             }
 718
 719             /* Process the last entry
 720             */
 721             parse_config_file(opts, ndx);
 722         }
 723     }
 724
 725     /* Reset the options index so we can run through them again.
 726     */
 727     optind = 0;
 728
 729     /* Last, but not least, we process command-line options (some of which
 730      * may override configuration file options.
 731     */
 732     while ((cmd_arg = getopt_long(argc, argv,
 733             GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
 734
 735         switch(cmd_arg) {
 736             case 'a':
 737                 set_config_entry(opts, CONF_ACCESS_FILE, optarg);
 738                 break;
 739             case 'c':
 740                 /* This was handled earlier */
 741                 break;
 742             case 'C':
 743                 opts->packet_ctr_limit = atoi(optarg);
 744                 break;
 745             case 'd':
 746 #if USE_FILE_CACHE
 747                 set_config_entry(opts, CONF_DIGEST_FILE, optarg);
 748 #else
 749                 set_config_entry(opts, CONF_DIGEST_DB_FILE, optarg);
 750 #endif
 751                 break;
 752             case 'D':
 753                 opts->dump_config = 1;
 754                 break;
 755             case 'f':
 756                 opts->foreground = 1;
 757                 break;
 758             case FW_LIST:
 759                 opts->fw_list = 1;
 760                 break;
 761             case FW_LIST_ALL:
 762                 opts->fw_list = 1;
 763                 opts->fw_list_all = 1;
 764                 break;
 765             case FW_FLUSH:
 766                 opts->fw_flush = 1;
 767                 break;
 768             case GPG_HOME_DIR:
 769                 if (is_valid_dir(optarg))
 770                 {
 771                     set_config_entry(opts, CONF_GPG_HOME_DIR, optarg);
 772                 }
 773                 else
 774                 {
 775                     fprintf(stderr,
 776                         "[*] Directory '%s' could not stat()/does not exist?\n",
 777                         optarg);
 778                     clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 779                 }
 780                 break;
 781             case 'i':
 782                 set_config_entry(opts, CONF_PCAP_INTF, optarg);
 783                 break;
 784             case 'K':
 785                 opts->kill = 1;
 786                 break;
 787             case 'l':
 788                 set_config_entry(opts, CONF_LOCALE, optarg);
 789                 break;
 790             case 'O':
 791                 /* This was handled earlier */
 792                 break;
 793             case 'p':
 794                 set_config_entry(opts, CONF_FWKNOP_PID_FILE, optarg);
 795                 break;
 796             case 'P':
 797                 set_config_entry(opts, CONF_PCAP_FILTER, optarg);
 798                 break;
 799             case ROTATE_DIGEST_CACHE:
 800                 opts->rotate_digest_cache = 1;
 801                 break;
 802             case 'R':
 803                 opts->restart = 1;
 804                 break;
 805             case 'S':
 806                 opts->status = 1;
 807                 break;
 808             case 'v':
 809                 opts->verbose++;
 810                 break;
 811             case 'V':
 812                 fprintf(stdout, "fwknopd server %s\n", MY_VERSION);
 813                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
 814                 break;
 815             default:
 816                 usage();
 817                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 818         }
 819     }
 820
 821     /* Now that we have all of our options set, and we are actually going to
 822      * start fwknopd, we can validate them.
 823     */
 824     validate_options(opts);
 825
 826     return;
 827 }
 828
 829 /* Dump the configuration
 830 */
 831 void
 832 dump_config(const fko_srv_options_t *opts)
 833 {
 834     int i;
 835
 836     fprintf(stdout, "Current fwknopd config settings:\n");
 837
 838     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
 839         fprintf(stdout, "%3i. %-28s =  '%s'\n",
 840             i,
 841             config_map[i],
 842             (opts->config[i] == NULL) ? "<not set>" : opts->config[i]
 843         );
 844
 845     fprintf(stdout, "\n");
 846     fflush(stdout);
 847 }
 848
 849 /* Print usage message...
 850 */
 851 void
 852 usage(void)
 853 {
 854     fprintf(stdout, "\n%s server version %s\n%s\n\n", MY_NAME, MY_VERSION, MY_DESC);
 855     fprintf(stdout,
 856       "Usage: fwknopd [options]\n\n"
 857       " -h, --help              - Print this usage message and exit.\n"
 858       " -a, --access-file       - Specify an alternate access.conf file.\n"
 859       " -c, --config-file       - Specify an alternate configuration file.\n"
 860       " -C, --packet-limit      - Limit the number of candidate SPA packets to\n"
 861       "                           process and exit when this limit is reached.\n"
 862       " -d, --digest-file       - Specify an alternate digest.cache file.\n"
 863       " -D, --dump-config       - Dump the current fwknop configuration values.\n"
 864       " -f, --foreground        - Run fwknopd in the foreground (do not become\n"
 865       "                           a background daemon).\n"
 866       " -i, --interface         - Specify interface to listen for incoming SPA\n"
 867       "                           packets.\n"
 868       " -K, --kill              - Kill the currently running fwknopd.\n"
 869       "     --gpg-home-dir      - Specify the GPG home directory.\n"
 870       " -l, --locale            - Provide a locale setting other than the system\n"
 871       "                           default.\n"
 872       " -O, --override-config   - Specify a file with configuration entries that will\n"
 873       "                           overide those in fwknopd.conf\n"
 874       " -p, --pid-file          - Specify an alternate fwknopd.pid file.\n"
 875       " -P, --pcap-filter       - Specify a Berkeley packet filter statement to\n"
 876       "                           override the PCAP_FILTER variable in fwknopd.conf.\n"
 877       " -R, --restart           - Force the currently running fwknopd to restart.\n"
 878       "     --rotate-digest-cache\n"
 879       "                         - Rotate the digest cache file by renaming it to\n"
 880       "                           '<name>-old', and starting a new one.\n"
 881       " -S, --status            - Display the status of any running fwknopd process.\n"
 882       " -v, --verbose           - Set verbose mode.\n"
 883       " -V, --version           - Print version number.\n"
 884       "     --fw-list           - List all firewall rules that fwknop has created\n"
 885       "                           and then exit.\n"
 886       "     --fw-list-all       - List all firewall rules in the complete policy,\n"
 887       "                           including those that have nothing to do with\n"
 888       "                           fwknop.\n"
 889       "     --fw-flush          - Flush all firewall rules created by fwknop.\n"
 890       "\n"
 891     );
 892
 893     return;
 894 }
 895
 896 /***EOF***/