destination.h File Reference

Routines used to setup a Flowgrind destination for a test. More...

#include "config.h"

Go to the source code of this file.

Functions
int	accept_data (struct flow *flow)
void	add_flow_destination (struct request_add_flow_destination *request)
	To set daemon flow as destination endpoint. More...

Detailed Description

Routines used to setup a Flowgrind destination for a test.

Definition in file destination.h.

Function Documentation

accept_data()

int accept_data

(

struct flow *

flow

)

Bug:

: currently we use portable select() API, which is limited by the number of bits in an fd_set

Definition at line 250 of file destination.c.

{
        struct sockaddr_storage caddr;
        socklen_t addrlen = sizeof(caddr);
        unsigned real_send_buffer_size;
        unsigned real_receive_buffer_size;
 
        flow->fd = accept(flow->listenfd_data, (struct sockaddr *)&caddr,
                          &addrlen);
        if (flow->fd == -1) {
                /* try again later .... */
                if (errno == EINTR || errno == EAGAIN)
                        return 0;
                logging(LOG_ALERT, "accept() failed: %s", strerror(errno));
                return -1;
        }
 
        /* FIXME: currently we use portable select() API, which
         * is limited by the number of bits in an fd_set */
        if (flow->fd >= FD_SETSIZE) {
                logging(LOG_ALERT, "too many file descriptors are "
                        "already in use by this daemon (FD number=%u)", flow->fd);
                flow_error(flow, "failed to add test connection: too many"
                        "file descriptors in use by this daemon");
                close(flow->fd);
                return -1;
        }
 
        if (close(flow->listenfd_data) == -1)
                logging(LOG_WARNING, "close() failed");
        flow->listenfd_data = -1;
 
        logging(LOG_NOTICE, "client %s connected for testing (fd=%u)",
                fg_nameinfo((struct sockaddr *)&caddr, addrlen), flow->fd);
 
#ifdef HAVE_LIBPCAP
        fg_pcap_go(flow);
#endif /* HAVE_LIBPCAP */
 
        real_send_buffer_size =
                set_window_size_directed(flow->fd,
                                         flow->settings.requested_send_buffer_size,
                                         SO_SNDBUF);
        if (flow->requested_server_test_port &&
            flow->real_listen_send_buffer_size != real_send_buffer_size) {
                logging(LOG_WARNING, "failed to set send buffer size of test "
                        "socket to send buffer size size of listen socket "
                        "(listen = %u, test = %u)",
                        flow->real_listen_send_buffer_size, real_send_buffer_size);
                return -1;
        }
        real_receive_buffer_size =
                set_window_size_directed(flow->fd,
                                         flow->settings.requested_read_buffer_size,
                                         SO_RCVBUF);
        if (flow->requested_server_test_port &&
            flow->real_listen_receive_buffer_size != real_receive_buffer_size) {
                logging(LOG_WARNING, "failed to set receive buffer size "
                        "(advertised window) of test socket to receive "
                        "buffer size of listen socket (listen = %u, "
                        "test = %u)", flow->real_listen_receive_buffer_size,
                        real_receive_buffer_size);
                return -1;
        }
        if (set_flow_tcp_options(flow) == -1)
                return -1;
        DEBUG_MSG(LOG_NOTICE, "data socket accepted");
        flow->state = GRIND;
        flow->connect_called = 1;
 
        return 0;
}

add_flow_destination()

void add_flow_destination

(

struct request_add_flow_destination *

request

)

To set daemon flow as destination endpoint.

To set the flow options and settings as destination endpoint. Listening port created and send back to the controller in the same request structure

Parameters

[in,out]

request

contain the test option and parameter for destination source endpoint

Bug:

: currently we use portable select() API, which is limited by the number of bits in an fd_set

Definition at line 158 of file destination.c.

{
        struct flow *flow;
        unsigned short server_data_port;
 
        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;
        }
 
        flow = malloc(sizeof(struct flow));
        if (!flow) {
                logging(LOG_ALERT, "could not allocate memory for flow");
                return;
        }
 
        init_flow(flow, 0);
 
        flow->settings = request->settings;
        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;
        }
 
        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);
        }
 
        /* Create listen socket for data connection */
        if ((flow->listenfd_data =
                        create_listen_socket(flow,
                                             flow->settings.bind_address[0]
                                                ? flow->settings.bind_address : 0,
                                             &server_data_port)) == -1) {
                logging(LOG_ALERT, "could not create listen socket for "
                        "data connection: %s", flow->error);
                request_error(&request->r, "could not create listen socket "
                              "for data connection: %s", flow->error);
                uninit_flow(flow);
                return;
        } else {
                /* FIXME: currently we use portable select() API, which
                 * is limited by the number of bits in an fd_set */
                if (flow->listenfd_data >= FD_SETSIZE) {
                        logging(LOG_ALERT, "failed to add listen socket: "
                                "fd number too high (fd=%u)", flow->listenfd_data);
                        flow_error(flow, "failed to add listen socket: too many"
                                "file descriptors in use by this daemon");
                        uninit_flow(flow);
                        return;
                }
                DEBUG_MSG(LOG_WARNING, "listening on %s port %u for data "
                          "connection (fd=%u)", flow->settings.bind_address,
                          server_data_port, flow->listenfd_data);
        }
 
        flow->real_listen_send_buffer_size =
                set_window_size_directed(flow->listenfd_data,
                                         flow->settings.requested_send_buffer_size,
                                         SO_SNDBUF);
        flow->real_listen_receive_buffer_size =
                set_window_size_directed(flow->listenfd_data,
                                         flow->settings.requested_read_buffer_size,
                                         SO_RCVBUF);
 
        request->listen_data_port = (int)server_data_port;
        request->real_listen_send_buffer_size =
                flow->real_listen_send_buffer_size;
        request->real_listen_read_buffer_size =
                flow->real_listen_receive_buffer_size;
        request->flow_id = flow->id;
 
        fg_list_push_back(&flows, flow);
 
        return;
}