packet.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.h>
#include <netinet/in.h>
#include <src/util/dbg.h>
#include <src/util/common.h>
#include "packet.h"

void *encode_general_header(void *buf_ptr, const PrrtPacket *packet);

void *encode_data_header(void *buf_ptr, const void *payload);

void *encode_redundancy_header(void *buf_ptr, const void *payload);

void *encode_feedback_header(void *buf_ptr, const void *payload);

void *decode_data_header(void *buf_ptr, const void *payload_ptr);

void *decode_redundancy_header(void *buf_ptr, const void *payload_ptr);

void *decode_feedback_header(void *buf_ptr, const void *payload_ptr);

uint8_t PrrtPacket_type(PrrtPacket *packet_ptr)
{
    return (uint8_t) ((packet_ptr->type_priority >> 4) & 0x0F);
}

uint8_t PrrtPacket_priority(PrrtPacket *packet_ptr)
{
    return (uint8_t) (packet_ptr->type_priority & 0x0F);
}

uint16_t PrrtPacket_size(PrrtPacket *packet_ptr)
{
    return (uint16_t) (packet_ptr->payload_len + PRRT_PACKET_GENERAL_HEADER_SIZE);
}

int PrrtPacket_print(PrrtPacket *packet_ptr)
{
    printf(" 0                   1                   2                   3\n"
                   " 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n"
                   "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
    uint8_t type = PrrtPacket_type(packet_ptr);

    printf("| %5u | %5u | %13u | %29u |\n", type, PrrtPacket_priority(packet_ptr), packet_ptr->index,
           packet_ptr->seqno);
    printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");

    if(type == PACKET_TYPE_DATA) {
        PrrtPacketDataPayload *payload = packet_ptr->payload;
        printf("| %61u |\n", payload->timestamp);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %29u | %29u |\n", payload->group_round_trip_time, payload->packet_timeout);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %29u | %29u |\n", payload->decoding_timeout, payload->feedback_timeout);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %61s |\n", (char *) (packet_ptr->payload + PRRT_PACKET_DATA_HEADER_SIZE));
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
    } else if(type == PACKET_TYPE_REDUNDANCY) {
        PrrtPacketRedundancyPayload *payload = packet_ptr->payload;
        printf("| %29u | %13u | %13u |\n", payload->base_seqno, payload->n, payload->k);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
    } else if(type == PACKET_TYPE_FEEDBACK) {
        PrrtPacketFeedbackPayload *payload = packet_ptr->payload;
        printf("| %61u |\n", payload->group_round_trip_time);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %61u |\n", payload->forward_trip_time);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %61u |\n", payload->packet_loss_rate);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %29u | %29u |\n", payload->gap, payload->ngap);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %29u | %29u |\n", payload->burst, payload->nburst);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %61u |\n", payload->bandwidth_estimate);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
        printf("| %61u |\n", payload->buffer_feedback);
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
    } else {
        printf("| Unhandeled Type                                               |\n");
        printf("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n");
    }

    return 0;
}

PrrtPacket *PrrtPacket_copy(PrrtPacket *original)
{
    PrrtPacket *newPacket = calloc(1, sizeof(PrrtPacket));
    check_mem(newPacket);
    void *payload = calloc(1, original->payload_len);
    check_mem(payload);

    newPacket->payload = payload;
    newPacket->payload_len = original->payload_len;
    memcpy(newPacket->payload, original->payload, original->payload_len);

    newPacket->index = original->index;
    newPacket->seqno = original->seqno;
    newPacket->type_priority = original->type_priority;


    return newPacket;
    error:
    PERROR("Not enough memory for packet copies.");
}

int PrrtPacket_encode(void *buf_ptr, uint16_t buf_size, PrrtPacket *packet_ptr)
{
    void *payload = packet_ptr->payload;

    check(packet_ptr->payload_len + PRRT_PACKET_GENERAL_HEADER_SIZE <= buf_size, "Buffer too small.");

    buf_ptr = encode_general_header(buf_ptr, packet_ptr);

    uint8_t type = PrrtPacket_type(packet_ptr);
    if(type == PACKET_TYPE_DATA) {
        buf_ptr = encode_data_header(buf_ptr, payload);
        PrrtPacket_copy_payload_to_buffer(buf_ptr, packet_ptr, PRRT_PACKET_DATA_HEADER_SIZE);
    } else if(type == PACKET_TYPE_REDUNDANCY) {
        buf_ptr = encode_redundancy_header(buf_ptr, payload);
        PrrtPacket_copy_payload_to_buffer(buf_ptr, packet_ptr, PRRT_PACKET_REDUNDANCY_HEADER_SIZE);
    } else if(type == PACKET_TYPE_FEEDBACK) {
        buf_ptr = encode_feedback_header(buf_ptr, payload);
        PrrtPacket_copy_payload_to_buffer(buf_ptr, packet_ptr, PRRT_PACKET_FEEDBACK_HEADER_SIZE);
    } else {
        perror("NOT IMPLEMENTED");
        return -1;
    }
    return 0;

    error:
    return -1;
}

void *encode_redundancy_header(void *buf_ptr, const void *payload)
{
    const PrrtPacketRedundancyPayload *redundancyPayload = payload;

    uint16_t *baseSeqNo = (uint16_t *) buf_ptr;
    *baseSeqNo = htons(redundancyPayload->base_seqno);
    buf_ptr += 2;

    uint8_t *n = (uint8_t *) buf_ptr;
    *n = redundancyPayload->n;
    buf_ptr += 1;

    uint8_t *k = (uint8_t *) buf_ptr;
    *k = redundancyPayload->k;
    buf_ptr += 1;

    return buf_ptr;
}

void *encode_feedback_header(void *buf_ptr, const void *payload)
{
    const PrrtPacketFeedbackPayload *feedbackPayload = payload;

    uint32_t *receiver_ip = (uint32_t *) buf_ptr;
    *receiver_ip = htonl(feedbackPayload->receiver_addr);
    buf_ptr += 4;

    uint32_t *group_round_trip_time = (uint32_t *) buf_ptr;
    *group_round_trip_time = htonl(feedbackPayload->group_round_trip_time);
    buf_ptr += 4;

    uint32_t *forward_trip_time = (uint32_t *) buf_ptr;
    *forward_trip_time = htonl(feedbackPayload->forward_trip_time);
    buf_ptr += 4;

    uint32_t *packet_loss_rate = (uint32_t *) buf_ptr;
    *packet_loss_rate = htonl(feedbackPayload->packet_loss_rate);
    buf_ptr += 4;

    uint16_t *gap = (uint16_t *) buf_ptr;
    *gap = htons(feedbackPayload->gap);
    buf_ptr += 2;

    uint16_t *ngap = (uint16_t *) buf_ptr;
    *ngap = htons(feedbackPayload->ngap);
    buf_ptr += 2;

    uint16_t *burst = (uint16_t *) buf_ptr;
    *burst = htons(feedbackPayload->burst);
    buf_ptr += 2;

    uint16_t *nburst = (uint16_t *) buf_ptr;
    *nburst = htons(feedbackPayload->nburst);
    buf_ptr += 2;

    uint32_t *bandwidth_estimate = (uint32_t *) buf_ptr;
    *bandwidth_estimate = htonl(feedbackPayload->bandwidth_estimate);
    buf_ptr += 4;

    uint32_t *buffer_feedback = (uint32_t *) buf_ptr;
    *buffer_feedback = htonl(feedbackPayload->buffer_feedback);
    buf_ptr += 4;

    return buf_ptr;
}

void *encode_data_header(void *buf_ptr, const void *payload)
{
    const PrrtPacketDataPayload *data_payload = payload;

    uint32_t *timestamp = (uint32_t *) buf_ptr;
    *timestamp = htonl(data_payload->timestamp);
    buf_ptr += 4;

    uint16_t *group_round_trip_time = (uint16_t *) buf_ptr;
    *group_round_trip_time = htons(data_payload->group_round_trip_time);
    buf_ptr += 2;

    uint16_t *packet_timeout = (uint16_t *) buf_ptr;
    *packet_timeout = htons(data_payload->packet_timeout);
    buf_ptr += 2;

    uint16_t *decoding_timeout = (uint16_t *) buf_ptr;
    *decoding_timeout = htons(data_payload->decoding_timeout);
    buf_ptr += 2;

    uint16_t *feedback_timeout = (uint16_t *) buf_ptr;
    *feedback_timeout = htons(data_payload->feedback_timeout);
    buf_ptr += 2;
    return buf_ptr;
}

void *encode_general_header(void *buf_ptr, const PrrtPacket *packet)
{
    uint8_t *type_priority = (uint8_t *) buf_ptr;
    *type_priority = packet->type_priority;
    buf_ptr += 1;

    uint8_t *index = (uint8_t *) buf_ptr;
    *index = packet->index;
    buf_ptr += 1;

    uint16_t *seqno = (uint16_t *) buf_ptr;
    *seqno = htons(packet->seqno);
    buf_ptr += 2;

    return buf_ptr;
}

int PrrtPacket_decode(void *buf_ptr, uint16_t buf_size, PrrtPacket *packet_ptr)
{
    uint32_t payload_len = (uint32_t) (buf_size - PRRT_PACKET_GENERAL_HEADER_SIZE);
    packet_ptr->type_priority = *(uint8_t *) buf_ptr;
    buf_ptr += 1;
    uint8_t *index_ptr = (uint8_t *) buf_ptr;
    packet_ptr->index = *index_ptr;
    buf_ptr += 1;
    uint16_t *seqno_prt = (uint16_t *) buf_ptr;
    packet_ptr->seqno = ntohs(*seqno_prt);
    buf_ptr += 2;

    void *payload_buffer = calloc(1, payload_len);
    check_mem(payload_buffer);

    packet_ptr->payload = payload_buffer;
    packet_ptr->payload_len = payload_len;

    if(PrrtPacket_type(packet_ptr) == PACKET_TYPE_DATA) {
        buf_ptr = decode_data_header(buf_ptr, payload_buffer);
        PrrtPacket_copy_buffer_to_payload(packet_ptr, buf_ptr, PRRT_PACKET_DATA_HEADER_SIZE);
    } else if(PrrtPacket_type(packet_ptr)) {
        buf_ptr = decode_redundancy_header(buf_ptr, payload_buffer);
        PrrtPacket_copy_buffer_to_payload(packet_ptr, buf_ptr, PRRT_PACKET_REDUNDANCY_HEADER_SIZE);
    } else if(PrrtPacket_type(packet_ptr) == PACKET_TYPE_FEEDBACK) {
        buf_ptr = decode_feedback_header(buf_ptr, payload_buffer);
        PrrtPacket_copy_buffer_to_payload(packet_ptr, buf_ptr, PRRT_PACKET_FEEDBACK_HEADER_SIZE);
    } else {
        printf("NOT IMPLEMENTED\n");
    }
    return 0;

    error:
    return EXIT_FAILURE;
}

void *decode_redundancy_header(void *buf_ptr, const void *payload_ptr)
{
    PrrtPacketRedundancyPayload *redundancyPayload = (PrrtPacketRedundancyPayload *) payload_ptr;

    uint16_t *baseSeqNo = (uint16_t *) buf_ptr;
    redundancyPayload->base_seqno = ntohs(*baseSeqNo);
    buf_ptr += 2;

    uint8_t *n = (uint8_t *) buf_ptr;
    redundancyPayload->n = *n;
    buf_ptr += 1;

    uint8_t *k = (uint8_t *) buf_ptr;
    redundancyPayload->k = *k;
    buf_ptr += 1;

    return buf_ptr;
}

void *decode_feedback_header(void *buf_ptr, const void *payload_ptr)
{
    PrrtPacketFeedbackPayload *feedback_payload = (PrrtPacketFeedbackPayload *) payload_ptr;

    uint32_t *receiver_addr = (uint32_t *) buf_ptr;
    feedback_payload->receiver_addr = ntohl(*receiver_addr);
    buf_ptr += 4;

    uint32_t *group_round_trip_time = (uint32_t *) buf_ptr;
    feedback_payload->group_round_trip_time = ntohl(*group_round_trip_time);
    buf_ptr += 4;

    uint32_t *forward_trip_time = (uint32_t *) buf_ptr;
    feedback_payload->forward_trip_time = ntohl(*forward_trip_time);
    buf_ptr += 4;

    uint32_t *packet_loss_rate = (uint32_t *) buf_ptr;
    feedback_payload->packet_loss_rate = ntohl(*packet_loss_rate);
    buf_ptr += 4;

    uint16_t *gap = (uint16_t *) buf_ptr;
    feedback_payload->gap = ntohs(*gap);
    buf_ptr += 2;

    uint16_t *ngap = (uint16_t *) buf_ptr;
    feedback_payload->ngap = ntohs(*ngap);
    buf_ptr += 2;

    uint16_t *burst = (uint16_t *) buf_ptr;
    feedback_payload->burst = ntohs(*burst);
    buf_ptr += 2;

    uint16_t *nburst = (uint16_t *) buf_ptr;
    feedback_payload->nburst = ntohs(*nburst);
    buf_ptr += 2;

    uint32_t *bandwidth_estimate = (uint32_t *) buf_ptr;
    feedback_payload->bandwidth_estimate = ntohl(*bandwidth_estimate);
    buf_ptr += 4;

    uint32_t *buffer_feedback = (uint32_t *) buf_ptr;
    feedback_payload->buffer_feedback = ntohl(*buffer_feedback);
    buf_ptr += 4;

    return buf_ptr;
}

void *decode_data_header(void *buf_ptr, const void *payload_ptr)
{
    PrrtPacketDataPayload *data_payload = (PrrtPacketDataPayload *) payload_ptr;

    uint32_t *timestamp = (uint32_t *) buf_ptr;
    data_payload->timestamp = ntohl(*timestamp);
    buf_ptr += 4;

    uint16_t *group_round_trip_time = (uint16_t *) buf_ptr;
    data_payload->group_round_trip_time = ntohs(*group_round_trip_time);
    buf_ptr += 2;

    uint16_t *packet_timeout = (uint16_t *) buf_ptr;
    data_payload->packet_timeout = ntohs(*packet_timeout);
    buf_ptr += 2;

    uint16_t *decoding_timeout = (uint16_t *) buf_ptr;
    data_payload->decoding_timeout = ntohs(*decoding_timeout);
    buf_ptr += 2;

    uint16_t *feedback_timeout = (uint16_t *) buf_ptr;
    data_payload->feedback_timeout = ntohs(*feedback_timeout);
    buf_ptr += 2;
    return buf_ptr;
}

int PrrtPacket_destroy(PrrtPacket *packet_ptr)
{
    if(packet_ptr->payload != NULL) {
        free(packet_ptr->payload);
    }
    free(packet_ptr);
    return 0;
}

int PrrtPacket_create_data_packet(PrrtPacket *packet_ptr, uint8_t priority, const void *data_ptr,
                                  uint32_t data_len, uint16_t seqno)
{
    uint32_t payload_length = (uint32_t) (data_len + PRRT_PACKET_DATA_HEADER_SIZE);

    packet_ptr->type_priority = PACKET_TYPE_DATA << 4;
    packet_ptr->type_priority |= priority & 0x0F;
    packet_ptr->index = 0;
    packet_ptr->seqno = seqno;

    void *content_buf = calloc(1, payload_length);
    check_mem(content_buf);

    PrrtPacketDataPayload *source_payload = content_buf;

    struct timeval tv;
    gettimeofday(&tv, NULL);
    unsigned long time_in_micros = (unsigned long) (1000000 * tv.tv_sec + tv.tv_usec);

    source_payload->timestamp = (uint32_t) time_in_micros;
    source_payload->group_round_trip_time = 95; // TODO: payload->rtt = CURRENT ESTIMATE
    source_payload->packet_timeout = 110; // TODO: payload->packet_timeout = NOW + maximum delay
    source_payload->decoding_timeout = 150; // TODO: payload->decoding_timeout
    source_payload->feedback_timeout = 170; // TODO: payload->feedback_timer

    packet_ptr->payload = content_buf;
    packet_ptr->payload_len = payload_length;
    PrrtPacket_copy_buffer_to_payload(packet_ptr, data_ptr, PRRT_PACKET_DATA_HEADER_SIZE)

    error:
    return -1;
}

PrrtPacket *PrrtPacket_create_redundancy_packet(uint8_t priority, void *data_ptr, uint32_t data_len,
                                                uint16_t seqno, uint8_t index, uint16_t base_seqno,
                                                PrrtCodingParams codingParams)
{
    uint32_t payload_length = (uint32_t) (data_len + PRRT_PACKET_REDUNDANCY_HEADER_SIZE);

    PrrtPacket *packet_ptr = calloc(1, sizeof(PrrtPacket));
    check_mem(packet_ptr);

    packet_ptr->type_priority = PACKET_TYPE_REDUNDANCY << 4;
    packet_ptr->type_priority |= priority & 0x0F;
    packet_ptr->index = index;
    packet_ptr->seqno = seqno;

    void *content_buf = calloc(1, PRRT_PACKET_REDUNDANCY_HEADER_SIZE + data_len);
    check_mem(content_buf);

    PrrtPacketRedundancyPayload *redundancy_payload = content_buf;

    redundancy_payload->base_seqno = base_seqno;
    redundancy_payload->k = codingParams.k;
    redundancy_payload->n = codingParams.n;

    packet_ptr->payload = content_buf;
    packet_ptr->payload_len = payload_length;
    PrrtPacket_copy_buffer_to_payload(packet_ptr, data_ptr, PRRT_PACKET_REDUNDANCY_HEADER_SIZE);

    return packet_ptr;

    error:
    return NULL;
}

PrrtPacket *PrrtPacket_create_feedback_packet(uint8_t priority, uint8_t index, uint16_t seqno, uint32_t round_trip_time,
                                              uint32_t forward_trip_time, uint32_t packet_loss_rate, uint16_t gap,
                                              uint16_t ngap,
                                              uint16_t burst, uint16_t nburst, uint32_t bandwidth,
                                              uint32_t buffer_feedback)
{
    PrrtPacket *packet_ptr = calloc(1, sizeof(PrrtPacket));
    check_mem(packet_ptr);
    packet_ptr->type_priority = PACKET_TYPE_FEEDBACK << 4;
    packet_ptr->type_priority |= priority & 0x0F;
    packet_ptr->index = index;
    packet_ptr->seqno = seqno;

    PrrtPacketFeedbackPayload *payload = calloc(1, PRRT_PACKET_FEEDBACK_HEADER_SIZE);
    check_mem(payload);

    payload->group_round_trip_time = round_trip_time;
    payload->forward_trip_time = forward_trip_time;
    payload->packet_loss_rate = packet_loss_rate;
    payload->gap = gap;
    payload->ngap = ngap;
    payload->burst = burst;
    payload->nburst = nburst;
    payload->bandwidth_estimate = bandwidth;
    payload->buffer_feedback = buffer_feedback;

    packet_ptr->payload = (void *) payload;
    packet_ptr->payload_len = (uint32_t) (PRRT_PACKET_FEEDBACK_HEADER_SIZE);

    return packet_ptr;

    error:
    return NULL;
}