Fixed conflicts

14 files changed, 422 insertions, 124 deletions

diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index e1b8534c..420c490d 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -30,11 +30,72 @@
 
 #define MAX_INTERFACES 16
 
-#ifdef __linux
 
 static int     broadcast_count = -1;
 static IP_Port broadcast_ip_port[MAX_INTERFACES];
 
+#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+
+#include <iphlpapi.h>
+
+static void fetch_broadcast_info(uint16_t port)
+{
+    broadcast_count = 0;
+
+    IP_ADAPTER_INFO *pAdapterInfo = malloc(sizeof(pAdapterInfo));
+    unsigned long ulOutBufLen = sizeof(pAdapterInfo);
+
+    if (pAdapterInfo == NULL) {
+        printf("Error allocating memory for pAdapterInfo\n");
+        return;
+    }
+
+    if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
+        free(pAdapterInfo);
+        pAdapterInfo = malloc(ulOutBufLen);
+
+        if (pAdapterInfo == NULL) {
+            printf("Error allocating memory needed to call GetAdaptersinfo\n");
+            return;
+        }
+    }
+
+    int ret;
+
+    if ((ret = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) {
+        IP_ADAPTER_INFO *pAdapter = pAdapterInfo;
+
+        while (pAdapter) {
+            IP gateway = {0}, subnet_mask = {0};
+
+            if (addr_parse_ip(pAdapter->IpAddressList.IpMask.String, &subnet_mask)
+                    && addr_parse_ip(pAdapter->GatewayList.IpAddress.String, &gateway)) {
+                if (gateway.family == AF_INET && subnet_mask.family == AF_INET) {
+                    IP_Port *ip_port = &broadcast_ip_port[broadcast_count];
+                    ip_port->ip.family = AF_INET;
+                    uint32_t gateway_ip = ntohl(gateway.ip4.uint32), subnet_ip = ntohl(subnet_mask.ip4.uint32);
+                    uint32_t broadcast_ip = gateway_ip + ~subnet_ip - 1;
+                    ip_port->ip.ip4.uint32 = htonl(broadcast_ip);
+                    ip_port->port = port;
+                    broadcast_count++;
+                    printf("broadcast ip: %s\n", ip_ntoa(&ip_port->ip));
+
+                    if (broadcast_count >= MAX_INTERFACES) {
+                        return;
+                    }
+                }
+            }
+
+            pAdapter = pAdapter->Next;
+        }
+    } else {
+        printf("Fetching adapter info failed %i\n", ret);
+    }
+
+}
+
+#elif defined(__linux__)
+
 static void fetch_broadcast_info(uint16_t port)
 {
     /* Not sure how many platforms this will run on,
@@ -93,6 +154,14 @@ static void fetch_broadcast_info(uint16_t port)
     close(sock);
 }
 
+#else //TODO: Other platforms?
+
+static void fetch_broadcast_info(uint16_t port)
+{
+    broadcast_count = 0;
+}
+
+#endif
 /* Send packet to all IPv4 broadcast addresses
  *
  *  return 1 if sent to at least one broadcast target.
@@ -115,7 +184,6 @@ static uint32_t send_broadcasts(Networking_Core *net, uint16_t port, const uint8
 
     return 1;
 }
-#endif /* __linux */
 
 /* Return the broadcast ip. */
 static IP broadcast_ip(sa_family_t family_socket, sa_family_t family_broadcast)
@@ -228,9 +296,8 @@ int send_LANdiscovery(uint16_t port, DHT *dht)
     data[0] = NET_PACKET_LAN_DISCOVERY;
     id_copy(data + 1, dht->self_public_key);
 
-#ifdef __linux
     send_broadcasts(dht->net, port, data, 1 + crypto_box_PUBLICKEYBYTES);
-#endif
+
     int res = -1;
     IP_Port ip_port;
     ip_port.port = port;
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 4344fdcb..b65f09ae 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -1206,8 +1206,10 @@ int join_groupchat(Messenger *m, int32_t friendnumber, const uint8_t *friend_gro
 
     IP_Port friend_ip = get_friend_ipport(m, friendnumber);
 
-    if (friend_ip.ip.family == 0)
+    if (friend_ip.ip.family == 0) {
+        del_groupchat(m, groupnum);
         return -1;
+    }
 
     id_copy(data, friend_group_public_key);
     id_copy(data + crypto_box_PUBLICKEYBYTES, m->chats[groupnum]->self_public_key);
@@ -1218,6 +1220,7 @@ int join_groupchat(Messenger *m, int32_t friendnumber, const uint8_t *friend_gro
         return groupnum;
     }
 
+    del_groupchat(m, groupnum);
     return -1;
 }
 
@@ -2598,6 +2601,10 @@ static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length)
 
         if (temp.status >= 3) {
             int fnum = m_addfriend_norequest(m, temp.client_id);
+
+            if (fnum < 0)
+                continue;
+
             setfriendname(m, fnum, temp.name, ntohs(temp.name_length));
             set_friend_statusmessage(m, fnum, temp.statusmessage, ntohs(temp.statusmessage_length));
             set_friend_userstatus(m, fnum, temp.userstatus);
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index 087188f7..45220538 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -109,7 +109,7 @@ static int handle_handshake(TCP_Client_Connection *TCP_conn, const uint8_t *data
 /* return 0 if pending data was sent completely
  * return -1 if it wasn't
  */
-static int send_pending_data(TCP_Client_Connection *con)
+static int send_pending_data_nonpriority(TCP_Client_Connection *con)
 {
     if (con->last_packet_length == 0) {
         return 0;
@@ -127,24 +127,95 @@ static int send_pending_data(TCP_Client_Connection *con)
         return 0;
     }
 
-    if (len > left)
+    con->last_packet_sent += len;
+    return -1;
+}
+
+/* return 0 if pending data was sent completely
+ * return -1 if it wasn't
+ */
+static int send_pending_data(TCP_Client_Connection *con)
+{
+    /* finish sending current non-priority packet */
+    if (send_pending_data_nonpriority(con) == -1) {
         return -1;
+    }
+
+    TCP_Priority_List *p = con->priority_queue_start;
+
+    while (p) {
+        uint16_t left = p->size - p->sent;
+        int len = send(con->sock, p->data + p->sent, left, MSG_NOSIGNAL);
+
+        if (len != left) {
+            if (len > 0) {
+                p->sent += len;
+            }
+
+            break;
+        }
+
+        TCP_Priority_List *pp = p;
+        p = p->next;
+        free(pp);
+    }
+
+    con->priority_queue_start = p;
+
+    if (!p) {
+        con->priority_queue_end = NULL;
+        return 0;
+    }
 
-    con->last_packet_sent += len;
     return -1;
 }
 
+/* return 0 on failure (only if malloc fails)
+ * return 1 on success
+ */
+static _Bool add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
+{
+    TCP_Priority_List *p = con->priority_queue_end, *new;
+    new = malloc(sizeof(TCP_Priority_List) + size);
+
+    if (!new) {
+        return 0;
+    }
+
+    new->next = NULL;
+    new->size = size;
+    new->sent = sent;
+    memcpy(new->data, packet, size);
+
+    if (p) {
+        p->next = new;
+    } else {
+        con->priority_queue_start = new;
+    }
+
+    con->priority_queue_end = new;
+    return 1;
+}
+
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length)
+static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
+        _Bool priority)
 {
     if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
         return -1;
 
-    if (send_pending_data(con) == -1)
-        return 0;
+    _Bool sendpriority = 1;
+
+    if (send_pending_data(con) == -1) {
+        if (priority) {
+            sendpriority = 0;
+        } else {
+            return 0;
+        }
+    }
 
     uint8_t packet[sizeof(uint16_t) + length + crypto_box_MACBYTES];
 
@@ -155,17 +226,33 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
     if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t)))
         return -1;
 
-    increment_nonce(con->sent_nonce);
+    if (priority) {
+        len = sendpriority ? send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL) : 0;
 
-    len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
+        if (len <= 0) {
+            len = 0;
+        }
 
-    if ((unsigned int)len == sizeof(packet))
-        return 1;
+        increment_nonce(con->sent_nonce);
+
+        if (len == sizeof(packet)) {
+            return 1;
+        }
+
+        return add_priority(con, packet, sizeof(packet), len);
+    }
+
+    len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
 
     if (len <= 0)
         return 0;
 
-    memcpy(con->last_packet, packet, length);
+    increment_nonce(con->sent_nonce);
+
+    if ((unsigned int)len == sizeof(packet))
+        return 1;
+
+    memcpy(con->last_packet, packet, sizeof(packet));
     con->last_packet_length = sizeof(packet);
     con->last_packet_sent = len;
     return 1;
@@ -180,7 +267,7 @@ int send_routing_request(TCP_Client_Connection *con, uint8_t *public_key)
     uint8_t packet[1 + crypto_box_PUBLICKEYBYTES];
     packet[0] = TCP_PACKET_ROUTING_REQUEST;
     memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
 }
 
 void routing_response_handler(TCP_Client_Connection *con, int (*response_callback)(void *object, uint8_t connection_id,
@@ -197,6 +284,9 @@ void routing_status_handler(TCP_Client_Connection *con, int (*status_callback)(v
     con->status_callback_object = object;
 }
 
+static int send_ping_response(TCP_Client_Connection *con);
+static int send_ping_request(TCP_Client_Connection *con);
+
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure.
@@ -209,10 +299,13 @@ int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, u
     if (con->connections[con_id].status != 2)
         return -1;
 
+    if (send_ping_response(con) == 0 || send_ping_request(con) == 0)
+        return 0;
+
     uint8_t packet[1 + length];
     packet[0] = con_id + NUM_RESERVED_PORTS;
     memcpy(packet + 1, data, length);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0);
 }
 
 /* return 1 on success.
@@ -228,7 +321,7 @@ int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const
     packet[0] = TCP_PACKET_OOB_SEND;
     memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
     memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, data, length);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0);
 }
 
 
@@ -274,31 +367,49 @@ static int send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
     uint8_t packet[1 + 1];
     packet[0] = TCP_PACKET_DISCONNECT_NOTIFICATION;
     packet[1] = id;
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
 }
 
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_ping_request(TCP_Client_Connection *con, uint64_t ping_id)
+static int send_ping_request(TCP_Client_Connection *con)
 {
+    if (!con->ping_request_id)
+        return 1;
+
     uint8_t packet[1 + sizeof(uint64_t)];
     packet[0] = TCP_PACKET_PING;
-    memcpy(packet + 1, &ping_id, sizeof(uint64_t));
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    memcpy(packet + 1, &con->ping_request_id, sizeof(uint64_t));
+    int ret;
+
+    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
+        con->ping_request_id = 0;
+    }
+
+    return ret;
 }
 
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_ping_response(TCP_Client_Connection *con, uint64_t ping_id)
+static int send_ping_response(TCP_Client_Connection *con)
 {
+    if (!con->ping_response_id)
+        return 1;
+
     uint8_t packet[1 + sizeof(uint64_t)];
     packet[0] = TCP_PACKET_PONG;
-    memcpy(packet + 1, &ping_id, sizeof(uint64_t));
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    memcpy(packet + 1, &con->ping_response_id, sizeof(uint64_t));
+    int ret;
+
+    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
+        con->ping_response_id = 0;
+    }
+
+    return ret;
 }
 
 /* return 1 on success.
@@ -324,7 +435,7 @@ int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t
     uint8_t packet[1 + length];
     packet[0] = TCP_PACKET_ONION_REQUEST;
     memcpy(packet + 1, data, length);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0);
 }
 
 void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
@@ -427,7 +538,7 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
             uint8_t con_id = data[1] - NUM_RESERVED_PORTS;
 
             if (conn->connections[con_id].status != 1)
-                return -1;
+                return 0;
 
             conn->connections[con_id].status = 2;
 
@@ -451,7 +562,7 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
                 return 0;
 
             if (conn->connections[con_id].status != 2)
-                return -1;
+                return 0;
 
             conn->connections[con_id].status = 1;
 
@@ -468,7 +579,8 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
 
             uint64_t ping_id;
             memcpy(&ping_id, data + 1, sizeof(uint64_t));
-            send_ping_response(conn, ping_id);
+            conn->ping_response_id = ping_id;
+            send_ping_response(conn);
             return 0;
         }
 
@@ -523,6 +635,9 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
 static int do_confirmed_TCP(TCP_Client_Connection *conn)
 {
     send_pending_data(conn);
+    send_ping_response(conn);
+    send_ping_request(conn);
+
     uint8_t packet[MAX_PACKET_SIZE];
     int len;
 
@@ -532,16 +647,9 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn)
         if (!ping_id)
             ++ping_id;
 
-        int ret = send_ping_request(conn, ping_id);
-
-        if (ret == 1) {
-            conn->last_pinged = unix_time();
-            conn->ping_id = ping_id;
-        } else {
-            if (is_timeout(conn->last_pinged, TCP_PING_FREQUENCY + TCP_PING_TIMEOUT)) {
-                conn->status = TCP_CLIENT_DISCONNECTED;
-            }
-        }
+        conn->ping_request_id = conn->ping_id = ping_id;
+        send_ping_request(conn);
+        conn->last_pinged = unix_time();
     }
 
     if (conn->ping_id && is_timeout(conn->last_pinged, TCP_PING_TIMEOUT)) {
diff --git a/toxcore/TCP_client.h b/toxcore/TCP_client.h
index 2622b4f7..9998d20c 100644
--- a/toxcore/TCP_client.h
+++ b/toxcore/TCP_client.h
@@ -52,11 +52,16 @@ typedef struct  {
     uint16_t last_packet_length;
     uint16_t last_packet_sent;
 
+    TCP_Priority_List *priority_queue_start, *priority_queue_end;
+
     uint64_t kill_at;
 
     uint64_t last_pinged;
     uint64_t ping_id;
 
+    uint64_t ping_response_id;
+    uint64_t ping_request_id;
+
     void *net_crypto_pointer;
     uint32_t net_crypto_location;
     struct {
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index 7487ad4f..47e2ff27 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -288,7 +288,7 @@ int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length,
 /* return 0 if pending data was sent completely
  * return -1 if it wasn't
  */
-static int send_pending_data(TCP_Secure_Connection *con)
+static int send_pending_data_nonpriority(TCP_Secure_Connection *con)
 {
     if (con->last_packet_length == 0) {
         return 0;
@@ -306,25 +306,96 @@ static int send_pending_data(TCP_Secure_Connection *con)
         return 0;
     }
 
-    if (len > left)
+    con->last_packet_sent += len;
+    return -1;
+
+}
+
+/* return 0 if pending data was sent completely
+ * return -1 if it wasn't
+ */
+static int send_pending_data(TCP_Secure_Connection *con)
+{
+    /* finish sending current non-priority packet */
+    if (send_pending_data_nonpriority(con) == -1) {
         return -1;
+    }
+
+    TCP_Priority_List *p = con->priority_queue_start;
+
+    while (p) {
+        uint16_t left = p->size - p->sent;
+        int len = send(con->sock, p->data + p->sent, left, MSG_NOSIGNAL);
+
+        if (len != left) {
+            if (len > 0) {
+                p->sent += len;
+            }
+
+            break;
+        }
+
+        TCP_Priority_List *pp = p;
+        p = p->next;
+        free(pp);
+    }
+
+    con->priority_queue_start = p;
+
+    if (!p) {
+        con->priority_queue_end = NULL;
+        return 0;
+    }
 
-    con->last_packet_sent += len;
     return -1;
+}
+
+/* return 0 on failure (only if malloc fails)
+ * return 1 on success
+ */
+static _Bool add_priority(TCP_Secure_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
+{
+    TCP_Priority_List *p = con->priority_queue_end, *new;
+    new = malloc(sizeof(TCP_Priority_List) + size);
 
+    if (!new) {
+        return 0;
+    }
+
+    new->next = NULL;
+    new->size = size;
+    new->sent = sent;
+    memcpy(new->data, packet, size);
+
+    if (p) {
+        p->next = new;
+    } else {
+        con->priority_queue_start = new;
+    }
+
+    con->priority_queue_end = new;
+    return 1;
 }
 
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length)
+static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length,
+        _Bool priority)
 {
     if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
         return -1;
 
-    if (send_pending_data(con) == -1)
-        return 0;
+    _Bool sendpriority = 1;
+
+    if (send_pending_data(con) == -1) {
+        if (priority) {
+            sendpriority = 0;
+        } else {
+            return 0;
+        }
+    }
 
     uint8_t packet[sizeof(uint16_t) + length + crypto_box_MACBYTES];
 
@@ -335,17 +406,33 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
     if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t)))
         return -1;
 
-    increment_nonce(con->sent_nonce);
+    if (priority) {
+        len = sendpriority ? send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL) : 0;
 
-    len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
+        if (len <= 0) {
+            len = 0;
+        }
 
-    if ((unsigned int)len == sizeof(packet))
-        return 1;
+        increment_nonce(con->sent_nonce);
+
+        if (len == sizeof(packet)) {
+            return 1;
+        }
+
+        return add_priority(con, packet, sizeof(packet), len);
+    }
+
+    len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
 
     if (len <= 0)
         return 0;
 
-    memcpy(con->last_packet, packet, length);
+    increment_nonce(con->sent_nonce);
+
+    if ((unsigned int)len == sizeof(packet))
+        return 1;
+
+    memcpy(con->last_packet, packet, sizeof(packet));
     con->last_packet_length = sizeof(packet);
     con->last_packet_sent = len;
     return 1;
@@ -459,7 +546,7 @@ static int send_routing_response(TCP_Secure_Connection *con, uint8_t rpid, const
     data[1] = rpid;
     memcpy(data + 2, public_key, crypto_box_PUBLICKEYBYTES);
 
-    return write_packet_TCP_secure_connection(con, data, sizeof(data));
+    return write_packet_TCP_secure_connection(con, data, sizeof(data), 1);
 }
 
 /* return 1 on success.
@@ -469,7 +556,7 @@ static int send_routing_response(TCP_Secure_Connection *con, uint8_t rpid, const
 static int send_connect_notification(TCP_Secure_Connection *con, uint8_t id)
 {
     uint8_t data[2] = {TCP_PACKET_CONNECTION_NOTIFICATION, id + NUM_RESERVED_PORTS};
-    return write_packet_TCP_secure_connection(con, data, sizeof(data));
+    return write_packet_TCP_secure_connection(con, data, sizeof(data), 1);
 }
 
 /* return 1 on success.
@@ -479,7 +566,7 @@ static int send_connect_notification(TCP_Secure_Connection *con, uint8_t id)
 static int send_disconnect_notification(TCP_Secure_Connection *con, uint8_t id)
 {
     uint8_t data[2] = {TCP_PACKET_DISCONNECT_NOTIFICATION, id + NUM_RESERVED_PORTS};
-    return write_packet_TCP_secure_connection(con, data, sizeof(data));
+    return write_packet_TCP_secure_connection(con, data, sizeof(data), 1);
 }
 
 /* return 0 on success.
@@ -579,7 +666,7 @@ static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, const ui
         memcpy(resp_packet + 1, con->public_key, crypto_box_PUBLICKEYBYTES);
         memcpy(resp_packet + 1 + crypto_box_PUBLICKEYBYTES, data, length);
         write_packet_TCP_secure_connection(&TCP_server->accepted_connection_array[other_index], resp_packet,
-                                           sizeof(resp_packet));
+                                           sizeof(resp_packet), 0);
     }
 
     return 0;
@@ -637,7 +724,7 @@ static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data,
     memcpy(packet + 1, data, length);
     packet[0] = TCP_PACKET_ONION_RESPONSE;
 
-    if (write_packet_TCP_secure_connection(con, packet, sizeof(packet)) != 1)
+    if (write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0) != 1)
         return 1;
 
     return 0;
@@ -682,7 +769,7 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
             uint8_t response[1 + sizeof(uint64_t)];
             response[0] = TCP_PACKET_PONG;
             memcpy(response + 1, data + 1, sizeof(uint64_t));
-            write_packet_TCP_secure_connection(con, response, sizeof(response));
+            write_packet_TCP_secure_connection(con, response, sizeof(response), 1);
             return 0;
         }
 
@@ -752,7 +839,7 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
             uint8_t new_data[length];
             memcpy(new_data, data, length);
             new_data[0] = other_c_id;
-            int ret = write_packet_TCP_secure_connection(&TCP_server->accepted_connection_array[index], new_data, length);
+            int ret = write_packet_TCP_secure_connection(&TCP_server->accepted_connection_array[index], new_data, length, 0);
 
             if (ret == -1)
                 return -1;
@@ -1058,7 +1145,7 @@ static void do_TCP_confirmed(TCP_Server *TCP_server)
                 ++ping_id;
 
             memcpy(ping + 1, &ping_id, sizeof(uint64_t));
-            int ret = write_packet_TCP_secure_connection(conn, ping, sizeof(ping));
+            int ret = write_packet_TCP_secure_connection(conn, ping, sizeof(ping), 1);
 
             if (ret == 1) {
                 conn->last_pinged = unix_time();
diff --git a/toxcore/TCP_server.h b/toxcore/TCP_server.h
index def0a978..81507acb 100644
--- a/toxcore/TCP_server.h
+++ b/toxcore/TCP_server.h
@@ -80,6 +80,14 @@ enum {
     TCP_STATUS_CONFIRMED,
 };
 
+typedef struct TCP_Priority_List TCP_Priority_List;
+
+struct TCP_Priority_List {
+    TCP_Priority_List *next;
+    uint16_t size, sent;
+    uint8_t data[0];
+};
+
 typedef struct TCP_Secure_Connection {
     uint8_t status;
     sock_t  sock;
@@ -98,6 +106,8 @@ typedef struct TCP_Secure_Connection {
     uint16_t last_packet_length;
     uint16_t last_packet_sent;
 
+    TCP_Priority_List *priority_queue_start, *priority_queue_end;
+
     uint64_t identifier;
 
     uint64_t last_pinged;
diff --git a/toxcore/group_chats.c b/toxcore/group_chats.c
index 1f76878b..77fa6acd 100644
--- a/toxcore/group_chats.c
+++ b/toxcore/group_chats.c
@@ -471,16 +471,6 @@ static int handle_sendnodes(Group_Chat *chat, IP_Port source, int peernum, const
 
     int ok = add_closepeer(chat, chat->group[peernum].client_id, source);
 
-    if (chat->assoc) {
-        ippts_send.ip_port = chat->group[peernum].ping_via;
-        ippts_send.timestamp = chat->group[peernum].last_pinged;
-
-        IP_Port ipp_recv;
-        ipp_recv = source;
-
-        Assoc_add_entry(chat->assoc, contents.nodes[i].client_id, &ippts_send, &ipp_recv, ok == 0 ? 1 : 0);
-    }
-
     return 0;
 }
 
@@ -830,6 +820,7 @@ void do_groupchat(Group_Chat *chat)
 void kill_groupchat(Group_Chat *chat)
 {
     send_data(chat, 0, 0, GROUP_CHAT_QUIT);
+    kill_Assoc(chat->assoc);
     free(chat->group);
     free(chat);
 }
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index e0319f34..ac2359ee 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -37,21 +37,6 @@ static uint8_t crypt_connection_id_not_valid(const Net_Crypto *c, int crypt_conn
     return (uint32_t)crypt_connection_id >= c->crypto_connections_length;
 }
 
-/* return 0 if connection is dead.
- * return 1 if connection is alive.
- */
-static int is_alive(uint8_t status)
-{
-    if (status == CRYPTO_CONN_COOKIE_REQUESTING ||
-            status == CRYPTO_CONN_HANDSHAKE_SENT ||
-            status == CRYPTO_CONN_NOT_CONFIRMED ||
-            status == CRYPTO_CONN_ESTABLISHED) {
-        return 1;
-    }
-
-    return 0;
-}
-
 /* cookie timeout in seconds */
 #define COOKIE_TIMEOUT 10
 #define COOKIE_DATA_LENGTH (crypto_box_PUBLICKEYBYTES * 2)
@@ -426,19 +411,22 @@ static int send_packet_to(const Net_Crypto *c, int crypt_connection_id, const ui
 
     }
 
-    //TODO: spread packets over many relays, detect and kill bad relays.
+    //TODO: detect and kill bad relays.
     uint32_t i;
 
+    unsigned int r = rand();
+
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
-        if (conn->status_tcp[i] == STATUS_TCP_ONLINE) {/* friend is connected to this relay. */
-            if (send_data(c->tcp_connections[i], conn->con_number_tcp[i], data, length) == 1)
+        if (conn->status_tcp[(i + r) % MAX_TCP_CONNECTIONS] == STATUS_TCP_ONLINE) {/* friend is connected to this relay. */
+            if (send_data(c->tcp_connections[(i + r) % MAX_TCP_CONNECTIONS], conn->con_number_tcp[(i + r) % MAX_TCP_CONNECTIONS],
+                          data, length) == 1)
                 return 0;
         }
     }
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
-        if (conn->status_tcp[i] == STATUS_TCP_INVISIBLE) {
-            if (send_oob_packet(c->tcp_connections[i], conn->dht_public_key, data, length) == 1)
+        if (conn->status_tcp[(i + r) % MAX_TCP_CONNECTIONS] == STATUS_TCP_INVISIBLE) {
+            if (send_oob_packet(c->tcp_connections[(i + r) % MAX_TCP_CONNECTIONS], conn->dht_public_key, data, length) == 1)
                 return 0;
         }
     }
@@ -1106,6 +1094,14 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
             return -1;
     }
 
+    if (conn->status == CRYPTO_CONN_NOT_CONFIRMED) {
+        clear_temp_packet(c, crypt_connection_id);
+        conn->status = CRYPTO_CONN_ESTABLISHED;
+
+        if (conn->connection_status_callback)
+            conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, 1);
+    }
+
     if (real_data[0] == PACKET_ID_REQUEST) {
         int requested = handle_request_packet(&conn->send_array, real_data, real_length);
 
@@ -1148,14 +1144,6 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
         return -1;
     }
 
-    if (conn->status == CRYPTO_CONN_NOT_CONFIRMED) {
-        if (conn->connection_status_callback)
-            conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, 1);
-
-        clear_temp_packet(c, crypt_connection_id);
-        conn->status = CRYPTO_CONN_ESTABLISHED;
-    }
-
     return 0;
 }
 
@@ -1485,6 +1473,7 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
     /* Status needs to be CRYPTO_CONN_NOT_CONFIRMED for this to work. */
     set_connection_dht_public_key(c, crypt_connection_id, n_c->dht_public_key, current_time_monotonic());
     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
+    conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
     crypto_connection_add_source(c, crypt_connection_id, n_c->source);
     return crypt_connection_id;
 }
@@ -1517,6 +1506,7 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key)
     crypto_box_keypair(conn->sessionpublic_key, conn->sessionsecret_key);
     conn->status = CRYPTO_CONN_COOKIE_REQUESTING;
     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
+    conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
     return crypt_connection_id;
 }
 
@@ -2250,6 +2240,15 @@ static void send_crypto_packets(Net_Crypto *c)
                     notes: needs improvement but seems to work fine for packet loss <1%
                  */
 
+                /* additional step: adjust the send rate based on the size change of the send queue */
+                uint32_t queue_size = num_packets_array(&conn->send_array);
+
+                if (queue_size > conn->packet_send_rate && queue_size > conn->last_queue_size) {
+                    conn->rate_increase = 0;
+                    conn->packets_resent = conn->packets_sent;
+                }
+
+
                 //hack to prevent 1 packet lost from affecting calculations at low send rates
                 if (conn->packets_resent == 1) {
                     conn->packets_resent = 0;
@@ -2300,18 +2299,27 @@ static void send_crypto_packets(Net_Crypto *c)
                 double linear_increase = realrate * 0.0025 + 1.0;
 
                 //final send rate: average of "real" and previous send rates + increases
-                conn->packet_send_rate = (realrate + conn->packet_send_rate) / 2.0 + conn->rate_increase + linear_increase;
+                double newrate = (realrate + conn->packet_send_rate) / 2.0 + conn->rate_increase + linear_increase;
+                conn->last_send_rate = conn->packet_send_rate;
+                conn->packet_send_rate = newrate;
 
 
                 conn->dropped = dropped;
                 conn->drop_ignore = drop_ignore_new;
                 conn->packets_resent = 0;
+                conn->last_queue_size = queue_size;
 
-                if (conn->packet_send_rate < CRYPTO_PACKET_MIN_RATE || !conn->sending) {
+                if (!conn->sending || !conn->packets_sent) {
                     conn->rate_increase = 0;
+                    conn->packet_send_rate /= 2;
+                }
+
+                if (conn->packet_send_rate < CRYPTO_PACKET_MIN_RATE) {
                     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
                 }
 
+                conn->packets_sent = 0;
+
                 if (conn->sending != 0 && num_packets_array(&conn->send_array) < CRYPTO_MIN_QUEUE_LENGTH / 2) {
                     --conn->sending;
                 }
@@ -2342,6 +2350,7 @@ static void send_crypto_packets(Net_Crypto *c)
 
                 conn->packets_resent += ret;
                 conn->packets_left -= ret;
+                conn->packets_sent += ret;
             }
 
             if (conn->packet_send_rate > CRYPTO_PACKET_MIN_RATE * 1.5) {
@@ -2421,6 +2430,7 @@ int64_t write_cryptpacket(const Net_Crypto *c, int crypt_connection_id, const ui
         return -1;
 
     --conn->packets_left;
+    conn->packets_sent++;
     conn->sending = CONN_SENDING_VALUE;
     return ret;
 }
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index 4fed0000..2bc9a716 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -143,9 +143,9 @@ typedef struct {
     uint32_t packets_left;
     uint64_t last_packets_left_set;
 
-    double dropped, drop_ignore, rate_increase;
+    double dropped, drop_ignore, rate_increase, last_send_rate;
     uint64_t drop_ignore_start, rate_increase_stop_start;
-    uint32_t packets_resent;
+    uint32_t packets_resent, last_queue_size, packets_sent, last_packets_sent;
 
     uint8_t sending; /* indicates if data is being sent or not. */
 
diff --git a/toxcore/network.c b/toxcore/network.c
index 0009a558..373fef9e 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -671,7 +671,7 @@ int ip_equal(const IP *a, const IP *b)
     }
 
     return 0;
-};
+}
 
 /* ipport_equal
  *  compares two IPAny_Port structures
@@ -688,7 +688,7 @@ int ipport_equal(const IP_Port *a, const IP_Port *b)
         return 0;
 
     return ip_equal(&a->ip, &b->ip);
-};
+}
 
 /* nulls out ip */
 void ip_reset(IP *ip)
@@ -697,7 +697,7 @@ void ip_reset(IP *ip)
         return;
 
     memset(ip, 0, sizeof(IP));
-};
+}
 
 /* nulls out ip, sets family according to flag */
 void ip_init(IP *ip, uint8_t ipv6enabled)
@@ -707,7 +707,7 @@ void ip_init(IP *ip, uint8_t ipv6enabled)
 
     memset(ip, 0, sizeof(IP));
     ip->family = ipv6enabled ? AF_INET6 : AF_INET;
-};
+}
 
 /* checks if ip is valid */
 int ip_isset(const IP *ip)
@@ -716,7 +716,7 @@ int ip_isset(const IP *ip)
         return 0;
 
     return (ip->family != 0);
-};
+}
 
 /* checks if ip is valid */
 int ipport_isset(const IP_Port *ipport)
@@ -728,7 +728,7 @@ int ipport_isset(const IP_Port *ipport)
         return 0;
 
     return ip_isset(&ipport->ip);
-};
+}
 
 /* copies an ip structure (careful about direction!) */
 void ip_copy(IP *target, const IP *source)
@@ -737,7 +737,7 @@ void ip_copy(IP *target, const IP *source)
         return;
 
     memcpy(target, source, sizeof(IP));
-};
+}
 
 /* copies an ip_port structure (careful about direction!) */
 void ipport_copy(IP_Port *target, const IP_Port *source)
@@ -805,7 +805,7 @@ const char *ip_ntoa(const IP *ip)
     /* brute force protection against lacking termination */
     addresstext[sizeof(addresstext) - 1] = 0;
     return addresstext;
-};
+}
 
 /*
  * addr_parse_ip
@@ -820,7 +820,6 @@ const char *ip_ntoa(const IP *ip)
  *
  * returns 1 on success, 0 on failure
  */
-
 int addr_parse_ip(const char *address, IP *to)
 {
     if (!address || !to)
@@ -832,7 +831,7 @@ int addr_parse_ip(const char *address, IP *to)
         to->family = AF_INET;
         to->ip4.in_addr = addr4;
         return 1;
-    };
+    }
 
     struct in6_addr addr6;
 
@@ -840,10 +839,10 @@ int addr_parse_ip(const char *address, IP *to)
         to->family = AF_INET6;
         to->ip6.in6_addr = addr6;
         return 1;
-    };
+    }
 
     return 0;
-};
+}
 
 /*
  * addr_resolve():
@@ -862,7 +861,6 @@ int addr_parse_ip(const char *address, IP *to)
  * returns in *extra an IPv4 address, if family was AF_UNSPEC and *to is AF_INET6
  * returns 0 on failure
  */
-
 int addr_resolve(const char *address, IP *to, IP *extra)
 {
     if (!address || !to)
@@ -970,4 +968,4 @@ int addr_resolve_or_parse_ip(const char *address, IP *to, IP *extra)
             return 0;
 
     return 1;
-};
+}
diff --git a/toxcore/network.h b/toxcore/network.h
index 359d26c8..b902a487 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -191,6 +191,21 @@ IP_Port;
  */
 const char *ip_ntoa(const IP *ip);
 
+/*
+ * addr_parse_ip
+ *  directly parses the input into an IP structure
+ *  tries IPv4 first, then IPv6
+ *
+ * input
+ *  address: dotted notation (IPv4: quad, IPv6: 16) or colon notation (IPv6)
+ *
+ * output
+ *  IP: family and the value is set on success
+ *
+ * returns 1 on success, 0 on failure
+ */
+int addr_parse_ip(const char *address, IP *to);
+
 /* ip_equal
  *  compares two IPAny structures
  *  unset means unequal
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index 7d0efc79..42982ea8 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -831,7 +831,7 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
     uint32_t i;
 
     for (i = onion_c->num_friends; i != 0; --i) {
-        if (onion_c->friends_list[i].status != 0)
+        if (onion_c->friends_list[i - 1].status != 0)
             break;
     }
 
diff --git a/toxcore/ping_array.c b/toxcore/ping_array.c
index 5c92527e..93dade05 100644
--- a/toxcore/ping_array.c
+++ b/toxcore/ping_array.c
@@ -135,7 +135,7 @@ int ping_array_init(Ping_Array *empty_array, uint32_t size, uint32_t timeout)
     if (size == 0 || timeout == 0 || empty_array == NULL)
         return -1;
 
-    empty_array->entries = calloc(size * sizeof(Ping_Array_Entry), 1);
+    empty_array->entries = calloc(size, sizeof(Ping_Array_Entry));
 
     if (empty_array->entries == NULL)
         return -1;
diff --git a/toxcore/tox.h b/toxcore/tox.h
index 5418b03e..14426f31 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -90,7 +90,7 @@ void tox_get_address(const Tox *tox, uint8_t *address);
  * data is the data and length is the length.
  *
  *  return the friend number if success.
- *  return TOX_FA_TOOLONG if message length is too long.
+ *  return TOX_FAERR_TOOLONG if message length is too long.
  *  return TOX_FAERR_NOMESSAGE if no message (message length must be >= 1 byte).
  *  return TOX_FAERR_OWNKEY if user's own key.
  *  return TOX_FAERR_ALREADYSENT if friend request already sent or already a friend.
@@ -294,13 +294,13 @@ void tox_callback_friend_request(Tox *tox, void (*function)(Tox *tox, const uint
                                  void *), void *userdata);
 
 /* Set the function that will be executed when a message from a friend is received.
- *  Function format is: function(Tox *tox, int32_t friendnumber, uint8_t * message, uint32_t length, void *userdata)
+ *  Function format is: function(Tox *tox, int32_t friendnumber, uint8_t * message, uint16_t length, void *userdata)
  */
 void tox_callback_friend_message(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
                                  void *userdata);
 
 /* Set the function that will be executed when an action from a friend is received.
- *  Function format is: function(Tox *tox, int32_t friendnumber, uint8_t * action, uint32_t length, void *userdata)
+ *  Function format is: function(Tox *tox, int32_t friendnumber, uint8_t * action, uint16_t length, void *userdata)
  */
 void tox_callback_friend_action(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
                                 void *userdata);
@@ -495,20 +495,20 @@ uint32_t tox_get_chatlist(const Tox *tox, int *out_list, uint32_t list_size);
  * tox_file_data_remaining(...) can be used to know how many bytes are left to send/receive.
  *
  * If the connection breaks during file sending (The other person goes offline without pausing the sending and then comes back)
- * the receiver must send a control packet with receive_send == 0 message_id = TOX_FILECONTROL_RESUME_BROKEN and the data being
+ * the receiver must send a control packet with send_receive == 1 message_id = TOX_FILECONTROL_RESUME_BROKEN and the data being
  * a uint64_t (in host byte order) containing the number of bytes received.
  *
- * If the sender receives this packet, he must send a control packet with receive_send == 1 and control_type == TOX_FILECONTROL_ACCEPT
+ * If the sender receives this packet, he must send a control packet with send_receive == 0 and control_type == TOX_FILECONTROL_ACCEPT
  * then he must start sending file data from the position (data , uint64_t in host byte order) received in the TOX_FILECONTROL_RESUME_BROKEN packet.
  *
  * To pause a file transfer send a control packet with control_type == TOX_FILECONTROL_PAUSE.
  * To unpause a file transfer send a control packet with control_type == TOX_FILECONTROL_ACCEPT.
  *
  * If you receive a control packet with receive_send == 1 and control_type == TOX_FILECONTROL_PAUSE, you must stop sending filenumber until the other
- * person sends a control packet with receive_send == 1 and control_type == TOX_FILECONTROL_ACCEPT with the filenumber being a paused filenumber.
+ * person sends a control packet with send_receive == 0 and control_type == TOX_FILECONTROL_ACCEPT with the filenumber being a paused filenumber.
  *
  * If you receive a control packet with receive_send == 0 and control_type == TOX_FILECONTROL_PAUSE, it means the sender of filenumber has paused the
- * transfer and will resume it later with a control packet with receive_send == 0 and control_type == TOX_FILECONTROL_ACCEPT for that file number.
+ * transfer and will resume it later with a control packet with send_receive == 1 and control_type == TOX_FILECONTROL_ACCEPT for that file number.
  *
  * More to come...
  */