LCOV - code coverage report
Current view: top level - server - config_init.c (source / functions) Hit Total Coverage
Test: id:002084,src:002034,op:havoc,rep:2.lcov_info_final Lines: 227 331 68.6 %
Date: 2015-05-30 Functions: 10 11 90.9 %
Branches: 147 224 65.6 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  ******************************************************************************
       3                 :            :  *
       4                 :            :  * File:    config_init.c
       5                 :            :  *
       6                 :            :  * Purpose: Command-line and config file processing for fwknop server.
       7                 :            :  *
       8                 :            :  *  Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
       9                 :            :  *  Copyright (C) 2009-2014 fwknop developers and contributors. For a full
      10                 :            :  *  list of contributors, see the file 'CREDITS'.
      11                 :            :  *
      12                 :            :  *  License (GNU General 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 "fwknopd_errors.h"
      33                 :            : #include "config_init.h"
      34                 :            : #include "access.h"
      35                 :            : #include "cmd_opts.h"
      36                 :            : #include "utils.h"
      37                 :            : #include "log_msg.h"
      38                 :            : 
      39                 :            : #if FIREWALL_FIREWALLD
      40                 :            :   #include "fw_util_firewalld.h"
      41                 :            : #elif FIREWALL_IPTABLES
      42                 :            :   #include "fw_util_iptables.h"
      43                 :            : #endif
      44                 :            : 
      45                 :            : /* Check to see if an integer variable has a value that is within a
      46                 :            :  * specific range
      47                 :            : */
      48                 :            : static void
      49                 :      10415 : range_check(fko_srv_options_t *opts, char *var, char *val, int low, int high)
      50                 :            : {
      51                 :            :     int     is_err;
      52                 :            : 
      53                 :      10415 :     strtol_wrapper(val, low, high, NO_EXIT_UPON_ERR, &is_err);
      54         [ +  + ]:      10415 :     if(is_err != FKO_SUCCESS)
      55                 :            :     {
      56                 :        119 :         log_msg(LOG_ERR, "[*] var %s value '%s' not in the range %d-%d",
      57                 :            :             var, val, low, high);
      58                 :        119 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
      59                 :            :     }
      60                 :            : 
      61                 :      10296 :     return;
      62                 :            : }
      63                 :            : 
      64                 :            : /* Take an index and a string value. malloc the space for the value
      65                 :            :  * and assign it to the array at the specified index.
      66                 :            : */
      67                 :            : static void
      68                 :     102288 : set_config_entry(fko_srv_options_t *opts, const int var_ndx, const char *value)
      69                 :            : {
      70                 :            :     int space_needed;
      71                 :            : 
      72                 :            :     /* Sanity check the index value.
      73                 :            :     */
      74         [ -  + ]:     102288 :     if(var_ndx < 0 || var_ndx >= NUMBER_OF_CONFIG_ENTRIES)
      75                 :            :     {
      76                 :          0 :         log_msg(LOG_ERR, "[*] Index value of %i is not valid", var_ndx);
      77                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
      78                 :            :     }
      79                 :            : 
      80                 :            :     /* If this particular entry was already set (i.e. not NULL), then
      81                 :            :      * assume it needs to be freed first.
      82                 :            :     */
      83         [ +  + ]:     102288 :     if(opts->config[var_ndx] != NULL)
      84                 :      25843 :         free(opts->config[var_ndx]);
      85                 :            : 
      86                 :            :     /* If we are setting it to NULL, do it and be done.
      87                 :            :     */
      88         [ -  + ]:     102288 :     if(value == NULL)
      89                 :            :     {
      90                 :          0 :         opts->config[var_ndx] = NULL;
      91                 :          0 :         return;
      92                 :            :     }
      93                 :            : 
      94                 :            :     /* Otherwise, make the space we need and set it.
      95                 :            :     */
      96                 :     102288 :     space_needed = strlen(value) + 1;
      97                 :            : 
      98                 :     102288 :     opts->config[var_ndx] = calloc(1, space_needed);
      99                 :            : 
     100         [ -  + ]:     102288 :     if(opts->config[var_ndx] == NULL)
     101                 :            :     {
     102                 :          0 :         log_msg(LOG_ERR, "[*] Fatal memory allocation error!");
     103                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     104                 :            :     }
     105                 :            : 
     106                 :     102288 :     strlcpy(opts->config[var_ndx], value, space_needed);
     107                 :            : 
     108                 :     102288 :     return;
     109                 :            : }
     110                 :            : 
     111                 :            : /* Given a config parameter name, return its index or -1 if not found.
     112                 :            : */
     113                 :            : static int
     114                 :      10361 : config_entry_index(const fko_srv_options_t *opts, const char *var)
     115                 :            : {
     116                 :            :     int i;
     117                 :            : 
     118         [ +  + ]:     347555 :     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
     119 [ +  + ][ +  + ]:     345816 :         if(opts->config[i] != NULL && CONF_VAR_IS(var, config_map[i]))
     120                 :       8622 :             return(i);
     121                 :            : 
     122                 :            :     return(-1);
     123                 :            : }
     124                 :            : 
     125                 :            : /* Free the config memory
     126                 :            : */
     127                 :            : void
     128                 :       1814 : free_configs(fko_srv_options_t *opts)
     129                 :            : {
     130                 :            :     int i;
     131                 :            : 
     132                 :       1814 :     free_acc_stanzas(opts);
     133                 :            : 
     134         [ +  + ]:      90700 :     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
     135         [ +  + ]:      88886 :         if(opts->config[i] != NULL)
     136                 :      76445 :             free(opts->config[i]);
     137                 :       1814 : }
     138                 :            : 
     139                 :            : static void
     140                 :       1797 : validate_int_var_ranges(fko_srv_options_t *opts)
     141                 :            : {
     142                 :            : #if FIREWALL_IPFW
     143                 :            :     int     is_err = FKO_SUCCESS;
     144                 :            : #endif
     145                 :            : 
     146                 :       1797 :     range_check(opts, "PCAP_LOOP_SLEEP", opts->config[CONF_PCAP_LOOP_SLEEP],
     147                 :            :         1, RCHK_MAX_PCAP_LOOP_SLEEP);
     148                 :       1764 :     range_check(opts, "MAX_SPA_PACKET_AGE", opts->config[CONF_MAX_SPA_PACKET_AGE],
     149                 :            :         1, RCHK_MAX_SPA_PACKET_AGE);
     150                 :       1750 :     range_check(opts, "MAX_SNIFF_BYTES", opts->config[CONF_MAX_SNIFF_BYTES],
     151                 :            :         1, RCHK_MAX_SNIFF_BYTES);
     152                 :       1712 :     range_check(opts, "TCPSERV_PORT", opts->config[CONF_TCPSERV_PORT],
     153                 :            :         1, RCHK_MAX_TCPSERV_PORT);
     154                 :       1703 :     range_check(opts, "UDPSERV_PORT", opts->config[CONF_UDPSERV_PORT],
     155                 :            :         1, RCHK_MAX_UDPSERV_PORT);
     156                 :       1689 :     range_check(opts, "UDPSERV_PORT", opts->config[CONF_UDPSERV_SELECT_TIMEOUT],
     157                 :            :         1, RCHK_MAX_UDPSERV_SELECT_TIMEOUT);
     158                 :            : 
     159                 :            : #if FIREWALL_IPFW
     160                 :            :     range_check(opts, "IPFW_START_RULE_NUM", opts->config[CONF_IPFW_START_RULE_NUM],
     161                 :            :         0, RCHK_MAX_IPFW_START_RULE_NUM);
     162                 :            :     range_check(opts, "IPFW_MAX_RULES", opts->config[CONF_IPFW_MAX_RULES],
     163                 :            :         1, RCHK_MAX_IPFW_MAX_RULES);
     164                 :            :     range_check(opts, "IPFW_ACTIVE_SET_NUM", opts->config[CONF_IPFW_ACTIVE_SET_NUM],
     165                 :            :         0, RCHK_MAX_IPFW_SET_NUM);
     166                 :            :     range_check(opts, "IPFW_EXPIRE_SET_NUM", opts->config[CONF_IPFW_EXPIRE_SET_NUM],
     167                 :            :         0, RCHK_MAX_IPFW_SET_NUM);
     168                 :            :     range_check(opts, "IPFW_EXPIRE_PURGE_INTERVAL",
     169                 :            :         opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL],
     170                 :            :         1, RCHK_MAX_IPFW_PURGE_INTERVAL);
     171                 :            : 
     172                 :            :     /* Make sure the active and expire sets are not identical whenever
     173                 :            :      * they are non-zero
     174                 :            :     */
     175                 :            :     if((strtol_wrapper(opts->config[CONF_IPFW_ACTIVE_SET_NUM],
     176                 :            :                     0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err) > 0
     177                 :            :             && strtol_wrapper(opts->config[CONF_IPFW_EXPIRE_SET_NUM],
     178                 :            :                 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err) > 0)
     179                 :            :             && strtol_wrapper(opts->config[CONF_IPFW_ACTIVE_SET_NUM],
     180                 :            :                 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err)
     181                 :            :                 == strtol_wrapper(opts->config[CONF_IPFW_EXPIRE_SET_NUM],
     182                 :            :                     0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err))
     183                 :            :     {
     184                 :            :         log_msg(LOG_ERR,
     185                 :            :                 "[*] Cannot set identical ipfw active and expire sets.");
     186                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     187                 :            :     }
     188                 :            : 
     189                 :            :     if(is_err != FKO_SUCCESS)
     190                 :            :     {
     191                 :            :         log_msg(LOG_ERR, "[*] invalid integer conversion error.\n");
     192                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     193                 :            :     }
     194                 :            : 
     195                 :            : #elif FIREWALL_PF
     196                 :            :     range_check(opts, "PF_EXPIRE_INTERVAL", opts->config[CONF_PF_EXPIRE_INTERVAL],
     197                 :            :         1, RCHK_MAX_PF_EXPIRE_INTERVAL);
     198                 :            : 
     199                 :            : #endif /* FIREWALL type */
     200                 :            : 
     201                 :       1678 :     return;
     202                 :            : }
     203                 :            : 
     204                 :            : /* Parse the config file...
     205                 :            : */
     206                 :            : static void
     207                 :       3628 : parse_config_file(fko_srv_options_t *opts, const char *config_file)
     208                 :            : {
     209                 :            :     FILE           *cfile_ptr;
     210                 :       3628 :     unsigned int    numLines = 0;
     211                 :            :     unsigned int    i, good_ent;
     212                 :            :     int             cndx;
     213                 :            : 
     214                 :       3628 :     char            conf_line_buf[MAX_LINE_LEN] = {0};
     215                 :       3628 :     char            var[MAX_LINE_LEN]  = {0};
     216                 :       3628 :     char            val[MAX_LINE_LEN]  = {0};
     217                 :       3628 :     char            tmp1[MAX_LINE_LEN] = {0};
     218                 :       3628 :     char            tmp2[MAX_LINE_LEN] = {0};
     219                 :            : 
     220                 :            :     struct stat     st;
     221                 :            : 
     222                 :            :     /* Make sure the config file exists.
     223                 :            :     */
     224         [ -  + ]:       3628 :     if(stat(config_file, &st) != 0)
     225                 :            :     {
     226                 :          0 :         log_msg(LOG_ERR, "[*] Config file: '%s' was not found.",
     227                 :            :             config_file);
     228                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     229                 :            :     }
     230                 :            : 
     231         [ -  + ]:       3628 :     if(verify_file_perms_ownership(config_file) != 1)
     232                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     233                 :            : 
     234                 :            :     /* See the comment in the parse_access_file() function regarding security
     235                 :            :      * here relative to a TOCTOU bug flagged by Coverity.
     236                 :            :     */
     237         [ -  + ]:       3628 :     if ((cfile_ptr = fopen(config_file, "r")) == NULL)
     238                 :            :     {
     239                 :          0 :         log_msg(LOG_ERR, "[*] Could not open config file: %s",
     240                 :            :             config_file);
     241                 :          0 :         perror(NULL);
     242                 :            : 
     243                 :       3628 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     244                 :            :     }
     245                 :            : 
     246         [ +  + ]:     111880 :     while ((fgets(conf_line_buf, MAX_LINE_LEN, cfile_ptr)) != NULL)
     247                 :            :     {
     248                 :     108252 :         numLines++;
     249                 :     108252 :         conf_line_buf[MAX_LINE_LEN-1] = '\0';
     250                 :            : 
     251                 :            :         /* Get past comments and empty lines (note: we only look at the
     252                 :            :          * first character.
     253                 :            :         */
     254 [ +  + ][ +  - ]:     108252 :         if(IS_EMPTY_LINE(conf_line_buf[0]))
         [ +  + ][ +  + ]
     255                 :       8873 :             continue;
     256                 :            : 
     257         [ +  + ]:      99379 :         if(sscanf(conf_line_buf, "%s %[^;\n\r]", var, val) != 2)
     258                 :            :         {
     259                 :      12787 :             log_msg(LOG_ERR,
     260                 :            :                 "*Invalid config file entry in %s at line %i.\n - '%s'",
     261                 :            :                 config_file, numLines, conf_line_buf
     262                 :            :             );
     263                 :      12787 :             continue;
     264                 :            :         }
     265                 :            : 
     266                 :            :         good_ent = 0;
     267         [ +  + ]:    3397956 :         for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
     268                 :            :         {
     269         [ +  + ]:    3347537 :             if(CONF_VAR_IS(config_map[i], var))
     270                 :            :             {
     271                 :            :                 /* First check to see if we need to do a varable expansion
     272                 :            :                  * on this value.  Note: this only supports one expansion and
     273                 :            :                  * only if the value starts with the variable.
     274                 :            :                 */
     275         [ +  + ]:      36173 :                 if(*val == '$')
     276                 :            :                 {
     277         [ +  + ]:      10745 :                     if(sscanf((val+1), "%[A-Z_]%s", tmp1, tmp2))
     278                 :            :                     {
     279         [ +  + ]:      10361 :                         if((cndx = config_entry_index(opts, tmp1)) >= 0)
     280                 :            :                         {
     281                 :       8622 :                             strlcpy(val, opts->config[cndx], sizeof(val));
     282                 :       8622 :                             strlcat(val, tmp2, sizeof(val));
     283                 :            :                         }
     284                 :            :                         else
     285                 :            :                         {
     286                 :            :                             /* We didn't map the embedded variable to a valid
     287                 :            :                              * config parameter
     288                 :            :                             */
     289                 :       1739 :                             log_msg(LOG_ERR,
     290                 :            :                                 "[*] Invalid embedded variable in: '%s'", val);
     291                 :       1739 :                             break;
     292                 :            :                         }
     293                 :            :                     }
     294                 :            :                 }
     295                 :            : 
     296                 :      34434 :                 set_config_entry(opts, i, val);
     297                 :      34434 :                 good_ent++;
     298                 :      34434 :                 break;
     299                 :            :             }
     300                 :            :         }
     301                 :            : 
     302         [ +  + ]:      86592 :         if(good_ent == 0)
     303                 :     108252 :             log_msg(LOG_ERR,
     304                 :            :                 "[*] Ignoring unknown configuration parameter: '%s' in %s",
     305                 :            :                 var, config_file
     306                 :            :             );
     307                 :            :     }
     308                 :            : 
     309                 :       3628 :     fclose(cfile_ptr);
     310                 :            : 
     311                 :       3628 :     return;
     312                 :            : }
     313                 :            : 
     314                 :            : /* Set defaults, and do sanity and bounds checks for the various options.
     315                 :            : */
     316                 :            : static void
     317                 :       1797 : validate_options(fko_srv_options_t *opts)
     318                 :            : {
     319                 :       1797 :     char tmp_path[MAX_PATH_LEN] = {0};
     320                 :            : 
     321                 :            :     /* If no conf dir is set in the config file, use the default.
     322                 :            :     */
     323         [ +  + ]:       1797 :     if(opts->config[CONF_FWKNOP_CONF_DIR] == NULL)
     324                 :       1562 :         set_config_entry(opts, CONF_FWKNOP_CONF_DIR, DEF_CONF_DIR);
     325                 :            : 
     326                 :            :     /* If no access.conf path was specified on the command line or set in
     327                 :            :      * the config file, use the default.
     328                 :            :     */
     329         [ -  + ]:       1797 :     if(opts->config[CONF_ACCESS_FILE] == NULL)
     330                 :          0 :         set_config_entry(opts, CONF_ACCESS_FILE, DEF_ACCESS_FILE);
     331                 :            : 
     332                 :            :     /* If the pid and digest cache files where not set in the config file or
     333                 :            :      * via command-line, then grab the defaults. Start with RUN_DIR as the
     334                 :            :      * files may depend on that.
     335                 :            :     */
     336         [ +  + ]:       1797 :     if(opts->config[CONF_FWKNOP_RUN_DIR] == NULL)
     337                 :        448 :         set_config_entry(opts, CONF_FWKNOP_RUN_DIR, DEF_RUN_DIR);
     338                 :            : 
     339         [ +  + ]:       1797 :     if(opts->config[CONF_FWKNOP_PID_FILE] == NULL)
     340                 :            :     {
     341                 :       1536 :         strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], sizeof(tmp_path));
     342                 :            : 
     343         [ +  - ]:       1536 :         if(tmp_path[strlen(tmp_path)-1] != '/')
     344                 :       1536 :             strlcat(tmp_path, "/", sizeof(tmp_path));
     345                 :            : 
     346                 :       1536 :         strlcat(tmp_path, DEF_PID_FILENAME, sizeof(tmp_path));
     347                 :            : 
     348                 :       1536 :         set_config_entry(opts, CONF_FWKNOP_PID_FILE, tmp_path);
     349                 :            :     }
     350                 :            : 
     351                 :            : #if USE_FILE_CACHE
     352         [ +  + ]:       1797 :     if(opts->config[CONF_DIGEST_FILE] == NULL)
     353                 :            : #else
     354                 :            :     if(opts->config[CONF_DIGEST_DB_FILE] == NULL)
     355                 :            : #endif
     356                 :            :     {
     357                 :       1459 :         strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], sizeof(tmp_path));
     358                 :            : 
     359         [ +  - ]:       1459 :         if(tmp_path[strlen(tmp_path)-1] != '/')
     360                 :       1459 :             strlcat(tmp_path, "/", sizeof(tmp_path));
     361                 :            : 
     362                 :            : #if USE_FILE_CACHE
     363                 :       1459 :         strlcat(tmp_path, DEF_DIGEST_CACHE_FILENAME, sizeof(tmp_path));
     364                 :       1459 :         set_config_entry(opts, CONF_DIGEST_FILE, tmp_path);
     365                 :            : #else
     366                 :            :         strlcat(tmp_path, DEF_DIGEST_CACHE_DB_FILENAME, sizeof(tmp_path));
     367                 :            :         set_config_entry(opts, CONF_DIGEST_DB_FILE, tmp_path);
     368                 :            : #endif
     369                 :            :     }
     370                 :            : 
     371                 :            :     /* Set remaining require CONF_ vars if they are not already set.  */
     372                 :            : 
     373                 :            :     /* PCAP capture interface - note that if '-r <pcap file>' is specified
     374                 :            :      * on the command line, then this will override the pcap interface setting.
     375                 :            :     */
     376         [ +  + ]:       1797 :     if(opts->config[CONF_PCAP_INTF] == NULL)
     377                 :       1475 :         set_config_entry(opts, CONF_PCAP_INTF, DEF_INTERFACE);
     378                 :            : 
     379                 :            :     /* PCAP Promiscuous mode.
     380                 :            :     */
     381         [ +  + ]:       1797 :     if(opts->config[CONF_ENABLE_PCAP_PROMISC] == NULL)
     382                 :       1483 :         set_config_entry(opts, CONF_ENABLE_PCAP_PROMISC,
     383                 :            :             DEF_ENABLE_PCAP_PROMISC);
     384                 :            : 
     385                 :            :     /* The packet count argument to pcap_dispatch()
     386                 :            :     */
     387         [ +  + ]:       1797 :     if(opts->config[CONF_PCAP_DISPATCH_COUNT] == NULL)
     388                 :       1565 :         set_config_entry(opts, CONF_PCAP_DISPATCH_COUNT,
     389                 :            :             DEF_PCAP_DISPATCH_COUNT);
     390                 :            : 
     391                 :            :     /* Microseconds to sleep between pcap loop iterations
     392                 :            :     */
     393         [ +  + ]:       1797 :     if(opts->config[CONF_PCAP_LOOP_SLEEP] == NULL)
     394                 :       1539 :         set_config_entry(opts, CONF_PCAP_LOOP_SLEEP,
     395                 :            :             DEF_PCAP_LOOP_SLEEP);
     396                 :            : 
     397                 :            :     /* PCAP Filter.
     398                 :            :     */
     399         [ +  + ]:       1797 :     if(opts->config[CONF_PCAP_FILTER] == NULL)
     400                 :       1435 :         set_config_entry(opts, CONF_PCAP_FILTER, DEF_PCAP_FILTER);
     401                 :            : 
     402                 :            :     /* Enable SPA packet aging unless we're getting packet data
     403                 :            :      * directly from a pcap file
     404                 :            :     */
     405         [ +  + ]:       1797 :     if(opts->config[CONF_ENABLE_SPA_PACKET_AGING] == NULL)
     406                 :            :     {
     407         [ +  + ]:       1541 :         if(opts->config[CONF_PCAP_FILE] == NULL)
     408                 :            :         {
     409                 :       1532 :             set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING,
     410                 :            :                 DEF_ENABLE_SPA_PACKET_AGING);
     411                 :            :         }
     412                 :            :         else
     413                 :            :         {
     414                 :          9 :             set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING, "N");
     415                 :            :         }
     416                 :            :     }
     417                 :            : 
     418                 :            :     /* SPA packet age.
     419                 :            :     */
     420         [ +  + ]:       1797 :     if(opts->config[CONF_MAX_SPA_PACKET_AGE] == NULL)
     421                 :       1579 :         set_config_entry(opts, CONF_MAX_SPA_PACKET_AGE,
     422                 :            :             DEF_MAX_SPA_PACKET_AGE);
     423                 :            : 
     424                 :            : 
     425                 :            :     /* Enable digest persistence.
     426                 :            :     */
     427         [ +  + ]:       1797 :     if(opts->config[CONF_ENABLE_DIGEST_PERSISTENCE] == NULL)
     428                 :        519 :         set_config_entry(opts, CONF_ENABLE_DIGEST_PERSISTENCE,
     429                 :            :             DEF_ENABLE_DIGEST_PERSISTENCE);
     430                 :            :             
     431                 :            :     /* Enable destination rule.
     432                 :            :     */
     433         [ +  - ]:       1797 :     if(opts->config[CONF_ENABLE_DESTINATION_RULE] == NULL)
     434                 :       1797 :         set_config_entry(opts, CONF_ENABLE_DESTINATION_RULE,
     435                 :            :             DEF_ENABLE_DESTINATION_RULE);
     436                 :            : 
     437                 :            :     /* Max sniff bytes.
     438                 :            :     */
     439         [ +  + ]:       1797 :     if(opts->config[CONF_MAX_SNIFF_BYTES] == NULL)
     440                 :       1610 :         set_config_entry(opts, CONF_MAX_SNIFF_BYTES, DEF_MAX_SNIFF_BYTES);
     441                 :            : 
     442                 :            : #if FIREWALL_FIREWALLD
     443                 :            :     /* Enable FIREWD forwarding.
     444                 :            :     */
     445         [ +  - ]:       1797 :     if(opts->config[CONF_ENABLE_FIREWD_FORWARDING] == NULL)
     446                 :       1797 :         set_config_entry(opts, CONF_ENABLE_FIREWD_FORWARDING,
     447                 :            :             DEF_ENABLE_FIREWD_FORWARDING);
     448                 :            : 
     449                 :            :     /* Enable FIREWD local NAT.
     450                 :            :     */
     451         [ +  - ]:       1797 :     if(opts->config[CONF_ENABLE_FIREWD_LOCAL_NAT] == NULL)
     452                 :       1797 :         set_config_entry(opts, CONF_ENABLE_FIREWD_LOCAL_NAT,
     453                 :            :             DEF_ENABLE_FIREWD_LOCAL_NAT);
     454                 :            : 
     455                 :            :     /* Enable FIREWD SNAT.
     456                 :            :     */
     457         [ +  - ]:       1797 :     if(opts->config[CONF_ENABLE_FIREWD_SNAT] == NULL)
     458                 :       1797 :         set_config_entry(opts, CONF_ENABLE_FIREWD_SNAT,
     459                 :            :             DEF_ENABLE_FIREWD_SNAT);
     460                 :            : 
     461                 :            :     /* Make sure we have a valid IP if SNAT is enabled
     462                 :            :     */
     463         [ -  + ]:       1797 :     if(strncasecmp(opts->config[CONF_ENABLE_FIREWD_SNAT], "Y", 1) == 0)
     464                 :            :     {
     465                 :            :         /* Note that fw_config_init() will set use_masquerade if necessary
     466                 :            :         */
     467         [ #  # ]:          0 :         if(opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
     468                 :            :         {
     469         [ #  # ]:          0 :             if(! is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP]))
     470                 :            :             {
     471                 :          0 :                 log_msg(LOG_ERR,
     472                 :            :                     "Invalid IPv4 addr for SNAT_TRANSLATE_IP"
     473                 :            :                 );
     474                 :          0 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     475                 :            :             }
     476                 :            :         }
     477                 :            :     }
     478                 :            : 
     479                 :            :     /* Enable FIREWD OUTPUT.
     480                 :            :     */
     481         [ +  - ]:       1797 :     if(opts->config[CONF_ENABLE_FIREWD_OUTPUT] == NULL)
     482                 :       1797 :         set_config_entry(opts, CONF_ENABLE_FIREWD_OUTPUT,
     483                 :            :             DEF_ENABLE_FIREWD_OUTPUT);
     484                 :            : 
     485                 :            :     /* Flush FIREWD at init.
     486                 :            :     */
     487         [ +  - ]:       1797 :     if(opts->config[CONF_FLUSH_FIREWD_AT_INIT] == NULL)
     488                 :       1797 :         set_config_entry(opts, CONF_FLUSH_FIREWD_AT_INIT, DEF_FLUSH_FIREWD_AT_INIT);
     489                 :            : 
     490                 :            :     /* Flush FIREWD at exit.
     491                 :            :     */
     492         [ +  - ]:       1797 :     if(opts->config[CONF_FLUSH_FIREWD_AT_EXIT] == NULL)
     493                 :       1797 :         set_config_entry(opts, CONF_FLUSH_FIREWD_AT_EXIT, DEF_FLUSH_FIREWD_AT_EXIT);
     494                 :            : 
     495                 :            :     /* FIREWD input access.
     496                 :            :     */
     497         [ +  - ]:       1797 :     if(opts->config[CONF_FIREWD_INPUT_ACCESS] == NULL)
     498                 :       1797 :         set_config_entry(opts, CONF_FIREWD_INPUT_ACCESS,
     499                 :            :             DEF_FIREWD_INPUT_ACCESS);
     500                 :            : 
     501         [ -  + ]:       1797 :     if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_INPUT_ACCESS]) != 1)
     502                 :            :     {
     503                 :          0 :         log_msg(LOG_ERR,
     504                 :            :             "Invalid FIREWD_INPUT_ACCESS specification, see fwknopd.conf comments"
     505                 :            :         );
     506                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     507                 :            :     }
     508                 :            : 
     509                 :            :     /* FIREWD output access.
     510                 :            :     */
     511         [ +  - ]:       1797 :     if(opts->config[CONF_FIREWD_OUTPUT_ACCESS] == NULL)
     512                 :       1797 :         set_config_entry(opts, CONF_FIREWD_OUTPUT_ACCESS,
     513                 :            :             DEF_FIREWD_OUTPUT_ACCESS);
     514                 :            : 
     515         [ -  + ]:       1797 :     if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_OUTPUT_ACCESS]) != 1)
     516                 :            :     {
     517                 :          0 :         log_msg(LOG_ERR,
     518                 :            :             "Invalid FIREWD_OUTPUT_ACCESS specification, see fwknopd.conf comments"
     519                 :            :         );
     520                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     521                 :            :     }
     522                 :            : 
     523                 :            :     /* FIREWD forward access.
     524                 :            :     */
     525         [ +  - ]:       1797 :     if(opts->config[CONF_FIREWD_FORWARD_ACCESS] == NULL)
     526                 :       1797 :         set_config_entry(opts, CONF_FIREWD_FORWARD_ACCESS,
     527                 :            :             DEF_FIREWD_FORWARD_ACCESS);
     528                 :            : 
     529         [ -  + ]:       1797 :     if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_FORWARD_ACCESS]) != 1)
     530                 :            :     {
     531                 :          0 :         log_msg(LOG_ERR,
     532                 :            :             "Invalid FIREWD_FORWARD_ACCESS specification, see fwknopd.conf comments"
     533                 :            :         );
     534                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     535                 :            :     }
     536                 :            : 
     537                 :            :     /* FIREWD dnat access.
     538                 :            :     */
     539         [ +  - ]:       1797 :     if(opts->config[CONF_FIREWD_DNAT_ACCESS] == NULL)
     540                 :       1797 :         set_config_entry(opts, CONF_FIREWD_DNAT_ACCESS,
     541                 :            :             DEF_FIREWD_DNAT_ACCESS);
     542                 :            : 
     543         [ -  + ]:       1797 :     if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_DNAT_ACCESS]) != 1)
     544                 :            :     {
     545                 :          0 :         log_msg(LOG_ERR,
     546                 :            :             "Invalid FIREWD_DNAT_ACCESS specification, see fwknopd.conf comments"
     547                 :            :         );
     548                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     549                 :            :     }
     550                 :            : 
     551                 :            :     /* FIREWD snat access.
     552                 :            :     */
     553         [ +  - ]:       1797 :     if(opts->config[CONF_FIREWD_SNAT_ACCESS] == NULL)
     554                 :       1797 :         set_config_entry(opts, CONF_FIREWD_SNAT_ACCESS,
     555                 :            :             DEF_FIREWD_SNAT_ACCESS);
     556                 :            : 
     557         [ -  + ]:       1797 :     if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_SNAT_ACCESS]) != 1)
     558                 :            :     {
     559                 :          0 :         log_msg(LOG_ERR,
     560                 :            :             "Invalid FIREWD_SNAT_ACCESS specification, see fwknopd.conf comments"
     561                 :            :         );
     562                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     563                 :            :     }
     564                 :            : 
     565                 :            :     /* FIREWD masquerade access.
     566                 :            :     */
     567         [ +  - ]:       1797 :     if(opts->config[CONF_FIREWD_MASQUERADE_ACCESS] == NULL)
     568                 :       1797 :         set_config_entry(opts, CONF_FIREWD_MASQUERADE_ACCESS,
     569                 :            :             DEF_FIREWD_MASQUERADE_ACCESS);
     570                 :            : 
     571         [ -  + ]:       1797 :     if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_MASQUERADE_ACCESS]) != 1)
     572                 :            :     {
     573                 :          0 :         log_msg(LOG_ERR,
     574                 :            :             "Invalid FIREWD_MASQUERADE_ACCESS specification, see fwknopd.conf comments"
     575                 :            :         );
     576                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     577                 :            :     }
     578                 :            : 
     579                 :            :     /* Check for the firewalld 'comment' match at init time
     580                 :            :     */
     581         [ +  - ]:       1797 :     if(opts->config[CONF_ENABLE_FIREWD_COMMENT_CHECK] == NULL)
     582                 :       1797 :         set_config_entry(opts, CONF_ENABLE_FIREWD_COMMENT_CHECK,
     583                 :            :             DEF_ENABLE_FIREWD_COMMENT_CHECK);
     584                 :            : 
     585                 :            : #elif FIREWALL_IPTABLES
     586                 :            :     /* Enable IPT forwarding.
     587                 :            :     */
     588                 :            :     if(opts->config[CONF_ENABLE_IPT_FORWARDING] == NULL)
     589                 :            :         set_config_entry(opts, CONF_ENABLE_IPT_FORWARDING,
     590                 :            :             DEF_ENABLE_IPT_FORWARDING);
     591                 :            : 
     592                 :            :     /* Enable IPT local NAT.
     593                 :            :     */
     594                 :            :     if(opts->config[CONF_ENABLE_IPT_LOCAL_NAT] == NULL)
     595                 :            :         set_config_entry(opts, CONF_ENABLE_IPT_LOCAL_NAT,
     596                 :            :             DEF_ENABLE_IPT_LOCAL_NAT);
     597                 :            : 
     598                 :            :     /* Enable IPT SNAT.
     599                 :            :     */
     600                 :            :     if(opts->config[CONF_ENABLE_IPT_SNAT] == NULL)
     601                 :            :         set_config_entry(opts, CONF_ENABLE_IPT_SNAT,
     602                 :            :             DEF_ENABLE_IPT_SNAT);
     603                 :            : 
     604                 :            :     /* Make sure we have a valid IP if SNAT is enabled
     605                 :            :     */
     606                 :            :     if(strncasecmp(opts->config[CONF_ENABLE_IPT_SNAT], "Y", 1) == 0)
     607                 :            :     {
     608                 :            :         /* Note that fw_config_init() will set use_masquerade if necessary
     609                 :            :         */
     610                 :            :         if(opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
     611                 :            :         {
     612                 :            :             if(! is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP]))
     613                 :            :             {
     614                 :            :                 log_msg(LOG_ERR,
     615                 :            :                     "Invalid IPv4 addr for SNAT_TRANSLATE_IP"
     616                 :            :                 );
     617                 :            :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     618                 :            :             }
     619                 :            :         }
     620                 :            :     }
     621                 :            : 
     622                 :            :     /* Enable IPT OUTPUT.
     623                 :            :     */
     624                 :            :     if(opts->config[CONF_ENABLE_IPT_OUTPUT] == NULL)
     625                 :            :         set_config_entry(opts, CONF_ENABLE_IPT_OUTPUT,
     626                 :            :             DEF_ENABLE_IPT_OUTPUT);
     627                 :            : 
     628                 :            :     /* Flush IPT at init.
     629                 :            :     */
     630                 :            :     if(opts->config[CONF_FLUSH_IPT_AT_INIT] == NULL)
     631                 :            :         set_config_entry(opts, CONF_FLUSH_IPT_AT_INIT, DEF_FLUSH_IPT_AT_INIT);
     632                 :            : 
     633                 :            :     /* Flush IPT at exit.
     634                 :            :     */
     635                 :            :     if(opts->config[CONF_FLUSH_IPT_AT_EXIT] == NULL)
     636                 :            :         set_config_entry(opts, CONF_FLUSH_IPT_AT_EXIT, DEF_FLUSH_IPT_AT_EXIT);
     637                 :            : 
     638                 :            :     /* IPT input access.
     639                 :            :     */
     640                 :            :     if(opts->config[CONF_IPT_INPUT_ACCESS] == NULL)
     641                 :            :         set_config_entry(opts, CONF_IPT_INPUT_ACCESS,
     642                 :            :             DEF_IPT_INPUT_ACCESS);
     643                 :            : 
     644                 :            :     if(validate_ipt_chain_conf(opts->config[CONF_IPT_INPUT_ACCESS]) != 1)
     645                 :            :     {
     646                 :            :         log_msg(LOG_ERR,
     647                 :            :             "Invalid IPT_INPUT_ACCESS specification, see fwknopd.conf comments"
     648                 :            :         );
     649                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     650                 :            :     }
     651                 :            : 
     652                 :            :     /* IPT output access.
     653                 :            :     */
     654                 :            :     if(opts->config[CONF_IPT_OUTPUT_ACCESS] == NULL)
     655                 :            :         set_config_entry(opts, CONF_IPT_OUTPUT_ACCESS,
     656                 :            :             DEF_IPT_OUTPUT_ACCESS);
     657                 :            : 
     658                 :            :     if(validate_ipt_chain_conf(opts->config[CONF_IPT_OUTPUT_ACCESS]) != 1)
     659                 :            :     {
     660                 :            :         log_msg(LOG_ERR,
     661                 :            :             "Invalid IPT_OUTPUT_ACCESS specification, see fwknopd.conf comments"
     662                 :            :         );
     663                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     664                 :            :     }
     665                 :            : 
     666                 :            :     /* IPT forward access.
     667                 :            :     */
     668                 :            :     if(opts->config[CONF_IPT_FORWARD_ACCESS] == NULL)
     669                 :            :         set_config_entry(opts, CONF_IPT_FORWARD_ACCESS,
     670                 :            :             DEF_IPT_FORWARD_ACCESS);
     671                 :            : 
     672                 :            :     if(validate_ipt_chain_conf(opts->config[CONF_IPT_FORWARD_ACCESS]) != 1)
     673                 :            :     {
     674                 :            :         log_msg(LOG_ERR,
     675                 :            :             "Invalid IPT_FORWARD_ACCESS specification, see fwknopd.conf comments"
     676                 :            :         );
     677                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     678                 :            :     }
     679                 :            : 
     680                 :            :     /* IPT dnat access.
     681                 :            :     */
     682                 :            :     if(opts->config[CONF_IPT_DNAT_ACCESS] == NULL)
     683                 :            :         set_config_entry(opts, CONF_IPT_DNAT_ACCESS,
     684                 :            :             DEF_IPT_DNAT_ACCESS);
     685                 :            : 
     686                 :            :     if(validate_ipt_chain_conf(opts->config[CONF_IPT_DNAT_ACCESS]) != 1)
     687                 :            :     {
     688                 :            :         log_msg(LOG_ERR,
     689                 :            :             "Invalid IPT_DNAT_ACCESS specification, see fwknopd.conf comments"
     690                 :            :         );
     691                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     692                 :            :     }
     693                 :            : 
     694                 :            :     /* IPT snat access.
     695                 :            :     */
     696                 :            :     if(opts->config[CONF_IPT_SNAT_ACCESS] == NULL)
     697                 :            :         set_config_entry(opts, CONF_IPT_SNAT_ACCESS,
     698                 :            :             DEF_IPT_SNAT_ACCESS);
     699                 :            : 
     700                 :            :     if(validate_ipt_chain_conf(opts->config[CONF_IPT_SNAT_ACCESS]) != 1)
     701                 :            :     {
     702                 :            :         log_msg(LOG_ERR,
     703                 :            :             "Invalid IPT_SNAT_ACCESS specification, see fwknopd.conf comments"
     704                 :            :         );
     705                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     706                 :            :     }
     707                 :            : 
     708                 :            :     /* IPT masquerade access.
     709                 :            :     */
     710                 :            :     if(opts->config[CONF_IPT_MASQUERADE_ACCESS] == NULL)
     711                 :            :         set_config_entry(opts, CONF_IPT_MASQUERADE_ACCESS,
     712                 :            :             DEF_IPT_MASQUERADE_ACCESS);
     713                 :            : 
     714                 :            :     if(validate_ipt_chain_conf(opts->config[CONF_IPT_MASQUERADE_ACCESS]) != 1)
     715                 :            :     {
     716                 :            :         log_msg(LOG_ERR,
     717                 :            :             "Invalid IPT_MASQUERADE_ACCESS specification, see fwknopd.conf comments"
     718                 :            :         );
     719                 :            :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     720                 :            :     }
     721                 :            : 
     722                 :            :     /* Check for the iptables 'comment' match at init time
     723                 :            :     */
     724                 :            :     if(opts->config[CONF_ENABLE_IPT_COMMENT_CHECK] == NULL)
     725                 :            :         set_config_entry(opts, CONF_ENABLE_IPT_COMMENT_CHECK,
     726                 :            :             DEF_ENABLE_IPT_COMMENT_CHECK);
     727                 :            : 
     728                 :            : #elif FIREWALL_IPFW
     729                 :            : 
     730                 :            :     /* Flush ipfw rules at init.
     731                 :            :     */
     732                 :            :     if(opts->config[CONF_FLUSH_IPFW_AT_INIT] == NULL)
     733                 :            :         set_config_entry(opts, CONF_FLUSH_IPFW_AT_INIT, DEF_FLUSH_IPFW_AT_INIT);
     734                 :            : 
     735                 :            :     /* Flush ipfw rules at exit.
     736                 :            :     */
     737                 :            :     if(opts->config[CONF_FLUSH_IPFW_AT_EXIT] == NULL)
     738                 :            :         set_config_entry(opts, CONF_FLUSH_IPFW_AT_EXIT, DEF_FLUSH_IPFW_AT_EXIT);
     739                 :            : 
     740                 :            :     /* Set IPFW start rule number.
     741                 :            :     */
     742                 :            :     if(opts->config[CONF_IPFW_START_RULE_NUM] == NULL)
     743                 :            :         set_config_entry(opts, CONF_IPFW_START_RULE_NUM,
     744                 :            :             DEF_IPFW_START_RULE_NUM);
     745                 :            : 
     746                 :            :     /* Set IPFW max rules.
     747                 :            :     */
     748                 :            :     if(opts->config[CONF_IPFW_MAX_RULES] == NULL)
     749                 :            :         set_config_entry(opts, CONF_IPFW_MAX_RULES,
     750                 :            :             DEF_IPFW_MAX_RULES);
     751                 :            : 
     752                 :            :     /* Set IPFW active set number.
     753                 :            :     */
     754                 :            :     if(opts->config[CONF_IPFW_ACTIVE_SET_NUM] == NULL)
     755                 :            :         set_config_entry(opts, CONF_IPFW_ACTIVE_SET_NUM,
     756                 :            :             DEF_IPFW_ACTIVE_SET_NUM);
     757                 :            : 
     758                 :            :     /* Set IPFW expire set number.
     759                 :            :     */
     760                 :            :     if(opts->config[CONF_IPFW_EXPIRE_SET_NUM] == NULL)
     761                 :            :         set_config_entry(opts, CONF_IPFW_EXPIRE_SET_NUM,
     762                 :            :             DEF_IPFW_EXPIRE_SET_NUM);
     763                 :            : 
     764                 :            :     /* Set IPFW Dynamic rule expiry interval.
     765                 :            :     */
     766                 :            :     if(opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL] == NULL)
     767                 :            :         set_config_entry(opts, CONF_IPFW_EXPIRE_PURGE_INTERVAL,
     768                 :            :             DEF_IPFW_EXPIRE_PURGE_INTERVAL);
     769                 :            : 
     770                 :            :     /* Set IPFW Dynamic rule expiry interval.
     771                 :            :     */
     772                 :            :     if(opts->config[CONF_IPFW_ADD_CHECK_STATE] == NULL)
     773                 :            :         set_config_entry(opts, CONF_IPFW_ADD_CHECK_STATE,
     774                 :            :             DEF_IPFW_ADD_CHECK_STATE);
     775                 :            : 
     776                 :            : #elif FIREWALL_PF
     777                 :            :     /* Set PF anchor name
     778                 :            :     */
     779                 :            :     if(opts->config[CONF_PF_ANCHOR_NAME] == NULL)
     780                 :            :         set_config_entry(opts, CONF_PF_ANCHOR_NAME,
     781                 :            :             DEF_PF_ANCHOR_NAME);
     782                 :            : 
     783                 :            :     /* Set PF rule expiry interval.
     784                 :            :     */
     785                 :            :     if(opts->config[CONF_PF_EXPIRE_INTERVAL] == NULL)
     786                 :            :         set_config_entry(opts, CONF_PF_EXPIRE_INTERVAL,
     787                 :            :             DEF_PF_EXPIRE_INTERVAL);
     788                 :            : 
     789                 :            : #elif FIREWALL_IPF
     790                 :            :     /* --DSS Place-holder */
     791                 :            : 
     792                 :            : #endif /* FIREWALL type */
     793                 :            : 
     794                 :            :     /* GPG Home dir.
     795                 :            :     */
     796         [ +  + ]:       1797 :     if(opts->config[CONF_GPG_HOME_DIR] == NULL)
     797                 :       1461 :         set_config_entry(opts, CONF_GPG_HOME_DIR, DEF_GPG_HOME_DIR);
     798                 :            : 
     799                 :            :     /* GPG executable
     800                 :            :     */
     801         [ +  + ]:       1797 :     if(opts->config[CONF_GPG_EXE] == NULL)
     802                 :       1488 :         set_config_entry(opts, CONF_GPG_EXE, DEF_GPG_EXE);
     803                 :            : 
     804                 :            :     /* Enable SPA over HTTP.
     805                 :            :     */
     806         [ +  + ]:       1797 :     if(opts->config[CONF_ENABLE_SPA_OVER_HTTP] == NULL)
     807                 :       1467 :         set_config_entry(opts, CONF_ENABLE_SPA_OVER_HTTP,
     808                 :            :             DEF_ENABLE_SPA_OVER_HTTP);
     809                 :            : 
     810                 :            :     /* Enable TCP server.
     811                 :            :     */
     812         [ +  + ]:       1797 :     if(opts->config[CONF_ENABLE_TCP_SERVER] == NULL)
     813                 :       1564 :         set_config_entry(opts, CONF_ENABLE_TCP_SERVER, DEF_ENABLE_TCP_SERVER);
     814                 :            : 
     815                 :            :     /* TCP Server port.
     816                 :            :     */
     817         [ +  + ]:       1797 :     if(opts->config[CONF_TCPSERV_PORT] == NULL)
     818                 :       1482 :         set_config_entry(opts, CONF_TCPSERV_PORT, DEF_TCPSERV_PORT);
     819                 :            : 
     820                 :            :     /* Enable UDP server.
     821                 :            :     */
     822         [ +  + ]:       1797 :     if(opts->config[CONF_ENABLE_UDP_SERVER] == NULL)
     823                 :            :     {
     824 [ -  + ][ #  # ]:       1443 :         if((strncasecmp(DEF_ENABLE_UDP_SERVER, "Y", 1) == 0) &&
     825                 :          0 :                 !opts->enable_udp_server)
     826                 :            :         {
     827                 :          0 :             log_msg(LOG_ERR, "pcap capture not compiled in, forcing UDP server mode");
     828                 :          0 :             opts->enable_udp_server = 1;
     829                 :            :         }
     830                 :       1443 :         set_config_entry(opts, CONF_ENABLE_UDP_SERVER, DEF_ENABLE_UDP_SERVER);
     831                 :            :     }
     832                 :            : 
     833                 :            :     /* UDP Server port.
     834                 :            :     */
     835         [ +  + ]:       1797 :     if(opts->config[CONF_UDPSERV_PORT] == NULL)
     836                 :       1526 :         set_config_entry(opts, CONF_UDPSERV_PORT, DEF_UDPSERV_PORT);
     837                 :            : 
     838                 :            :     /* UDP server select() timeout in microseconds
     839                 :            :     */
     840         [ +  + ]:       1797 :     if(opts->config[CONF_UDPSERV_SELECT_TIMEOUT] == NULL)
     841                 :       1563 :         set_config_entry(opts, CONF_UDPSERV_SELECT_TIMEOUT,
     842                 :            :             DEF_UDPSERV_SELECT_TIMEOUT);
     843                 :            : 
     844                 :            :     /* Syslog identity.
     845                 :            :     */
     846         [ +  + ]:       1797 :     if(opts->config[CONF_SYSLOG_IDENTITY] == NULL)
     847                 :       1467 :         set_config_entry(opts, CONF_SYSLOG_IDENTITY, DEF_SYSLOG_IDENTITY);
     848                 :            : 
     849                 :            :     /* Syslog facility.
     850                 :            :     */
     851         [ +  + ]:       1797 :     if(opts->config[CONF_SYSLOG_FACILITY] == NULL)
     852                 :       1530 :         set_config_entry(opts, CONF_SYSLOG_FACILITY, DEF_SYSLOG_FACILITY);
     853                 :            : 
     854                 :            : 
     855                 :            :     /* Validate integer variable ranges
     856                 :            :     */
     857                 :       1797 :     validate_int_var_ranges(opts);
     858                 :            : 
     859                 :            :     /* Some options just trigger some output of information, or trigger an
     860                 :            :      * external function, but do not actually start fwknopd.  If any of those
     861                 :            :      * are set, we can return here an skip the validation routines as all
     862                 :            :      * other options will be ignored anyway.
     863                 :            :      *
     864                 :            :      * These are also mutually exclusive (for now).
     865                 :            :     */
     866         [ +  - ]:       1678 :     if((opts->dump_config + opts->kill + opts->restart + opts->status) == 1)
     867                 :            :         return;
     868                 :            : 
     869         [ -  + ]:       1678 :     if((opts->dump_config + opts->kill + opts->restart + opts->status) > 1)
     870                 :            :     {
     871                 :          0 :         log_msg(LOG_ERR,
     872                 :            :             "The -D, -K, -R, and -S options are mutually exclusive.  Pick only one."
     873                 :            :         );
     874                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     875                 :            :     }
     876                 :            : 
     877         [ -  + ]:       1678 :     if(opts->config[CONF_FIREWALL_EXE] == NULL)
     878                 :            :     {
     879                 :          0 :         log_msg(LOG_ERR,
     880                 :            :             "[*] No firewall command executable is set. Please check FIREWALL_EXE in fwknopd.conf."
     881                 :            :         );
     882                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     883                 :            :     }
     884                 :            : 
     885                 :            :     return;
     886                 :            : }
     887                 :            : 
     888                 :            : void
     889                 :       1814 : set_preconfig_entries(fko_srv_options_t *opts)
     890                 :            : {
     891                 :            :     /* First, set any default or otherwise static settings here.  Some may
     892                 :            :      * end up being overwritten via config file or command-line.
     893                 :            :     */
     894                 :            : 
     895                 :            :     /* Setup the firewall executable based on build-time info.
     896                 :            :      * --DSS Note: We will want to either force external script mode, or
     897                 :            :      *             error out if we do not have a firewall executable defined.
     898                 :            :     */
     899                 :            : #ifdef FIREWALL_EXE
     900                 :       1814 :     set_config_entry(opts, CONF_FIREWALL_EXE, FIREWALL_EXE);
     901                 :            : #endif
     902                 :            : 
     903                 :       1814 : }
     904                 :            : 
     905                 :            : /* Initialize program configuration via config file and/or command-line
     906                 :            :  * switches.
     907                 :            : */
     908                 :            : void
     909                 :       1814 : config_init(fko_srv_options_t *opts, int argc, char **argv)
     910                 :            : {
     911                 :            :     int             cmd_arg, index, is_err;
     912                 :       1814 :     unsigned char   got_conf_file = 0, got_override_config = 0;
     913                 :            : 
     914                 :       1814 :     char            override_file[MAX_LINE_LEN] = {0};
     915                 :            :     char           *ndx, *cmrk;
     916                 :            : 
     917                 :            :     /* Zero out options and opts_track.
     918                 :            :     */
     919                 :            :     memset(opts, 0x00, sizeof(fko_srv_options_t));
     920                 :            : 
     921                 :            :     /* Set some preconfiguration options (i.e. build-time defaults)
     922                 :            :     */
     923                 :       1814 :     set_preconfig_entries(opts);
     924                 :            : 
     925                 :            :     /* In case this is a re-config.
     926                 :            :     */
     927                 :       1814 :     optind = 0;
     928                 :            : 
     929                 :            :     /* First, scan the command-line args for -h/--help or an alternate
     930                 :            :      * configuration file. If we find an alternate config file, use it,
     931                 :            :      * otherwise use the default.  We also grab any override config files
     932                 :            :      * as well.
     933                 :            :     */
     934         [ +  + ]:      20099 :     while ((cmd_arg = getopt_long(argc, argv,
     935                 :            :             GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
     936                 :            : 
     937                 :            :         /* If help is wanted, give it and exit.
     938                 :            :         */
     939   [ -  +  +  + ]:      16471 :         switch(cmd_arg) {
     940                 :            :             case 'h':
     941                 :          0 :                 usage();
     942                 :          0 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
     943                 :            : 
     944                 :            :             /* Look for configuration file arg.
     945                 :            :             */
     946                 :            :             case 'c':
     947                 :       1814 :                 set_config_entry(opts, CONF_CONFIG_FILE, optarg);
     948                 :       1814 :                 got_conf_file++;
     949                 :            : 
     950                 :            :                 /* If we already have the config_override option, we are done.
     951                 :            :                 */
     952         [ +  - ]:       1814 :                 if(got_override_config > 0)
     953                 :            :                     break;
     954                 :            : 
     955                 :            :             /* Look for override configuration file arg.
     956                 :            :             */
     957                 :            :             case 'O':
     958                 :       3109 :                 set_config_entry(opts, CONF_OVERRIDE_CONFIG, optarg);
     959                 :       4923 :                 got_override_config++;
     960                 :            : 
     961                 :            :                 /* If we already have the conf_file option, we are done.
     962                 :            :                 */
     963                 :            :                 if(got_conf_file > 0)
     964                 :            :                     break;
     965                 :            :         }
     966                 :            :     }
     967                 :            : 
     968                 :            :     /* If no alternate configuration file was specified, we use the
     969                 :            :      * default.
     970                 :            :     */
     971         [ -  + ]:       1814 :     if(opts->config[CONF_CONFIG_FILE] == NULL)
     972                 :          0 :         set_config_entry(opts, CONF_CONFIG_FILE, DEF_CONFIG_FILE);
     973                 :            : 
     974                 :            :     /* Parse configuration file to populate any params not already specified
     975                 :            :      * via command-line options.
     976                 :            :     */
     977                 :       1814 :     parse_config_file(opts, opts->config[CONF_CONFIG_FILE]);
     978                 :            : 
     979                 :            :     /* If there are override configuration entries, process them
     980                 :            :      * here.
     981                 :            :     */
     982         [ +  - ]:       1814 :     if(opts->config[CONF_OVERRIDE_CONFIG] != NULL)
     983                 :            :     {
     984                 :            :         /* Make a copy of the override_config string so we can munge it.
     985                 :            :         */
     986                 :       1814 :         strlcpy(override_file, opts->config[CONF_OVERRIDE_CONFIG], sizeof(override_file));
     987                 :            : 
     988                 :       1814 :         ndx  = override_file;
     989                 :       1814 :         cmrk = strchr(ndx, ',');
     990                 :            : 
     991         [ -  + ]:       1814 :         if(cmrk == NULL)
     992                 :            :         {
     993                 :            :             /* Only one to process...
     994                 :            :             */
     995                 :       1814 :             parse_config_file(opts, ndx);
     996                 :            : 
     997                 :            :         } else {
     998                 :            :             /* Walk the string pulling the next config override
     999                 :            :              * at the comma delimiters.
    1000                 :            :             */
    1001         [ #  # ]:          0 :             while(cmrk != NULL) {
    1002                 :          0 :                 *cmrk = '\0';
    1003                 :          0 :                 parse_config_file(opts, ndx);
    1004                 :          0 :                 ndx = cmrk + 1;
    1005                 :          0 :                 cmrk = strchr(ndx, ',');
    1006                 :            :             }
    1007                 :            : 
    1008                 :            :             /* Process the last entry
    1009                 :            :             */
    1010                 :          0 :             parse_config_file(opts, ndx);
    1011                 :            :         }
    1012                 :            :     }
    1013                 :            : 
    1014                 :            :     /* Set up the verbosity level according to the value found in the
    1015                 :            :      * config files */
    1016         [ +  + ]:       1814 :     if (opts->config[CONF_VERBOSE] != NULL)
    1017                 :            :     {
    1018                 :        451 :         opts->verbose = strtol_wrapper(opts->config[CONF_VERBOSE], 0, -1,
    1019                 :            :                                        NO_EXIT_UPON_ERR, &is_err);
    1020         [ +  + ]:        451 :         if(is_err != FKO_SUCCESS)
    1021                 :            :         {
    1022                 :         17 :             log_msg(LOG_ERR, "[*] VERBOSE value '%s' not in the range (>0)",
    1023                 :            :                 opts->config[CONF_VERBOSE]);
    1024                 :         17 :             clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1025                 :            :         }
    1026                 :            :     }
    1027                 :            : 
    1028                 :            :     /* Reset the options index so we can run through them again.
    1029                 :            :     */
    1030                 :       1797 :     optind = 0;
    1031                 :            : 
    1032                 :            :     /* Last, but not least, we process command-line options (some of which
    1033                 :            :      * may override configuration file options.
    1034                 :            :     */
    1035         [ +  + ]:      19878 :     while ((cmd_arg = getopt_long(argc, argv,
    1036                 :            :             GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
    1037                 :            : 
    1038   [ +  -  +  -  :      16284 :         switch(cmd_arg) {
          +  -  -  +  +  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  +  -  +  -  
             +  -  -  -  
                      + ]
    1039                 :            :             case 'A':
    1040                 :            : #if AFL_FUZZING
    1041                 :       1002 :                 opts->afl_fuzzing = 1;
    1042                 :            : #else
    1043                 :            :                 log_msg(LOG_ERR, "[*] fwknopd not compiled with AFL fuzzing support");
    1044                 :            :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1045                 :            : #endif
    1046                 :       1002 :                 break;
    1047                 :            :             case AFL_PKT_FILE:
    1048                 :            : #if AFL_FUZZING
    1049                 :          0 :                 opts->afl_fuzzing = 1;
    1050                 :          0 :                 set_config_entry(opts, CONF_AFL_PKT_FILE, optarg);
    1051                 :            : #else
    1052                 :            :                 log_msg(LOG_ERR, "[*] fwknopd not compiled with AFL fuzzing support");
    1053                 :            :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1054                 :            : #endif
    1055                 :          0 :                 break;
    1056                 :            :             case 'a':
    1057                 :       1797 :                 set_config_entry(opts, CONF_ACCESS_FILE, optarg);
    1058                 :       1797 :                 break;
    1059                 :            :             case 'c':
    1060                 :            :                 /* This was handled earlier */
    1061                 :            :                 break;
    1062                 :            :             case 'C':
    1063                 :          0 :                 opts->packet_ctr_limit = strtol_wrapper(optarg,
    1064                 :            :                         0, (2 << 30), NO_EXIT_UPON_ERR, &is_err);
    1065         [ #  # ]:          0 :                 if(is_err != FKO_SUCCESS)
    1066                 :            :                 {
    1067                 :          0 :                     log_msg(LOG_ERR,
    1068                 :            :                         "[*] invalid -C packet count limit '%s'",
    1069                 :            :                         optarg);
    1070                 :          0 :                     clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1071                 :            :                 }
    1072                 :            :                 break;
    1073                 :            :             case 'd':
    1074                 :            : #if USE_FILE_CACHE
    1075                 :         71 :                 set_config_entry(opts, CONF_DIGEST_FILE, optarg);
    1076                 :            : #else
    1077                 :            :                 set_config_entry(opts, CONF_DIGEST_DB_FILE, optarg);
    1078                 :            : #endif
    1079                 :         71 :                 break;
    1080                 :            :             case 'D':
    1081                 :          0 :                 opts->dump_config = 1;
    1082                 :          0 :                 break;
    1083                 :            :             case DUMP_SERVER_ERR_CODES:
    1084                 :          0 :                 dump_server_errors();
    1085                 :          0 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
    1086                 :            :             case EXIT_AFTER_PARSE_CONFIG:
    1087                 :       1349 :                 opts->exit_after_parse_config = 1;
    1088                 :       1349 :                 opts->foreground = 1;
    1089                 :       1349 :                 break;
    1090                 :            :             case 'f':
    1091                 :       1797 :                 opts->foreground = 1;
    1092                 :       1797 :                 break;
    1093                 :            :             case FAULT_INJECTION_TAG:
    1094                 :            : #if HAVE_LIBFIU
    1095                 :            :                 set_config_entry(opts, CONF_FAULT_INJECTION_TAG, optarg);
    1096                 :            : #else
    1097                 :          0 :                 log_msg(LOG_ERR, "[*] fwknopd not compiled with libfiu support");
    1098                 :          0 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1099                 :            : #endif
    1100                 :          0 :                 break;
    1101                 :            :             case FW_LIST:
    1102                 :          0 :                 opts->fw_list = 1;
    1103                 :          0 :                 break;
    1104                 :            :             case FW_LIST_ALL:
    1105                 :          0 :                 opts->fw_list = 1;
    1106                 :          0 :                 opts->fw_list_all = 1;
    1107                 :          0 :                 break;
    1108                 :            :             case FW_FLUSH:
    1109                 :          0 :                 opts->fw_flush = 1;
    1110                 :          0 :                 break;
    1111                 :            :             case GPG_HOME_DIR:
    1112         [ #  # ]:          0 :                 if (is_valid_dir(optarg))
    1113                 :            :                 {
    1114                 :          0 :                     set_config_entry(opts, CONF_GPG_HOME_DIR, optarg);
    1115                 :            :                 }
    1116                 :            :                 else
    1117                 :            :                 {
    1118                 :          0 :                     log_msg(LOG_ERR,
    1119                 :            :                         "[*] Directory '%s' could not stat()/does not exist?",
    1120                 :            :                         optarg);
    1121                 :          0 :                     clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1122                 :            :                 }
    1123                 :            :                 break;
    1124                 :            :             case 'i':
    1125                 :          0 :                 set_config_entry(opts, CONF_PCAP_INTF, optarg);
    1126                 :          0 :                 break;
    1127                 :            :             case FIREWD_DISABLE_CHECK_SUPPORT:
    1128                 :          0 :                 opts->firewd_disable_check_support = 1;
    1129                 :          0 :                 break;
    1130                 :            :             case IPT_DISABLE_CHECK_SUPPORT:
    1131                 :          0 :                 opts->ipt_disable_check_support = 1;
    1132                 :          0 :                 break;
    1133                 :            :             case 'K':
    1134                 :          0 :                 opts->kill = 1;
    1135                 :          0 :                 break;
    1136                 :            :             case 'l':
    1137                 :          0 :                 set_config_entry(opts, CONF_LOCALE, optarg);
    1138                 :          0 :                 break;
    1139                 :            :             case 'O':
    1140                 :            :                 /* This was handled earlier */
    1141                 :            :                 break;
    1142                 :            :             case 'p':
    1143                 :          0 :                 set_config_entry(opts, CONF_FWKNOP_PID_FILE, optarg);
    1144                 :          0 :                 break;
    1145                 :            :             case 'P':
    1146                 :          0 :                 set_config_entry(opts, CONF_PCAP_FILTER, optarg);
    1147                 :          0 :                 break;
    1148                 :            :             case PCAP_FILE:
    1149                 :          0 :                 set_config_entry(opts, CONF_PCAP_FILE, optarg);
    1150                 :          0 :                 break;
    1151                 :            :             case ENABLE_PCAP_ANY_DIRECTION:
    1152                 :          0 :                 opts->pcap_any_direction = 1;
    1153                 :          0 :                 break;
    1154                 :            :             case ROTATE_DIGEST_CACHE:
    1155                 :          0 :                 opts->rotate_digest_cache = 1;
    1156                 :          0 :                 break;
    1157                 :            :             case 'R':
    1158                 :          0 :                 opts->restart = 1;
    1159                 :          0 :                 break;
    1160                 :            :             case 'r':
    1161                 :       1349 :                 set_config_entry(opts, CONF_FWKNOP_RUN_DIR, optarg);
    1162                 :       1349 :                 break;
    1163                 :            :             case 'S':
    1164                 :          0 :                 opts->status = 1;
    1165                 :          0 :                 break;
    1166                 :            :             case 't':
    1167                 :       1797 :                 opts->test = 1;
    1168                 :       1797 :                 break;
    1169                 :            :             case 'U':
    1170                 :          0 :                 opts->enable_udp_server = 1;
    1171                 :          0 :                 break;
    1172                 :            :             /* Verbosity level */
    1173                 :            :             case 'v':
    1174                 :       4047 :                 opts->verbose++;
    1175                 :       4047 :                 break;
    1176                 :            :             case SYSLOG_ENABLE:
    1177                 :          0 :                 opts->syslog_enable = 1;
    1178                 :          0 :                 break;
    1179                 :            :             case 'V':
    1180                 :          0 :                 fprintf(stdout, "fwknopd server %s\n", MY_VERSION);
    1181                 :          0 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
    1182                 :            :             default:
    1183                 :          0 :                 usage();
    1184                 :      15006 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
    1185                 :            :         }
    1186                 :            :     }
    1187                 :            : 
    1188                 :            :     /* Now that we have all of our options set, and we are actually going to
    1189                 :            :      * start fwknopd, we can validate them.
    1190                 :            :     */
    1191                 :       1797 :     validate_options(opts);
    1192                 :            : 
    1193                 :       1678 :     return;
    1194                 :            : }
    1195                 :            : 
    1196                 :            : /* Dump the configuration
    1197                 :            : */
    1198                 :            : void
    1199                 :        634 : dump_config(const fko_srv_options_t *opts)
    1200                 :            : {
    1201                 :            :     int i;
    1202                 :            : 
    1203                 :        634 :     fprintf(stdout, "Current fwknopd config settings:\n");
    1204                 :            : 
    1205         [ +  + ]:      31700 :     for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
    1206         [ +  + ]:      31066 :         fprintf(stdout, "%3i. %-28s =  '%s'\n",
    1207                 :            :             i,
    1208                 :            :             config_map[i],
    1209                 :      31066 :             (opts->config[i] == NULL) ? "<not set>" : opts->config[i]
    1210                 :            :         );
    1211                 :            : 
    1212                 :        634 :     fprintf(stdout, "\n");
    1213                 :        634 :     fflush(stdout);
    1214                 :        634 : }
    1215                 :            : 
    1216                 :            : /* Print usage message...
    1217                 :            : */
    1218                 :            : void
    1219                 :          0 : usage(void)
    1220                 :            : {
    1221                 :          0 :     fprintf(stdout, "\n%s server version %s\n%s - http://www.cipherdyne.org/fwknop/\n\n",
    1222                 :            :             MY_NAME, MY_VERSION, MY_DESC);
    1223                 :          0 :     fprintf(stdout,
    1224                 :            :       "Usage: fwknopd [options]\n\n"
    1225                 :            :       " -a, --access-file       - Specify an alternate access.conf file.\n"
    1226                 :            :       " -c, --config-file       - Specify an alternate configuration file.\n"
    1227                 :            :       " -f, --foreground        - Run fwknopd in the foreground (do not become\n"
    1228                 :            :       "                           a background daemon).\n"
    1229                 :            :       " -i, --interface         - Specify interface to listen for incoming SPA\n"
    1230                 :            :       "                           packets.\n"
    1231                 :            :       " -C, --packet-limit      - Limit the number of candidate SPA packets to\n"
    1232                 :            :       "                           process and exit when this limit is reached.\n"
    1233                 :            :       " -d, --digest-file       - Specify an alternate digest.cache file.\n"
    1234                 :            :       " -D, --dump-config       - Dump the current fwknop configuration values.\n"
    1235                 :            :       " -K, --kill              - Kill the currently running fwknopd.\n"
    1236                 :            :       " -l, --locale            - Provide a locale setting other than the system\n"
    1237                 :            :       "                           default.\n"
    1238                 :            :       " -O, --override-config   - Specify a file with configuration entries that will\n"
    1239                 :            :       "                           overide those in fwknopd.conf\n"
    1240                 :            :       " -p, --pid-file          - Specify an alternate fwknopd.pid file.\n"
    1241                 :            :       " -P, --pcap-filter       - Specify a Berkeley packet filter statement to\n"
    1242                 :            :       "                           override the PCAP_FILTER variable in fwknopd.conf.\n"
    1243                 :            :       " -R, --restart           - Force the currently running fwknopd to restart.\n"
    1244                 :            :       "     --rotate-digest-cache\n"
    1245                 :            :       "                         - Rotate the digest cache file by renaming the file\n"
    1246                 :            :       "                           to the same path with the -old suffix.\n"
    1247                 :            :       " -r, --run-dir           - Set path to local state run directory.\n"
    1248                 :            :       "                         - Rotate the digest cache file by renaming it to\n"
    1249                 :            :       "                           '<name>-old', and starting a new one.\n"
    1250                 :            :       " -S, --status            - Display the status of any running fwknopd process.\n"
    1251                 :            :       " -t, --test              - Test mode, process SPA packets but do not make any\n"
    1252                 :            :       "                           firewall modifications.\n"
    1253                 :            :       " -U, --udp-server        - Set UDP server mode.\n"
    1254                 :            :       " -v, --verbose           - Set verbose mode.\n"
    1255                 :            :       "     --syslog-enable     - Allow messages to be sent to syslog even if the\n"
    1256                 :            :       "                           foreground mode is set.\n"
    1257                 :            :       " -V, --version           - Print version number.\n"
    1258                 :            :       " -A, --afl-fuzzing       - Run in American Fuzzy Lop (AFL) fuzzing mode so\n"
    1259                 :            :       "                           that plaintext SPA packets are accepted via stdin.\n"
    1260                 :            :       " -h, --help              - Print this usage message and exit.\n"
    1261                 :            :       " --dump-serv-err-codes   - List all server error codes (only needed by the\n"
    1262                 :            :       "                           test suite).\n"
    1263                 :            :       " --exit-parse-config     - Parse config files and exit.\n"
    1264                 :            :       " --fault-injection-tag   - Enable a fault injection tag (only needed by the\n"
    1265                 :            :       "                           test suite).\n"
    1266                 :            :       " --pcap-file             - Read potential SPA packets from an existing pcap\n"
    1267                 :            :       "                           file.\n"
    1268                 :            :       " --pcap-any-direction    - By default fwknopd processes packets that are\n"
    1269                 :            :       "                           sent to the sniffing interface, but this option\n"
    1270                 :            :       "                           enables processing of packets that originate from\n"
    1271                 :            :       "                           an interface (such as in a forwarding situation).\n"
    1272                 :            :       "     --fw-list           - List all firewall rules that fwknop has created\n"
    1273                 :            :       "                           and then exit.\n"
    1274                 :            :       "     --fw-list-all       - List all firewall rules in the complete policy,\n"
    1275                 :            :       "                           including those that have nothing to do with\n"
    1276                 :            :       "                           fwknop.\n"
    1277                 :            :       "     --fw-flush          - Flush all firewall rules created by fwknop.\n"
    1278                 :            :       "     --gpg-home-dir      - Specify the GPG home directory (this is normally\n"
    1279                 :            :       "                           done in the access.conf file).\n"
    1280                 :            :       "     --gpg-exe           - Specify the path to GPG (this is normally done in\n"
    1281                 :            :       "                           the access.conf file).\n"
    1282                 :            :       " --no-firewd-check-support\n"
    1283                 :            :       "                         - Disable test for 'firewall-cmd ... -C' support.\n"
    1284                 :            :       " --no-ipt-check-support  - Disable test for 'iptables -C' support.\n"
    1285                 :            :       "\n"
    1286                 :            :     );
    1287                 :            : 
    1288                 :          0 :     return;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : /***EOF***/

Generated by: LCOV version 1.10