src/vfer_api.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 *
 * @file   vfer_api.c
 * @author Ivan Beschastnikh
 * @brief  Implements the api calls that can be made to the library.
 *
 * The application may only call the functions prototyped in
 * api.h. The API has been written by Steven Senger of Internet2, and
 * can be found online at
 * http://transport.internet2.edu/transport-api-06.pdf
 *
 * -     05/08-11/06     ivan            Moved to using vfer_fd data type for all api calls, mane changes due to new threading model
 * -     04/30/06        ivan            implemented vfer_recvfile and vfer_sendfile
 * -     03/25/06        ivan            added debugging support for congestion control (ccontrol.c) in the form of DEBUG_CCTL var in vfer_debug
 * -     12/29/05        ivan            added VFERSO_SNDSIZE support to control packet|frag size dynamically with vfer_setsockopt
 *                                       added nonblocking socket vfer_connect() functionality, moved all connect logic to Control_ConnectT @ control.c
 * -     12/28/05        ivan            tsci2 integration ; vfer_setsockopt and vfer_sendfile bug fixes
 * -     10/17/05        ivan            added vfer_debug function to specify level of debug verbosity at runtime
 * -     10/13/05        ivan            now includes a main page blurb for doxygen created docs
 * -     09/01/05        ivan            modified to use new packet structures
 * -     08/28/05        ivan            added recv/send buffer setting and udp checksum enable checking in vfer_bind
 * -     08/05/05        ivan            changed vfer_connect to release socket correctly on error and support nonblocking vfer_sockets
 * -     07/28/05        ivan            c_control hooks to vfer{accept,connect,send,recv}, debug printing for all api calls added
 * -     07/18,19,20/05  ivan            select related function implementations
 * -     06/29/05        ivan            migration to the api specified in I2's writeup (version 6), all doxygened
 * -     06/10/05        ivan            renamed to api.[c,h] (from protocol.[c,h]) ; wrote Protocol_Init code & Accept code for barebones connection
 * -     05/24/05        ivan            initially added to app_api layer & recoded for this
 * -     05/18/05        ivan            created
 */

/** \mainpage VFER
 *
 * \section intro_sec Introduction
 *
 * VFER is a functionally reliable, congestion controlled transport
 * protocol. It is connection based, bidirectional and is meant to
 * work on top of IP. The protocol is TCP friendly, and is
 * functionally reliable. This documentation is generated for a user
 * level prototype implementation of VFER written in C.
 *
 * For more information regarding VFER or this implementation please
 * visit the project's homepage: http://vfer.sf.net
 */

#include "vfer_api.h"

/*
 * controls whether the protocol has been initialized
 * or not (tested by a macro defined in api.h)
 */
static int Initialized = -1;
static int Debug_Initialized = -1;

/* an internal function used for initializeation of components, etc */
static int vfer_internal_init();

/*
 * test is the protocol has been initialized and if it hasn't, calls
 * vfer_internal_init() to initialize all layers of the protocol
 */
#define PROTOCOL_INIT_TEST ({ \
        if (Initialized == -1) \
                vfer_internal_init(); \
        -1;})

/* Begin I2 api Version 6 */

/**
 * Return a newly reserved vfer socket identifier
 *
 * In case the call fails the error status can be obtained through
 * vfer_sockstatus(). Only socktype of type SOCK_DGRAM is supported
 * right now.
 *
 * @param socktype a SOCK_STREAM or SOCK_DGRAM
 * @return
 *      - a vfer_fd identifier >= 0
 *      - a negative vfer_fd identifier varrying the error code:
 *        - VFER_BADTYPE invalid socktype error
 *        - VFER_IMPL underlying socket descriptor failure
 */
vfer_fd vfer_socket(int socktype) {
        int sockfd, icmp_fd;
        int i;
        char is_df_set;
        vfer_sock* sock;

        if (!PROTOCOL_INIT_TEST) return VFER_IMPL;
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_socket", "Entered");

        if (socktype != SOCK_STREAM && socktype != SOCK_DGRAM) {
                return VFER_BADTYPE;
        }

        if (socktype == SOCK_STREAM) {
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_socket", "only socktype of SOCK_DGRAM supported");
                return VFER_BADTYPE;
        }

        for (i = 0; i < MAX_SOCKETS; i++) {
                pthread_mutex_lock(&(sockets.s[i].mutex));
                if (sockets.s[i].state == CONN_DISCONNECTED) {
                        sock = &(sockets.s[i]);
                        sock->state = CONN_ACQUIRED;
                        pthread_mutex_unlock(&(sockets.s[i].mutex));
                        break;
                }
                pthread_mutex_unlock(&(sockets.s[i].mutex));
        }
        if (i == MAX_SOCKETS) {
                return VFER_IMPL;
        }

        Datagrams_Clear(&(sock->recvd_frames));

        if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
                perror("vfer_socket :: socket");
                pthread_mutex_lock(&(sock->mutex));
                sock->state = CONN_DISCONNECTED;
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_IMPL;
        }

        if (fcntl(sockfd, F_SETFD, O_NONBLOCK) == -1) {
                perror("vfer_socket :: fcntl");
                pthread_mutex_lock(&(sock->mutex));
                sock->state = CONN_DISCONNECTED;
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_IMPL;
        }

        /* PMTU: Set DF bit */
        SET_DF_BIT(sockfd, is_df_set);
        if(is_df_set < 0){
                sock->is_df_set = 0;
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_socket", "Unable to set DF bit. Continuing without PMTUD");
        }else{
                sock->is_df_set = 1;
        }

        /* PMTU: Create socket for ICMP messages. Useful but not required for PMTU discovery. */
        if(sock->is_df_set == 0){
                icmp_fd = -1;
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_socket", "DF bit not set so ICMP not needed.");
        }else if ((icmp_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_ICMP)) == -1) {
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_socket", "Unable to create ICMP socket. Continuing anyways");
        }else if (fcntl(icmp_fd, F_SETFD, O_NONBLOCK) == -1) {
                icmp_fd = -1;
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_socket", "Unable to remove blocking on ICMP socket. Continuing without ICMP.");
        }else{
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_socket", "ICMP socket created.");
        }

        sock->fd = sockfd;
        sock->icmp_fd = icmp_fd;
        sock->type = socktype;
        sock->err = 0;
        sock->opts = 0;
        sock->state = CONN_ACQUIRED;
        sock->select_mark = 0;
        sock->select_result = 0;
        sock->select_active = 0;
        sock->connect_timeout = DEFAULT_CONNECT_TIMEOUT;
        sock->close_timeout = 0;
        sock->accept_timeout = 0;
        sock->snd_timeout = 0;
        sock->rcv_timeout = 0;
        return i;
} /* vfer_sock() */


/**
 * Closes the socket identified by a vfer identifier.
 *
 * This call returns immediately without changing the error status
 * of sock if sock is marked with an error on entry.
 *
 * @param vfd vfer socket identifier
 * @return
 *      - 0 on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_IMPL failure closing underlying socket descriptor
 */
int vfer_close(vfer_fd vfd) {
        vfer_sock* sock;

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        sock = &(sockets.s[vfd]);
        if (sock->err != 0) { return VFER_BADSOCK; }

        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_close", "Entered vfd[%d]", vfd);

        pthread_mutex_lock(&(sock->mutex));
        switch (sock->state) {
        case CONN_DISCONNECTED:
        case CONN_DISCONNECTING:
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_close", "Socket already disconnected or disconnecting");
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_BADSOCK;
        case CONN_CONNECTED:
                /* Control_Close() changes the state of the socket, make sure not to alter afterwards! */
                Control_Close(sock);
                break;
        case CONN_LISTENING:
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_close", "Closing listening socket");
                Accept_Queue_Delete(sock->accept_queue);
                sock->state = CONN_DISCONNECTED;
                pthread_mutex_unlock(&(sock->mutex));
                Control_Unregister_Socket(sock);
                return 0;
        default:
                close(sock->fd);
                sock->state = CONN_DISCONNECTED;
        }
        pthread_mutex_unlock(&(sock->mutex));
        return 0;
} /* vfer_close() */


/**
 * Establishes a connection with a peer.
 *
 * This works equally for a SOCK_DGRAM or SOCK_STREAM (if
 * implemented): attempts a connection operation with the peer defined
 * by addr and len. This call returns immediately without changing the
 * error status of sock if sock is marked with an error on entry. If
 * the socket is nonblocking then this call returns as soon as
 * possible (connection will happen in the background ie. with the
 * ControlT thread). A vfer_select() call can then determine if the
 * connection succeded or not. For a nonblocking socket, this call
 * returns VFER_INPROGRESS.
 *
 * @param vfd vfer socket identifier
 * @param serv_addr a peer address
 * @param addrlen length of addr
 * @return
 *      - 0 on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_TIMEOUT connection attempt timedout
 *      - VFER_REFUSED connection attempt refused
 *      - VFER_NOCONN socket is not able to perform a connect.
 *      - VFER_INPROGRESS only returned for nonblocking socket- indicates success
 */
int vfer_connect(vfer_fd vfd, const struct sockaddr *serv_addr, int addrlen) {
        vfer_sock* sock;
        int ret;

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        sock = &(sockets.s[vfd]);
        if (sock->err != 0) { return VFER_BADSOCK; }

        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_connect", "Entered");

        /***************/
        pthread_mutex_lock(&(sock->mutex));
        if (sock->state != CONN_BOUND) {
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_connect", "socket not bound");
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_BADSOCK;
        }
        memcpy(&sock->addr, serv_addr, addrlen);
        sock->addr_len = sizeof(sock->addr);

        if ((ret = Control_Connect(sock)) == -1) {
                pthread_mutex_unlock(&(sock->mutex));
                return sock->err;
        } else if (ret == -2) {
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_INPROGRESS;
        }

        pthread_mutex_unlock(&(sock->mutex));
        /***************/
        return 0;
} /* vfer_connect() */


/**
 * Associate the socket with the specified addr.
 *
 * This call returns BADSOCK immediately without changing the error
 * status of sock if sock is marked with an error on entry.
 *
 * @param vfd vfer socket identifier
 * @param addr a peer address
 * @param len length of addr
 * @return
 *      - 0 on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_NOBIND socket is not able to perform a bind because it is bound
 *      - VFER_BADADDR address is unavailable or in use.
 */
int vfer_bind(vfer_fd vfd, struct sockaddr *addr, int len) {
        int err;
        int val;
        int ret;
        int num_packets;
        vfer_sock* sock;

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        sock = &(sockets.s[vfd]);
        if (sock->err != 0) { return VFER_BADSOCK; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_bind", "Entered");

        /* PMTU: try to bind ICMP socket */
        if (sock->icmp_fd == -1 || bind(sock->icmp_fd, addr, len) < 0) {
                sock->icmp_fd = -1;
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_bind", "Unable to bind ICMP socket. Continuing without ICMP.");
        }else{
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "api.c", "vfer_bind", "ICMP socket bind succeeded.");
        }

        /***************/
        pthread_mutex_lock(&(sock->mutex));
        switch (sock->state) {
        case CONN_BOUND:
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_BADSOCK;
        case CONN_ACQUIRED:
                break;
        default:
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_BADSOCK;
        }

        if (bind(sock->fd, addr, len) < 0) {
                err = errno;
                pthread_mutex_unlock(&(sock->mutex));
                perror("vfer_bin :: bind");
                if (err == EINVAL) {
                        return VFER_NOBIND;
                }
                return VFER_BADADDR;
        }

        /* try to set the receive buffer sizes */
        num_packets = DEFAULT_RECV_BUF_MAXPACKETS;
        val = CALC_UDP_RECV_BUF_SIZE(num_packets);
        do {
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_bind", "Trying to set SO_RCVBUF to %d", val);
                ret = setsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val));
                if (ret != 0) {
                        if (errno == ENOBUFS && num_packets > 100) {
                                num_packets -= 100;
                                val = CALC_UDP_RECV_BUF_SIZE(num_packets);
                        } else {
                                perror("vfer_bind :: setsockopt");
                                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_bind", "Could not set RCVBUF size to [%d]", val);
                                pthread_mutex_unlock(&(sock->mutex));
                                return VFER_NOBIND;
                        }
                }
        } while (ret != 0);
        sock->udp_recv_buf_size = val;

        /* try to set the send buffer size */
        num_packets = DEFAULT_SEND_BUF_MAXPACKETS;
        val = CALC_UDP_SEND_BUF_SIZE(num_packets);
        do {
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_bind", "Trying to set SO_SNDBUF to %d", val);
                ret = setsockopt(sock->fd, SOL_SOCKET, SO_SNDBUF, &val, sizeof(val));
                if (ret != 0) {
                        if (errno == ENOBUFS && num_packets > 100) {
                                num_packets -= 100;
                                val = CALC_UDP_SEND_BUF_SIZE(num_packets);
                        } else {
                                perror("vfer_bind :: setsockopt");
                                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_bind", "Could not set SNDBUF size to [%d]", val);
                                pthread_mutex_unlock(&(sock->mutex));
                                return VFER_NOBIND;
                        }
                }
        } while (ret != 0);
        sock->udp_send_buf_size = val;

        sock->state = CONN_BOUND;
        pthread_mutex_unlock(&(sock->mutex));
        /*****************/
        return 0;
} /* vfer_bind() */

/**
 * Configures socket to listen for incoming connection requests.
 *
 * The call returns VFER_BADSOCK immediately without changing the error status
 * of sock if sock is marked with an error on entry.
 *
 * @param vfd vfer socket identifier
 * @param backlog the size of the queue for pending requests
 * @return
 *      - 0 on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_NOLISTEN socket is not able to perform a listen
 */
int vfer_listen(vfer_fd vfd, int backlog) {
        vfer_sock* sock;

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS) || (backlog < 1)) { return VFER_BADSOCK; }
        sock = &(sockets.s[vfd]);
        if (sock->err != 0) { return VFER_BADSOCK; }

        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_listen", "Entered");
        pthread_mutex_lock(&(sock->mutex));
        if (sock->state != CONN_BOUND) {
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_BADSOCK;
        }

        if (!(sock->accept_queue = Accept_Queue_Create(backlog))) {
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_NOLISTEN;
        }

        sock->state = CONN_LISTENING;
        pthread_mutex_unlock(&(sock->mutex));
        Control_Register_Socket(sock);
        return 0;
} /* vfer_listen() */


/**
 * For a socket in the listening state, removes the first pending
 * connection request from the queue and establishes a connection on
 * that socket.
 *
 * The call returns a socket identifier for use with the
 * connection. If, on entry, the listening socket is marked with an
 * error, this call immediately returns VFER_BADSOCK without changing
 * the error status.
 *
 * @param vfd vfer socket identifier
 * @param addr pointer to an address structure to be filled in with information
 * @param len length of the address strucutre
 * @return
 *      - a positive vfer socket identifier on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_TIMEOUT accept connection attempt timedout
 *      - VFER_NOACCEPT socket is not able to perform an accept because it is not listening,
 *      - VFER_NOTSTREAM socket is not of type SOCK_STREAM
 *      - VFER_WOULDBLOCK socket is non-blocking and there are no waiting connections
 *      - VFER_IMPL underlying socket error
 */
vfer_fd vfer_accept(vfer_fd vfd, struct sockaddr *addr, socklen_t *len) {
        vfer_sock* accepted_socket;     /* socket pointer to socket to use as accepting socket */
        vfer_sock* sock;                /* listening socket pointer */
        int ret, i;

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS) || !addr || !len) { return VFER_BADSOCK; }
        sock = &(sockets.s[vfd]);
        if (sock->err != 0) { return VFER_BADSOCK; }

        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_accept", "Entered");

        pthread_mutex_lock(&(sock->mutex));
        if (sock->state != CONN_LISTENING) {
                pthread_mutex_unlock(&(sock->mutex));
                return VFER_BADSOCK;
        }
        pthread_mutex_unlock(&(sock->mutex));

        /* reserve a socket for acquisition */
        for (i = 0; i < MAX_SOCKETS; i++) {
                pthread_mutex_lock(&(sockets.s[i].mutex));
                if (sockets.s[i].state == CONN_DISCONNECTED) {
                        accepted_socket = &(sockets.s[i]);
                        accepted_socket->state = CONN_ACQUIRED;
                        /* note that we locked the accepted_socket's mutex */
                        break;
                }
                pthread_mutex_unlock(&(sockets.s[i].mutex));
        }
        if (i == MAX_SOCKETS) {
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_accept", "reached connections limit");
                return VFER_IMPL;
        }

        /* accept connection on top of queue */
        ret = Control_Accept(sock, accepted_socket);
        if (ret == 0) {
                ret = i;
        } else {
                // printf("setting state to disconnected for ret_sock\n");
                accepted_socket->err = 0;
                accepted_socket->state = CONN_DISCONNECTED;
        }
        pthread_mutex_unlock(&(accepted_socket->mutex));
        return ret;
} /* vfer_accept() */


/**
 * Uses the data described by optval and optlen to set optname on socket.
 *
 * If, on entry, the socket is marked with an error, this call
 * immediately returns without changing the error status. The possible
 * option names are:
 * - SOCK_STREAM
 * - SOCK_DGRAM
 *   - QTTL (int) The duration (in msec) that unacknowledged messages will
 *     remain available for retransmission.
 * - Both
 *   - SNDSIZE (int) The packet size used for the underlying transport.
 *     This defaults to the MTU.
 *   - NOPMTUD (int) Disable PMTUD.
 *   - NONBLOCK (int) Set socket to use non-blocking mode for send, recv,
 *     accept and connect calls.
 *
 * @param vfd vfer socket identifier
 * @param optname option name
 * @param optval option value
 * @param optlen option length,description
 * @return
 *      0 on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_BADOPT unknown or illegal option/length
 */
int vfer_setsockopt(vfer_fd vfd, int optname, void *optval, int optlen) {
        int ival;

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS) || (sockets.s[vfd].err != 0)) { return VFER_BADSOCK; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_setsockopt", "Entered with optname[%d]", optname);

        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        switch (optname) {
        case VFERSO_QTTL:
                /* not implemented */
                break;
        case VFERSO_SNDSIZE:
                /* not implemented */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }

                ival = *((int*)(optval));
                if (ival < 1) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].ccontrol.mtu = ival;
                break;
        case VFERSO_RELFUN:
                if (optlen != sizeof(relfun_t*)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].relfun = optval;
                break;
        case VFERSO_CONNECTTIMEOUT:
                /* controls timeout value for vfer_connect() */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].connect_timeout = *((int*)(optval));
                break;
        case VFERSO_CLOSETIMEOUT:
                /* controls timeout value for vfer_close- irrespective of whether send queue is empty or not */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].close_timeout = *((int*)(optval));
                break;
        case VFERSO_ACCEPTTIMEOUT:
                /* controls timeout value for vfer_accept() */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].accept_timeout = *((int*)(optval));
                break;
        case VFERSO_SNDTIMEOUT:
                /* controls timeout value for vfer_send() */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].snd_timeout = *((int*)(optval));
                break;
        case VFERSO_RCVTIMEOUT:
                /* controls timeout value for vfer_recv() */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                sockets.s[vfd].rcv_timeout = *((int*)(optval));
                break;
        case VFERSO_NOPMTUD:
                /* controls whether path mtu is performed. Default is 0. */
                if (optlen != sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                if(1 == *((int*)(optval))){
                        sockets.s[vfd].pmtu.probe_state = NO_PMTUD;
                }
                break;
        case VFERSO_NONBLOCK:
                if (*((int*)(optval)) == 1) {
                        sockets.s[vfd].opts |= optname;
                } else {
                        sockets.s[vfd].opts &= (~optname);
                }
                break;
        default:
                pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                return VFER_BADOPT;
        }
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return 0;
} /* vfer_setsockopt() */


/**
 * Returns data describing option optname of socket.
 *
 * On entry optlen is the size of space pointed to by optval. On exit,
 * optlen is changed to reflect the actual size of the returned
 * data. If, on entry, sock is marked with an error, this call
 * immediately returns without changing the error status. In
 * addition to the option names valid for the vfer_setsockopt() call the
 * following additional options are available.
 * - SOCK_STREAM
 * - SOCK_DGRAM
 *   - MTU (int) current MTU
 *   - MSGSIZE (int) The maximum size of an individual message.
 *
 * @param vfd vfer socket identifier
 * @param optname option name pointer
 * @param optval option value pointer
 * @param optlen option length,description pointer
 * @return
 *      - 0 on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_BADOPT unknown or illegal option/length
 */
int vfer_getsockopt(vfer_fd vfd, int optname, void *optval, int *optlen) {

        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS) || !optval || !optlen || (sockets.s[vfd].err != 0)) { return VFER_BADSOCK; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_getsockopt", "Entered with optname[%d]", optname);

        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        if (*optlen <= 0) {
                pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                return VFER_BADOPT;
        }

        switch (optname) {
        case VFERSO_QTTL:
                /* not implemented */
                break;
        case VFERSO_SNDSIZE:
                /* not implemented */
                break;
        case VFERSO_NOPMTUD:
                /* okay not to check optlen since > 0 */
                *((char*)(optval)) = SOCK_OPT_ISSET((&(sockets.s[vfd])), VFERSO_NOPMTUD);
                *optlen = 1;
                break;
        case VFERSO_NONBLOCK:
                /* okay not to check optlen since > 0 */
                *((char*)(optval)) = SOCK_OPT_ISSET((&(sockets.s[vfd])), VFERSO_NONBLOCK);
                *optlen = 1;
                break;
        case VFERSO_RELFUN:
                /* not implemented */
                break;
        case VFERSO_CONNECTTIMEOUT:
                if (*optlen < sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                *((int*)(optval)) = sockets.s[vfd].connect_timeout;
                *optlen = sizeof(int);
                break;
        case VFERSO_CLOSETIMEOUT:
                if (*optlen < sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                *((int*)(optval)) = sockets.s[vfd].close_timeout;
                *optlen = sizeof(int);
                break;
        case VFERSO_ACCEPTTIMEOUT:
                if (*optlen < sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                *((int*)(optval)) = sockets.s[vfd].accept_timeout;
                *optlen = sizeof(int);
                break;
        case VFERSO_SNDTIMEOUT:
                if (*optlen < sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                *((int*)(optval)) = sockets.s[vfd].snd_timeout;
                *optlen = sizeof(int);
                break;
        case VFERSO_RCVTIMEOUT:
                if (*optlen < sizeof(int)) {
                        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                        return VFER_BADOPT;
                }
                *((int*)(optval)) = sockets.s[vfd].rcv_timeout;
                *optlen = sizeof(int);
                break;
        default:
                pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                return VFER_BADOPT;
        }
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return 0;
} /* vfer_getsockopt() */

/**
 * Computes and return current performance data for socket sock.
 *
 * If, on entry, vfd is invalid or marked with an error this call
 * immediately returns a zeroed out vfer_stats structure. On
 * successfully return, this structure contains among many other
 * things, average performance statistics for the socket and
 * incremental statistics since the last call to
 * vfer_sockstats(). Performance statistics include the following.
 * - send rate in Mbps
 * - recv rate in Mbps
 * - retransmit traffic as a fraction of total traffic
 * - round trip time statistics
 *
 * For a SOCK_DGRAM socket, configured for partial reliability, the
 * performance statistics also include the number of messages that
 * expire after exceeding the QTTL limit.
 *
 * @param vfd vfer socket identifier
 * @return
 *      - a stats structure filled with current stats about socket sock
 *      - a zeroed out stats structure on error
 */
vfer_stats vfer_sockstats(vfer_fd vfd) {
        vfer_stats stats;
        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return stats; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_sockstats", "Entered");

        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        stats = sockets.s[vfd].stats;
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return stats;
} /* vfer_sockstats() */


/**
 * Returns the error condition of a socket
 *
 * @param vfd vfer socket identifier
 * @return
 *      the error condition of socket sock.
 */
int vfer_sockerror(vfer_fd vfd) {
        int err;
        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return 0; }
        /* DEBUG_PRINT(DEBUG_API, "api.c", "vfer_sockerror", "Entered"); */

        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        err = sockets.s[vfd].err;
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return err;
} /* vfer_sockerror() */


/**
 * Returns a text description of the error code err.
 *
 * @param err error code
 * @return
 *      a pointer to a text description of err
 */
char* vfer_errortext(int err) {
        if (!PROTOCOL_INIT_TEST) return 0;
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_errortext", "Entered");

        switch (err) {
        case 0:
                return "success";
        case VFER_BADTYPE:
                return "invalid socket type";
        case VFER_IMPL:
                return "internal implemenation error";
        case VFER_BADSOCK:
                return "bad socket passed as argument";
        case VFER_TIMEOUT:
                return "connection attempt timedout";
        case VFER_REFUSED:
                return "connection refused";
        case VFER_NOCONN:
                return "not able to connect on a socket";
        case VFER_NOBIND:
                return "can't bind the socket";
        case VFER_BADADDR:
                return "bad adress passed as argument";
        case VFER_NOLISTEN:
                return "can't listen on socket";
        case VFER_NOACCEPT:
                return "socket not able to perform accept because it is not listening";
        case VFER_NOTSTREAM:
                return "socket is not of type SOCK_STREAM";
        case VFER_WOULDBLOCK:
                return "socket is non-blocking and there are no waiting connections";
        case VFER_BADOPT:
                return "unknown or illegal option/length";
        case VFER_BADFD:
                return "error using mmap on fd";
        case VFER_INVAL:
                return "argument value is invalid";
        case VFER_UNCONN:
                return "socket is not connected";
        default:
                return "unrecognized error";
        }
} /* vfer_errortext() */


/**
 * Mmap the file described by fd and send size bytes of data starting
 * at offset. For now we assume that this send call will use the
 * current reliability function, ie. if the file will be arbitrarily
 * parititioned into frames (into MAX_SEND_WINDOW chunks), each frame
 * will be treated separately as far as reliability is
 * concerned. Therefore this call makes most sense if the reliability
 * function is the constant 1 (ie. full reliability).
 *
 * @param vfd vfer socket identifier
 * @param fd file descriptor to map into mem and to send
 * @param offset data starting position in the file
 * @param size number of bytes to send
 * @return
 *      - Returns the actual number of bytes sent on success
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_BADFD error using mmap on fd
 *      - VFER_INVAL invalid offset or size
 */
int vfer_sendfile(vfer_fd vfd, int fd, off_t offset, size_t size) {
    if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
    DEBUG_PRINT(DEBUG_API, "api.c", "vfer_sendfile", "Entered fd[%d] offset[%d] size[%d]", fd, (int)(offset), (int)(size));

    return vfer__sendfile( (vfer_trnsm_fn) vfer_send,
                           (vfer_trnsm_arg) vfd, MAX_FRAME_SIZE, fd,
                           offset, size);
}

/**
 * Mmap the file described by \a fd and send \a size bytes of data
 * starting at \a offset into socket \a arg using function \a fn.
 *
 * @param[in] fn  send function to use
 * @param[in] arg socket argument to pass to send function
 * @param[in] frame_size maximum frame size that \a fn can handle for
 *            \a arg
 * @param[in] fd file descriptor to map into mem and to send
 * @param[in] offset writing starting position in the file
 * @param[in] size number of bytes to send
 * @return
 *      - Returns the actual number of bytes sent on success
 *      - VFER_BADFD error using mmap on fd
 *      - VFER_INVAL invalid offset or size
 *      - Every error code that \a fn can return
 */
int vfer__sendfile(vfer_trnsm_fn fn, vfer_trnsm_arg arg,
                   int frame_size, int fd, off_t offset, size_t size) {
        void* ptr;
        int bytes_sent, err, n, to_send;
        size_t to_map, bytes_mapped;
        int page_size;
        size_t mmap_chunk_size;

        /* determine the mmap_chunk_size as a multiple of page_size */
        page_size = getpagesize();
        mmap_chunk_size = (MMAP_CHUNK_SIZE / page_size) * page_size;

        bytes_mapped = 0;
        while (bytes_mapped != size) {
                if ((size - bytes_mapped) >= mmap_chunk_size) {
                        to_map = mmap_chunk_size;
                } else {
                        to_map = size - bytes_mapped;
                }
                ptr = mmap(0, to_map, PROT_READ, MAP_PRIVATE, fd, bytes_mapped + offset);
                if (ptr == MAP_FAILED) {
                        err = errno;
                        perror("vfer__sendfile :: mmap");
                        DEBUG_PRINT(DEBUG_API, "api.c", "vfer__sendfile", "mmap failed with err[%d]", err);
                        switch (err) {
                        case EBADF:
                                return VFER_BADFD;
                        default:
                                return VFER_INVAL;
                        }
                }

                /* loop and send max sized frames until eof */
                bytes_sent = 0;
                while (bytes_sent != to_map) {
                        if ((to_map - bytes_sent) >= frame_size) {
                                to_send = frame_size;
                        } else {
                                to_send = to_map - bytes_sent;
                        }
                        n = fn(arg, ptr + bytes_sent, to_send);
                        if (n < 0) {
                                DEBUG_PRINT(DEBUG_API, "api.c", "vfer__sendfile", "send function failed with err[%d]", n);
                                munmap(ptr, to_map);
                                return n;
                        }
                        bytes_sent += n;
                }
                bytes_mapped += to_map;
                munmap(ptr, to_map);
        }
        return bytes_mapped;
} /* vfer__sendfile() */

/**
 * Sends len bytes from buf on a connected socket.
 *
 * If the socket is of type SOCK_DGRAM then the data is treated as a
 * single message and len must be less then the maximum message
 * length. Messages greater than SNDSIZE are fragmented. On a fully
 * reliable socket messages will be delivered intact. Messages always
 * arrive *in* the original order. On an unreliable socket messages
 * are either delivered intact or discarded also *in* the original
 * order.
 *
 * @param vfd vfer socket identifier
 * @param buf a pointer to a buffer to send
 * @param len length of the data to send starting at buf
 * @return
 *      - Returns the actual number of bytes sent on success (a positive number)
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_TIMEOUT timed out while sending data
 *      - VFER_UNCONN sock is not connected
 *      - VFER_INVAL invalid buf or len
 *      - VFER_WOULDBLOCK socket is non-blocking and requested operation would block
 */
int vfer_send(vfer_fd vfd, const void * buf, size_t len) {
        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        /* DEBUG_PRINT(DEBUG_API, "api.c", "vfer_send", "Entered len[%d]", len); */

        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        if (sockets.s[vfd].state == CONN_CONNECTED) {
                if (len > MAX_FRAME_SIZE) {
                        return VFER_INVAL;
                }
                return Control_Send(&(sockets.s[vfd]), buf, len); /* this function sets sock->err */
        }
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return VFER_UNCONN;
} /* vfer_send() */


/**
 * Reads size bytes from socket writing them into the file described
 * by fd at offset offset.
 *
 * @param vfd vfer socket identifier
 * @param fd file descriptor to write received data to
 * @param offset writing starting position in the file
 * @param size number of bytes to read
 * @return
 *      - Returns the actual number of bytes read on success (a positive number)
 *      - VFER_TIMEOUT timed out while waiting to receive file
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_INVAL invalid offset or size
 */
int vfer_recvfile(vfer_fd vfd, int fd, off_t offset, size_t size) {
    if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
    DEBUG_PRINT(DEBUG_API, "api.c", "vfer_recvfile", "Entered fd[%d] offset[%d] size[%d]", fd, (int)(offset), (int)(size));

    return vfer__recvfile( (vfer_trnsm_fn) vfer_recv,
                           (vfer_trnsm_arg) vfd, MAX_FRAME_SIZE, fd,
                           offset, size);
}



/**
 * Reads \a size bytes from socket \a arg using function \a fn and
 * writes them into the file described by \a fd at offset \a offset.
 *
 * @param[in] fn  receive function to use
 * @param[in] arg socket argument to pass to receive function
 * @param[in] frame_size maximum frame size that \a fn can handle for
 *            \a arg
 * @param[out] fd file descriptor to write received data to
 * @param[in] offset writing starting position in the file
 * @param[in] size number of bytes to read
 * @return
 *      - Returns the actual number of bytes read on success (a positive number)
 *      - Every error code that \a fn can return
 *      - VFER_INVAL invalid offset or size
 */
int vfer__recvfile(vfer_trnsm_fn fn, vfer_trnsm_arg arg,
                   uint32_t frame_size, int fd, off_t offset, size_t size) {
    char file_buf[frame_size];
    int i, n;

    /* set the file pointer to requested offset position in the file */
    lseek(fd, offset, SEEK_SET);

    /* i counts the number of frames received */
    /* size maintains number of bytes left to write  */
    i = n = 0;
    while (size != 0 && ((n = fn(arg, file_buf, frame_size)) > 0)) {
        if (n > size) {
            n = size;
        }
                if (write(fd, file_buf, n) != n) {
                    perror("vfer_recvfile :: write");
                    DEBUG_PRINT(DEBUG_API, "api.c", "vfer__recvfile", "write failed on frame[%d]", i);
                    return VFER_INVAL;
                }
                i++;
                size -= n;
    }
    if (n < 0) {
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer__recvfile", "receive function failed on frame[%d] error[%d]", i, n);
        return n;
    }
    return size;
} /* vfer__recvfile() */


/**
 * Read up to len bytes from socket into buf. If the socket is of type
 * SOCK_DGRAM then an entire message is read into buf with bytes in
 * excess of len being discarded.
 *
 * @param vfd vfer socket identifier
 * @param buf a pointer to a buffer into which to receive
 * @param len maximum length of data to receive into buf
 * @return
 *      - number of bytes read on success
 *      - VFER_TIMEOUT timed out while waiting to receive data
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_UNCONN sock is not connected
 *      - VFER_INVAL invalid buf or len
 *      - VFER_WOULDBLOCK socket is non-blocking and requested operation would block
 */
int vfer_recv(vfer_fd vfd, void *buf, size_t len) {
        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        /* DEBUG_PRINT(DEBUG_API, "api.c", "vfer_recv", "Entered len[%d]", len); */

        if (len > MAX_FRAME_SIZE) { return VFER_INVAL; }

        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        if (sockets.s[vfd].state != CONN_CONNECTED &&
            sockets.s[vfd].state != CONN_DISCONNECTED &&
            sockets.s[vfd].state != CONN_DISCONNECTING) {
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_recv", "socket not in CONN_CONNECTED/DISCONNECTED/DISCONNECTING states but state[%d]",
                            sockets.s[vfd].state);
                pthread_mutex_unlock(&(sockets.s[vfd].mutex));
                return VFER_UNCONN;
        }
        return Control_Recv(&(sockets.s[vfd]), buf, len); /* this function sets sock->err */
} /* vfer_recv() */

/**
 * Marks socket with the conditions to be tested by the select call.
 *
 * Called prior to using vfer_select(). Mark is a bitwise OR of
 * VFER_READABLE, VFER_WRITABLE and VFER_EXCEPTION.
 *
 * @param vfd vfer socket identifier
 * @param mark a mark to associate with the socket sock
 * @return
 *      - 0 on succes
 *      - VFER_BADSOCK bad vfd argument
 *      - VFER_INVAL invalid mark value
 */
int vfer_selectmark(vfer_fd vfd, int mark) {
        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_selectmark", "Entered");
        if ((mark ^ (VFER_READABLE | VFER_WRITABLE | VFER_EXCEPTION)) != 0) {
                return VFER_INVAL;
        }
        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        sockets.s[vfd].select_mark = mark;
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return 0;
} /* vfer_selectmark() */

/**
 * Returns the result of the vfer_select() call for socket.
 *
 * The return value will be a bitwise OR of VFER_READABLE,
 * VFER_WRITABLE and VFER_EXCEPTION depending on how sock was marked
 * and the result of the vfer_select() call.
 *
 * @param vfd vfer socket identifier
 * @return
 *      - bitwise OR of marks for socket sock on succes
 *      - VFER_BADSOCK bad vfer_sock
 */
int vfer_selecttest(vfer_fd vfd) {
        int ret;
        if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS)) { return VFER_BADSOCK; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_selecttest", "Entered");
        pthread_mutex_lock(&(sockets.s[vfd].mutex));
        ret = (int)(sockets.s[vfd].select_result);
        pthread_mutex_unlock(&(sockets.s[vfd].mutex));
        return ret;
} /* vfer_selecttest() */

/**
 * Returns the number of sockets in an array that satisfy the marked
 * conditions.
 *
 * Timeout is the maximum time to wait before the call returns. If
 * timeout is null the call blocks indefinitely. A timeout value of
 * zero can be used to effect a poll operation. Timeout is not changed
 * by the call.
 *
 * @param len length of vfds array
 * @param vfds an array of socket vfer_fds to check for marked conditions
 * @param timeout a timeout value to control waiting time
 * @return
 *      - number of sockets in array socks that satisfy the marked conditions
 *      - VFER_BADSOCK one of the vfer_sock's in socks is bad
 *      - VFER_IMPL underlying select error
 *      - VFER_INVAL timeout value is invalid
 */
int vfer_select(int len, vfer_fd *vfds, struct timeval *timeout) {
        int i;                  /* itterator var */
        int count;              /* counts number of sockets that have non 0 select marks */
        int ret;                /* return var for pthread_cond_timedwait */
        struct timespec timedwait_timeout; /* used as argument to  pthread_cond_timedwait */

        if (!PROTOCOL_INIT_TEST) { return VFER_BADSOCK; }
        DEBUG_PRINT(DEBUG_API, "api.c", "vfer_select", "Entered");

        /* count the number of sockets marked with a condition to test
           for and set their select_active to 1 indicating that
           select_mark should be consulted and select_result should be
           set in case of correct condition for the socket */
        count = 0;
        pthread_mutex_lock(&(sockets.select_mutex));
        for (i = 0; i < len; i++) {
                if ((vfds[i] < 0) || (vfds[i] > MAX_SOCKETS)) {
                        return VFER_BADSOCK;
                }
                pthread_mutex_lock(&(sockets.s[vfds[i]].mutex));
                if (sockets.s[vfds[i]].select_mark != 0) {
                        sockets.s[vfds[i]].select_active = 1;
                        sockets.s[vfds[i]].select_result = 0;
                        count++;
                }
                pthread_mutex_unlock(&(sockets.s[vfds[i]].mutex));
        }
        /* if none of the sockets are marked with conditions to test, return 0 */
        if (count == 0) {
                pthread_mutex_unlock(&(sockets.select_mutex));
                return 0;
        }
        /* set up the timeout var */
        timedwait_timeout.tv_sec = timeout->tv_sec;
        timedwait_timeout.tv_nsec = timeout->tv_usec * 1000;

        /* wait until a select_cond is signalled or we timeout */
        do {
                ret = pthread_cond_timedwait(&(sockets.select_cond), &(sockets.select_mutex), &(timedwait_timeout));
        } while (ret != 0 && ret != ETIMEDOUT);

        /* count the number of mutexes that are marked with some select result */
        count = 0;
        for (i = 0; i < len; i++) {
                pthread_mutex_lock(&(sockets.s[vfds[i]].mutex));
                if (sockets.s[vfds[i]].select_active == 1) {
                        if (sockets.s[vfds[i]].select_result != 0) {
                                count++;
                        }
                        sockets.s[vfds[i]].select_active = 0;
                }
                pthread_mutex_unlock(&(sockets.s[vfds[i]].mutex));
        }
        pthread_mutex_unlock(&(sockets.select_mutex));
        return count;
} /* vfer_select() */

/**
 * Controls debugging for the library.
 *
 * By specifying a debug file output, and an error file output as FILE
 * pointers, debug information can be outputted to specific
 * files. Printing is also controlled by a selection of logical levels
 * of the internal implementation (via character string wherein each
 * char encodes one level) needing debug output.
 *
 * @param debug_file output FILE pointer for debug messages
 * @param error_file output FILE pointer for error messages
 * @param layers a string containing chars specifying layers needing debugging output
 *      the char to component map is:
 *      - q : accept queue component
 *      - a : api component
 *      - c : control component
 *      - C : ccontrol component (congestion control)
 *      - p : packet component
 * @return
 *      0 on succes
 *      -1 on error
 */
int vfer_debug(FILE* debug_file, FILE* error_file, const char* layers) {
        int len;
        DEBUG_ACCEPTQ           = 0;
        DEBUG_API               = 0;
        DEBUG_CTL               = 0;
        DEBUG_PACKET            = 0;
        DEBUG_CCTL              = 0;
        DEBUG_PMTUD     = 0;

        if (layers == NULL) {
                len = 0;
        } else {
                len = strlen(layers);
        }
        while (len > 0) {
                switch (layers[len-1]) {
                case 'q':
                        DEBUG_ACCEPTQ = 1;
                        break;
                case 'a':
                        DEBUG_API = 1;
                        break;
                case 'c':
                        DEBUG_CTL = 1;
                        break;
                case 'C':
                        DEBUG_CCTL = 1;
                        break;
                case 'p':
                        DEBUG_PACKET = 1;
                        break;
                case 'P':
                        DEBUG_PMTUD = 1;
                        break;
                }
                len--;
        }
        debug_out = debug_file;
        error_out = error_file;
        /* signals to vfer_internal_init not to set the printing vars
         * as we've already set them per user's request */
        Debug_Initialized = 0;
        if (!PROTOCOL_INIT_TEST) return -1;
        return 0;
} /* vfer_debug() */

/**
 * Initializes all the data structures & component used by the
 * vfer protocol
 *
 * This function runs only once for every time we load the protocol
 * into a program. Note that this function is internal and should NOT
 * be used outside of the protocol's scope. It does NOT set any
 * socket's err field.
 *
 * @return
 *      0 on success
 *      -1 on error
 */
static int vfer_internal_init() {
        int i;
#ifdef TSCI2
        int tsci2_methods;
#endif
        if (Debug_Initialized == -1) {
                /* initialize all debug controlling vars to 0 (no printing) unless vfer_debug was called prior */
                debug_out = NULL;
                error_out = stdout;
                DEBUG_ACCEPTQ           = 0;
                DEBUG_API               = 0;
                DEBUG_CTL               = 0;
                DEBUG_CCTL              = 0;
                DEBUG_PACKET            = 0;
        }

        sockets.num_active = 0;
        sockets.max_fd = 0;
        FD_ZERO(&(sockets.fds));
        pthread_mutex_init(&(sockets.mutex), NULL);
        pthread_mutex_init (&(sockets.select_mutex), NULL);
        pthread_cond_init(&(sockets.select_cond), NULL);

        for (i = 0; i < MAX_SOCKETS; i++) {
                pthread_mutex_init (&(sockets.s[i].mutex), NULL);
                pthread_cond_init(&(sockets.s[i].cond), NULL);

                sockets.s[i].send_frames.first  = sockets.s[i].send_frames.last = NULL;
                sockets.s[i].recv_frames.first  = sockets.s[i].recv_frames.last = NULL;
                sockets.s[i].recvd_frames.first = sockets.s[i].recvd_frames.last        = NULL;
                sockets.s[i].send_frames.num            = 0;
                sockets.s[i].recv_frames.num            = 0;
                sockets.s[i].recvd_frames.num           = 0;
                sockets.s[i].recvd_frames.length        = 0;
                sockets.s[i].recv_frames.length         = 0;
                sockets.s[i].send_frames.length         = 0;
                pthread_mutex_init(&(sockets.s[i]).mutx_readable, NULL);
                pthread_cond_init(&(sockets.s[i]).cond_readable, NULL);
                sockets.s[i].state = CONN_DISCONNECTED;
        }

        /* initialize the TSCI2 library if we are compiled with it */
#ifdef TSCI2
        tsci2_methods = TSCI2_DAEMON | TSCI2_CLIENT | TSCI2_FALLBACK;
        tsci2_methods = tsci2_init(tsci2_methods);
        switch ( tsci2_methods )  {
        case TSCI2_DAEMON:
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_internal_init", "using method TSCI2_DAEMON for gettimeofday");
                break;
        case TSCI2_CLIENT:
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_internal_init", "using method TSCI2_CLIENT for gettimeofday");
                break;
        case TSCI2_FALLBACK:
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_internal_init", "using method TSCI2_FALLBACK for gettimeofday");
                break;
        default:
                DEBUG_PRINT(DEBUG_API, "api.c", "vfer_internal_init", "TSCI2 initialization failed");
        }
#endif

        /* rand gen init (rand() is used to gen random seq/frame numbers in packet.c) */
        srand(time(NULL));

        /* memory allocation var reset */
        ReqMem = 0;

        Initialized = 1;
        return 0;
} /* vfer_internal_init() */


/**
 * Returns the current name for the specified socket. The
 * \a namelen parameter should be initialized to indicate the amount of
 * space pointed to by name. On return it contains the actual size of
 * the name returned (in bytes).
 *
 * @param[in] vfd vfer socket identifier
 * @param[out] name pointer to name structure
 * @param[in] len length of the name structure
 * @return
 *      - 0 on success
 *      - VFER_BADSOCK bad vfd argument
 */
int vfer_getsockname (vfer_fd vfd, struct sockaddr *name, socklen_t* len) {
    if (!PROTOCOL_INIT_TEST || (vfd < 0) || (vfd > MAX_SOCKETS))
        return VFER_BADSOCK;

    vfer_sock* sock = &(sockets.s[vfd]);
    if (sock->err != 0)
        return VFER_BADSOCK;

    // \todo do proper error checking
    if (getsockname(sock->fd, name, len) != 0) {
        perror("getsockname failed");
        abort();
    }
    return 0;
}

/**
 * Returns \a true if the given socket is stream and not datagram based.
 *
 * \param[in] fd VFER FD to check
 * \return
 *  - \a true for a streamed connection
 *  - \a false for a datagram based connection
 *
 *  \todo Implement me properly
 **/
bool vfer_is_stream (vfer_fd fd) {
    return false;
}

/**
 * Returns \a the maximum size of a frame.
 *
 * \param[in] fd VFER FD to check
 * \return
 *  - the maximum frame size > 0 on success
 *
 *  \todo Implement me properly
 **/
ssize_t vfer_max_frame_size (vfer_fd fd) {
    return MAX_FRAME_SIZE;
}

---