Create basic source packet header.

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

add_subdirectory(prrt)

add_library(PRRT prrt/socket.c)

add_library(PRRT prrt/socket.c prrt/block.c prrt/block.h prrt/packet.c prrt/packet.h)

add_executable(sender sender.c)

add_executable(receiver receiver.c)

add_executable(tester tester.c)

target_link_libraries(sender LINK_PUBLIC PRRT)

target_link_libraries(receiver LINK_PUBLIC PRRT)

target_link_libraries(tester LINK_PUBLIC PRRT)

 No newline at end of file

//

// Created by root on 05.11.15.

//

#ifndef PRRT_DEFINES_H

#define PRRT_DEFINES_H

#define MAX(x, y) (((x) > (y)) ? (x) : (y))

#define MIN(x, y) (((x) < (y)) ? (x) : (y))

#define PRRT_MAX_RECEIVER_COUNT 255

#define PRRT_PACKET_GENERAL_HEADER_SIZE 4

#define PRRT_PACKET_SOURCE_HEADER_SIZE 12

#define MAX_PAYLOAD_LENGTH 65528 // maximum UDP packet length (2^16 - 8)

#endif //PRRT_DEFINES_H

#include "block.h"

#ifndef PRRT_BLOCK_H

#define PRRT_BLOCK_H

#endif //PRRT_BLOCK_H

//

// Created by andreas on 06.11.15.

//

#include <stdlib.h>

#include <stdio.h>

#include <sys/time.h>

#include <string.h>

#include <tgmath.h>

#include "packet.h"

#include "../defines.h"

uint8_t packet_type(prrt_packet *packet_ptr) {

    return (uint8_t) ((packet_ptr->type_priority >> 4) & 0x0F);

}

uint8_t packet_priority(prrt_packet *packet_ptr) {

    return (uint8_t) (packet_ptr->type_priority & 0x0F);

}

uint16_t packet_size(prrt_packet *packet_ptr) {

    return (uint16_t) (packet_ptr->payload_len + PRRT_PACKET_GENERAL_HEADER_SIZE); // 4 = 4bit type + 4bit priority + 8 bit index + 16bit seqno

}

int create_packet_source(prrt_packet *packet_ptr, uint8_t priority, const void * data_ptr, unsigned long data_len) {

    packet_ptr->type_priority = PACKET_TYPE_SOURCE << 4;

    packet_ptr->type_priority |= priority & 0x0F;

    prrt_packet_source_payload * payload = malloc(sizeof(prrt_packet_source_payload));

    struct timeval tv;

    gettimeofday(&tv,NULL);

    unsigned long time_in_micros = (unsigned long) (1000000 * tv.tv_sec + tv.tv_usec);

    payload->timestamp = (uint32_t) time_in_micros;

    // TODO: payload->rtt = CURRENT ESTIMATE

    // TODO: payload->packet_timeout = NOW + maximum delay

    // TODO: payload->decoding_timeout

    // TODO: payload->feedback_timer

    packet_ptr->payload = (void*) payload;

    memcpy(payload + sizeof(prrt_packet_source_payload), data_ptr, data_len);

    packet_ptr->payload_len = (uint32_t) (data_len + sizeof(prrt_packet_source_payload));

    return 0;

}

int encode_packet_source(void *buf, uint16_t buf_size, prrt_packet *packet) {

    prrt_packet_source_payload * payload = packet->payload;

    if(buf_size < packet->payload_len + PRRT_PACKET_GENERAL_HEADER_SIZE) {

        return -1;

    }

    memcpy(buf, packet, PRRT_PACKET_GENERAL_HEADER_SIZE);

    buf += PRRT_PACKET_GENERAL_HEADER_SIZE;

    memcpy(buf, payload, PRRT_PACKET_SOURCE_HEADER_SIZE);

    buf += PRRT_PACKET_SOURCE_HEADER_SIZE;

    memcpy(buf, payload + PRRT_PACKET_SOURCE_HEADER_SIZE, packet->payload_len - PRRT_PACKET_SOURCE_HEADER_SIZE);

    return 0;

}