src/vfer_packet.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 * @file   vfer_packet.c
 * @author Ivan Beschastnikh
 * @brief  Implements packetizing and depacketizing functions.
 *
 * This file contains usefull functions to compose and decompose
 * packets. It also includes some handy utilities for printing packets
 * out to stdout.
 *
 * -     07/26/06        ivan            removed vector ack packet type
 * -     12/28/05        ivan            tsci2 integration ; Packet_Set_Header return value bug fix ; packet delay computing func coded
 * -     10/16/05        ivan            added Packet_Seq_Set function
 * -     10/15/05        ivan            bugfix of rand gen functions and byte ordering functions
 * -     09/01/05        ivan            modified to use new packet structures ; coded packet printing functions
 * -     08/30/05        ivan            use uint32_t for opts instead of char[3] ; added option interpretation and setting support ; added packet structs
 * -     08/29/05        ivan            changed Packet_Read to take and set by ref an error argument
 * -     08/28/05        ivan            added many new functions to do packet reading,writing,validation, seq and frame num generation
 * -     07/15/05        ivan            new api packet print and form functions added
 * -     05/18/05        ivan            created
 */

#include "vfer_packet.h"

/* private function prototypes */
/* helpers */
static inline int Packet_Set_Header     (packet* p, unsigned char type, uint32_t opts, uint32_t seq);
static inline void Packet_Get_Header    (packet* p); 
static inline void Packet_Get_Type      (char* buf, unsigned char* type);
static inline void Packet_Get_Version   (char* buf, unsigned char* version);
static inline void Packet_Compute_Delay (char* pack_buf, struct timeval* tv, packet* p);
static inline packet* Packet_PrepIov    (int num_bufs, int first_buf_len);

/* option helper functions */
static inline int Packet_Get_Opt        (uint32_t opts, int opt);
static inline void Packet_Set_Opt       (uint32_t* opts, int opt);
static inline void Packet_Unset_Opt     (uint32_t* opts, int opt);

/****************************************************************
 * PRINTING FUNCTIONS
 ****************************************************************/

/**
 * String type of packet
 * @param p packet pointer
 * @return 
 *      string describing the type of the packet parameter
 */
char* Packet_Str_Type(packet* p) {
        switch (p->type) {
        case REQUEST:
                return "REQUEST";
        case RESPONSE:
                return "RESPONSE";
        case DATA:
                return "DATA";
        case CC_ACK:
                return "CC_ACK";
        case CLOSE:
                return "CLOSE";
        default:
                return "UNKNOWN";
        }
} /* Packet_Str_Type() */

/**
 * Create a string description of the packet
 * @param p packet pointer
 * @return string describing the packet parameter
 */
char* Packet_Str(packet* p) {
        char* str;
        str = (char*)malloc(1024);      /* 1024 should be enough... */

        sprintf(str, "%u %s [%d us] opt[%u] v[%u] ", p->seq, Packet_Str_Type(p), p->delay, p->opts, p->version);
        switch (p->type) {
        case REQUEST:
                sprintf(str + strlen(str), "max_frame_len[%u] rcv_buf[%u] snd_buf[%u] init_frame[%u]",
                        p->u.req.max_frame_size, p->u.req.recv_buf_size, p->u.req.send_buf_size, p->u.req.init_frame_num);
                break;
        case RESPONSE:
                sprintf(str + strlen(str), "max_frame_len[%u] rcv_buf[%u] snd_buf[%u] init_frame[%u] port[%u] req_delay[%d]",
                        p->u.res.max_frame_size, p->u.res.recv_buf_size, p->u.res.send_buf_size, p->u.res.init_frame_num, p->u.res.connection_port, p->u.res.request_delay); 
                break;
        case DATA:
                sprintf(str + strlen(str), "frame[%u] data_offset[%u] frame_len[%u] data_len[%u]",
                        p->u.data.frame_num, p->u.data.data_offset, p->u.data.frame_len, p->u.data.data_len);
                break;
        case CC_ACK:
                sprintf(str + strlen(str), "last_seq[%u] lost[%u] oldest_f[%u] newest_f[%u] dlay_dlta[%d] dlay[%d] bytes[%d]", p->u.ccack.last_seq, p->u.ccack.packets_lost, p->u.ccack.oldest_frame, p->u.ccack.newest_frame, p->u.ccack.delay_delta, p->u.ccack.delay, p->u.ccack.bytes_total);
                if (Packet_Get_Opt(p->opts, OPT_VEC)) {
                        sprintf(str + strlen(str), " intervals_frame[%u] num_intervals[%d]", p->u.ccack.intervals_frame_num, p->u.ccack.interval_count);
                }
                break;
        }
        return str;
} /* Packet_Str() */

/**
 * Prints a description of the packet onto stdout
 * @param p packet pointer
 */
void Packet_Print (packet* p) {
        char* str;
        str = Packet_Str(p);
        printf("%s", str);
        free(str);
} /* Packet_Print() */
        
/****************************************************************
 * FORMATION FUNCTIONS (return a void* buffer network byte ordered and
 * ready for transmission ; and sets a reference param to length of
 * the buffer)
 ****************************************************************/

/**
 * Forms a Request packet
 *
 * @param opts          options for the generic header of the packet
 * @param init_seq_num  initial sequence number for the sender's half of connection
 * @param max_frame_size maximum frame size the sender is willing to receive
 * @param recv_buf_size receive buffer size at the sender
 * @param send_buf_size sending buffer size at the sender
 * @param init_frame_num initial frame number for the sender's half of connection
 *
 * @return 
 *      NULL on error
 *      pointer to an allocated packet on success
 */
packet* Packet_Form_Request(uint32_t opts, uint32_t init_seq_num,
                            uint32_t max_frame_size, uint32_t recv_buf_size,
                            uint32_t send_buf_size, uint16_t init_frame_num) {
        char* buf;
        int offset;
        packet* p;

        if ((p = Packet_PrepIov(1, REQUEST_LENGTH)) == NULL) return NULL;

        buf = p->iov[0].iov_base;
        offset = Packet_Set_Header(p, REQUEST, opts, init_seq_num);
        
        p->u.req.max_frame_size = max_frame_size;
        max_frame_size = htonl(max_frame_size);
        memcpy(buf + offset, &max_frame_size, 4);
        
        p->u.req.recv_buf_size = recv_buf_size;
        recv_buf_size = htonl(recv_buf_size);
        memcpy(buf + offset + 4, &recv_buf_size, 4);

        p->u.req.send_buf_size = send_buf_size;
        send_buf_size = htonl(send_buf_size);
        memcpy(buf + offset + 8, &send_buf_size, 4);

        p->u.req.init_frame_num = init_frame_num;
        init_frame_num = htons(init_frame_num);
        memcpy(buf + offset + 12, &init_frame_num, 2);

        return p;
} /* Packet_Form_Request() */


/**
 * Forms a Response packet
 *
 * @param opts          options for the generic header of the packet
 * @param init_seq_num  initial sequence number for the sender's half of connection
 * @param init_frame_num initial frame number for the sender's half of connection
 * @param connection_port the connection port to which the sender
 *                        should connect and use for the remained of this connection
 * @param max_frame_size maximum frame size the sender is willing to receive
 * @param recv_buf_size receive buffer size at the sender
 * @param send_buf_size sending buffer size at the sender
 * @param request_delay the delay computed for the request packet
 *
 * @return 
 *      NULL on error
 *      pointer to an allocated packet on success
 */
packet* Packet_Form_Response(uint32_t opts, uint32_t init_seq_num, uint16_t init_frame_num,
                           uint16_t connection_port, uint32_t max_frame_size,
                           uint32_t recv_buf_size, uint32_t send_buf_size, int32_t request_delay) {
        char* buf;
        int offset;
        packet* p;

        if ((p = Packet_PrepIov(1, RESPONSE_LENGTH)) == NULL) return NULL;

        buf = p->iov[0].iov_base;
        offset = Packet_Set_Header(p, RESPONSE, opts, init_seq_num);
        
        p->u.res.init_frame_num = init_frame_num;
        init_frame_num = htons(init_frame_num);
        memcpy(buf + offset, &init_frame_num, 2);

        p->u.res.connection_port = connection_port;
        connection_port = htons(connection_port);
        memcpy(buf + offset + 2, &connection_port, 2);

        p->u.res.max_frame_size = max_frame_size;
        max_frame_size = htonl(max_frame_size);
        memcpy(buf + offset + 4, &max_frame_size, 4);

        p->u.res.recv_buf_size = recv_buf_size;
        recv_buf_size = htonl(recv_buf_size);
        memcpy(buf + offset + 8, &recv_buf_size, 4);

        p->u.res.send_buf_size = send_buf_size;
        send_buf_size = htonl(send_buf_size);
        memcpy(buf + offset + 12, &send_buf_size, 4);

        p->u.res.request_delay = request_delay;
        request_delay = htonl(request_delay);
        memcpy(buf + offset + 16, &request_delay, 4);

        return p;
} /* Packet_Form_Response() */


/**
 * Forms a Data packet
 *
 * @param opts          options for the generic header of the packet
 * @param seq_num       sequence number for the generic header of the packet
 * @param frame_num     frame number this data packet carries a frag for
 * @param data_offset   offset of the data in the frame
 * @param frame_len     either -1 (do not include in the data header)
 *                      (opts will be set and send accordingly) or is not -1,
 *                      in which case it is included in the data header
 * @param data          data buffer to send in the body of the data packet
 * @param data_len      tells us how the span of the data buffer pointed to by the data arg
 *
 * @return 
 *      NULL on error
 *      pointer to an allocated packet on success
 */
packet* Packet_Form_Data(uint32_t opts, uint32_t seq_num, uint16_t frame_num,
                         uint32_t data_offset, uint32_t frame_len, void* data, int data_len) {
        char* buf;
        int offset;
        packet* p;

        if (frame_len != -1) {
                if ((p = Packet_PrepIov(2, DATA_LENGTH)) == NULL) return NULL;
                Packet_Set_Opt(&opts, OPT_FRAME_LEN);
        } else {
                if ((p = Packet_PrepIov(2, DATA_LENGTH)) == NULL) return NULL;
                Packet_Unset_Opt(&opts, OPT_FRAME_LEN);
        }
        buf = p->iov[0].iov_base;
        offset = Packet_Set_Header(p, DATA, opts, seq_num);
        
        p->u.data.frame_num = frame_num;
        frame_num = htons(frame_num);
        memcpy(buf + offset, &frame_num, 2);
        offset += 2;
        
        p->u.data.data_offset = data_offset;
        data_offset = htonl(data_offset);
        memcpy(buf + offset, &data_offset, 4);
        offset += 4;
        
        if (frame_len != -1) {
                p->u.data.frame_len = frame_len;
                frame_len = htonl(frame_len);
                memcpy(buf + offset, &frame_len, 4);
                offset += 4;
        } else {
                offset += 4; /* just skip the space for now */
        }
        
        p->u.data.data          = data;
        p->u.data.data_len      = data_len;
        /* no data copying here */
        p->iov[1].iov_base      = data;
        p->iov[1].iov_len       = data_len;

        DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Form_Data", "iov[0]: %d ; iov[1]: %d ; frame_len[%u]", (int)(p->iov[0].iov_len), (int)(p->iov[1].iov_len), ntohl(frame_len)); 
        return p;
} /* Packet_Form_Data() */

/**
 * Forms a CC Ack packet
 *
 * @param opts          options for the generic header of the packet
 * @param seq_num       sequence number for the generic header of the packet
 * @param last_seq_received     last sequence number received by this connection
 * @param packets_lost  estimated lost number of frags
 * @param oldest_frame  oldest frame the received of this packet should resend
 * @param newest_frame  oldest frame the received of this packet should resend
 * @param delay_delta   current delay on the reverse path (not the path of this ack)
 * @param delay         current delay for the reverse path
 * @param bytes_total   total data bytes received by the endpoint
 * @param intervals_frame_num   the frame number corresponding to the missing data intervals
 * @param intervals     intervals structure (defined in datagram.h) If intervals->head == 0 then no intervals will be sent in the ack packet
 *
 * @return 
 *      NULL on error
 *      pointer to an allocated packet on success
 */
packet* Packet_Form_CCAck(uint32_t opts, uint32_t seq_num, uint32_t last_seq_received,
                          uint16_t packets_lost, uint16_t oldest_frame, uint16_t newest_frame,
                          int32_t delay_delta, int32_t delay, uint32_t bytes_total,
                          uint16_t intervals_frame_num, intervals_t* intervals) {
        char* buf;
        int offset;
        packet* p;
        interval_t* current;
        uint32_t tmp;

        if (intervals != NULL) {
//              printf("setting OPT_VEC\n");
                if (intervals->head != NULL) {
//                      printf("intervals->head != NULL ; setting up iov buffer[%d]\n", CCACK_LENGTH + 8*intervals->count + 6);
                        // 4*(2*intervals->count)+2+4
                        // 52 = 8 + 6 = 14 + 38 (ccack_length)
                        if ((p = Packet_PrepIov(1, CCACK_LENGTH + 8*intervals->count + 6)) == NULL) return NULL;
                } else {
//                      printf("intervals->head == NULL ; setting up iov buffer[%d]\n", CCACK_LENGTH + 14);
                        // 4*(2)+2+4
                        if ((p = Packet_PrepIov(1, CCACK_LENGTH + 14)) == NULL) return NULL;
                }
                Packet_Set_Opt(&opts, OPT_VEC);
        } else { 
                if ((p = Packet_PrepIov(1, CCACK_LENGTH)) == NULL) return NULL;
        }
        buf = p->iov[0].iov_base;
        
        offset = Packet_Set_Header(p, CC_ACK, opts, seq_num);
        
        p->u.ccack.last_seq = last_seq_received;
        last_seq_received = htonl(last_seq_received);
        memcpy(buf + offset, &last_seq_received, 4);

        p->u.ccack.packets_lost = packets_lost;
        packets_lost = htons(packets_lost);
        memcpy(buf + offset + 4, &packets_lost, 2);

        p->u.ccack.oldest_frame = oldest_frame;
        oldest_frame = htons(oldest_frame);
        memcpy(buf + offset + 6, &oldest_frame, 2);
        
        p->u.ccack.newest_frame = newest_frame;
        newest_frame = htons(newest_frame);
        memcpy(buf + offset + 8, &newest_frame, 2);

        p->u.ccack.delay_delta = delay_delta;
        delay_delta = htonl(delay_delta);
        memcpy(buf + offset + 10, &delay_delta, 4);

        p->u.ccack.delay = delay;
        delay = htonl(delay);
        memcpy(buf + offset + 14, &delay, 4);

//      printf("** sending delay [%d]\n", p->u.ccack.delay);
        
        p->u.ccack.bytes_total = bytes_total;
        bytes_total = htonl(bytes_total);
        memcpy(buf + offset + 18, &bytes_total, 4);
        
        if (intervals != NULL) {
//              printf("sending intervals_frame_num[%d] ", intervals_frame_num);
                if (intervals->head != NULL) {
                        //printf(" interval_count[%d]\n", intervals->count);
                        p->u.ccack.interval_count = intervals->count;
                        p->u.ccack.intervals_frame_num = intervals_frame_num;
                        intervals_frame_num = htons(intervals_frame_num);
                        memcpy(buf + offset + 22, &intervals_frame_num, 2);
                        
                        tmp = htonl(intervals->count);
                        memcpy(buf + offset + 24, &tmp, 4);
                        offset += 28;
                        
                        current = intervals->head;
                        //printf("ccack intervals: ");
                        while (current != NULL) {
                                //printf("writing to offset[%d]\n", offset);
                                tmp = htonl(current->start);
                                memcpy(buf + offset, &tmp, 4);
                                tmp = htonl(current->end);
                                //printf("writing to offset+4[%d]\n", offset+4);
                                memcpy(buf + offset + 4, &tmp, 4);
                                offset += 8;
                                // printf("[%d %d] ", current->start, current->end);
                                current = current->next;
                        } 
                        // printf("\n"); 
                } else {
                        // printf(" interval_count[0!]\n");
                        p->u.ccack.interval_count = 0;
                        p->u.ccack.intervals_frame_num = intervals_frame_num;
                        intervals_frame_num = htons(intervals_frame_num);
                        memcpy(buf + offset + 22, &intervals_frame_num, 2);
                        tmp = htonl(1);
                        memcpy(buf + offset + 24, &tmp, 4);
                        tmp = 0;
                        memcpy(buf + offset + 28, &tmp, 4);
                        memcpy(buf + offset + 32, &tmp, 4);
                }
        }
        return p;
} /* Packet_Form_CCAck() */

/**
 * Forms a Close packet
 *
 * @param opts          options for the generic header of the packet
 * @param seq_num       sequence number for the generic header of the packet
 *
 * @return 
 *      NULL on error
 *      pointer to an allocated packet on success
 */
packet* Packet_Form_Close(uint32_t opts, uint32_t seq_num) {
        packet* p;
        if ((p = Packet_PrepIov(1, CLOSE_LENGTH)) == NULL) return NULL;
        Packet_Set_Header(p, CLOSE, opts, seq_num);
        return p;
} /* Packet_Form_Close() */

/****************************************************************
 * TRANSLATION FUNCTIONS (translate a void* buf of correct length into
 * references passed as args)
 ****************************************************************/

/**
 * Fills in the request union memeber with values from a raw packet
 *
 * @param p packet pointer to traslate
 * @return
 *      0 on success
 *      -1 packet with incorrect length
 */
int Packet_Translate_Request(packet* p) {
        char* buf = p->iov[0].iov_base;
        int offset = TOPH_LENGTH;
        
        if (p->iov[0].iov_len != REQUEST_LENGTH) return -1;
        Packet_Get_Header(p);
        
        memcpy(&(p->u.req.max_frame_size), buf + offset, 4);
        p->u.req.max_frame_size = ntohl(p->u.req.max_frame_size);

        memcpy(&(p->u.req.recv_buf_size), buf + offset + 4, 4);
        p->u.req.recv_buf_size = ntohl(p->u.req.recv_buf_size);

        memcpy(&(p->u.req.send_buf_size), buf + offset + 8, 4);
        p->u.req.send_buf_size = ntohl(p->u.req.send_buf_size);

        memcpy(&(p->u.req.init_frame_num), buf + offset + 12, 2);
        p->u.req.init_frame_num = ntohs(p->u.req.init_frame_num);
        return 0;
} /* Packet_Translate_Request() */

/**
 * Fills in the response union memeber with values from a raw packet
 *
 * @param p packet pointer to traslate
 * @return
 *      0 on success
 *      -1 packet with incorrect length
 */
int Packet_Translate_Response(packet* p) {
        char* buf = p->iov[0].iov_base;
        int offset = TOPH_LENGTH;
        
        if (p->iov[0].iov_len != RESPONSE_LENGTH) return -1;
        Packet_Get_Header(p);

        memcpy(&(p->u.res.init_frame_num), buf + offset, 2);
        p->u.res.init_frame_num = ntohs(p->u.res.init_frame_num);

        memcpy(&(p->u.res.connection_port), buf + offset + 2, 2);
        p->u.res.connection_port = ntohs(p->u.res.connection_port);

        memcpy(&(p->u.res.max_frame_size), buf + offset + 4, 4);
        p->u.res.max_frame_size = ntohl(p->u.res.max_frame_size);

        memcpy(&(p->u.res.recv_buf_size), buf + offset + 8, 4);
        p->u.res.recv_buf_size = ntohl(p->u.res.recv_buf_size);

        memcpy(&(p->u.res.send_buf_size), buf + offset + 12, 4);
        p->u.res.send_buf_size = ntohl(p->u.res.send_buf_size);

        memcpy(&(p->u.res.request_delay), buf + offset + 16, 4);
        p->u.res.request_delay = ntohl(p->u.res.request_delay);
        
        return 0;
} /* Packet_Translate_Response() */

/**
 * Fills in the data union memeber with values from a raw packet
 *
 * @param p packet pointer to traslate
 * @return
 *      0 on success
 *      -1 packet with incorrect length
 */
int Packet_Translate_Data(packet* p) {
        char* buf = p->iov[0].iov_base;
        int offset = TOPH_LENGTH;
        
        if (p->iov[0].iov_len < DATA_LENGTH) return -1;
        Packet_Get_Header(p);

        memcpy(&(p->u.data.frame_num), buf + offset, 2);
        p->u.data.frame_num = ntohs(p->u.data.frame_num);
        offset += 2;
        
        memcpy(&(p->u.data.data_offset), buf + offset, 4);
        p->u.data.data_offset = ntohl(p->u.data.data_offset);
        offset += 4;
        
        /* evaluate opts to see if the option for frame_len is set or not */
        if (Packet_Get_Opt(p->opts, OPT_FRAME_LEN) == 1) {
                memcpy(&(p->u.data.frame_len), buf + offset, 4);
                p->u.data.frame_len = ntohl(p->u.data.frame_len);
                offset += 4;
        } else {
                p->u.data.frame_len = 0;
                offset += 4; /* just skip the space for now */
        }

        /* data_len should depend on whether this packet is carrying
         * the frame_len field */
        p->u.data.data_len = p->iov[0].iov_len - offset;
        p->u.data.data = buf + offset;
        DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Translate_Data", "len[%d] ; offset[%d] ; data_len[%u]\n", (int)(p->iov[0].iov_len), offset, (int)(p->u.data.data_len));
        return 0;
} /* Packet_Translate_Data() */

/**
 * Fills in the cc_ack union memeber with values from a raw packet
 *
 * @param p packet pointer to traslate
 * @return
 *      0 on success
 *      -1 packet with incorrect length
 */
int Packet_Translate_CCAck(packet* p) {
        char* buf = p->iov[0].iov_base;
        int offset = TOPH_LENGTH;
        
        if (p->iov[0].iov_len < CCACK_LENGTH) return -1;
        Packet_Get_Header(p);

        memcpy(&(p->u.ccack.last_seq), buf + offset, 4);
        p->u.ccack.last_seq = ntohl(p->u.ccack.last_seq);

        memcpy(&(p->u.ccack.packets_lost), buf + offset + 4, 2);
        p->u.ccack.packets_lost = ntohs(p->u.ccack.packets_lost);
        
        memcpy(&(p->u.ccack.oldest_frame), buf + offset + 6, 2);
        p->u.ccack.oldest_frame = ntohs(p->u.ccack.oldest_frame);

        memcpy(&(p->u.ccack.newest_frame), buf + offset + 8, 2);
        p->u.ccack.newest_frame = ntohs(p->u.ccack.newest_frame);

        memcpy(&(p->u.ccack.delay_delta), buf + offset + 10, 4);
        p->u.ccack.delay_delta = ntohl(p->u.ccack.delay_delta);

        memcpy(&(p->u.ccack.delay), buf + offset + 14, 4);
        p->u.ccack.delay = ntohl(p->u.ccack.delay);

//      printf("** received delay [%d]\n", p->u.ccack.delay);

        memcpy(&(p->u.ccack.bytes_total), buf + offset + 18, 4);
        p->u.ccack.bytes_total = ntohl(p->u.ccack.bytes_total);
        
        if (Packet_Get_Opt(p->opts, OPT_VEC)) {
//              printf("OPT_VEC is set\n");
                memcpy(&(p->u.ccack.intervals_frame_num), buf + offset + 22, 2);
                p->u.ccack.intervals_frame_num = ntohs(p->u.ccack.intervals_frame_num);
                
                memcpy(&(p->u.ccack.interval_count), buf + offset + 24, 4);
                p->u.ccack.interval_count = ntohl(p->u.ccack.interval_count);

                // printf("received intervals_frame_num[%d] and interval_count[%d]\n",
                //p->u.ccack.intervals_frame_num, p->u.ccack.interval_count);
                
                p->u.ccack.raw_intervals = (uint32_t*)(buf + offset + 28);
        } else {
                p->u.ccack.intervals_frame_num = 0;
                p->u.ccack.interval_count = 0;
                p->u.ccack.raw_intervals = NULL;
        } 
        return 0;
} /* Packet_Translate_CCAck() */

/**
 * Fills in the close union memeber with values from a raw packet
 *
 * @param p packet pointer to traslate
 * @return
 *      0 on success
 *      -1 packet with incorrect length
 */
int Packet_Translate_Close(packet* p) {
        if (p->iov[0].iov_len != CLOSE_LENGTH) return -1;
        Packet_Get_Header(p);
        return 0;
} /* Packet_Translate_Close() */

/****************************************************************
 * Helper functions
 ****************************************************************/

/**
 * Sets the sequence number in the packet header
 *
 * @param p pointer to the packet in which to set the header
 * @param seq sequence number to set in the header
 */

inline void Packet_Set_Seq(packet* p, uint32_t seq) {
        char* buf = p->iov[0].iov_base;
        /* seq */
        p->seq = seq;
        seq = htonl(seq);
        memcpy(buf + 4, &(seq), 4);
}

/**
 * Sets the packet header into a packet buffer
 *
 * @param p pointer to the packet in which to set the header
 * @param type type of packet
 * @param opts opts to store in packet
 * @param seq sequence number to set in packet
 *
 * @return
 *      number of bytes of buf that are used by the header
 */
static inline int Packet_Set_Header(packet* p, unsigned char type, uint32_t opts, uint32_t seq) {
        /* type[s] + VFER_VERSION (global vars defined in globals.h) */
        char* buf = p->iov[0].iov_base;

        p->type = type;
        p->version = VFER_VERSION;
        p->opts = opts;
//      printf("SET_HEADER0: opts: %x\n", p->opts);
        opts = opts | ((0xF0000000 & (p->type << 24)) | (0x0F000000 & (p->version << 24)));
//      printf("SET_HEDAER1: opts: %x\n", p->opts);
        /* opts */
        opts = htonl(opts);
        memcpy(buf, &(opts), 4);
        /* seq */
        Packet_Set_Seq(p, seq);
        return TOPH_LENGTH;
} /* Packet_Set_Header() */

/**
 * Gets the packet header from a packet buffer and writes into the packet structure
 * @param p pointer to the packet in which get and get the header
 */
static inline void Packet_Get_Header(packet* p) {
        uint32_t tmp;
        char* buf = p->iov[0].iov_base;
        
        /* type + version */
        Packet_Get_Type(buf, &(p->type));
        Packet_Get_Version(buf, &(p->version));

        /* opts */
        memcpy(&(tmp), buf, 4);
        ((char*)(&tmp))[0] = 0; /* because network byte order is big endian, otherwise it would be [3]=0 */
        tmp = ntohl(tmp);
        p->opts = 0;
        memcpy(&(p->opts), &tmp, 4);
        
        /* seq */
        memcpy(&(p->seq), buf + 4, 4);
        p->seq = ntohl(p->seq);
        
} /* Packet_Get_Header() */

/**
 * Extracts the type in a bufer interpreted as packet header
 *
 * @param buf packet buffer
 * @param type reference arg type of packet
 */
static inline void Packet_Get_Type(char* buf, unsigned char* type) {
        /* type */
        uint32_t tmp;
        memcpy(&(tmp), buf, 4);
        tmp = ntohl(tmp);
        *type   = (tmp & 0xF0000000) >> 24;
} /* Packet_Get_Type() */

/**
 * Extracts the version in a buffer interpreted as packet header
 *
 * @param buf packet buffer
 * @param version reference argument into which the version will be stored
 */
static inline void Packet_Get_Version(char* buf, unsigned char* version) {
        /* version */
        uint32_t tmp;
        memcpy(&(tmp), buf, 4);
        tmp = ntohl(tmp);
        *version = (tmp & 0x0F000000) >> 24;
} /* Packet_Get_Version() */

/**
 * Computes the delay for a packet based on the raw packet buffer,
 * sets the value computed in the packet structure and also extracts
 * the time stamp from the raw packet buffer into the structure
 *
 * @param pack_buf raw packet buffer
 * @param tv time structure marking receipt time for the packet
 * @param p packet structure for the packet buffer
 */
static inline void Packet_Compute_Delay(char* pack_buf, struct timeval* tv, packet* p) {
        uint32_t tmp;
        int micro;
        memcpy(&(tmp), pack_buf + 8, 4);
        tmp = ntohl(tmp);
        p->tv_sec = tmp;
        memcpy(&(tmp), pack_buf + 12, 4);
        tmp = ntohl(tmp);
        p->tv_usec = tmp;
//      printf("computing delay with sent:[%d,%d] received:[%d,%d]: ", (int)p->tv_sec, (int)p->tv_usec, (int)tv->tv_sec, (int)tv->tv_usec);
        /* micro contains the microseconds delay difference */
        micro = (int)(((int)p->tv_usec - (int)tv->tv_usec));
        p->delay = (int32_t)((((int)p->tv_sec - (int)tv->tv_sec) * 1000000) + micro);
        if (p->delay == 0) {
                /* avoid delay of 0us */
                if (((int)p->tv_usec - (int)tv->tv_usec) < 0)
                        p->delay = -1;
                else
                        p->delay = 1;
        }
}

/**
 * Prepares the iov strucutre for a packet
 *
 * @param num_bufs number of iov buffers to allocate
 * @param first_buf_len length of the first buffer to allocate
 * @return
 *      NULL on error
 *      newly allocated packet pointer with allocated buffers
 */
static inline packet* Packet_PrepIov(int num_bufs, int first_buf_len) {
        char* buf;
        packet* p;
        if (ALLOC(p, struct packet*, struct packet, 1)== NULL) return NULL;
        if (ALLOC(p->iov, struct iovec*, struct iovec, num_bufs)== NULL) {
                RELEASE(p, sizeof(packet));
                return NULL;
        }
        if (ALLOC(buf, char*, char, first_buf_len) == NULL) {
                RELEASE(p->iov, sizeof(struct iovec));
                RELEASE(p, sizeof(packet));
                return NULL;
        }
        p->iov[0].iov_base      = buf;
        p->iov[0].iov_len       = first_buf_len;
        p->iovlen               = num_bufs;
        return p;
} /* Packet_PrepIov() */

/**
 * Reads from a file descriptor into an iov buffer.
 *
 * Does minor validation of the generic header. Returns either an
 * error or the packet_type of the received packet. Set iov as return
 * by reference.
 *
 * @param fd file descriptor to which to write the buffer
 * @param p packet strucutre to read the packet into
 * @param addr pointer that is either NULL or address to which we send the iov
 * @param addr_len pointer to be set by reference to length of addr param
 * @return 
 *      0 on success (p contains a valid packet)
 *      errno on syscall error
 *      -1 received packet has incorrect length (validation err)
 *      -2 received packet has incorrect type (validation err)
 *      -3 received packet has incorrect version (validation err)
 *      -4 on unknown packet type
 *      -5 on error (shutdown socket)
 *      -6 on error (ALLOC macro)
 *      -7 on error (other) - such as mismatched recv sizes (see below)
 */
int Packet_Read(int fd, packet** p, struct sockaddr* addr, socklen_t* addr_len) {
        int n;
        unsigned char packet_type;
        unsigned char packet_version;
        int ret;
        struct timeval tv;
        int err_val_len;
        int err_val;

        /* quit if there is a pending error on this socket */
        err_val_len = 4;
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err_val, &err_val_len) == -1) perror("Packet_Read :: getsockopt");
        if (err_val != 0) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "socket has a pending error[%d]:[%s]", err_val, strerror(err_val));
                return err_val;
        }
        
        /* read packet into a temporary buffer of max UDP packet length */
        n = recvfrom(fd, pack_buf, 65535, MSG_DONTWAIT, addr, addr_len);

        // DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "fd[%d] recvfrom returned %d", fd, n);
        // DEBUG_PRINT(1, "packet.c", "Packet_Read", "fd[%d] recvfrom returned %d", fd, n);

        /* mark receipt time */
        GET_TIME_OF_DAY(&(tv));
        
        if (n == -1) {
                ret = errno;
                if (ret != EAGAIN) {
                        perror("packet_read :: recvfrom");
                }
                return ret;
        } else if (n == 0) {
                return -5;
        }

        Packet_Get_Type(pack_buf, &packet_type);
        Packet_Get_Version(pack_buf, &packet_version);
        //DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "Received: bytes[%d] type[%d] version[%d]", n, (int)(packet_type), (int)(packet_version));

        /* discard incorrect packets */
        if (packet_version != VFER_VERSION) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "received packet with bad version: version[%d] ; my version[%d]", packet_version, VFER_VERSION);
                return -3;
        } else if (packet_type != REQUEST       &&
                   packet_type != RESPONSE      &&
                   packet_type != DATA          &&
                   packet_type != CC_ACK        && 
                   packet_type != DATA_ACK      &&
                   packet_type != CLOSE) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "received packet with bad type: type[%d]", (int)(packet_type));
                return -2;
        }           
        
        /* allocate the packet structure to hold the received packet */
        if (ALLOC(*p, struct packet*, struct packet, 1) == NULL) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "could not allocate packet");
                return -6;
        }
        if (ALLOC((*p)->iov, struct iovec*, struct iovec, 1) == NULL) { 
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "could not allocate iovec array of size 1");
                RELEASE((*p), sizeof(struct packet));
                return -6;
        }
        if (ALLOC((*p)->iov[0].iov_base, char*, char, n) == NULL) { 
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "could not allocate %d bytes", n);
                RELEASE((*p)->iov, sizeof(struct iovec));
                RELEASE((*p), sizeof(struct packet));
                return -6;
        }
        
        /* copy packet from tmp buffer to persistent mem buffer */
        (*p)->iov[0].iov_len    = n;
        (*p)->iovlen            = 1;
        memcpy((*p)->iov[0].iov_base, pack_buf, n);

        /* interpret the packet */
        switch (packet_type) {
        case REQUEST:
                ret = Packet_Translate_Request(*p);
                break;
        case RESPONSE:
                ret = Packet_Translate_Response(*p);
                break;
        case DATA:
                ret = Packet_Translate_Data(*p);
                break;
        case CC_ACK:
                ret = Packet_Translate_CCAck(*p);
                break;
        case DATA_ACK:
//              ret = Packet_Translate_DataAck(*p);
                ret = -4;       /* for now */
                break;
        case CLOSE:
                ret = Packet_Translate_Close(*p);
                break;
        default:
                ret = -4;
                break;
        }

        if (ret != 0) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Read", "Packet discarded with error [%d]", ret);
                RELEASE((*p)->iov[0].iov_base, n);
                RELEASE((*p)->iov, sizeof(struct iovec));
                RELEASE((*p), sizeof(struct packet));
        }
        /* compute and set the delay for this packet, including the time on the packet */
        Packet_Compute_Delay(pack_buf, &tv, *p);
        
        /* DEBUG_PACK(DEBUG_PACKET, "packet.c", "Packet_Read", *p, "Received"); */
        return ret;
} /* Packet_Read() */

/**
 * Reads ICMP packets and makes any necessary adjustments to the path MTU.
 *
 * @param icmp_fd file descriptor of icmp socket
 * @param pmtu pmtu structure to modify if we read an ICMP packet
 * @return 
 *      0 on success (p contains a valid packet)
 *  -1 no ICMP packets to be read
 */
int Packet_Read_ICMP(int icmp_fd, void* pmtu){
        if(icmp_fd == -1){
                return 1;
        }
        char buf[1024];
        int n = recvfrom(icmp_fd, &buf, 1024, MSG_DONTWAIT, NULL, NULL);
        path_mtu* pmtu_vals = (path_mtu*)pmtu;
        
        if(n == -1){
                return 1;
        }else{
                int type = buf[20];
                int code = buf[21];
                int udp_size = ((int)buf[52] << 8) + buf[53] - 8;
                
                /* PMTU: If Type = Destination Unreachable and Code = Fragmentation Needed then decrease MTU probe size
                   if UDP length indicates packet the same size as the probe */
                if(type == DEST_UNREACHABLE && code == FRAG_NEEDED && udp_size == *(pmtu_vals->probe_size)){
                        pmtu_vals->probe_state = MTU_FOUND;
                        pmtu_vals->search_high = pmtu_vals->probe_size;
                        struct timeval tv;
                        GET_TIME_OF_DAY(&tv);
                        pmtu_vals->next_probe_time = tv.tv_sec + PMTUD_TIME_INTERVAL;
                        DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "packet.c", "Packet_Read_ICMP", "Found MTU based on ICMP. Next probe begins at %lu", (long int)tv.tv_sec);
                }
                
                DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "packet.c", "Packet_Read_ICMP", "Received ICMP packet. [Size=> %d, Type=> %d, Code=>%d]", n, type, code);
        }
        
        return 0;
}/* Packet_Read_ICMP() */

/**
 * Writes a packet of a certain length to a file descriptor.
 *
 * @param p packet structure containing the packet to write out
 * @param fd file descriptor to which to write the buffer
 * @param addr is the address to send the packet to (eg. for unconnected sockets - used in server.c Server_Accept() )
 * @param addr_len is the length of the addr param
 * @return
 *       0 on success
 *       errno generated by sendmsg or writev on error
 */
int Packet_Write(packet* p, int fd, struct sockaddr* addr, socklen_t addr_len) {
        int n;
        int err_val;
        socklen_t err_val_len;
        struct timeval tv;
        uint32_t int32;

        DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "sending packet: type[%s] iovlen[%d] fd[%d]", Packet_Str_Type(p), p->iovlen, fd);

        /* randomly drop every 2nd data packet: */
        /* if (p->type == DATA) {
                n = (2 * 1.0 * rand() / (RAND_MAX + 1.0));
                if (n == 1) {
                        // DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "Random DROP: frame[%d] data_offset[%d] len[%d]", p->u.data.frame_num, p->u.data.data_offset, p->u.data.data_len);
                        goto random_end;
                }
        }
        */
        
        /* quit if there is a pending error on this socket */
        err_val_len = 4;
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err_val, &err_val_len) == -1) perror("Packet_Write :: getsockopt");
        if (err_val != 0) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "socket has a pending error[%d]:[%s]", err_val, strerror(err_val));
                return err_val;
        }

        /* time stamp this packet with local time, the stamp goes into
         * the header of every packet at the 8th byte for 8 bytes :
         * two integers, check packet.h for more */
        GET_TIME_OF_DAY(&(tv));
        
        int32 = (uint32_t) (tv.tv_sec);
        int32 = htonl(int32);
        memcpy(p->iov[0].iov_base + 8, &(int32), 4);
                
        int32 = (uint32_t) (tv.tv_usec);
        int32 = htonl(int32);
        memcpy(p->iov[0].iov_base + 12, &(int32), 4);

        /* send iov */
        if (addr != NULL) {
                if (p->iovlen != 1) {
                        DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "can't send more than a vector of 1 element on unconnected socket");
                        return -1;
                }
                n = sendto(fd, p->iov[0].iov_base, p->iov[0].iov_len, MSG_DONTWAIT, addr, addr_len);
                if (n == -1) {
                        err_val = errno;
                        DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "sendto generated an error, %s", strerror(err_val));
                        return err_val;
                }
        } else {
                if ((n = writev(fd, p->iov, p->iovlen)) == -1) {
                        err_val = errno;
                        DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "writev generated an error, %s", strerror(err_val));
                        return err_val;
                }
                /* DEBUG_PMTUD_PRINT(DEBUG_PMTUD, "vfer_packet.c", "Packet_Write()", "Sent packet of size %d", n); */
                /* DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "writev returned [%d] ; p->iov[0].iov_len[%d]", n, (int)(p->iov[0].iov_len)); */
        }

        /* check any pending errors on the socket */
        err_val_len = 4;
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err_val, &err_val_len) == -1) perror("packet_write :: getsockopt");
        if (n == -1 || err_val != 0) {
                DEBUG_PRINT(DEBUG_PACKET, "packet.c", "Packet_Write", "socket generated error[%s]", strerror(err_val));
                return err_val;
        }
        DEBUG_PACK(DEBUG_PACKET, "packet.c", "Packet_Write", p, "Sent");
/* random_end: */
        return 0;
} /* Packet_Write() */


/**
 * Generates a random (2 bytes) frame number
 *
 * @return
 *      generated frame number
 */
inline uint16_t Packet_Gen_FrameNum() {
        // return (uint16_t)(USHRT_MAX * 1.0 * rand() / (RAND_MAX + 1.0)); /* USHRT_MAX is defined in <limits.h> */
        return 0;
} /* Packet_Gen_FrameNum() */

/**
 * Generates a random (4 byte) sequence number.
 *
 * @return
 *      generated sequence number
 */
inline uint32_t Packet_Gen_SeqNum() {
        // return (uint32_t)(UINT_MAX * 1.0 * rand() / (RAND_MAX + 1.0)); /* USHRT_MAX is defined in <limits.h> */
        return 0;
} /* Packet_Gen_SeqNum() */

/****************************************************************
 * Option helper functions
 ****************************************************************/

/**
 * Sets an option in an options pointer
 *
 * @param opts options pointer
 * @param opt option to set
 */
static inline void Packet_Set_Opt(uint32_t* opts, int opt) {
//      printf("set opt1: %d\n", *opts);
        *opts = (*opts) | opt;
//      printf("set opt2: %d\n", *opts);
} /* Packet_Set_Opt() */

/**
 * Unsets an option in an options pointer
 *
 * @param opts options pointer
 * @param opt option to unset
 */
static inline void Packet_Unset_Opt(uint32_t* opts, int opt) {
//      printf("unset opt1: %d\n", *opts);
        *opts = (*opts) & (~opt);
//      printf("unset opt2: %d\n", *opts);
} /* Packet_Unset_Opt() */

/**
 * Boolean function that checks if an option is set
 *
 * @param opts options pointer
 * @param opt option to check for
 *
 * @return
 *      0 if option is not set
 *      1 if the option is set
 */
static inline int Packet_Get_Opt(uint32_t opts, int opt) {
//      printf("get opts[%d] | opt[%d] = %d\n", opts, opt, opts & opt;)
        return (opts & opt);
} /* Packet_Get_Opt() */

---