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