src/vfer_datagram.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 *
 * @file   vfer_datagram.c
 * @author Ivan Beschastnikh
 * @brief  Implements datagrams that are defined in datagram.h
 *
 * -     02/19/06        ivan            added function Datagram_Insert_Phantom
 * -     02/18/06        ivan            created
 */

#include "vfer_datagram.h"
#include "vfer.h"

/**
 * Creates a new datagram entry, copies the buffer data into the entry
 * and enqueues the datagram into the datagram list.
 *
 * @param frames datagram list pointer
 * @param buffer buffer to include into this datagram (unchanged by this function)
 * @param len length of buffer
 * @param frame_num frame number to assign to this frame (used in control.c)
 *
 * @return -1 on error, if allocation of new datagram failed
 * @return 0 on succes
 */
inline int Datagram_Enqueue(frame_list* frames, const void* buffer, int len, int frame_num) {
        frame_link* frame_l;
        interval_t* interval_ptr;
        
        /* create a new frame structure and add it to the frame list passed as argument */
        if (ALLOC(frame_l,frame_link*,frame_link,1) == 0)
                return -1;
        if (ALLOC(frame_l->frame.data, void*, char, len) == 0) {
                RELEASE(frame_l, sizeof(frame_link));
                return -1;
        }
        if (ALLOC(interval_ptr, interval_t*, interval_t, 1) == 0) {
                RELEASE(frame_l->frame.data, sizeof(frame_link));
                RELEASE(frame_l, sizeof(frame_link));
                return -1;
        }

        if (frames->num == 0)
                frames->first = frame_l;
        if (frames->last != NULL)
                frames->last->next = frame_l;

        frames->last = frame_l;
        frames->num++;

        /* data copying */
        memcpy(frame_l->frame.data, buffer, len);
        frame_l->frame.len              = len;
        frame_l->frame.urgency          = -1;            /* implies this frame has not been attempted (to be sent) yet : used to send frame_len on first packets */
        frame_l->frame.frame_num        = frame_num;
        frame_l->next                   = NULL;

        frame_l->frame.missing_data.count = 1;
        frame_l->frame.missing_data.head = interval_ptr;
        interval_ptr->prev = interval_ptr->next = NULL;
        interval_ptr->start = 0;
        interval_ptr->end = len;
        
        frames->length += len; /* add size to total size of frame list */

//      DEBUG_PRINT(DEBUG_CTL, "datagram.c", "Datagram_Enqueue", "frame_id[%d] frame_len[%d] num_frags[%d] frag_size[%u]; num_frames[%d]", 
//                  frame_l->frame.frame_num, frame_l->frame.len, frame_l->frame.num_frags, frame_l->frame.frag_size, frames->num);

//      printf("new datagram list:\n");
//      Datagrams_Print(frames);
        return 0;
} /* Datagram_Enqueue() */


/**
 * Dequeues a frame from the frames list and fills in the buffer with
 * it's data. Returns -1 if the buffer is not large enough to hold the
 * frame's data.
 *
 * For now we assume that there are frames in the list (has to be
 * checked before the call)
 *
 * @param frames datagram list pointer
 * @param buffer buffer to fill with the datagram contents
 * @param len max length of buffer to fill
 * 
 * @return -1 on error, buffer is too small
 * @return size of the datagram written to buffer on success
 */
inline int Datagram_Dequeue(frame_list* frames, void* buffer, int len) {
        int size;
        frame_link* frame_l;
        frame_l = frames->first;

        DEBUG_PRINT(DEBUG_CTL, "datagram.c", "Datagram_Dequeue", "Returning frame[%d] with len[%d] with recvd->len[%d]", frame_l->frame.frame_num, frame_l->frame.len, frames->num);

        if (frame_l->frame.len > len) {
                return -1;
        }

        /* copy datagram into user supplied buffer */
        size = frame_l->frame.len;
        memcpy (buffer, frame_l->frame.data, size);
        frames->length -= size;

        /* remove this frame from the frame list & dealloc */
        Datagram_Remove (frames, NULL, frame_l);
        RELEASE(frame_l->frame.data, size);
        RELEASE(frame_l, sizeof(frame_link));
        return size;
} /* Datagram_Dequeue() */


/**
 * Remove a frame from a frame list
 *
 * Maintains the last_frame_num, first_frame_num, count, and data byte
 * length of frames in the frame list.
 *
 * @param list          frame list pointer to remove the frame from
 * @param prev          previous frame pointer
 * @param remove        the frame pointer to remove from the list
 */
inline void Datagram_Remove(frame_list* list, frame_link* prev, frame_link* remove) {
        if (prev == NULL) {             /* remove from the beginning of the list */
                if (remove != list->first) { /* double check that we are indeed removing first frame */
                        ERROR_PRINT("datagram.c", "Datagram_Remove", "removing from beginning of list but frame is not first");
                        return;
                }
                if (remove->next != NULL) {
                        list->first_frame_num = remove->next->frame.frame_num;
                        list->first = remove->next;
                } else {
                        list->first = list->last = NULL;
                }
        } else {
                prev->next = remove->next;
                if (list->last == remove) {
                        list->last_frame_num = prev->frame.frame_num;
                        list->last = prev;
                }
        }
        list->length -= remove->frame.len;
        list->num--;
} /* Datagram_Remove() */

/**
 * Inserts a frame into a frame list
 * 
 * Maintains the last_frame_num, first_frame_num, count, and the data
 * byte length of frames in the frame list.
 *
 * @param list          frame list pointer to insert the new frame link into
 * @param prev          frame link before the one to insert
 * @param insert        frame link to insert
 */
inline void Datagram_Insert(frame_list* list, frame_link* prev, frame_link* insert) {
        if (prev == NULL) {
                /* insert at beginning of list */
                insert->next = list->first;
                list->first = insert;
                if (list->last == NULL) {
                        list->last = insert;
                        list->last_frame_num = insert->frame.frame_num;;
                }
                list->first_frame_num = insert->frame.frame_num;
        } else {
                insert->next = prev->next;
                prev->next = insert;
                if (list->last == prev) {
                        list->last_frame_num = insert->frame.frame_num;
                        list->last = insert;
                }
        }
        list->length += insert->frame.len;
        list->num++;
} /* Datagram_Insert() */

/*
 * Inserts a phantom frame into a frame list
 * 
 * Maintains the last_frame_num, first_frame_num, count, and the data
 * byte length of frames in the frame list.
 *
 * @param list          frame list pointer to insert the new frame link into
 * @param prev          frame link before the one to insert
 * @param insert        frame link to insert
 *
 * @return NULL on error
 * @return frame_link pointer that was inserted into the frame list
 */
inline frame_link* Datagram_Insert_Phantom(frame_list* list, frame_link* prev, int frame_num) {
        frame_link* insert;
        if (ALLOC(insert,frame_link*,frame_link,1) == 0) return NULL;
        insert->frame.len               = 0;
        insert->frame.frame_num         = frame_num;
        insert->frame.urgency           = -1; /* this will generate a nack_vec on this turn */
        insert->frame.done              = 0;
        insert->frame.missing_data.head = NULL;
        insert->frame.missing_data.count= 0;
        Datagram_Insert(list, prev, insert);
        return insert;
} /* Datagram_Insert_Phantom() */


/**
 * Useful internal function to print a frame_list to stdout
 *
 * @param list frame list
 */
void Datagrams_Print(frame_list* list) {
        frame_link* frame_l;
        printf("--------------- len[%d]: \n", list->num);
        if (list->first != NULL) {
                printf("[first] : [%d] %d\n", list->first->frame.frame_num, list->first->frame.len);
        }

        frame_l = list->first;
        while (frame_l != NULL) {
                printf("[%d] : %d\n", frame_l->frame.frame_num, frame_l->frame.len);
                frame_l = frame_l->next;
        }
        if (list->last != NULL) {
                printf("[last] : [%d] %d\n", list->last->frame.frame_num, list->last->frame.len);
                }
        printf("---------------\n");
} /* Datagrams_Print() */


/**
 * Clears out the datagrams from the frame list
 *
 * @param list frame list
 */
inline void Datagrams_Clear(frame_list* list) {
        frame_link* frame_l;
        frame_link* frame_l2;

        /* free up all the allocated send frames */
        frame_l = list->first;
        while (frame_l != NULL) {
                frame_l2 = frame_l;
                frame_l = frame_l->next;
                RELEASE(frame_l2->frame.data, frame_l2->frame.len);
                RELEASE(frame_l2, sizeof(frame_link));
        }
} /* Datagrams_Clear */

---