src/vfer_accept_queue.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 * @file   vfer_accept_queue.c
 * @author Ivan Beschastnikh
 * @brief  Implements an accept queue to hold to be accepted connections from
 * remote clients.
 *
 * The queue size is determine by the backlog argument
 * to Accept_Queue_Create. The queue wraps around upon reaching the
 * end, so that older connection requests are overwritten if they are
 * not taken off the queue in time.  note that the top pointer in the
 * Accept_Queue structure always points to the oldest connection
 * request record in the queue. Once the next_free pointer wraps
 * around to bump against the top of the queue, the top of the queue
 * moves up by one (thus loosing the oldest connection request)
 *
 * Implemented with blocking in mind, the Dequeue function
 * blocks if the queue is empty and wakes up when something
 * appears in the queue
 *
 * -    05/14/06        ivan            removed locks since accept_queue access is restricted to a single thread (ControlT thread)
 * -    09/01/05        ivan            modified to use new packet structures
 * -    07/02/05        ivan            rewritten to support I2 api
 * -    05/26/05        ivan            created
 */

#include "vfer_accept_queue.h"

/* static void  Accept_Queue_Print      (accept_queue* ac); */

/**
 * Creates the accept queue structure and initializes the data members.
 *
 * @param backlog the max number of connection to queue in this queue. backlog > 0
 *        right now there is no limit on the size of the backlog
 * @return
 *      pointer to an new accept_queue with backlog max depth on succes
 *      NULL on error
 */
accept_queue* Accept_Queue_Create (int backlog) {
        accept_queue* ac;
        
        DEBUG_PRINT(DEBUG_ACCEPTQ, "accept_queue.c", "Accept_Queue_Create", "Entered with backlog[%d]", backlog);

        if (backlog <= 0) return NULL;
        if (! ALLOC(ac, accept_queue*, accept_queue, 1)) return NULL;
        
        ac->count = 0;
        ac->backlog = backlog;
        ac->first = NULL;
        ac->last = NULL;
        return ac;
}

/**
 * Deletes the accept queue structure.
 *
 * @param ac accept_queue pointer
 */
void Accept_Queue_Delete (accept_queue* ac) {
        queued_conn *c1, *c2;
        DEBUG_PRINT(DEBUG_ACCEPTQ, "accept_queue.c", "Accept_Queue_Delete", "Entered");
        /* go through and release all the elements in the accept queue */
        c1 = ac->first;
        while (c1 != NULL) {
                c2 = c1->next;
                RELEASE_PACK(c1->request);
                RELEASE(c1, sizeof(queued_conn));
                c1 = c2;
        }
        RELEASE (ac, sizeof(accept_queue));
}

/**
 * Adds a queued connection to a queue.
 *
 * If the queue is full, then we merely wrap around and overwrite old
 * connections
 *
 * @param ac accept_queue pointer to which we are trying to enqueue the connection
 * @param fd the file descriptor of the open connection
 * @param sa the socke address strucutre describing the remote connection
 * @param request request packet associated with the new connection
 * @return
 *      0 on succes
 *      -1 on error
 */
int Accept_Queue_Enqueue (accept_queue* ac, int fd, struct sockaddr sa, packet* request) 
{
        queued_conn* qc;
        queued_conn* tmp;

        DEBUG_PRINT(DEBUG_ACCEPTQ, "accept_queue.c", "Accept_Queue_Enqueue", "Enqueueing new connection fd[%d] into accept queue with size[%d]", fd, ac->count);
        
        /* this socket doesn't queue any connections */
        if (ac->backlog == 0) {
                DEBUG_PRINT(DEBUG_ACCEPTQ, "accept_queue.c", "Accept_Queue_Enqueue", "Backlog=0 ; dropping conn fd[%d]", fd);
                return 0;
        }
        
        if (! ALLOC(qc, queued_conn*, queued_conn, 1)) {
                return -1;
        }
        
        qc->next        = ac->first;
        qc->prev        = NULL;
        qc->fd          = fd;
        qc->sa          = sa;
        qc->request     = request;

        if (ac->count == ac->backlog) { 
                /* shift the whole list to the right */
                if (ac->last == ac->first) {
                        /* i.e. ac->backlog == 1 ; note that we don't
                         * allow a backlog of 0.*/
                        if (ac->first != NULL) {
                                RELEASE_PACK(ac->last->request);
                                RELEASE(ac->last, sizeof(struct queued_conn));
                        }
                        ac->first = ac->last = qc;
                } else {
                        tmp = ac->last->prev;
                        RELEASE_PACK(ac->last->request);
                        RELEASE(ac->last, sizeof(struct queued_conn));
                        ac->last = tmp;
                        ac->last->next = NULL;
                        ac->first->prev = qc;
                        ac->first = qc;
                }
        } else {
                /* add to back of queue (pointed to by ac->first) */
                if (ac->count == 0)
                        ac->last = qc;
                else
                        ac->first->prev = qc;

                ac->first = qc;
                ac->count++;
        }
        DEBUG_PRINT(DEBUG_ACCEPTQ, "accept_queue.c", "Accept_Queue_Enqueue", "New accept queue size[%d]", ac->count);
        return 0;
} /* Accept_Queue_Enqueue() */


/**
 * Removes and returns a queued connection from the front of the queue.
 *
 * This function does not block.
 *
 * @param ac accept queue pointer from which we dequeu
 * @return
 *      queued connection structure on success (if not empty queue)
 *      NULL on error (empty queue or otherwise)
 */
queued_conn* Accept_Queue_Dequeue (accept_queue* ac) {
        queued_conn* saved_top;
        
        DEBUG_PRINT(DEBUG_ACCEPTQ, "accept_queue.c", "Accept_Queue_Dequeue", "Entered with accept queue size[%d]", ac->count);
        if (ac->count == 0) {
                return NULL;
        }

        saved_top = ac->last;

        if (ac->count == 1) {
                ac->last = ac->first = NULL;
        } else {
                ac->last = ac->last->prev;
        }
        ac->count--;
        return saved_top;
} /* Accept_Queue_Dequeue() */

/**
 * Prints the accept queue forward and back. Useful as an internal
 * debugging tool.
 *
 * @param
 *      ac is an accept queue pointer
 */
/* static void Accept_Queue_Print(accept_queue* ac) {
        queued_conn* qc;
        int i;

        qc = ac->first;
        i = 0;
        printf("FORWARD: \n");
        while (qc != NULL) {
                printf("[%d] : %d\n", i, qc->fd);
                i++;
                qc = qc->next;
        }

        qc = ac->last;
        i = 0;
        printf("BACK: \n");
        while (qc != NULL) {
                printf("[%d] : %d\n", i, qc->fd);
                i++;
                qc = qc->prev;
        }

        return;
} */ /* Accept_Queue_Print() */

---