15 files changed, 335 insertions, 160 deletions

diff --git a/INSTALL.md b/INSTALL.md
index b8265951..9eea323a 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -54,6 +54,11 @@ make check
 sudo make install
 cd ..
 ```
+If your default prefix is /usr/local and you happen to get an error that says "error while loading shared libraries: libtoxcore.so.0: cannot open shared object file: No such file or directory", then you can try running ```sudo ldconfig```. If that doesn't fix it, run:
+```
+sudo echo "/usr/local/lib/" >> /etc/ld.so.conf.d/locallib.conf
+sudo ldconfig
+```
 
 You also need recent [FFmpeg](http://git.videolan.org/?p=ffmpeg.git) libraries:
 ```bash
diff --git a/auto_tests/Makefile.inc b/auto_tests/Makefile.inc
index 6c59eebb..9c06bc78 100644
--- a/auto_tests/Makefile.inc
+++ b/auto_tests/Makefile.inc
@@ -4,15 +4,12 @@ TESTS = messenger_autotest crypto_test network_test
 
 check_PROGRAMS = messenger_autotest crypto_test network_test
 
-messenger_autotest_SOURCES = \
-                        ../auto_tests/messenger_test.c
-
-messenger_autotest_CFLAGS = \
-                        $(LIBSODIUM_CFLAGS) \
-                        $(NACL_CFLAGS) \
-                        $(CHECK_CFLAGS)
-
-messenger_autotest_LDADD = \
+AUTOTEST_CFLAGS = \
+                         $(LIBSODIUM_CFLAGS) \
+                         $(NACL_CFLAGS) \
+                         $(CHECK_CFLAGS)
+ 
+AUTOTEST_LDADD = \
                         $(LIBSODIUM_LDFLAGS) \
                         $(NACL_LDFLAGS) \
                         libtoxcore.la \
@@ -20,35 +17,26 @@ messenger_autotest_LDADD = \
                         $(NACL_LIBS) \
                         $(CHECK_LIBS)
 
+messenger_autotest_SOURCES = ../auto_tests/messenger_test.c
+
+messenger_autotest_CFLAGS = $(AUTOTEST_CFLAGS)
+
+messenger_autotest_LDADD = $(AUTOTEST_LDADD)
+
 
 crypto_test_SOURCES =   ../auto_tests/crypto_test.c
 
-crypto_test_CFLAGS =    $(LIBSODIUM_CFLAGS) \
-                        $(NACL_CFLAGS) \
-                        $(CHECK_CFLAGS)
+crypto_test_CFLAGS = $(AUTOTEST_CFLAGS)
 
-crypto_test_LDADD =     $(LIBSODIUM_LDFLAGS) \
-                        $(NACL_LDFLAGS) \
-                        libtoxcore.la \
-                        $(LIBSODIUM_LIBS) \
-                        $(NACL_LIBS) \
-                        $(CHECK_LIBS)
+crypto_test_LDADD = $(AUTOTEST_LDADD)
 
-network_test_SOURCES = \
-                        ../auto_tests/network_test.c
 
-network_test_CFLAGS = \
-                        $(LIBSODIUM_CFLAGS) \
-                        $(NACL_CFLAGS) \
-                        $(CHECK_CFLAGS)
+network_test_SOURCES = ../auto_tests/network_test.c
+
+network_test_CFLAGS = $(AUTOTEST_CFLAGS)
+
+network_test_LDADD = $(AUTOTEST_LDADD)
 
-network_test_LDADD = \
-                        $(LIBSODIUM_LDFLAGS) \
-                        $(NACL_LDFLAGS) \
-                        libtoxcore.la \
-                        $(LIBSODIUM_LIBS) \
-                        $(NACL_LIBS) \
-                        $(CHECK_LIBS)
 
 endif
 
diff --git a/auto_tests/skeleton_test.c b/auto_tests/skeleton_test.c
new file mode 100644
index 00000000..89ef1b8b
--- /dev/null
+++ b/auto_tests/skeleton_test.c
@@ -0,0 +1,53 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <string.h>
+#include <check.h>
+#include <stdlib.h>
+#include <time.h>
+
+/*
+#include "../<stuff to test>"
+*/
+
+START_TEST(test_creativetestnamegoeshere)
+{
+    uint8_t test = 0;
+    ck_assert_msg(test == 0, "test: expected result 0, got %u.", test);
+}
+END_TEST
+
+
+#define DEFTESTCASE(NAME) \
+    TCase *tc_##NAME = tcase_create(#NAME); \
+    tcase_add_test(tc_##NAME, test_##NAME); \
+    suite_add_tcase(s, tc_##NAME);
+
+Suite *creativesuitenamegoeshere_suite(void)
+{
+    Suite *s = suite_create("creativesuitedescritptiongoeshere");
+
+    DEFTESTCASE(/* remove test_ from test function names */ creativetestnamegoeshere);
+
+    return s;
+}
+
+int main(int argc, char *argv[])
+{
+    srand((unsigned int) time(NULL));
+
+    Suite *creativesuitenamegoeshere = creativesuitenamegoeshere_suite();
+    SRunner *test_runner = srunner_create(creativesuitenamegoeshere);
+
+    int number_failed = 0;
+    srunner_run_all(test_runner, CK_NORMAL);
+    number_failed = srunner_ntests_failed(test_runner);
+
+    srunner_free(test_runner);
+
+    return number_failed;
+}
+
diff --git a/docs/Hardening.txt b/docs/Hardening.txt
index 838b3566..d95b2cda 100644
--- a/docs/Hardening.txt
+++ b/docs/Hardening.txt
@@ -45,4 +45,16 @@ to us then it is good.
 
 Problems with this: People don't always have at least one online friend.
 
-2. ...
+2. Pick random nodes (add ourselves some random (fake) friends to increase the 
+pool of available nodes) and make then send requests to other nodes, the 
+response is then relayed back to us and compared to how the node should have 
+behaved. If the node is found to be behaving correctly, it is set as trusted. 
+Only trusted nodes are sent in send node packets, that is unless the exact node 
+being queried for in the getnode packet is present, it will be sent in the 
+sendnode packet even if it is not trusted.
+
+The hypothesis is that if to be part of the network nodes have to behave 
+correctly it should prevent disruption from nodes that behave incorrectly.
+
+(This idea is currently being implemented in the harden branch.)
+...
diff --git a/docs/av_api.md b/docs/av_api.md
index 08e05a6d..17930144 100644
--- a/docs/av_api.md
+++ b/docs/av_api.md
@@ -1,10 +1,13 @@
-A/V API reference
+#A/V API reference
 
-Take toxmsi/phone.c as a reference
+##Take toxmsi/phone.c as a reference
 
-Initialization:
+###Initialization:
 
+```
 phone_t* initPhone(uint16_t _listen_port, uint16_t _send_port);
+```
+
 function initializes sample phone. _listen_port and _send_port are variables only meant
 for local testing. You will not have to do anything regarding to that since
 everything will be started within a mesenger.
@@ -13,17 +16,22 @@ everything will be started within a mesenger.
 Phone requires one msi session and two rtp sessions ( one for audio and one for
 video ). 
 
+```
 msi_session_t* msi_init_session( void* _core_handler, const uint8_t* _user_agent );
+```
 
 initializes msi session.
 Params:
+
+```
 void* _core_handler - pointer to an object handling networking,
 const uint8_t* _user_agent - string describing phone client version.
+```
 
 Return value:
 msi_session_t* - pointer to a newly created msi session handler.
 
-msi_session_t reference:
+###msi_session_t reference:
 
 How to handle msi session:
 Controling is done via callbacks and action handlers.
@@ -32,6 +40,7 @@ NOT TO PLACE SOMETHING LIKE LOOPS THAT TAKES A LOT OF TIME TO EXECUTE; every cal
 directly from event loop. You can find examples in phone.c.
 
 Register callbacks: 
+```
 void msi_register_callback_call_started ( MCALLBACK );
 void msi_register_callback_call_canceled ( MCALLBACK );
 void msi_register_callback_call_rejected ( MCALLBACK );
@@ -44,52 +53,72 @@ void msi_register_callback_recv_ending ( MCALLBACK );
 void msi_register_callback_recv_error ( MCALLBACK );
 
 void msi_register_callback_requ_timeout ( MCALLBACK );
+```
 
 MCALLBACK is defined as: void (*callback) (void* _arg)
-msi_session_t* handler is being thrown as _arg so you can use that and _agent_handler to get to your own phone handler
+msi_session_t* handler is being thrown as \_arg so you can use that and \_agent_handler to get to your own phone handler
 directly from callback.
 
 
 Actions:
+
+```
 int msi_invite ( msi_session_t* _session, call_type _call_type, uint32_t _timeoutms );
+```
+
 Sends call invite. Before calling/sending invite msi_session_t::_friend_id is needed to be set or else
 it will not work. _call_type is type of the call ( Audio/Video ) and _timeoutms is how long 
 will poll wait until request is terminated.
 
+```
 int msi_hangup ( msi_session_t* _session );
+```
 Hangs up active call
 
+```
 int msi_answer ( msi_session_t* _session, call_type _call_type );
+```
 Answer incomming call. _call_type set's callee call type.
 
+```
 int msi_cancel ( msi_session_t* _session );
+```
 Cancel current request.
 
+```
 int msi_reject ( msi_session_t* _session );
+```
 Reject incomming call.
 
 
+###Now for rtp:
 
-
-Now for rtp:
 You will need 2 sessions; one for audio one for video.
 You start them with:
-
+```
 rtp_session_t* rtp_init_session ( int _max_users, int _multi_session );
+```
 
 Params:
+```
 int _max_users - max users. -1 if undefined
 int _multi_session - any positive number means uses multi session; -1 if not.
+```
 
 Return value:
+```
 rtp_session_t* - pointer to a newly created rtp session handler.
+```
 
-How to handle rtp session:
+###How to handle rtp session:
 Take a look at
+```
 void* phone_handle_media_transport_poll ( void* _hmtc_args_p ) in phone.c
+```
 on example. Basically what you do is just receive a message via:
-
+```
 struct rtp_msg_s* rtp_recv_msg ( rtp_session_t* _session );
+```
 
 and then you use payload within the rtp_msg_s struct. Don't forget to deallocate it with:
 void rtp_free_msg ( rtp_session_t* _session, struct rtp_msg_s* _msg );
@@ -98,17 +127,20 @@ Receiving should be thread safe so don't worry about that.
 When you capture and encode a payload you want to send it ( obviously ).
 
 first create a new message with:
+```
 struct rtp_msg_s* rtp_msg_new ( rtp_session_t* _session, const uint8_t* _data, uint32_t _length );
+```
 
 and then send it with:
+```
 int rtp_send_msg ( rtp_session_t* _session, struct rtp_msg_s* _msg, void* _core_handler );
+```
 
 _core_handler is the same network handler as in msi_session_s struct.
 
 
-
-A/V initialization:
-
+##A/V initialization:
+```
 int init_receive_audio(codec_state *cs);
 int init_receive_video(codec_state *cs);
 Initialises the A/V decoders. On failure it will print the reason and return 0. On success it will return 1.
@@ -122,30 +154,36 @@ int video_encoder_refresh(codec_state *cs, int bps);
 Reinitialises the video encoder with a new bitrate. ffmpeg does not expose the needed VP8 feature to change the bitrate on the fly, so this serves as a workaround.
 In the future, VP8 should be used directly and ffmpeg should be dropped from the dependencies.
 The variable bps is the required bitrate in bits per second.
+```
 
 
-
-A/V encoding/decoding:
-
+###A/V encoding/decoding:
+```
 void *encode_video_thread(void *arg);
+```
 Spawns the video encoding thread. The argument should hold a pointer to a codec_state.
 This function should only be called if video encoding is supported (when init_send_video returns 1).
 Each video frame gets encoded into a packet, which is sent via RTP. Every 60 frames a new bidirectional interframe is encoded.
-
+```
 void *encode_audio_thread(void *arg);
+```
 Spawns the audio encoding thread. The argument should hold a pointer to a codec_state.
 This function should only be called if audio encoding is supported (when init_send_audio returns 1).
 Audio frames are read from the selected audio capture device during intitialisation. This audio capturing can be rerouted to a different device on the fly.
 Each audio frame is encoded into a packet, and sent via RTP. All audio frames have the same amount of samples, which is defined in AV_codec.h.
-
+```
 int video_decoder_refresh(codec_state *cs, int width, int height);
+```
 Sets the SDL window dimensions and creates a pixel buffer with the requested size. It also creates a scaling context, which will be used to convert the input image format to YUV420P.
 
+```
 void *decode_video_thread(void *arg);
+```
 Spawns a video decoding thread. The argument should hold a pointer to a codec_state. The codec_state is assumed to contain a successfully initialised video decoder.
 This function reads video packets and feeds them to the video decoder. If the video frame's resolution has changed, video_decoder_refresh() is called. Afterwards, the frame is displayed on the SDL window.
-
+```
 void *decode_audio_thread(void *arg);
+```
 Spawns an audio decoding thread. The argument should hold a pointer to a codec_state. The codec_state is assumed to contain a successfully initialised audio decoder.
 All received audio packets are pushed into a jitter buffer and are reordered. If there is a missing packet, or a packet has arrived too late, it is treated as a lost packet and the audio decoder is informed of the packet loss. The audio decoder will then try to reconstruct the lost packet, based on information from previous packets.
 Audio is played on the default OpenAL output device.
@@ -153,4 +191,4 @@ Audio is played on the default OpenAL output device.
 
 If you have any more qustions/bug reports/feature request contact the following users on the irc channel #tox-dev on irc.freenode.net:
 For RTP and MSI: mannol
-For audio and video: Martijnvdc
\ No newline at end of file
+For audio and video: Martijnvdc
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index c43382ed..b9ba7e1d 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -814,110 +814,109 @@ static uint8_t sent_getnode_to_node(DHT *dht, uint8_t *client_id, IP_Port node_i
 /* Function is needed in following functions. */
 static int send_hardening_getnode_res(DHT *dht, Node_format *sendto, Node_format *list, uint16_t num_nodes);
 
-static int handle_sendnodes(void *object, IP_Port source, uint8_t *packet, uint32_t length)
+static int handle_sendnodes_core(void *object, IP_Port source, uint8_t *packet, uint32_t length,
+                                 size_t node_format_size, uint8_t *plain, uint16_t plain_length, uint32_t *num_nodes_out, Node_format *sendback_node)
 {
+    if (plain_length != MAX_SENT_NODES * node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH)
+        return 1;
+
     DHT *dht = object;
-    uint32_t cid_size = 1 + CLIENT_ID_SIZE;
-    cid_size += crypto_box_NONCEBYTES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES;
+    uint32_t cid_size = 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES;
 
-    size_t Node4_format_size = sizeof(Node4_format);
+    if (length <= cid_size) /* too short */
+        return 1;
+
+    uint32_t data_size = length - cid_size;
 
-    if (length > (cid_size + Node4_format_size * MAX_SENT_NODES) ||
-            ((length - cid_size) % Node4_format_size) != 0 ||
-            (length < cid_size + Node4_format_size))
+    if ((data_size % node_format_size) != 0) /* invalid length */
         return 1;
 
-    uint32_t num_nodes = (length - cid_size) / Node4_format_size;
-    uint8_t plain[Node4_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint32_t num_nodes = data_size / node_format_size;
+
+    if (num_nodes > MAX_SENT_NODES) /* too long */
+        return 1;
 
     int len = decrypt_data(
                   packet + 1,
                   dht->c->self_secret_key,
                   packet + 1 + CLIENT_ID_SIZE,
                   packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                  num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES, plain );
+                  num_nodes * node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES,
+                  plain);
+
+    if ((unsigned int)len != num_nodes * node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH)
+        return 1;
 
-    if ((unsigned int)len != num_nodes * Node4_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH)
+    if (!sent_getnode_to_node(dht, packet + 1, source, plain + num_nodes * node_format_size, sendback_node))
         return 1;
 
+    /* store the address the *request* was sent to */
+    addto_lists(dht, source, packet + 1);
+
+    *num_nodes_out = num_nodes;
+
+    return 0;
+}
+
+static int handle_sendnodes(void *object, IP_Port source, uint8_t *packet, uint32_t length)
+{
+    DHT *dht = object;
+    size_t node4_format_size = sizeof(Node4_format);
+    uint8_t plain[node4_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint32_t num_nodes;
+
     Node_format sendback_node;
 
-    if (!sent_getnode_to_node(dht, packet + 1, source, plain + num_nodes * Node4_format_size, &sendback_node))
+    if (handle_sendnodes_core(object, source, packet, length, node4_format_size, plain, sizeof(plain), &num_nodes,
+                              &sendback_node))
         return 1;
 
     Node4_format *nodes4_list = (Node4_format *)(plain);
+    uint32_t i;
+
+    IP_Port ipp;
+    ipp.ip.family = AF_INET;
+
     Node_format nodes_list[MAX_SENT_NODES];
-    uint32_t i, num_nodes_ok = 0;
 
-    /* blow up from Node4 (IPv4) wire format to Node (IPv4/IPv6) structure */
     for (i = 0; i < num_nodes; i++)
         if ((nodes4_list[i].ip_port.ip.uint32 != 0) && (nodes4_list[i].ip_port.ip.uint32 != (uint32_t)~0)) {
-            memcpy(nodes_list[num_nodes_ok].client_id, nodes4_list[i].client_id, CLIENT_ID_SIZE);
-            nodes_list[num_nodes_ok].ip_port.ip.family = AF_INET;
-            nodes_list[num_nodes_ok].ip_port.ip.ip4.uint32 = nodes4_list[i].ip_port.ip.uint32;
-            nodes_list[num_nodes_ok].ip_port.port = nodes4_list[i].ip_port.port;
+            ipp.ip.ip4.uint32 = nodes4_list[i].ip_port.ip.uint32;
+            ipp.port = nodes4_list[i].ip_port.port;
 
-            num_nodes_ok++;
-        }
+            send_ping_request(dht->ping, ipp, nodes4_list[i].client_id);
+            returnedip_ports(dht, ipp, nodes4_list[i].client_id, packet + 1);
 
-    if (num_nodes_ok < num_nodes) {
-        /* shouldn't happen */
-        num_nodes = num_nodes_ok;
-    }
+            memcpy(nodes_list[i].client_id, nodes4_list[i].client_id, CLIENT_ID_SIZE);
+            ipport_copy(&nodes_list[i].ip_port, &ipp);
+        }
 
     send_hardening_getnode_res(dht, &sendback_node, nodes_list, num_nodes);
-    addto_lists(dht, source, packet + 1);
-
-    for (i = 0; i < num_nodes; ++i)  {
-        send_ping_request(dht->ping, nodes_list[i].ip_port, nodes_list[i].client_id);
-        returnedip_ports(dht, nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1);
-    }
-
     return 0;
 }
 
 static int handle_sendnodes_ipv6(void *object, IP_Port source, uint8_t *packet, uint32_t length)
 {
     DHT *dht = object;
-    uint32_t cid_size = 1 + CLIENT_ID_SIZE;
-    cid_size += crypto_box_NONCEBYTES + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES;
-
-    size_t Node_format_size = sizeof(Node_format);
-
-    if (length > (cid_size + Node_format_size * MAX_SENT_NODES) ||
-            ((length - cid_size) % Node_format_size) != 0 ||
-            (length < cid_size + Node_format_size))
-        return 1;
-
-    uint32_t num_nodes = (length - cid_size) / Node_format_size;
-    uint8_t plain[Node_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
-
-    int len = decrypt_data(
-                  packet + 1,
-                  dht->c->self_secret_key,
-                  packet + 1 + CLIENT_ID_SIZE,
-                  packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                  num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH + crypto_box_MACBYTES, plain );
-
-    if ((unsigned int)len != num_nodes * Node_format_size + NODES_ENCRYPTED_MESSAGE_LENGTH)
-        return 1;
+    size_t node_format_size = sizeof(Node_format);
+    uint8_t plain[node_format_size * MAX_SENT_NODES + NODES_ENCRYPTED_MESSAGE_LENGTH];
+    uint32_t num_nodes;
 
     Node_format sendback_node;
 
-    if (!sent_getnode_to_node(dht, packet + 1, source, plain + num_nodes * Node_format_size, &sendback_node))
+    if (handle_sendnodes_core(object, source, packet, length, node_format_size, plain, sizeof(plain), &num_nodes,
+                              &sendback_node))
         return 1;
 
+    Node_format *nodes_list = (Node_format *)(plain);
     uint32_t i;
-    Node_format nodes_list[MAX_SENT_NODES];
-    memcpy(nodes_list, plain, num_nodes * sizeof(Node_format));
-
     send_hardening_getnode_res(dht, &sendback_node, nodes_list, num_nodes);
-    addto_lists(dht, source, packet + 1);
 
-    for (i = 0; i < num_nodes; ++i)  {
-        send_ping_request(dht->ping, nodes_list[i].ip_port, nodes_list[i].client_id);
-        returnedip_ports(dht, nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1);
-    }
+    for (i = 0; i < num_nodes; i++)
+        if (ipport_isset(&nodes_list[i].ip_port)) {
+            send_ping_request(dht->ping, nodes_list[i].ip_port, nodes_list[i].client_id);
+            returnedip_ports(dht, nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1);
+        }
 
     return 0;
 }
diff --git a/toxcore/Lossless_UDP.c b/toxcore/Lossless_UDP.c
index 04533a3b..79ee32c3 100644
--- a/toxcore/Lossless_UDP.c
+++ b/toxcore/Lossless_UDP.c
@@ -833,8 +833,7 @@ static int handle_SYNC2(Lossless_UDP *ludp, int connection_id, uint8_t counter,
 {
     Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
 
-    if (recv_packetnum == connection->orecv_packetnum) {
-        /* && sent_packetnum == connection->osent_packetnum) */
+    if (recv_packetnum == connection->orecv_packetnum && sent_packetnum == connection->osent_packetnum) {
         connection->status = LUDP_ESTABLISHED;
         connection->recv_counter = counter;
         ++connection->send_counter;
@@ -862,8 +861,8 @@ static void adjust_datasendspeed(Connection *connection, uint32_t req_packets)
         return;
     }
 
-    if (req_packets <= (connection->data_rate / connection->SYNC_rate) / 5 || req_packets <= 10) {
-        connection->data_rate += (connection->data_rate / 8) + 1;
+    if (req_packets <= (connection->data_rate / connection->SYNC_rate) / 4 || req_packets <= 10) {
+        connection->data_rate += (connection->data_rate / 4) + 1;
 
         if (connection->data_rate > connection->sendbuffer_length * connection->SYNC_rate)
             connection->data_rate = connection->sendbuffer_length * connection->SYNC_rate;
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index be3d82e0..659c837b 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -868,13 +868,36 @@ int m_group_peername(Messenger *m, int groupnumber, int peernumber, uint8_t *nam
 
     return group_peername(m->chats[groupnumber], peernumber, name);
 }
+
+/* Store the fact that we invited a specific friend.
+ */
+static void group_store_friendinvite(Messenger *m, int friendnumber, int groupnumber)
+{
+    /* Add 1 to the groupchat number because 0 (default value in invited_groups) is a valid groupchat number */
+    m->friendlist[friendnumber].invited_groups[m->friendlist[friendnumber].invited_groups_num % MAX_INVITED_GROUPS] =
+        groupnumber + 1;
+    ++m->friendlist[friendnumber].invited_groups_num;
+}
+
 /* return 1 if that friend was invited to the group
  * return 0 if the friend was not or error.
  */
 static uint8_t group_invited(Messenger *m, int friendnumber, int groupnumber)
 {
-    //TODO: this function;
-    return 1;
+
+    uint32_t i;
+    uint16_t num = MAX_INVITED_GROUPS;
+
+    if (MAX_INVITED_GROUPS > m->friendlist[friendnumber].invited_groups_num)
+        num = m->friendlist[friendnumber].invited_groups_num;
+
+    for (i = 0; i < num; ++i) {
+        if (m->friendlist[friendnumber].invited_groups[i] == groupnumber + 1) {
+            return 1;
+        }
+    }
+
+    return 0;
 }
 
 /* invite friendnumber to groupnumber
@@ -892,7 +915,8 @@ int invite_friend(Messenger *m, int friendnumber, int groupnumber)
     if (m->friendlist[friendnumber].status == NOFRIEND || m->chats[groupnumber] == NULL)
         return -1;
 
-    //TODO: store invited friends.
+    group_store_friendinvite(m, friendnumber, groupnumber);
+
     if (write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_GROUPCHAT, m->chats[groupnumber]->self_public_key,
                              crypto_box_PUBLICKEYBYTES) == 0)
         return -1;
@@ -1782,10 +1806,10 @@ void do_messenger(Messenger *m)
 
 #ifdef LOGGING
 
-    if (now() > lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) {
+    if (unix_time() > lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) {
         loglog(" = = = = = = = = \n");
 
-        lastdump = now();
+        lastdump = unix_time();
         uint32_t client, last_pinged;
 
         for (client = 0; client < LCLIENT_LIST; client++) {
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index aa9d8632..10ac0eae 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -52,6 +52,9 @@
 #define PACKET_ID_JOIN_GROUPCHAT 145
 #define PACKET_ID_ACCEPT_GROUPCHAT 146
 
+/* Max number of groups we can invite someone at the same time to. */
+#define MAX_INVITED_GROUPS 64
+
 /* Status definitions. */
 enum {
     NOFRIEND,
@@ -148,6 +151,8 @@ typedef struct {
     uint64_t ping_lastsent;
     struct File_Transfers file_sending[MAX_CONCURRENT_FILE_PIPES];
     struct File_Transfers file_receiving[MAX_CONCURRENT_FILE_PIPES];
+    int invited_groups[MAX_INVITED_GROUPS];
+    uint16_t invited_groups_num;
 } Friend;
 
 typedef struct Messenger {
diff --git a/toxcore/group_chats.c b/toxcore/group_chats.c
index 5831e7d4..6ad41c7f 100644
--- a/toxcore/group_chats.c
+++ b/toxcore/group_chats.c
@@ -205,13 +205,15 @@ static int addpeer(Group_Chat *chat, uint8_t *client_id)
 
     Group_Peer *temp;
     temp = realloc(chat->group, sizeof(Group_Peer) * (chat->numpeers + 1));
-    memset(&(temp[chat->numpeers]), 0, sizeof(Group_Peer));
 
     if (temp == NULL)
         return -1;
 
+    memset(&(temp[chat->numpeers]), 0, sizeof(Group_Peer));
     chat->group = temp;
     id_copy(chat->group[chat->numpeers].client_id, client_id);
+    chat->group[chat->numpeers].last_recv = unix_time();
+    chat->group[chat->numpeers].last_recv_msgping = unix_time();
     ++chat->numpeers;
     return (chat->numpeers - 1);
 }
@@ -287,7 +289,8 @@ static int send_getnodes(Group_Chat *chat, IP_Port ip_port, int peernum)
     chat->group[peernum].last_pinged = unix_time();
     chat->group[peernum].pingid = contents.pingid;
 
-    return send_groupchatpacket(chat, ip_port, chat->group[peernum].client_id, (uint8_t *)&contents, sizeof(contents), 48);
+    return send_groupchatpacket(chat, ip_port, chat->group[peernum].client_id, (uint8_t *)&contents, sizeof(contents),
+                                CRYPTO_PACKET_GROUP_CHAT_GET_NODES);
 }
 
 static int send_sendnodes(Group_Chat *chat, IP_Port ip_port, int peernum, uint64_t pingid)
@@ -308,7 +311,7 @@ static int send_sendnodes(Group_Chat *chat, IP_Port ip_port, int peernum, uint64
     }
 
     return send_groupchatpacket(chat, ip_port, chat->group[peernum].client_id, (uint8_t *)&contents,
-                                sizeof(contents.pingid) + sizeof(groupchat_nodes) * j, 49);
+                                sizeof(contents.pingid) + sizeof(groupchat_nodes) * j, CRYPTO_PACKET_GROUP_CHAT_SEND_NODES);
 }
 
 static int handle_getnodes(Group_Chat *chat, IP_Port source, int peernum, uint8_t *data, uint32_t len)
@@ -392,9 +395,9 @@ static int handle_data(Group_Chat *chat, uint8_t *data, uint32_t len)
 
         if (chat->group[peernum].last_recv == temp_time)
             return 1;
-
-        chat->group[peernum].last_recv = temp_time;
     */
+    chat->group[peernum].last_recv = unix_time();
+
     uint32_t message_num;
     memcpy(&message_num, data + crypto_box_PUBLICKEYBYTES, sizeof(uint32_t));
     message_num = ntohl(message_num);
@@ -412,21 +415,21 @@ static int handle_data(Group_Chat *chat, uint8_t *data, uint32_t len)
     uint16_t contents_len = len - GROUP_DATA_MIN_SIZE;
 
     switch (data[crypto_box_PUBLICKEYBYTES + sizeof(message_num)]) {
-        case 0: /* If message is ping */
+        case GROUP_CHAT_PING: /* If message is ping */
             if (contents_len != 0)
                 return 1;
 
             chat->group[peernum].last_recv_msgping = unix_time();
             break;
 
-        case 16: /* If message is new peer */
+        case GROUP_CHAT_NEW_PEER: /* If message is new peer */
             if (contents_len != crypto_box_PUBLICKEYBYTES)
                 return 1;
 
             addpeer(chat, contents);
             break;
 
-        case 64: /* If message is chat message */
+        case GROUP_CHAT_CHAT_MESSAGE: /* If message is chat message */
             if (chat->group_message != NULL)
                 (*chat->group_message)(chat, peernum, contents, contents_len, chat->group_message_userdata);
 
@@ -439,7 +442,7 @@ static int handle_data(Group_Chat *chat, uint8_t *data, uint32_t len)
     }
 
     if (handled == 1) {
-        sendto_allpeers(chat, data, len, 50);
+        sendto_allpeers(chat, data, len, CRYPTO_PACKET_GROUP_CHAT_BROADCAST);
         return 0;
     }
 
@@ -461,9 +464,12 @@ static uint8_t send_data(Group_Chat *chat, uint8_t *data, uint32_t len, uint8_t
 //TODO
     id_copy(packet, chat->self_public_key);
     memcpy(packet + crypto_box_PUBLICKEYBYTES, &message_num, sizeof(message_num));
-    memcpy(packet + GROUP_DATA_MIN_SIZE, data, len);
+
+    if (len != 0)
+        memcpy(packet + GROUP_DATA_MIN_SIZE, data, len);
+
     packet[crypto_box_PUBLICKEYBYTES + sizeof(message_num)] = message_id;
-    return sendto_allpeers(chat, packet, len + GROUP_DATA_MIN_SIZE, 50);
+    return sendto_allpeers(chat, packet, len + GROUP_DATA_MIN_SIZE, CRYPTO_PACKET_GROUP_CHAT_BROADCAST);
 }
 /*
  * Handle get nodes group packet.
@@ -494,13 +500,13 @@ int handle_groupchatpacket(Group_Chat *chat, IP_Port source, uint8_t *packet, ui
         return 1;
 
     switch (number) {
-        case 48:
+        case CRYPTO_PACKET_GROUP_CHAT_GET_NODES:
             return handle_getnodes(chat, source, peernum, data, len);
 
-        case 49:
+        case CRYPTO_PACKET_GROUP_CHAT_SEND_NODES:
             return handle_sendnodes(chat, source, peernum, data, len);
 
-        case 50:
+        case CRYPTO_PACKET_GROUP_CHAT_BROADCAST:
             return handle_data(chat, data, len);
 
         default:
@@ -512,13 +518,13 @@ int handle_groupchatpacket(Group_Chat *chat, IP_Port source, uint8_t *packet, ui
 
 uint32_t group_sendmessage(Group_Chat *chat, uint8_t *message, uint32_t length)
 {
-    return send_data(chat, message, length, 64); //TODO: better return values?
+    return send_data(chat, message, length, GROUP_CHAT_CHAT_MESSAGE); //TODO: better return values?
 }
 
 uint32_t group_newpeer(Group_Chat *chat, uint8_t *client_id)
 {
     addpeer(chat, client_id);
-    return send_data(chat, client_id, crypto_box_PUBLICKEYBYTES, 16); //TODO: better return values?
+    return send_data(chat, client_id, crypto_box_PUBLICKEYBYTES, GROUP_CHAT_NEW_PEER); //TODO: better return values?
 }
 
 void callback_groupmessage(Group_Chat *chat, void (*function)(Group_Chat *chat, int, uint8_t *, uint16_t, void *),
@@ -561,10 +567,35 @@ static void ping_close(Group_Chat *chat)
     }
 }
 
+/* Interval in seconds to send ping messages */
+#define GROUP_PING_INTERVAL 30
+
+static void ping_group(Group_Chat *chat)
+{
+    if (is_timeout(chat->last_sent_ping, GROUP_PING_INTERVAL)) {
+        if (send_data(chat, 0, 0, GROUP_CHAT_PING) != 0) /* Ping */
+            chat->last_sent_ping = unix_time();
+    }
+}
+
+static void del_dead_peers(Group_Chat *chat)
+{
+    uint32_t i;
+
+    for (i = 0; i < chat->numpeers; ++i) {
+        if (is_timeout(chat->group[i].last_recv_msgping, GROUP_PING_INTERVAL * 2)) {
+            delpeer(chat, chat->group[i].client_id);
+        }
+    }
+}
+
 void do_groupchat(Group_Chat *chat)
 {
     unix_time_update();
     ping_close(chat);
+    ping_group(chat);
+    /* TODO: Maybe run this less? */
+    del_dead_peers(chat);
 }
 
 void kill_groupchat(Group_Chat *chat)
diff --git a/toxcore/group_chats.h b/toxcore/group_chats.h
index 33f0b1e6..b3f2e5a8 100644
--- a/toxcore/group_chats.h
+++ b/toxcore/group_chats.h
@@ -63,9 +63,14 @@ typedef struct Group_Chat {
     uint32_t message_number;
     void (*group_message)(struct Group_Chat *m, int, uint8_t *, uint16_t, void *);
     void *group_message_userdata;
+    uint64_t last_sent_ping;
 
 } Group_Chat;
 
+#define GROUP_CHAT_PING 0
+#define GROUP_CHAT_NEW_PEER 16
+#define GROUP_CHAT_CHAT_MESSAGE 64
+
 /* Copy the name of peernum to name.
  * name must be at least MAX_NICK_BYTES long.
  *
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index 38400ebc..74c3326a 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -29,6 +29,9 @@
 #define CRYPTO_PACKET_FRIEND_REQ    32  /* Friend request crypto packet ID. */
 #define CRYPTO_PACKET_HARDENING     48  /* Hardening crypto packet ID. */
 #define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
+#define CRYPTO_PACKET_GROUP_CHAT_GET_NODES      48 /* Group chat get Nodes packet */
+#define CRYPTO_PACKET_GROUP_CHAT_SEND_NODES     49 /* Group chat send Nodes packet */
+#define CRYPTO_PACKET_GROUP_CHAT_BROADCAST      50 /* Group chat broadcast packet */
 #define CRYPTO_HANDSHAKE_TIMEOUT (CONNECTION_TIMEOUT * 2)
 
 #define CRYPTO_CONN_NO_CONNECTION 0
diff --git a/toxcore/ping.c b/toxcore/ping.c
index 3f237836..80e85a45 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -114,28 +114,35 @@ static uint64_t add_ping(PING *ping, IP_Port ipp)  // O(n)
     return ping->pings[p].id;
 }
 
-static bool is_pinging(PING *ping, IP_Port ipp, uint64_t ping_id)    // O(n) TODO: Replace this with something else.
+/* checks if ip/port or ping_id are already in the list to ping
+ * if both are set, both must match, otherwise the set must match
+ *
+ *  returns 0 if neither is set or no match was found
+ *  returns the (index + 1) of the match if one was found
+ */
+static int is_pinging(PING *ping, IP_Port ipp, uint64_t ping_id)
 {
+    // O(n) TODO: Replace this with something else.
 
-    /* shouldn't that be an OR ? */
-    if (!ip_isset(&ipp.ip) && ping_id == 0)
-        return false;
+    /* at least one MUST be set */
+    uint8_t ip_valid = ip_isset(&ipp.ip);
 
-    size_t i, id;
+    if (!ip_valid && !ping_id)
+        return 0;
+
+    size_t i;
 
     remove_timeouts(ping);
 
     for (i = 0; i < ping->num_pings; i++) {
-        id = (ping->pos_pings + i) % PING_NUM_MAX;
+        size_t id = (ping->pos_pings + i) % PING_NUM_MAX;
 
-        /* ping_id = 0 means match any id. */
-        if ((!ip_isset(&ipp.ip) || ipport_equal(&ping->pings[id].ip_port, &ipp)) &&
-                (ping->pings[id].id == ping_id || ping_id == 0)) {
-            return true;
-        }
+        if (!ping_id || (ping->pings[id].id == ping_id))
+            if (!ip_valid || ipport_equal(&ping->pings[id].ip_port, &ipp))
+                return id + 1;
     }
 
-    return false;
+    return 0;
 }
 
 #define DHT_PING_SIZE (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(uint64_t) + crypto_box_MACBYTES)
@@ -252,11 +259,13 @@ static int handle_ping_response(void *_dht, IP_Port source, uint8_t *packet, uin
         return 1;
 
     /* Make sure ping_id is correct. */
-    if (!is_pinging(ping, source, ping_id))
+    int ping_index = is_pinging(ping, source, ping_id);
+
+    if (!ping_index)
         return 1;
 
-    // Associate source ip with client_id
-    addto_lists(dht, source, packet + 1);
+    /* Associate client_id with the ip the request was sent to */
+    addto_lists(dht, ping->pings[ping_index - 1].ip_port, packet + 1);
     return 0;
 }
 
diff --git a/toxcore/tox.h b/toxcore/tox.h
index 5d3916b4..13e9c7a9 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -521,7 +521,7 @@ uint64_t tox_file_dataremaining(Tox *tox, int friendnumber, uint8_t filenumber,
 void tox_bootstrap_from_ip(Tox *tox, tox_IP_Port ip_port, uint8_t *public_key);
 
 /* Resolves address into an IP address. If successful, sends a "get nodes"
- *   request to the given node with ip, port (in network byte order, HINT: use htons()) 
+ *   request to the given node with ip, port (in network byte order, HINT: use htons())
  *   and public_key to setup connections
  *
  * address can be a hostname or an IP address (IPv4 or IPv6).
diff --git a/toxcore/util.c b/toxcore/util.c
index fab9f660..3a43042d 100644
--- a/toxcore/util.c
+++ b/toxcore/util.c
@@ -139,8 +139,10 @@ void loginit(uint16_t port)
     if (logfile)
         fclose(logfile);
 
-    if (!starttime)
-        starttime = now();
+    if (!starttime) {
+        unix_time_update();
+        starttime = unix_time();
+    }
 
     struct tm *tm = localtime(&starttime);
 
@@ -164,7 +166,7 @@ void loginit(uint16_t port)
 void loglog(char *text)
 {
     if (logfile) {
-        fprintf(logfile, "%4u %s", (uint32_t)(now() - starttime), text);
+        fprintf(logfile, "%4u %s", (uint32_t)(unix_time() - starttime), text);
         fflush(logfile);
 
         return;
@@ -175,7 +177,9 @@ void loglog(char *text)
     size_t len = strlen(text);
 
     if (!starttime) {
-        starttime = now();
+        unix_time_update();
+        starttime = unix_time();
+
         logbufferprelen = 1024 + len - (len % 1024);
         logbufferpredata = malloc(logbufferprelen);
         logbufferprehead = logbufferpredata;
@@ -193,7 +197,7 @@ void loglog(char *text)
         logbufferprelen = lennew;
     }
 
-    int written = sprintf(logbufferprehead, "%4u %s", (uint32_t)(now() - starttime), text);
+    int written = sprintf(logbufferprehead, "%4u %s", (uint32_t)(unix_time() - starttime), text);
     logbufferprehead += written;
 }