11 files changed, 661 insertions, 174 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 1761f50b..ad4c8a1d 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -131,14 +131,32 @@ static int is_timeout(uint64_t time_now, uint64_t timestamp, uint64_t timeout)
  *
  *  return True(1) or False(0)
  */
-static int client_in_list(Client_data *list, uint32_t length, uint8_t *client_id, IP_Port ip_port)
+static int client_or_ip_port_in_list(Client_data *list, uint32_t length, uint8_t *client_id, IP_Port ip_port)
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
 
+    uint8_t candropipv4 = 1;
+    if (ip_port.ip.family == AF_INET6) {
+        uint8_t ipv6cnt = 0;
+
+        /* ipv6: count how many spots are used */
+        for(i = 0; i < length; i++)
+            if (list[i].ip_port.ip.family == AF_INET6)
+                ipv6cnt++;
+
+        /* more than half the list filled with ipv6: block ipv4->ipv6 overwrite */
+        if (ipv6cnt > length / 2)
+            candropipv4 = 0;
+    }
+
     /* if client_id is in list, find it and maybe overwrite ip_port */
     for (i = 0; i < length; ++i)
         if (id_equal(list[i].client_id, client_id)) {
+            /* if we got "too many" ipv6 addresses already, keep the ipv4 address */
+            if (!candropipv4 && (list[i].ip_port.ip.family == AF_INET))
+                return 1;
+
             /* Refresh the client timestamp. */
             list[i].timestamp = temp_time;
             list[i].ip_port = ip_port;
@@ -299,15 +317,31 @@ static int replace_bad(    Client_data    *list,
     uint32_t i;
     uint64_t temp_time = unix_time();
 
+    uint8_t candropipv4 = 1;
+    if (ip_port.ip.family == AF_INET6) {
+        uint32_t ipv6cnt = 0;
+
+        /* ipv6: count how many spots are used */
+        for(i = 0; i < length; i++)
+            if (list[i].ip_port.ip.family == AF_INET6)
+                ipv6cnt++;
+
+        /* more than half the list filled with ipv6: block ipv4->ipv6 overwrite */
+        if (ipv6cnt > length / 2)
+            candropipv4 = 0;
+    }
+
     for (i = 0; i < length; ++i) {
         /* If node is bad */
-        if (is_timeout(temp_time, list[i].timestamp, BAD_NODE_TIMEOUT)) {
-            memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);
-            list[i].ip_port = ip_port;
-            list[i].timestamp = temp_time;
-            ip_reset(&list[i].ret_ip_port.ip);
-            list[i].ret_ip_port.port = 0;
-            list[i].ret_timestamp = 0;
+        Client_data *client = &list[i];
+        if ((candropipv4 || (client->ip_port.ip.family == AF_INET6)) &&
+            is_timeout(temp_time, client->timestamp, BAD_NODE_TIMEOUT)) {
+            memcpy(client->client_id, client_id, CLIENT_ID_SIZE);
+            client->ip_port = ip_port;
+            client->timestamp = temp_time;
+            ip_reset(&client->ret_ip_port.ip);
+            client->ret_ip_port.port = 0;
+            client->ret_timestamp = 0;
             return 0;
         }
     }
@@ -344,20 +378,69 @@ static int replace_good(   Client_data    *list,
                            IP_Port         ip_port,
                            uint8_t        *comp_client_id )
 {
-    uint32_t i;
-    uint64_t temp_time = unix_time();
     sort_list(list, length, comp_client_id);
 
-    for (i = 0; i < length; ++i)
-        if (id_closest(comp_client_id, list[i].client_id, client_id) == 2) {
-            memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);
-            list[i].ip_port = ip_port;
-            list[i].timestamp = temp_time;
-            ip_reset(&list[i].ret_ip_port.ip);
-            list[i].ret_ip_port.port = 0;
-            list[i].ret_timestamp = 0;
-            return 0;
+    uint8_t candropipv4 = 1;
+    if (ip_port.ip.family == AF_INET6) {
+        uint32_t i, ipv6cnt = 0;
+
+        /* ipv6: count how many spots are used */
+        for(i = 0; i < length; i++)
+            if (list[i].ip_port.ip.family == AF_INET6)
+                ipv6cnt++;
+
+        /* more than half the list filled with ipv6: block ipv4->ipv6 overwrite */
+        if (ipv6cnt > length / 2)
+            candropipv4 = 0;
+    }
+
+    int8_t replace = -1;
+    uint32_t i;
+
+    if (candropipv4) {
+        /* either we got an ipv4 address, or we're "allowed" to push out an ipv4
+         * address in favor of an ipv6 one
+         *
+         * because the list is sorted, we can simply check the client_id at the
+         * border, either it is closer, then every other one is as well, or it is
+         * further, then it gets pushed out in favor of the new address, which
+         * will with the next sort() move to its "rightful" position
+         *
+         * CAVEAT: weirdly enough, the list is sorted DESCENDING in distance
+         * so the furthest element is the first, NOT the last (at least that's
+         * what the comment above sort_list() claims)
+         */
+        if (id_closest(comp_client_id, list[0].client_id, client_id) == 2)
+            replace = 0;
+    } else {
+        /* ipv6 case without a right to push out an ipv4: only look for ipv6
+         * addresses, the first one we find is either closer (then we can skip
+         * out like above) or further (then we can replace it, like above)
+         */
+        for (i = 0; i < length; i++) {
+            Client_data *client = &list[i];
+            if (client->ip_port.ip.family == AF_INET6) {
+                if (id_closest(comp_client_id, list[i].client_id, client_id) == 2)
+                    replace = i;
+
+                break;
+            }
         }
+    }
+
+    if (replace != -1) {
+#ifdef DEBUG
+        assert(replace >= 0 && replace < length);
+#endif
+        Client_data *client = &list[replace];
+        memcpy(client->client_id, client_id, CLIENT_ID_SIZE);
+        client->ip_port = ip_port;
+        client->timestamp = unix_time();
+        ip_reset(&client->ret_ip_port.ip);
+        client->ret_ip_port.port = 0;
+        client->ret_timestamp = 0;
+        return 0;
+    }
 
     return 1;
 }
@@ -369,36 +452,32 @@ void addto_lists(DHT *dht, IP_Port ip_port, uint8_t *client_id)
 {
     uint32_t i;
 
+    /* convert IPv4-in-IPv6 to IPv4 */
+    if ((ip_port.ip.family == AF_INET6) && IN6_IS_ADDR_V4MAPPED(&ip_port.ip.ip6.in6_addr)) {
+        ip_port.ip.family = AF_INET;
+        ip_port.ip.ip4.uint32 = ip_port.ip.ip6.uint32[3];
+    }
+
     /* NOTE: Current behavior if there are two clients with the same id is
      * to replace the first ip by the second.
      */
-    if (!client_in_list(dht->close_clientlist, LCLIENT_LIST, client_id, ip_port)) {
+    if (!client_or_ip_port_in_list(dht->close_clientlist, LCLIENT_LIST, client_id, ip_port)) {
         if (replace_bad(dht->close_clientlist, LCLIENT_LIST, client_id, ip_port)) {
             /* If we can't replace bad nodes we try replacing good ones. */
-            replace_good(   dht->close_clientlist,
-                            LCLIENT_LIST,
-                            client_id,
-                            ip_port,
-                            dht->c->self_public_key );
+            replace_good(dht->close_clientlist, LCLIENT_LIST, client_id, ip_port,
+                         dht->c->self_public_key);
         }
     }
 
     for (i = 0; i < dht->num_friends; ++i) {
-        if (!client_in_list(    dht->friends_list[i].client_list,
-                                MAX_FRIEND_CLIENTS,
-                                client_id,
-                                ip_port )) {
-
-            if (replace_bad(    dht->friends_list[i].client_list,
-                                MAX_FRIEND_CLIENTS,
-                                client_id,
-                                ip_port )) {
+        if (!client_or_ip_port_in_list(dht->friends_list[i].client_list,
+                                       MAX_FRIEND_CLIENTS, client_id, ip_port)) {
+
+            if (replace_bad(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
+                            client_id, ip_port)) {
                 /* If we can't replace bad nodes we try replacing good ones. */
-                replace_good(   dht->friends_list[i].client_list,
-                                MAX_FRIEND_CLIENTS,
-                                client_id,
-                                ip_port,
-                                dht->friends_list[i].client_id );
+                replace_good(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
+                             client_id, ip_port, dht->friends_list[i].client_id);
             }
         }
     }
diff --git a/toxcore/Lossless_UDP.c b/toxcore/Lossless_UDP.c
index 83a5b338..8d447534 100644
--- a/toxcore/Lossless_UDP.c
+++ b/toxcore/Lossless_UDP.c
@@ -52,6 +52,43 @@ int getconnection_id(Lossless_UDP *ludp, IP_Port ip_port)
     return -1;
 }
 
+/* Resize a queue
+ * return length of queue on success.
+ * return ~0 on failure.
+ */
+uint32_t resize_queue(Data **buffer, uint32_t length, uint32_t new_length, uint32_t min_packetnum,
+                      uint32_t max_packetnum)
+{
+    if (MAX_QUEUE_NUM < new_length)
+        new_length = MAX_QUEUE_NUM;
+
+    if (max_packetnum - min_packetnum > new_length)
+        return ~0;
+
+    if (length == new_length)
+        return new_length;
+
+    Data *temp = calloc(1, sizeof(Data) * new_length);
+
+    if (temp == NULL)
+        return ~0;
+
+    if (*buffer == NULL) {
+        *buffer = temp;
+        return new_length;
+    }
+
+    uint32_t i;
+
+    for (i = min_packetnum; i != max_packetnum; ++i)
+        memcpy(temp + (i % new_length), *buffer + (i % length), sizeof(Data));
+
+    free(*buffer);
+    *buffer = temp;
+    return new_length;
+}
+
+
 
 /*
  * Generate a handshake_id which depends on the ip_port.
@@ -148,8 +185,10 @@ int new_connection(Lossless_UDP *ludp, IP_Port ip_port)
 {
     int connection_id = getconnection_id(ludp, ip_port);
 
-    if (connection_id != -1)
+    if (connection_id != -1) {
+        confirm_connection(ludp, connection_id);
         return connection_id;
+    }
 
     tox_array_for_each(&ludp->connections, Connection, tmp) {
         if (tmp->status == 0) {
@@ -170,7 +209,8 @@ int new_connection(Lossless_UDP *ludp, IP_Port ip_port)
     memset(connection, 0, sizeof(Connection));
 
     uint32_t handshake_id1 = handshake_id(ludp, ip_port);
-    uint64_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
+    /* add randomness to timeout to prevent connections getting stuck in a loop. */
+    uint8_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
 
     *connection = (Connection) {
         .ip_port            = ip_port,
@@ -186,9 +226,18 @@ int new_connection(Lossless_UDP *ludp, IP_Port ip_port)
                   .last_sent          = current_time(),
                    .killat             = ~0,
                     .send_counter       = 0,
-                     /* add randomness to timeout to prevent connections getting stuck in a loop. */
-                     .timeout            = timeout
+                     .timeout            = timeout,
+                      .confirmed          = 1
     };
+    connection->sendbuffer_length = resize_queue(&connection->sendbuffer, 0, DEFAULT_QUEUE_NUM, 0, 0);
+    connection->recvbuffer_length = resize_queue(&connection->recvbuffer, 0, DEFAULT_QUEUE_NUM, 0, 0);
+
+    if (connection->sendbuffer_length == (uint32_t)~0 || connection->recvbuffer_length == (uint32_t)~0) {
+        free(connection->sendbuffer);
+        free(connection->recvbuffer);
+        memset(connection, 0, sizeof(Connection));
+        return -1;
+    }
 
     return connection_id;
 }
@@ -221,8 +270,8 @@ static int new_inconnection(Lossless_UDP *ludp, IP_Port ip_port)
 
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
     memset(connection, 0, sizeof(Connection));
-
-    uint64_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
+    /* Add randomness to timeout to prevent connections getting stuck in a loop. */
+    uint8_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
 
     *connection = (Connection) {
         .ip_port = ip_port,
@@ -234,24 +283,33 @@ static int new_inconnection(Lossless_UDP *ludp, IP_Port ip_port)
               .last_sent = current_time(),
                .send_counter = 127,
 
-                /* Add randomness to timeout to prevent connections getting stuck in a loop. */
                 .timeout = timeout,
 
                  /* If this connection isn't handled within the timeout kill it. */
-                 .killat = current_time() + 1000000UL * timeout
+                 .killat = current_time() + 1000000UL * timeout,
+                  .confirmed = 0
     };
+    connection->sendbuffer_length = resize_queue(&connection->sendbuffer, 0, DEFAULT_QUEUE_NUM, 0, 0);
+    connection->recvbuffer_length = resize_queue(&connection->recvbuffer, 0, DEFAULT_QUEUE_NUM, 0, 0);
+
+    if (connection->sendbuffer_length == (uint32_t)~0 || connection->recvbuffer_length == (uint32_t)~0) {
+        free(connection->sendbuffer);
+        free(connection->recvbuffer);
+        memset(connection, 0, sizeof(Connection));
+        return -1;
+    }
 
     return connection_id;
 }
 
 /*
- *  return an integer corresponding to the next connection in our incoming connection list.
+ *  return an integer corresponding to the next connection in our incoming connection list with at least numpackets in the recieve queue.
  *  return -1 if there are no new incoming connections in the list.
  */
-int incoming_connection(Lossless_UDP *ludp)
+int incoming_connection(Lossless_UDP *ludp, uint32_t numpackets)
 {
     tox_array_for_each(&ludp->connections, Connection, tmp) {
-        if (tmp->inbound == 2) {
+        if (tmp->inbound == 2 && tmp->recv_packetnum - tmp->successful_read >= numpackets) {
             tmp->inbound = 1;
             return tmp_i;
         }
@@ -286,6 +344,8 @@ int kill_connection(Lossless_UDP *ludp, int connection_id)
         if (connection->status > 0) {
             connection->status = 0;
             change_handshake(ludp, connection->ip_port);
+            free(connection->sendbuffer);
+            free(connection->recvbuffer);
             memset(connection, 0, sizeof(Connection));
             free_connections(ludp);
             return 0;
@@ -332,6 +392,49 @@ int is_connected(Lossless_UDP *ludp, int connection_id)
     return 0;
 }
 
+/* Check if connection is confirmed.
+ *
+ *  returns 1 if yes.
+ *  returns 0 if no/failure.
+ */
+int connection_confirmed(Lossless_UDP *ludp, int connection_id)
+{
+    if ((unsigned int)connection_id >= ludp->connections.len)
+        return 0;
+
+    Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
+
+    if (connection->status == 0)
+        return 0;
+
+    if (connection->confirmed == 1)
+        return 1;
+
+    return 0;
+}
+
+/* Confirm an incoming connection.
+ * Also disables the auto kill timeout on incomming connections.
+ *
+ *  return 0 on success
+ *  return -1 on failure.
+ */
+int confirm_connection(Lossless_UDP *ludp, int connection_id)
+{
+    if ((unsigned int)connection_id >= ludp->connections.len)
+        return -1;
+
+    Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
+
+    if (connection->status == 0)
+        return -1;
+
+    connection->killat = ~0;
+    connection->confirmed = 1;
+    connection->inbound = 0;
+    return 0;
+}
+
 /*  return the ip_port of the corresponding connection. */
 IP_Port connection_ip(Lossless_UDP *ludp, int connection_id)
 {
@@ -383,7 +486,7 @@ char id_packet(Lossless_UDP *ludp, int connection_id)
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
 
     if (connection->status != 0)
-        return connection->recvbuffer[connection->successful_read % MAX_QUEUE_NUM].data[0];
+        return connection->recvbuffer[connection->successful_read % connection->recvbuffer_length].data[0];
 
     return -1;
 }
@@ -401,13 +504,47 @@ int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data)
     if (connection->status == 0)
         return 0;
 
-    uint16_t index = connection->successful_read % MAX_QUEUE_NUM;
+    uint16_t index = connection->successful_read % connection->recvbuffer_length;
     uint16_t size  = connection->recvbuffer[index].size;
     memcpy(data, connection->recvbuffer[index].data, size);
     ++connection->successful_read;
     connection->recvbuffer[index].size = 0;
     return size;
+}
+
+/* Like read_packet() but does leaves the queue as is.
+ *  return 0 if there is no received data in the buffer.
+ *  return length of received packet if successful.
+ */
+int read_packet_silent(Lossless_UDP *ludp, int connection_id, uint8_t *data)
+{
+    if (recvqueue(ludp, connection_id) == 0)
+        return 0;
+
+    Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
+
+    if (connection->status == 0)
+        return 0;
+
+    uint16_t index = connection->successful_read % connection->recvbuffer_length;
+    uint16_t size  = connection->recvbuffer[index].size;
+    memcpy(data, connection->recvbuffer[index].data, size);
+    return size;
+}
+/* Discard the next packet to be read from the queue
+ *  return 0 if success.
+ *  return -1 if failure.
+ */
+int discard_packet(Lossless_UDP *ludp, int connection_id)
+{
+    if (recvqueue(ludp, connection_id) == 0)
+        return -1;
 
+    Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
+    uint16_t index = connection->successful_read % connection->recvbuffer_length;
+    ++connection->successful_read;
+    connection->recvbuffer[index].size = 0;
+    return 0;
 }
 
 /*  return 0 if data could not be put in packet queue.
@@ -418,15 +555,27 @@ int write_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data, uint32_t
     if ((unsigned int)connection_id >= ludp->connections.len)
         return 0;
 
-    if (length > MAX_DATA_SIZE || length == 0 || sendqueue(ludp, connection_id) >= BUFFER_PACKET_NUM)
-        return 0;
-
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
 
     if (connection->status == 0)
         return 0;
 
-    uint32_t index = connection->sendbuff_packetnum % MAX_QUEUE_NUM;
+    if (length > MAX_DATA_SIZE || length == 0 || sendqueue(ludp, connection_id) >= MAX_QUEUE_NUM)
+        return 0;
+
+    if (sendqueue(ludp, connection_id) >= connection->sendbuffer_length && connection->sendbuffer_length != 0) {
+        uint32_t newlen = connection->sendbuffer_length = resize_queue(&connection->sendbuffer, connection->sendbuffer_length,
+                          connection->sendbuffer_length * 2, connection->successful_sent, connection->sendbuff_packetnum);
+
+        if (newlen == (uint32_t)~0)
+            return 0;
+
+        connection->sendbuffer_length = newlen;
+        return write_packet(ludp, connection_id, data, length);
+    }
+
+
+    uint32_t index = connection->sendbuff_packetnum % connection->sendbuffer_length;
     memcpy(connection->sendbuffer[index].data, data, length);
     connection->sendbuffer[index].size = length;
     connection->sendbuff_packetnum++;
@@ -434,26 +583,32 @@ int write_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data, uint32_t
 }
 
 /* Put the packet numbers the we are missing in requested and return the number. */
-uint32_t missing_packets(Lossless_UDP *ludp, int connection_id, uint32_t *requested)
+static uint32_t missing_packets(Lossless_UDP *ludp, int connection_id, uint32_t *requested)
 {
+    if ((unsigned int)connection_id >= ludp->connections.len)
+        return 0;
+
+    Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
+
     /* Don't request packets if the buffer is full. */
-    if (recvqueue(ludp, connection_id) >= (BUFFER_PACKET_NUM - 1))
+    if (recvqueue(ludp, connection_id) >= (connection->recvbuffer_length - 1))
         return 0;
 
     uint32_t number = 0;
     uint32_t i;
     uint32_t temp;
 
-    Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
-
     for (i = connection->recv_packetnum;
             i != connection->osent_packetnum;
             i++) {
-        if (connection->recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
+        if (connection->recvbuffer[i % connection->recvbuffer_length].size == 0) {
             temp = htonl(i);
             memcpy(requested + number, &temp, 4);
             ++number;
         }
+
+        if (number >= MAX_REQUESTED_PACKETS)
+            return number;
     }
 
     if (number == 0)
@@ -485,7 +640,7 @@ static int send_handshake(Lossless_UDP *ludp, IP_Port ip_port, uint32_t handshak
 static int send_SYNC(Lossless_UDP *ludp, int connection_id)
 {
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
-    uint8_t packet[(BUFFER_PACKET_NUM * 4 + 4 + 4 + 2)];
+    uint8_t packet[(MAX_REQUESTED_PACKETS * 4 + 4 + 4 + 2)];
     uint16_t index = 0;
 
     IP_Port ip_port         = connection->ip_port;
@@ -493,7 +648,7 @@ static int send_SYNC(Lossless_UDP *ludp, int connection_id)
     uint32_t recv_packetnum = htonl(connection->recv_packetnum);
     uint32_t sent_packetnum = htonl(connection->sent_packetnum);
 
-    uint32_t requested[BUFFER_PACKET_NUM];
+    uint32_t requested[MAX_REQUESTED_PACKETS];
     uint32_t number         = missing_packets(ludp, connection_id, requested);
 
     packet[0] = NET_PACKET_SYNC;
@@ -514,7 +669,7 @@ static int send_data_packet(Lossless_UDP *ludp, int connection_id, uint32_t pack
 {
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
 
-    uint32_t index = packet_num % MAX_QUEUE_NUM;
+    uint32_t index = packet_num % connection->sendbuffer_length;
     uint32_t temp;
     uint8_t packet[1 + 4 + MAX_DATA_SIZE];
     packet[0] = NET_PACKET_DATA;
@@ -529,7 +684,7 @@ static int send_DATA(Lossless_UDP *ludp, int connection_id)
 {
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
     int ret;
-    uint32_t buffer[BUFFER_PACKET_NUM];
+    uint32_t buffer[MAX_REQUESTED_PACKETS];
 
     if (connection->num_req_paquets > 0) {
         ret = send_data_packet(ludp, connection_id, connection->req_packets[0]);
@@ -609,7 +764,7 @@ static int SYNC_valid(uint32_t length)
     if (length < 4 + 4 + 2)
         return 0;
 
-    if (length > (BUFFER_PACKET_NUM * 4 + 4 + 4 + 2) ||
+    if (length > (MAX_REQUESTED_PACKETS * 4 + 4 + 4 + 2) ||
             ((length - 4 - 4 - 2) % 4) != 0)
         return 0;
 
@@ -656,6 +811,35 @@ static int handle_SYNC2(Lossless_UDP *ludp, int connection_id, uint8_t counter,
 
     return 1;
 }
+
+/*
+ * Automatically adjusts send rates of data packets for optimal transmission.
+ *
+ * TODO: Impove this.
+ */
+static void adjust_datasendspeed(Connection *connection, uint32_t req_packets)
+{
+    /* if there are no packets in send buffer */
+    if (connection->sendbuff_packetnum - connection->successful_sent == 0) {
+        connection->data_rate -= connection->data_rate / 8;
+
+        if (connection->data_rate < DATA_SYNC_RATE)
+            connection->data_rate = DATA_SYNC_RATE;
+
+        return;
+    }
+
+    if (req_packets <= (connection->data_rate / connection->SYNC_rate) / 20 || req_packets <= 1) {
+        connection->data_rate += connection->data_rate / 8;
+
+        if (connection->data_rate > connection->sendbuffer_length * connection->SYNC_rate)
+            connection->data_rate = connection->sendbuffer_length * connection->SYNC_rate;
+    } else {
+        connection->data_rate -= connection->data_rate / 8;
+    }
+}
+
+
 /* case 3 in handle_SYNC: */
 static int handle_SYNC3(Lossless_UDP *ludp, int connection_id, uint8_t counter, uint32_t recv_packetnum,
                         uint32_t sent_packetnum,
@@ -672,13 +856,14 @@ static int handle_SYNC3(Lossless_UDP *ludp, int connection_id, uint8_t counter,
     uint32_t comp_2 = (sent_packetnum - connection->osent_packetnum);
 
     /* Packet valid. */
-    if (comp_1 <= BUFFER_PACKET_NUM &&
-            comp_2 <= BUFFER_PACKET_NUM &&
-            comp_counter == 1) {
+    if (comp_1 <= connection->sendbuffer_length &&
+            comp_2 <= MAX_QUEUE_NUM &&
+            comp_counter != 0 && comp_counter < 4) {
         connection->orecv_packetnum = recv_packetnum;
         connection->osent_packetnum = sent_packetnum;
         connection->successful_sent = recv_packetnum;
         connection->last_recvSYNC   = current_time();
+
         connection->recv_counter    = counter;
 
         ++connection->send_counter;
@@ -689,6 +874,7 @@ static int handle_SYNC3(Lossless_UDP *ludp, int connection_id, uint8_t counter,
         }
 
         connection->num_req_paquets = number;
+        adjust_datasendspeed(connection, number);
         return 0;
     }
 
@@ -705,8 +891,8 @@ static int handle_SYNC(void *object, IP_Port source, uint8_t *packet, uint32_t l
     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;
+    uint32_t req_packets[number];
 
     memcpy(&counter, packet + 1, 1);
     memcpy(&temp, packet + 2, 4);
@@ -749,17 +935,35 @@ static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, ui
 
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
     uint32_t i;
-    uint32_t maxnum = connection->successful_read + BUFFER_PACKET_NUM;
+    uint32_t test = data_num - connection->recv_packetnum;
+
+    if (test > MAX_QUEUE_NUM)
+        return 0;
+
+    if (test > connection->recvbuffer_length) {
+        if (connection->confirmed == 0)
+            return 0;
+
+        uint32_t len = resize_queue(&connection->recvbuffer, connection->recvbuffer_length, test * 2,
+                                    connection->successful_read, connection->successful_read + connection->recvbuffer_length);
+
+        if (len == (uint32_t)~0)
+            return 0;
+
+        connection->recvbuffer_length = len;
+    }
+
+    uint32_t maxnum = connection->successful_read + connection->recvbuffer_length;
     uint32_t sent_packet = data_num - connection->osent_packetnum;
 
     for (i = connection->recv_packetnum; i != maxnum; ++i) {
         if (i == data_num) {
-            memcpy(connection->recvbuffer[i % MAX_QUEUE_NUM].data, data, size);
+            memcpy(connection->recvbuffer[data_num % connection->recvbuffer_length].data, data, size);
 
-            connection->recvbuffer[i % MAX_QUEUE_NUM].size = size;
+            connection->recvbuffer[data_num % connection->recvbuffer_length].size = size;
             connection->last_recvdata = current_time();
 
-            if (sent_packet < BUFFER_PACKET_NUM)
+            if (sent_packet < connection->recvbuffer_length)
                 connection->osent_packetnum = data_num;
 
             break;
@@ -767,7 +971,7 @@ static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, ui
     }
 
     for (i = connection->recv_packetnum; i != maxnum; ++i) {
-        if (connection->recvbuffer[i % MAX_QUEUE_NUM].size != 0)
+        if (connection->recvbuffer[i % connection->recvbuffer_length].size != 0)
             connection->recv_packetnum = i;
         else
             break;
@@ -871,7 +1075,8 @@ static void do_data(Lossless_UDP *ludp)
         if (tmp->status == 3 && sendqueue(ludp, tmp_i) != 0 &&
                 (tmp->last_sent + (1000000UL / tmp->data_rate)) <= temp_time) {
             for (j = tmp->last_sent; j < temp_time; j +=  (1000000UL / tmp->data_rate))
-                send_DATA(ludp, tmp_i);
+                if (send_DATA(ludp, tmp_i) <= 0)
+                    break;
 
             tmp->last_sent = temp_time;
 
@@ -879,7 +1084,7 @@ static void do_data(Lossless_UDP *ludp)
     }
 }
 
-#define MAX_SYNC_RATE 10
+#define MAX_SYNC_RATE 20
 
 /*
  * Automatically adjusts send rates of packets for optimal transmission.
@@ -896,12 +1101,12 @@ static void adjust_rates(Lossless_UDP *ludp)
 
         if (tmp->status == 3) {
             if (sendqueue(ludp, tmp_i) != 0) {
-                tmp->data_rate = (BUFFER_PACKET_NUM - tmp->num_req_paquets) * MAX_SYNC_RATE;
                 tmp->SYNC_rate = MAX_SYNC_RATE;
-            } else if (tmp->last_recvdata + 1000000UL > temp_time)
+            } else if (tmp->last_recvdata + 200000UL > temp_time) { /* 200 ms */
                 tmp->SYNC_rate = MAX_SYNC_RATE;
-            else
+            } else {
                 tmp->SYNC_rate = SYNC_RATE;
+            }
         }
     }
 }
@@ -917,6 +1122,11 @@ void do_lossless_udp(Lossless_UDP *ludp)
 
 void kill_lossless_udp(Lossless_UDP *ludp)
 {
+    uint32_t i;
+
+    for (i = 0; i < ludp->connections.len; ++i)
+        kill_connection(ludp, i);
+
     tox_array_delete(&ludp->connections);
     free(ludp);
 }
diff --git a/toxcore/Lossless_UDP.h b/toxcore/Lossless_UDP.h
index f0ce0e87..2ef6f4d9 100644
--- a/toxcore/Lossless_UDP.h
+++ b/toxcore/Lossless_UDP.h
@@ -32,10 +32,11 @@
 #define MAX_DATA_SIZE 1024
 
 /* Maximum data packets in sent and receive queues. */
-#define MAX_QUEUE_NUM     16
+#define MAX_QUEUE_NUM     1024
+#define DEFAULT_QUEUE_NUM     4
 
 /* Maximum number of data packets in the buffer. */
-#define BUFFER_PACKET_NUM (16-1)
+#define MAX_REQUESTED_PACKETS 256
 
 /* Timeout per connection is randomly set between CONNEXION_TIMEOUT and 2*CONNEXION_TIMEOUT. */
 #define CONNEXION_TIMEOUT 5
@@ -71,7 +72,7 @@ typedef struct {
     uint8_t inbound;
 
     uint16_t  SYNC_rate;     /* Current SYNC packet send rate packets per second. */
-    uint16_t  data_rate;     /* Current data packet send rate packets per second. */
+    uint32_t  data_rate;     /* Current data packet send rate packets per second. */
 
     uint64_t  last_SYNC;     /* Time our last SYNC packet was sent. */
     uint64_t  last_sent;     /* Time our last data or handshake packet was sent. */
@@ -79,9 +80,10 @@ typedef struct {
     uint64_t  last_recvdata; /* Time we last received a DATA packet from the other. */
     uint64_t  killat;        /* Time to kill the connection. */
 
-    Data      sendbuffer[MAX_QUEUE_NUM]; /* packet send buffer. */
-    Data      recvbuffer[MAX_QUEUE_NUM]; /* packet receive buffer. */
-
+    Data      *sendbuffer; /* packet send buffer. */
+    uint32_t  sendbuffer_length;
+    Data      *recvbuffer; /* packet receive buffer. */
+    uint32_t  recvbuffer_length;
     uint32_t  handshake_id1;
     uint32_t  handshake_id2;
 
@@ -107,7 +109,7 @@ typedef struct {
     uint32_t  successful_read;
 
     /* List of currently requested packet numbers(by the other person). */
-    uint32_t  req_packets[BUFFER_PACKET_NUM];
+    uint32_t  req_packets[MAX_REQUESTED_PACKETS];
 
     /* Total number of currently requested packets(by the other person). */
     uint16_t  num_req_paquets;
@@ -115,6 +117,9 @@ typedef struct {
     uint8_t   recv_counter;
     uint8_t   send_counter;
     uint8_t   timeout; /* connection timeout in seconds. */
+
+    /* is the connection confirmed or not 1 if yes, 0 if no */
+    uint8_t   confirmed;
 } Connection;
 
 typedef struct {
@@ -150,10 +155,11 @@ int new_connection(Lossless_UDP *ludp, IP_Port ip_port);
  */
 int getconnection_id(Lossless_UDP *ludp, IP_Port ip_port);
 
-/*  return an integer corresponding to the next connection in our imcoming connection list.
+/*
+ *  return an integer corresponding to the next connection in our incoming connection list with at least numpackets in the recieve queue.
  *  return -1 if there are no new incoming connections in the list.
  */
-int incoming_connection(Lossless_UDP *ludp);
+int incoming_connection(Lossless_UDP *ludp, uint32_t numpackets);
 
 /*  return -1 if it could not kill the connection.
  *  return 0 if killed successfully.
@@ -168,6 +174,22 @@ int kill_connection(Lossless_UDP *ludp, int connection_id);
  */
 int kill_connection_in(Lossless_UDP *ludp, int connection_id, uint32_t seconds);
 
+
+/* Check if connection is confirmed.
+ *
+ *  returns 1 if yes.
+ *  returns 0 if no.
+ */
+int connection_confirmed(Lossless_UDP *ludp, int connection_id);
+
+/* Confirm an incoming connection.
+ * Also disables the auto kill timeout on incomming connections.
+ *
+ *  return 0 on success
+ *  return -1 on failure.
+ */
+int confirm_connection(Lossless_UDP *ludp, int connection_id);
+
 /*  returns the ip_port of the corresponding connection.
  *  return 0 if there is no such connection.
  */
@@ -183,6 +205,18 @@ char id_packet(Lossless_UDP *ludp, int connection_id);
  */
 int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data);
 
+/* Like read_packet() but does leaves the queue as is.
+ *  return 0 if there is no received data in the buffer.
+ *  return length of received packet if successful.
+ */
+int read_packet_silent(Lossless_UDP *ludp, int connection_id, uint8_t *data);
+
+/* Discard the next packet to be read from the queue
+ *  return 0 if success.
+ *  return -1 if failure.
+ */
+int discard_packet(Lossless_UDP *ludp, int connection_id);
+
 /*  return 0 if data could not be put in packet queue.
  *  return 1 if data was put into the queue.
  */
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index dbbfa58c..f22a8d57 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -352,13 +352,16 @@ static int m_sendname(Messenger *m, int friendnumber, uint8_t *name, uint16_t le
  *  return 0 if success.
  *  return -1 if failure.
  */
-static int setfriendname(Messenger *m, int friendnumber, uint8_t *name, uint16_t len)
+int setfriendname(Messenger *m, int friendnumber, uint8_t *name, uint16_t length)
 {
     if (friend_not_valid(m, friendnumber))
         return -1;
 
-    m->friendlist[friendnumber].name_length = len;
-    memcpy(m->friendlist[friendnumber].name, name, len);
+    if (length > MAX_NAME_LENGTH || length == 0)
+        return -1;
+
+    m->friendlist[friendnumber].name_length = length;
+    memcpy(m->friendlist[friendnumber].name, name, length);
     return 0;
 }
 
@@ -513,8 +516,10 @@ static int send_userstatus(Messenger *m, int friendnumber, USERSTATUS status)
 
 static int send_ping(Messenger *m, int friendnumber)
 {
-    m->friendlist[friendnumber].ping_lastsent = unix_time();
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_PING, 0, 0);
+    int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_PING, 0, 0);
+    if (ret == 1)
+            m->friendlist[friendnumber].ping_lastsent = unix_time();
+    return ret;
 }
 
 static int set_friend_statusmessage(Messenger *m, int friendnumber, uint8_t *status, uint16_t length)
@@ -538,7 +543,7 @@ static void set_friend_userstatus(Messenger *m, int friendnumber, USERSTATUS sta
 /* Sets whether we send read receipts for friendnumber. */
 void m_set_sends_receipts(Messenger *m, int friendnumber, int yesno)
 {
-    if (yesno != 0 || yesno != 1)
+    if (yesno != 0 && yesno != 1)
         return;
 
     if (friend_not_valid(m, friendnumber))
@@ -705,7 +710,7 @@ static void group_message_function(Group_Chat *chat, int peer_number, uint8_t *m
     }
 
     if (m->group_message)
-        (*m->group_message)(m, i, peer_number, message, length, m->group_invite_userdata);
+        (*m->group_message)(m, i, peer_number, message, length, m->group_message_userdata);
 }
 
 /* Creates a new groupchat and puts it in the chats array.
@@ -1182,6 +1187,8 @@ void doFriends(Messenger *m)
 
                         if (m->group_invite)
                             (*m->group_invite)(m, i, data, m->group_invite_userdata);
+                        
+                        break;
                     }
 
                     case PACKET_ID_JOIN_GROUPCHAT: {
@@ -1197,6 +1204,12 @@ void doFriends(Messenger *m)
                             break;
 
                         group_newpeer(m->chats[groupnum], data + crypto_box_PUBLICKEYBYTES);
+                        
+                        break;
+                    }
+                        
+                    default: {
+                        break;
                     }
                 }
             } else {
@@ -1231,6 +1244,11 @@ void doInbound(Messenger *m)
         int friend_id = getfriend_id(m, public_key);
 
         if (friend_id != -1) {
+            if (m_get_friend_connectionstatus(m, friend_id) == 1) {
+                kill_connection(m->net_crypto->lossless_udp, inconnection);
+                return;
+            }
+
             crypto_kill(m->net_crypto, m->friendlist[friend_id].crypt_connection_id);
             m->friendlist[friend_id].crypt_connection_id =
                 accept_crypto_inbound(m->net_crypto, inconnection, public_key, secret_nonce, session_key);
@@ -1263,8 +1281,8 @@ void doMessenger(Messenger *m)
 
     do_DHT(m->dht);
     do_net_crypto(m->net_crypto);
-    doInbound(m);
     doFriends(m);
+    doInbound(m);
     do_allgroupchats(m);
     LANdiscovery(m);
 
@@ -1425,12 +1443,12 @@ static int Messenger_load_old(Messenger *m, uint8_t *data, uint32_t length)
     if (length < size)
         return -1;
 
-    if (DHT_load_old(m->dht, data, size) == -1)
+    if (DHT_load_old(m->dht, data, size) == -1) {
 #ifdef DEBUG
         fprintf(stderr, "Data file: Something wicked happened to the stored connections...\n");
-
+        /* DO go on, friends/name still might be intact */
 #endif
-    /* DO go on, friends/name still might be intact */
+    }
 
     data += size;
     length -= size;
@@ -1640,6 +1658,54 @@ int Messenger_load(Messenger *m, uint8_t *data, uint32_t length)
         return Messenger_load_old(m, data, length);
 }
 
+/* Return the number of friends in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_friendlist. */
+uint32_t count_friendlist(Messenger *m)
+{
+    uint32_t ret = 0;
+    uint32_t i;
+
+    for (i = 0; i < m->numfriends; i++) {
+        if (m->friendlist[i].status > 0) {
+            ret++;
+        }
+    }
+
+    return ret;
+}
+
+/* Copy a list of valid friend IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t copy_friendlist(Messenger *m, int *out_list, uint32_t list_size)
+{
+    if (!out_list)
+        return 0;
+
+    if (m->numfriends == 0) {
+        return 0;
+    }
+
+    uint32_t i;
+    uint32_t ret = 0;
+
+    for (i = 0; i < m->numfriends; i++) {
+        if (i >= list_size) {
+            break; /* Abandon ship */
+        }
+
+        if (m->friendlist[i].status > 0) {
+            out_list[i] = i;
+            ret++;
+        }
+    }
+
+    return ret;
+}
+
 /* Allocate and return a list of valid friend id's. List must be freed by the
  * caller.
  *
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 78580dc0..0ff14de4 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -246,6 +246,16 @@ uint32_t m_sendmessage_withid(Messenger *m, int friendnumber, uint32_t theid, ui
  */
 int m_sendaction(Messenger *m, int friendnumber, uint8_t *action, uint32_t length);
 
+/* Set the name and name_length of a friend.
+ * name must be a string of maximum MAX_NAME_LENGTH length.
+ * length must be at least 1 byte.
+ * length is the length of name with the NULL terminator.
+ *
+ *  return 0 if success.
+ *  return -1 if failure.
+ */
+int setfriendname(Messenger *m, int friendnumber, uint8_t *name, uint16_t length);
+
 /* Set our nickname.
  * name must be a string of maximum MAX_NAME_LENGTH length.
  * length must be at least 1 byte.
@@ -456,6 +466,18 @@ void Messenger_save(Messenger *m, uint8_t *data);
 /* Load the messenger from data of size length. */
 int Messenger_load(Messenger *m, uint8_t *data, uint32_t length);
 
+/* Return the number of friends in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_friendlist. */
+uint32_t count_friendlist(Messenger *m);
+
+/* Copy a list of valid friend IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t copy_friendlist(Messenger *m, int *out_list, uint32_t list_size);
+
 /* Allocate and return a list of valid friend id's. List must be freed by the
  * caller.
  *
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index a2e42557..98571ce7 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -503,27 +503,26 @@ int crypto_connect(Net_Crypto *c, uint8_t *public_key, IP_Port ip_port)
  */
 int crypto_inbound(Net_Crypto *c, uint8_t *public_key, uint8_t *secret_nonce, uint8_t *session_key)
 {
-    uint32_t i;
+    while (1) {
+        int incoming_con = incoming_connection(c->lossless_udp, 1);
 
-    for (i = 0; i < MAX_INCOMING; ++i) {
-        if (c->incoming_connections[i] != -1) {
-            if (is_connected(c->lossless_udp, c->incoming_connections[i]) == 4
-                    || is_connected(c->lossless_udp, c->incoming_connections[i]) == 0) {
-                kill_connection(c->lossless_udp, c->incoming_connections[i]);
-                c->incoming_connections[i] = -1;
+        if (incoming_con != -1) {
+            if (is_connected(c->lossless_udp, incoming_con) == 4
+                    || is_connected(c->lossless_udp, incoming_con) == 0) {
+                kill_connection(c->lossless_udp, incoming_con);
                 continue;
             }
 
-            if (id_packet(c->lossless_udp, c->incoming_connections[i]) == 2) {
+            if (id_packet(c->lossless_udp, incoming_con) == 2) {
                 uint8_t temp_data[MAX_DATA_SIZE];
-                uint16_t len = read_packet(c->lossless_udp, c->incoming_connections[i], temp_data);
+                uint16_t len = read_packet_silent(c->lossless_udp, incoming_con, temp_data);
 
                 if (handle_cryptohandshake(c, public_key, secret_nonce, session_key, temp_data, len)) {
-                    int connection_id = c->incoming_connections[i];
-                    c->incoming_connections[i] = -1; /* Remove this connection from the incoming connection list. */
-                    return connection_id;
+                    return incoming_con;
                 }
             }
+        } else {
+            break;
         }
     }
 
@@ -570,7 +569,7 @@ int accept_crypto_inbound(Net_Crypto *c, int connection_id, uint8_t *public_key,
 {
     uint32_t i;
 
-    if (connection_id == -1)
+    if (discard_packet(c->lossless_udp, connection_id) == -1)
         return -1;
 
     /*
@@ -579,6 +578,10 @@ int accept_crypto_inbound(Net_Crypto *c, int connection_id, uint8_t *public_key,
      *     return -1;
      * }
      */
+
+    /* Connection is accepted. */
+    confirm_connection(c->lossless_udp, connection_id);
+
     if (realloc_cryptoconnection(c, c->crypto_connections_length + 1) == -1
             || c->crypto_connections == NULL)
         return -1;
@@ -659,41 +662,6 @@ void load_keys(Net_Crypto *c, uint8_t *keys)
     memcpy(c->self_secret_key, keys + crypto_box_PUBLICKEYBYTES, crypto_box_SECRETKEYBYTES);
 }
 
-/* Adds an incoming connection to the incoming_connection list.
- * TODO: Optimize this.
- *
- *  returns 0 if successful
- *  returns 1 if failure.
- */
-static int new_incoming(Net_Crypto *c, int id)
-{
-    uint32_t i;
-
-    for (i = 0; i < MAX_INCOMING; ++i) {
-        if (c->incoming_connections[i] == -1) {
-            c->incoming_connections[i] = id;
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-/* Handle all new incoming connections.
- * TODO: Optimize this.
- */
-static void handle_incomings(Net_Crypto *c)
-{
-    int income;
-
-    while (1) {
-        income = incoming_connection(c->lossless_udp);
-
-        if (income == -1 || new_incoming(c, income) )
-            break;
-    }
-}
-
 /* Handle received packets for not yet established crypto connections. */
 static void receive_crypto(Net_Crypto *c)
 {
@@ -748,9 +716,6 @@ static void receive_crypto(Net_Crypto *c)
                                        c->crypto_connections[i].sessionsecret_key,
                                        c->crypto_connections[i].shared_key);
                     c->crypto_connections[i].status = CONN_ESTABLISHED;
-
-                    /* Connection is accepted so we disable the auto kill by setting it to about 1 month from now. */
-                    kill_connection_in(c->lossless_udp, c->crypto_connections[i].number, 3000000);
                 } else {
                     /* This should not happen, kill the connection if it does. */
                     crypto_kill(c, i);
@@ -785,7 +750,6 @@ Net_Crypto *new_net_crypto(Networking_Core *net)
         return NULL;
     }
 
-    memset(temp->incoming_connections, -1 , sizeof(int) * MAX_INCOMING);
     return temp;
 }
 
@@ -810,7 +774,6 @@ static void kill_timedout(Net_Crypto *c)
 void do_net_crypto(Net_Crypto *c)
 {
     do_lossless_udp(c->lossless_udp);
-    handle_incomings(c);
     kill_timedout(c);
     receive_crypto(c);
 }
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index 55c1e3e3..f8eeb424 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -26,8 +26,6 @@
 
 #include "Lossless_UDP.h"
 
-#define MAX_INCOMING 64
-
 #define CRYPTO_PACKET_FRIEND_REQ    32  /* Friend request crypto packet ID. */
 #define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
 
@@ -66,9 +64,6 @@ typedef struct {
     uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
     uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
 
-    /* keeps track of the connection numbers for friends request so we can check later if they were sent. */
-    int incoming_connections[MAX_INCOMING];
-
     Cryptopacket_Handles cryptopackethandlers[256];
 } Net_Crypto;
 
diff --git a/toxcore/network.c b/toxcore/network.c
index 49e1726c..619248d8 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -28,6 +28,72 @@
 #include "network.h"
 #include "util.h"
 
+#ifndef IPV6_V6ONLY
+#define IPV6_V6ONLY 27
+#endif
+
+#ifdef WIN32
+
+static const char *inet_ntop(sa_family_t family, void *addr, char *buf, size_t bufsize)
+{
+    if (family == AF_INET) {
+        struct sockaddr_in saddr = { 0 };
+        saddr.sin_family = AF_INET;
+        saddr.sin_addr = *(struct in_addr *)addr;
+
+        DWORD len = bufsize;
+
+        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), NULL, buf, &len))
+            return NULL;
+
+        return buf;
+    } else if (family == AF_INET6) {
+        struct sockaddr_in6 saddr = { 0 };
+        saddr.sin6_family = AF_INET6;
+        saddr.sin6_addr = *(struct in6_addr *)addr;
+
+        DWORD len = bufsize;
+
+        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), NULL, buf, &len))
+            return NULL;
+
+        return buf;
+    }
+
+    return NULL;
+}
+
+static int inet_pton(sa_family_t family, const char *addrString, void *addrbuf)
+{
+    if (family == AF_INET) {
+        struct sockaddr_in saddr = { 0 };
+
+        INT len = sizeof(saddr);
+
+        if (WSAStringToAddress((LPTSTR)addrString, AF_INET, NULL, (LPSOCKADDR)&saddr, &len))
+            return 0;
+
+        *(struct in_addr *)addrbuf = saddr.sin_addr;
+
+        return 1;
+    } else if (family == AF_INET6) {
+        struct sockaddr_in6 saddr = { 0 };
+
+        INT len = sizeof(saddr);
+
+        if (WSAStringToAddress((LPTSTR)addrString, AF_INET6, NULL, (LPSOCKADDR)&saddr, &len))
+            return 0;
+
+        *(struct in6_addr *)addrbuf = saddr.sin6_addr;
+
+        return 1;
+    }
+
+    return 0;
+}
+
+#endif
+
 /*  return current UNIX time in microseconds (us). */
 uint64_t current_time(void)
 {
@@ -407,7 +473,7 @@ Networking_Core *new_networking(IP ip, uint16_t port)
 #ifdef LOGGING
         res =
 #endif
-            setsockopt(temp->sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
+            setsockopt(temp->sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq));
 #ifdef LOGGING
 
         if (res < 0) {
diff --git a/toxcore/network.h b/toxcore/network.h
index 4432baed..0d2b5786 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -40,6 +40,15 @@
 #include <ws2tcpip.h>
 
 typedef unsigned int sock_t;
+typedef INT sa_family_t;
+
+#ifndef IN6_ARE_ADDR_EQUAL
+#define IN6_ARE_ADDR_EQUAL(a,b) \
+    ((((__const uint32_t *) (a))[0] == ((__const uint32_t *) (b))[0]) \
+  && (((__const uint32_t *) (a))[1] == ((__const uint32_t *) (b))[1]) \
+  && (((__const uint32_t *) (a))[2] == ((__const uint32_t *) (b))[2]) \
+  && (((__const uint32_t *) (a))[3] == ((__const uint32_t *) (b))[3]))
+#endif
 
 #else // Linux includes
 
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 4fba360b..1d7118be 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -153,6 +153,20 @@ int tox_sendaction(void *tox, int friendnumber, uint8_t *action, uint32_t length
     return m_sendaction(m, friendnumber, action, length);
 }
 
+/* Set friendnumber's nickname.
+ * name must be a string of maximum MAX_NAME_LENGTH length.
+ * length must be at least 1 byte.
+ * length is the length of name with the NULL terminator.
+ *
+ *  return 0 if success.
+ *  return -1 if failure.
+ */
+int tox_setfriendname(void *tox, int friendnumber, uint8_t *name, uint16_t length)
+{
+    Messenger *m = tox;
+    return setfriendname(m, friendnumber, name, length);
+}
+
 /* Set our nickname.
  * name must be a string of maximum MAX_NAME_LENGTH length.
  * length must be at least 1 byte.
@@ -262,16 +276,24 @@ void tox_set_sends_receipts(void *tox, int friendnumber, int yesno)
     m_set_sends_receipts(m, friendnumber, yesno);
 }
 
-/* Allocate and return a list of valid friend id's. List must be freed by the
- * caller.
- *
- * retun 0 if success.
- * return -1 if failure.
- */
-int tox_get_friendlist(void *tox, int **out_list, uint32_t *out_list_length)
+/* Return the number of friends in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_friendlist. */
+uint32_t tox_count_friendlist(void *tox)
+{
+    Messenger *m = tox;
+    return count_friendlist(m);
+}
+
+/* Copy a list of valid friend IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t tox_copy_friendlist(void *tox, int *out_list, uint32_t list_size)
 {
     Messenger *m = tox;
-    return get_friendlist(m, out_list, out_list_length);
+    return copy_friendlist(m, out_list, list_size);
 }
 
 /* Set the function that will be executed when a friend request is received.
diff --git a/toxcore/tox.h b/toxcore/tox.h
index b39008fe..eabbb1af 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -36,6 +36,13 @@
 #include <windows.h>
 #include <ws2tcpip.h>
 
+typedef INT sa_family_t;
+#ifndef true
+#define true 1
+#endif
+#ifndef false
+#define false 0
+#endif
 #else
 
 #include <netinet/ip.h>
@@ -214,6 +221,16 @@ uint32_t tox_sendmessage_withid(Tox *tox, int friendnumber, uint32_t theid, uint
  */
 int tox_sendaction(Tox *tox, int friendnumber, uint8_t *action, uint32_t length);
 
+/* Set friendnumber's nickname.
+ * name must be a string of maximum MAX_NAME_LENGTH length.
+ * length must be at least 1 byte.
+ * length is the length of name with the NULL terminator.
+ *
+ *  return 0 if success.
+ *  return -1 if failure.
+ */
+int tox_setfriendname(void *tox, int friendnumber, uint8_t *name, uint16_t length);
+
 /* Set our nickname.
  * name must be a string of maximum MAX_NAME_LENGTH length.
  * length must be at least 1 byte.
@@ -280,13 +297,17 @@ TOX_USERSTATUS tox_get_selfuserstatus(Tox *tox);
  */
 void tox_set_sends_receipts(Tox *tox, int friendnumber, int yesno);
 
-/* Allocate and return a list of valid friend id's. List must be freed by the
- * caller.
- *
- * retun 0 if success.
- * return -1 if failure.
- */
-int tox_get_friendlist(void *tox, int **out_list, uint32_t *out_list_length);
+/* Return the number of friends in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_friendlist. */
+uint32_t tox_count_friendlist(void *tox);
+
+/* Copy a list of valid friend IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t tox_copy_friendlist(void *tox, int *out_list, uint32_t list_size);
 
 /* Set the function that will be executed when a friend request is received.
  *  Function format is function(uint8_t * public_key, uint8_t * data, uint16_t length)