Branch data Line data Source code
1 : : /**
2 : : * \file server/config_init.c
3 : : *
4 : : * \brief Command-line and config file processing for fwknop server.
5 : : */
6 : :
7 : : /* Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
8 : : * Copyright (C) 2009-2015 fwknop developers and contributors. For a full
9 : : * list of contributors, see the file 'CREDITS'.
10 : : *
11 : : * License (GNU General Public License):
12 : : *
13 : : * This program is free software; you can redistribute it and/or
14 : : * modify it under the terms of the GNU General Public License
15 : : * as published by the Free Software Foundation; either version 2
16 : : * of the License, or (at your option) any later version.
17 : : *
18 : : * This program is distributed in the hope that it will be useful,
19 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 : : * GNU General Public License for more details.
22 : : *
23 : : * You should have received a copy of the GNU General Public License
24 : : * along with this program; if not, write to the Free Software
25 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26 : : * USA
27 : : *
28 : : ******************************************************************************
29 : : */
30 : : #include "fwknopd_common.h"
31 : : #include "fwknopd_errors.h"
32 : : #include "config_init.h"
33 : : #include "access.h"
34 : : #include "cmd_opts.h"
35 : : #include "utils.h"
36 : : #include "log_msg.h"
37 : :
38 : : #if FIREWALL_FIREWALLD
39 : : #include "fw_util_firewalld.h"
40 : : #elif FIREWALL_IPTABLES
41 : : #include "fw_util_iptables.h"
42 : : #endif
43 : :
44 : : /* Check to see if an integer variable has a value that is within a
45 : : * specific range
46 : : */
47 : : static int
48 : 48256 : range_check(fko_srv_options_t *opts, char *var, char *val, int low, int high)
49 : : {
50 : : int is_err, rv;
51 : :
52 : 48256 : rv = strtol_wrapper(val, low, high, NO_EXIT_UPON_ERR, &is_err);
53 [ + + ]: 48256 : if(is_err != FKO_SUCCESS)
54 : : {
55 : 4 : log_msg(LOG_ERR, "[*] var %s value '%s' not in the range %d-%d",
56 : : var, val, low, high);
57 : 4 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
58 : : }
59 : :
60 : 48252 : return rv;
61 : : }
62 : :
63 : : /* Take an index and a string value. malloc the space for the value
64 : : * and assign it to the array at the specified index.
65 : : */
66 : : static void
67 : 298504 : set_config_entry(fko_srv_options_t *opts, const int var_ndx, const char *value)
68 : : {
69 : : int space_needed;
70 : :
71 : : /* Sanity check the index value.
72 : : */
73 [ - + ]: 298504 : if(var_ndx < 0 || var_ndx >= NUMBER_OF_CONFIG_ENTRIES)
74 : : {
75 : 0 : log_msg(LOG_ERR, "[*] Index value of %i is not valid", var_ndx);
76 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
77 : : }
78 : :
79 : : /* If this particular entry was already set (i.e. not NULL), then
80 : : * assume it needs to be freed first.
81 : : */
82 [ + + ]: 298504 : if(opts->config[var_ndx] != NULL)
83 : 560 : free(opts->config[var_ndx]);
84 : :
85 : : /* If we are setting it to NULL, do it and be done.
86 : : */
87 [ - + ]: 298504 : if(value == NULL)
88 : : {
89 : 0 : opts->config[var_ndx] = NULL;
90 : 0 : return;
91 : : }
92 : :
93 : : /* Otherwise, make the space we need and set it.
94 : : */
95 : 298504 : space_needed = strlen(value) + 1;
96 : :
97 : 298504 : opts->config[var_ndx] = calloc(1, space_needed);
98 : :
99 [ + + ]: 298504 : if(opts->config[var_ndx] == NULL)
100 : : {
101 : 865 : log_msg(LOG_ERR, "[*] Fatal memory allocation error!");
102 : 865 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
103 : : }
104 : :
105 : 297639 : strlcpy(opts->config[var_ndx], value, space_needed);
106 : :
107 : 297639 : return;
108 : : }
109 : :
110 : : /* Given a config parameter name, return its index or -1 if not found.
111 : : */
112 : : static int
113 : 6 : config_entry_index(const fko_srv_options_t *opts, const char *var)
114 : : {
115 : : int i;
116 : :
117 [ + + ]: 312 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
118 [ + + ][ + + ]: 308 : if(opts->config[i] != NULL && CONF_VAR_IS(var, config_map[i]))
119 : 2 : return(i);
120 : :
121 : : return(-1);
122 : : }
123 : :
124 : : /* Free the config memory
125 : : */
126 : : void
127 : 7119 : free_configs(fko_srv_options_t *opts)
128 : : {
129 : : int i;
130 : :
131 : 7119 : free_acc_stanzas(opts);
132 : :
133 [ + + ]: 398664 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
134 [ + + ]: 391545 : if(opts->config[i] != NULL)
135 : 297027 : free(opts->config[i]);
136 : 7119 : }
137 : :
138 : : static void
139 : 6034 : validate_int_var_ranges(fko_srv_options_t *opts)
140 : : {
141 : : #if FIREWALL_IPFW
142 : : int is_err = FKO_SUCCESS;
143 : : #endif
144 : :
145 : 6034 : opts->pcap_loop_sleep = range_check(opts,
146 : : "PCAP_LOOP_SLEEP", opts->config[CONF_PCAP_LOOP_SLEEP],
147 : : 1, RCHK_MAX_PCAP_LOOP_SLEEP);
148 : 6033 : opts->pcap_dispatch_count = range_check(opts,
149 : : "PCAP_DISPATCH_COUNT", opts->config[CONF_PCAP_DISPATCH_COUNT],
150 : : 1, RCHK_MAX_PCAP_DISPATCH_COUNT);
151 : 6032 : opts->max_spa_packet_age = range_check(opts,
152 : : "MAX_SPA_PACKET_AGE", opts->config[CONF_MAX_SPA_PACKET_AGE],
153 : : 1, RCHK_MAX_SPA_PACKET_AGE);
154 : 6032 : opts->max_sniff_bytes = range_check(opts,
155 : : "MAX_SNIFF_BYTES", opts->config[CONF_MAX_SNIFF_BYTES],
156 : : 1, RCHK_MAX_SNIFF_BYTES);
157 : 6032 : opts->rules_chk_threshold = range_check(opts,
158 : : "RULES_CHECK_THRESHOLD", opts->config[CONF_RULES_CHECK_THRESHOLD],
159 : : 0, RCHK_MAX_RULES_CHECK_THRESHOLD);
160 : 6032 : opts->tcpserv_port = range_check(opts,
161 : : "TCPSERV_PORT", opts->config[CONF_TCPSERV_PORT],
162 : : 1, RCHK_MAX_TCPSERV_PORT);
163 : 6031 : opts->udpserv_port = range_check(opts,
164 : : "UDPSERV_PORT", opts->config[CONF_UDPSERV_PORT],
165 : : 1, RCHK_MAX_UDPSERV_PORT);
166 : 6030 : opts->udpserv_select_timeout = range_check(opts,
167 : : "UDPSERV_SELECT_TIMEOUT", opts->config[CONF_UDPSERV_SELECT_TIMEOUT],
168 : : 1, RCHK_MAX_UDPSERV_SELECT_TIMEOUT);
169 : :
170 : : #if FIREWALL_IPFW
171 : : range_check(opts, "IPFW_START_RULE_NUM", opts->config[CONF_IPFW_START_RULE_NUM],
172 : : 0, RCHK_MAX_IPFW_START_RULE_NUM);
173 : : range_check(opts, "IPFW_MAX_RULES", opts->config[CONF_IPFW_MAX_RULES],
174 : : 1, RCHK_MAX_IPFW_MAX_RULES);
175 : : range_check(opts, "IPFW_ACTIVE_SET_NUM", opts->config[CONF_IPFW_ACTIVE_SET_NUM],
176 : : 0, RCHK_MAX_IPFW_SET_NUM);
177 : : range_check(opts, "IPFW_EXPIRE_SET_NUM", opts->config[CONF_IPFW_EXPIRE_SET_NUM],
178 : : 0, RCHK_MAX_IPFW_SET_NUM);
179 : : range_check(opts, "IPFW_EXPIRE_PURGE_INTERVAL",
180 : : opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL],
181 : : 1, RCHK_MAX_IPFW_PURGE_INTERVAL);
182 : :
183 : : /* Make sure the active and expire sets are not identical whenever
184 : : * they are non-zero
185 : : */
186 : : if((strtol_wrapper(opts->config[CONF_IPFW_ACTIVE_SET_NUM],
187 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err) > 0
188 : : && strtol_wrapper(opts->config[CONF_IPFW_EXPIRE_SET_NUM],
189 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err) > 0)
190 : : && strtol_wrapper(opts->config[CONF_IPFW_ACTIVE_SET_NUM],
191 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err)
192 : : == strtol_wrapper(opts->config[CONF_IPFW_EXPIRE_SET_NUM],
193 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err))
194 : : {
195 : : log_msg(LOG_ERR,
196 : : "[*] Cannot set identical ipfw active and expire sets.");
197 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
198 : : }
199 : :
200 : : if(is_err != FKO_SUCCESS)
201 : : {
202 : : log_msg(LOG_ERR, "[*] invalid integer conversion error.\n");
203 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
204 : : }
205 : :
206 : : #elif FIREWALL_PF
207 : : range_check(opts, "PF_EXPIRE_INTERVAL", opts->config[CONF_PF_EXPIRE_INTERVAL],
208 : : 1, RCHK_MAX_PF_EXPIRE_INTERVAL);
209 : :
210 : : #endif /* FIREWALL type */
211 : :
212 : 6030 : return;
213 : : }
214 : :
215 : : /**
216 : : * @brief Generate Rijndael + HMAC keys from /dev/urandom (base64 encoded).
217 : : *
218 : : * @param options FKO command line option structure
219 : : */
220 : : static void
221 : 103 : generate_keys(fko_srv_options_t *options)
222 : : {
223 : : char key_base64[MAX_B64_KEY_LEN+1];
224 : : char hmac_key_base64[MAX_B64_KEY_LEN+1];
225 : :
226 : 103 : FILE *key_gen_file_ptr = NULL;
227 : : int res;
228 : :
229 : : /* Set defaults and validate for --key-gen mode
230 : : */
231 [ + - ]: 103 : if(options->key_len == 0)
232 : 103 : options->key_len = FKO_DEFAULT_KEY_LEN;
233 : :
234 [ + - ]: 103 : if(options->hmac_key_len == 0)
235 : 103 : options->hmac_key_len = FKO_DEFAULT_HMAC_KEY_LEN;
236 : :
237 [ + - ]: 103 : if(options->hmac_type == 0)
238 : 103 : options->hmac_type = FKO_DEFAULT_HMAC_MODE;
239 : :
240 : : /* Zero out the key buffers */
241 : : memset(key_base64, 0x00, sizeof(key_base64));
242 : : memset(hmac_key_base64, 0x00, sizeof(hmac_key_base64));
243 : :
244 : : /* Generate the key through libfko */
245 : 103 : res = fko_key_gen(key_base64, options->key_len,
246 : : hmac_key_base64, options->hmac_key_len,
247 : : options->hmac_type);
248 : :
249 [ - + ]: 103 : if(res != FKO_SUCCESS)
250 : : {
251 : 0 : log_msg(LOG_ERR, "%s: fko_key_gen: Error %i - %s",
252 : : MY_NAME, res, fko_errstr(res));
253 : 0 : clean_exit(options, NO_FW_CLEANUP, EXIT_FAILURE);
254 : : }
255 : :
256 [ + + ]: 103 : if(options->key_gen_file[0] != '\0')
257 : : {
258 [ + + ]: 2 : if ((key_gen_file_ptr = fopen(options->key_gen_file, "w")) == NULL)
259 : : {
260 : 1 : log_msg(LOG_ERR, "Unable to create key gen file: %s: %s",
261 : 1 : options->key_gen_file, strerror(errno));
262 : 1 : clean_exit(options, NO_FW_CLEANUP, EXIT_FAILURE);
263 : : }
264 : : fprintf(key_gen_file_ptr, "KEY_BASE64: %s\nHMAC_KEY_BASE64: %s\n",
265 : : key_base64, hmac_key_base64);
266 : 1 : fclose(key_gen_file_ptr);
267 : 1 : fprintf(stdout, "[+] Wrote Rijndael and HMAC keys to: %s",
268 : : options->key_gen_file);
269 : : }
270 : : else
271 : : {
272 : 101 : fprintf(stdout, "KEY_BASE64: %s\nHMAC_KEY_BASE64: %s\n",
273 : : key_base64, hmac_key_base64);
274 : : }
275 : 102 : clean_exit(options, NO_FW_CLEANUP, EXIT_SUCCESS);
276 : 0 : }
277 : :
278 : : /* Parse the config file...
279 : : */
280 : : static void
281 : 13702 : parse_config_file(fko_srv_options_t *opts, const char *config_file)
282 : : {
283 : : FILE *cfile_ptr;
284 : 13702 : unsigned int numLines = 0;
285 : : unsigned int i, good_ent;
286 : : int cndx;
287 : :
288 : 13702 : char conf_line_buf[MAX_LINE_LEN] = {0};
289 : 13702 : char var[MAX_LINE_LEN] = {0};
290 : 13702 : char val[MAX_LINE_LEN] = {0};
291 : 13702 : char tmp1[MAX_LINE_LEN] = {0};
292 : 13702 : char tmp2[MAX_LINE_LEN] = {0};
293 : :
294 : : struct stat st;
295 : :
296 : : /* Make sure the config file exists.
297 : : */
298 [ + + ]: 13702 : if(stat(config_file, &st) != 0)
299 : : {
300 : 2 : log_msg(LOG_ERR, "[*] Config file: '%s' was not found.",
301 : : config_file);
302 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
303 : : }
304 : :
305 [ + + ]: 13700 : if(verify_file_perms_ownership(config_file) != 1)
306 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
307 : :
308 : : /* See the comment in the parse_access_file() function regarding security
309 : : * here relative to a TOCTOU bug flagged by Coverity.
310 : : */
311 [ + + ]: 13699 : if ((cfile_ptr = fopen(config_file, "r")) == NULL)
312 : : {
313 : 84 : log_msg(LOG_ERR, "[*] Could not open config file: %s",
314 : : config_file);
315 : 84 : perror(NULL);
316 : :
317 : 13699 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
318 : : }
319 : :
320 [ + + ]: 28038 : while ((fgets(conf_line_buf, MAX_LINE_LEN, cfile_ptr)) != NULL)
321 : : {
322 : 14423 : numLines++;
323 : 14423 : conf_line_buf[MAX_LINE_LEN-1] = '\0';
324 : :
325 : : /* Get past comments and empty lines (note: we only look at the
326 : : * first character.
327 : : */
328 [ + + ][ + - ]: 14423 : if(IS_EMPTY_LINE(conf_line_buf[0]))
[ + - ][ - + ]
329 : 13297 : continue;
330 : :
331 [ + + ]: 1126 : if(sscanf(conf_line_buf, "%s %[^;\n\r]", var, val) != 2)
332 : : {
333 : 2 : log_msg(LOG_ERR,
334 : : "*Invalid config file entry in %s at line %i.\n - '%s'",
335 : : config_file, numLines, conf_line_buf
336 : : );
337 : 2 : continue;
338 : : }
339 : :
340 : : good_ent = 0;
341 [ + + ]: 30381 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
342 : : {
343 [ + + ]: 30379 : if(CONF_VAR_IS(config_map[i], var))
344 : : {
345 : : /* First check to see if we need to do a varable expansion
346 : : * on this value. Note: this only supports one expansion and
347 : : * only if the value starts with the variable.
348 : : */
349 [ + + ]: 1122 : if(*val == '$')
350 : : {
351 [ + - ]: 6 : if(sscanf((val+1), "%[A-Z_]%s", tmp1, tmp2))
352 : : {
353 [ + + ]: 6 : if((cndx = config_entry_index(opts, tmp1)) >= 0)
354 : : {
355 : 2 : strlcpy(val, opts->config[cndx], sizeof(val));
356 : 2 : strlcat(val, tmp2, sizeof(val));
357 : : }
358 : : else
359 : : {
360 : : /* We didn't map the embedded variable to a valid
361 : : * config parameter
362 : : */
363 : 4 : log_msg(LOG_ERR,
364 : : "[*] Invalid embedded variable in: '%s'", val);
365 : 4 : break;
366 : : }
367 : : }
368 : : }
369 : :
370 : 1118 : set_config_entry(opts, i, val);
371 : 1118 : good_ent++;
372 : 1118 : break;
373 : : }
374 : : }
375 : :
376 [ + + ]: 1124 : if(good_ent == 0)
377 : 14423 : log_msg(LOG_ERR,
378 : : "[*] Ignoring unknown configuration parameter: '%s' in %s",
379 : : var, config_file
380 : : );
381 : : }
382 : :
383 : 13615 : fclose(cfile_ptr);
384 : :
385 : 13615 : return;
386 : : }
387 : :
388 : : /* Set defaults, and do sanity and bounds checks for the various options.
389 : : */
390 : : static void
391 : 6625 : validate_options(fko_srv_options_t *opts)
392 : : {
393 : 6625 : char tmp_path[MAX_PATH_LEN] = {0};
394 : :
395 : : /* If no conf dir is set in the config file, use the default.
396 : : */
397 [ + - ]: 6625 : if(opts->config[CONF_FWKNOP_CONF_DIR] == NULL)
398 : 6625 : set_config_entry(opts, CONF_FWKNOP_CONF_DIR, DEF_CONF_DIR);
399 : :
400 : : /* If no access.conf path was specified on the command line or set in
401 : : * the config file, use the default.
402 : : */
403 [ + + ]: 6599 : if(opts->config[CONF_ACCESS_FILE] == NULL)
404 : 2 : set_config_entry(opts, CONF_ACCESS_FILE, DEF_ACCESS_FILE);
405 : :
406 : : /* If the pid and digest cache files where not set in the config file or
407 : : * via command-line, then grab the defaults. Start with RUN_DIR as the
408 : : * files may depend on that.
409 : : */
410 [ + + ]: 6599 : if(opts->config[CONF_FWKNOP_RUN_DIR] == NULL)
411 : 6594 : set_config_entry(opts, CONF_FWKNOP_RUN_DIR, DEF_RUN_DIR);
412 : :
413 [ + + ]: 6570 : if(opts->config[CONF_FWKNOP_PID_FILE] == NULL)
414 : : {
415 : 37 : strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], sizeof(tmp_path));
416 : :
417 [ + - ]: 37 : if(tmp_path[strlen(tmp_path)-1] != '/')
418 : 37 : strlcat(tmp_path, "/", sizeof(tmp_path));
419 : :
420 : 37 : strlcat(tmp_path, DEF_PID_FILENAME, sizeof(tmp_path));
421 : :
422 : 37 : set_config_entry(opts, CONF_FWKNOP_PID_FILE, tmp_path);
423 : : }
424 : :
425 : : #if USE_FILE_CACHE
426 [ + + ]: 6570 : if(opts->config[CONF_DIGEST_FILE] == NULL)
427 : : #else
428 : : if(opts->config[CONF_DIGEST_DB_FILE] == NULL)
429 : : #endif
430 : : {
431 : 36 : strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], sizeof(tmp_path));
432 : :
433 [ + - ]: 36 : if(tmp_path[strlen(tmp_path)-1] != '/')
434 : 36 : strlcat(tmp_path, "/", sizeof(tmp_path));
435 : :
436 : : #if USE_FILE_CACHE
437 : 36 : strlcat(tmp_path, DEF_DIGEST_CACHE_FILENAME, sizeof(tmp_path));
438 : 36 : set_config_entry(opts, CONF_DIGEST_FILE, tmp_path);
439 : : #else
440 : : strlcat(tmp_path, DEF_DIGEST_CACHE_DB_FILENAME, sizeof(tmp_path));
441 : : set_config_entry(opts, CONF_DIGEST_DB_FILE, tmp_path);
442 : : #endif
443 : : }
444 : :
445 : : /* Set remaining require CONF_ vars if they are not already set. */
446 : :
447 : : /* PCAP capture interface - note that if '-r <pcap file>' is specified
448 : : * on the command line, then this will override the pcap interface setting.
449 : : */
450 [ + + ]: 6570 : if(opts->config[CONF_PCAP_INTF] == NULL)
451 : 4699 : set_config_entry(opts, CONF_PCAP_INTF, DEF_INTERFACE);
452 : :
453 : : /* PCAP Promiscuous mode.
454 : : */
455 [ + + ]: 6561 : if(opts->config[CONF_ENABLE_PCAP_PROMISC] == NULL)
456 : 6558 : set_config_entry(opts, CONF_ENABLE_PCAP_PROMISC,
457 : : DEF_ENABLE_PCAP_PROMISC);
458 : :
459 : : /* The packet count argument to pcap_dispatch()
460 : : */
461 [ + + ]: 6533 : if(opts->config[CONF_PCAP_DISPATCH_COUNT] == NULL)
462 : 6532 : set_config_entry(opts, CONF_PCAP_DISPATCH_COUNT,
463 : : DEF_PCAP_DISPATCH_COUNT);
464 : :
465 : : /* Microseconds to sleep between pcap loop iterations
466 : : */
467 [ + + ]: 6509 : if(opts->config[CONF_PCAP_LOOP_SLEEP] == NULL)
468 : 6508 : set_config_entry(opts, CONF_PCAP_LOOP_SLEEP,
469 : : DEF_PCAP_LOOP_SLEEP);
470 : :
471 : : /* Control whether to exit if the interface where we're sniffing
472 : : * goes down.
473 : : */
474 [ + + ]: 6477 : if(opts->config[CONF_EXIT_AT_INTF_DOWN] == NULL)
475 : 6476 : set_config_entry(opts, CONF_EXIT_AT_INTF_DOWN,
476 : : DEF_EXIT_AT_INTF_DOWN);
477 : :
478 : : /* PCAP Filter.
479 : : */
480 [ + + ]: 6453 : if(opts->config[CONF_PCAP_FILTER] == NULL)
481 : 6437 : set_config_entry(opts, CONF_PCAP_FILTER, DEF_PCAP_FILTER);
482 : :
483 : : /* Enable SPA packet aging unless we're getting packet data
484 : : * directly from a pcap file
485 : : */
486 [ + + ]: 6432 : if(opts->config[CONF_ENABLE_SPA_PACKET_AGING] == NULL)
487 : : {
488 [ + + ]: 6331 : if(opts->config[CONF_PCAP_FILE] == NULL)
489 : : {
490 : 6072 : set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING,
491 : : DEF_ENABLE_SPA_PACKET_AGING);
492 : : }
493 : : else
494 : : {
495 : 259 : set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING, "N");
496 : : }
497 : : }
498 : :
499 : : /* SPA packet age.
500 : : */
501 [ + - ]: 6401 : if(opts->config[CONF_MAX_SPA_PACKET_AGE] == NULL)
502 : 6401 : set_config_entry(opts, CONF_MAX_SPA_PACKET_AGE,
503 : : DEF_MAX_SPA_PACKET_AGE);
504 : :
505 : : /* Enable digest persistence.
506 : : */
507 [ + - ]: 6386 : if(opts->config[CONF_ENABLE_DIGEST_PERSISTENCE] == NULL)
508 : 6386 : set_config_entry(opts, CONF_ENABLE_DIGEST_PERSISTENCE,
509 : : DEF_ENABLE_DIGEST_PERSISTENCE);
510 : :
511 : : /* Set firewall rule "deep" collection interval - this allows
512 : : * fwknopd to remove rules with proper _exp_<time> expiration
513 : : * times even when added by a different program.
514 : : */
515 [ + - ]: 6357 : if(opts->config[CONF_RULES_CHECK_THRESHOLD] == NULL)
516 : 6357 : set_config_entry(opts, CONF_RULES_CHECK_THRESHOLD,
517 : : DEF_RULES_CHECK_THRESHOLD);
518 : :
519 : : /* Enable destination rule.
520 : : */
521 [ + + ]: 6333 : if(opts->config[CONF_ENABLE_DESTINATION_RULE] == NULL)
522 : 6324 : set_config_entry(opts, CONF_ENABLE_DESTINATION_RULE,
523 : : DEF_ENABLE_DESTINATION_RULE);
524 : :
525 : : /* Max sniff bytes.
526 : : */
527 [ + - ]: 6315 : if(opts->config[CONF_MAX_SNIFF_BYTES] == NULL)
528 : 6315 : set_config_entry(opts, CONF_MAX_SNIFF_BYTES, DEF_MAX_SNIFF_BYTES);
529 : :
530 : : #if FIREWALL_FIREWALLD
531 : : /* Enable FIREWD forwarding.
532 : : */
533 [ + + ]: 6297 : if(opts->config[CONF_ENABLE_FIREWD_FORWARDING] == NULL)
534 : 6090 : set_config_entry(opts, CONF_ENABLE_FIREWD_FORWARDING,
535 : : DEF_ENABLE_FIREWD_FORWARDING);
536 : :
537 : : /* Enable FIREWD local NAT.
538 : : */
539 [ + + ]: 6282 : if(opts->config[CONF_ENABLE_FIREWD_LOCAL_NAT] == NULL)
540 : 6223 : set_config_entry(opts, CONF_ENABLE_FIREWD_LOCAL_NAT,
541 : : DEF_ENABLE_FIREWD_LOCAL_NAT);
542 : :
543 : : /* Enable FIREWD SNAT.
544 : : */
545 [ + + ]: 6263 : if(opts->config[CONF_ENABLE_FIREWD_SNAT] == NULL)
546 : 6206 : set_config_entry(opts, CONF_ENABLE_FIREWD_SNAT,
547 : : DEF_ENABLE_FIREWD_SNAT);
548 : :
549 : : /* Make sure we have a valid IP if SNAT is enabled
550 : : */
551 [ + + ]: 6245 : if(strncasecmp(opts->config[CONF_ENABLE_FIREWD_SNAT], "Y", 1) == 0)
552 : : {
553 : : /* Note that fw_config_init() will set use_masquerade if necessary
554 : : */
555 [ + + ]: 57 : if(opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
556 : : {
557 [ + + ]: 24 : if(! is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP], strlen(opts->config[CONF_SNAT_TRANSLATE_IP])))
558 : : {
559 : 1 : log_msg(LOG_ERR,
560 : : "Invalid IPv4 addr for SNAT_TRANSLATE_IP"
561 : : );
562 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
563 : : }
564 : : }
565 : : }
566 : :
567 : : /* Enable FIREWD OUTPUT.
568 : : */
569 [ + + ]: 6244 : if(opts->config[CONF_ENABLE_FIREWD_OUTPUT] == NULL)
570 : 6243 : set_config_entry(opts, CONF_ENABLE_FIREWD_OUTPUT,
571 : : DEF_ENABLE_FIREWD_OUTPUT);
572 : :
573 : : /* Flush FIREWD at init.
574 : : */
575 [ + + ]: 6228 : if(opts->config[CONF_FLUSH_FIREWD_AT_INIT] == NULL)
576 : 6220 : set_config_entry(opts, CONF_FLUSH_FIREWD_AT_INIT, DEF_FLUSH_FIREWD_AT_INIT);
577 : :
578 : : /* Flush FIREWD at exit.
579 : : */
580 [ + + ]: 6216 : if(opts->config[CONF_FLUSH_FIREWD_AT_EXIT] == NULL)
581 : 6208 : set_config_entry(opts, CONF_FLUSH_FIREWD_AT_EXIT, DEF_FLUSH_FIREWD_AT_EXIT);
582 : :
583 : : /* FIREWD input access.
584 : : */
585 [ + + ]: 6201 : if(opts->config[CONF_FIREWD_INPUT_ACCESS] == NULL)
586 : 6186 : set_config_entry(opts, CONF_FIREWD_INPUT_ACCESS,
587 : : DEF_FIREWD_INPUT_ACCESS);
588 : :
589 [ + + ]: 6187 : if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_INPUT_ACCESS]) != 1)
590 : : {
591 : 3 : log_msg(LOG_ERR,
592 : : "Invalid FIREWD_INPUT_ACCESS specification, see fwknopd.conf comments"
593 : : );
594 : 3 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
595 : : }
596 : :
597 : : /* FIREWD output access.
598 : : */
599 [ + + ]: 6184 : if(opts->config[CONF_FIREWD_OUTPUT_ACCESS] == NULL)
600 : 6182 : set_config_entry(opts, CONF_FIREWD_OUTPUT_ACCESS,
601 : : DEF_FIREWD_OUTPUT_ACCESS);
602 : :
603 [ + + ]: 6174 : if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_OUTPUT_ACCESS]) != 1)
604 : : {
605 : 1 : log_msg(LOG_ERR,
606 : : "Invalid FIREWD_OUTPUT_ACCESS specification, see fwknopd.conf comments"
607 : : );
608 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
609 : : }
610 : :
611 : : /* FIREWD forward access.
612 : : */
613 [ + + ]: 6173 : if(opts->config[CONF_FIREWD_FORWARD_ACCESS] == NULL)
614 : 6169 : set_config_entry(opts, CONF_FIREWD_FORWARD_ACCESS,
615 : : DEF_FIREWD_FORWARD_ACCESS);
616 : :
617 [ + + ]: 6161 : if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_FORWARD_ACCESS]) != 1)
618 : : {
619 : 1 : log_msg(LOG_ERR,
620 : : "Invalid FIREWD_FORWARD_ACCESS specification, see fwknopd.conf comments"
621 : : );
622 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
623 : : }
624 : :
625 : : /* FIREWD dnat access.
626 : : */
627 [ + + ]: 6160 : if(opts->config[CONF_FIREWD_DNAT_ACCESS] == NULL)
628 : 6156 : set_config_entry(opts, CONF_FIREWD_DNAT_ACCESS,
629 : : DEF_FIREWD_DNAT_ACCESS);
630 : :
631 [ + + ]: 6148 : if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_DNAT_ACCESS]) != 1)
632 : : {
633 : 1 : log_msg(LOG_ERR,
634 : : "Invalid FIREWD_DNAT_ACCESS specification, see fwknopd.conf comments"
635 : : );
636 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
637 : : }
638 : :
639 : : /* FIREWD snat access.
640 : : */
641 [ + + ]: 6147 : if(opts->config[CONF_FIREWD_SNAT_ACCESS] == NULL)
642 : 6146 : set_config_entry(opts, CONF_FIREWD_SNAT_ACCESS,
643 : : DEF_FIREWD_SNAT_ACCESS);
644 : :
645 [ + + ]: 6133 : if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_SNAT_ACCESS]) != 1)
646 : : {
647 : 1 : log_msg(LOG_ERR,
648 : : "Invalid FIREWD_SNAT_ACCESS specification, see fwknopd.conf comments"
649 : : );
650 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
651 : : }
652 : :
653 : : /* FIREWD masquerade access.
654 : : */
655 [ + + ]: 6132 : if(opts->config[CONF_FIREWD_MASQUERADE_ACCESS] == NULL)
656 : 6131 : set_config_entry(opts, CONF_FIREWD_MASQUERADE_ACCESS,
657 : : DEF_FIREWD_MASQUERADE_ACCESS);
658 : :
659 [ + + ]: 6126 : if(validate_firewd_chain_conf(opts->config[CONF_FIREWD_MASQUERADE_ACCESS]) != 1)
660 : : {
661 : 1 : log_msg(LOG_ERR,
662 : : "Invalid FIREWD_MASQUERADE_ACCESS specification, see fwknopd.conf comments"
663 : : );
664 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
665 : : }
666 : :
667 : : /* Check for the firewalld 'comment' match at init time
668 : : */
669 [ + - ]: 6125 : if(opts->config[CONF_ENABLE_FIREWD_COMMENT_CHECK] == NULL)
670 : 6125 : set_config_entry(opts, CONF_ENABLE_FIREWD_COMMENT_CHECK,
671 : : DEF_ENABLE_FIREWD_COMMENT_CHECK);
672 : :
673 : : #elif FIREWALL_IPTABLES
674 : : /* Enable IPT forwarding.
675 : : */
676 : : if(opts->config[CONF_ENABLE_IPT_FORWARDING] == NULL)
677 : : set_config_entry(opts, CONF_ENABLE_IPT_FORWARDING,
678 : : DEF_ENABLE_IPT_FORWARDING);
679 : :
680 : : /* Enable IPT local NAT.
681 : : */
682 : : if(opts->config[CONF_ENABLE_IPT_LOCAL_NAT] == NULL)
683 : : set_config_entry(opts, CONF_ENABLE_IPT_LOCAL_NAT,
684 : : DEF_ENABLE_IPT_LOCAL_NAT);
685 : :
686 : : /* Enable IPT SNAT.
687 : : */
688 : : if(opts->config[CONF_ENABLE_IPT_SNAT] == NULL)
689 : : set_config_entry(opts, CONF_ENABLE_IPT_SNAT,
690 : : DEF_ENABLE_IPT_SNAT);
691 : :
692 : : /* Make sure we have a valid IP if SNAT is enabled
693 : : */
694 : : if(strncasecmp(opts->config[CONF_ENABLE_IPT_SNAT], "Y", 1) == 0)
695 : : {
696 : : /* Note that fw_config_init() will set use_masquerade if necessary
697 : : */
698 : : if(opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
699 : : {
700 : : if(! is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP], strlen(opts->config[CONF_SNAT_TRANSLATE_IP])))
701 : : {
702 : : log_msg(LOG_ERR,
703 : : "Invalid IPv4 addr for SNAT_TRANSLATE_IP"
704 : : );
705 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
706 : : }
707 : : }
708 : : }
709 : :
710 : : /* Enable IPT OUTPUT.
711 : : */
712 : : if(opts->config[CONF_ENABLE_IPT_OUTPUT] == NULL)
713 : : set_config_entry(opts, CONF_ENABLE_IPT_OUTPUT,
714 : : DEF_ENABLE_IPT_OUTPUT);
715 : :
716 : : /* Flush IPT at init.
717 : : */
718 : : if(opts->config[CONF_FLUSH_IPT_AT_INIT] == NULL)
719 : : set_config_entry(opts, CONF_FLUSH_IPT_AT_INIT, DEF_FLUSH_IPT_AT_INIT);
720 : :
721 : : /* Flush IPT at exit.
722 : : */
723 : : if(opts->config[CONF_FLUSH_IPT_AT_EXIT] == NULL)
724 : : set_config_entry(opts, CONF_FLUSH_IPT_AT_EXIT, DEF_FLUSH_IPT_AT_EXIT);
725 : :
726 : : /* IPT input access.
727 : : */
728 : : if(opts->config[CONF_IPT_INPUT_ACCESS] == NULL)
729 : : set_config_entry(opts, CONF_IPT_INPUT_ACCESS,
730 : : DEF_IPT_INPUT_ACCESS);
731 : :
732 : : if(validate_ipt_chain_conf(opts->config[CONF_IPT_INPUT_ACCESS]) != 1)
733 : : {
734 : : log_msg(LOG_ERR,
735 : : "Invalid IPT_INPUT_ACCESS specification, see fwknopd.conf comments"
736 : : );
737 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
738 : : }
739 : :
740 : : /* IPT output access.
741 : : */
742 : : if(opts->config[CONF_IPT_OUTPUT_ACCESS] == NULL)
743 : : set_config_entry(opts, CONF_IPT_OUTPUT_ACCESS,
744 : : DEF_IPT_OUTPUT_ACCESS);
745 : :
746 : : if(validate_ipt_chain_conf(opts->config[CONF_IPT_OUTPUT_ACCESS]) != 1)
747 : : {
748 : : log_msg(LOG_ERR,
749 : : "Invalid IPT_OUTPUT_ACCESS specification, see fwknopd.conf comments"
750 : : );
751 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
752 : : }
753 : :
754 : : /* IPT forward access.
755 : : */
756 : : if(opts->config[CONF_IPT_FORWARD_ACCESS] == NULL)
757 : : set_config_entry(opts, CONF_IPT_FORWARD_ACCESS,
758 : : DEF_IPT_FORWARD_ACCESS);
759 : :
760 : : if(validate_ipt_chain_conf(opts->config[CONF_IPT_FORWARD_ACCESS]) != 1)
761 : : {
762 : : log_msg(LOG_ERR,
763 : : "Invalid IPT_FORWARD_ACCESS specification, see fwknopd.conf comments"
764 : : );
765 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
766 : : }
767 : :
768 : : /* IPT dnat access.
769 : : */
770 : : if(opts->config[CONF_IPT_DNAT_ACCESS] == NULL)
771 : : set_config_entry(opts, CONF_IPT_DNAT_ACCESS,
772 : : DEF_IPT_DNAT_ACCESS);
773 : :
774 : : if(validate_ipt_chain_conf(opts->config[CONF_IPT_DNAT_ACCESS]) != 1)
775 : : {
776 : : log_msg(LOG_ERR,
777 : : "Invalid IPT_DNAT_ACCESS specification, see fwknopd.conf comments"
778 : : );
779 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
780 : : }
781 : :
782 : : /* IPT snat access.
783 : : */
784 : : if(opts->config[CONF_IPT_SNAT_ACCESS] == NULL)
785 : : set_config_entry(opts, CONF_IPT_SNAT_ACCESS,
786 : : DEF_IPT_SNAT_ACCESS);
787 : :
788 : : if(validate_ipt_chain_conf(opts->config[CONF_IPT_SNAT_ACCESS]) != 1)
789 : : {
790 : : log_msg(LOG_ERR,
791 : : "Invalid IPT_SNAT_ACCESS specification, see fwknopd.conf comments"
792 : : );
793 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
794 : : }
795 : :
796 : : /* IPT masquerade access.
797 : : */
798 : : if(opts->config[CONF_IPT_MASQUERADE_ACCESS] == NULL)
799 : : set_config_entry(opts, CONF_IPT_MASQUERADE_ACCESS,
800 : : DEF_IPT_MASQUERADE_ACCESS);
801 : :
802 : : if(validate_ipt_chain_conf(opts->config[CONF_IPT_MASQUERADE_ACCESS]) != 1)
803 : : {
804 : : log_msg(LOG_ERR,
805 : : "Invalid IPT_MASQUERADE_ACCESS specification, see fwknopd.conf comments"
806 : : );
807 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
808 : : }
809 : :
810 : : /* Check for the iptables 'comment' match at init time
811 : : */
812 : : if(opts->config[CONF_ENABLE_IPT_COMMENT_CHECK] == NULL)
813 : : set_config_entry(opts, CONF_ENABLE_IPT_COMMENT_CHECK,
814 : : DEF_ENABLE_IPT_COMMENT_CHECK);
815 : :
816 : : #elif FIREWALL_IPFW
817 : :
818 : : /* Flush ipfw rules at init.
819 : : */
820 : : if(opts->config[CONF_FLUSH_IPFW_AT_INIT] == NULL)
821 : : set_config_entry(opts, CONF_FLUSH_IPFW_AT_INIT, DEF_FLUSH_IPFW_AT_INIT);
822 : :
823 : : /* Flush ipfw rules at exit.
824 : : */
825 : : if(opts->config[CONF_FLUSH_IPFW_AT_EXIT] == NULL)
826 : : set_config_entry(opts, CONF_FLUSH_IPFW_AT_EXIT, DEF_FLUSH_IPFW_AT_EXIT);
827 : :
828 : : /* Set IPFW start rule number.
829 : : */
830 : : if(opts->config[CONF_IPFW_START_RULE_NUM] == NULL)
831 : : set_config_entry(opts, CONF_IPFW_START_RULE_NUM,
832 : : DEF_IPFW_START_RULE_NUM);
833 : :
834 : : /* Set IPFW max rules.
835 : : */
836 : : if(opts->config[CONF_IPFW_MAX_RULES] == NULL)
837 : : set_config_entry(opts, CONF_IPFW_MAX_RULES,
838 : : DEF_IPFW_MAX_RULES);
839 : :
840 : : /* Set IPFW active set number.
841 : : */
842 : : if(opts->config[CONF_IPFW_ACTIVE_SET_NUM] == NULL)
843 : : set_config_entry(opts, CONF_IPFW_ACTIVE_SET_NUM,
844 : : DEF_IPFW_ACTIVE_SET_NUM);
845 : :
846 : : /* Set IPFW expire set number.
847 : : */
848 : : if(opts->config[CONF_IPFW_EXPIRE_SET_NUM] == NULL)
849 : : set_config_entry(opts, CONF_IPFW_EXPIRE_SET_NUM,
850 : : DEF_IPFW_EXPIRE_SET_NUM);
851 : :
852 : : /* Set IPFW Dynamic rule expiry interval.
853 : : */
854 : : if(opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL] == NULL)
855 : : set_config_entry(opts, CONF_IPFW_EXPIRE_PURGE_INTERVAL,
856 : : DEF_IPFW_EXPIRE_PURGE_INTERVAL);
857 : :
858 : : /* Set IPFW Dynamic rule expiry interval.
859 : : */
860 : : if(opts->config[CONF_IPFW_ADD_CHECK_STATE] == NULL)
861 : : set_config_entry(opts, CONF_IPFW_ADD_CHECK_STATE,
862 : : DEF_IPFW_ADD_CHECK_STATE);
863 : :
864 : : #elif FIREWALL_PF
865 : : /* Set PF anchor name
866 : : */
867 : : if(opts->config[CONF_PF_ANCHOR_NAME] == NULL)
868 : : set_config_entry(opts, CONF_PF_ANCHOR_NAME,
869 : : DEF_PF_ANCHOR_NAME);
870 : :
871 : : /* Set PF rule expiry interval.
872 : : */
873 : : if(opts->config[CONF_PF_EXPIRE_INTERVAL] == NULL)
874 : : set_config_entry(opts, CONF_PF_EXPIRE_INTERVAL,
875 : : DEF_PF_EXPIRE_INTERVAL);
876 : :
877 : : #elif FIREWALL_IPF
878 : : /* --DSS Place-holder */
879 : :
880 : : #endif /* FIREWALL type */
881 : :
882 : : /* Disallow ENABLE_X_FORWARDED_FOR by default*/
883 [ + + ]: 6118 : if(opts->config[CONF_ENABLE_X_FORWARDED_FOR] == NULL)
884 : 6117 : set_config_entry(opts, CONF_ENABLE_X_FORWARDED_FOR, DEF_ENABLE_X_FORWARDED_FOR);
885 : :
886 : : /* Prepend firewall rules*/
887 [ + + ]: 6112 : if(opts->config[CONF_ENABLE_RULE_PREPEND] == NULL)
888 : 6111 : set_config_entry(opts, CONF_ENABLE_RULE_PREPEND, DEF_ENABLE_RULE_PREPEND);
889 : :
890 : : /* NAT DNS enabled*/
891 [ + + ]: 6106 : if(opts->config[CONF_ENABLE_NAT_DNS] == NULL)
892 : 6093 : set_config_entry(opts, CONF_ENABLE_NAT_DNS, DEF_ENABLE_NAT_DNS);
893 : :
894 : : /* GPG Home dir.
895 : : */
896 [ + + ]: 6097 : if(opts->config[CONF_GPG_HOME_DIR] == NULL)
897 : 6096 : set_config_entry(opts, CONF_GPG_HOME_DIR, DEF_GPG_HOME_DIR);
898 : :
899 : : /* GPG executable
900 : : */
901 [ + - ]: 6092 : if(opts->config[CONF_GPG_EXE] == NULL)
902 : 6092 : set_config_entry(opts, CONF_GPG_EXE, DEF_GPG_EXE);
903 : :
904 : : /* sudo executable
905 : : */
906 [ + + ]: 6087 : if(opts->config[CONF_SUDO_EXE] == NULL)
907 : 6078 : set_config_entry(opts, CONF_SUDO_EXE, DEF_SUDO_EXE);
908 : :
909 : : /* Enable SPA over HTTP.
910 : : */
911 [ + + ]: 6082 : if(opts->config[CONF_ENABLE_SPA_OVER_HTTP] == NULL)
912 : 6080 : set_config_entry(opts, CONF_ENABLE_SPA_OVER_HTTP,
913 : : DEF_ENABLE_SPA_OVER_HTTP);
914 : :
915 : : /* Enable TCP server.
916 : : */
917 [ + + ]: 6071 : if(opts->config[CONF_ENABLE_TCP_SERVER] == NULL)
918 : 6069 : set_config_entry(opts, CONF_ENABLE_TCP_SERVER, DEF_ENABLE_TCP_SERVER);
919 : :
920 : : /* TCP Server port.
921 : : */
922 [ + + ]: 6068 : if(opts->config[CONF_TCPSERV_PORT] == NULL)
923 : 6065 : set_config_entry(opts, CONF_TCPSERV_PORT, DEF_TCPSERV_PORT);
924 : :
925 : : #if USE_LIBNETFILTER_QUEUE
926 : : /* Enable NFQ Capture
927 : : */
928 : : if(opts->config[CONF_ENABLE_NFQ_CAPTURE] == NULL)
929 : : set_config_entry(opts, CONF_ENABLE_NFQ_CAPTURE, DEF_ENABLE_NFQ_CAPTURE);
930 : :
931 : : if((strncasecmp(opts->config[CONF_ENABLE_NFQ_CAPTURE], "Y", 1) == 0) &&
932 : : !opts->enable_nfq_capture)
933 : : {
934 : : opts->enable_nfq_capture = 1;
935 : : }
936 : :
937 : : /* NFQ Interface
938 : : */
939 : : if(opts->config[CONF_NFQ_INTERFACE] == NULL)
940 : : set_config_entry(opts, CONF_NFQ_INTERFACE, DEF_NFQ_INTERFACE);
941 : :
942 : : /* NFQ port.
943 : : */
944 : : if(opts->config[CONF_NFQ_PORT] == NULL)
945 : : set_config_entry(opts, CONF_NFQ_PORT, DEF_NFQ_PORT);
946 : :
947 : : /* NFQ Queue Number
948 : : */
949 : : if(opts->config[CONF_NFQ_QUEUE_NUMBER] == NULL)
950 : : set_config_entry(opts, CONF_NFQ_QUEUE_NUMBER,
951 : : DEF_NFQ_QUEUE_NUMBER);
952 : :
953 : : /* NFQ Chain
954 : : */
955 : : if(opts->config[CONF_NFQ_CHAIN] == NULL)
956 : : set_config_entry(opts, CONF_NFQ_CHAIN, DEF_NFQ_CHAIN);
957 : :
958 : : /* NFQ Table
959 : : */
960 : : if(opts->config[CONF_NFQ_TABLE] == NULL)
961 : : set_config_entry(opts, CONF_NFQ_TABLE, DEF_NFQ_TABLE);
962 : :
963 : : /* NFQ loop delay
964 : : */
965 : : if(opts->config[CONF_NFQ_LOOP_SLEEP] == NULL)
966 : : set_config_entry(opts, CONF_NFQ_LOOP_SLEEP, DEF_CONF_NFQ_LOOP_SLEEP);
967 : : #endif
968 : :
969 : : /* Enable UDP server.
970 : : */
971 [ + + ]: 6058 : if(opts->config[CONF_ENABLE_UDP_SERVER] == NULL)
972 : : {
973 [ - + ][ # # ]: 6056 : if((strncasecmp(DEF_ENABLE_UDP_SERVER, "Y", 1) == 0) &&
974 : 0 : !opts->enable_udp_server)
975 : : {
976 : 0 : log_msg(LOG_ERR, "pcap capture not compiled in, forcing UDP server mode");
977 : 0 : opts->enable_udp_server = 1;
978 : : }
979 : 6056 : set_config_entry(opts, CONF_ENABLE_UDP_SERVER, DEF_ENABLE_UDP_SERVER);
980 : : }
981 : :
982 : : /* UDP Server port.
983 : : */
984 [ + + ]: 6051 : if(opts->config[CONF_UDPSERV_PORT] == NULL)
985 : 6048 : set_config_entry(opts, CONF_UDPSERV_PORT, DEF_UDPSERV_PORT);
986 : :
987 : : /* UDP server select() timeout in microseconds
988 : : */
989 [ + - ]: 6047 : if(opts->config[CONF_UDPSERV_SELECT_TIMEOUT] == NULL)
990 : 6047 : set_config_entry(opts, CONF_UDPSERV_SELECT_TIMEOUT,
991 : : DEF_UDPSERV_SELECT_TIMEOUT);
992 : :
993 : : /* Syslog identity.
994 : : */
995 [ + - ]: 6039 : if(opts->config[CONF_SYSLOG_IDENTITY] == NULL)
996 : 6039 : set_config_entry(opts, CONF_SYSLOG_IDENTITY, DEF_SYSLOG_IDENTITY);
997 : :
998 : : /* Syslog facility.
999 : : */
1000 [ + + ]: 6037 : if(opts->config[CONF_SYSLOG_FACILITY] == NULL)
1001 : 6027 : set_config_entry(opts, CONF_SYSLOG_FACILITY, DEF_SYSLOG_FACILITY);
1002 : :
1003 : :
1004 : : /* Validate integer variable ranges
1005 : : */
1006 : 6034 : validate_int_var_ranges(opts);
1007 : :
1008 : : /* Some options just trigger some output of information, or trigger an
1009 : : * external function, but do not actually start fwknopd. If any of those
1010 : : * are set, we can return here an skip the validation routines as all
1011 : : * other options will be ignored anyway.
1012 : : *
1013 : : * These are also mutually exclusive (for now).
1014 : : */
1015 [ + + ]: 6030 : if((opts->dump_config + opts->kill + opts->restart + opts->status) == 1)
1016 : : return;
1017 : :
1018 [ + + ]: 4645 : if((opts->dump_config + opts->kill + opts->restart + opts->status) > 1)
1019 : : {
1020 : 2 : log_msg(LOG_ERR,
1021 : : "The -D, -K, -R, and -S options are mutually exclusive. Pick only one."
1022 : : );
1023 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1024 : : }
1025 : :
1026 [ - + ]: 4643 : if(opts->config[CONF_FIREWALL_EXE] == NULL)
1027 : : {
1028 : 0 : log_msg(LOG_ERR,
1029 : : "[*] No firewall command executable is set. Please check FIREWALL_EXE in fwknopd.conf."
1030 : : );
1031 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1032 : : }
1033 : :
1034 : : return;
1035 : : }
1036 : :
1037 : : void
1038 : 7120 : set_preconfig_entries(fko_srv_options_t *opts)
1039 : : {
1040 : : /* First, set any default or otherwise static settings here. Some may
1041 : : * end up being overwritten via config file or command-line.
1042 : : */
1043 : :
1044 : : /* Setup the firewall executable based on build-time info.
1045 : : * --DSS Note: We will want to either force external script mode, or
1046 : : * error out if we do not have a firewall executable defined.
1047 : : */
1048 : : #ifdef FIREWALL_EXE
1049 : 7120 : set_config_entry(opts, CONF_FIREWALL_EXE, FIREWALL_EXE);
1050 : : #endif
1051 : :
1052 : 7071 : }
1053 : :
1054 : : /* Initialize program configuration via config file and/or command-line
1055 : : * switches.
1056 : : */
1057 : : void
1058 : 7120 : config_init(fko_srv_options_t *opts, int argc, char **argv)
1059 : : {
1060 : : int cmd_arg, index, is_err;
1061 : 7120 : unsigned char got_conf_file = 0, got_override_config = 0;
1062 : :
1063 : 7120 : char override_file[MAX_LINE_LEN] = {0};
1064 : : char *ndx, *cmrk;
1065 : :
1066 : : /* Zero out options and opts_track.
1067 : : */
1068 : : memset(opts, 0x00, sizeof(fko_srv_options_t));
1069 : :
1070 : : /* Set some preconfiguration options (i.e. build-time defaults)
1071 : : */
1072 : 7120 : set_preconfig_entries(opts);
1073 : :
1074 : : /* In case this is a re-config.
1075 : : */
1076 : 7071 : optind = 0;
1077 : :
1078 : : /* Enable access.conf parsing (in case this is a re-config)
1079 : : */
1080 : 7071 : enable_acc_stanzas_init();
1081 : :
1082 : : /* First, scan the command-line args to see if we are in key-generation
1083 : : * mode. This is independent of config parsing and other operations, so
1084 : : * it is done as the very first thing. Also handle printing of the fwknop
1085 : : * version string since we don't need to parse a config for this.
1086 : : */
1087 [ + + ]: 59936 : while ((cmd_arg = getopt_long(argc, argv,
1088 : : GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
1089 : :
1090 [ + + + + : 45798 : switch(cmd_arg) {
+ + + ]
1091 : : case 'V':
1092 : 1 : fprintf(stdout, "fwknopd server %s, compiled for firewall bin: %s\n",
1093 : : MY_VERSION, FIREWALL_EXE);
1094 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
1095 : : case 'k':
1096 : 106 : opts->key_gen = 1;
1097 : 106 : break;
1098 : : case KEY_GEN_FILE:
1099 : 2 : opts->key_gen = 1;
1100 : 2 : strlcpy(opts->key_gen_file, optarg, sizeof(opts->key_gen_file));
1101 : 2 : break;
1102 : : case KEY_LEN: /* used in --key-gen mode only */
1103 : 1 : opts->key_len = strtol_wrapper(optarg, 1,
1104 : : MAX_KEY_LEN, NO_EXIT_UPON_ERR, &is_err);
1105 [ + - ]: 1 : if(is_err != FKO_SUCCESS)
1106 : : {
1107 : 1 : log_msg(LOG_ERR,
1108 : : "Invalid key length '%s', must be in [%d-%d]",
1109 : : optarg, 1, MAX_KEY_LEN);
1110 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1111 : : }
1112 : : break;
1113 : : case HMAC_DIGEST_TYPE: /* used in --key-gen mode only */
1114 [ + - ]: 1 : if((opts->hmac_type = hmac_digest_strtoint(optarg)) < 0)
1115 : : {
1116 : 1 : log_msg(LOG_ERR,
1117 : : "* Invalid hmac digest type: %s, use {md5,sha1,sha256,sha384,sha512}",
1118 : : optarg);
1119 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1120 : : }
1121 : : break;
1122 : : case HMAC_KEY_LEN: /* used in --key-gen mode only */
1123 : 1 : opts->hmac_key_len = strtol_wrapper(optarg, 1,
1124 : : MAX_KEY_LEN, NO_EXIT_UPON_ERR, &is_err);
1125 [ + - ]: 1 : if(is_err != FKO_SUCCESS)
1126 : : {
1127 : 1 : log_msg(LOG_ERR,
1128 : : "Invalid hmac key length '%s', must be in [%d-%d]",
1129 : : optarg, 1, MAX_KEY_LEN);
1130 : 7180 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1131 : : }
1132 : : break;
1133 : : }
1134 : : }
1135 : :
1136 [ + + ]: 7067 : if(opts->key_gen)
1137 : 103 : generate_keys(opts); /* this function exits */
1138 : :
1139 : : /* Reset the options index so we can run through them again.
1140 : : */
1141 : 6964 : optind = 0;
1142 : :
1143 : : /* Now, scan the command-line args for -h/--help or an alternate
1144 : : * configuration file. If we find an alternate config file, use it,
1145 : : * otherwise use the default. We also grab any override config files
1146 : : * as well. In addition, we handle key generation here since this is
1147 : : * independent of configuration parsing.
1148 : : */
1149 [ + + ]: 58718 : while ((cmd_arg = getopt_long(argc, argv,
1150 : : GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
1151 : :
1152 : : /* If help is wanted, give it and exit.
1153 : : */
1154 [ + + + + ]: 44882 : switch(cmd_arg) {
1155 : : case 'h':
1156 : 1 : usage();
1157 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
1158 : :
1159 : : /* Look for configuration file arg.
1160 : : */
1161 : : case 'c':
1162 : 6962 : set_config_entry(opts, CONF_CONFIG_FILE, optarg);
1163 : 6901 : got_conf_file++;
1164 : :
1165 : : /* If we already have the config_override option, we are done.
1166 : : */
1167 [ + - ]: 6901 : if(got_override_config > 0)
1168 : : break;
1169 : :
1170 : : /* Look for override configuration file arg.
1171 : : */
1172 : : case 'O':
1173 : 6903 : set_config_entry(opts, CONF_OVERRIDE_CONFIG, optarg);
1174 : 13837 : got_override_config++;
1175 : :
1176 : : /* If we already have the conf_file option, we are done.
1177 : : */
1178 : : if(got_conf_file > 0)
1179 : : break;
1180 : : }
1181 : : }
1182 : :
1183 : : /* If no alternate configuration file was specified, we use the
1184 : : * default.
1185 : : */
1186 [ + + ]: 6872 : if(opts->config[CONF_CONFIG_FILE] == NULL)
1187 : 1 : set_config_entry(opts, CONF_CONFIG_FILE, DEF_CONFIG_FILE);
1188 : :
1189 : : /* Parse configuration file to populate any params not already specified
1190 : : * via command-line options.
1191 : : */
1192 : 6872 : parse_config_file(opts, opts->config[CONF_CONFIG_FILE]);
1193 : :
1194 : : /* If there are override configuration entries, process them
1195 : : * here.
1196 : : */
1197 [ + + ]: 6830 : if(opts->config[CONF_OVERRIDE_CONFIG] != NULL)
1198 : : {
1199 : : /* Make a copy of the override_config string so we can munge it.
1200 : : */
1201 : 6829 : strlcpy(override_file, opts->config[CONF_OVERRIDE_CONFIG], sizeof(override_file));
1202 : :
1203 : 6829 : ndx = override_file;
1204 : 6829 : cmrk = strchr(ndx, ',');
1205 : :
1206 [ + + ]: 6829 : if(cmrk == NULL)
1207 : : {
1208 : : /* Only one to process...
1209 : : */
1210 : 6828 : parse_config_file(opts, ndx);
1211 : :
1212 : : } else {
1213 : : /* Walk the string pulling the next config override
1214 : : * at the comma delimiters.
1215 : : */
1216 [ + + ]: 2 : while(cmrk != NULL) {
1217 : 1 : *cmrk = '\0';
1218 : 1 : parse_config_file(opts, ndx);
1219 : 1 : ndx = cmrk + 1;
1220 : 1 : cmrk = strchr(ndx, ',');
1221 : : }
1222 : :
1223 : : /* Process the last entry
1224 : : */
1225 : 1 : parse_config_file(opts, ndx);
1226 : : }
1227 : : }
1228 : :
1229 : : /* Set up the verbosity level according to the value found in the
1230 : : * config files */
1231 [ + + ]: 6785 : if (opts->config[CONF_VERBOSE] != NULL)
1232 : : {
1233 : 1 : opts->verbose = strtol_wrapper(opts->config[CONF_VERBOSE], 0, -1,
1234 : : NO_EXIT_UPON_ERR, &is_err);
1235 [ + - ]: 1 : if(is_err != FKO_SUCCESS)
1236 : : {
1237 : 1 : log_msg(LOG_ERR, "[*] VERBOSE value '%s' not in the range (>0)",
1238 : : opts->config[CONF_VERBOSE]);
1239 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1240 : : }
1241 : : }
1242 : :
1243 : : /* Reset the options index so we can run through them again.
1244 : : */
1245 : 6784 : optind = 0;
1246 : :
1247 : : /* Last, but not least, we process command-line options (some of which
1248 : : * may override configuration file options.
1249 : : */
1250 [ + + ]: 56433 : while ((cmd_arg = getopt_long(argc, argv,
1251 : : GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
1252 : :
1253 [ + - + + : 43024 : switch(cmd_arg) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + -
+ + + + +
+ + + ]
1254 : : case 'A':
1255 : : #if AFL_FUZZING
1256 : : opts->afl_fuzzing = 1;
1257 : : #else
1258 : 1 : log_msg(LOG_ERR, "[*] fwknopd not compiled with AFL fuzzing support");
1259 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1260 : : #endif
1261 : 0 : break;
1262 : : case AFL_PKT_FILE:
1263 : : #if AFL_FUZZING
1264 : : opts->afl_fuzzing = 1;
1265 : : set_config_entry(opts, CONF_AFL_PKT_FILE, optarg);
1266 : : #else
1267 : 0 : log_msg(LOG_ERR, "[*] fwknopd not compiled with AFL fuzzing support");
1268 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1269 : : #endif
1270 : 0 : break;
1271 : : case 'a':
1272 [ + + ]: 6776 : if (is_valid_file(optarg))
1273 : 6775 : set_config_entry(opts, CONF_ACCESS_FILE, optarg);
1274 : : else
1275 : : {
1276 : 1 : log_msg(LOG_ERR,
1277 : : "[*] Invalid access.conf file path '%s'", optarg);
1278 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1279 : : }
1280 : : break;
1281 : : case ACCESS_FOLDER:
1282 : 7 : chop_char(optarg, PATH_SEP);
1283 [ + + ]: 7 : if (is_valid_dir(optarg))
1284 : 2 : set_config_entry(opts, CONF_ACCESS_FOLDER, optarg);
1285 : : else
1286 : : {
1287 : 5 : log_msg(LOG_ERR,
1288 : : "[*] Invalid access folder directory '%s' could not lstat(), does not exist, or too large?",
1289 : : optarg);
1290 : 5 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1291 : : }
1292 : : break;
1293 : : case 'c':
1294 : : /* This was handled earlier */
1295 : : break;
1296 : : case 'C':
1297 : 407 : opts->packet_ctr_limit = strtol_wrapper(optarg,
1298 : : 0, (2 << 30), NO_EXIT_UPON_ERR, &is_err);
1299 [ + + ]: 407 : if(is_err != FKO_SUCCESS)
1300 : : {
1301 : 1 : log_msg(LOG_ERR,
1302 : : "[*] invalid -C packet count limit '%s'",
1303 : : optarg);
1304 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1305 : : }
1306 : : break;
1307 : : case 'd':
1308 : : #if USE_FILE_CACHE
1309 : 6702 : set_config_entry(opts, CONF_DIGEST_FILE, optarg);
1310 : : #else
1311 : : set_config_entry(opts, CONF_DIGEST_DB_FILE, optarg);
1312 : : #endif
1313 : 6657 : break;
1314 : : case 'D':
1315 : 39 : opts->dump_config = 1;
1316 : 39 : break;
1317 : : case DUMP_SERVER_ERR_CODES:
1318 : 1 : dump_server_errors();
1319 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
1320 : : case EXIT_AFTER_PARSE_CONFIG:
1321 : 1388 : opts->exit_after_parse_config = 1;
1322 : 1388 : opts->foreground = 1;
1323 : 1388 : break;
1324 : : case EXIT_VALIDATE_DIGEST_CACHE:
1325 : 2 : opts->exit_parse_digest_cache = 1;
1326 : 2 : opts->foreground = 1;
1327 : 2 : break;
1328 : : case 'f':
1329 : 2260 : opts->foreground = 1;
1330 : 2260 : break;
1331 : : case FAULT_INJECTION_TAG:
1332 : : #if HAVE_LIBFIU
1333 : 36 : set_config_entry(opts, CONF_FAULT_INJECTION_TAG, optarg);
1334 : : #else
1335 : : log_msg(LOG_ERR, "[*] fwknopd not compiled with libfiu support");
1336 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1337 : : #endif
1338 : 36 : break;
1339 : : case FW_LIST:
1340 : 2980 : opts->fw_list = 1;
1341 : 2980 : break;
1342 : : case FW_LIST_ALL:
1343 : 2 : opts->fw_list = 1;
1344 : 2 : opts->fw_list_all = 1;
1345 : 2 : break;
1346 : : case FW_FLUSH:
1347 : 19 : opts->fw_flush = 1;
1348 : 19 : break;
1349 : : case GPG_EXE_PATH:
1350 [ - + ]: 1 : if (is_valid_exe(optarg))
1351 : 0 : set_config_entry(opts, CONF_GPG_EXE, optarg);
1352 : : else
1353 : : {
1354 : 1 : log_msg(LOG_ERR,
1355 : : "[*] gpg path '%s' could not lstat()/not executable?",
1356 : : optarg);
1357 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1358 : : }
1359 : : break;
1360 : : case GPG_HOME_DIR:
1361 : 3 : chop_char(optarg, PATH_SEP);
1362 [ + + ]: 3 : if (is_valid_dir(optarg))
1363 : 1 : set_config_entry(opts, CONF_GPG_HOME_DIR, optarg);
1364 : : else
1365 : : {
1366 : 2 : log_msg(LOG_ERR,
1367 : : "[*] gpg home directory '%s' could not lstat(), does not exist, or too large?",
1368 : : optarg);
1369 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1370 : : }
1371 : : break;
1372 : : case 'i':
1373 : 1919 : set_config_entry(opts, CONF_PCAP_INTF, optarg);
1374 : 1905 : break;
1375 : : case FIREWD_DISABLE_CHECK_SUPPORT:
1376 : 9 : opts->firewd_disable_check_support = 1;
1377 : 9 : break;
1378 : : case IPT_DISABLE_CHECK_SUPPORT:
1379 : 354 : opts->ipt_disable_check_support = 1;
1380 : 354 : break;
1381 : : case 'K':
1382 : 455 : opts->kill = 1;
1383 : 455 : break;
1384 : : case 'l':
1385 : 2 : set_config_entry(opts, CONF_LOCALE, optarg);
1386 : 2 : break;
1387 : : #if USE_LIBNETFILTER_QUEUE
1388 : : case 'n':
1389 : : opts->enable_nfq_capture = 1;
1390 : : break;
1391 : : #endif
1392 : : case 'O':
1393 : : /* This was handled earlier */
1394 : : break;
1395 : : case 'p':
1396 : 6655 : set_config_entry(opts, CONF_FWKNOP_PID_FILE, optarg);
1397 : 6630 : break;
1398 : : case 'P':
1399 : 8 : set_config_entry(opts, CONF_PCAP_FILTER, optarg);
1400 : 8 : break;
1401 : : case PCAP_FILE:
1402 [ + - ]: 370 : if (is_valid_file(optarg))
1403 : 370 : set_config_entry(opts, CONF_PCAP_FILE, optarg);
1404 : : else
1405 : : {
1406 : 0 : log_msg(LOG_ERR,
1407 : : "[*] Invalid pcap file path '%s'", optarg);
1408 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1409 : : }
1410 : : break;
1411 : : case ENABLE_PCAP_ANY_DIRECTION:
1412 : 1 : opts->pcap_any_direction = 1;
1413 : 1 : break;
1414 : : case ROTATE_DIGEST_CACHE:
1415 : 2 : opts->rotate_digest_cache = 1;
1416 : 2 : break;
1417 : : case 'R':
1418 : 3 : opts->restart = 1;
1419 : 3 : break;
1420 : : case 'r':
1421 : 0 : set_config_entry(opts, CONF_FWKNOP_RUN_DIR, optarg);
1422 : 0 : break;
1423 : : case 'S':
1424 : 892 : opts->status = 1;
1425 : 892 : break;
1426 : : case SUDO_EXE_PATH:
1427 [ + + ]: 11 : if (is_valid_exe(optarg))
1428 : 9 : set_config_entry(opts, CONF_SUDO_EXE, optarg);
1429 : : else
1430 : : {
1431 : 2 : log_msg(LOG_ERR,
1432 : : "[*] sudo path '%s' could not stat()/not executable?",
1433 : : optarg);
1434 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1435 : : }
1436 : : break;
1437 : : case 't':
1438 : 350 : opts->test = 1;
1439 : 350 : break;
1440 : : case 'U':
1441 : 11 : opts->enable_udp_server = 1;
1442 : 11 : break;
1443 : : /* Verbosity level */
1444 : : case 'v':
1445 : 4569 : opts->verbose++;
1446 : 4569 : break;
1447 : : case SYSLOG_ENABLE:
1448 : 2 : opts->syslog_enable = 1;
1449 : 2 : break;
1450 : : default:
1451 : 2 : usage();
1452 : 42866 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
1453 : : }
1454 : : }
1455 : :
1456 : : /* Now that we have all of our options set, and we are actually going to
1457 : : * start fwknopd, we can validate them.
1458 : : */
1459 : 6625 : validate_options(opts);
1460 : :
1461 : 6028 : return;
1462 : : }
1463 : :
1464 : : /* Dump the configuration
1465 : : */
1466 : : void
1467 : 523 : dump_config(const fko_srv_options_t *opts)
1468 : : {
1469 : : int i;
1470 : :
1471 : 523 : fprintf(stdout, "Current fwknopd config settings:\n");
1472 : :
1473 [ + + ]: 29288 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
1474 [ + + ]: 28765 : fprintf(stdout, "%3i. %-28s = '%s'\n",
1475 : : i,
1476 : : config_map[i],
1477 : 28765 : (opts->config[i] == NULL) ? "<not set>" : opts->config[i]
1478 : : );
1479 : :
1480 : 523 : fprintf(stdout, "\n");
1481 : 523 : fflush(stdout);
1482 : 523 : }
1483 : :
1484 : : /* Print usage message...
1485 : : */
1486 : : void
1487 : 3 : usage(void)
1488 : : {
1489 : 3 : fprintf(stdout, "\n%s server version %s\n%s - http://www.cipherdyne.org/fwknop/\n\n",
1490 : : MY_NAME, MY_VERSION, MY_DESC);
1491 : 3 : fprintf(stdout,
1492 : : "Usage: fwknopd [options]\n\n"
1493 : : " -a, --access-file - Specify an alternate access.conf file.\n"
1494 : : " --access-folder - Specify an access.conf folder. All .conf\n"
1495 : : " files in this folder will be processed.\n"
1496 : : " -c, --config-file - Specify an alternate configuration file.\n"
1497 : : " -f, --foreground - Run fwknopd in the foreground (do not become\n"
1498 : : " a background daemon).\n"
1499 : : " -i, --interface - Specify interface to listen for incoming SPA\n"
1500 : : " packets.\n"
1501 : : " -C, --packet-limit - Limit the number of candidate SPA packets to\n"
1502 : : " process and exit when this limit is reached.\n"
1503 : : " -d, --digest-file - Specify an alternate digest.cache file.\n"
1504 : : " -D, --dump-config - Dump the current fwknop configuration values.\n"
1505 : : " -K, --kill - Kill the currently running fwknopd.\n"
1506 : : " -l, --locale - Provide a locale setting other than the system\n"
1507 : : " default.\n"
1508 : : #if USE_LIBNETFILTER_QUEUE
1509 : : " -n, --nfq-capture - Capture packets using libnetfilter_queue (falls\n"
1510 : : " back to UDP server mode if not used).\n"
1511 : : #endif
1512 : : " -O, --override-config - Specify a file with configuration entries that will\n"
1513 : : " overide those in fwknopd.conf\n"
1514 : : " -p, --pid-file - Specify an alternate fwknopd.pid file.\n"
1515 : : " -P, --pcap-filter - Specify a Berkeley packet filter statement to\n"
1516 : : " override the PCAP_FILTER variable in fwknopd.conf.\n"
1517 : : " -R, --restart - Force the currently running fwknopd to restart.\n"
1518 : : " --rotate-digest-cache\n"
1519 : : " - Rotate the digest cache file by renaming the file\n"
1520 : : " to the same path with the -old suffix.\n"
1521 : : " -r, --run-dir - Set path to local state run directory.\n"
1522 : : " - Rotate the digest cache file by renaming it to\n"
1523 : : " '<name>-old', and starting a new one.\n"
1524 : : " -S, --status - Display the status of any running fwknopd process.\n"
1525 : : " -t, --test - Test mode, process SPA packets but do not make any\n"
1526 : : " firewall modifications.\n"
1527 : : " -U, --udp-server - Set UDP server mode.\n"
1528 : : " -v, --verbose - Set verbose mode.\n"
1529 : : " --syslog-enable - Allow messages to be sent to syslog even if the\n"
1530 : : " foreground mode is set.\n"
1531 : : " -V, --version - Print version number.\n"
1532 : : " -A, --afl-fuzzing - Run in American Fuzzy Lop (AFL) fuzzing mode so\n"
1533 : : " that plaintext SPA packets are accepted via stdin.\n"
1534 : : " -h, --help - Print this usage message and exit.\n"
1535 : : " --dump-serv-err-codes - List all server error codes (only needed by the\n"
1536 : : " test suite).\n"
1537 : : " --exit-parse-config - Parse config files and exit.\n"
1538 : : " --exit-parse-digest-cache - Parse and validate digest cache and exit.\n"
1539 : : " --fault-injection-tag - Enable a fault injection tag (only needed by the\n"
1540 : : " test suite).\n"
1541 : : " --pcap-file - Read potential SPA packets from an existing pcap\n"
1542 : : " file.\n"
1543 : : " --pcap-any-direction - By default fwknopd processes packets that are\n"
1544 : : " sent to the sniffing interface, but this option\n"
1545 : : " enables processing of packets that originate from\n"
1546 : : " an interface (such as in a forwarding situation).\n"
1547 : : " --fw-list - List all firewall rules that fwknop has created\n"
1548 : : " and then exit.\n"
1549 : : " --fw-list-all - List all firewall rules in the complete policy,\n"
1550 : : " including those that have nothing to do with\n"
1551 : : " fwknop.\n"
1552 : : " --fw-flush - Flush all firewall rules created by fwknop.\n"
1553 : : " --gpg-home-dir - Specify the GPG home directory (this is normally\n"
1554 : : " done in the access.conf file).\n"
1555 : : " --gpg-exe - Specify the path to GPG (this is normally done in\n"
1556 : : " the access.conf file).\n"
1557 : : " --sudo-exe - Specify the path to sudo (the default path is\n"
1558 : : " /usr/bin/sudo).\n"
1559 : : " --no-firewd-check-support\n"
1560 : : " - Disable test for 'firewall-cmd ... -C' support.\n"
1561 : : " --no-ipt-check-support - Disable test for 'iptables -C' support.\n"
1562 : : "\n"
1563 : : );
1564 : :
1565 : 3 : return;
1566 : : }
1567 : :
1568 : : /***EOF***/
|
