LCOV - code coverage report
Current view: top level - server - fwknopd.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 223 290 76.9 %
Date: 2014-11-16 Functions: 15 15 100.0 %
Branches: 120 174 69.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  *****************************************************************************
       3                 :            :  *
       4                 :            :  * File:    fwknopd.c
       5                 :            :  *
       6                 :            :  * Purpose: An implementation of an 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.h"
      32                 :            : #include "access.h"
      33                 :            : #include "config_init.h"
      34                 :            : #include "log_msg.h"
      35                 :            : #include "utils.h"
      36                 :            : #include "fw_util.h"
      37                 :            : #include "sig_handler.h"
      38                 :            : #include "replay_cache.h"
      39                 :            : #include "tcp_server.h"
      40                 :            : #include "udp_server.h"
      41                 :            : 
      42                 :            : #if USE_LIBPCAP
      43                 :            :   #include "pcap_capture.h"
      44                 :            : #endif
      45                 :            : 
      46                 :            : /* Prototypes
      47                 :            : */
      48                 :            : static int check_dir_path(const char * const path,
      49                 :            :         const char * const path_name, const unsigned char use_basename);
      50                 :            : static int make_dir_path(const char * const path);
      51                 :            : static void daemonize_process(fko_srv_options_t * const opts);
      52                 :            : static int stop_fwknopd(fko_srv_options_t * const opts);
      53                 :            : static int status_fwknopd(fko_srv_options_t * const opts);
      54                 :            : static int restart_fwknopd(fko_srv_options_t * const opts);
      55                 :            : static int write_pid_file(fko_srv_options_t *opts);
      56                 :            : static int handle_signals(fko_srv_options_t *opts);
      57                 :            : static void setup_pid(fko_srv_options_t *opts);
      58                 :            : static void init_digest_cache(fko_srv_options_t *opts);
      59                 :            : static void set_locale(fko_srv_options_t *opts);
      60                 :            : static pid_t get_running_pid(const fko_srv_options_t *opts);
      61                 :            : #if AFL_FUZZING
      62                 :            : static void afl_pkt_from_stdin(fko_srv_options_t *opts);
      63                 :            : #endif
      64                 :            : 
      65                 :            : #if HAVE_LIBFIU
      66                 :            : static void enable_fault_injections(fko_srv_options_t * const opts);
      67                 :            : #endif
      68                 :            : 
      69                 :            : #if AFL_FUZZING
      70                 :            : #define AFL_MAX_PKT_SIZE  1024
      71                 :            : #define AFL_DUMP_CTX_SIZE 4096
      72                 :            : #endif
      73                 :            : 
      74                 :            : int
      75                 :      11010 : main(int argc, char **argv)
      76                 :            : {
      77                 :            :     fko_srv_options_t   opts;
      78                 :            : 
      79                 :            :     while(1)
      80                 :            :     {
      81                 :            :         /* Handle command line
      82                 :            :         */
      83                 :       5506 :         config_init(&opts, argc, argv);
      84                 :            : 
      85                 :            : #if HAVE_LIBFIU
      86                 :            :         /* Set any fault injection points early
      87                 :            :         */
      88                 :       3708 :         enable_fault_injections(&opts);
      89                 :            : #endif
      90                 :            : 
      91                 :            :         /* Process any options that do their thing and exit.
      92                 :            :         */
      93                 :            : 
      94                 :            :         /* Kill the currently running fwknopd process?
      95                 :            :         */
      96         [ +  + ]:       3708 :         if(opts.kill == 1)
      97                 :        371 :             clean_exit(&opts, NO_FW_CLEANUP, stop_fwknopd(&opts));
      98                 :            : 
      99                 :            :         /* Status of the currently running fwknopd process?
     100                 :            :         */
     101         [ +  + ]:       3337 :         if(opts.status == 1)
     102                 :        739 :             clean_exit(&opts, NO_FW_CLEANUP, status_fwknopd(&opts));
     103                 :            : 
     104                 :            :         /* Restart the currently running fwknopd process?
     105                 :            :         */
     106         [ +  + ]:       2598 :         if(opts.restart == 1)
     107                 :          4 :             clean_exit(&opts, NO_FW_CLEANUP, restart_fwknopd(&opts));
     108                 :            : 
     109                 :            :         /* Initialize logging.
     110                 :            :         */
     111                 :       2594 :         init_logging(&opts);
     112                 :            : 
     113                 :            :         /* Update the verbosity level for the log module */
     114                 :       2582 :         log_set_verbosity(LOG_DEFAULT_VERBOSITY + opts.verbose);
     115                 :            : 
     116                 :            : #if HAVE_LOCALE_H
     117                 :            :         /* Set the locale if specified.
     118                 :            :         */
     119                 :       2582 :         set_locale(&opts);
     120                 :            : #endif
     121                 :            : 
     122                 :            :         /* Make sure we have a valid run dir and path leading to digest file
     123                 :            :          * in case it configured to be somewhere other than the run dir.
     124                 :            :         */
     125         [ +  - ]:       2582 :         if(!opts.afl_fuzzing
     126         [ +  + ]:       2582 :                 && ! check_dir_path((const char *)opts.config[CONF_FWKNOP_RUN_DIR], "Run", 0))
     127                 :          2 :             clean_exit(&opts, NO_FW_CLEANUP, EXIT_FAILURE);
     128                 :            : 
     129                 :            :         /* Initialize the firewall rules handler based on the fwknopd.conf
     130                 :            :          * file, but (for iptables firewalls) don't flush any rules or create
     131                 :            :          * any chains yet. This allows us to dump the current firewall rules
     132                 :            :          * via fw_rules_dump() in --fw-list mode before changing around any rules
     133                 :            :          * of an existing fwknopd process.
     134                 :            :         */
     135         [ +  + ]:       2580 :         if(fw_config_init(&opts) != 1)
     136                 :          3 :             clean_exit(&opts, NO_FW_CLEANUP, EXIT_FAILURE);
     137                 :            : 
     138 [ +  + ][ -  + ]:       2577 :         if(opts.fw_list == 1 || opts.fw_list_all == 1)
     139                 :            :         {
     140                 :        891 :             fw_dump_rules(&opts);
     141                 :        891 :             clean_exit(&opts, NO_FW_CLEANUP, EXIT_SUCCESS);
     142                 :            :         }
     143                 :            : 
     144         [ +  + ]:       1686 :         if(opts.fw_flush == 1)
     145                 :            :         {
     146                 :         18 :             fprintf(stdout, "Deleting any existing firewall rules...\n");
     147                 :         18 :             clean_exit(&opts, FW_CLEANUP, EXIT_SUCCESS);
     148                 :            :         }
     149                 :            : 
     150                 :            :         /* Process the access.conf file.
     151                 :            :         */
     152                 :       1668 :         parse_access_file(&opts);
     153                 :            : 
     154                 :            :         /* Show config (including access.conf vars) and exit dump config was
     155                 :            :          * wanted.
     156                 :            :         */
     157         [ +  + ]:       1587 :         if(opts.dump_config == 1)
     158                 :            :         {
     159                 :         15 :             dump_config(&opts);
     160                 :         15 :             dump_access_list(&opts);
     161                 :         15 :             clean_exit(&opts, NO_FW_CLEANUP, EXIT_SUCCESS);
     162                 :            :         }
     163                 :            : 
     164                 :            :         /* Acquire pid, become a daemon or run in the foreground, write pid
     165                 :            :          * to pid file.
     166                 :            :         */
     167                 :       1572 :         setup_pid(&opts);
     168                 :            : 
     169 [ +  + ][ +  + ]:       1572 :         if(opts.verbose > 1 && opts.foreground)
     170                 :            :         {
     171                 :       1565 :             dump_config(&opts);
     172                 :       1565 :             dump_access_list(&opts);
     173                 :            :         }
     174                 :            : 
     175                 :            :         /* Initialize the digest cache for replay attack detection (either
     176                 :            :          * with dbm support or with the default simple cache file strategy)
     177                 :            :          * if so configured.
     178                 :            :         */
     179                 :       1572 :         init_digest_cache(&opts);
     180                 :            : 
     181         [ +  + ]:       1572 :         if(opts.exit_after_parse_config)
     182                 :            :         {
     183                 :       1103 :             log_msg(LOG_INFO, "Configs parsed, exiting.");
     184                 :       1103 :             clean_exit(&opts, NO_FW_CLEANUP, EXIT_SUCCESS);
     185                 :            :         }
     186                 :            : 
     187                 :            : #if AFL_FUZZING
     188                 :            :         /* SPA data from STDIN. */
     189                 :            :         if(opts.afl_fuzzing)
     190                 :            :             afl_pkt_from_stdin(&opts);
     191                 :            : #endif
     192                 :            : 
     193                 :            :         /* Prepare the firewall - i.e. flush any old rules and (for iptables)
     194                 :            :          * create fwknop chains.
     195                 :            :         */
     196 [ +  + ][ +  + ]:        469 :         if(!opts.test && (fw_initialize(&opts) != 1))
     197                 :          3 :             clean_exit(&opts, FW_CLEANUP, EXIT_FAILURE);
     198                 :            : 
     199                 :            :         /* If we are to acquire SPA data via a UDP socket, start it up here.
     200                 :            :         */
     201 [ +  + ][ +  + ]:        466 :         if(opts.enable_udp_server ||
     202                 :        457 :                 strncasecmp(opts.config[CONF_ENABLE_UDP_SERVER], "Y", 1) == 0)
     203                 :            :         {
     204         [ -  + ]:         11 :             if(run_udp_server(&opts) < 0)
     205                 :            :             {
     206                 :          0 :                 log_msg(LOG_ERR, "Fatal run_udp_server() error");
     207                 :          0 :                 clean_exit(&opts, FW_CLEANUP, EXIT_FAILURE);
     208                 :            :             }
     209                 :            :             else
     210                 :            :             {
     211                 :            :                 break;
     212                 :            :             }
     213                 :            :         }
     214                 :            : 
     215                 :            :         /* If the TCP server option was set, fire it up here. Note that in
     216                 :            :          * this mode, fwknopd still acquires SPA packets via libpcap. If you
     217                 :            :          * want to use UDP only without the libpcap dependency, see the FIXME...
     218                 :            :         */
     219         [ +  + ]:        455 :         if(strncasecmp(opts.config[CONF_ENABLE_TCP_SERVER], "Y", 1) == 0)
     220                 :            :         {
     221         [ -  + ]:          1 :             if(run_tcp_server(&opts) < 0)
     222                 :            :             {
     223                 :          0 :                 log_msg(LOG_ERR, "Fatal run_tcp_server() error");
     224                 :          0 :                 clean_exit(&opts, FW_CLEANUP, EXIT_FAILURE);
     225                 :            :             }
     226                 :            :         }
     227                 :            : 
     228                 :            : #if USE_LIBPCAP
     229                 :            :         /* Intiate pcap capture mode...
     230                 :            :         */
     231         [ +  - ]:        455 :         if(strncasecmp(opts.config[CONF_ENABLE_UDP_SERVER], "N", 1) == 0)
     232                 :        455 :             pcap_capture(&opts);
     233                 :            : #endif
     234                 :            : 
     235                 :            :         /* Deal with any signals that we've received and break out
     236                 :            :          * of the loop for any terminating signals
     237                 :            :         */
     238         [ +  + ]:        384 :         if(handle_signals(&opts) == 1)
     239                 :            :             break;
     240                 :            :     }
     241                 :            : 
     242                 :        394 :     log_msg(LOG_INFO, "Shutting Down fwknopd.");
     243                 :            : 
     244                 :            :     /* Kill the TCP server (if we have one running).
     245                 :            :     */
     246         [ -  + ]:        394 :     if(opts.tcp_server_pid > 0)
     247                 :            :     {
     248                 :          0 :         log_msg(LOG_INFO, "Killing the TCP server (pid=%i)",
     249                 :            :             opts.tcp_server_pid);
     250                 :            : 
     251                 :          0 :         kill(opts.tcp_server_pid, SIGTERM);
     252                 :            : 
     253                 :            :         /* --DSS XXX: This seems to be necessary if the tcp server
     254                 :            :          *            was restarted by this program. We need to
     255                 :            :          *            investigate and fix this. For now, this works
     256                 :            :          *            (it is kludgy, but does no harm afaik).
     257                 :            :         */
     258                 :          0 :         kill(opts.tcp_server_pid, SIGKILL);
     259                 :            :     }
     260                 :            : 
     261                 :        394 :     clean_exit(&opts, FW_CLEANUP, EXIT_SUCCESS);
     262                 :            : 
     263                 :            :     return(EXIT_SUCCESS);  /* This never gets called */
     264                 :            : }
     265                 :            : 
     266                 :       2582 : static void set_locale(fko_srv_options_t *opts)
     267                 :            : {
     268                 :            :     char               *locale;
     269                 :            : 
     270         [ +  + ]:       2582 :     if(opts->config[CONF_LOCALE] != NULL
     271         [ +  - ]:          2 :       && strncasecmp(opts->config[CONF_LOCALE], "NONE", 4) != 0)
     272                 :            :     {
     273                 :          2 :         locale = setlocale(LC_ALL, opts->config[CONF_LOCALE]);
     274                 :            : 
     275         [ +  + ]:          2 :         if(locale == NULL)
     276                 :            :         {
     277                 :          1 :             log_msg(LOG_ERR,
     278                 :            :                 "WARNING: Unable to set locale to '%s'.",
     279                 :            :                 opts->config[CONF_LOCALE]
     280                 :            :             );
     281                 :            :         }
     282                 :            :         else
     283                 :            :         {
     284                 :          1 :             log_msg(LOG_INFO,
     285                 :            :                 "Locale set to '%s'.", opts->config[CONF_LOCALE]
     286                 :            :             );
     287                 :            :         }
     288                 :            :     }
     289                 :       2582 :     return;
     290                 :            : }
     291                 :            : 
     292                 :            : #if AFL_FUZZING
     293                 :            : static void afl_pkt_from_stdin(fko_srv_options_t *opts)
     294                 :            : {
     295                 :            :     FILE                *fp = NULL;
     296                 :            :     fko_ctx_t           decode_ctx = NULL;
     297                 :            :     unsigned char       spa_pkt[AFL_MAX_PKT_SIZE] = {0};
     298                 :            :     int                 res = 0, es = EXIT_SUCCESS;
     299                 :            :     char                dump_buf[AFL_DUMP_CTX_SIZE];
     300                 :            : 
     301                 :            :     fp = fdopen(STDIN_FILENO, "r");
     302                 :            :     if(fp != NULL)
     303                 :            :     {
     304                 :            :         if(fgets((char *)spa_pkt, AFL_MAX_PKT_SIZE, fp) == NULL)
     305                 :            :         {
     306                 :            :             fclose(fp);
     307                 :            :             clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     308                 :            :         }
     309                 :            : 
     310                 :            :         fclose(fp);
     311                 :            : 
     312                 :            :         fko_new(&decode_ctx);
     313                 :            : 
     314                 :            :         res = fko_set_encoded_data(decode_ctx, (char *) spa_pkt,
     315                 :            :                 strlen((char *)spa_pkt), 0, FKO_DIGEST_SHA256);
     316                 :            : 
     317                 :            :         if(res == FKO_SUCCESS)
     318                 :            :             res = fko_set_spa_data(decode_ctx, (const char *) spa_pkt);
     319                 :            :         if(res == FKO_SUCCESS)
     320                 :            :             res = fko_decode_spa_data(decode_ctx);
     321                 :            :         if(res == FKO_SUCCESS)
     322                 :            :             res = dump_ctx_to_buffer(decode_ctx, dump_buf, sizeof(dump_buf));
     323                 :            :         if(res == FKO_SUCCESS)
     324                 :            :             log_msg(LOG_INFO, "%s", dump_buf);
     325                 :            : 
     326                 :            :         fko_destroy(decode_ctx);
     327                 :            : 
     328                 :            :         if(res == FKO_SUCCESS)
     329                 :            :         {
     330                 :            :             log_msg(LOG_INFO, "SPA packet decode: %s", fko_errstr(res));
     331                 :            :             es = EXIT_SUCCESS;
     332                 :            :         }
     333                 :            :         else
     334                 :            :         {
     335                 :            :             log_msg(LOG_ERR, "Could not decode SPA packet: %s", fko_errstr(res));
     336                 :            :             es = EXIT_FAILURE;
     337                 :            :         }
     338                 :            :     }
     339                 :            :     else
     340                 :            :         log_msg(LOG_ERR, "Could not acquire SPA packet from stdin.");
     341                 :            : 
     342                 :            :     clean_exit(opts, NO_FW_CLEANUP, es);
     343                 :            : }
     344                 :            : #endif
     345                 :            : 
     346                 :       1572 : static void init_digest_cache(fko_srv_options_t *opts)
     347                 :            : {
     348                 :            :     int     rp_cache_count;
     349                 :            : 
     350                 :            : #if AFL_FUZZING
     351                 :            :     if(opts->afl_fuzzing)
     352                 :            :         return;
     353                 :            : #endif
     354                 :            : 
     355         [ +  - ]:       1572 :     if(strncasecmp(opts->config[CONF_ENABLE_DIGEST_PERSISTENCE], "Y", 1) == 0)
     356                 :            :     {
     357                 :       1572 :         rp_cache_count = replay_cache_init(opts);
     358                 :            : 
     359         [ +  + ]:       1572 :         if(rp_cache_count < 0)
     360                 :            :         {
     361                 :          8 :             log_msg(LOG_WARNING,
     362                 :            :                 "Error opening digest cache file. Incoming digests will not be remembered."
     363                 :            :             );
     364                 :            :             /* Destination points to heap memory, and is guaranteed to be
     365                 :            :              * at least two bytes large via validate_options(),
     366                 :            :              * DEF_ENABLE_DIGEST_PERSISTENCE, and set_config_entry()
     367                 :            :             */
     368                 :          8 :             strlcpy(opts->config[CONF_ENABLE_DIGEST_PERSISTENCE], "N", 2);
     369                 :            :         }
     370                 :            : 
     371         [ +  + ]:       1572 :         if(opts->verbose)
     372                 :       1566 :             log_msg(LOG_ERR,
     373                 :            :                 "Using Digest Cache: '%s' (entry count = %i)",
     374                 :            : #if USE_FILE_CACHE
     375                 :            :                 opts->config[CONF_DIGEST_FILE], rp_cache_count
     376                 :            : #else
     377                 :            :                 opts->config[CONF_DIGEST_DB_FILE], rp_cache_count
     378                 :            : #endif
     379                 :            :             );
     380                 :            :     }
     381                 :       1572 :     return;
     382                 :            : }
     383                 :            : 
     384                 :       1572 : static void setup_pid(fko_srv_options_t *opts)
     385                 :            : {
     386                 :            :     pid_t    old_pid;
     387                 :            : 
     388                 :            : #if AFL_FUZZING
     389                 :            :     if(opts->afl_fuzzing)
     390                 :            :         return;
     391                 :            : #endif
     392                 :            : 
     393                 :            :     /* If we are a new process (just being started), proceed with normal
     394                 :            :      * start-up. Otherwise, we are here as a result of a signal sent to an
     395                 :            :      * existing process and we want to restart.
     396                 :            :     */
     397         [ +  - ]:       1572 :     if(get_running_pid(opts) != getpid())
     398                 :            :     {
     399                 :            :         /* If foreground mode is not set, then fork off and become a daemon.
     400                 :            :         * Otherwise, attempt to get the pid file lock and go on.
     401                 :            :         */
     402         [ +  + ]:       1572 :         if(opts->foreground == 0)
     403                 :            :         {
     404                 :          1 :             daemonize_process(opts);
     405                 :            :         }
     406                 :            :         else
     407                 :            :         {
     408                 :       1571 :             old_pid = write_pid_file(opts);
     409         [ -  + ]:       1571 :             if(old_pid > 0)
     410                 :            :             {
     411                 :          0 :                 fprintf(stderr,
     412                 :            :                     "[*] An instance of fwknopd is already running: (PID=%i).\n", old_pid
     413                 :            :                 );
     414                 :            : 
     415                 :          0 :                 clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     416                 :            :             }
     417         [ -  + ]:       1571 :             else if(old_pid < 0)
     418                 :            :             {
     419                 :          0 :                 fprintf(stderr, "[*] PID file error. The lock may not be effective.\n");
     420                 :            :             }
     421                 :            :         }
     422                 :            : 
     423                 :       1572 :         log_msg(LOG_INFO, "Starting %s", MY_NAME);
     424                 :            :     }
     425                 :            :     else
     426                 :            :     {
     427                 :          0 :         log_msg(LOG_INFO, "Re-starting %s", MY_NAME);
     428                 :            :     }
     429                 :            : 
     430                 :       1572 :     return;
     431                 :            : }
     432                 :            : 
     433                 :          4 : static int restart_fwknopd(fko_srv_options_t * const opts)
     434                 :            : {
     435                 :          4 :     int      res = 0;
     436                 :            :     pid_t    old_pid;
     437                 :            : 
     438                 :          4 :     old_pid = get_running_pid(opts);
     439                 :            : 
     440         [ +  - ]:          4 :     if(old_pid > 0)
     441                 :            :     {
     442                 :          4 :         res = kill(old_pid, SIGHUP);
     443         [ +  + ]:          4 :         if(res == 0)
     444                 :            :         {
     445                 :          1 :             fprintf(stdout, "Sent restart signal to fwknopd (pid=%i)\n", old_pid);
     446                 :          1 :             return EXIT_SUCCESS;
     447                 :            :         }
     448                 :            :         else
     449                 :            :         {
     450                 :          3 :             perror("Unable to send signal to fwknop: ");
     451                 :          3 :             return EXIT_FAILURE;
     452                 :            :         }
     453                 :            :     }
     454                 :            : 
     455                 :          0 :     fprintf(stdout, "No running fwknopd detected.\n");
     456                 :          0 :     return EXIT_FAILURE;
     457                 :            : }
     458                 :            : 
     459                 :        739 : static int status_fwknopd(fko_srv_options_t * const opts)
     460                 :            : {
     461                 :            :     pid_t    old_pid;
     462                 :            : 
     463                 :        739 :     old_pid = write_pid_file(opts);
     464                 :            : 
     465         [ +  + ]:        739 :     if(old_pid > 0)
     466                 :            :     {
     467                 :        366 :         fprintf(stdout, "Detected fwknopd is running (pid=%i).\n", old_pid);
     468                 :        366 :         return EXIT_SUCCESS;
     469                 :            :     }
     470                 :            : 
     471                 :        373 :     fprintf(stdout, "No running fwknopd detected.\n");
     472                 :        373 :     return EXIT_FAILURE;
     473                 :            : }
     474                 :            : 
     475                 :        384 : static int handle_signals(fko_srv_options_t *opts)
     476                 :            : {
     477                 :        384 :     int      last_sig = 0, rv = 1;
     478                 :            : 
     479         [ +  + ]:        384 :     if(got_signal) {
     480                 :        360 :         last_sig   = got_signal;
     481                 :        360 :         got_signal = 0;
     482                 :            : 
     483         [ +  + ]:        360 :         if(got_sighup)
     484                 :            :         {
     485                 :          1 :             log_msg(LOG_WARNING, "Got SIGHUP. Re-reading configs.");
     486                 :          1 :             free_configs(opts);
     487                 :          1 :             kill(opts->tcp_server_pid, SIGTERM);
     488                 :          1 :             usleep(1000000);
     489                 :          1 :             got_sighup = 0;
     490                 :          1 :             rv = 0;  /* this means fwknopd will not exit */
     491                 :            :         }
     492         [ +  + ]:        359 :         else if(got_sigint)
     493                 :            :         {
     494                 :          1 :             log_msg(LOG_WARNING, "Got SIGINT. Exiting...");
     495                 :          1 :             got_sigint = 0;
     496                 :            :         }
     497         [ +  - ]:        358 :         else if(got_sigterm)
     498                 :            :         {
     499                 :        358 :             log_msg(LOG_WARNING, "Got SIGTERM. Exiting...");
     500                 :        358 :             got_sigterm = 0;
     501                 :            :         }
     502                 :            :         else
     503                 :            :         {
     504                 :          0 :             log_msg(LOG_WARNING,
     505                 :            :                 "Got signal %i. No defined action but to exit.", last_sig);
     506                 :            :         }
     507                 :            :     }
     508         [ +  - ]:         24 :     else if (opts->packet_ctr_limit > 0
     509         [ +  - ]:         24 :         && opts->packet_ctr >= opts->packet_ctr_limit)
     510                 :            :     {
     511                 :         24 :         log_msg(LOG_INFO,
     512                 :            :             "Packet count limit (%d) reached. Exiting...",
     513                 :            :             opts->packet_ctr_limit);
     514                 :            :     }
     515                 :            :     else    /* got_signal was not set (should be if we are here) */
     516                 :            :     {
     517                 :          0 :         log_msg(LOG_WARNING,
     518                 :            :             "Capture ended without signal. Exiting...");
     519                 :            :     }
     520                 :        384 :     return rv;
     521                 :            : }
     522                 :            : 
     523                 :        371 : static int stop_fwknopd(fko_srv_options_t * const opts)
     524                 :            : {
     525                 :        371 :     int      res = 0, is_err = 0;
     526                 :            :     pid_t    old_pid;
     527                 :            : 
     528                 :        371 :     old_pid = get_running_pid(opts);
     529                 :            : 
     530         [ +  - ]:        371 :     if(old_pid > 0)
     531                 :            :     {
     532                 :        371 :         res    = kill(old_pid, SIGTERM);
     533                 :        371 :         is_err = kill(old_pid, 0);
     534                 :            : 
     535         [ -  + ]:        371 :         if(res == 0 && is_err != 0)
     536                 :            :         {
     537                 :          0 :             fprintf(stdout, "Killed fwknopd (pid=%i)\n", old_pid);
     538                 :          0 :             return EXIT_SUCCESS;
     539                 :            :         }
     540                 :            :         else
     541                 :            :         {
     542                 :            :             /* give a bit of time for process shutdown and check again
     543                 :            :             */
     544                 :        371 :             sleep(1);
     545                 :        371 :             is_err = kill(old_pid, 0);
     546         [ +  - ]:        371 :             if(is_err != 0)
     547                 :            :             {
     548                 :        371 :                 fprintf(stdout, "Killed fwknopd (pid=%i) via SIGTERM\n",
     549                 :            :                         old_pid);
     550                 :        371 :                 return EXIT_SUCCESS;
     551                 :            :             }
     552                 :            :             else
     553                 :            :             {
     554                 :          0 :                 res    = kill(old_pid, SIGKILL);
     555                 :          0 :                 is_err = kill(old_pid, 0);
     556         [ #  # ]:          0 :                 if(res == 0 && is_err != 0)
     557                 :            :                 {
     558                 :          0 :                     fprintf(stdout,
     559                 :            :                             "Killed fwknopd (pid=%i) via SIGKILL\n",
     560                 :            :                             old_pid);
     561                 :          0 :                     return EXIT_SUCCESS;
     562                 :            :                 }
     563                 :            :                 else
     564                 :            :                 {
     565                 :          0 :                     sleep(1);
     566                 :          0 :                     is_err = kill(old_pid, 0);
     567         [ #  # ]:          0 :                     if(is_err != 0)
     568                 :            :                     {
     569                 :          0 :                         fprintf(stdout,
     570                 :            :                                 "Killed fwknopd (pid=%i) via SIGKILL\n",
     571                 :            :                                 old_pid);
     572                 :          0 :                         return EXIT_SUCCESS;
     573                 :            :                     }
     574                 :            :                     else
     575                 :            :                     {
     576                 :          0 :                         perror("Unable to kill fwknop: ");
     577                 :          0 :                         return EXIT_FAILURE;
     578                 :            :                     }
     579                 :            :                 }
     580                 :            :             }
     581                 :            :         }
     582                 :            :     }
     583                 :            : 
     584                 :          0 :     fprintf(stderr, "No running fwknopd detected.\n");
     585                 :          0 :     return EXIT_FAILURE;
     586                 :            : }
     587                 :            : 
     588                 :            : /* Ensure the specified directory exists. If not, create it or die.
     589                 :            : */
     590                 :            : static int
     591                 :       2582 : check_dir_path(const char * const filepath, const char * const fp_desc, const unsigned char use_basename)
     592                 :            : {
     593                 :            :     struct stat     st;
     594                 :       2582 :     int             res = 0;
     595                 :            :     char            tmp_path[MAX_PATH_LEN];
     596                 :            :     char            *ndx;
     597                 :            : 
     598                 :            :     /*
     599                 :            :      * FIXME:  We shouldn't use a hard-coded dir-separator here.
     600                 :            :     */
     601                 :            :     /* But first make sure we are using an absolute path.
     602                 :            :     */
     603         [ +  + ]:       2582 :     if(*filepath != PATH_SEP)
     604                 :            :     {
     605                 :          1 :         log_msg(LOG_ERR,
     606                 :            :             "Path '%s' is not absolute.", filepath
     607                 :            :         );
     608                 :          1 :         return 0;
     609                 :            :     }
     610                 :            : 
     611                 :            :     /* If this is a file path that we want to use only the basename, strip
     612                 :            :      * the trailing filename here.
     613                 :            :     */
     614 [ -  + ][ #  # ]:       2581 :     if(use_basename && ((ndx = strrchr(filepath, PATH_SEP)) != NULL))
     615                 :          0 :         strlcpy(tmp_path, filepath, (ndx-filepath)+1);
     616                 :            :     else
     617                 :       2581 :         strlcpy(tmp_path, filepath, sizeof(tmp_path));
     618                 :            : 
     619                 :            :     /* At this point, we should make the path is more than just the
     620                 :            :      * PATH_SEP. If it is not, silently return.
     621                 :            :     */
     622         [ +  - ]:       2581 :     if(strlen(tmp_path) < 2)
     623                 :            :         return 1;
     624                 :            : 
     625                 :            :     /* Make sure we have a valid directory.
     626                 :            :     */
     627                 :       2581 :     res = stat(tmp_path, &st);
     628         [ +  + ]:       2581 :     if(res != 0)
     629                 :            :     {
     630         [ +  - ]:          1 :         if(errno == ENOENT)
     631                 :            :         {
     632                 :          1 :             log_msg(LOG_WARNING,
     633                 :            :                 "%s directory: %s does not exist. Attempting to create it.",
     634                 :            :                 fp_desc, tmp_path
     635                 :            :             );
     636                 :            : 
     637                 :            :             /* Directory does not exist, so attempt to create it.
     638                 :            :             */
     639                 :          1 :             res = make_dir_path(tmp_path);
     640         [ -  + ]:          1 :             if(res != 0)
     641                 :            :             {
     642                 :          0 :                 log_msg(LOG_ERR,
     643                 :            :                     "Unable to create %s directory: %s (error: %i)",
     644                 :            :                     fp_desc, tmp_path, errno
     645                 :            :                 );
     646                 :          0 :                 return 0;
     647                 :            :             }
     648                 :            : 
     649                 :          1 :             log_msg(LOG_ERR,
     650                 :            :                 "Successfully created %s directory: %s", fp_desc, tmp_path
     651                 :            :             );
     652                 :            :         }
     653                 :            :         else
     654                 :            :         {
     655                 :          0 :             log_msg(LOG_ERR,
     656                 :            :                 "Stat of %s returned error %i", tmp_path, errno
     657                 :            :             );
     658                 :          0 :             return 0;
     659                 :            :         }
     660                 :            :     }
     661                 :            :     else
     662                 :            :     {
     663                 :            :         /* It is a file, but is it a directory?
     664                 :            :         */
     665         [ +  + ]:       2580 :         if(! S_ISDIR(st.st_mode))
     666                 :            :         {
     667                 :          1 :             log_msg(LOG_ERR,
     668                 :            :                 "Specified %s directory: %s is NOT a directory", fp_desc, tmp_path
     669                 :            :             );
     670                 :          1 :             return 0;
     671                 :            :         }
     672                 :            :     }
     673                 :            :     return 1;
     674                 :            : }
     675                 :            : 
     676                 :            : static int
     677                 :          1 : make_dir_path(const char * const run_dir)
     678                 :            : {
     679                 :            :     struct stat     st;
     680                 :          1 :     int             res = 0, len = 0;
     681                 :            :     char            tmp_path[MAX_PATH_LEN];
     682                 :            :     char            *ndx;
     683                 :            : 
     684                 :          1 :     strlcpy(tmp_path, run_dir, sizeof(tmp_path));
     685                 :            : 
     686                 :          1 :     len = strlen(tmp_path);
     687                 :            : 
     688                 :            :     /* Strip any trailing dir sep char.
     689                 :            :     */
     690         [ -  + ]:          1 :     if(tmp_path[len-1] == PATH_SEP)
     691                 :          1 :         tmp_path[len-1] = '\0';
     692                 :            : 
     693         [ +  + ]:         36 :     for(ndx = tmp_path+1; *ndx; ndx++)
     694                 :            :     {
     695         [ +  + ]:         35 :         if(*ndx == '/')
     696                 :            :         {
     697                 :          5 :             *ndx = '\0';
     698                 :            : 
     699                 :            :             /* Stat this part of the path to see if it is a valid directory.
     700                 :            :              * If it does not exist, attempt to create it. If it does, and
     701                 :            :              * it is a directory, go on. Otherwise, any other error cause it
     702                 :            :              * to bail.
     703                 :            :             */
     704         [ -  + ]:          5 :             if(stat(tmp_path, &st) != 0)
     705                 :            :             {
     706         [ #  # ]:          0 :                 if(errno == ENOENT)
     707                 :            :                 {
     708                 :          0 :                     res = mkdir(tmp_path, S_IRWXU);
     709         [ #  # ]:          0 :                     if(res != 0)
     710                 :            :                         return res;
     711                 :            : 
     712                 :            :                     /* run stat() against the component since we just
     713                 :            :                      * created it
     714                 :            :                     */
     715         [ #  # ]:          0 :                     if(stat(tmp_path, &st) != 0)
     716                 :            :                     {
     717                 :          0 :                         log_msg(LOG_ERR,
     718                 :            :                             "Could not create component: %s of %s", tmp_path, run_dir
     719                 :            :                         );
     720                 :          0 :                         return(ENOTDIR);
     721                 :            :                     }
     722                 :            :                 }
     723                 :            :             }
     724                 :            : 
     725         [ -  + ]:          5 :             if(! S_ISDIR(st.st_mode))
     726                 :            :             {
     727                 :          0 :                 log_msg(LOG_ERR,
     728                 :            :                     "Component: %s of %s is NOT a directory", tmp_path, run_dir
     729                 :            :                 );
     730                 :          0 :                 return(ENOTDIR);
     731                 :            :             }
     732                 :            : 
     733                 :          5 :             *ndx = '/';
     734                 :            :         }
     735                 :            :     }
     736                 :            : 
     737                 :          1 :     res = mkdir(tmp_path, S_IRWXU);
     738                 :            : 
     739                 :          1 :     return(res);
     740                 :            : }
     741                 :            : 
     742                 :            : /* Become a daemon: fork(), start a new session, chdir "/",
     743                 :            :  * and close unneeded standard filehandles.
     744                 :            : */
     745                 :            : static void
     746                 :          1 : daemonize_process(fko_srv_options_t * const opts)
     747                 :            : {
     748                 :            :     pid_t pid, old_pid;
     749                 :            : 
     750                 :            :     /* Reset the our umask
     751                 :            :     */
     752                 :          1 :     umask(0);
     753                 :            : 
     754         [ -  + ]:          1 :     if ((pid = fork()) < 0)
     755                 :            :     {
     756                 :          0 :         perror("Unable to fork: ");
     757                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     758                 :            :     }
     759         [ +  + ]:          2 :     else if (pid != 0) /* parent */
     760                 :            :     {
     761                 :          1 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_SUCCESS);
     762                 :            :     }
     763                 :            : 
     764                 :            :     /* Child process from here on out */
     765                 :            : 
     766                 :            :     /* Start a new session
     767                 :            :     */
     768                 :          1 :     setsid();
     769                 :            : 
     770                 :            :     /* Create the PID file (or be blocked by an existing one).
     771                 :            :     */
     772                 :          1 :     old_pid = write_pid_file(opts);
     773         [ -  + ]:          1 :     if(old_pid > 0)
     774                 :            :     {
     775                 :          0 :         fprintf(stderr,
     776                 :            :             "[*] An instance of fwknopd is already running: (PID=%i).\n", old_pid
     777                 :            :         );
     778                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     779                 :            :     }
     780         [ -  + ]:          1 :     else if(old_pid < 0)
     781                 :            :     {
     782                 :          0 :         fprintf(stderr,
     783                 :            :                 "[*] PID file error. The lock may not be effective.\n");
     784                 :            :     }
     785                 :            : 
     786                 :            :     /* Chdir to the root of the filesystem
     787                 :            :     */
     788         [ -  + ]:          1 :     if ((chdir("/")) < 0) {
     789                 :          0 :         perror("Could not chdir() to /: ");
     790                 :          0 :         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     791                 :            :     }
     792                 :            : 
     793                 :            :     /* Close un-needed file handles
     794                 :            :     */
     795                 :          1 :     close(STDIN_FILENO);
     796                 :          1 :     close(STDOUT_FILENO);
     797                 :          1 :     close(STDERR_FILENO);
     798                 :            : 
     799                 :          1 :     return;
     800                 :            : }
     801                 :            : 
     802                 :            : static int
     803                 :       2311 : write_pid_file(fko_srv_options_t *opts)
     804                 :            : {
     805                 :            :     pid_t   old_pid, my_pid;
     806                 :            :     int     op_fd, lck_res, num_bytes;
     807                 :       2311 :     char    buf[PID_BUFLEN] = {0};
     808                 :            : 
     809                 :            :     /* Reset errno (just in case)
     810                 :            :     */
     811                 :       2311 :     errno = 0;
     812                 :            : 
     813                 :            :     /* Open the PID file
     814                 :            :     */
     815                 :       2311 :     op_fd = open(
     816                 :       2311 :         opts->config[CONF_FWKNOP_PID_FILE], O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR
     817                 :            :     );
     818                 :            : 
     819         [ -  + ]:       2311 :     if(op_fd == -1)
     820                 :            :     {
     821                 :          0 :         perror("Error trying to open PID file: ");
     822                 :          0 :         return -1;
     823                 :            :     }
     824                 :            : 
     825         [ -  + ]:       2311 :     if(fcntl(op_fd, F_SETFD, FD_CLOEXEC) == -1)
     826                 :            :     {
     827                 :          0 :         close(op_fd);
     828                 :          0 :         perror("Unexpected error from fcntl: ");
     829                 :          0 :         return -1;
     830                 :            :     }
     831                 :            : 
     832                 :            :     /* Attempt to lock the PID file. If we get an EWOULDBLOCK
     833                 :            :      * error, another instance already has the lock. So we grab
     834                 :            :      * the pid from the existing lock file, complain and bail.
     835                 :            :     */
     836                 :       2311 :     lck_res = lockf(op_fd, F_TLOCK, 0);
     837         [ +  + ]:       2311 :     if(lck_res == -1)
     838                 :            :     {
     839                 :        366 :         close(op_fd);
     840                 :            : 
     841         [ -  + ]:        366 :         if(errno != EAGAIN)
     842                 :            :         {
     843                 :          0 :             perror("Unexpected error from lockf: ");
     844                 :          0 :             return -1;
     845                 :            :         }
     846                 :            : 
     847                 :            :         /* Look for an existing lock holder. If we get a pid return it.
     848                 :            :         */
     849                 :        366 :         old_pid = get_running_pid(opts);
     850         [ -  + ]:        366 :         if(old_pid)
     851                 :            :             return old_pid;
     852                 :            : 
     853                 :            :         /* Otherwise, consider it an error.
     854                 :            :         */
     855                 :          0 :         perror("Unable read existing PID file: ");
     856                 :          0 :         return -1;
     857                 :            :     }
     858                 :            : 
     859                 :            :     /* Write our PID to the file
     860                 :            :     */
     861                 :       1945 :     my_pid = getpid();
     862                 :            :     snprintf(buf, PID_BUFLEN, "%i\n", my_pid);
     863                 :            : 
     864                 :       1945 :     log_msg(LOG_DEBUG, "[+] Writing my PID (%i) to the lock file: %s",
     865                 :            :         my_pid, opts->config[CONF_FWKNOP_PID_FILE]);
     866                 :            : 
     867                 :       1945 :     num_bytes = write(op_fd, buf, strlen(buf));
     868                 :            : 
     869 [ +  + ][ +  + ]:       1945 :     if(errno || num_bytes != strlen(buf))
     870                 :         81 :         perror("Lock may not be valid. PID file write error: ");
     871                 :            : 
     872                 :            :     /* Sync/flush regardless...
     873                 :            :     */
     874                 :       1945 :     fsync(op_fd);
     875                 :            : 
     876                 :            :     /* Put the lock file discriptor in out options struct so any
     877                 :            :      * child processes we my spawn can close and release it.
     878                 :            :     */
     879                 :       1945 :     opts->lock_fd = op_fd;
     880                 :            : 
     881                 :       1945 :     return 0;
     882                 :            : }
     883                 :            : 
     884                 :            : static pid_t
     885                 :       2313 : get_running_pid(const fko_srv_options_t *opts)
     886                 :            : {
     887                 :       2313 :     int     op_fd, is_err, bytes_read = 0;
     888                 :       2313 :     char    buf[PID_BUFLEN] = {0};
     889                 :       2313 :     pid_t   rpid            = 0;
     890                 :            : 
     891                 :            : 
     892         [ -  + ]:       2313 :     if(verify_file_perms_ownership(opts->config[CONF_FWKNOP_PID_FILE]) != 1)
     893                 :            :     {
     894                 :          0 :         fprintf(stderr, "verify_file_perms_ownership() error\n");
     895                 :          0 :         return(rpid);
     896                 :            :     }
     897                 :            : 
     898                 :       4626 :     op_fd = open(opts->config[CONF_FWKNOP_PID_FILE], O_RDONLY);
     899                 :            : 
     900         [ -  + ]:       2313 :     if(op_fd == -1)
     901                 :            :     {
     902 [ #  # ][ #  # ]:          0 :         if((opts->foreground != 0) && (opts->verbose != 0))
     903                 :          0 :             perror("Error trying to open PID file: ");
     904                 :            :         return(rpid);
     905                 :            :     }
     906                 :            : 
     907                 :       2313 :     bytes_read = read(op_fd, buf, PID_BUFLEN);
     908         [ +  + ]:       2313 :     if (bytes_read > 0)
     909                 :            :     {
     910                 :       2263 :         buf[PID_BUFLEN-1] = '\0';
     911                 :            :         /* max pid value is configurable on Linux
     912                 :            :         */
     913                 :       2263 :         rpid = (pid_t) strtol_wrapper(buf, 0, (2 << 30),
     914                 :            :                 NO_EXIT_UPON_ERR, &is_err);
     915         [ -  + ]:       2263 :         if(is_err != FKO_SUCCESS)
     916                 :          0 :             rpid = 0;
     917                 :            :     }
     918         [ +  - ]:         50 :     else if (bytes_read < 0)
     919                 :         50 :         perror("Error trying to read() PID file: ");
     920                 :            : 
     921                 :       2313 :     close(op_fd);
     922                 :            : 
     923                 :       2313 :     return(rpid);
     924                 :            : }
     925                 :            : 
     926                 :            : #if HAVE_LIBFIU
     927                 :            : static void
     928                 :       3708 : enable_fault_injections(fko_srv_options_t * const opts)
     929                 :            : {
     930         [ +  + ]:       3708 :     if(opts->config[CONF_FAULT_INJECTION_TAG] != NULL)
     931                 :            :     {
     932                 :         35 :         fiu_init(0);
     933         [ -  + ]:         35 :         if (fiu_enable(opts->config[CONF_FAULT_INJECTION_TAG], 1, NULL, 0) != 0)
     934                 :            :         {
     935                 :          0 :             fprintf(stderr, "[*] Could not enable fault injection: %s\n",
     936                 :            :                     opts->config[CONF_FAULT_INJECTION_TAG]);
     937                 :          0 :             clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
     938                 :            :         }
     939                 :            :     }
     940                 :       3708 :     return;
     941                 :            : }
     942                 :            : #endif
     943                 :            : 
     944                 :            : void
     945                 :       5499 : clean_exit(fko_srv_options_t *opts, unsigned int fw_cleanup_flag, unsigned int exit_status)
     946                 :            : {
     947                 :            : #if HAVE_LIBFIU
     948         [ +  + ]:       5499 :     if(opts->config[CONF_FAULT_INJECTION_TAG] != NULL)
     949                 :            :     {
     950                 :         35 :         fiu_disable(opts->config[CONF_FAULT_INJECTION_TAG]);
     951                 :            :     }
     952                 :            : #endif
     953                 :            : 
     954 [ +  + ][ +  + ]:       5499 :     if(!opts->test && (fw_cleanup_flag == FW_CLEANUP))
     955                 :        391 :         fw_cleanup(opts);
     956                 :            : 
     957                 :            : #if USE_FILE_CACHE
     958                 :       5499 :     free_replay_list(opts);
     959                 :            : #endif
     960                 :            : 
     961                 :       5499 :     free_logging();
     962                 :       5499 :     free_configs(opts);
     963                 :       5499 :     exit(exit_status);
     964                 :            : }
     965                 :            : 
     966                 :            : /***EOF***/

Generated by: LCOV version 1.10