packet.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.h>
#include <netinet/in.h>
#include "../util/common.h"
#include "../util/dbg.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 *dstBuffer, const void *srcBuffer);

void *decode_redundancy_header(void *dstBuffer, const void *srcBuffer);

void *decode_feedback_header(void *dstBuffer, const void *srcBuffer);

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.%s", "");
}

PrrtPacket *create_header(uint8_t priority, uint16_t seqno, uint32_t size, uint8_t type, uint8_t index)
{
    PrrtPacket *packet = calloc(1, sizeof(PrrtPacket));
    check_mem(packet);

    packet->type_priority = type << 4;
    packet->type_priority |= priority & 0x0F;
    packet->index = index;
    packet->seqno = seqno;
    packet->payload_len = size;

    return packet;

    error:
    PERROR("Could not create packet.%s", "");
}

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 *srcBuffer, uint16_t srcBufferSize, PrrtPacket *targetPacket)
{
    uint32_t payload_len = (uint32_t) (srcBufferSize - PRRT_PACKET_GENERAL_HEADER_SIZE);
    targetPacket->type_priority = *(uint8_t *) srcBuffer;
    srcBuffer += 1;
    uint8_t *index_ptr = (uint8_t *) srcBuffer;
    targetPacket->index = *index_ptr;
    srcBuffer += 1;
    uint16_t *seqno_prt = (uint16_t *) srcBuffer;
    targetPacket->seqno = ntohs(*seqno_prt);
    srcBuffer += 2;

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

    targetPacket->payload = payload_buffer;
    targetPacket->payload_len = payload_len;

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

    error:
    return EXIT_FAILURE;
}

void *decode_redundancy_header(void *dstBuffer, const void *srcBuffer)
{
    PrrtPacketRedundancyPayload *redundancyPayload = (PrrtPacketRedundancyPayload *) srcBuffer;

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

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

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

    return dstBuffer;
}

void *decode_feedback_header(void *dstBuffer, const void *srcBuffer)
{
    PrrtPacketFeedbackPayload *feedback_payload = (PrrtPacketFeedbackPayload *) srcBuffer;

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

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

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

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

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

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

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

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

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

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

    return dstBuffer;
}

void *decode_data_header(void *dstBuffer, const void *srcBuffer)
{
    PrrtPacketDataPayload *data_payload = (PrrtPacketDataPayload *) srcBuffer;

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

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

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

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

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

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

PrrtPacket *PrrtPacket_create_data_packet(uint8_t priority, const void *payloadPointer, uint32_t payloadLength,
                                          uint16_t sequenceNumber)
{
    PrrtPacket *packet = create_header(priority, sequenceNumber,
                                       (uint32_t) (payloadLength + PRRT_PACKET_DATA_HEADER_SIZE), PACKET_TYPE_DATA, 0);

    PrrtPacketDataPayload *dataPayload = calloc(1, packet->payload_len);
    check_mem(dataPayload);
    packet->payload = dataPayload;

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

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

    return packet;

    error:
    PERROR("Could not create packet.%s","");
}

PrrtPacket *PrrtPacket_create_redundancy_packet(uint8_t priority, void *payloadPointer, uint32_t payloadLength,
                                                uint16_t sequenceNumber, uint8_t index, uint16_t baseSequenceNumber,
                                                PrrtCodingParams codingParams)
{
    PrrtPacket *packet = create_header(priority, sequenceNumber,
                                       (uint32_t) (payloadLength + PRRT_PACKET_REDUNDANCY_HEADER_SIZE),
                                       PACKET_TYPE_REDUNDANCY, index);

    PrrtPacketRedundancyPayload *redundancyPayload = calloc(1, packet->payload_len);
    check_mem(redundancyPayload);
    packet->payload = redundancyPayload;

    redundancyPayload->base_seqno = baseSequenceNumber;
    redundancyPayload->k = codingParams.k;
    redundancyPayload->n = codingParams.n;
    PrrtPacket_copy_buffer_to_payload(packet, payloadPointer, PRRT_PACKET_REDUNDANCY_HEADER_SIZE);

    return packet;

    error:
    return NULL;
}

PrrtPacket *PrrtPacket_create_feedback_packet(uint8_t priority, uint8_t index, uint16_t sequenceNumber,
                                              uint32_t roundTripTime, uint32_t forwardTripTime, uint32_t packetLossRate,
                                              uint16_t gap, uint16_t ngap, uint16_t burst, uint16_t nburst,
                                              uint32_t bandwidth, uint32_t bufferFeedback)
{
    PrrtPacket *packet = create_header(priority, sequenceNumber, PRRT_PACKET_FEEDBACK_HEADER_SIZE, PACKET_TYPE_FEEDBACK,
                                       index);

    PrrtPacketFeedbackPayload *payload = calloc(1, packet->payload_len);
    check_mem(payload);
    packet->payload = payload;

    payload->group_round_trip_time = roundTripTime;
    payload->forward_trip_time = forwardTripTime;
    payload->packet_loss_rate = packetLossRate;
    payload->gap = gap;
    payload->ngap = ngap;
    payload->burst = burst;
    payload->nburst = nburst;
    payload->bandwidth_estimate = bandwidth;
    payload->buffer_feedback = bufferFeedback;


    return packet;

    error:
    return NULL;
}