daemon.h File Reference

Routines used by the Flowgrind daemon. More...

#include "config.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <gsl/gsl_rng.h>
#include "common.h"
#include "fg_list.h"
#include <xmlrpc-c/base.h>
#include <xmlrpc-c/server.h>
#include <xmlrpc-c/server_abyss.h>
#include <xmlrpc-c/util.h>

Go to the source code of this file.

Data Structures
struct	flow
struct	flow_source_settings
struct	request
struct	request_add_flow_destination
struct	request_add_flow_source
struct	request_get_status
struct	request_get_uuid
	structure for getting the UUID. More...
struct	request_start_flows
struct	request_stop_flow
struct	flow::statistics

Macros
#define	DEFAULT_SELECT_TIMEOUT   10000000
	Time select() will block waiting for a file descriptor to become ready. More...
#define	REQUEST_ADD_DESTINATION   0
#define	REQUEST_ADD_SOURCE   1
#define	REQUEST_GET_STATUS   4
#define	REQUEST_GET_UUID   5
#define	REQUEST_START_FLOWS   2
#define	REQUEST_STOP_FLOW   3

Enumerations
enum	flow_state_t { GRIND_WAIT_CONNECT = 0, GRIND_WAIT_ACCEPT, GRIND }

Functions
void	add_report (struct report *report)
void *	daemon_main (void *ptr)
int	dispatch_request (struct request *request, int type)
	Dispatch a request to daemon loop. More...
void	flow_error (struct flow *flow, const char *fmt,...)
struct report *	get_reports (int *has_more)
void	get_uuid_string (char *uuid_str)
	To generate daemon UUID. More...
void	request_error (struct request *request, const char *fmt,...)
int	set_flow_tcp_options (struct flow *flow)

Variables
int	daemon_pipe [2]
pthread_t	daemon_thread
char *	dump_dir
char *	dump_prefix
struct linked_list	flows
pthread_mutex_t	mutex
unsigned	pending_reports
struct report *	reports
struct report *	reports_last
struct request *	requests
struct request *	requests_last
char	started

Detailed Description

Routines used by the Flowgrind daemon.

Definition in file daemon.h.

Macro Definition Documentation

DEFAULT_SELECT_TIMEOUT

#define DEFAULT_SELECT_TIMEOUT   10000000

Time select() will block waiting for a file descriptor to become ready.

Definition at line 51 of file daemon.h.

REQUEST_ADD_DESTINATION

#define REQUEST_ADD_DESTINATION   0

Definition at line 173 of file daemon.h.

REQUEST_ADD_SOURCE

#define REQUEST_ADD_SOURCE   1

Definition at line 174 of file daemon.h.

REQUEST_GET_STATUS

#define REQUEST_GET_STATUS   4

Definition at line 177 of file daemon.h.

REQUEST_GET_UUID

#define REQUEST_GET_UUID   5

Definition at line 178 of file daemon.h.

REQUEST_START_FLOWS

#define REQUEST_START_FLOWS   2

Definition at line 175 of file daemon.h.

REQUEST_STOP_FLOW

#define REQUEST_STOP_FLOW   3

Definition at line 176 of file daemon.h.

Enumeration Type Documentation

flow_state_t

enum flow_state_t

Enumerator
GRIND_WAIT_CONNECT
GRIND_WAIT_ACCEPT
GRIND

Definition at line 53 of file daemon.h.

{
        /* SOURCE */
        GRIND_WAIT_CONNECT = 0,
        /* DESTINATION */
        GRIND_WAIT_ACCEPT,
        /* RUN */
        GRIND,
};

Function Documentation

add_report()

void add_report

(

struct report *

report

)

Definition at line 827 of file daemon.c.

{
        DEBUG_MSG(LOG_DEBUG, "add_report trying to lock mutex");
        pthread_mutex_lock(&mutex);
        DEBUG_MSG(LOG_DEBUG, "add_report aquired mutex");
        /* Do not keep too much data */
        if (pending_reports >= 250 && report->type != FINAL) {
                free(report);
                pthread_mutex_unlock(&mutex);
                return;
        }
 
        report->next = 0;
 
        if (reports_last)
                reports_last->next = report;
        else
                reports = report;
 
        reports_last = report;
        pending_reports++;
 
        pthread_mutex_unlock(&mutex);
        DEBUG_MSG(LOG_DEBUG, "add_report unlocked mutex");
}

daemon_main()

void* daemon_main

(

void *

ptr

)

dispatch_request()

int dispatch_request	(	struct request *	request,
		int	type
	)

Dispatch a request to daemon loop.

Is called by the rpc server to feed in requests to the daemon.

Definition at line 1489 of file daemon.c.

{
        pthread_cond_t cond;
 
        request->error = NULL;
        request->type = type;
        request->next = NULL;
 
        /* Create synchronization mutex */
        if (pthread_cond_init(&cond, NULL)) {
                request_error(request, "Could not create synchronization mutex");
                return -1;
        }
        request->condition = &cond;
 
        pthread_mutex_lock(&mutex);
 
        if (!requests) {
                requests = request;
                requests_last = request;
        } else {
                requests_last->next = request;
                requests_last = request;
        }
        if (write(daemon_pipe[1], &type, 1) != 1) /* Doesn't matter what we write */
                return -1;
        /* Wait until the daemon thread has processed the request */
        pthread_cond_wait(&cond, &mutex);
 
        pthread_mutex_unlock(&mutex);
 
        if (request->error)
                return -1;
 
        return 0;
}

flow_error()

void flow_error	(	struct flow *	flow,
		const char *	fmt,
			...
	)

Definition at line 119 of file daemon.c.

{
        char str[1000];
        va_list ap;
 
        va_start(ap, fmt);
        vsnprintf(str, 1000, fmt, ap);
        va_end(ap);
        str[sizeof(str) - 1] = 0;
        flow->error = malloc(strlen(str) + 1);
        strcpy(flow->error, str);
}

get_reports()

struct report* get_reports

(

int *

has_more

)

Definition at line 853 of file daemon.c.

{
        const unsigned max_reports = 50;
 
        struct report* ret;
        DEBUG_MSG(LOG_DEBUG, "get_reports trying to lock mutex");
        pthread_mutex_lock(&mutex);
        DEBUG_MSG(LOG_DEBUG, "get_reports aquired mutex");
        ret = reports;
 
        if (pending_reports <= max_reports) {
                *has_more = 0;
                pending_reports = 0;
                reports = NULL;
                reports_last = 0;
        } else {
                /* Split off first 50 items */
                struct report* tmp;
                for (unsigned i = 0; i < max_reports - 1; i++)
                        reports = reports->next;
                tmp = reports->next;
                reports->next = 0;
                reports = tmp;
 
                pending_reports -= max_reports;
                *has_more = 1;
        }
 
        pthread_mutex_unlock(&mutex);
        DEBUG_MSG(LOG_DEBUG, "get_reports unlocked mutex");
        return ret;
}

get_uuid_string()

void get_uuid_string

(

char *

uuid_str

)

To generate daemon UUID.

Generate the daemon UUID and convert the UUID to a string data. UUID is generated by daemon only once and stored in the global variable. The daemon return the same UUID for all the flows it maintaining. This UUID is taken as a reference to identify the daemon in the controller.

Parameters

[in,out]

uuid_str

daemons UUID

Definition at line 1536 of file daemon.c.

{
        uuid_t uuid;
        static char server_uuid[38] = "";
 
        if (!strlen(server_uuid)) {
                uuid_generate_time(uuid);
                uuid_unparse(uuid,uuid_str);
                memset(server_uuid,0,sizeof(server_uuid));
                strcpy(server_uuid,uuid_str);
                return;
        }
        strcpy(uuid_str,server_uuid);
}

request_error()

void request_error	(	struct request *	request,
		const char *	fmt,
			...
	)

Definition at line 132 of file daemon.c.

{
        char str[1000];
        va_list ap;
 
        va_start(ap, fmt);
        vsnprintf(str, 1000, fmt, ap);
        va_end(ap);
        str[sizeof(str) - 1] = 0;
        request->error = malloc(strlen(str) + 1);
        strcpy(request->error, str);
}

set_flow_tcp_options()

int set_flow_tcp_options

(

struct flow *

flow

)

Definition at line 1424 of file daemon.c.

{
        set_non_blocking(flow->fd);
 
        if (*flow->settings.cc_alg &&
            set_congestion_control(flow->fd, flow->settings.cc_alg) == -1) {
                flow_error(flow, "Unable to set congestion control "
                           "algorithm: %s", strerror(errno));
                return -1;
        }
        if (flow->settings.elcn &&
            set_so_elcn(flow->fd, flow->settings.elcn) == -1) {
                flow_error(flow, "Unable to set TCP_ELCN: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.lcd && set_so_lcd(flow->fd) == -1) {
                flow_error(flow, "Unable to set TCP_LCD: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.cork && set_tcp_cork(flow->fd) == -1) {
                flow_error(flow, "Unable to set TCP_CORK: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.so_debug && set_so_debug(flow->fd) == -1) {
                flow_error(flow, "Unable to set SO_DEBUG: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.mtcp && set_tcp_mtcp(flow->fd) == -1) {
                flow_error(flow, "Unable to set TCP_MTCP: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.nonagle && set_tcp_nodelay(flow->fd) == -1) {
                flow_error(flow, "Unable to set TCP_NODELAY: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.route_record && set_route_record(flow->fd) == -1) {
                flow_error(flow, "Unable to set route record option: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.dscp &&
            set_dscp(flow->fd, flow->settings.dscp) == -1) {
                flow_error(flow, "Unable to set DSCP value: %s",
                           strerror(errno));
                return -1;
        }
        if (flow->settings.ipmtudiscover &&
            set_ip_mtu_discover(flow->fd) == -1) {
                flow_error(flow, "Unable to set IP_MTU_DISCOVER value: %s",
                           strerror(errno));
                return -1;
        }
        if (apply_extra_socket_options(flow) == -1)
                return -1;
 
        return 0;
}

Variable Documentation

daemon_pipe

int daemon_pipe[2]

Definition at line 87 of file daemon.c.

daemon_thread

pthread_t daemon_thread

Definition at line 89 of file daemon.c.

dump_dir

char* dump_dir

Definition at line 91 of file daemon.c.

dump_prefix

char* dump_prefix

Definition at line 90 of file daemon.c.

flows

struct linked_list flows

Definition at line 103 of file daemon.c.

mutex

pthread_mutex_t mutex

Definition at line 93 of file daemon.c.

pending_reports

unsigned pending_reports

Definition at line 101 of file daemon.c.

reports

struct report* reports

Definition at line 99 of file daemon.c.

reports_last

struct report* reports_last

Definition at line 100 of file daemon.c.

requests

struct request* requests

Definition at line 94 of file daemon.c.

requests_last

struct request * requests_last

Definition at line 191 of file daemon.h.

started

char started

Definition at line 105 of file daemon.c.