ffi-tox 0.1.1 → 0.1.3

data/ProjectTox-Core/core/DHT.h

@@ -1,111 +0,0 @@
-/* DHT.h
- *
- * An implementation of the DHT as seen in docs/DHT.txt
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DHT_H
-#define DHT_H
-
-#include "net_crypto.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Current time, unix format */
-#define unix_time() ((uint32_t)time(NULL))
-
-/* size of the client_id in bytes */
-#define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES
-
-/* Add a new friend to the friends list
-    client_id must be CLIENT_ID_SIZE bytes long.
-    returns 0 if success
-    returns 1 if failure (friends list is full) */
-int DHT_addfriend(uint8_t *client_id);
-
-/* Delete a friend from the friends list
-    client_id must be CLIENT_ID_SIZE bytes long.
-    returns 0 if success
-    returns 1 if failure (client_id not in friends list) */
-int DHT_delfriend(uint8_t *client_id);
-
-/* Get ip of friend
-    client_id must be CLIENT_ID_SIZE bytes long.
-    ip must be 4 bytes long.
-    port must be 2 bytes long.
-    returns ip if success
-    returns ip of 0 if failure (This means the friend is either offline or we have not found him yet.)
-    returns ip of 1 if friend is not in list. */
-IP_Port DHT_getfriendip(uint8_t *client_id);
-
-/* Run this function at least a couple times per second (It's the main loop) */
-void doDHT();
-
-/* if we receive a DHT packet we call this function so it can be handled.
-    return 0 if packet is handled correctly.
-    return 1 if it didn't handle the packet or if the packet was shit. */
-int DHT_handlepacket(uint8_t *packet, uint32_t length, IP_Port source);
-
-/* Use this function to bootstrap the client
-    Sends a get nodes request to the given node with ip port and public_key */
-void DHT_bootstrap(IP_Port ip_port, uint8_t *public_key);
-
-/* ROUTING FUNCTIONS */
-
-/* send the given packet to node with client_id
-    returns -1 if failure */
-int route_packet(uint8_t *client_id, uint8_t *packet, uint32_t length);
-
-/* Send the following packet to everyone who tells us they are connected to friend_id
-    returns the number of nodes it sent the packet to */
-int route_tofriend(uint8_t *friend_id, uint8_t *packet, uint32_t length);
-
-/* NAT PUNCHING FUNCTIONS */
-
-/* Puts all the different ips returned by the nodes for a friend_id into array ip_portlist
-    ip_portlist must be at least MAX_FRIEND_CLIENTS big
-    returns the number of ips returned
-    returns -1 if no such friend*/
-int friend_ips(IP_Port *ip_portlist, uint8_t *friend_id);
-
-/* SAVE/LOAD functions */
-
-/* get the size of the DHT (for saving) */
-uint32_t DHT_size();
-
-/* save the DHT in data where data is an array of size DHT_size() */
-void DHT_save(uint8_t *data);
-
-/* load the DHT from data of size size;
-    return -1 if failure
-    return 0 if success */
-int DHT_load(uint8_t *data, uint32_t size);
-
-/* returns 0 if we are not connected to the DHT
-    returns 1 if we are */
-int DHT_isconnected();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

data/ProjectTox-Core/core/LAN_discovery.c

@@ -1,79 +0,0 @@
-/*  LAN_discovery.c
- *
- *  LAN discovery implementation.
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "LAN_discovery.h"
-
-
-/*Return the broadcast ip
-  TODO: make it return the real one, not the 255.255.255.255 one.*/
-IP broadcast_ip()
-{
-    IP ip;
-    ip.i = ~0;
-    return ip;
-}
-
-/*return 0 if ip is a LAN ip
-  return -1 if it is not */
-int LAN_ip(IP ip)
-{
-    if (ip.c[0] == 127)/* Loopback */
-        return 0;
-    if (ip.c[0] == 10)/* 10.0.0.0 to 10.255.255.255 range */
-        return 0;
-    if (ip.c[0] == 172 && ip.c[1] >= 16 && ip.c[1] <= 31)/* 172.16.0.0 to 172.31.255.255 range */
-        return 0;
-    if (ip.c[0] == 192 && ip.c[1] == 168) /* 192.168.0.0 to 192.168.255.255 range */
-        return 0;
-    if (ip.c[0] == 169 && ip.c[1] == 254 && ip.c[2] != 0 && ip.c[2] != 255)/* 169.254.1.0 to 169.254.254.255 range */
-        return 0;
-    return -1;
-}
-
-int handle_LANdiscovery(uint8_t *packet, uint32_t length, IP_Port source)
-{
-    if (LAN_ip(source.ip) == -1)
-        return 1;
-    if (length != crypto_box_PUBLICKEYBYTES + 1)
-        return 1;
-    DHT_bootstrap(source, packet + 1);
-    return 0;
-}
-
-
-int send_LANdiscovery(uint16_t port)
-{
-    uint8_t data[crypto_box_PUBLICKEYBYTES + 1];
-    data[0] = 32;
-    memcpy(data + 1, self_public_key, crypto_box_PUBLICKEYBYTES);
-    IP_Port ip_port = {broadcast_ip(), port};
-    return sendpacket(ip_port, data, 1 + crypto_box_PUBLICKEYBYTES);
-}
-
-
-int LANdiscovery_handlepacket(uint8_t *packet, uint32_t length, IP_Port source)
-{
-    if (packet[0] == 32)
-        return handle_LANdiscovery(packet, length, source);
-    return 1;
-}

data/ProjectTox-Core/core/Lossless_UDP.c

@@ -1,755 +0,0 @@
-/* Lossless_UDP.c
- *
- * An implementation of the Lossless_UDP protocol as seen in docs/Lossless_UDP.txt
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/* TODO: clean this file a bit.
-   There are a couple of useless variables to get rid of. */
-#include "Lossless_UDP.h"
-
-/* maximum data packets in sent and receive queues. */
-#define MAX_QUEUE_NUM 16
-
-/* maximum length of the data in the data packets */
-/* #define MAX_DATA_SIZE 1024 */ /* defined in Lossless_UDP.h */
-
-/* maximum number of data packets in the buffer */
-#define BUFFER_PACKET_NUM (16-1)
-
-/* Lossless UDP connection timeout.
-timeout per connection is randomly set between CONNEXION_TIMEOUT and 2*CONNEXION_TIMEOUT */
-#define CONNEXION_TIMEOUT 5
-
-/* initial amount of sync/hanshake packets to send per second. */
-#define SYNC_RATE 2
-
-/* initial send rate of data. */
-#define DATA_SYNC_RATE 30
-
-typedef struct {
-    uint8_t data[MAX_DATA_SIZE];
-    uint16_t size;
-} Data;
-
-typedef struct {
-    IP_Port ip_port;
-    uint8_t status; /* 0 if connection is dead, 1 if attempting handshake,
-                       2 if handshake is done (we start sending SYNC packets)
-                       3 if we are sending SYNC packets and can send data
-                       4 if the connection has timed out. */
-
-    uint8_t inbound; /* 1 or 2 if connection was initiated by someone else, 0 if not.
-                        2 if incoming_connection() has not returned it yet, 1 if it has. */
-
-    uint16_t SYNC_rate; /* current SYNC packet send rate packets per second. */
-    uint16_t data_rate; /* current data packet send rate packets per second. */
-    uint64_t last_SYNC; /* time at which our last SYNC packet was sent. */
-    uint64_t last_sent; /* time at which our last data or handshake packet was sent. */
-    uint64_t last_recvSYNC; /* time at which we last received a SYNC packet from the other */
-    uint64_t last_recvdata; /* time at which we last received a DATA packet from the other */
-    uint64_t killat; /* time at which to kill the connection */
-    Data sendbuffer[MAX_QUEUE_NUM]; /* packet send buffer. */
-    Data recvbuffer[MAX_QUEUE_NUM]; /* packet receive buffer. */
-    uint32_t handshake_id1;
-    uint32_t handshake_id2;
-    uint32_t recv_packetnum; /* number of data packets received (also used as handshake_id1) */
-    uint32_t orecv_packetnum; /* number of packets received by the other peer */
-    uint32_t sent_packetnum; /* number of data packets sent */
-    uint32_t osent_packetnum; /* number of packets sent by the other peer. */
-    uint32_t sendbuff_packetnum; /* number of latest packet written onto the sendbuffer */
-    uint32_t successful_sent; /* we know all packets before that number were successfully sent */
-    uint32_t successful_read; /* packet number of last packet read with the read_packet function */
-    uint32_t req_packets[BUFFER_PACKET_NUM]; /* list of currently requested packet numbers(by the other person) */
-    uint16_t num_req_paquets;  /* total number of currently requested packets(by the other person) */
-    uint8_t recv_counter;
-    uint8_t send_counter;
-    uint8_t timeout; /* connection timeout in seconds. */
-} Connection;
-
-
-static Connection * connections;
-
-static uint32_t connections_length; /* Length of connections array */
-static uint32_t connections_number; /* Number of connections in connections array */
-
-#define MAX_CONNECTIONS connections_length
-
-/* Functions */
-
-/* get connection id from IP_Port
-   return -1 if there are no connections like we are looking for
-   return id if it found it */
-int getconnection_id(IP_Port ip_port)
-{
-    uint32_t i;
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if (connections[i].ip_port.ip.i == ip_port.ip.i &&
-            connections[i].ip_port.port == ip_port.port && connections[i].status > 0)
-            return i;
-    }
-    return -1;
-}
-
-/* table of random numbers used below. */
-static uint32_t randtable[6][256];
-
-/* generate a handshake_id which depends on the ip_port.
-   this function will always give one unique handshake_id per ip_port.
-   TODO: make this better */
-uint32_t handshake_id(IP_Port source)
-{
-    uint32_t id = 0, i;
-    for (i = 0; i < 6; ++i) {
-        if(randtable[i][((uint8_t *)&source)[i]] == 0)
-            randtable[i][((uint8_t *)&source)[i]] = random_int();
-        id ^= randtable[i][((uint8_t *)&source)[i]];
-    }
-    if (id == 0) /* id can't be zero */
-        id = 1;
-    return id;
-}
-
-/* change the hnshake id associated with that ip_port
-   TODO: make this better */
-void change_handshake(IP_Port source)
-{
-    uint8_t rand = random_int() % 4;
-    randtable[rand][((uint8_t *)&source)[rand]] = random_int();
-}
-
-/* initialize a new connection to ip_port
-   returns an integer corresponding to the connection id.
-   return -1 if it could not initialize the connection.
-   if there already was an existing connection to that ip_port return its number. */
-int new_connection(IP_Port ip_port)
-{
-    int connect = getconnection_id(ip_port);
-    if (connect != -1)
-        return connect;
-    
-    if(connections_number == connections_length) {
-        Connection * temp;
-        temp = realloc(connections, sizeof(Connection) * (connections_length + 1));
-        if(temp == NULL)
-            return -1;
-        memset(&temp[connections_length], 0, sizeof(Connection));
-        ++connections_length;
-        connections = temp;
-    }
-    
-    uint32_t i;
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if(connections[i].status == 0) {
-            memset(&connections[i], 0, sizeof(Connection));
-            connections[i].ip_port = ip_port;
-            connections[i].status = 1;
-            connections[i].inbound = 0;
-            connections[i].handshake_id1 = handshake_id(ip_port);
-            connections[i].sent_packetnum = connections[i].handshake_id1;
-            connections[i].sendbuff_packetnum = connections[i].handshake_id1;
-            connections[i].successful_sent = connections[i].handshake_id1;
-            connections[i].SYNC_rate = SYNC_RATE;
-            connections[i].data_rate = DATA_SYNC_RATE;
-            connections[i].last_recvSYNC = current_time();
-            connections[i].last_sent = current_time();
-            connections[i].killat = ~0;
-            connections[i].send_counter = 0;
-            /* add randomness to timeout to prevent connections getting stuck in a loop. */
-            connections[i].timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
-            ++connections_number;
-            return i;
-        }
-    }
-    return -1;
-}
-
-/* initialize a new inbound connection from ip_port
-   returns an integer corresponding to the connection id.
-   return -1 if it could not initialize the connection. */
-int new_inconnection(IP_Port ip_port)
-{
-    if (getconnection_id(ip_port) != -1)
-        return -1;
-    
-    if(connections_number == connections_length) {
-        Connection * temp;
-        temp = realloc(connections, sizeof(Connection) * (connections_length + 1));
-        if(temp == NULL)
-            return -1;
-        memset(&temp[connections_length], 0, sizeof(Connection));
-        ++connections_length;
-        connections = temp;
-    }
-    
-    uint32_t i;
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if (connections[i].status == 0) {
-            memset(&connections[i], 0, sizeof(Connection));
-            connections[i].ip_port = ip_port;
-            connections[i].status = 2;
-            connections[i].inbound = 2;
-            connections[i].SYNC_rate = SYNC_RATE;
-            connections[i].data_rate = DATA_SYNC_RATE;
-            connections[i].last_recvSYNC = current_time();
-            connections[i].last_sent = current_time();
-            /* add randomness to timeout to prevent connections getting stuck in a loop. */
-            connections[i].timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
-            /* if this connection isn't handled within the timeout kill it. */
-            connections[i].killat = current_time() + 1000000UL*connections[i].timeout;
-            connections[i].send_counter = 127;
-            ++connections_number;
-            return i;
-        }
-    }
-    return -1;
-}
-
-/* returns an integer corresponding to the next connection in our incoming connection list
-   return -1 if there are no new incoming connections in the list. */
-int incoming_connection()
-{
-    uint32_t i;
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if (connections[i].inbound == 2) {
-            connections[i].inbound = 1;
-            return i;
-        }
-    }
-    return -1;
-}
-/*Try to free some memory from the connections array.*/
-static void free_connections()
-{
-    uint32_t i;
-    for(i = connections_length; i != 0; --i)
-        if (connections[i - 1].status != 0)
-            break;
-
-    if(connections_length == i)
-        return;
-    Connection * temp;
-    temp = realloc(connections, sizeof(Connection) * i);
-    if(temp == NULL && i != 0)
-        return;
-    connections = temp;
-    connections_length = i;
-}
-
-/* return -1 if it could not kill the connection.
-   return 0 if killed successfully */
-int kill_connection(int connection_id)
-{
-    if (connection_id >= 0 && connection_id < MAX_CONNECTIONS) {
-        if (connections[connection_id].status > 0) {
-            connections[connection_id].status = 0;
-            change_handshake(connections[connection_id].ip_port);
-            --connections_number;
-            free_connections();
-            return 0;
-        }
-    }
-    return -1;
-}
-
-/* kill connection in seconds seconds.
-   return -1 if it can not kill the connection.
-   return 0 if it will kill it */
-int kill_connection_in(int connection_id, uint32_t seconds)
-{
-    if (connection_id >= 0 && connection_id < MAX_CONNECTIONS) {
-        if (connections[connection_id].status > 0) {
-            connections[connection_id].killat = current_time() + 1000000UL*seconds;
-            return 0;
-        }
-    }
-    return -1;
-}
-
-/* check if connection is connected
-   return 0 no.
-   return 1 if attempting handshake
-   return 2 if handshake is done
-   return 3 if fully connected
-   return 4 if timed out and waiting to be killed */
-int is_connected(int connection_id)
-{
-    if (connection_id >= 0 && connection_id < MAX_CONNECTIONS)
-        return connections[connection_id].status;
-    return 0;
-}
-
-/* returns the ip_port of the corresponding connection. */
-IP_Port connection_ip(int connection_id)
-{
-    if (connection_id >= 0 && connection_id < MAX_CONNECTIONS)
-        return connections[connection_id].ip_port;
-    IP_Port zero = {{{0}}, 0};
-    return zero;
-}
-
-/* returns the number of packets in the queue waiting to be successfully sent. */
-uint32_t sendqueue(int connection_id)
-{
-    if (connection_id < 0 || connection_id >= MAX_CONNECTIONS)
-        return 0;
-    return connections[connection_id].sendbuff_packetnum - connections[connection_id].successful_sent;
-}
-
-/* returns the number of packets in the queue waiting to be successfully read with read_packet(...) */
-uint32_t recvqueue(int connection_id)
-{
-    if (connection_id < 0 || connection_id >= MAX_CONNECTIONS)
-        return 0;
-    return connections[connection_id].recv_packetnum - connections[connection_id].successful_read;
-}
-
-/* returns the id of the next packet in the queue
-   return -1 if no packet in queue */
-char id_packet(int connection_id)
-{
-    if (connection_id < 0 || connection_id >= MAX_CONNECTIONS)
-        return -1;
-    if (recvqueue(connection_id) != 0 && connections[connection_id].status != 0)
-        return connections[connection_id].recvbuffer[connections[connection_id].successful_read % MAX_QUEUE_NUM].data[0];
-    return -1;
-}
-
-/* return 0 if there is no received data in the buffer.
-   return length of received packet if successful */
-int read_packet(int connection_id, uint8_t * data)
-{
-    if (recvqueue(connection_id) != 0) {
-        uint16_t index = connections[connection_id].successful_read % MAX_QUEUE_NUM;
-        uint16_t size = connections[connection_id].recvbuffer[index].size;
-        memcpy(data, connections[connection_id].recvbuffer[index].data, size);
-        ++connections[connection_id].successful_read;
-        connections[connection_id].recvbuffer[index].size = 0;
-        return size;
-    }
-    return 0;
-}
-
-/* return 0 if data could not be put in packet queue
-   return 1 if data was put into the queue */
-int write_packet(int connection_id, uint8_t * data, uint32_t length)
-{
-    if (length > MAX_DATA_SIZE)
-        return 0;
-    if (length == 0)
-        return 0;
-    if (sendqueue(connection_id) <  BUFFER_PACKET_NUM) {
-        uint32_t index = connections[connection_id].sendbuff_packetnum % MAX_QUEUE_NUM;
-        memcpy(connections[connection_id].sendbuffer[index].data, data, length);
-        connections[connection_id].sendbuffer[index].size = length;
-        connections[connection_id].sendbuff_packetnum++;
-        return 1;
-    }
-    return 0;
-}
-
-/* put the packet numbers the we are missing in requested and return the number */
-uint32_t missing_packets(int connection_id, uint32_t * requested)
-{
-    uint32_t number = 0;
-    uint32_t i;
-    uint32_t temp;
-    if (recvqueue(connection_id) >= (BUFFER_PACKET_NUM - 1)) /* don't request packets if the buffer is full. */
-        return 0;
-    for (i = connections[connection_id].recv_packetnum; i != connections[connection_id].osent_packetnum; i++) {
-        if(connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
-            temp = htonl(i);
-            memcpy(requested + number, &temp, 4);
-            ++number;
-        }
-    }
-    if(number == 0)
-        connections[connection_id].recv_packetnum = connections[connection_id].osent_packetnum;
-    return number;
-}
-
-/* Packet sending functions
-  One per packet type.
-  see docs/Lossless_UDP.txt for more information. */
-int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t handshake_id2)
-{
-    uint8_t packet[1 + 4 + 4];
-    uint32_t temp;
-
-    packet[0] = 16;
-    temp = htonl(handshake_id1);
-    memcpy(packet + 1, &temp, 4);
-    temp = htonl(handshake_id2);
-    memcpy(packet + 5, &temp, 4);
-    return sendpacket(ip_port, packet, sizeof(packet));
-}
-
-int send_SYNC(uint32_t connection_id)
-{
-
-    uint8_t packet[(BUFFER_PACKET_NUM*4 + 4 + 4 + 2)];
-    uint16_t index = 0;
-
-    IP_Port ip_port = connections[connection_id].ip_port;
-    uint8_t counter = connections[connection_id].send_counter;
-    uint32_t recv_packetnum = htonl(connections[connection_id].recv_packetnum);
-    uint32_t sent_packetnum = htonl(connections[connection_id].sent_packetnum);
-    uint32_t requested[BUFFER_PACKET_NUM];
-    uint32_t number = missing_packets(connection_id, requested);
-
-    packet[0] = 17;
-    index += 1;
-    memcpy(packet + index, &counter, 1);
-    index += 1;
-    memcpy(packet + index, &recv_packetnum, 4);
-    index += 4;
-    memcpy(packet + index, &sent_packetnum, 4);
-    index += 4;
-    memcpy(packet + index, requested, 4 * number);
-
-    return sendpacket(ip_port, packet, (number*4 + 4 + 4 + 2));
-
-}
-
-int send_data_packet(uint32_t connection_id, uint32_t packet_num)
-{
-    uint32_t index = packet_num % MAX_QUEUE_NUM;
-    uint32_t temp;
-    uint8_t packet[1 + 4 + MAX_DATA_SIZE];
-    packet[0] = 18;
-    temp = htonl(packet_num);
-    memcpy(packet + 1, &temp, 4);
-    memcpy(packet + 5, connections[connection_id].sendbuffer[index].data,
-           connections[connection_id].sendbuffer[index].size);
-    return sendpacket(connections[connection_id].ip_port, packet,
-                      1 + 4 + connections[connection_id].sendbuffer[index].size);
-}
-
-/* sends 1 data packet */
-int send_DATA(uint32_t connection_id)
-{
-    int ret;
-    uint32_t buffer[BUFFER_PACKET_NUM];
-    if (connections[connection_id].num_req_paquets > 0) {
-        ret = send_data_packet(connection_id, connections[connection_id].req_packets[0]);
-        connections[connection_id].num_req_paquets--;
-        memcpy(buffer, connections[connection_id].req_packets + 1, connections[connection_id].num_req_paquets * 4);
-        memcpy(connections[connection_id].req_packets, buffer, connections[connection_id].num_req_paquets * 4);
-        return ret;
-    }
-    if (connections[connection_id].sendbuff_packetnum != connections[connection_id].sent_packetnum) {
-        ret = send_data_packet(connection_id, connections[connection_id].sent_packetnum);
-        connections[connection_id].sent_packetnum++;
-        return ret;
-    }
-    return 0;
-}
-
-/* END of packet sending functions */
-
-/* Packet handling functions
-   One to handle each type of packets we receive
-   return 0 if handled correctly, 1 if packet is bad. */
-int handle_handshake(uint8_t * packet, uint32_t length, IP_Port source)
-{
-    if (length != (1 + 4 + 4))
-        return 1;
-    uint32_t temp;
-    uint32_t handshake_id1, handshake_id2;
-    int connection = getconnection_id(source);
-    memcpy(&temp, packet + 1, 4);
-    handshake_id1 = ntohl(temp);
-    memcpy(&temp, packet + 5, 4);
-    handshake_id2 = ntohl(temp);
-
-    if (handshake_id2 == 0 && is_connected(connection) < 3) {
-        send_handshake(source, handshake_id(source), handshake_id1);
-        return 0;
-    }
-    if (is_connected(connection) != 1)
-        return 1;
-    if (handshake_id2 == connections[connection].handshake_id1) { /* if handshake_id2 is what we sent previously as handshake_id1 */
-        connections[connection].status = 2;
-        /* NOTE: is this necessary?
-        connections[connection].handshake_id2 = handshake_id1; */
-        connections[connection].orecv_packetnum = handshake_id2;
-        connections[connection].osent_packetnum = handshake_id1;
-        connections[connection].recv_packetnum = handshake_id1;
-        connections[connection].successful_read = handshake_id1;
-    }
-    return 0;
-
-}
-
-/* returns 1 if sync packet is valid
-   0 if not. */
-int SYNC_valid(uint32_t length)
-{
-    if (length < 4 + 4 + 2)
-        return 0;
-    if (length > (BUFFER_PACKET_NUM*4 + 4 + 4 + 2) ||
-        ((length - 4 - 4 - 2) % 4) != 0)
-        return 0;
-    return 1;
-}
-
-/* case 1: */
-int handle_SYNC1(IP_Port source, uint32_t recv_packetnum, uint32_t sent_packetnum)
-{
-    if (handshake_id(source) == recv_packetnum) {
-        int x = new_inconnection(source);
-        if (x != -1) {
-            connections[x].orecv_packetnum = recv_packetnum;
-            connections[x].sent_packetnum = recv_packetnum;
-            connections[x].sendbuff_packetnum = recv_packetnum;
-            connections[x].successful_sent = recv_packetnum;
-            connections[x].osent_packetnum = sent_packetnum;
-            connections[x].recv_packetnum = sent_packetnum;
-            connections[x].successful_read = sent_packetnum;
-
-            return x;
-        }
-    }
-    return -1;
-}
-
-/* case 2: */
-int handle_SYNC2(int connection_id, uint8_t counter, uint32_t recv_packetnum, uint32_t sent_packetnum)
-{
-    if (recv_packetnum == connections[connection_id].orecv_packetnum) {
-        /* && sent_packetnum == connections[connection_id].osent_packetnum) */
-        connections[connection_id].status =  3;
-        connections[connection_id].recv_counter = counter;
-        ++connections[connection_id].send_counter;
-        send_SYNC(connection_id);
-        return 0;
-    }
-    return 1;
-}
-/* case 3: */
-int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packetnum, uint32_t sent_packetnum, uint32_t * req_packets,
-                 uint16_t number)
-{
-    uint8_t comp_counter = (counter - connections[connection_id].recv_counter );
-    uint32_t i, temp;
-    /* uint32_t comp_1 = (recv_packetnum - connections[connection_id].successful_sent);
-       uint32_t comp_2 = (sent_packetnum - connections[connection_id].successful_read); */
-    uint32_t comp_1 = (recv_packetnum - connections[connection_id].orecv_packetnum);
-    uint32_t comp_2 = (sent_packetnum - connections[connection_id].osent_packetnum);
-    if (comp_1 <= BUFFER_PACKET_NUM && comp_2 <= BUFFER_PACKET_NUM && comp_counter < 10 && comp_counter != 0) { /* packet valid */
-        connections[connection_id].orecv_packetnum = recv_packetnum;
-        connections[connection_id].osent_packetnum = sent_packetnum;
-        connections[connection_id].successful_sent = recv_packetnum;
-        connections[connection_id].last_recvSYNC = current_time();
-        connections[connection_id].recv_counter = counter;
-        ++connections[connection_id].send_counter;
-        for (i = 0; i < number; ++i) {
-            temp = ntohl(req_packets[i]);
-            memcpy(connections[connection_id].req_packets + i, &temp, 4 * number);
-        }
-        connections[connection_id].num_req_paquets = number;
-        return 0;
-    }
-    return 1;
-}
-
-int handle_SYNC(uint8_t *packet, uint32_t length, IP_Port source)
-{
-
-    if (!SYNC_valid(length))
-        return 1;
-    int connection = getconnection_id(source);
-    uint8_t counter;
-    uint32_t temp;
-    uint32_t recv_packetnum, sent_packetnum;
-    uint32_t req_packets[BUFFER_PACKET_NUM];
-    uint16_t number = (length - 4 - 4 - 2)/ 4;
-
-    memcpy(&counter, packet + 1, 1);
-    memcpy(&temp, packet + 2, 4);
-    recv_packetnum = ntohl(temp);
-    memcpy(&temp,packet + 6,  4);
-    sent_packetnum = ntohl(temp);
-    if (number != 0)
-        memcpy(req_packets, packet + 10,  4 * number);
-    if (connection == -1)
-        return handle_SYNC1(source, recv_packetnum, sent_packetnum);
-    if (connections[connection].status ==  2)
-        return handle_SYNC2(connection, counter, recv_packetnum, sent_packetnum);
-    if (connections[connection].status ==  3)
-        return handle_SYNC3(connection, counter, recv_packetnum, sent_packetnum, req_packets, number);
-    return 0;
-}
-
-/* add a packet to the received buffer and set the recv_packetnum of the connection to its proper value.
-   return 1 if data was too big, 0 if not. */
-int add_recv(int connection_id, uint32_t data_num, uint8_t *data, uint16_t size)
-{
-    if (size > MAX_DATA_SIZE)
-        return 1;
-
-    uint32_t i;
-    uint32_t maxnum = connections[connection_id].successful_read + BUFFER_PACKET_NUM;
-    uint32_t sent_packet = data_num - connections[connection_id].osent_packetnum;
-    for (i = connections[connection_id].recv_packetnum; i != maxnum; ++i) {
-        if (i == data_num) {
-            memcpy(connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].data, data, size);
-            connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size = size;
-            connections[connection_id].last_recvdata = current_time();
-            if (sent_packet < BUFFER_PACKET_NUM)
-                connections[connection_id].osent_packetnum = data_num;
-            break;
-        }
-    }
-    for (i = connections[connection_id].recv_packetnum; i != maxnum; ++i) {
-        if (connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size != 0)
-            connections[connection_id].recv_packetnum = i;
-        else
-            break;
-    }
-
-    return 0;
-}
-
-int handle_data(uint8_t *packet, uint32_t length, IP_Port source)
-{
-    int connection = getconnection_id(source);
-
-    if (connection == -1)
-        return 1;
-
-    if (connections[connection].status != 3) /* Drop the data packet if connection is not connected. */
-        return 1;
-
-    if (length > 1 + 4 + MAX_DATA_SIZE || length < 1 + 4 + 1)
-        return 1;
-    uint32_t temp;
-    uint32_t number;
-    uint16_t size = length - 1 - 4;
-
-    memcpy(&temp, packet + 1, 4);
-    number = ntohl(temp);
-    return add_recv(connection, number, packet + 5, size);
-}
-
-/* END of packet handling functions */
-
-int LosslessUDP_handlepacket(uint8_t *packet, uint32_t length, IP_Port source)
-{
-    switch (packet[0]) { //TODO: check if no break statement is correct???
-    case 16:
-        return handle_handshake(packet, length, source);
-
-    case 17:
-        return handle_SYNC(packet, length, source);
-
-    case 18:
-        return handle_data(packet, length, source);
-
-    default:
-        return 1;
-    }
-
-    return 0;
-}
-
-/* Send handshake requests
-   handshake packets are sent at the same rate as SYNC packets */
-void doNew()
-{
-    uint32_t i;
-    uint64_t temp_time = current_time();
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if (connections[i].status == 1)
-            if ((connections[i].last_sent + (1000000UL/connections[i].SYNC_rate)) <= temp_time) {
-                send_handshake(connections[i].ip_port, connections[i].handshake_id1, 0);
-                connections[i].last_sent = temp_time;
-            }
-
-        /* kill all timed out connections */
-        if ( connections[i].status > 0 && (connections[i].last_recvSYNC + connections[i].timeout * 1000000UL) < temp_time &&
-             connections[i].status != 4)
-            /* kill_connection(i); */
-            connections[i].status = 4;
-        if (connections[i].status > 0 && connections[i].killat < temp_time)
-            kill_connection(i);
-    }
-}
-
-void doSYNC()
-{
-    uint32_t i;
-    uint64_t temp_time = current_time();
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if (connections[i].status == 2 || connections[i].status == 3)
-            if ((connections[i].last_SYNC + (1000000UL/connections[i].SYNC_rate)) <= temp_time) {
-                send_SYNC(i);
-                connections[i].last_SYNC = temp_time;
-            }
-    }
-}
-
-void doData()
-{
-    uint32_t i;
-    uint64_t j;
-    uint64_t temp_time = current_time();
-    for (i = 0; i < MAX_CONNECTIONS; ++i)
-        if (connections[i].status == 3 && sendqueue(i) != 0)
-            if ((connections[i].last_sent + (1000000UL/connections[i].data_rate)) <= temp_time) {
-                for (j = connections[i].last_sent; j < temp_time; j +=  (1000000UL/connections[i].data_rate))
-                    send_DATA(i);
-                connections[i].last_sent = temp_time;
-            }
-}
-
-/* TODO: flow control.
-   automatically adjusts send rates of packets for optimal transmission. */
-
-#define MAX_SYNC_RATE 10
-
-void adjustRates()
-{
-    uint32_t i;
-    uint64_t temp_time = current_time();
-    for (i = 0; i < MAX_CONNECTIONS; ++i) {
-        if (connections[i].status == 1 || connections[i].status == 2)
-            connections[i].SYNC_rate = MAX_SYNC_RATE;
-        if (connections[i].status == 3) {
-            if (sendqueue(i) != 0) {
-                connections[i].data_rate = (BUFFER_PACKET_NUM - connections[i].num_req_paquets) * MAX_SYNC_RATE;
-                connections[i].SYNC_rate = MAX_SYNC_RATE;
-            } else if (connections[i].last_recvdata + 1000000UL > temp_time)
-                connections[i].SYNC_rate = MAX_SYNC_RATE;
-            else
-                connections[i].SYNC_rate = SYNC_RATE;
-        }
-    }
-}
-
-/* Call this function a couple times per second
-   It's the main loop. */
-void doLossless_UDP()
-{
-    doNew();
-    doSYNC();
-    doData();
-    adjustRates();
-}