source.h File Reference

Routines used by Flowgrind to setup the source for a test flow. More...

#include "config.h"

Go to the source code of this file.

Functions
int	add_flow_source (struct request_add_flow_source *request)
	To set daemon flow as source endpoint. More...
int	do_connect (struct flow *flow)
	Establishes a connection of a flow. More...

Detailed Description

Routines used by Flowgrind to setup the source for a test flow.

Definition in file source.h.

Function Documentation

add_flow_source()

int add_flow_source

(

struct request_add_flow_source *

request

)

To set daemon flow as source endpoint.

To set the flow options and settings as source endpoint. Depending upon the late connection option the data connection is established to connect the destination daemon listening port address with source daemon.

Parameters

[in,out]

request

Contain the test option and parameter for daemon source endpoint

Definition at line 177 of file source.c.

{
#ifdef HAVE_SO_TCP_CONGESTION
        socklen_t opt_len = 0;
#endif /* HAVE_SO_TCP_CONGESTION */
        struct flow *flow;
 
        if (fg_list_size(&flows) >= MAX_FLOWS_DAEMON) {
                logging(LOG_WARNING, "can not accept another flow, already "
                        "handling %zu flows", fg_list_size(&flows));
                request_error(&request->r,
                        "Can not accept another flow, already "
                        "handling %zu flows.", fg_list_size(&flows));
                return -1;
        }
 
        flow = malloc(sizeof(struct flow));
        if (!flow) {
                logging(LOG_ALERT, "could not allocate memory for flow");
                return -1;
        }
 
        init_flow(flow, 1);
 
        flow->settings = request->settings;
        flow->source_settings = request->source_settings;
        /* be greedy with buffer sizes */
        flow->write_block = calloc(1, flow->settings.maximum_block_size);
        flow->read_block = calloc(1, flow->settings.maximum_block_size);
        /* Controller flow ID is set in the daemon */
        flow->id = flow->settings.flow_id;
        if (flow->write_block == NULL || flow->read_block == NULL) {
                logging(LOG_ALERT, "could not allocate memory for read/write "
                        "blocks");
                request_error(&request->r, "could not allocate memory for read/write blocks");
                uninit_flow(flow);
                return -1;
        }
        if (flow->settings.byte_counting) {
                int byte_idx;
                for (byte_idx = 0; byte_idx < flow->settings.maximum_block_size; byte_idx++)
                        *(flow->write_block + byte_idx) = (unsigned char)(byte_idx & 0xff);
        }
 
        flow->state = GRIND_WAIT_CONNECT;
        flow->fd = name2socket(flow, flow->source_settings.destination_host,
                        flow->source_settings.destination_port,
                        &flow->addr, &flow->addr_len,
                        flow->settings.requested_read_buffer_size, &request->real_read_buffer_size,
                        flow->settings.requested_send_buffer_size, &request->real_send_buffer_size);
        if (flow->fd == -1) {
                logging(LOG_ALERT, "could not create data socket: %s",
                        flow->error);
                request_error(&request->r, "Could not create data socket: %s", flow->error);
                uninit_flow(flow);
                return -1;
        }
 
        if (set_flow_tcp_options(flow) == -1) {
                request->r.error = flow->error;
                flow->error = NULL;
                uninit_flow(flow);
                return -1;
        }
 
#ifdef HAVE_SO_TCP_CONGESTION
        opt_len = sizeof(request->cc_alg);
        if (getsockopt(flow->fd, IPPROTO_TCP, TCP_CONGESTION,
                                request->cc_alg, &opt_len) == -1) {
                request_error(&request->r, "failed to determine actual congestion control algorithm: %s",
                        strerror(errno));
                uninit_flow(flow);
                return -1;
        }
#endif /* HAVE_SO_TCP_CONGESTION */
 
#ifdef HAVE_LIBPCAP
        fg_pcap_go(flow);
#endif /* HAVE_LIBPCAP */
        if (!flow->source_settings.late_connect) {
                DEBUG_MSG(4, "(early) connecting test socket (fd=%u)", flow->fd);
                if (do_connect(flow) == -1) {
                        request->r.error = flow->error;
                        flow->error = NULL;
                        uninit_flow(flow);
                        return -1;
                }
        }
 
        request->flow_id = flow->id;
 
        fg_list_push_back(&flows, flow);
 
        return 0;
}

do_connect()

int do_connect

(

struct flow *

flow

)

Establishes a connection of a flow.

Establishes a connection to the destination daemon listening port, and marks the flow as connected.

Parameters

[in,out]

flow

Flow to connect.

Definition at line 153 of file source.c.

                                  {
        int rc;
 
        rc = connect(flow->fd, flow->addr, flow->addr_len);
        if (rc == -1 && errno != EINPROGRESS) {
                flow_error(flow, "connect() failed: %s",
                                strerror(errno));
                err("failed to connect flow %u", flow->id);
                return rc;
        }
        flow->connect_called = 1;
        flow->pmtu = get_pmtu(flow->fd);
        return 0;
}