18 files changed, 381 insertions, 200 deletions

diff --git a/.gitignore b/.gitignore
index 0b178e8e..73c7919e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,5 @@ CMakeFiles
 Makefile
 cmake_install.cmake
 install_manifest.txt
+
+testing/data
diff --git a/.travis.yml b/.travis.yml
index 9f62c84c..0a294bf1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,16 +8,15 @@ before_script:
   - cd libsodium
   - git checkout tags/0.4.2
   - ./autogen.sh
-  - ./configure && make -j3 check
+  - ./configure && make check -j3
   - sudo make install
   - sudo ldconfig
   - cd ..
 
 script:
-  - cmake CMakeLists.txt
-  - make DHT_bootstrap -j3
-  - make Messenger_test -j3
-  - make nTox -j3
+  - mkdir build && cd build
+  - cmake ..
+  - make -j3
 
 notifications:
   email: false
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 505983f2..c16ce6fe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,6 @@
 cmake_minimum_required(VERSION 2.6.0)
 
+#MinGW prints more warnings for -Wall than gcc does, thus causing build to fail
 if(NOT WIN32)
         if(("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU") OR ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang"))
                 message(STATUS "==== ${CMAKE_C_COMPILER_ID} detected - Adding compiler flags ====")
@@ -7,31 +8,21 @@ if(NOT WIN32)
         endif()
 endif()
 
-if(WIN32)
-        include_directories(${CMAKE_HOME_DIRECTORY}/sodium/include/)
-endif()
-
-set(core_sources
-        core/DHT.c
-        core/network.c
-        core/Lossless_UDP.c
-        core/net_crypto.c
-        core/Messenger.c)
-
-add_library(core ${core_sources})
-
 macro(linkCoreLibraries exe_name)
+        add_dependencies(${exe_name} core)
         if(WIN32)
-                target_link_libraries(${exe_name} core
-                        ${CMAKE_SOURCE_DIR}/sodium/lib/libsodium.a
+                include_directories(${CMAKE_HOME_DIRECTORY}/sodium/include/)
+                target_link_libraries(${exe_name} core
+                ${CMAKE_SOURCE_DIR}/sodium/lib/libsodium.a
                         ws2_32)
         else()
-                target_link_libraries(${exe_name} core
+                target_link_libraries(${exe_name} core
                         sodium)
         endif()
 endmacro()
 
 cmake_policy(SET CMP0011 NEW)
 
-ADD_SUBDIRECTORY(testing)
-ADD_SUBDIRECTORY(other)
\ No newline at end of file
+add_subdirectory(core)
+add_subdirectory(testing)
+add_subdirectory(other)
\ No newline at end of file
diff --git a/INSTALL.md b/INSTALL.md
index b4e28379..bc027c0b 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -15,10 +15,11 @@ sudo ldconfig
 
 Then clone this repo and run:
 ```bash
-cmake CMakeLists.txt
+mkdir build && cd build
+cmake ..
 ```
 
-Then you can build any of the [`/testing`](/testing) and [`/other`](/other) by running:
+Then you can build any of the [`/testing`](/testing) and [`/other`](/other) that are currently supported on your platform by running:
 ```bash
 make name_of_c_file
 ```
@@ -27,6 +28,28 @@ For example, to build [`Messenger_test.c`](/others/Messenger_test.c) you would r
 make Messenger_test
 ```
 
+Or you could just build everything that is supported on your platform by running:
+```bash
+make
+```
+
+###OSX:
+
+Much the same as above, remember to install the latest XCode and the developer tools (Preferences -> Downloads -> Command Line Tools).
+Users running Mountain Lion and the latest version of XCode (4.6.3) will also need to install libtool
+Libtool is easy enough to install, grab it from http://www.gnu.org/software/libtool/ and:
+
+./configure
+make
+sudo make install
+
+Do not install it from macports (or any dependencies for that matter) as they get shoved in the wrong directory
+and make your life more annoying.
+
+Another thing you may want to install is the latest gcc, this caused me a few problems as XCode from 4.3
+no longer includes gcc and instead uses LLVM-GCC, a nice install guide can be found at
+http://caiustheory.com/install-gcc-421-apple-build-56663-with-xcode-42
+
 ###Windows:
 
 You should install:
@@ -39,14 +62,20 @@ After that you should get precompiled packages of libsodium from [here](https://
 
 Navigate in `cmd` to this repo and run:
 ```cmd
-cmake -G "MinGW Makefiles" CMakeLists.txt
+mkdir build && cd build
+cmake -G "MinGW Makefiles" ..
 ```
 
-Then you can build any of the [`/testing`](/testing) and [`/other`](/other) by running:
+Then you can build any of the [`/testing`](/testing) and [`/other`](/other) that are currently supported on your platform by running:
 ```cmd
 mingw32-make name_of_c_file
 ```
 For example, to build [`Messenger_test.c`](/others/Messenger_test.c) you would run:
 ```cmd
 mingw32-make Messenger_test
-```
\ No newline at end of file
+```
+
+Or you could just build everything that is supported on your platform by running:
+```bash
+mingw32-make
+```
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
new file mode 100644
index 00000000..ab4ff4bc
--- /dev/null
+++ b/core/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.6.0)
+project(core C)
+
+if(WIN32)
+        include_directories(${CMAKE_HOME_DIRECTORY}/sodium/include/)
+endif()
+
+set(core_sources
+        DHT.c
+        network.c
+        Lossless_UDP.c
+        net_crypto.c
+        friend_requests.c
+        Messenger.c)
+
+add_library(core ${core_sources})
diff --git a/core/Messenger.c b/core/Messenger.c
index 25ce067d..3d874837 100644
--- a/core/Messenger.c
+++ b/core/Messenger.c
@@ -353,15 +353,14 @@ static int set_friend_userstatus(int friendnumber, uint8_t * status, uint16_t le
     friendlist[friendnumber].userstatus_length = length;
     return 0;
 }
-
+/*
 static void (*friend_request)(uint8_t *, uint8_t *, uint16_t);
 static uint8_t friend_request_isset = 0;
-
+*/
 /* set the function that will be executed when a friend request is received. */
 void m_callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t))
 {
-    friend_request = function;
-    friend_request_isset = 1;
+    callback_friendrequest(function);
 }
 
 
@@ -413,19 +412,20 @@ static void doFriends()
     {
         if(friendlist[i].status == 1)
         {
-             IP_Port friendip = DHT_getfriendip(friendlist[i].client_id);
-             int request = check_friendrequest(friendlist[i].friend_request_id);
-             /* printf("\n%u %u %u\n", friendip.ip.i, request, friendlist[i].friend_request_id); */
-             if(friendip.ip.i > 1 && request == -1)
-             {
-                  friendlist[i].friend_request_id = send_friendrequest(friendlist[i].client_id,
-                                               friendip, friendlist[i].info, friendlist[i].info_size);
-                  friendlist[i].status = 2;
-             }
+            int fr = send_friendrequest(friendlist[i].client_id, friendlist[i].info, friendlist[i].info_size);
+            if(fr == 0)/*TODO: This needs to be fixed so that it sends the friend requests a couple of times in case
+                                of packet loss*/
+            {
+                friendlist[i].status = 2;
+            }
+            else 
+            if(fr > 0)
+            {
+                friendlist[i].status = 2;
+            }
         }
         if(friendlist[i].status == 2 || friendlist[i].status == 3) /* friend is not online */
         {
-            check_friendrequest(friendlist[i].friend_request_id); /* for now this is used to kill the friend request */
             IP_Port friendip = DHT_getfriendip(friendlist[i].client_id);
             switch(is_cryptoconnected(friendlist[i].crypt_connection_id))
             {
@@ -508,21 +508,6 @@ static void doFriends()
     }
 }
 
-static void doFriendRequest()
-{
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t temp[MAX_DATA_SIZE];
-    
-    int len = handle_friendrequest(public_key, temp);
-    if(len >= 0)
-    {
-        if(friend_request_isset)
-        {
-            (*friend_request)(public_key, temp, len);
-        }
-    }
-}
-
 
 
 static void doInbound()
@@ -556,7 +541,7 @@ void doMessenger()
 #ifdef DEBUG
         /* if(rand() % 3 != 1) //simulate packet loss */
         /* { */
-        if(DHT_handlepacket(data, length, ip_port) && LosslessUDP_handlepacket(data, length, ip_port))
+        if(DHT_handlepacket(data, length, ip_port) && LosslessUDP_handlepacket(data, length, ip_port) && friendreq_handlepacket(data, length, ip_port))
         {
             /* if packet is discarded */
             printf("Received unhandled packet with length: %u\n", length);
@@ -570,6 +555,7 @@ void doMessenger()
 #else
         DHT_handlepacket(data, length, ip_port);
         LosslessUDP_handlepacket(data, length, ip_port);
+        friendreq_handlepacket(data, length, ip_port);
 #endif
 
     }
@@ -577,7 +563,6 @@ void doMessenger()
     doLossless_UDP();
     doNetCrypto();
     doInbound();
-    doFriendRequest();
     doFriends();
 }
 
diff --git a/core/Messenger.h b/core/Messenger.h
index 6fd98972..a7f114cf 100644
--- a/core/Messenger.h
+++ b/core/Messenger.h
@@ -29,6 +29,7 @@
 
 #include "net_crypto.h"
 #include "DHT.h"
+#include "friend_requests.h"
 
 #define MAX_NAME_LENGTH 128
 #define MAX_USERSTATUS_LENGTH 128
diff --git a/core/friend_requests.c b/core/friend_requests.c
new file mode 100644
index 00000000..18f0866b
--- /dev/null
+++ b/core/friend_requests.c
@@ -0,0 +1,93 @@
+/* friend_requests.c
+ * 
+ * Handle friend requests.
+ * 
+ */
+
+#include "friend_requests.h"
+
+uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
+
+
+/* Try to send a friendrequest to peer with public_key
+   data is the data in the request and length is the length. 
+   return -1 if failure.
+   return  0 if it sent the friend request directly to the friend.
+   return the number of peers it was routed through if it did not send it directly.*/
+int send_friendrequest(uint8_t * public_key, uint8_t * data, uint32_t length)
+{
+    uint8_t packet[MAX_DATA_SIZE];
+    int len = create_request(packet, public_key, data, length, 32); /* 32 is friend request packet id */
+    if(len == -1)
+    {
+        return -1;
+    }
+    IP_Port ip_port = DHT_getfriendip(public_key);
+    if(ip_port.ip.i == 1)
+    {
+        return -1;
+    }
+    if(ip_port.ip.i != 0)
+    {
+        if(sendpacket(ip_port, packet, len) != -1)
+        {
+            return 0;
+        }
+        return -1;
+    }
+    
+    int num = route_tofriend(public_key, packet, len);
+    if(num == 0)
+    {
+        return -1;
+    }
+    return num;
+}
+
+
+static void (*handle_friendrequest)(uint8_t *, uint8_t *, uint16_t);
+static uint8_t handle_friendrequest_isset = 0;
+
+/* set the function that will be executed when a friend request is received. */
+void callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t))
+{
+    handle_friendrequest = function;
+    handle_friendrequest_isset = 1;
+}
+
+
+int friendreq_handlepacket(uint8_t * packet, uint32_t length, IP_Port source)
+{
+
+    if(packet[0] == 32)
+    {
+        if(length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING &&
+        length > MAX_DATA_SIZE + ENCRYPTION_PADDING)
+        {
+            return 1;
+        }
+        if(memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)//check if request is for us.
+        {
+            if(handle_friendrequest_isset == 0)
+            {
+                return 1;
+            }
+            uint8_t public_key[crypto_box_PUBLICKEYBYTES];
+            uint8_t data[MAX_DATA_SIZE];
+            int len = handle_request(public_key, data, packet, length);
+            if(len == -1)
+            {
+                return 1;
+            }
+            (*handle_friendrequest)(public_key, data, len);
+        }
+        else//if request is not for us, try routing it.
+        {
+            if(route_packet(packet + 1, packet, length) == length)
+            {
+                return 0;
+            }
+        }
+    }
+        return 1;
+}
\ No newline at end of file
diff --git a/core/friend_requests.h b/core/friend_requests.h
new file mode 100644
index 00000000..a3de46c8
--- /dev/null
+++ b/core/friend_requests.h
@@ -0,0 +1,34 @@
+/* friend_requests.h
+ * 
+ * Handle friend requests.
+ * 
+ */
+
+
+#ifndef FRIEND_REQUESTS_H 
+#define FRIEND_REQUESTS_H  
+
+
+#include "DHT.h"
+#include "net_crypto.h"
+
+
+/* Try to send a friendrequest to peer with public_key
+   data is the data in the request and length is the length. */
+int send_friendrequest(uint8_t * public_key, uint8_t * data, uint32_t length);
+
+
+/* set the function that will be executed when a friend request for us is received.
+   function format is function(uint8_t * public_key, uint8_t * data, uint16_t length) */
+void callback_friendrequest(void (*function)(uint8_t *, uint8_t *, uint16_t));
+
+/* if we receive a packet we call this function so it can be handled.
+   return 0 if packet is handled correctly.
+   return 1 if it didn't handle the packet or if the packet was shit. */
+int friendreq_handlepacket(uint8_t * packet, uint32_t length, IP_Port source);
+
+
+
+
+
+#endif
\ No newline at end of file
diff --git a/core/net_crypto.c b/core/net_crypto.c
index 270c969a..e01ed695 100644
--- a/core/net_crypto.c
+++ b/core/net_crypto.c
@@ -52,11 +52,6 @@ typedef struct
 
 static Crypto_Connection crypto_connections[MAX_CRYPTO_CONNECTIONS];
 
-#define MAX_FRIEND_REQUESTS 32
-
-/* keeps track of the connection numbers for friends request so we can check later if they were sent */
-static int outbound_friendrequests[MAX_FRIEND_REQUESTS];
-
 #define MAX_INCOMING 64
 
 /* keeps track of the connection numbers for friends request so we can check later if they were sent */
@@ -138,14 +133,14 @@ void increment_nonce(uint8_t * nonce)
     }
 }
 
-/* fill the given nonce with random bytes.
-   TODO: make this more optimized */
+/* fill the given nonce with random bytes. */
 void random_nonce(uint8_t * nonce)
 {
-    uint32_t i;
-    for(i = 0; i < crypto_box_NONCEBYTES; ++i)
+    uint32_t i, temp;
+    for (i = 0; i < crypto_box_NONCEBYTES / 4; ++i) 
     {
-        nonce[i] = random_int() % 256;
+        temp = random_int();
+        memcpy(nonce + 4 * i, &temp, 4);
     }
 }
 
@@ -217,88 +212,63 @@ int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length)
     return 1;
 }
 
-/* send a friend request to peer with public_key and ip_port.
-   Data represents the data we send with the friends request.
+/* create a request to peer with public_key.
+   packet must be an array of MAX_DATA_SIZE big.
+   Data represents the data we send with the request with length being the length of the data.
+   request_id is the id of the request (32 = friend request, 254 = ping request)
    returns -1 on failure
-   returns a positive friend request id that can be used later to see if it was sent correctly on success. */
-int send_friendrequest(uint8_t * public_key, IP_Port ip_port, uint8_t * data, uint32_t length)
+   returns the length of the created packet on success */
+int create_request(uint8_t * packet, uint8_t * public_key, uint8_t * data, uint32_t length, uint8_t request_id)
 {
-    if(length > MAX_DATA_SIZE - 1 - crypto_box_PUBLICKEYBYTES - crypto_box_NONCEBYTES)
+    if(MAX_DATA_SIZE < length + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + ENCRYPTION_PADDING)
     {
         return -1;
     }
-    uint32_t i;
-    for(i = 0; i < MAX_FRIEND_REQUESTS; ++i)
-    {
-        if(outbound_friendrequests[i] == -1)
-        {
-            break;
-        }
-    }
-    if(i == MAX_FRIEND_REQUESTS)
-    {
-        return -1;
-    }
-    uint8_t temp_data[MAX_DATA_SIZE];
     uint8_t nonce[crypto_box_NONCEBYTES];
     random_nonce(nonce);
     int len = encrypt_data(public_key, self_secret_key, nonce, data, length, 
-                           1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + temp_data);
+                           1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + packet);
     if(len == -1)
     {
         return -1;
     }
-    temp_data[0] = 1;
-    memcpy(temp_data + 1, self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(temp_data + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
-    int id = new_connection(ip_port);
-    if(id == -1)
-    {
-        return -1;
-    }
-    if(write_packet(id, temp_data, len + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES) == 1)
-    {
-        outbound_friendrequests[i] = id;
-        return i;
-    }
-    return -1;
+    packet[0] = request_id;
+    memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES * 2, nonce, crypto_box_NONCEBYTES);
+    
+    return len + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES;
 }
 
-/* return -1 if failure
-   return 0 if connection is still trying to send the request.
-   return 1 if sent correctly
-   return 2 if connection timed out */
-int check_friendrequest(int friend_request)
+/* puts the senders public key in the request in public_key, the data from the request 
+   in data if a friend or ping request was sent to us and returns the length of the data.
+   packet is the request packet and length is its length
+   return -1 if not valid request. */
+int handle_request(uint8_t * public_key, uint8_t * data, uint8_t * packet, uint16_t length)
 {
-    if(friend_request < 0 || friend_request > MAX_FRIEND_REQUESTS)
+
+    if(length > crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + ENCRYPTION_PADDING &&
+       length <= MAX_DATA_SIZE + ENCRYPTION_PADDING &&
+       memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)
     {
-        return -1;
+        memcpy(public_key, packet + 1 + crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
+        uint8_t nonce[crypto_box_NONCEBYTES];
+        memcpy(nonce, packet + 1 + crypto_box_PUBLICKEYBYTES * 2, crypto_box_NONCEBYTES);
+        int len1 = decrypt_data(public_key, self_secret_key, nonce, packet + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES, 
+                                        length - (crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1), data);
+        if(len1 == -1)
+        {
+            return -1;
+        }
+        return len1;
     }
-    if(outbound_friendrequests[friend_request] == -1)
+    else
     {
         return -1;
     }
-    if(sendqueue(outbound_friendrequests[friend_request]) == 0)
-    {
-        kill_connection(outbound_friendrequests[friend_request]);
-        outbound_friendrequests[friend_request] = -1;
-        return 1;
-    }
-    int status = is_connected(outbound_friendrequests[friend_request]);
-    if(status == 4)
-    {
-        kill_connection(outbound_friendrequests[friend_request]);
-        outbound_friendrequests[friend_request] = -1;
-        return 2;
-    }
-    if(status == 0)
-    {
-        outbound_friendrequests[friend_request] = -1;
-        return 2;
-    }
-    return 0;
 }
 
+
 /* Send a crypto handshake packet containing an encrypted secret nonce and session public key
    to peer with connection_id and public_key
    the packet is encrypted with a random nonce which is sent in plain text with the packet */
@@ -359,43 +329,7 @@ int handle_cryptohandshake(uint8_t * public_key, uint8_t * secret_nonce,
 }
 
 
-/* puts the public key of the friend if public_key, the  data from the request 
-   in data if a friend request was sent to us and returns the length of the data.
-   return -1 if no valid friend requests. */
-int handle_friendrequest(uint8_t * public_key, uint8_t * data)
-{
-    uint32_t i;
-    for(i = 0; i < MAX_INCOMING; ++i)
-    {
-        if(incoming_connections[i] != -1)
-        {
-            if(id_packet(incoming_connections[i]) == 1)
-            {
-                uint8_t temp_data[MAX_DATA_SIZE];
-                uint16_t len = read_packet(incoming_connections[i], temp_data);
-                if(len > crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + 1 
-                                 - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES)
-                {
-                    memcpy(public_key, temp_data + 1, crypto_box_PUBLICKEYBYTES);
-                    uint8_t nonce[crypto_box_NONCEBYTES];
-                    memcpy(nonce, temp_data + 1 + crypto_box_PUBLICKEYBYTES, crypto_box_NONCEBYTES);
-                    int len1 = decrypt_data(public_key, self_secret_key, nonce, temp_data + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, 
-                                                    len - (crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + 1), data);
-                    if(len1 != -1)
-                    {
-                        kill_connection(incoming_connections[i]);
-                        /* kill_connection_in(incoming_connections[i], 1); //conection is useless now, kill it in 1 seconds */
-                        incoming_connections[i] = -1;
-                        return len1;
-                    }
-                }
-                kill_connection(incoming_connections[i]); /* conection is useless now, kill it. */
-                incoming_connections[i] = -1;
-            }
-        }
-    }
-    return -1;
-}
+
 
 /* get crypto connection id from public key of peer
    return -1 if there are no connections like we are looking for
@@ -714,7 +648,6 @@ static void receive_crypto()
 void initNetCrypto()
 {
     memset(crypto_connections, 0 ,sizeof(crypto_connections));
-    memset(outbound_friendrequests, -1 ,sizeof(outbound_friendrequests));
     memset(incoming_connections, -1 ,sizeof(incoming_connections));
     uint32_t i;
     for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i)
diff --git a/core/net_crypto.h b/core/net_crypto.h
index 0bf21f60..5a282002 100644
--- a/core/net_crypto.h
+++ b/core/net_crypto.h
@@ -62,24 +62,20 @@ int read_cryptpacket(int crypt_connection_id, uint8_t * data);
    return 1 if data was put into the queue */
 int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length);
 
-/* send a friend request to peer with public_key and ip_port.
-   Data represents the data we send with the friends request.
+/* create a request to peer with public_key.
+   packet must be an array of MAX_DATA_SIZE big.
+   Data represents the data we send with the request with length being the length of the data.
+   request_id is the id of the request (32 = friend request, 254 = ping request)
    returns -1 on failure
-   returns a positive friend request id that can be used later to see if it was sent correctly on success. */
-int send_friendrequest(uint8_t * public_key, IP_Port ip_port, uint8_t * data, uint32_t length);
+   returns the length of the created packet on success */
+int create_request(uint8_t * packet, uint8_t * public_key, uint8_t * data, uint32_t length, uint8_t request_id);
 
 
-/* return -1 if failure
-   return 0 if connection is still trying to send the request.
-   return 1 if sent correctly
-   return 2 if connection timed out */
-int check_friendrequest(int friend_request);
-
-
-/* puts the public key of the friend if public_key, the  data from the request 
-   in data if a friend request was sent to us and returns the length of the data.
-   return -1 if no valid friend requests. */
-int handle_friendrequest(uint8_t * public_key, uint8_t * data);
+/* puts the senders public key in the request in public_key, the data from the request 
+   in data if a friend or ping request was sent to us and returns the length of the data.
+   packet is the request packet and length is its length
+   return -1 if not valid request. */
+int handle_request(uint8_t * public_key, uint8_t * data, uint8_t * packet, uint16_t length);
 
 
 /* Start a secure connection with other peer who has public_key and ip_port
diff --git a/other/CMakeLists.txt b/other/CMakeLists.txt
index 22dc8e25..05b24f06 100644
--- a/other/CMakeLists.txt
+++ b/other/CMakeLists.txt
@@ -1 +1,9 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+cmake_policy(SET CMP0011 NEW)
+
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/DHT_bootstrap.cmake)
+
+if(NOT WIN32)
+        add_subdirectory(bootstrap_serverdaemon)
+endif()
diff --git a/other/DHT_bootstrap.c b/other/DHT_bootstrap.c
index 02d7d261..85ed679c 100644
--- a/other/DHT_bootstrap.c
+++ b/other/DHT_bootstrap.c
@@ -3,12 +3,13 @@
  * A simple DHT boostrap server for tox.
  *
  * Build commands (use one or the other):
- *                gcc -O2 -Wall -D VANILLA_NACL -o bootstrap_server ../core/Lossless_UDP.c ../core/network.c ../core/net_crypto.c ../core/Messenger.c ../core/DHT.c ../nacl/build/${HOSTNAME%.*}/lib/amd64/{cpucycles.o,libnacl.a,randombytes.o} DHT_bootstrap.c
+ *                gcc -O2 -Wall -D VANILLA_NACL -o bootstrap_server ../core/Lossless_UDP.c ../core/network.c ../core/net_crypto.c ../core/Messenger.c ../core/DHT.c ../core/friend_requests.c ../nacl/build/${HOSTNAME%.*}/lib/amd64/{cpucycles.o,libnacl.a,randombytes.o} DHT_bootstrap.c
  *
- *                gcc -O2 -Wall -o bootstrap_server ../core/Lossless_UDP.c ../core/network.c ../core/net_crypto.c ../core/Messenger.c ../core/DHT.c -lsodium DHT_bootstrap.c
+ *                gcc -O2 -Wall -o bootstrap_server ../core/Lossless_UDP.c ../core/network.c ../core/net_crypto.c ../core/Messenger.c ../core/DHT.c ../core/friend_requests.c -lsodium DHT_bootstrap.c
  */
 
 #include "../core/DHT.h"
+#include "../core/friend_requests.h"
 
 //Sleep function (x = milliseconds)
 #ifdef WIN32
@@ -35,9 +36,41 @@ unsigned char * hex_string_to_bin(char hex_string[])
     return val;
 }
 
+void manage_keys()
+{
+    const uint32_t KEYS_SIZE = crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES;
+    uint8_t keys[KEYS_SIZE];
+
+    FILE *keys_file = fopen("key", "r");
+    if (keys_file != NULL) {
+        //if file was opened successfully -- load keys
+        size_t read_size = fread(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
+        if (read_size != KEYS_SIZE) {
+            printf("Error while reading the key file\nExiting.\n");
+            exit(1);
+        } else {
+            printf("Keys loaded successfully\n");
+        }
+        load_keys(keys);
+    } else {
+        //otherwise save new keys
+        new_keys();
+        save_keys(keys);
+        keys_file = fopen("key", "w");
+        if (fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keys_file) != KEYS_SIZE) {
+            printf("Error while writing the key file.\nExiting.\n");
+            exit(1);
+        } else {
+            printf("Keys saved successfully\n");
+        }
+    }
+
+    fclose(keys_file);
+}
+
 int main(int argc, char *argv[])
 {
-    new_keys();
+    manage_keys();
     printf("Public key: ");
     uint32_t i;
     for(i = 0; i < 32; i++)
@@ -83,6 +116,7 @@ int main(int argc, char *argv[])
         while(receivepacket(&ip_port, data, &length) != -1)
         {
             DHT_handlepacket(data, length, ip_port);
+            friendreq_handlepacket(data, length, ip_port);
         }
         c_sleep(1);
     }
diff --git a/other/bootstrap_serverdaemon/CMakeLists.txt b/other/bootstrap_serverdaemon/CMakeLists.txt
new file mode 100644
index 00000000..bc717d4b
--- /dev/null
+++ b/other/bootstrap_serverdaemon/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 2.6.0)
+project(DHT_bootstrap_daemon C)
+
+set(exe_name DHT_bootstrap_daemon)
+
+add_executable(${exe_name}
+        DHT_bootstrap_daemon.c)
+
+linkCoreLibraries(${exe_name})
diff --git a/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c b/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c
index 276821e6..4d79c48b 100644
--- a/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c
+++ b/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c
@@ -10,7 +10,9 @@
 #include <unistd.h> /* POSIX things */
 #include <errno.h>
     
-#include "../core/DHT.h"
+#include "../../core/DHT.h"
+#include "../../core/friend_requests.h"
+
     
 /* Sleep function (x = milliseconds) */
 #ifdef WIN32
@@ -123,6 +125,7 @@ int main(int argc, char *argv[]) {
         doDHT();
         while(receivepacket(&ip_port, data, &length) != -1) {
             DHT_handlepacket(data, length, ip_port);
+            friendreq_handlepacket(data, length, ip_port);
         }
         c_sleep(1);
     }
diff --git a/testing/CMakeLists.txt b/testing/CMakeLists.txt
index bb599b86..12efc2f4 100644
--- a/testing/CMakeLists.txt
+++ b/testing/CMakeLists.txt
@@ -1,7 +1,13 @@
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/DHT_cryptosendfiletest.cmake)
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/DHT_sendfiletest.cmake)
+cmake_minimum_required(VERSION 2.6.0)
+
+cmake_policy(SET CMP0011 NEW)
+
+#include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/DHT_cryptosendfiletest.cmake)
+#include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/DHT_sendfiletest.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/DHT_test.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Lossless_UDP_testclient.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Lossless_UDP_testserver.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Messenger_test.cmake)
-include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/nTox.cmake)
\ No newline at end of file
+if(NOT WIN32)
+        include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/nTox.cmake)
+endif()
diff --git a/testing/DHT_test.c b/testing/DHT_test.c
index 5f85e934..9d599370 100644
--- a/testing/DHT_test.c
+++ b/testing/DHT_test.c
@@ -1,7 +1,7 @@
 /* DHT test
  * A file with a main that runs our DHT for testing.
  * 
- * Compile with: gcc -O2 -Wall -D VANILLA_NACL -o test ../core/Lossless_UDP.c ../core/network.c ../core/net_crypto.c ../core/Messenger.c ../nacl/build/${HOSTNAME%.*}/lib/amd64/* DHT_test.c
+ * Compile with: gcc -O2 -Wall -D VANILLA_NACL -o test ../core/Lossless_UDP.c ../core/network.c ../core/net_crypto.c ../core/Messenger.c ../nacl/build/${HOSTNAME%.*}/lib/amd64/{cpucycles.o,libnacl.a,randombytes.o} DHT_test.c
  * 
  * Command line arguments are the ip, port and public key of a node.
  * EX: ./test 127.0.0.1 33445 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@@ -10,6 +10,7 @@
  */
 //#include "../core/network.h"
 #include "../core/DHT.c"
+#include "../core/friend_requests.c"
 
 #include <string.h>
 
@@ -45,7 +46,7 @@ void print_clientlist()
         printf("\nTimestamp: %u", close_clientlist[i].timestamp);
         printf("\nLast pinged: %u\n", close_clientlist[i].last_pinged);
         p_ip = close_clientlist[i].ret_ip_port;
-        printf("\nOUR IP: %u.%u.%u.%u Port: %u",p_ip.ip.c[0],p_ip.ip.c[1],p_ip.ip.c[2],p_ip.ip.c[3],ntohs(p_ip.port));
+        printf("OUR IP: %u.%u.%u.%u Port: %u\n",p_ip.ip.c[0],p_ip.ip.c[1],p_ip.ip.c[2],p_ip.ip.c[3],ntohs(p_ip.port));
     }  
 }
 
@@ -81,7 +82,7 @@ void print_friendlist()
             printf("\nTimestamp: %u", friends_list[k].client_list[i].timestamp);
             printf("\nLast pinged: %u\n", friends_list[k].client_list[i].last_pinged);
             p_ip = friends_list[k].client_list[i].ret_ip_port;
-            printf("\nret IP: %u.%u.%u.%u:%u",p_ip.ip.c[0],p_ip.ip.c[1],p_ip.ip.c[2],p_ip.ip.c[3],ntohs(p_ip.port));
+            printf("ret IP: %u.%u.%u.%u:%u\n",p_ip.ip.c[0],p_ip.ip.c[1],p_ip.ip.c[2],p_ip.ip.c[3],ntohs(p_ip.port));
         }
     }
 }
@@ -146,8 +147,6 @@ int main(int argc, char *argv[])
     init_networking(ip, PORT);
     
 
-    
-
     perror("Initialization");
     IP_Port bootstrap_ip_port;
     bootstrap_ip_port.port = htons(atoi(argv[2]));
@@ -169,7 +168,7 @@ int main(int argc, char *argv[])
         
         while(receivepacket(&ip_port, data, &length) != -1)
         {
-            if(DHT_handlepacket(data, length, ip_port))
+            if(DHT_handlepacket(data, length, ip_port) && friendreq_handlepacket(data, length, ip_port))
             {
                 //unhandled packet
                 printpacket(data, length, ip_port);
diff --git a/testing/nTox.c b/testing/nTox.c
index ccb11a71..8e9a5456 100644
--- a/testing/nTox.c
+++ b/testing/nTox.c
@@ -1,5 +1,6 @@
 #include "nTox.h"
-
+#include <stdio.h>
+#include <time.h>
 #ifdef WIN32
 #define c_sleep(x) Sleep(1*x)
 #else
@@ -168,12 +169,12 @@ void do_refresh()
 }
 void print_request(uint8_t * public_key, uint8_t * data, uint16_t length)
 {
-    new_lines("Friend request");
+    new_lines("[i] received friend request");
     do_refresh();
     if(memcmp(data , "Install Gentoo", sizeof("Install Gentoo")) == 0 )
     //if the request contained the message of peace the person is obviously a friend so we add him.
     {
-        new_lines("[i] friend request accepted.");
+        new_lines("[i] friend request accepted");
         do_refresh();
         int num = m_addfriend_norequest(public_key);
         char numchar[100];
@@ -186,7 +187,14 @@ void print_message(int friendnumber, uint8_t * string, uint16_t length)
     char *name = malloc(MAX_NAME_LENGTH);
     getname(friendnumber, (uint8_t*)name);
     char msg[100+length+strlen(name)+1];
-    sprintf(msg, "[%d] <%s> %s", friendnumber, name, string);
+    time_t rawtime;
+    struct tm * timeinfo;
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    char* temp = asctime(timeinfo);
+    int len = strlen(temp);
+    temp[len-1]='\0';
+    sprintf(msg, "[%d] %s <%s> %s", friendnumber, temp, name, string); // someone please fix this
     free(name);
     new_lines(msg);
 }
@@ -206,15 +214,50 @@ void print_statuschange(int friendnumber, uint8_t *string, uint16_t length) {
     free(name);
     new_lines(msg);
 }
+int load_key(){
+    FILE *data_file = NULL;
+    if ((data_file = fopen("data","r"))) {
+                 //load keys
+                 fseek(data_file, 0, SEEK_END);
+                 int size = ftell(data_file);
+                 fseek(data_file, 0, SEEK_SET);
+                 uint8_t data[size];
+            if(fread(data, sizeof(uint8_t), size, data_file) != size){
+                printf("Error reading file\n");
+                exit(0);
+            }
+                Messenger_load(data, size);
+            } else { 
+               //else save new keys
+               int size = Messenger_size();
+               uint8_t data[size];
+               Messenger_save(data);
+               data_file = fopen("data","w");
+               if(fwrite(data, sizeof(uint8_t), size, data_file) != size){
+                   printf("Error writing file\n");
+                   exit(0);
+               }
+           }
+   fclose(data_file);
+   return 0;
+}
 int main(int argc, char *argv[])
 {
     if (argc < 4) {
-        printf("[!] Usage: %s [IP] [port] [public_key]\n", argv[0]);
+        printf("[!] Usage: %s [IP] [port] [public_key] <nokey>\n", argv[0]);
         exit(0);
     }
     int c;
     int on = 0;
     initMessenger();
+    //if keyfiles exist
+    if(argc > 4){
+        if(strncmp(argv[4], "nokey", 6) < 0){
+        //load_key();
+        }
+    } else {
+        load_key();
+    }
     m_callback_friendrequest(print_request);
     m_callback_friendmessage(print_message);
     m_callback_namechange(print_nickchange);