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_IPTABLES
40 : : #include "fw_util_iptables.h"
41 : : #endif
42 : :
43 : : /* Check to see if an integer variable has a value that is within a
44 : : * specific range
45 : : */
46 : : static void
47 : 14433 : range_check(fko_srv_options_t *opts, char *var, char *val, int low, int high)
48 : : {
49 : : int is_err;
50 : :
51 : 14433 : strtol_wrapper(val, low, high, NO_EXIT_UPON_ERR, &is_err);
52 [ + + ]: 14433 : if(is_err != FKO_SUCCESS)
53 : : {
54 : 1 : log_msg(LOG_ERR, "[*] var %s value '%s' not in the range %d-%d",
55 : : var, val, low, high);
56 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
57 : : }
58 : :
59 : 14432 : return;
60 : : }
61 : :
62 : : /* Take an index and a string value. malloc the space for the value
63 : : * and assign it to the array at the specified index.
64 : : */
65 : : static void
66 : 156419 : set_config_entry(fko_srv_options_t *opts, const int var_ndx, const char *value)
67 : : {
68 : : int space_needed;
69 : :
70 : : /* Sanity check the index value.
71 : : */
72 [ - + ]: 156419 : if(var_ndx < 0 || var_ndx >= NUMBER_OF_CONFIG_ENTRIES)
73 : : {
74 : 0 : log_msg(LOG_ERR, "[*] Index value of %i is not valid", var_ndx);
75 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
76 : : }
77 : :
78 : : /* If this particular entry was already set (i.e. not NULL), then
79 : : * assume it needs to be freed first.
80 : : */
81 [ + + ]: 156419 : if(opts->config[var_ndx] != NULL)
82 : 351 : free(opts->config[var_ndx]);
83 : :
84 : : /* If we are setting it to NULL, do it and be done.
85 : : */
86 [ - + ]: 156419 : if(value == NULL)
87 : : {
88 : 0 : opts->config[var_ndx] = NULL;
89 : 0 : return;
90 : : }
91 : :
92 : : /* Otherwise, make the space we need and set it.
93 : : */
94 : 156419 : space_needed = strlen(value) + 1;
95 : :
96 : 156419 : opts->config[var_ndx] = calloc(1, space_needed);
97 : :
98 [ + + ]: 156419 : if(opts->config[var_ndx] == NULL)
99 : : {
100 : 1539 : log_msg(LOG_ERR, "[*] Fatal memory allocation error!");
101 : 1539 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
102 : : }
103 : :
104 : 154880 : strlcpy(opts->config[var_ndx], value, space_needed);
105 : :
106 : 154880 : return;
107 : : }
108 : :
109 : : /* Given a config parameter name, return its index or -1 if not found.
110 : : */
111 : : static int
112 : 6 : config_entry_index(const fko_srv_options_t *opts, const char *var)
113 : : {
114 : : int i;
115 : :
116 [ + + ]: 250 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
117 [ + + ][ + + ]: 246 : if(opts->config[i] != NULL && CONF_VAR_IS(var, config_map[i]))
118 : : return(i);
119 : :
120 : : return(-1);
121 : : }
122 : :
123 : : /* Free the config memory
124 : : */
125 : : void
126 : 5315 : free_configs(fko_srv_options_t *opts)
127 : : {
128 : : int i;
129 : :
130 : 5315 : free_acc_stanzas(opts);
131 : :
132 [ + + ]: 239175 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
133 [ + + ]: 233860 : if(opts->config[i] != NULL)
134 : 154148 : free(opts->config[i]);
135 : 5315 : }
136 : :
137 : : static void
138 : 3609 : validate_int_var_ranges(fko_srv_options_t *opts)
139 : : {
140 : : #if FIREWALL_IPFW
141 : : int is_err = FKO_SUCCESS;
142 : : #endif
143 : :
144 : 3609 : range_check(opts, "PCAP_LOOP_SLEEP", opts->config[CONF_PCAP_LOOP_SLEEP],
145 : : 1, RCHK_MAX_PCAP_LOOP_SLEEP);
146 : 3608 : range_check(opts, "MAX_SPA_PACKET_AGE", opts->config[CONF_MAX_SPA_PACKET_AGE],
147 : : 1, RCHK_MAX_SPA_PACKET_AGE);
148 : 3608 : range_check(opts, "MAX_SNIFF_BYTES", opts->config[CONF_MAX_SNIFF_BYTES],
149 : : 1, RCHK_MAX_SNIFF_BYTES);
150 : 3608 : range_check(opts, "TCPSERV_PORT", opts->config[CONF_TCPSERV_PORT],
151 : : 1, RCHK_MAX_TCPSERV_PORT);
152 : :
153 : : #if FIREWALL_IPFW
154 : : range_check(opts, "IPFW_START_RULE_NUM", opts->config[CONF_IPFW_START_RULE_NUM],
155 : : 0, RCHK_MAX_IPFW_START_RULE_NUM);
156 : : range_check(opts, "IPFW_MAX_RULES", opts->config[CONF_IPFW_MAX_RULES],
157 : : 1, RCHK_MAX_IPFW_MAX_RULES);
158 : : range_check(opts, "IPFW_ACTIVE_SET_NUM", opts->config[CONF_IPFW_ACTIVE_SET_NUM],
159 : : 0, RCHK_MAX_IPFW_SET_NUM);
160 : : range_check(opts, "IPFW_EXPIRE_SET_NUM", opts->config[CONF_IPFW_EXPIRE_SET_NUM],
161 : : 0, RCHK_MAX_IPFW_SET_NUM);
162 : : range_check(opts, "IPFW_EXPIRE_PURGE_INTERVAL",
163 : : opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL],
164 : : 1, RCHK_MAX_IPFW_PURGE_INTERVAL);
165 : :
166 : : /* Make sure the active and expire sets are not identical whenever
167 : : * they are non-zero
168 : : */
169 : : if((strtol_wrapper(opts->config[CONF_IPFW_ACTIVE_SET_NUM],
170 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err) > 0
171 : : && strtol_wrapper(opts->config[CONF_IPFW_EXPIRE_SET_NUM],
172 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err) > 0)
173 : : && strtol_wrapper(opts->config[CONF_IPFW_ACTIVE_SET_NUM],
174 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err)
175 : : == strtol_wrapper(opts->config[CONF_IPFW_EXPIRE_SET_NUM],
176 : : 0, RCHK_MAX_IPFW_SET_NUM, NO_EXIT_UPON_ERR, &is_err))
177 : : {
178 : : log_msg(LOG_ERR,
179 : : "[*] Cannot set identical ipfw active and expire sets.");
180 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
181 : : }
182 : :
183 : : if(is_err != FKO_SUCCESS)
184 : : {
185 : : log_msg(LOG_ERR, "[*] invalid integer conversion error.\n");
186 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
187 : : }
188 : :
189 : : #elif FIREWALL_PF
190 : : range_check(opts, "PF_EXPIRE_INTERVAL", opts->config[CONF_PF_EXPIRE_INTERVAL],
191 : : 1, RCHK_MAX_PF_EXPIRE_INTERVAL);
192 : :
193 : : #endif /* FIREWALL type */
194 : :
195 : 3608 : return;
196 : : }
197 : :
198 : : /* Parse the config file...
199 : : */
200 : : static void
201 : 10005 : parse_config_file(fko_srv_options_t *opts, const char *config_file)
202 : : {
203 : : FILE *cfile_ptr;
204 : 10005 : unsigned int numLines = 0;
205 : : unsigned int i, good_ent;
206 : : int cndx;
207 : :
208 : 10005 : char conf_line_buf[MAX_LINE_LEN] = {0};
209 : 10005 : char var[MAX_LINE_LEN] = {0};
210 : 10005 : char val[MAX_LINE_LEN] = {0};
211 : 10005 : char tmp1[MAX_LINE_LEN] = {0};
212 : 10005 : char tmp2[MAX_LINE_LEN] = {0};
213 : :
214 : : struct stat st;
215 : :
216 : : /* Make sure the config file exists.
217 : : */
218 [ + + ]: 10005 : if(stat(config_file, &st) != 0)
219 : : {
220 : 2 : log_msg(LOG_ERR, "[*] Config file: '%s' was not found.",
221 : : config_file);
222 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
223 : : }
224 : :
225 [ - + ]: 10003 : if(verify_file_perms_ownership(config_file) != 1)
226 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
227 : :
228 : : /* See the comment in the parse_access_file() function regarding security
229 : : * here relative to a TOCTOU bug flagged by Coverity.
230 : : */
231 [ + + ]: 10003 : if ((cfile_ptr = fopen(config_file, "r")) == NULL)
232 : : {
233 : 158 : log_msg(LOG_ERR, "[*] Could not open config file: %s",
234 : : config_file);
235 : 158 : perror(NULL);
236 : :
237 : 10003 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
238 : : }
239 : :
240 [ + + ]: 20681 : while ((fgets(conf_line_buf, MAX_LINE_LEN, cfile_ptr)) != NULL)
241 : : {
242 : 10836 : numLines++;
243 : 10836 : conf_line_buf[MAX_LINE_LEN-1] = '\0';
244 : :
245 : : /* Get past comments and empty lines (note: we only look at the
246 : : * first character.
247 : : */
248 [ + + ][ + - ]: 10836 : if(IS_EMPTY_LINE(conf_line_buf[0]))
[ + - ][ - + ]
249 : 10130 : continue;
250 : :
251 [ + + ]: 706 : if(sscanf(conf_line_buf, "%s %[^;\n\r]", var, val) != 2)
252 : : {
253 : 2 : log_msg(LOG_ERR,
254 : : "*Invalid config file entry in %s at line %i.\n - '%s'",
255 : : config_file, numLines, conf_line_buf
256 : : );
257 : 2 : continue;
258 : : }
259 : :
260 : : good_ent = 0;
261 [ + - ]: 13861 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
262 : : {
263 [ + + ]: 13861 : if(CONF_VAR_IS(config_map[i], var))
264 : : {
265 : : /* First check to see if we need to do a varable expansion
266 : : * on this value. Note: this only supports one expansion and
267 : : * only if the value starts with the variable.
268 : : */
269 [ + + ]: 704 : if(*val == '$')
270 : : {
271 [ + - ]: 6 : if(sscanf((val+1), "%[A-Z_]%s", tmp1, tmp2))
272 : : {
273 [ + + ]: 6 : if((cndx = config_entry_index(opts, tmp1)) >= 0)
274 : : {
275 : 2 : strlcpy(val, opts->config[cndx], sizeof(val));
276 : 2 : strlcat(val, tmp2, sizeof(val));
277 : : }
278 : : else
279 : : {
280 : : /* We didn't map the embedded variable to a valid
281 : : * config parameter
282 : : */
283 : 4 : log_msg(LOG_ERR,
284 : : "[*] Invalid embedded variable in: '%s'", val);
285 : 4 : break;
286 : : }
287 : : }
288 : : }
289 : :
290 : 700 : set_config_entry(opts, i, val);
291 : 700 : good_ent++;
292 : 700 : break;
293 : : }
294 : : }
295 : :
296 [ + + ]: 704 : if(good_ent == 0)
297 : 10836 : log_msg(LOG_ERR,
298 : : "[*] Ignoring unknown configuration parameter: '%s' in %s",
299 : : var, config_file
300 : : );
301 : : }
302 : :
303 : 9845 : fclose(cfile_ptr);
304 : :
305 : 9845 : return;
306 : : }
307 : :
308 : : /* Set defaults, and do sanity and bounds checks for the various options.
309 : : */
310 : : static void
311 : 4624 : validate_options(fko_srv_options_t *opts)
312 : : {
313 : 4624 : char tmp_path[MAX_PATH_LEN] = {0};
314 : :
315 : : /* If no conf dir is set in the config file, use the default.
316 : : */
317 [ + - ]: 4624 : if(opts->config[CONF_FWKNOP_CONF_DIR] == NULL)
318 : 4624 : set_config_entry(opts, CONF_FWKNOP_CONF_DIR, DEF_CONF_DIR);
319 : :
320 : : /* If no access.conf path was specified on the command line or set in
321 : : * the config file, use the default.
322 : : */
323 [ - + ]: 4565 : if(opts->config[CONF_ACCESS_FILE] == NULL)
324 : 0 : set_config_entry(opts, CONF_ACCESS_FILE, DEF_ACCESS_FILE);
325 : :
326 : : /* If the pid and digest cache files where not set in the config file or
327 : : * via command-line, then grab the defaults. Start with RUN_DIR as the
328 : : * files may depend on that.
329 : : */
330 [ + + ]: 4565 : if(opts->config[CONF_FWKNOP_RUN_DIR] == NULL)
331 : 4561 : set_config_entry(opts, CONF_FWKNOP_RUN_DIR, DEF_RUN_DIR);
332 : :
333 [ + + ]: 4506 : if(opts->config[CONF_FWKNOP_PID_FILE] == NULL)
334 : : {
335 : 19 : strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], sizeof(tmp_path));
336 : :
337 [ + - ]: 19 : if(tmp_path[strlen(tmp_path)-1] != '/')
338 : 19 : strlcat(tmp_path, "/", sizeof(tmp_path));
339 : :
340 : 19 : strlcat(tmp_path, DEF_PID_FILENAME, sizeof(tmp_path));
341 : :
342 : 19 : set_config_entry(opts, CONF_FWKNOP_PID_FILE, tmp_path);
343 : : }
344 : :
345 : : #if USE_FILE_CACHE
346 [ + + ]: 4506 : if(opts->config[CONF_DIGEST_FILE] == NULL)
347 : : #else
348 : : if(opts->config[CONF_DIGEST_DB_FILE] == NULL)
349 : : #endif
350 : : {
351 : 18 : strlcpy(tmp_path, opts->config[CONF_FWKNOP_RUN_DIR], sizeof(tmp_path));
352 : :
353 [ + - ]: 18 : if(tmp_path[strlen(tmp_path)-1] != '/')
354 : 18 : strlcat(tmp_path, "/", sizeof(tmp_path));
355 : :
356 : :
357 : : #if USE_FILE_CACHE
358 : 18 : strlcat(tmp_path, DEF_DIGEST_CACHE_FILENAME, sizeof(tmp_path));
359 : 18 : set_config_entry(opts, CONF_DIGEST_FILE, tmp_path);
360 : : #else
361 : : strlcat(tmp_path, DEF_DIGEST_CACHE_DB_FILENAME, sizeof(tmp_path));
362 : : set_config_entry(opts, CONF_DIGEST_DB_FILE, tmp_path);
363 : : #endif
364 : : }
365 : :
366 : : /* Set remaining require CONF_ vars if they are not already set. */
367 : :
368 : : /* PCAP capture interface - note that if '-r <pcap file>' is specified
369 : : * on the command line, then this will override the pcap interface setting.
370 : : */
371 [ + + ]: 4506 : if(opts->config[CONF_PCAP_INTF] == NULL)
372 : 2499 : set_config_entry(opts, CONF_PCAP_INTF, DEF_INTERFACE);
373 : :
374 : : /* PCAP Promiscuous mode.
375 : : */
376 [ + + ]: 4488 : if(opts->config[CONF_ENABLE_PCAP_PROMISC] == NULL)
377 : 4485 : set_config_entry(opts, CONF_ENABLE_PCAP_PROMISC,
378 : : DEF_ENABLE_PCAP_PROMISC);
379 : :
380 : : /* The packet count argument to pcap_dispatch()
381 : : */
382 [ + + ]: 4444 : if(opts->config[CONF_PCAP_DISPATCH_COUNT] == NULL)
383 : 4443 : set_config_entry(opts, CONF_PCAP_DISPATCH_COUNT,
384 : : DEF_PCAP_DISPATCH_COUNT);
385 : :
386 : : /* Microseconds to sleep between pcap loop iterations
387 : : */
388 [ + + ]: 4385 : if(opts->config[CONF_PCAP_LOOP_SLEEP] == NULL)
389 : 4384 : set_config_entry(opts, CONF_PCAP_LOOP_SLEEP,
390 : : DEF_PCAP_LOOP_SLEEP);
391 : :
392 : : /* PCAP Filter.
393 : : */
394 [ + + ]: 4332 : if(opts->config[CONF_PCAP_FILTER] == NULL)
395 : 4318 : set_config_entry(opts, CONF_PCAP_FILTER, DEF_PCAP_FILTER);
396 : :
397 : : /* Enable SPA packet aging unless we're getting packet data
398 : : * directly from a pcap file
399 : : */
400 [ + + ]: 4295 : if(opts->config[CONF_ENABLE_SPA_PACKET_AGING] == NULL)
401 : : {
402 [ + + ]: 4215 : if(opts->config[CONF_PCAP_FILE] == NULL)
403 : : {
404 : 3740 : set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING,
405 : : DEF_ENABLE_SPA_PACKET_AGING);
406 : : }
407 : : else
408 : : {
409 : 475 : set_config_entry(opts, CONF_ENABLE_SPA_PACKET_AGING, "N");
410 : : }
411 : : }
412 : :
413 : : /* SPA packet age.
414 : : */
415 [ + - ]: 4248 : if(opts->config[CONF_MAX_SPA_PACKET_AGE] == NULL)
416 : 4248 : set_config_entry(opts, CONF_MAX_SPA_PACKET_AGE,
417 : : DEF_MAX_SPA_PACKET_AGE);
418 : :
419 : :
420 : : /* Enable digest persistence.
421 : : */
422 [ + - ]: 4211 : if(opts->config[CONF_ENABLE_DIGEST_PERSISTENCE] == NULL)
423 : 4211 : set_config_entry(opts, CONF_ENABLE_DIGEST_PERSISTENCE,
424 : : DEF_ENABLE_DIGEST_PERSISTENCE);
425 : :
426 : : /* Max sniff bytes.
427 : : */
428 [ + - ]: 4171 : if(opts->config[CONF_MAX_SNIFF_BYTES] == NULL)
429 : 4171 : set_config_entry(opts, CONF_MAX_SNIFF_BYTES, DEF_MAX_SNIFF_BYTES);
430 : :
431 : : #if FIREWALL_IPTABLES
432 : : /* Enable IPT forwarding.
433 : : */
434 [ + + ]: 4129 : if(opts->config[CONF_ENABLE_IPT_FORWARDING] == NULL)
435 : 4011 : set_config_entry(opts, CONF_ENABLE_IPT_FORWARDING,
436 : : DEF_ENABLE_IPT_FORWARDING);
437 : :
438 : : /* Enable IPT local NAT.
439 : : */
440 [ + + ]: 4091 : if(opts->config[CONF_ENABLE_IPT_LOCAL_NAT] == NULL)
441 : 4058 : set_config_entry(opts, CONF_ENABLE_IPT_LOCAL_NAT,
442 : : DEF_ENABLE_IPT_LOCAL_NAT);
443 : :
444 : : /* Enable IPT SNAT.
445 : : */
446 [ + + ]: 4059 : if(opts->config[CONF_ENABLE_IPT_SNAT] == NULL)
447 : 4028 : set_config_entry(opts, CONF_ENABLE_IPT_SNAT,
448 : : DEF_ENABLE_IPT_SNAT);
449 : :
450 : : /* Make sure we have a valid IP if SNAT is enabled
451 : : */
452 [ + + ]: 4026 : if(strncasecmp(opts->config[CONF_ENABLE_IPT_SNAT], "Y", 1) == 0)
453 : : {
454 : : /* Note that fw_config_init() will set use_masquerade if necessary
455 : : */
456 [ + + ]: 31 : if(opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
457 : : {
458 [ + + ]: 16 : if(! is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP]))
459 : : {
460 : 1 : log_msg(LOG_ERR,
461 : : "Invalid IPv4 addr for SNAT_TRANSLATE_IP"
462 : : );
463 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
464 : : }
465 : : }
466 : : }
467 : :
468 : : /* Enable IPT OUTPUT.
469 : : */
470 [ + + ]: 4025 : if(opts->config[CONF_ENABLE_IPT_OUTPUT] == NULL)
471 : 4024 : set_config_entry(opts, CONF_ENABLE_IPT_OUTPUT,
472 : : DEF_ENABLE_IPT_OUTPUT);
473 : :
474 : : /* Flush IPT at init.
475 : : */
476 [ + + ]: 3992 : if(opts->config[CONF_FLUSH_IPT_AT_INIT] == NULL)
477 : 3984 : set_config_entry(opts, CONF_FLUSH_IPT_AT_INIT, DEF_FLUSH_IPT_AT_INIT);
478 : :
479 : : /* Flush IPT at exit.
480 : : */
481 [ + + ]: 3969 : if(opts->config[CONF_FLUSH_IPT_AT_EXIT] == NULL)
482 : 3961 : set_config_entry(opts, CONF_FLUSH_IPT_AT_EXIT, DEF_FLUSH_IPT_AT_EXIT);
483 : :
484 : : /* IPT input access.
485 : : */
486 [ + + ]: 3943 : if(opts->config[CONF_IPT_INPUT_ACCESS] == NULL)
487 : 3931 : set_config_entry(opts, CONF_IPT_INPUT_ACCESS,
488 : : DEF_IPT_INPUT_ACCESS);
489 : :
490 [ + + ]: 3912 : if(validate_ipt_chain_conf(opts->config[CONF_IPT_INPUT_ACCESS]) != 1)
491 : : {
492 : 3 : log_msg(LOG_ERR,
493 : : "Invalid IPT_INPUT_ACCESS specification, see fwknopd.conf comments"
494 : : );
495 : 3 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
496 : : }
497 : :
498 : : /* IPT output access.
499 : : */
500 [ + + ]: 3909 : if(opts->config[CONF_IPT_OUTPUT_ACCESS] == NULL)
501 : 3907 : set_config_entry(opts, CONF_IPT_OUTPUT_ACCESS,
502 : : DEF_IPT_OUTPUT_ACCESS);
503 : :
504 [ + + ]: 3876 : if(validate_ipt_chain_conf(opts->config[CONF_IPT_OUTPUT_ACCESS]) != 1)
505 : : {
506 : 1 : log_msg(LOG_ERR,
507 : : "Invalid IPT_OUTPUT_ACCESS specification, see fwknopd.conf comments"
508 : : );
509 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
510 : : }
511 : :
512 : : /* IPT forward access.
513 : : */
514 [ + + ]: 3875 : if(opts->config[CONF_IPT_FORWARD_ACCESS] == NULL)
515 : 3871 : set_config_entry(opts, CONF_IPT_FORWARD_ACCESS,
516 : : DEF_IPT_FORWARD_ACCESS);
517 : :
518 [ + + ]: 3844 : if(validate_ipt_chain_conf(opts->config[CONF_IPT_FORWARD_ACCESS]) != 1)
519 : : {
520 : 1 : log_msg(LOG_ERR,
521 : : "Invalid IPT_FORWARD_ACCESS specification, see fwknopd.conf comments"
522 : : );
523 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
524 : : }
525 : :
526 : : /* IPT dnat access.
527 : : */
528 [ + + ]: 3843 : if(opts->config[CONF_IPT_DNAT_ACCESS] == NULL)
529 : 3839 : set_config_entry(opts, CONF_IPT_DNAT_ACCESS,
530 : : DEF_IPT_DNAT_ACCESS);
531 : :
532 [ + + ]: 3812 : if(validate_ipt_chain_conf(opts->config[CONF_IPT_DNAT_ACCESS]) != 1)
533 : : {
534 : 1 : log_msg(LOG_ERR,
535 : : "Invalid IPT_DNAT_ACCESS specification, see fwknopd.conf comments"
536 : : );
537 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
538 : : }
539 : :
540 : : /* IPT snat access.
541 : : */
542 [ + + ]: 3811 : if(opts->config[CONF_IPT_SNAT_ACCESS] == NULL)
543 : 3810 : set_config_entry(opts, CONF_IPT_SNAT_ACCESS,
544 : : DEF_IPT_SNAT_ACCESS);
545 : :
546 [ + + ]: 3779 : if(validate_ipt_chain_conf(opts->config[CONF_IPT_SNAT_ACCESS]) != 1)
547 : : {
548 : 1 : log_msg(LOG_ERR,
549 : : "Invalid IPT_SNAT_ACCESS specification, see fwknopd.conf comments"
550 : : );
551 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
552 : : }
553 : :
554 : : /* IPT masquerade access.
555 : : */
556 [ + + ]: 3778 : if(opts->config[CONF_IPT_MASQUERADE_ACCESS] == NULL)
557 : 3777 : set_config_entry(opts, CONF_IPT_MASQUERADE_ACCESS,
558 : : DEF_IPT_MASQUERADE_ACCESS);
559 : :
560 [ + + ]: 3755 : if(validate_ipt_chain_conf(opts->config[CONF_IPT_MASQUERADE_ACCESS]) != 1)
561 : : {
562 : 1 : log_msg(LOG_ERR,
563 : : "Invalid IPT_MASQUERADE_ACCESS specification, see fwknopd.conf comments"
564 : : );
565 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
566 : : }
567 : :
568 : : /* Check for the iptables 'comment' match at init time
569 : : */
570 [ + - ]: 3754 : if(opts->config[CONF_ENABLE_IPT_COMMENT_CHECK] == NULL)
571 : 3754 : set_config_entry(opts, CONF_ENABLE_IPT_COMMENT_CHECK,
572 : : DEF_ENABLE_IPT_COMMENT_CHECK);
573 : :
574 : : #elif FIREWALL_IPFW
575 : :
576 : : /* Flush ipfw rules at init.
577 : : */
578 : : if(opts->config[CONF_FLUSH_IPFW_AT_INIT] == NULL)
579 : : set_config_entry(opts, CONF_FLUSH_IPFW_AT_INIT, DEF_FLUSH_IPFW_AT_INIT);
580 : :
581 : : /* Flush ipfw rules at exit.
582 : : */
583 : : if(opts->config[CONF_FLUSH_IPFW_AT_EXIT] == NULL)
584 : : set_config_entry(opts, CONF_FLUSH_IPFW_AT_EXIT, DEF_FLUSH_IPFW_AT_EXIT);
585 : :
586 : : /* Set IPFW start rule number.
587 : : */
588 : : if(opts->config[CONF_IPFW_START_RULE_NUM] == NULL)
589 : : set_config_entry(opts, CONF_IPFW_START_RULE_NUM,
590 : : DEF_IPFW_START_RULE_NUM);
591 : :
592 : : /* Set IPFW max rules.
593 : : */
594 : : if(opts->config[CONF_IPFW_MAX_RULES] == NULL)
595 : : set_config_entry(opts, CONF_IPFW_MAX_RULES,
596 : : DEF_IPFW_MAX_RULES);
597 : :
598 : : /* Set IPFW active set number.
599 : : */
600 : : if(opts->config[CONF_IPFW_ACTIVE_SET_NUM] == NULL)
601 : : set_config_entry(opts, CONF_IPFW_ACTIVE_SET_NUM,
602 : : DEF_IPFW_ACTIVE_SET_NUM);
603 : :
604 : : /* Set IPFW expire set number.
605 : : */
606 : : if(opts->config[CONF_IPFW_EXPIRE_SET_NUM] == NULL)
607 : : set_config_entry(opts, CONF_IPFW_EXPIRE_SET_NUM,
608 : : DEF_IPFW_EXPIRE_SET_NUM);
609 : :
610 : : /* Set IPFW Dynamic rule expiry interval.
611 : : */
612 : : if(opts->config[CONF_IPFW_EXPIRE_PURGE_INTERVAL] == NULL)
613 : : set_config_entry(opts, CONF_IPFW_EXPIRE_PURGE_INTERVAL,
614 : : DEF_IPFW_EXPIRE_PURGE_INTERVAL);
615 : :
616 : : /* Set IPFW Dynamic rule expiry interval.
617 : : */
618 : : if(opts->config[CONF_IPFW_ADD_CHECK_STATE] == NULL)
619 : : set_config_entry(opts, CONF_IPFW_ADD_CHECK_STATE,
620 : : DEF_IPFW_ADD_CHECK_STATE);
621 : :
622 : : #elif FIREWALL_PF
623 : : /* Set PF anchor name
624 : : */
625 : : if(opts->config[CONF_PF_ANCHOR_NAME] == NULL)
626 : : set_config_entry(opts, CONF_PF_ANCHOR_NAME,
627 : : DEF_PF_ANCHOR_NAME);
628 : :
629 : : /* Set PF rule expiry interval.
630 : : */
631 : : if(opts->config[CONF_PF_EXPIRE_INTERVAL] == NULL)
632 : : set_config_entry(opts, CONF_PF_EXPIRE_INTERVAL,
633 : : DEF_PF_EXPIRE_INTERVAL);
634 : :
635 : : #elif FIREWALL_IPF
636 : : /* --DSS Place-holder */
637 : :
638 : : #endif /* FIREWALL type */
639 : :
640 : : /* GPG Home dir.
641 : : */
642 [ + + ]: 3731 : if(opts->config[CONF_GPG_HOME_DIR] == NULL)
643 : 3730 : set_config_entry(opts, CONF_GPG_HOME_DIR, DEF_GPG_HOME_DIR);
644 : :
645 : : /* GPG executable
646 : : */
647 [ + - ]: 3703 : if(opts->config[CONF_GPG_EXE] == NULL)
648 : 3703 : set_config_entry(opts, CONF_GPG_EXE, DEF_GPG_EXE);
649 : :
650 : : /* Enable SPA over HTTP.
651 : : */
652 [ + + ]: 3685 : if(opts->config[CONF_ENABLE_SPA_OVER_HTTP] == NULL)
653 : 3684 : set_config_entry(opts, CONF_ENABLE_SPA_OVER_HTTP,
654 : : DEF_ENABLE_SPA_OVER_HTTP);
655 : :
656 : : /* Enable TCP server.
657 : : */
658 [ + + ]: 3664 : if(opts->config[CONF_ENABLE_TCP_SERVER] == NULL)
659 : 3663 : set_config_entry(opts, CONF_ENABLE_TCP_SERVER, DEF_ENABLE_TCP_SERVER);
660 : :
661 : : /* TCP Server port.
662 : : */
663 [ + + ]: 3644 : if(opts->config[CONF_TCPSERV_PORT] == NULL)
664 : 3643 : set_config_entry(opts, CONF_TCPSERV_PORT, DEF_TCPSERV_PORT);
665 : :
666 : : /* Syslog identity.
667 : : */
668 [ + - ]: 3633 : if(opts->config[CONF_SYSLOG_IDENTITY] == NULL)
669 : 3633 : set_config_entry(opts, CONF_SYSLOG_IDENTITY, DEF_SYSLOG_IDENTITY);
670 : :
671 : : /* Syslog facility.
672 : : */
673 [ + + ]: 3618 : if(opts->config[CONF_SYSLOG_FACILITY] == NULL)
674 : 3608 : set_config_entry(opts, CONF_SYSLOG_FACILITY, DEF_SYSLOG_FACILITY);
675 : :
676 : :
677 : : /* Validate integer variable ranges
678 : : */
679 : 3609 : validate_int_var_ranges(opts);
680 : :
681 : : /* Some options just trigger some output of information, or trigger an
682 : : * external function, but do not actually start fwknopd. If any of those
683 : : * are set, we can return here an skip the validation routines as all
684 : : * other options will be ignored anyway.
685 : : *
686 : : * These are also mutually exclusive (for now).
687 : : */
688 [ + + ]: 3608 : if((opts->dump_config + opts->kill + opts->restart + opts->status) == 1)
689 : : return;
690 : :
691 [ + + ]: 2547 : if((opts->dump_config + opts->kill + opts->restart + opts->status) > 1)
692 : : {
693 : 2 : log_msg(LOG_ERR,
694 : : "The -D, -K, -R, and -S options are mutually exclusive. Pick only one."
695 : : );
696 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
697 : : }
698 : :
699 [ - + ]: 2545 : if(opts->config[CONF_FIREWALL_EXE] == NULL)
700 : : {
701 : 0 : log_msg(LOG_ERR,
702 : : "[*] No firewall command executable is set. Please check FIREWALL_EXE in fwknopd.conf."
703 : : );
704 : 0 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
705 : : }
706 : :
707 : : return;
708 : : }
709 : :
710 : : void
711 : 5325 : set_preconfig_entries(fko_srv_options_t *opts)
712 : : {
713 : : /* First, set any default or otherwise static settings here. Some may
714 : : * end up being overwritten via config file or command-line.
715 : : */
716 : :
717 : : /* Setup the firewall executable based on build-time info.
718 : : * --DSS Note: We will want to either force external script mode, or
719 : : * error out if we do not have a firewall executable defined.
720 : : */
721 : : #ifdef FIREWALL_EXE
722 : 5325 : set_config_entry(opts, CONF_FIREWALL_EXE, FIREWALL_EXE);
723 : : #endif
724 : :
725 : 5226 : }
726 : :
727 : : /* Initialize program configuration via config file and/or command-line
728 : : * switches.
729 : : */
730 : : void
731 : 5325 : config_init(fko_srv_options_t *opts, int argc, char **argv)
732 : : {
733 : : int cmd_arg, index, is_err;
734 : 5325 : unsigned char got_conf_file = 0, got_override_config = 0;
735 : :
736 : 5325 : char override_file[MAX_LINE_LEN] = {0};
737 : : char *ndx, *cmrk;
738 : :
739 : : /* Zero out options and opts_track.
740 : : */
741 : : memset(opts, 0x00, sizeof(fko_srv_options_t));
742 : :
743 : : /* Set some preconfiguration options (i.e. build-time defaults)
744 : : */
745 : 5325 : set_preconfig_entries(opts);
746 : :
747 : : /* In case this is a re-config.
748 : : */
749 : 5226 : optind = 0;
750 : :
751 : : /* First, scan the command-line args for -h/--help or an alternate
752 : : * configuration file. If we find an alternate config file, use it,
753 : : * otherwise use the default. We also grab any override config files
754 : : * as well.
755 : : */
756 [ + + ]: 49614 : while ((cmd_arg = getopt_long(argc, argv,
757 : : GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
758 : :
759 : : /* If help is wanted, give it and exit.
760 : : */
761 [ + + + + ]: 39340 : switch(cmd_arg) {
762 : : case 'h':
763 : 1 : usage();
764 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
765 : :
766 : : /* Look for configuration file arg.
767 : : */
768 : : case 'c':
769 : 5223 : set_config_entry(opts, CONF_CONFIG_FILE, optarg);
770 : 5125 : got_conf_file++;
771 : :
772 : : /* If we already have the config_override option, we are done.
773 : : */
774 [ + - ]: 5125 : if(got_override_config > 0)
775 : : break;
776 : :
777 : : /* Look for override configuration file arg.
778 : : */
779 : : case 'O':
780 : 5127 : set_config_entry(opts, CONF_OVERRIDE_CONFIG, optarg);
781 : 10274 : got_override_config++;
782 : :
783 : : /* If we already have the conf_file option, we are done.
784 : : */
785 : : if(got_conf_file > 0)
786 : : break;
787 : : }
788 : : }
789 : :
790 : : /* If no alternate configuration file was specified, we use the
791 : : * default.
792 : : */
793 [ + + ]: 5048 : if(opts->config[CONF_CONFIG_FILE] == NULL)
794 : 2 : set_config_entry(opts, CONF_CONFIG_FILE, DEF_CONFIG_FILE);
795 : :
796 : : /* Parse configuration file to populate any params not already specified
797 : : * via command-line options.
798 : : */
799 : 5048 : parse_config_file(opts, opts->config[CONF_CONFIG_FILE]);
800 : :
801 : : /* If there are override configuration entries, process them
802 : : * here.
803 : : */
804 [ + + ]: 4958 : if(opts->config[CONF_OVERRIDE_CONFIG] != NULL)
805 : : {
806 : : /* Make a copy of the override_config string so we can munge it.
807 : : */
808 : 4956 : strlcpy(override_file, opts->config[CONF_OVERRIDE_CONFIG], sizeof(override_file));
809 : :
810 : 4956 : ndx = override_file;
811 : 4956 : cmrk = strchr(ndx, ',');
812 : :
813 [ + + ]: 4956 : if(cmrk == NULL)
814 : : {
815 : : /* Only one to process...
816 : : */
817 : 4955 : parse_config_file(opts, ndx);
818 : :
819 : : } else {
820 : : /* Walk the string pulling the next config override
821 : : * at the comma delimiters.
822 : : */
823 [ + + ]: 2 : while(cmrk != NULL) {
824 : 1 : *cmrk = '\0';
825 : 1 : parse_config_file(opts, ndx);
826 : 1 : ndx = cmrk + 1;
827 : 1 : cmrk = strchr(ndx, ',');
828 : : }
829 : :
830 : : /* Process the last entry
831 : : */
832 : 1 : parse_config_file(opts, ndx);
833 : : }
834 : : }
835 : :
836 : : /* Set up the verbosity level according to the value found in the
837 : : * config files */
838 [ + + ]: 4888 : if (opts->config[CONF_VERBOSE] != NULL)
839 : : {
840 : 1 : opts->verbose = strtol_wrapper(opts->config[CONF_VERBOSE], 0, -1,
841 : : NO_EXIT_UPON_ERR, &is_err);
842 [ + - ]: 1 : if(is_err != FKO_SUCCESS)
843 : : {
844 : 1 : log_msg(LOG_ERR, "[*] VERBOSE value '%s' not in the range (>0)",
845 : : opts->config[CONF_VERBOSE]);
846 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
847 : : }
848 : : }
849 : :
850 : : /* Reset the options index so we can run through them again.
851 : : */
852 : 4887 : optind = 0;
853 : :
854 : : /* Last, but not least, we process command-line options (some of which
855 : : * may override configuration file options.
856 : : */
857 [ + + ]: 45479 : while ((cmd_arg = getopt_long(argc, argv,
858 : : GETOPTS_OPTION_STRING, cmd_opts, &index)) != -1) {
859 : :
860 [ + + + + : 35968 : switch(cmd_arg) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + +
+ ]
861 : : case 'a':
862 : 4886 : set_config_entry(opts, CONF_ACCESS_FILE, optarg);
863 : 4816 : break;
864 : : case 'c':
865 : : /* This was handled earlier */
866 : : break;
867 : : case 'C':
868 : 756 : opts->packet_ctr_limit = strtol_wrapper(optarg,
869 : : 0, (2 << 30), NO_EXIT_UPON_ERR, &is_err);
870 [ + + ]: 756 : if(is_err != FKO_SUCCESS)
871 : : {
872 : 1 : log_msg(LOG_ERR,
873 : : "[*] invalid -C packet count limit '%s'",
874 : : optarg);
875 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
876 : : }
877 : : break;
878 : : case 'd':
879 : : #if USE_FILE_CACHE
880 : 4797 : set_config_entry(opts, CONF_DIGEST_FILE, optarg);
881 : : #else
882 : : set_config_entry(opts, CONF_DIGEST_DB_FILE, optarg);
883 : : #endif
884 : 4725 : break;
885 : : case 'D':
886 : 18 : opts->dump_config = 1;
887 : 18 : break;
888 : : case DUMP_SERVER_ERR_CODES:
889 : 1 : dump_server_errors();
890 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
891 : : case EXIT_AFTER_PARSE_CONFIG:
892 : 1663 : opts->exit_after_parse_config = 1;
893 : 1663 : opts->foreground = 1;
894 : 1663 : break;
895 : : case 'f':
896 : 2733 : opts->foreground = 1;
897 : 2733 : break;
898 : : case FAULT_INJECTION_TAG:
899 : : #if HAVE_LIBFIU
900 : 35 : set_config_entry(opts, CONF_FAULT_INJECTION_TAG, optarg);
901 : : #else
902 : : log_msg(LOG_ERR, "[*] fwknopd not compiled with libfiu support");
903 : : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
904 : : #endif
905 : 35 : break;
906 : : case FW_LIST:
907 : 815 : opts->fw_list = 1;
908 : 815 : break;
909 : : case FW_LIST_ALL:
910 : 2 : opts->fw_list = 1;
911 : 2 : opts->fw_list_all = 1;
912 : 2 : break;
913 : : case FW_FLUSH:
914 : 18 : opts->fw_flush = 1;
915 : 18 : break;
916 : : case GPG_HOME_DIR:
917 [ + + ]: 3 : if (is_valid_dir(optarg))
918 : : {
919 : 1 : set_config_entry(opts, CONF_GPG_HOME_DIR, optarg);
920 : : }
921 : : else
922 : : {
923 : 2 : log_msg(LOG_ERR,
924 : : "[*] Directory '%s' could not stat()/does not exist?",
925 : : optarg);
926 : 2 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
927 : : }
928 : : break;
929 : : case 'i':
930 : 2092 : set_config_entry(opts, CONF_PCAP_INTF, optarg);
931 : 2065 : break;
932 : : case IPT_DISABLE_CHECK_SUPPORT:
933 : 655 : opts->ipt_disable_check_support = 1;
934 : 655 : break;
935 : : case 'K':
936 : 349 : opts->kill = 1;
937 : 349 : break;
938 : : case 'l':
939 : 2 : set_config_entry(opts, CONF_LOCALE, optarg);
940 : 2 : break;
941 : : case 'O':
942 : : /* This was handled earlier */
943 : : break;
944 : : case 'p':
945 : 4723 : set_config_entry(opts, CONF_FWKNOP_PID_FILE, optarg);
946 : 4663 : break;
947 : : case 'P':
948 : 7 : set_config_entry(opts, CONF_PCAP_FILTER, optarg);
949 : 7 : break;
950 : : case PCAP_FILE:
951 : 684 : set_config_entry(opts, CONF_PCAP_FILE, optarg);
952 : 656 : break;
953 : : case ENABLE_PCAP_ANY_DIRECTION:
954 : 1 : opts->pcap_any_direction = 1;
955 : 1 : break;
956 : : case ROTATE_DIGEST_CACHE:
957 : 2 : opts->rotate_digest_cache = 1;
958 : 2 : break;
959 : : case 'R':
960 : 6 : opts->restart = 1;
961 : 6 : break;
962 : : case 'S':
963 : 692 : opts->status = 1;
964 : 692 : break;
965 : : case 't':
966 : 658 : opts->test = 1;
967 : 658 : break;
968 : : /* Verbosity level */
969 : : case 'v':
970 : 5479 : opts->verbose++;
971 : 5479 : break;
972 : : case SYSLOG_ENABLE:
973 : 2 : opts->syslog_enable = 1;
974 : 2 : break;
975 : : case 'V':
976 : 1 : fprintf(stdout, "fwknopd server %s\n", MY_VERSION);
977 : 1 : clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
978 : : default:
979 : 1 : usage();
980 : 35706 : clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
981 : : }
982 : : }
983 : :
984 : : /* Now that we have all of our options set, and we are actually going to
985 : : * start fwknopd, we can validate them.
986 : : */
987 : 4624 : validate_options(opts);
988 : :
989 : 3606 : return;
990 : : }
991 : :
992 : : /* Dump the configuration
993 : : */
994 : : void
995 : 1616 : dump_config(const fko_srv_options_t *opts)
996 : : {
997 : : int i;
998 : :
999 : 1616 : fprintf(stdout, "Current fwknopd config settings:\n");
1000 : :
1001 [ + + ]: 72720 : for(i=0; i<NUMBER_OF_CONFIG_ENTRIES; i++)
1002 [ + + ]: 71104 : fprintf(stdout, "%3i. %-28s = '%s'\n",
1003 : : i,
1004 : : config_map[i],
1005 : 71104 : (opts->config[i] == NULL) ? "<not set>" : opts->config[i]
1006 : : );
1007 : :
1008 : 1616 : fprintf(stdout, "\n");
1009 : 1616 : fflush(stdout);
1010 : 1616 : }
1011 : :
1012 : : /* Print usage message...
1013 : : */
1014 : : void
1015 : 2 : usage(void)
1016 : : {
1017 : 2 : fprintf(stdout, "\n%s server version %s\n%s - http://www.cipherdyne.org/fwknop/\n\n",
1018 : : MY_NAME, MY_VERSION, MY_DESC);
1019 : 2 : fprintf(stdout,
1020 : : "Usage: fwknopd [options]\n\n"
1021 : : " -h, --help - Print this usage message and exit.\n"
1022 : : " -a, --access-file - Specify an alternate access.conf file.\n"
1023 : : " -c, --config-file - Specify an alternate configuration file.\n"
1024 : : " -C, --packet-limit - Limit the number of candidate SPA packets to\n"
1025 : : " process and exit when this limit is reached.\n"
1026 : : " -d, --digest-file - Specify an alternate digest.cache file.\n"
1027 : : " -D, --dump-config - Dump the current fwknop configuration values.\n"
1028 : : " -f, --foreground - Run fwknopd in the foreground (do not become\n"
1029 : : " a background daemon).\n"
1030 : : " -i, --interface - Specify interface to listen for incoming SPA\n"
1031 : : " packets.\n"
1032 : : " -K, --kill - Kill the currently running fwknopd.\n"
1033 : : " -l, --locale - Provide a locale setting other than the system\n"
1034 : : " default.\n"
1035 : : " -O, --override-config - Specify a file with configuration entries that will\n"
1036 : : " overide those in fwknopd.conf\n"
1037 : : " -p, --pid-file - Specify an alternate fwknopd.pid file.\n"
1038 : : " -P, --pcap-filter - Specify a Berkeley packet filter statement to\n"
1039 : : " override the PCAP_FILTER variable in fwknopd.conf.\n"
1040 : : " -R, --restart - Force the currently running fwknopd to restart.\n"
1041 : : " --rotate-digest-cache\n"
1042 : : " - Rotate the digest cache file by renaming it to\n"
1043 : : " '<name>-old', and starting a new one.\n"
1044 : : " -S, --status - Display the status of any running fwknopd process.\n"
1045 : : " -t, --test - Test mode, process SPA packets but do not make any\n"
1046 : : " firewall modifications.\n"
1047 : : " -v, --verbose - Set verbose mode.\n"
1048 : : " --syslog-enable - Allow messages to be sent to syslog even if the\n"
1049 : : " foreground mode is set.\n"
1050 : : " -V, --version - Print version number.\n"
1051 : : " --dump-serv-err-codes - List all server error codes (only needed by the\n"
1052 : : " test suite).\n"
1053 : : " --exit-parse-config - Parse config files and exit.\n"
1054 : : " --fault-injection-tag - Enable a fault injection tag (only needed by the\n"
1055 : : " test suite).\n"
1056 : : " --pcap-file - Read potential SPA packets from an existing pcap\n"
1057 : : " file.\n"
1058 : : " --pcap-any-direction - By default fwknopd processes packets that are\n"
1059 : : " sent to the sniffing interface, but this option\n"
1060 : : " enables processing of packets that originate from\n"
1061 : : " an interface (such as in a forwarding situation).\n"
1062 : : " --fw-list - List all firewall rules that fwknop has created\n"
1063 : : " and then exit.\n"
1064 : : " --fw-list-all - List all firewall rules in the complete policy,\n"
1065 : : " including those that have nothing to do with\n"
1066 : : " fwknop.\n"
1067 : : " --fw-flush - Flush all firewall rules created by fwknop.\n"
1068 : : " --gpg-home-dir - Specify the GPG home directory (this is normally\n"
1069 : : " done in the access.conf file).\n"
1070 : : " --gpg-exe - Specify the path to GPG (this is normally done in\n"
1071 : : " the access.conf file).\n"
1072 : : " --no-ipt-check-support - Disable test for 'iptables -C' support.\n"
1073 : : "\n"
1074 : : );
1075 : :
1076 : 2 : return;
1077 : : }
1078 : :
1079 : : /***EOF***/
|
