flowgrindd.c File Reference

Flowgrind daemon. More...

#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <signal.h>
#include <syslog.h>
#include <string.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <fcntl.h>
#include <netdb.h>
#include <sys/stat.h>
#include <xmlrpc-c/base.h>
#include <xmlrpc-c/server.h>
#include <xmlrpc-c/server_abyss.h>
#include <xmlrpc-c/util.h>
#include "common.h"
#include "daemon.h"
#include "fg_log.h"
#include "fg_affinity.h"
#include "fg_error.h"
#include "fg_math.h"
#include "fg_progname.h"
#include "fg_string.h"
#include "fg_time.h"
#include "fg_definitions.h"
#include "debug.h"
#include "fg_argparser.h"
#include "fg_rpc_server.h"
#include "fg_pcap.h"

Go to the source code of this file.

Macros
#define	daemon   fake_daemon_function
	Temporarily renaming daemon() so compiler does not see the warning on OS X. More...
#define	PARSE_ERR(err_msg, ...)
	Print error message, usage string and exit. More...

Functions
void	bind_daemon_to_core (void)
void	create_daemon_thread ()
int	daemon (int, int)
	Remap daemon() function. More...
int	main (int argc, char *argv[])
static void	parse_cmdline (int argc, char *argv[])
	Parse command line options to initialize global options. More...
int	process_dump_dir ()
static void	sanity_check (void)
static void	sighandler (int sig)
	Signal handler to catching signals. More...
static void	tear_down_daemon (void)
	Gracefully tear down daemon. More...
static void	usage (short status)
	Print usage or error message and exit. More...

Variables
static int	core
	CPU core to which flowgrindd should bind to. More...
static struct arg_parser	parser
	Command line option parser. More...
static unsigned	port = DEFAULT_LISTEN_PORT
const char *	progname
	String containing name the program is called with. More...
static char *	rpc_bind_addr = NULL

Detailed Description

Flowgrind daemon.

Definition in file flowgrindd.c.

Macro Definition Documentation

daemon

#define daemon   fake_daemon_function

Temporarily renaming daemon() so compiler does not see the warning on OS X.

Definition at line 36 of file flowgrindd.c.

PARSE_ERR

#define PARSE_ERR	(		err_msg,
			...
	)

Value:

        do {    \
        errx(err_msg, ##__VA_ARGS__);   \
        usage(EXIT_FAILURE);            \
} while (0)

Print error message, usage string and exit.

Used for cmdline parsing errors.

Definition at line 86 of file flowgrindd.c.

Function Documentation

bind_daemon_to_core()

void bind_daemon_to_core

(

void

)

Definition at line 202 of file flowgrindd.c.

{
        pthread_t thread = pthread_self();
        int rc = pthread_setaffinity(thread, core);
 
        if (rc)
                logging(LOG_WARNING, "failed to bind %s (PID %d) to CPU core %i",
                        progname, getpid(), core);
        else
                DEBUG_MSG(LOG_INFO, "bind %s (PID %d) to CPU core %i",
                          progname, getpid(), core);
}

create_daemon_thread()

void create_daemon_thread

(

)

Definition at line 184 of file flowgrindd.c.

{
        int flags;
 
        if (pipe(daemon_pipe) == -1)
                crit("could not create pipe");
 
        if ((flags = fcntl(daemon_pipe[0], F_GETFL, 0)) == -1)
                flags = 0;
        fcntl(daemon_pipe[0], F_SETFL, flags | O_NONBLOCK);
 
        pthread_mutex_init(&mutex, NULL);
 
        int rc = pthread_create(&daemon_thread, NULL, daemon_main, 0);
        if (rc)
                critc(rc, "could not start thread");
}

daemon()

int daemon	(	int	,
		int
	)

Remap daemon() function.

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 365 of file flowgrindd.c.

{
        /* Info about the xmlrpc server */
        struct fg_rpc_server server;
 
        /* Initialize sighandler */
        struct sigaction sa;
        sa.sa_handler = sighandler;
        sa.sa_flags = 0;
        sigemptyset (&sa.sa_mask);
        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
                crit("could not ignore SIGPIPE");
        if (sigaction (SIGHUP, &sa, NULL))
                critx("could not set handler for SIGUP");
        if (sigaction (SIGALRM, &sa, NULL))
                critx("could not set handler for SIGALRM");
        if (sigaction (SIGCHLD, &sa, NULL))
                critx("could not set handler for SIGCHLD");
        if (sigaction(SIGINT, &sa, NULL))
                critx("could not set handler for SIGINT");
        if (sigaction(SIGTERM, &sa, NULL))
                critx("could not set handler for SIGTERM");
 
        set_progname(argv[0]);
        parse_cmdline(argc, argv);
        sanity_check();
 
        /* Initialize logging */
        if (!ap_is_used(&parser, 'd'))
                init_logging(LOGGING_SYSLOG);
        else
                init_logging(LOGGING_STDERR);
 
        fg_list_init(&flows);
 
#ifdef HAVE_LIBPCAP
        fg_pcap_init();
#endif /* HAVE_LIBPCAP */
 
        init_rpc_server(&server, rpc_bind_addr, port);
 
        /* Push flowgrindd into the background */
        if (!ap_is_used(&parser, 'd')) {
                /* Need to call daemon() before creating the thread because
                 * it internally calls fork() which does not copy threads. */
                if (daemon(0, 0) == -1)
                        crit("daemon() failed");
                logging(LOG_NOTICE, "flowgrindd daemonized");
        }
 
        if (ap_is_used(&parser, 'c'))
                bind_daemon_to_core();
 
        create_daemon_thread();
 
        /* This will block */
        run_rpc_server(&server);
        critx("control should never reach end of main()");
}

parse_cmdline()

static void parse_cmdline ( int  argc, char *  argv[]  )

static

Parse command line options to initialize global options.

Parameters

[in]	argc	number of command line arguments
[in]	argv	arguments provided by the command line

Definition at line 254 of file flowgrindd.c.

{
        const struct ap_Option options[] = {
                {'b', 0, ap_yes, 0, 0},
                {'c', 0, ap_yes, 0, 0},
#ifdef DEBUG
                {'d', "debug", ap_no, 0, 0},
#else /* DEBUG */
                {'d', 0, ap_no, 0, 0},
#endif
                {'h', "help", ap_no, 0, 0},
                {'o', 0, ap_yes, 0, 0},
                {'p', 0, ap_yes, 0, 0},
                {'v', "version", ap_no, 0, 0},
#ifdef HAVE_LIBPCAP
                {'w', 0, ap_yes, 0, 0},
#endif /* HAVE_LIBPCAP */
                {0, 0, ap_no, 0, 0}
        };
 
        if (!ap_init(&parser, argc, (const char* const*) argv, options, 0))
                critx("could not allocate memory for option parser");
        if (ap_error(&parser))
                PARSE_ERR("%s", ap_error(&parser));
 
        /* parse command line */
        for (int argind = 0; argind < ap_arguments(&parser); argind++) {
                const int code = ap_code(&parser, argind);
                const char *arg = ap_argument(&parser, argind);
 
                switch (code) {
                case 0:
                        PARSE_ERR("invalid argument: %s", arg);
                case 'b':
                        rpc_bind_addr = strdup(arg);
                        if (sscanf(arg, "%s", rpc_bind_addr) != 1)
                                PARSE_ERR("failed to parse bind address");
                        break;
                case 'c':
                        if (sscanf(arg, "%u", &core) != 1)
                                PARSE_ERR("failed to parse CPU number");
                        break;
                case 'd':
#ifdef DEBUG
                        increase_debuglevel();
#endif /* DEBUG */
                        break;
                case 'h':
                        usage(EXIT_SUCCESS);
                        break;
                case 'p':
                        if (sscanf(arg, "%u", &port) != 1)
                                PARSE_ERR("failed to parse port number");
                        break;
#ifdef HAVE_LIBPCAP
                case 'w':
                        dump_dir = strdup(arg);
                        break;
#endif /* HAVE_LIBPCAP */
                case 'v':
                        fprintf(stdout, "%s %s\%s\n%s\n\n%s\n", progname,
                                FLOWGRIND_VERSION, FLOWGRIND_COPYRIGHT,
                                FLOWGRIND_COPYING, FLOWGRIND_AUTHORS);
                        exit(EXIT_SUCCESS);
                        break;
                default:
                        PARSE_ERR("uncaught option: %s", arg);
                        break;
                }
        }
 
#ifdef HAVE_LIBPCAP
        if (!process_dump_dir()) {
                if (ap_is_used(&parser, 'w'))
                        PARSE_ERR("the dump directory %s for tcpdumps does "
                                  "either not exist or you have insufficient "
                                  "permissions to write to it", dump_dir);
                else
                        warnx("tcpdumping will not be available since you "
                              "don't have sufficient permissions to write to "
                              "%s", dump_dir);
        }
#endif /* HAVE_LIBPCAP */
}

process_dump_dir()

int process_dump_dir

(

)

Definition at line 216 of file flowgrindd.c.

                       {
        if (!dump_dir)
                dump_dir = getcwd(NULL, 0);
 
        struct stat dirstats;
 
        if (stat(dump_dir, &dirstats) == -1) {
                DEBUG_MSG(LOG_WARNING, "unable to stat %s: %s", dump_dir,
                          strerror(errno));
                return 0;
        }
 
        if (!S_ISDIR(dirstats.st_mode)) {
                DEBUG_MSG(LOG_ERR, "provided path %s is not a directory",
                          dump_dir);
                return 0;
        }
 
        if (access(dump_dir, W_OK | X_OK) == -1) {
                DEBUG_MSG(LOG_ERR, "insufficent permissions to access %s: %s",
                          dump_dir, strerror(errno));
                return 0;
        }
 
        /* ensure path contains terminating slash */
        if (dump_dir[strlen(dump_dir) - 1] != '/')
                asprintf_append(&dump_dir, "/");
 
        return 1;
}

sanity_check()

static void sanity_check ( void  )

static

Todo:

more sanity checks... (e.g. if port is in valid range)

Definition at line 339 of file flowgrindd.c.

{
        if (core < 0) {
                errx("CPU binding failed. Given CPU ID is negative");
                exit(EXIT_FAILURE);
        }
 
        if (core > get_ncores(NCORE_CURRENT)) {
                errx("CPU binding failed. Given CPU ID is higher then "
                     "available CPU cores");
                exit(EXIT_FAILURE);
        }
 
        /* TODO more sanity checks... (e.g. if port is in valid range) */
}

sighandler()

static void sighandler ( int  sig )

static

Signal handler to catching signals.

Parameters

[in]

sig

signal to catch

Definition at line 154 of file flowgrindd.c.

{
        int status;
 
        switch (sig) {
        case SIGCHLD:
                while (waitpid(-1, &status, WNOHANG) > 0)
                        logging(LOG_NOTICE, "child returned (status = %d)",
                                status);
                break;
        case SIGHUP:
                logging(LOG_NOTICE, "caught SIGHUP. don't know what to do.");
                break;
        case SIGALRM:
                logging(LOG_NOTICE, "caught SIGALRM, don't know what to do.");
                break;
        case SIGPIPE:
                break;
        case SIGINT:
        case SIGTERM:
                logging(LOG_NOTICE, "caught SIGINT/SIGTERM, tear down daemon");
                tear_down_daemon();
                break;
        default:
                logging(LOG_ALERT, "caught signal %d, but don't remember "
                        "intercepting it, aborting...", sig);
                abort();
        }
}

tear_down_daemon()

static void tear_down_daemon ( void  )

static

Gracefully tear down daemon.

Definition at line 358 of file flowgrindd.c.

{
        ap_free(&parser);
        close_logging();
        exit(EXIT_SUCCESS);
}

usage()

static void usage ( short  status )

static

Print usage or error message and exit.

Depending on exit status status print either the usage or an error message. In all cases it call exit() with the given exit status status.

Parameters

[in]

status

exit status

Definition at line 118 of file flowgrindd.c.

{
        /* Syntax error. Emit 'try help' to stderr and exit */
        if (status != EXIT_SUCCESS) {
                fprintf(stderr, "Try '%s -h' for more information\n", progname);
                exit(status);
        }
 
        fprintf(stdout,
                "Usage: %1$s [OPTION]...\n"
                "Advanced TCP traffic generator for Linux, FreeBSD, and Mac OS X.\n\n"
 
                "Mandatory arguments to long options are mandatory for short options too.\n"
                "  -b ADDR        XML-RPC server bind address\n"
                "  -c #           bound daemon to specific CPU. First CPU is 0\n"
#ifdef DEBUG
                "  -d, --debug    increase debugging verbosity. Add option multiple times to\n"
                "                 increase the verbosity (no daemon, log to stderr)\n"
#else /* DEBUG */
                "  -d             don't fork into background, log to stderr\n"
#endif /* DEBUG */
                "  -h, --help     display this help and exit\n"
                "  -p #           XML-RPC server port\n"
#ifdef HAVE_LIBPCAP
                "  -w DIR         target directory for dump files. The daemon must be run as root\n"
#endif /* HAVE_LIBPCAP */
                "  -v, --version  print version information and exit\n",
                progname);
        exit(EXIT_SUCCESS);
}

Variable Documentation

core

int core

static

CPU core to which flowgrindd should bind to.

Definition at line 101 of file flowgrindd.c.

parser

struct arg_parser parser

static

Command line option parser.

Definition at line 104 of file flowgrindd.c.

port

unsigned port = DEFAULT_LISTEN_PORT

static

Definition at line 95 of file flowgrindd.c.

progname

const char* progname

String containing name the program is called with.

Definition at line 35 of file fg_progname.c.

rpc_bind_addr

char* rpc_bind_addr = NULL

static

Definition at line 98 of file flowgrindd.c.