Branch data Line data Source code
1 : : /*
2 : : *****************************************************************************
3 : : *
4 : : * File: fw_util_firewalld.c
5 : : *
6 : : * Purpose: Fwknop routines for managing firewalld firewall rules.
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 : :
32 : : #include "fwknopd_common.h"
33 : :
34 : : #ifdef FIREWALL_FIREWALLD
35 : :
36 : : #include "fw_util.h"
37 : : #include "utils.h"
38 : : #include "log_msg.h"
39 : : #include "extcmd.h"
40 : : #include "access.h"
41 : :
42 : : static struct fw_config fwc;
43 : : static char cmd_buf[CMD_BUFSIZE];
44 : : static char err_buf[CMD_BUFSIZE];
45 : : static char cmd_out[STANDARD_CMD_OUT_BUFSIZE];
46 : :
47 : : /* assume 'firewall-cmd --direct --passthrough ipv4 -C' is offered
48 : : * (see firewd_chk_support()).
49 : : */
50 : : static int have_firewd_chk_support = 1;
51 : :
52 : : static void
53 : 12963 : zero_cmd_buffers(void)
54 : : {
55 : : memset(cmd_buf, 0x0, CMD_BUFSIZE);
56 : : memset(err_buf, 0x0, CMD_BUFSIZE);
57 : : memset(cmd_out, 0x0, STANDARD_CMD_OUT_BUFSIZE);
58 : 12963 : }
59 : :
60 : : static int pid_status = 0;
61 : :
62 : : static int
63 : 14 : rule_exists_no_chk_support(const fko_srv_options_t * const opts,
64 : : const struct fw_chain * const fwc,
65 : : const unsigned int proto,
66 : : const char * const srcip,
67 : : const char * const dstip,
68 : : const unsigned int port,
69 : : const char * const natip,
70 : : const unsigned int nat_port,
71 : : const unsigned int exp_ts)
72 : : {
73 : 14 : int rule_exists=0;
74 : 14 : char fw_line_buf[CMD_BUFSIZE] = {0};
75 : 14 : char target_search[CMD_BUFSIZE] = {0};
76 : 14 : char proto_search[CMD_BUFSIZE] = {0};
77 : 14 : char srcip_search[CMD_BUFSIZE] = {0};
78 : 14 : char dstip_search[CMD_BUFSIZE] = {0};
79 : 14 : char natip_search[CMD_BUFSIZE] = {0};
80 : 14 : char port_search[CMD_BUFSIZE] = {0};
81 : 14 : char nat_port_search[CMD_BUFSIZE] = {0};
82 : 14 : char exp_ts_search[CMD_BUFSIZE] = {0};
83 : 14 : char *ndx = NULL;
84 : :
85 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_LIST_RULES_ARGS,
86 : 14 : opts->fw_config->fw_command,
87 : 14 : fwc->table,
88 : 14 : fwc->to_chain
89 : : );
90 : :
91 : : #if CODE_COVERAGE
92 : : /* If we're maximizing code coverage, then exercise the run_extcmd_write()
93 : : * function which is normally only used for the PF firewall. This is to
94 : : * maximize code coverage in conjunction with the test suite, and is never
95 : : * compiled in for a production release of fwknop.
96 : : */
97 [ + - ]: 14 : if(run_extcmd_write("/bin/grep -v test", "/bin/echo test", &pid_status, opts) == 0)
98 : 14 : log_msg(LOG_WARNING, "[ignore] Code coverage: Executed command");
99 : : #endif
100 : :
101 [ + + ]: 14 : if(proto == IPPROTO_TCP)
102 : : snprintf(proto_search, CMD_BUFSIZE-1, " tcp ");
103 [ + - ]: 1 : else if(proto == IPPROTO_UDP)
104 : : snprintf(proto_search, CMD_BUFSIZE-1, " udp ");
105 [ # # ]: 0 : else if(proto == IPPROTO_ICMP)
106 : : snprintf(proto_search, CMD_BUFSIZE-1, " icmp ");
107 : : else
108 : : snprintf(proto_search, CMD_BUFSIZE-1, " %u ", proto);
109 : :
110 : : snprintf(port_search, CMD_BUFSIZE-1, "dpt:%u ", port);
111 : : snprintf(nat_port_search, CMD_BUFSIZE-1, ":%u", nat_port);
112 : 14 : snprintf(target_search, CMD_BUFSIZE-1, " %s ", fwc->target);
113 : :
114 [ + - ]: 14 : if (srcip != NULL)
115 : : snprintf(srcip_search, CMD_BUFSIZE-1, " %s ", srcip);
116 : :
117 [ - + ]: 14 : if (dstip != NULL)
118 : : snprintf(dstip_search, CMD_BUFSIZE-1, " %s ", dstip);
119 : :
120 [ + + ]: 14 : if (natip != NULL)
121 : : snprintf(natip_search, CMD_BUFSIZE-1, " to:%s", natip);
122 : :
123 : : snprintf(exp_ts_search, CMD_BUFSIZE-1, "%u ", exp_ts);
124 : :
125 : : /* search for each of the substrings - the rule expiration time is the
126 : : * primary search method
127 : : */
128 [ + + ]: 14 : if(search_extcmd_getline(cmd_buf, fw_line_buf,
129 : : CMD_BUFSIZE, NO_TIMEOUT, exp_ts_search, &pid_status, opts))
130 : : {
131 : 3 : chop_newline(fw_line_buf);
132 : : /* we have an iptables policy rule that matches the
133 : : * expiration time, so make sure this rule matches the
134 : : * other fields too. If not, then it is for different
135 : : * access requested by a separate SPA packet.
136 : : */
137 [ + - ]: 3 : if(((proto == ANY_PROTO) ? 1 : (strstr(fw_line_buf, proto_search) != NULL))
138 [ + - ][ + - ]: 3 : && ((srcip == NULL) ? 1 : (strstr(fw_line_buf, srcip_search) != NULL))
[ + - ]
139 [ - + ][ # # ]: 3 : && ((dstip == NULL) ? 1 : (strstr(fw_line_buf, dstip_search) != NULL))
140 [ + + ][ + - ]: 3 : && ((natip == NULL) ? 1 : (strstr(fw_line_buf, natip_search) != NULL))
141 [ + - ]: 3 : && (strstr(fw_line_buf, target_search) != NULL)
142 [ + - ][ + + ]: 3 : && ((port == ANY_PORT) ? 1 : (strstr(fw_line_buf, port_search) != NULL)))
143 : : {
144 : 2 : rule_exists = 1;
145 : : }
146 : : }
147 : :
148 : : /* If there is a nat port, we have to qualify it as part
149 : : * of the 'to:<ip>:<port>' portion of the rule (at the end)
150 : : */
151 [ + + ]: 14 : if(rule_exists && nat_port != NAT_ANY_PORT)
152 : : {
153 : 1 : ndx = strstr(fw_line_buf, " to:");
154 : : /* Make sure there isn't a duplicate " to:" string (i.e. if someone
155 : : * was trying to be tricky with the iptables comment match).
156 : : */
157 [ + - ][ + - ]: 1 : if(ndx != NULL && (strstr((ndx+strlen(" to:")), " to:") == NULL))
158 : : {
159 : 1 : ndx = strstr((ndx+strlen(" to:")), nat_port_search);
160 [ + - ]: 1 : if (ndx == NULL)
161 : : {
162 : : rule_exists = 0;
163 : : }
164 [ + - ]: 1 : else if((*(ndx+strlen(nat_port_search)) != '\0')
165 [ + - ]: 1 : && (*(ndx+strlen(nat_port_search)) != ' '))
166 : : {
167 : 1 : rule_exists = 0;
168 : : }
169 : : }
170 : : else
171 : : {
172 : : rule_exists = 0;
173 : : }
174 : : }
175 : :
176 [ + + ]: 14 : if(rule_exists)
177 : 1 : log_msg(LOG_DEBUG,
178 : : "rule_exists_no_chk_support() %s %u -> %s expires: %u rule already exists",
179 : : proto_search, port, srcip, exp_ts);
180 : : else
181 : 13 : log_msg(LOG_DEBUG,
182 : : "rule_exists_no_chk_support() %s %u -> %s expires: %u rule does not exist",
183 : : proto_search, port, srcip, exp_ts);
184 : :
185 : 14 : return(rule_exists);
186 : : }
187 : :
188 : : static int
189 : 2667 : rule_exists_chk_support(const fko_srv_options_t * const opts,
190 : : const char * const chain, const char * const rule)
191 : : {
192 : 2667 : int rule_exists = 0;
193 : 2667 : int res = 0;
194 : :
195 : 2667 : zero_cmd_buffers();
196 : :
197 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_CHK_RULE_ARGS,
198 : 2667 : opts->fw_config->fw_command, chain, rule);
199 : :
200 : 2667 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
201 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
202 : 2655 : chop_newline(err_buf);
203 : :
204 : 2655 : log_msg(LOG_DEBUG,
205 : : "rule_exists_chk_support() CMD: '%s' (res: %d, err: %s)",
206 : : cmd_buf, res, err_buf);
207 : :
208 [ + + ]: 2655 : if(strncmp(err_buf, "success", strlen("success")) == 0)
209 : : {
210 : 857 : rule_exists = 1;
211 : 857 : log_msg(LOG_DEBUG,
212 : : "rule_exists_chk_support() Rule : '%s' in %s already exists",
213 : : rule, chain);
214 : : }
215 : : else
216 : : {
217 : 1798 : log_msg(LOG_DEBUG,
218 : : "rule_exists_chk_support() Rule : '%s' in %s does not exist",
219 : : rule, chain);
220 : : }
221 : :
222 : 2655 : return(rule_exists);
223 : : }
224 : :
225 : : static int
226 : 355 : rule_exists(const fko_srv_options_t * const opts,
227 : : const struct fw_chain * const fwc,
228 : : const char * const rule,
229 : : const unsigned int proto,
230 : : const char * const srcip,
231 : : const char * const dstip,
232 : : const unsigned int port,
233 : : const char * const nat_ip,
234 : : const unsigned int nat_port,
235 : : const unsigned int exp_ts)
236 : : {
237 : 355 : int rule_exists = 0;
238 : :
239 [ + + ]: 355 : if(have_firewd_chk_support == 1)
240 : 341 : rule_exists = rule_exists_chk_support(opts, fwc->to_chain, rule);
241 : : else
242 [ - + ]: 14 : rule_exists = rule_exists_no_chk_support(opts, fwc, proto, srcip,
243 : 14 : (opts->fw_config->use_destination ? dstip : NULL), port,
244 : : nat_ip, nat_port, exp_ts);
245 : :
246 [ + + ]: 355 : if(rule_exists == 1)
247 : 7 : log_msg(LOG_DEBUG, "rule_exists() Rule : '%s' in %s already exists",
248 : 7 : rule, fwc->to_chain);
249 : : else
250 : 348 : log_msg(LOG_DEBUG, "rule_exists() Rule : '%s' in %s does not exist",
251 : 348 : rule, fwc->to_chain);
252 : :
253 : 355 : return(rule_exists);
254 : : }
255 : :
256 : : static void
257 : 413 : firewd_chk_support(const fko_srv_options_t * const opts)
258 : : {
259 : 413 : int res = 1;
260 : 413 : struct fw_chain *in_chain = &(opts->fw_config->chain[FIREWD_INPUT_ACCESS]);
261 : :
262 : 413 : zero_cmd_buffers();
263 : :
264 : : /* Add a harmless rule to the firewalld INPUT chain and see if firewalld
265 : : * supports '-C' to check for it. Set "have_firewd_chk_support" accordingly,
266 : : * delete the rule, and return.
267 : : */
268 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_TMP_CHK_RULE_ARGS,
269 : 413 : opts->fw_config->fw_command,
270 : 413 : in_chain->table,
271 : 413 : in_chain->from_chain,
272 : : 1, /* first rule */
273 : 413 : in_chain->target
274 : : );
275 : :
276 : 413 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
277 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
278 : 413 : chop_newline(err_buf);
279 : :
280 : 413 : log_msg(LOG_DEBUG, "firewd_chk_support() CMD: '%s' (res: %d, err: %s)",
281 : : cmd_buf, res, err_buf);
282 : :
283 : 413 : zero_cmd_buffers();
284 : :
285 : : /* Now see if '-C' works
286 : : */
287 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_TMP_VERIFY_CHK_ARGS,
288 : 413 : opts->fw_config->fw_command,
289 : : in_chain->table,
290 : : in_chain->from_chain,
291 : : in_chain->target
292 : : );
293 : :
294 : 413 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
295 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
296 : 413 : chop_newline(err_buf);
297 : :
298 : 413 : log_msg(LOG_DEBUG, "firewd_chk_support() CMD: '%s' (res: %d, err: %s)",
299 : : cmd_buf, res, err_buf);
300 : :
301 [ + + ]: 413 : if(strncmp(err_buf, "success", strlen("success")) == 0)
302 : : {
303 : 410 : log_msg(LOG_DEBUG, "firewd_chk_support() -C supported");
304 : 410 : have_firewd_chk_support = 1;
305 : : }
306 : : else
307 : : {
308 : 3 : log_msg(LOG_DEBUG, "firewd_chk_support() -C not supported");
309 : 3 : have_firewd_chk_support = 0;
310 : : }
311 : :
312 : : /* Delete the tmp rule
313 : : */
314 : 413 : zero_cmd_buffers();
315 : :
316 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_DEL_RULE_ARGS,
317 : 413 : opts->fw_config->fw_command,
318 : : in_chain->table,
319 : : in_chain->from_chain,
320 : : 1
321 : : );
322 : 413 : run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
323 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
324 : :
325 : 412 : return;
326 : : }
327 : :
328 : : static int
329 : 421 : comment_match_exists(const fko_srv_options_t * const opts)
330 : : {
331 : 421 : int res = 1;
332 : 421 : char *ndx = NULL;
333 : 421 : struct fw_chain *in_chain = &(opts->fw_config->chain[FIREWD_INPUT_ACCESS]);
334 : :
335 : 421 : zero_cmd_buffers();
336 : :
337 : : /* Add a harmless rule to the firewalld INPUT chain that uses the comment
338 : : * match and make sure it exists. If not, return zero. Otherwise, delete
339 : : * the rule and return true.
340 : : */
341 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_TMP_COMMENT_ARGS,
342 : 421 : opts->fw_config->fw_command,
343 : 421 : in_chain->table,
344 : 421 : in_chain->from_chain,
345 : : 1, /* first rule */
346 : 421 : in_chain->target
347 : : );
348 : :
349 : 421 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
350 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
351 : 421 : chop_newline(err_buf);
352 : :
353 : 421 : log_msg(LOG_DEBUG, "comment_match_exists() CMD: '%s' (res: %d, err: %s)",
354 : : cmd_buf, res, err_buf);
355 : :
356 : 421 : zero_cmd_buffers();
357 : :
358 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_LIST_RULES_ARGS,
359 : 421 : opts->fw_config->fw_command,
360 : : in_chain->table,
361 : : in_chain->from_chain
362 : : );
363 : :
364 : 421 : res = run_extcmd(cmd_buf, cmd_out, STANDARD_CMD_OUT_BUFSIZE,
365 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
366 : 420 : chop_newline(cmd_out);
367 : :
368 [ - + ]: 420 : if(!EXTCMD_IS_SUCCESS(res))
369 : 0 : log_msg(LOG_ERR, "comment_match_exists() Error %i from cmd:'%s': %s",
370 : : res, cmd_buf, cmd_out);
371 : :
372 : 420 : ndx = strstr(cmd_out, TMP_COMMENT);
373 [ + + ]: 420 : if(ndx == NULL)
374 : : res = 0; /* did not find the tmp comment */
375 : : else
376 : 417 : res = 1;
377 : :
378 [ + + ]: 420 : if(res == 1)
379 : : {
380 : : /* Delete the tmp comment rule
381 : : */
382 : 417 : zero_cmd_buffers();
383 : :
384 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_DEL_RULE_ARGS,
385 : 417 : opts->fw_config->fw_command,
386 : : in_chain->table,
387 : : in_chain->from_chain,
388 : : 1
389 : : );
390 : 417 : run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
391 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
392 : : }
393 : :
394 : 420 : return res;
395 : : }
396 : :
397 : : static int
398 : 542 : add_jump_rule(const fko_srv_options_t * const opts, const int chain_num)
399 : : {
400 : 542 : int res = 0, rv = 0;
401 : :
402 : 542 : zero_cmd_buffers();
403 : :
404 : 542 : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_ADD_JUMP_RULE_ARGS,
405 : : fwc.fw_command,
406 : 542 : fwc.chain[chain_num].table,
407 : 542 : fwc.chain[chain_num].from_chain,
408 : : fwc.chain[chain_num].jump_rule_pos,
409 : 542 : fwc.chain[chain_num].to_chain
410 : : );
411 : :
412 : 542 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
413 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
414 : :
415 : 542 : log_msg(LOG_DEBUG, "add_jump_rule() CMD: '%s' (res: %d, err: %s)",
416 : : cmd_buf, res, err_buf);
417 : :
418 [ + - ]: 542 : if(EXTCMD_IS_SUCCESS(res))
419 : : {
420 : 542 : log_msg(LOG_INFO, "Added jump rule from chain: %s to chain: %s",
421 : : fwc.chain[chain_num].from_chain,
422 : : fwc.chain[chain_num].to_chain);
423 : 542 : rv = 1;
424 : : }
425 : : else
426 : 0 : log_msg(LOG_ERR, "add_jump_rule() Error %i from cmd:'%s': %s",
427 : : res, cmd_buf, err_buf);
428 : :
429 : 542 : return rv;
430 : : }
431 : :
432 : : static int
433 : 885 : chain_exists(const fko_srv_options_t * const opts, const int chain_num)
434 : : {
435 : 885 : int res = 0, rv = 0;
436 : :
437 : 885 : zero_cmd_buffers();
438 : :
439 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_CHAIN_EXISTS_ARGS,
440 : : fwc.fw_command,
441 : 885 : fwc.chain[chain_num].table,
442 : 885 : fwc.chain[chain_num].to_chain
443 : : );
444 : :
445 : 885 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
446 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
447 : 885 : chop_newline(err_buf);
448 : :
449 : 885 : log_msg(LOG_DEBUG, "chain_exists() CMD: '%s' (res: %d, err: %s)",
450 : : cmd_buf, res, err_buf);
451 : :
452 [ + + ]: 885 : if(strstr(err_buf, FIREWD_CMD_FAIL_STR) == NULL)
453 : : {
454 : 345 : log_msg(LOG_DEBUG, "'%s' table '%s' chain exists",
455 : : fwc.chain[chain_num].table,
456 : : fwc.chain[chain_num].to_chain);
457 : 345 : rv = 1;
458 : : }
459 : : else
460 : 540 : log_msg(LOG_DEBUG,
461 : : "chain_exists() Error %i from cmd:'%s': %s",
462 : : res, cmd_buf, err_buf);
463 : :
464 : 885 : return rv;
465 : : }
466 : :
467 : : static int
468 : 2326 : jump_rule_exists_chk_support(const fko_srv_options_t * const opts, const int chain_num)
469 : : {
470 : 2326 : int exists = 0;
471 : 2326 : char rule_buf[CMD_BUFSIZE] = {0};
472 : :
473 : : snprintf(rule_buf, CMD_BUFSIZE-1, FIREWD_CHK_JUMP_RULE_ARGS,
474 : 2326 : fwc.chain[chain_num].table,
475 : 2326 : fwc.chain[chain_num].to_chain
476 : : );
477 : :
478 [ + + ]: 2326 : if(rule_exists_chk_support(opts, fwc.chain[chain_num].from_chain, rule_buf) == 1)
479 : : {
480 : 851 : log_msg(LOG_DEBUG, "jump_rule_exists_chk_support() jump rule found");
481 : 851 : exists = 1;
482 : : }
483 : : else
484 : 1463 : log_msg(LOG_DEBUG, "jump_rule_exists_chk_support() jump rule not found");
485 : :
486 : 2314 : return exists;
487 : : }
488 : :
489 : : static int
490 : 78 : jump_rule_exists_no_chk_support(const fko_srv_options_t * const opts,
491 : : const int chain_num)
492 : : {
493 : 78 : int exists = 0;
494 : 78 : char chain_search[CMD_BUFSIZE] = {0};
495 : :
496 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_LIST_RULES_ARGS,
497 : : fwc.fw_command,
498 : 78 : fwc.chain[chain_num].table,
499 : 78 : fwc.chain[chain_num].from_chain
500 : : );
501 : :
502 : : /* include spaces on either side as produced by 'firewalld -L' output
503 : : */
504 : : snprintf(chain_search, CMD_BUFSIZE-1, " %s ",
505 : 78 : fwc.chain[chain_num].to_chain);
506 : :
507 [ + + ]: 78 : if(search_extcmd(cmd_buf, WANT_STDERR,
508 : : NO_TIMEOUT, chain_search, &pid_status, opts) > 0)
509 : 29 : exists = 1;
510 : :
511 [ + + ]: 77 : if(exists)
512 : 29 : log_msg(LOG_DEBUG,
513 : : "jump_rule_exists_no_chk_support() jump rule found");
514 : : else
515 : 48 : log_msg(LOG_DEBUG,
516 : : "jump_rule_exists_no_chk_support() jump rule not found");
517 : :
518 : 77 : return(exists);
519 : : }
520 : :
521 : : static int
522 : 2404 : jump_rule_exists(const fko_srv_options_t * const opts, const int chain_num)
523 : : {
524 : 2404 : int exists = 0;
525 : :
526 [ + + ]: 2404 : if(have_firewd_chk_support == 1)
527 : 2326 : exists = jump_rule_exists_chk_support(opts, chain_num);
528 : : else
529 : 78 : exists = jump_rule_exists_no_chk_support(opts, chain_num);
530 : :
531 : 2391 : return exists;
532 : : }
533 : :
534 : : /* Print all firewall rules currently instantiated by the running fwknopd
535 : : * daemon to stdout.
536 : : */
537 : : int
538 : 1025 : fw_dump_rules(const fko_srv_options_t * const opts)
539 : : {
540 : : int i;
541 : 1025 : int res, got_err = 0;
542 : :
543 : 1025 : struct fw_chain *ch = opts->fw_config->chain;
544 : :
545 [ + + ]: 1025 : if (opts->fw_list_all == 1)
546 : : {
547 : 2 : fprintf(stdout, "Listing all firewalld rules in applicable tables...\n");
548 : 2 : fflush(stdout);
549 : :
550 [ + + ]: 14 : for(i=0; i < NUM_FWKNOP_ACCESS_TYPES; i++)
551 : : {
552 [ + + ]: 12 : if(fwc.chain[i].target[0] == '\0')
553 : 10 : continue;
554 : :
555 : 2 : zero_cmd_buffers();
556 : :
557 : : /* Create the list command
558 : : */
559 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_LIST_ALL_RULES_ARGS,
560 : 2 : opts->fw_config->fw_command,
561 : 2 : ch[i].table
562 : : );
563 : :
564 : 2 : res = run_extcmd(cmd_buf, NULL, 0, NO_STDERR,
565 : : NO_TIMEOUT, &pid_status, opts);
566 : :
567 : 2 : log_msg(LOG_DEBUG, "fw_dump_rules() CMD: '%s' (res: %d)",
568 : : cmd_buf, res);
569 : :
570 : : /* Expect full success on this */
571 [ - + ]: 2 : if(! EXTCMD_IS_SUCCESS(res))
572 : : {
573 : 0 : log_msg(LOG_ERR, "fw_dump_rules() Error %i from cmd:'%s': %s",
574 : : res, cmd_buf, err_buf);
575 : 0 : got_err++;
576 : : }
577 : : }
578 : : }
579 : : else
580 : : {
581 : 1023 : fprintf(stdout, "Listing rules in fwknopd firewalld chains...\n");
582 : 1023 : fflush(stdout);
583 : :
584 [ + + ]: 7161 : for(i=0; i < NUM_FWKNOP_ACCESS_TYPES; i++)
585 : : {
586 [ + + ]: 6138 : if(fwc.chain[i].target[0] == '\0')
587 : 4849 : continue;
588 : :
589 : 1289 : zero_cmd_buffers();
590 : :
591 : : /* Create the list command
592 : : */
593 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_LIST_RULES_ARGS,
594 : 1289 : opts->fw_config->fw_command,
595 : 1289 : ch[i].table,
596 : 1289 : ch[i].to_chain
597 : : );
598 : :
599 : 1289 : fprintf(stdout, "\n");
600 : 1289 : fflush(stdout);
601 : :
602 : 1289 : res = run_extcmd(cmd_buf, NULL, 0, NO_STDERR,
603 : : NO_TIMEOUT, &pid_status, opts);
604 : :
605 : 1289 : log_msg(LOG_DEBUG, "fw_dump_rules() CMD: '%s' (res: %d)",
606 : : cmd_buf, res);
607 : :
608 : : /* Expect full success on this */
609 [ - + ]: 1289 : if(! EXTCMD_IS_SUCCESS(res))
610 : : {
611 : 0 : log_msg(LOG_ERR, "fw_dump_rules() Error %i from cmd:'%s': %s",
612 : : res, cmd_buf, err_buf);
613 : 0 : got_err++;
614 : : }
615 : : }
616 : : }
617 : :
618 : 1025 : return(got_err);
619 : : }
620 : :
621 : : /* Quietly flush and delete all fwknop custom chains.
622 : : */
623 : : static void
624 : 844 : delete_all_chains(const fko_srv_options_t * const opts)
625 : : {
626 : 844 : int i, res, cmd_ctr = 0;
627 : :
628 [ + + ]: 5721 : for(i=0; i < NUM_FWKNOP_ACCESS_TYPES; i++)
629 : : {
630 [ + + ]: 4919 : if(fwc.chain[i].target[0] == '\0')
631 : 3919 : continue;
632 : :
633 : : /* First look for a jump rule to this chain and remove it if it
634 : : * is there.
635 : : */
636 : : cmd_ctr = 0;
637 [ + - ][ + + ]: 1519 : while(cmd_ctr < CMD_LOOP_TRIES && (jump_rule_exists(opts, i) == 1))
638 : : {
639 : 537 : zero_cmd_buffers();
640 : :
641 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_DEL_JUMP_RULE_ARGS,
642 : : fwc.fw_command,
643 : 537 : fwc.chain[i].table,
644 : 537 : fwc.chain[i].from_chain,
645 : 537 : fwc.chain[i].to_chain
646 : : );
647 : :
648 : 537 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
649 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
650 : 519 : chop_newline(err_buf);
651 : :
652 : 519 : log_msg(LOG_DEBUG, "delete_all_chains() CMD: '%s' (res: %d, err: %s)",
653 : : cmd_buf, res, err_buf);
654 : :
655 : : /* Expect full success on this */
656 [ - + ]: 519 : if(! EXTCMD_IS_SUCCESS(res))
657 : 0 : log_msg(LOG_ERR, "delete_all_chains() Error %i from cmd:'%s': %s",
658 : : res, cmd_buf, err_buf);
659 : :
660 : 519 : cmd_ctr++;
661 : : }
662 : :
663 : 969 : zero_cmd_buffers();
664 : :
665 : : /* Now flush and remove the chain.
666 : : */
667 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_FLUSH_CHAIN_ARGS,
668 : : fwc.fw_command,
669 : 969 : fwc.chain[i].table,
670 : 969 : fwc.chain[i].to_chain
671 : : );
672 : :
673 : 969 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE, WANT_STDERR,
674 : : NO_TIMEOUT, &pid_status, opts);
675 : 963 : chop_newline(err_buf);
676 : :
677 : 963 : log_msg(LOG_DEBUG, "delete_all_chains() CMD: '%s' (res: %d, err: %s)",
678 : : cmd_buf, res, err_buf);
679 : :
680 : : /* Expect full success on this */
681 [ - + ]: 963 : if(! EXTCMD_IS_SUCCESS(res))
682 : 0 : log_msg(LOG_ERR, "delete_all_chains() Error %i from cmd:'%s': %s",
683 : : res, cmd_buf, err_buf);
684 : :
685 : 963 : zero_cmd_buffers();
686 : :
687 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_DEL_CHAIN_ARGS,
688 : : fwc.fw_command,
689 : 963 : fwc.chain[i].table,
690 : : fwc.chain[i].to_chain
691 : : );
692 : :
693 : 963 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE, WANT_STDERR,
694 : : NO_TIMEOUT, &pid_status, opts);
695 : 958 : chop_newline(err_buf);
696 : :
697 : 958 : log_msg(LOG_DEBUG, "delete_all_chains() CMD: '%s' (res: %d, err: %s)",
698 : : cmd_buf, res, err_buf);
699 : :
700 : : /* Expect full success on this */
701 [ - + ]: 958 : if(! EXTCMD_IS_SUCCESS(res))
702 : 0 : log_msg(LOG_ERR, "delete_all_chains() Error %i from cmd:'%s': %s",
703 : : res, cmd_buf, err_buf);
704 : :
705 : : }
706 : 802 : return;
707 : : }
708 : :
709 : : static int
710 : 540 : create_chain(const fko_srv_options_t * const opts, const int chain_num)
711 : : {
712 : 540 : int res = 0, rv = 0;
713 : :
714 : 540 : zero_cmd_buffers();
715 : :
716 : : /* Create the custom chain.
717 : : */
718 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_NEW_CHAIN_ARGS,
719 : : fwc.fw_command,
720 : 540 : fwc.chain[chain_num].table,
721 : 540 : fwc.chain[chain_num].to_chain
722 : : );
723 : :
724 : 540 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE, WANT_STDERR,
725 : : NO_TIMEOUT, &pid_status, opts);
726 : 540 : chop_newline(err_buf);
727 : :
728 : 540 : log_msg(LOG_DEBUG, "create_chain() CMD: '%s' (res: %d, err: %s)",
729 : : cmd_buf, res, err_buf);
730 : :
731 : : /* Expect full success on this */
732 [ - + ]: 540 : if(EXTCMD_IS_SUCCESS(res))
733 : : rv = 1;
734 : : else
735 : 0 : log_msg(LOG_ERR, "create_chain() Error %i from cmd:'%s': %s",
736 : : res, cmd_buf, err_buf);
737 : :
738 : 540 : return rv;
739 : : }
740 : :
741 : : static int
742 : 885 : mk_chain(const fko_srv_options_t * const opts, const int chain_num)
743 : : {
744 : 885 : int err = 0;
745 : :
746 : : /* Make sure the required chain and jump rule exist
747 : : */
748 [ + + ]: 885 : if(! chain_exists(opts, chain_num))
749 [ - + ]: 540 : if(! create_chain(opts, chain_num))
750 : 0 : err++;
751 : :
752 [ + + ]: 885 : if (! jump_rule_exists(opts, chain_num))
753 [ - + ]: 542 : if(! add_jump_rule(opts, chain_num))
754 : 0 : err++;
755 : :
756 : 885 : return err;
757 : : }
758 : :
759 : : /* Create the fwknop custom chains (at least those that are configured).
760 : : */
761 : : static int
762 : 421 : create_fw_chains(const fko_srv_options_t * const opts)
763 : : {
764 : 421 : int i, got_err = 0;
765 : :
766 [ + + ]: 2947 : for(i=0; i < NUM_FWKNOP_ACCESS_TYPES; i++)
767 : : {
768 [ + + ]: 2526 : if(fwc.chain[i].target[0] == '\0')
769 : 1996 : continue;
770 : :
771 : 530 : got_err += mk_chain(opts, i);
772 : : }
773 : :
774 : 421 : return(got_err);
775 : : }
776 : :
777 : : static int
778 : 3130 : set_fw_chain_conf(const int type, const char * const conf_str)
779 : : {
780 : : int i, j, is_err;
781 : 3130 : char tbuf[MAX_LINE_LEN] = {0};
782 : 3130 : const char *ndx = conf_str;
783 : :
784 : : char *chain_fields[FW_NUM_CHAIN_FIELDS];
785 : :
786 : 3130 : struct fw_chain *chain = &(fwc.chain[type]);
787 : :
788 [ - + ]: 3130 : if(conf_str == NULL)
789 : : {
790 : 0 : log_msg(LOG_ERR, "[*] NULL conf_str");
791 : 0 : return 0;
792 : : }
793 : :
794 : 3130 : chain->type = type;
795 : :
796 [ + - ]: 3130 : if(ndx != NULL)
797 : 3130 : chain_fields[0] = tbuf;
798 : :
799 : : i = 0;
800 : : j = 1;
801 [ + + ]: 133865 : while(*ndx != '\0')
802 : : {
803 [ + + ]: 130735 : if(*ndx != ' ')
804 : : {
805 [ + + ]: 115085 : if(*ndx == ',')
806 : : {
807 : 15650 : tbuf[i] = '\0';
808 : 15650 : chain_fields[j++] = &(tbuf[++i]);
809 : : }
810 : : else
811 : 99435 : tbuf[i++] = *ndx;
812 : : }
813 [ + + ]: 130735 : if(*ndx != '\0'
814 : 130735 : && *ndx != ' '
815 [ + + ]: 115085 : && *ndx != ','
816 [ + + ]: 99435 : && *ndx != '_'
817 [ - + ]: 96288 : && isalnum(*ndx) == 0)
818 : : {
819 : 0 : log_msg(LOG_ERR, "[*] Custom chain config parse error: "
820 : : "invalid character '%c' for chain type %i, "
821 : 0 : "line: %s", *ndx, type, conf_str);
822 : 0 : return 0;
823 : : }
824 : 130735 : ndx++;
825 : : }
826 : :
827 : : /* Sanity check - j should be the number of chain fields
828 : : * (excluding the type).
829 : : */
830 [ - + ]: 3130 : if(j != FW_NUM_CHAIN_FIELDS)
831 : : {
832 : 0 : log_msg(LOG_ERR, "[*] Custom chain config parse error: "
833 : : "wrong number of fields for chain type %i, "
834 : : "line: %s", type, conf_str);
835 : 0 : return 0;
836 : : }
837 : :
838 : : /* Pull and set Target */
839 : 3130 : strlcpy(chain->target, chain_fields[0], sizeof(chain->target));
840 : :
841 : : /* Pull and set Table */
842 : 3130 : strlcpy(chain->table, chain_fields[1], sizeof(chain->table));
843 : :
844 : : /* Pull and set From_chain */
845 : 3130 : strlcpy(chain->from_chain, chain_fields[2], sizeof(chain->from_chain));
846 : :
847 : : /* Pull and set Jump_rule_position */
848 : 3130 : chain->jump_rule_pos = strtol_wrapper(chain_fields[3],
849 : : 0, RCHK_MAX_FIREWD_RULE_NUM, NO_EXIT_UPON_ERR, &is_err);
850 [ + + ]: 3130 : if(is_err != FKO_SUCCESS)
851 : : {
852 : 1 : log_msg(LOG_ERR, "[*] invalid jump rule position in Line: %s",
853 : : conf_str);
854 : 1 : return 0;
855 : : }
856 : :
857 : : /* Pull and set To_chain */
858 : 3129 : strlcpy(chain->to_chain, chain_fields[4], sizeof(chain->to_chain));
859 : :
860 : : /* Pull and set to_chain rule position */
861 : 3129 : chain->rule_pos = strtol_wrapper(chain_fields[5],
862 : : 0, RCHK_MAX_FIREWD_RULE_NUM, NO_EXIT_UPON_ERR, &is_err);
863 [ + + ]: 3129 : if(is_err != FKO_SUCCESS)
864 : : {
865 : 1 : log_msg(LOG_ERR, "[*] invalid to_chain rule position in Line: %s",
866 : : conf_str);
867 : 1 : return 0;
868 : : }
869 : : return 1;
870 : : }
871 : :
872 : : int
873 : 2720 : fw_config_init(fko_srv_options_t * const opts)
874 : : {
875 : : memset(&fwc, 0x0, sizeof(struct fw_config));
876 : :
877 : : /* Set our firewall exe command path (firewall-cmd or iptables in most cases).
878 : : */
879 : : #if FIREWALL_FIREWALLD
880 : : char cmd_passthru[512];
881 : 2720 : snprintf(cmd_passthru, sizeof cmd_passthru, "%s %s ",
882 : : opts->config[CONF_FIREWALL_EXE], FIREWD_CMD_PREFIX);
883 : 2720 : strlcpy(fwc.fw_command, cmd_passthru, sizeof(fwc.fw_command));
884 : : #else
885 : : strlcpy(fwc.fw_command, opts->config[CONF_FIREWALL_EXE], sizeof(fwc.fw_command));
886 : : #endif
887 : :
888 : : #if HAVE_LIBFIU
889 [ + + ]: 2720 : fiu_return_on("fw_config_init", 0);
890 : : #endif
891 : :
892 : : /* Pull the fwknop chain config info and setup our internal
893 : : * config struct. The FIREWD_INPUT is the only one that is
894 : : * required. The rest are optional.
895 : : */
896 [ + + ]: 2719 : if(set_fw_chain_conf(FIREWD_INPUT_ACCESS, opts->config[CONF_FIREWD_INPUT_ACCESS]) != 1)
897 : : return 0;
898 : :
899 : : /* The FWKNOP_OUTPUT_ACCESS requires ENABLE_FIREWD_OUTPUT_ACCESS == Y
900 : : */
901 [ + + ]: 2717 : if(strncasecmp(opts->config[CONF_ENABLE_FIREWD_OUTPUT], "Y", 1)==0)
902 [ + - ]: 1 : if(set_fw_chain_conf(FIREWD_OUTPUT_ACCESS, opts->config[CONF_FIREWD_OUTPUT_ACCESS]) != 1)
903 : : return 0;
904 : :
905 : : /* The remaining access chains require ENABLE_FIREWD_FORWARDING = Y
906 : : */
907 [ + + ]: 2717 : if(strncasecmp(opts->config[CONF_ENABLE_FIREWD_FORWARDING], "Y", 1)==0)
908 : : {
909 [ + - ]: 159 : if(set_fw_chain_conf(FIREWD_FORWARD_ACCESS, opts->config[CONF_FIREWD_FORWARD_ACCESS]) != 1)
910 : : return 0;
911 : :
912 [ + - ]: 159 : if(set_fw_chain_conf(FIREWD_DNAT_ACCESS, opts->config[CONF_FIREWD_DNAT_ACCESS]) != 1)
913 : : return 0;
914 : :
915 : : /* Requires ENABLE_FIREWD_SNAT = Y
916 : : */
917 [ + + ]: 159 : if(strncasecmp(opts->config[CONF_ENABLE_FIREWD_SNAT], "Y", 1)==0)
918 : : {
919 : : /* Support both SNAT and MASQUERADE - this will be controlled
920 : : * via the access.conf configuration for individual rules
921 : : */
922 [ + - ]: 46 : if(set_fw_chain_conf(FIREWD_MASQUERADE_ACCESS,
923 : 46 : opts->config[CONF_FIREWD_MASQUERADE_ACCESS]) != 1)
924 : : return 0;
925 : :
926 [ + - ]: 46 : if(set_fw_chain_conf(FIREWD_SNAT_ACCESS,
927 : 46 : opts->config[CONF_FIREWD_SNAT_ACCESS]) != 1)
928 : : return 0;
929 : : }
930 : : }
931 : :
932 [ + + ]: 2717 : if(strncasecmp(opts->config[CONF_ENABLE_DESTINATION_RULE], "Y", 1)==0)
933 : : {
934 : 8 : fwc.use_destination = 1;
935 : : }
936 : :
937 : : /* Let us find it via our opts struct as well.
938 : : */
939 : 2717 : opts->fw_config = &fwc;
940 : :
941 : 2717 : return 1;
942 : : }
943 : :
944 : : int
945 : 422 : fw_initialize(const fko_srv_options_t * const opts)
946 : : {
947 : 422 : int res = 1;
948 : :
949 : : /* See if firewalld offers the '-C' argument (older versions don't). If not,
950 : : * then switch to parsing firewalld -L output to find rules.
951 : : */
952 [ + + ]: 422 : if(opts->firewd_disable_check_support)
953 : 9 : have_firewd_chk_support = 0;
954 : : else
955 : 413 : firewd_chk_support(opts);
956 : :
957 : : /* Flush the chains (just in case) so we can start fresh.
958 : : */
959 [ + + ]: 421 : if(strncasecmp(opts->config[CONF_FLUSH_FIREWD_AT_INIT], "Y", 1) == 0)
960 : 413 : delete_all_chains(opts);
961 : :
962 : : /* Now create any configured chains.
963 : : */
964 [ - + ]: 421 : if(create_fw_chains(opts) != 0)
965 : : {
966 : 0 : log_msg(LOG_WARNING,
967 : : "fw_initialize() Warning: Errors detected during fwknop custom chain creation");
968 : 0 : res = 0;
969 : : }
970 : :
971 : : /* Make sure that the 'comment' match is available
972 : : */
973 [ + - ]: 421 : if(strncasecmp(opts->config[CONF_ENABLE_FIREWD_COMMENT_CHECK], "Y", 1) == 0)
974 : : {
975 [ + + ]: 421 : if(comment_match_exists(opts) == 1)
976 : : {
977 : 417 : log_msg(LOG_INFO, "firewalld 'comment' match is available");
978 : : }
979 : : else
980 : : {
981 : 3 : log_msg(LOG_WARNING, "Warning: Could not use the 'comment' match");
982 : 3 : res = 0;
983 : : }
984 : : }
985 : :
986 : 420 : return(res);
987 : : }
988 : :
989 : : int
990 : 439 : fw_cleanup(const fko_srv_options_t * const opts)
991 : : {
992 [ + + ]: 439 : if(strncasecmp(opts->config[CONF_FLUSH_FIREWD_AT_EXIT], "N", 1) == 0
993 [ - + ]: 8 : && opts->fw_flush == 0)
994 : : return(0);
995 : :
996 : 431 : delete_all_chains(opts);
997 : 389 : return(0);
998 : : }
999 : :
1000 : : static int
1001 : 348 : create_rule(const fko_srv_options_t * const opts,
1002 : : const char * const fw_chain, const char * const fw_rule)
1003 : : {
1004 : 348 : int res = 0;
1005 : :
1006 : 348 : zero_cmd_buffers();
1007 : :
1008 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s -A %s %s",
1009 : 348 : opts->fw_config->fw_command, fw_chain, fw_rule);
1010 : :
1011 : 348 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE, WANT_STDERR,
1012 : : NO_TIMEOUT, &pid_status, opts);
1013 : 348 : chop_newline(err_buf);
1014 : :
1015 : 348 : log_msg(LOG_DEBUG, "create_rule() CMD: '%s' (res: %d, err: %s)",
1016 : : cmd_buf, res, err_buf);
1017 : :
1018 [ + - ]: 348 : if(EXTCMD_IS_SUCCESS(res))
1019 : : {
1020 : 348 : log_msg(LOG_DEBUG, "create_rule() Rule: '%s' added to %s", fw_rule, fw_chain);
1021 : 348 : res = 1;
1022 : : }
1023 : : else
1024 : 0 : log_msg(LOG_ERR, "create_rule() Error %i from cmd:'%s': %s",
1025 : : res, cmd_buf, err_buf);
1026 : :
1027 : 348 : return res;
1028 : : }
1029 : :
1030 : : static void
1031 : 355 : firewd_rule(const fko_srv_options_t * const opts,
1032 : : const char * const complete_rule_buf,
1033 : : const char * const fw_rule_macro,
1034 : : const char * const srcip,
1035 : : const char * const dstip,
1036 : : const unsigned int proto,
1037 : : const unsigned int port,
1038 : : const char * const nat_ip,
1039 : : const unsigned int nat_port,
1040 : : struct fw_chain * const chain,
1041 : : const unsigned int exp_ts,
1042 : : const time_t now,
1043 : : const char * const msg,
1044 : : const char * const access_msg)
1045 : : {
1046 : 355 : char rule_buf[CMD_BUFSIZE] = {0};
1047 : :
1048 [ + + ][ + - ]: 355 : if(complete_rule_buf != NULL && complete_rule_buf[0] != 0x0)
1049 : : {
1050 : 55 : strlcpy(rule_buf, complete_rule_buf, CMD_BUFSIZE-1);
1051 : : }
1052 : : else
1053 : : {
1054 : : memset(rule_buf, 0, CMD_BUFSIZE);
1055 : :
1056 : : snprintf(rule_buf, CMD_BUFSIZE-1, fw_rule_macro,
1057 : 300 : chain->table,
1058 : : proto,
1059 : : srcip,
1060 : : dstip,
1061 : : port,
1062 : : exp_ts,
1063 : 300 : chain->target
1064 : : );
1065 : : }
1066 : :
1067 : : /* Check to make sure that the chain and jump rule exists
1068 : : */
1069 : 355 : mk_chain(opts, chain->type);
1070 : :
1071 [ + + ]: 355 : if(rule_exists(opts, chain, rule_buf, proto, srcip,
1072 : : dstip, port, nat_ip, nat_port, exp_ts) == 0)
1073 : : {
1074 [ + - ]: 348 : if(create_rule(opts, chain->to_chain, rule_buf))
1075 : : {
1076 [ + + ]: 348 : log_msg(LOG_INFO, "Added %s rule to %s for %s -> %s %s, expires at %u",
1077 : : msg, chain->to_chain, srcip, (dstip == NULL) ? FIREWD_ANY_IP : dstip,
1078 : : access_msg, exp_ts
1079 : : );
1080 : :
1081 : 348 : chain->active_rules++;
1082 : :
1083 : : /* Reset the next expected expire time for this chain if it
1084 : : * is warranted.
1085 : : */
1086 [ + + ][ - + ]: 348 : if(chain->next_expire < now || exp_ts < chain->next_expire)
1087 : 335 : chain->next_expire = exp_ts;
1088 : : }
1089 : : }
1090 : :
1091 : 355 : return;
1092 : : }
1093 : :
1094 : 64 : static void forward_access_rule(const fko_srv_options_t * const opts,
1095 : : const acc_stanza_t * const acc,
1096 : : struct fw_chain * const fwd_chain,
1097 : : const char * const nat_ip,
1098 : : const unsigned int nat_port,
1099 : : const unsigned int fst_proto,
1100 : : const unsigned int fst_port,
1101 : : spa_data_t * const spadat,
1102 : : const unsigned int exp_ts,
1103 : : const time_t now)
1104 : : {
1105 : 32 : char rule_buf[CMD_BUFSIZE] = {0};
1106 : :
1107 : 32 : log_msg(LOG_DEBUG,
1108 : : "forward_access_rule() forward_all: %d, nat_ip: %s, nat_port: %d",
1109 : 32 : acc->forward_all, nat_ip, nat_port);
1110 : :
1111 [ + + ]: 32 : if(acc->forward_all)
1112 : : {
1113 : : memset(rule_buf, 0, CMD_BUFSIZE);
1114 : :
1115 : 5 : snprintf(rule_buf, CMD_BUFSIZE-1, FIREWD_FWD_ALL_RULE_ARGS,
1116 : 5 : fwd_chain->table,
1117 : : spadat->use_src_ip,
1118 : : exp_ts,
1119 : 5 : fwd_chain->target
1120 : : );
1121 : :
1122 : : /* Make a global ACCEPT rule for all ports/protocols
1123 : : */
1124 : 5 : firewd_rule(opts, rule_buf, NULL, spadat->use_src_ip,
1125 : : NULL, ANY_PROTO, ANY_PORT, NULL, NAT_ANY_PORT,
1126 : : fwd_chain, exp_ts, now, "FORWARD ALL", "*/*");
1127 : : }
1128 : : else
1129 : : {
1130 : : /* Make the FORWARD access rule
1131 : : */
1132 : 27 : firewd_rule(opts, NULL, FIREWD_FWD_RULE_ARGS, spadat->use_src_ip,
1133 : : nat_ip, fst_proto, nat_port, NULL, NAT_ANY_PORT,
1134 : 27 : fwd_chain, exp_ts, now, "FORWARD", spadat->spa_message_remain);
1135 : : }
1136 : 32 : return;
1137 : : }
1138 : :
1139 : 74 : static void dnat_rule(const fko_srv_options_t * const opts,
1140 : : const acc_stanza_t * const acc,
1141 : : struct fw_chain * const dnat_chain,
1142 : : const char * const nat_ip,
1143 : : const unsigned int nat_port,
1144 : : const unsigned int fst_proto,
1145 : : const unsigned int fst_port,
1146 : : spa_data_t * const spadat,
1147 : : const unsigned int exp_ts,
1148 : : const time_t now)
1149 : : {
1150 : 37 : char rule_buf[CMD_BUFSIZE] = {0};
1151 : :
1152 : 37 : log_msg(LOG_DEBUG, "dnat_rule() forward_all: %d, nat_ip: %s, nat_port: %d",
1153 : 37 : acc->forward_all, nat_ip, nat_port);
1154 : :
1155 [ + + ]: 37 : if(acc->forward_all)
1156 : : {
1157 : : memset(rule_buf, 0, CMD_BUFSIZE);
1158 : :
1159 [ + + ]: 3 : snprintf(rule_buf, CMD_BUFSIZE-1, FIREWD_DNAT_ALL_RULE_ARGS,
1160 : 3 : dnat_chain->table,
1161 : : spadat->use_src_ip,
1162 : 3 : (fwc.use_destination ? spadat->pkt_destination_ip : FIREWD_ANY_IP),
1163 : : exp_ts,
1164 : 3 : dnat_chain->target,
1165 : : nat_ip
1166 : : );
1167 : :
1168 : : /* Make a global DNAT rule for all ports/protocols
1169 : : */
1170 : 3 : firewd_rule(opts, rule_buf, NULL, spadat->use_src_ip,
1171 : : NULL, ANY_PROTO, ANY_PORT, NULL, NAT_ANY_PORT,
1172 : : dnat_chain, exp_ts, now, "DNAT ALL", "*/*");
1173 : : }
1174 : : else
1175 : : {
1176 : : memset(rule_buf, 0, CMD_BUFSIZE);
1177 : :
1178 [ - + ]: 34 : snprintf(rule_buf, CMD_BUFSIZE-1, FIREWD_DNAT_RULE_ARGS,
1179 : 34 : dnat_chain->table,
1180 : : fst_proto,
1181 : : spadat->use_src_ip,
1182 : 34 : (fwc.use_destination ? spadat->pkt_destination_ip : FIREWD_ANY_IP),
1183 : : fst_port,
1184 : : exp_ts,
1185 : 34 : dnat_chain->target,
1186 : : nat_ip,
1187 : : nat_port
1188 : : );
1189 : :
1190 [ - + ]: 34 : firewd_rule(opts, rule_buf, NULL, spadat->use_src_ip,
1191 : 34 : (fwc.use_destination ? spadat->pkt_destination_ip : FIREWD_ANY_IP),
1192 : : fst_proto, fst_port, nat_ip, nat_port, dnat_chain, exp_ts, now,
1193 : 34 : "DNAT", spadat->spa_message_remain);
1194 : : }
1195 : 37 : return;
1196 : : }
1197 : :
1198 : 13 : static void snat_rule(const fko_srv_options_t * const opts,
1199 : : const acc_stanza_t * const acc,
1200 : : const char * const nat_ip,
1201 : : const unsigned int nat_port,
1202 : : const unsigned int fst_proto,
1203 : : const unsigned int fst_port,
1204 : : spa_data_t * const spadat,
1205 : : const unsigned int exp_ts,
1206 : : const time_t now)
1207 : : {
1208 : 13 : char rule_buf[CMD_BUFSIZE] = {0};
1209 : 13 : char snat_target[SNAT_TARGET_BUFSIZE] = {0};
1210 : 13 : struct fw_chain *snat_chain = NULL;
1211 : :
1212 [ + + ]: 13 : log_msg(LOG_DEBUG,
1213 : : "snat_rule() forward_all: %d, nat_ip: %s, nat_port: %d, force_snat: %d, force_snat_ip: %s, force_masq: %d",
1214 : 26 : acc->forward_all, nat_ip, nat_port, acc->force_snat,
1215 : 13 : (acc->force_snat_ip == NULL) ? "(NONE)" : acc->force_snat_ip,
1216 : 13 : acc->force_masquerade);
1217 : :
1218 [ + + ]: 13 : if(acc->forward_all)
1219 : : {
1220 : : /* Default to MASQUERADE */
1221 : 5 : snat_chain = &(opts->fw_config->chain[FIREWD_MASQUERADE_ACCESS]);
1222 : : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1, " ");
1223 : :
1224 : : /* Add SNAT or MASQUERADE rules.
1225 : : */
1226 [ + + ][ + + ]: 5 : if(acc->force_snat && is_valid_ipv4_addr(acc->force_snat_ip))
1227 : : {
1228 : : /* Using static SNAT */
1229 : 2 : snat_chain = &(opts->fw_config->chain[FIREWD_SNAT_ACCESS]);
1230 : 2 : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1,
1231 : : "--to-source %s", acc->force_snat_ip);
1232 : : }
1233 [ + + ]: 3 : else if((opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
1234 [ + - ]: 1 : && is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP]))
1235 : : {
1236 : : /* Using static SNAT */
1237 : 1 : snat_chain = &(opts->fw_config->chain[FIREWD_SNAT_ACCESS]);
1238 : 1 : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1,
1239 : : "--to-source %s", opts->config[CONF_SNAT_TRANSLATE_IP]);
1240 : : }
1241 : :
1242 : : memset(rule_buf, 0, CMD_BUFSIZE);
1243 : :
1244 : 5 : snprintf(rule_buf, CMD_BUFSIZE-1, FIREWD_SNAT_ALL_RULE_ARGS,
1245 : 5 : snat_chain->table,
1246 : : spadat->use_src_ip,
1247 : : exp_ts,
1248 : 5 : snat_chain->target,
1249 : : snat_target
1250 : : );
1251 : :
1252 : 5 : firewd_rule(opts, rule_buf, NULL, spadat->use_src_ip,
1253 : : NULL, ANY_PROTO, ANY_PORT, NULL, NAT_ANY_PORT,
1254 : : snat_chain, exp_ts, now, "SNAT ALL", "*/*");
1255 : : }
1256 : : else
1257 : : {
1258 : : /* Add SNAT or MASQUERADE rules.
1259 : : */
1260 [ + + ][ + + ]: 8 : if(acc->force_snat && is_valid_ipv4_addr(acc->force_snat_ip))
1261 : : {
1262 : : /* Using static SNAT */
1263 : 2 : snat_chain = &(opts->fw_config->chain[FIREWD_SNAT_ACCESS]);
1264 : 2 : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1,
1265 : : "--to-source %s:%i", acc->force_snat_ip, fst_port);
1266 : : }
1267 [ + + ][ + - ]: 6 : else if(acc->force_snat && acc->force_masquerade)
1268 : : {
1269 : : /* Using MASQUERADE */
1270 : 3 : snat_chain = &(opts->fw_config->chain[FIREWD_MASQUERADE_ACCESS]);
1271 : : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1,
1272 : : "--to-ports %i", fst_port);
1273 : : }
1274 [ + + ]: 3 : else if((opts->config[CONF_SNAT_TRANSLATE_IP] != NULL)
1275 [ + - ]: 2 : && is_valid_ipv4_addr(opts->config[CONF_SNAT_TRANSLATE_IP]))
1276 : : {
1277 : : /* Using static SNAT */
1278 : 2 : snat_chain = &(opts->fw_config->chain[FIREWD_SNAT_ACCESS]);
1279 : 2 : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1,
1280 : : "--to-source %s:%i", opts->config[CONF_SNAT_TRANSLATE_IP],
1281 : : fst_port);
1282 : : }
1283 : : else
1284 : : {
1285 : : /* Using MASQUERADE */
1286 : 1 : snat_chain = &(opts->fw_config->chain[FIREWD_MASQUERADE_ACCESS]);
1287 : : snprintf(snat_target, SNAT_TARGET_BUFSIZE-1,
1288 : : "--to-ports %i", fst_port);
1289 : : }
1290 : :
1291 : : memset(rule_buf, 0, CMD_BUFSIZE);
1292 : :
1293 : : snprintf(rule_buf, CMD_BUFSIZE-1, FIREWD_SNAT_RULE_ARGS,
1294 : 8 : snat_chain->table,
1295 : : fst_proto,
1296 : : nat_ip,
1297 : : nat_port,
1298 : : exp_ts,
1299 : 8 : snat_chain->target,
1300 : : snat_target
1301 : : );
1302 : :
1303 : 8 : firewd_rule(opts, rule_buf, NULL, spadat->use_src_ip,
1304 : : NULL, fst_proto, nat_port, nat_ip, nat_port,
1305 : : snat_chain, exp_ts, now, "SNAT",
1306 : 8 : spadat->spa_message_remain);
1307 : : }
1308 : 13 : return;
1309 : : }
1310 : :
1311 : : /****************************************************************************/
1312 : :
1313 : : /* Rule Processing - Create an access request...
1314 : : */
1315 : : int
1316 : 296 : process_spa_request(const fko_srv_options_t * const opts,
1317 : : const acc_stanza_t * const acc, spa_data_t * const spadat)
1318 : : {
1319 : 296 : char nat_ip[MAX_IPV4_STR_LEN] = {0};
1320 : 296 : unsigned int nat_port = 0;
1321 : : unsigned int fst_proto;
1322 : : unsigned int fst_port;
1323 : :
1324 : 296 : struct fw_chain * const in_chain = &(opts->fw_config->chain[FIREWD_INPUT_ACCESS]);
1325 : 296 : struct fw_chain * const out_chain = &(opts->fw_config->chain[FIREWD_OUTPUT_ACCESS]);
1326 : 296 : struct fw_chain * const fwd_chain = &(opts->fw_config->chain[FIREWD_FORWARD_ACCESS]);
1327 : 296 : struct fw_chain * const dnat_chain = &(opts->fw_config->chain[FIREWD_DNAT_ACCESS]);
1328 : :
1329 : 296 : acc_port_list_t *port_list = NULL;
1330 : 296 : acc_port_list_t *ple = NULL;
1331 : :
1332 : 296 : char *ndx = NULL;
1333 : 296 : int res = 0, is_err;
1334 : : time_t now;
1335 : : unsigned int exp_ts;
1336 : :
1337 : : /* Parse and expand our access message.
1338 : : */
1339 [ - + ]: 296 : if(expand_acc_port_list(&port_list, spadat->spa_message_remain) != 1)
1340 : : {
1341 : : /* technically we would already have exited with an error if there were
1342 : : * any memory allocation errors (see the add_port_list() function), but
1343 : : * for completeness...
1344 : : */
1345 : 0 : free_acc_port_list(port_list);
1346 : 0 : return res;
1347 : : }
1348 : :
1349 : : /* Start at the top of the proto-port list...
1350 : : */
1351 : 296 : ple = port_list;
1352 : :
1353 : : /* Remember the first proto/port combo in case we need them
1354 : : * for NAT access requests.
1355 : : */
1356 : 296 : fst_proto = ple->proto;
1357 : 296 : fst_port = ple->port;
1358 : :
1359 : : /* Set our expire time value.
1360 : : */
1361 : 296 : time(&now);
1362 : 296 : exp_ts = now + spadat->fw_access_timeout;
1363 : :
1364 : : /* deal with SPA packets that themselves request a NAT operation
1365 : : */
1366 [ + + ]: 296 : if(spadat->message_type == FKO_LOCAL_NAT_ACCESS_MSG
1367 : : || spadat->message_type == FKO_CLIENT_TIMEOUT_LOCAL_NAT_ACCESS_MSG
1368 : 296 : || spadat->message_type == FKO_NAT_ACCESS_MSG
1369 [ + - ]: 268 : || spadat->message_type == FKO_CLIENT_TIMEOUT_NAT_ACCESS_MSG
1370 [ + + ]: 268 : || acc->force_nat)
1371 : : {
1372 [ + + ]: 40 : if(acc->force_nat)
1373 : : {
1374 : 16 : strlcpy(nat_ip, acc->force_nat_ip, sizeof(nat_ip));
1375 : 16 : nat_port = acc->force_nat_port;
1376 : : }
1377 : : else
1378 : : {
1379 : 24 : ndx = strchr(spadat->nat_access, ',');
1380 [ + - ]: 24 : if(ndx != NULL)
1381 : : {
1382 : 24 : strlcpy(nat_ip, spadat->nat_access, (ndx-spadat->nat_access)+1);
1383 [ - + ]: 24 : if (! is_valid_ipv4_addr(nat_ip))
1384 : : {
1385 : 0 : log_msg(LOG_INFO, "Invalid NAT IP in SPA message");
1386 : 0 : free_acc_port_list(port_list);
1387 : 0 : return res;
1388 : : }
1389 : :
1390 : 24 : nat_port = strtol_wrapper(ndx+1, 0, MAX_PORT,
1391 : : NO_EXIT_UPON_ERR, &is_err);
1392 [ - + ]: 24 : if(is_err != FKO_SUCCESS)
1393 : : {
1394 : 0 : log_msg(LOG_INFO, "Invalid NAT port in SPA message");
1395 : 0 : free_acc_port_list(port_list);
1396 : 0 : res = is_err;
1397 : 0 : return res;
1398 : : }
1399 : : }
1400 : : }
1401 : :
1402 [ + + ]: 40 : if(spadat->message_type == FKO_LOCAL_NAT_ACCESS_MSG)
1403 : : {
1404 [ - + ]: 8 : firewd_rule(opts, NULL, FIREWD_RULE_ARGS, spadat->use_src_ip,
1405 : 8 : (fwc.use_destination ? spadat->pkt_destination_ip : FIREWD_ANY_IP),
1406 : : fst_proto, nat_port, nat_ip, nat_port, in_chain, exp_ts,
1407 : : now, "local NAT", spadat->spa_message_remain);
1408 : : }
1409 [ + - ]: 32 : else if(strlen(fwd_chain->to_chain))
1410 : : {
1411 : : /* FORWARD access rule
1412 : : */
1413 : 32 : forward_access_rule(opts, acc, fwd_chain, nat_ip,
1414 : : nat_port, fst_proto, fst_port, spadat, exp_ts, now);
1415 : : }
1416 : :
1417 : : /* DNAT rule
1418 : : */
1419 [ + - ][ + + ]: 40 : if(strlen(dnat_chain->to_chain) && !acc->disable_dnat)
1420 : 37 : dnat_rule(opts, acc, dnat_chain, nat_ip,
1421 : : nat_port, fst_proto, fst_port, spadat, exp_ts, now);
1422 : :
1423 : : /* SNAT rule
1424 : : */
1425 [ + + ][ + + ]: 40 : if(acc->force_snat || strncasecmp(opts->config[CONF_ENABLE_FIREWD_SNAT], "Y", 1) == 0)
1426 : 13 : snat_rule(opts, acc, nat_ip, nat_port,
1427 : : fst_proto, fst_port, spadat, exp_ts, now);
1428 : : }
1429 : : else /* Non-NAT request - this is the typical case. */
1430 : : {
1431 : : /* Create an access command for each proto/port for the source ip.
1432 : : */
1433 [ + + ]: 520 : while(ple != NULL)
1434 : : {
1435 [ + + ]: 264 : firewd_rule(opts, NULL, FIREWD_RULE_ARGS, spadat->use_src_ip,
1436 : 264 : (fwc.use_destination ? spadat->pkt_destination_ip : FIREWD_ANY_IP),
1437 : : ple->proto, ple->port, NULL, NAT_ANY_PORT,
1438 : : in_chain, exp_ts, now, "access", spadat->spa_message_remain);
1439 : :
1440 : : /* We need to make a corresponding OUTPUT rule if out_chain target
1441 : : * is not NULL.
1442 : : */
1443 [ + + ]: 264 : if(strlen(out_chain->to_chain))
1444 : : {
1445 [ - + ]: 1 : firewd_rule(opts, NULL, FIREWD_OUT_RULE_ARGS, spadat->use_src_ip,
1446 : 1 : (fwc.use_destination ? spadat->pkt_destination_ip : FIREWD_ANY_IP),
1447 : : ple->proto, ple->port, NULL, NAT_ANY_PORT,
1448 : : out_chain, exp_ts, now, "OUTPUT", spadat->spa_message_remain);
1449 : : }
1450 : 264 : ple = ple->next;
1451 : : }
1452 : : }
1453 : :
1454 : : /* Done with the port list for access rules.
1455 : : */
1456 : 296 : free_acc_port_list(port_list);
1457 : :
1458 : 296 : return(res);
1459 : : }
1460 : :
1461 : : static void
1462 : 655 : rm_expired_rules(const fko_srv_options_t * const opts,
1463 : : const char * const fw_output_buf,
1464 : : char *ndx, struct fw_chain *ch, int cpos, time_t now)
1465 : : {
1466 : 655 : char exp_str[12] = {0};
1467 : 655 : char rule_num_str[6] = {0};
1468 : : char *rn_start, *rn_end, *tmp_mark;
1469 : :
1470 : 655 : int res, is_err, rn_offset=0, rule_num;
1471 : 655 : time_t rule_exp, min_exp = 0;
1472 : :
1473 : : /* walk the list and process rules as needed.
1474 : : */
1475 [ + + ]: 1416 : while (ndx != NULL) {
1476 : : /* Jump forward and extract the timestamp
1477 : : */
1478 : 761 : ndx += strlen(EXPIRE_COMMENT_PREFIX);
1479 : :
1480 : : /* remember this spot for when we look for the next
1481 : : * rule.
1482 : : */
1483 : 761 : tmp_mark = ndx;
1484 : :
1485 : 761 : strlcpy(exp_str, ndx, sizeof(exp_str));
1486 : 761 : chop_spaces(exp_str);
1487 [ + + ]: 761 : if(!is_digits(exp_str))
1488 : : {
1489 : : /* go to the next rule if it exists
1490 : : */
1491 : 27 : ndx = strstr(tmp_mark, EXPIRE_COMMENT_PREFIX);
1492 : 27 : continue;
1493 : : }
1494 : :
1495 : 734 : rule_exp = (time_t)atoll(exp_str);
1496 : :
1497 [ + + ]: 734 : if(rule_exp <= now)
1498 : : {
1499 : : /* Backtrack and get the rule number and delete it.
1500 : : */
1501 : : rn_start = ndx;
1502 [ + - ]: 33012 : while(--rn_start > fw_output_buf)
1503 : : {
1504 [ + + ]: 33392 : if(*rn_start == '\n')
1505 : : break;
1506 : : }
1507 : :
1508 [ - + ]: 380 : if(*rn_start != '\n')
1509 : : {
1510 : : /* This should not happen. But if it does, complain,
1511 : : * decrement the active rule value, and go on.
1512 : : */
1513 : 0 : log_msg(LOG_ERR,
1514 : : "Rule parse error while finding rule line start in chain %i",
1515 : : cpos);
1516 : :
1517 [ # # ]: 0 : if (ch[cpos].active_rules > 0)
1518 : 0 : ch[cpos].active_rules--;
1519 : :
1520 : : break;
1521 : : }
1522 : 380 : rn_start++;
1523 : :
1524 : 380 : rn_end = strchr(rn_start, ' ');
1525 [ - + ]: 380 : if(rn_end == NULL)
1526 : : {
1527 : : /* This should not happen. But if it does, complain,
1528 : : * decrement the active rule value, and go on.
1529 : : */
1530 : 0 : log_msg(LOG_ERR,
1531 : : "Rule parse error while finding rule number in chain %i",
1532 : : cpos);
1533 : :
1534 [ # # ]: 0 : if (ch[cpos].active_rules > 0)
1535 : 0 : ch[cpos].active_rules--;
1536 : :
1537 : : break;
1538 : : }
1539 : :
1540 : 380 : strlcpy(rule_num_str, rn_start, (rn_end - rn_start)+1);
1541 : :
1542 : 380 : rule_num = strtol_wrapper(rule_num_str, rn_offset, RCHK_MAX_FIREWD_RULE_NUM,
1543 : : NO_EXIT_UPON_ERR, &is_err);
1544 [ - + ]: 380 : if(is_err != FKO_SUCCESS)
1545 : : {
1546 : 0 : log_msg(LOG_ERR,
1547 : : "Rule parse error while finding rule number in chain %i",
1548 : : cpos);
1549 : :
1550 [ # # ]: 0 : if (ch[cpos].active_rules > 0)
1551 : 0 : ch[cpos].active_rules--;
1552 : :
1553 : : break;
1554 : : }
1555 : :
1556 : 380 : zero_cmd_buffers();
1557 : :
1558 : 380 : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_DEL_RULE_ARGS,
1559 : 380 : opts->fw_config->fw_command,
1560 : 380 : ch[cpos].table,
1561 : 380 : ch[cpos].to_chain,
1562 : : rule_num - rn_offset /* account for position of previously
1563 : : deleted rule with rn_offset */
1564 : : );
1565 : :
1566 : 380 : res = run_extcmd(cmd_buf, err_buf, CMD_BUFSIZE,
1567 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
1568 : 380 : chop_newline(err_buf);
1569 : :
1570 : 380 : log_msg(LOG_DEBUG, "check_firewall_rules() CMD: '%s' (res: %d, err: %s)",
1571 : : cmd_buf, res, err_buf);
1572 : :
1573 [ + - ]: 380 : if(EXTCMD_IS_SUCCESS(res))
1574 : : {
1575 : 380 : log_msg(LOG_INFO, "Removed rule %s from %s with expire time of %u",
1576 : : rule_num_str, ch[cpos].to_chain, rule_exp
1577 : : );
1578 : :
1579 : 380 : rn_offset++;
1580 : :
1581 [ + + ]: 380 : if (ch[cpos].active_rules > 0)
1582 : 347 : ch[cpos].active_rules--;
1583 : : }
1584 : : else
1585 : 0 : log_msg(LOG_ERR, "rm_expired_rules() Error %i from cmd:'%s': %s",
1586 : : res, cmd_buf, err_buf);
1587 : :
1588 : : }
1589 : : else
1590 : : {
1591 : : /* Track the minimum future rule expire time.
1592 : : */
1593 : 354 : min_exp = (min_exp < rule_exp) ? min_exp : rule_exp;
1594 : : }
1595 : :
1596 : : /* Push our tracking index forward beyond (just processed) _exp_
1597 : : * string so we can continue to the next rule in the list.
1598 : : */
1599 : 761 : ndx = strstr(tmp_mark, EXPIRE_COMMENT_PREFIX);
1600 : : }
1601 : :
1602 : : /* Set the next pending expire time accordingly. 0 if there are no
1603 : : * more rules, or whatever the next expected (min_exp) time will be.
1604 : : */
1605 [ + + ]: 655 : if(ch[cpos].active_rules < 1)
1606 : 356 : ch[cpos].next_expire = 0;
1607 [ - + ]: 299 : else if(min_exp)
1608 : 0 : ch[cpos].next_expire = min_exp;
1609 : :
1610 : 655 : return;
1611 : : }
1612 : :
1613 : : /* Iterate over the configure firewall access chains and purge expired
1614 : : * firewall rules.
1615 : : */
1616 : : void
1617 : 19821 : check_firewall_rules(const fko_srv_options_t * const opts,
1618 : : const int chk_rm_all)
1619 : : {
1620 : : char *ndx;
1621 : 19821 : char fw_output_buf[STANDARD_CMD_OUT_BUFSIZE] = {0};
1622 : :
1623 : : int i, res;
1624 : : time_t now;
1625 : :
1626 : 19821 : struct fw_chain *ch = opts->fw_config->chain;
1627 : :
1628 : 19821 : time(&now);
1629 : :
1630 : : /* Iterate over each chain and look for active rules to delete.
1631 : : */
1632 [ + + ]: 138747 : for(i=0; i < NUM_FWKNOP_ACCESS_TYPES; i++)
1633 : : {
1634 : : /* If there are no active rules or we have not yet
1635 : : * reached our expected next expire time, continue.
1636 : : */
1637 [ + + ][ + + ]: 118926 : if(!chk_rm_all && (ch[i].active_rules == 0 || ch[i].next_expire > now))
[ + + ]
1638 : 113695 : continue;
1639 : :
1640 [ + + ][ - + ]: 5231 : if(ch[i].table[0] == '\0' || ch[i].to_chain[i] == '\0')
1641 : 3888 : continue;
1642 : :
1643 : 1343 : zero_cmd_buffers();
1644 : : memset(fw_output_buf, 0x0, STANDARD_CMD_OUT_BUFSIZE);
1645 : :
1646 : : /* Get the current list of rules for this chain and delete
1647 : : * any that have expired. Note that chk_rm_all puts us in
1648 : : * garbage collection mode, and allows any rules that have
1649 : : * been manually added (potentially by a program separate
1650 : : * from fwknopd) to take advantage of fwknopd's timeout
1651 : : * mechanism.
1652 : : */
1653 : : snprintf(cmd_buf, CMD_BUFSIZE-1, "%s " FIREWD_LIST_RULES_ARGS,
1654 : 1343 : opts->fw_config->fw_command,
1655 : 1343 : ch[i].table,
1656 : 1343 : ch[i].to_chain
1657 : : );
1658 : :
1659 : 1343 : res = run_extcmd(cmd_buf, fw_output_buf, STANDARD_CMD_OUT_BUFSIZE,
1660 : : WANT_STDERR, NO_TIMEOUT, &pid_status, opts);
1661 : 1343 : chop_newline(fw_output_buf);
1662 : :
1663 : 1343 : log_msg(LOG_DEBUG,
1664 : : "check_firewall_rules() CMD: '%s' (res: %d, fw_output_buf: %s)",
1665 : : cmd_buf, res, fw_output_buf);
1666 : :
1667 [ - + ]: 1343 : if(!EXTCMD_IS_SUCCESS(res))
1668 : : {
1669 : 0 : log_msg(LOG_ERR,
1670 : : "check_firewall_rules() Error %i from cmd:'%s': %s",
1671 : : res, cmd_buf, fw_output_buf);
1672 : 0 : continue;
1673 : : }
1674 : :
1675 : 1343 : log_msg(LOG_DEBUG, "RES=%i, CMD_BUF: %s\nRULES LIST: %s",
1676 : : res, cmd_buf, fw_output_buf);
1677 : :
1678 : 1343 : ndx = strstr(fw_output_buf, EXPIRE_COMMENT_PREFIX);
1679 [ + + ]: 1343 : if(ndx == NULL)
1680 : : {
1681 : : /* we did not find a candidate rule to expire
1682 : : */
1683 : 688 : log_msg(LOG_DEBUG,
1684 : : "Did not find expire comment in rules list %i", i);
1685 : :
1686 [ + + ]: 688 : if (ch[i].active_rules > 0)
1687 : 1 : ch[i].active_rules--;
1688 : :
1689 : 688 : continue;
1690 : : }
1691 : :
1692 : 655 : rm_expired_rules(opts, fw_output_buf, ndx, ch, i, now);
1693 : : }
1694 : :
1695 : 19821 : return;
1696 : : }
1697 : :
1698 : : int
1699 : 25135 : validate_firewd_chain_conf(const char * const chain_str)
1700 : : {
1701 : 25135 : int j, rv = 1;
1702 : 25135 : const char *ndx = chain_str;
1703 : :
1704 : 25135 : j = 1;
1705 [ + + ]: 1180527 : while(*ndx != '\0')
1706 : : {
1707 [ + + ]: 1155394 : if(*ndx == ',')
1708 : 125647 : j++;
1709 : :
1710 [ + + ]: 1155394 : if(*ndx != '\0'
1711 : 1155394 : && *ndx != ' '
1712 [ + + ]: 1029746 : && *ndx != ','
1713 [ + + ]: 904099 : && *ndx != '_'
1714 [ + + ]: 878951 : && isalnum(*ndx) == 0)
1715 : : {
1716 : : rv = 0;
1717 : : break;
1718 : : }
1719 : 1155392 : ndx++;
1720 : : }
1721 : :
1722 : : /* Sanity check - j should be the number of chain fields
1723 : : * (excluding the type).
1724 : : */
1725 [ + + ]: 25135 : if(j != FW_NUM_CHAIN_FIELDS)
1726 : 7 : rv = 0;
1727 : :
1728 : 25135 : return rv;
1729 : : }
1730 : :
1731 : : #endif /* FIREWALL_FIREWALLD */
1732 : :
1733 : : /***EOF***/
|
