/* net_crypto.c
* 
* Functions for the core network crypto.
* See also: docs/Crypto.txt
* 
* NOTE: This code has to be perfect. We don't mess around with encryption.
*
 
    Copyright (C) 2013 Tox project All Rights Reserved.

    This file is part of Tox.

    Tox is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Tox is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Tox.  If not, see <http://www.gnu.org/licenses/>.
    
*/

#include "net_crypto.h"


/* Our public and secret keys. */
uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];


typedef struct
{
    uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* the real public key of the peer. */
    uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* nonce of received packets */
    uint8_t sent_nonce[crypto_box_NONCEBYTES]; /* nonce of sent packets. */
    uint8_t sessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* our public key for this session. */
    uint8_t sessionsecret_key[crypto_box_SECRETKEYBYTES]; /* our private key for this session. */
    uint8_t peersessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* The public key of the peer. */
    uint8_t status; /* 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet 
                       (we have received a handshake but no empty data packet), 3 if the connection is established.
                       4 if the connection is timed out. */
    uint16_t number; /* Lossless_UDP connection number corresponding to this connection. */
    
}Crypto_Connection;

#define MAX_CRYPTO_CONNECTIONS 256

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 */
static int incoming_connections[MAX_INCOMING];

/* encrypts plain of length length to encrypted of length + 16 using the 
   public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce
   return -1 if there was a problem.
   return length of encrypted data if everything was fine. */
int encrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, 
                                       uint8_t * plain, uint32_t length, uint8_t * encrypted)
{
    if(length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES > MAX_DATA_SIZE || length == 0)
    {
        return -1;
    }
    
    uint8_t temp_plain[MAX_DATA_SIZE + crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES] = {0};
    uint8_t temp_encrypted[MAX_DATA_SIZE + crypto_box_ZEROBYTES];
    uint8_t zeroes[crypto_box_BOXZEROBYTES] = {0};
    
    memcpy(temp_plain + crypto_box_ZEROBYTES, plain, length); /* pad the message with 32 0 bytes. */
    
    crypto_box(temp_encrypted, temp_plain, length + crypto_box_ZEROBYTES, nonce, public_key, secret_key);
    
    /* if encryption is successful the first crypto_box_BOXZEROBYTES of the message will be zero */
    if(memcmp(temp_encrypted, zeroes, crypto_box_BOXZEROBYTES) != 0)
    {
        return -1;
    }
    /* unpad the encrypted message */
    memcpy(encrypted, temp_encrypted + crypto_box_BOXZEROBYTES, length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES);
    return length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES;
}

/* decrypts encrypted of length length to plain of length length - 16 using the
   public key(32 bytes) of the sender, the secret key of the receiver and a 24 byte nonce
   return -1 if there was a problem(decryption failed)
   return length of plain data if everything was fine. */
int decrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, 
                                       uint8_t * encrypted, uint32_t length, uint8_t * plain)
{
    if(length > MAX_DATA_SIZE || length <= crypto_box_BOXZEROBYTES)
    {
        return -1;
    }
    uint8_t temp_plain[MAX_DATA_SIZE - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES];
    uint8_t temp_encrypted[MAX_DATA_SIZE + crypto_box_ZEROBYTES] = {0};
    uint8_t zeroes[crypto_box_ZEROBYTES] = {0};
    
    memcpy(temp_encrypted + crypto_box_BOXZEROBYTES, encrypted, length); /* pad the message with 16 0 bytes. */
    
    if(crypto_box_open(temp_plain, temp_encrypted, length + crypto_box_BOXZEROBYTES, 
                                            nonce, public_key, secret_key) == -1)
    {
        return -1;
    }
    /* if decryption is successful the first crypto_box_ZEROBYTES of the message will be zero */
    if(memcmp(temp_plain, zeroes, crypto_box_ZEROBYTES) != 0)
    {
        return -1;
    }
    /* unpad the plain message */
    memcpy(plain, temp_plain + crypto_box_ZEROBYTES, length - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES);
    return length - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES;
}

/* increment the given nonce by 1 */
void increment_nonce(uint8_t * nonce)
{
    uint32_t i;
    for(i = 0; i < crypto_box_NONCEBYTES; ++i)
    {
        ++nonce[i];
        if(nonce[i] != 0)
        {
            break;
        }
    }
}

/* fill the given nonce with random bytes. */
void random_nonce(uint8_t * nonce)
{
    uint32_t i, temp;
    for (i = 0; i < crypto_box_NONCEBYTES / 4; ++i) 
    {
        uint32_t temp = random_int();
        memcpy(nonce + 4 * i, &temp, 4);
    }
}

/* return 0 if there is no received data in the buffer 
   return -1  if the packet was discarded.
   return length of received data if successful */
int read_cryptpacket(int crypt_connection_id, uint8_t * data)
{
    if(crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS)
    {
        return 0;   
    }
    if(crypto_connections[crypt_connection_id].status != 3)
    {
        return 0;
    }
    uint8_t temp_data[MAX_DATA_SIZE];
    int length = read_packet(crypto_connections[crypt_connection_id].number, temp_data);
    if(length == 0)
    {
        return 0;
    }
    if(temp_data[0] != 3)
    {
        return -1;
    }
    int len = decrypt_data(crypto_connections[crypt_connection_id].peersessionpublic_key, 
                           crypto_connections[crypt_connection_id].sessionsecret_key,
                           crypto_connections[crypt_connection_id].recv_nonce, temp_data + 1, length - 1, data);
    if(len != -1)
    {
        increment_nonce(crypto_connections[crypt_connection_id].recv_nonce);
        return len;
    }
    return -1;
}


/* return 0 if data could not be put in packet queue
   return 1 if data was put into the queue */
int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length)
{
    if(crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS)
    {
        return 0;   
    }
    if(length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES > MAX_DATA_SIZE - 1)
    {
        return 0;
    }
    if(crypto_connections[crypt_connection_id].status != 3)
    {
        return 0;
    }
    uint8_t temp_data[MAX_DATA_SIZE];
    int len = encrypt_data(crypto_connections[crypt_connection_id].peersessionpublic_key, 
                           crypto_connections[crypt_connection_id].sessionsecret_key,
                           crypto_connections[crypt_connection_id].sent_nonce, data, length, temp_data + 1);
    if(len == -1)
    {
        return 0;
    }
    temp_data[0] = 3;
    if(write_packet(crypto_connections[crypt_connection_id].number, temp_data, len + 1) == 0)
    {
        return 0;
    }
    increment_nonce(crypto_connections[crypt_connection_id].sent_nonce);
    return 1;
}

/* send a friend request to peer with public_key and ip_port.
   Data represents the data we send with the friends 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)
{
    if(length > MAX_DATA_SIZE - 1 - crypto_box_PUBLICKEYBYTES - crypto_box_NONCEBYTES)
    {
        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);
    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;
}

/* 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)
{
    if(friend_request < 0 || friend_request > MAX_FRIEND_REQUESTS)
    {
        return -1;
    }
    if(outbound_friendrequests[friend_request] == -1)
    {
        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 */
int send_cryptohandshake(int connection_id, uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key)
{
    uint8_t temp_data[MAX_DATA_SIZE];
    uint8_t temp[crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES];
    uint8_t nonce[crypto_box_NONCEBYTES];
    
    random_nonce(nonce);
    memcpy(temp, secret_nonce, crypto_box_NONCEBYTES);
    memcpy(temp + crypto_box_NONCEBYTES, session_key, crypto_box_PUBLICKEYBYTES);
    
    int len = encrypt_data(public_key, self_secret_key, nonce, temp, crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES, 
                             1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + temp_data);
    if(len == -1)
    {
        return 0;
    }
    temp_data[0] = 2;
    memcpy(temp_data + 1, self_public_key, crypto_box_PUBLICKEYBYTES);
    memcpy(temp_data + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
    return write_packet(connection_id, temp_data, len + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
}

/* Extract secret nonce, session public key and public_key from a packet(data) with length length
   return 1 if successful
   return 0 if failure */
int handle_cryptohandshake(uint8_t * public_key, uint8_t * secret_nonce, 
                           uint8_t * session_key, uint8_t * data, uint16_t length)
{
    int pad = (- crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES);
    if(length != 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES 
                              + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + pad)
    {
        return 0;
    }
    if(data[0] != 2)
    {
        return 0;
    }
    uint8_t temp[crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES];
    
    memcpy(public_key, data + 1, crypto_box_PUBLICKEYBYTES);
    
    int len = decrypt_data(public_key, self_secret_key, data + 1 + crypto_box_PUBLICKEYBYTES, 
              data + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, 
              crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + pad, temp);
    
    if(len != crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES)
    {
        return 0;
    }
    
    memcpy(secret_nonce, temp, crypto_box_NONCEBYTES);
    memcpy(session_key, temp + crypto_box_NONCEBYTES, crypto_box_PUBLICKEYBYTES);
    return 1;
}


/* 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
   return id if it found it */
int getcryptconnection_id(uint8_t * public_key)
{
    uint32_t i;
    for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i)
    {
        if(crypto_connections[i].status > 0)
        {
            if(memcmp(public_key, crypto_connections[i].public_key, crypto_box_PUBLICKEYBYTES) == 0)
            {
                return i;
            }
        }
    }
    return -1;
}


/* Start a secure connection with other peer who has public_key and ip_port
   returns -1 if failure
   returns crypt_connection_id of the initialized connection if everything went well. */
int crypto_connect(uint8_t * public_key, IP_Port ip_port)
{
    uint32_t i;
    int id = getcryptconnection_id(public_key);
    if(id != -1)
    {
        IP_Port c_ip = connection_ip(crypto_connections[id].number);
        if(c_ip.ip.i == ip_port.ip.i && c_ip.port == ip_port.port)
        {
            return -1;
        }
    }
    for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i)
    {
        if(crypto_connections[i].status == 0)
        {
            int id = new_connection(ip_port);
            if(id == -1)
            {
                return -1;
            }
            crypto_connections[i].number = id;
            crypto_connections[i].status = 1;
            random_nonce(crypto_connections[i].recv_nonce);
            memcpy(crypto_connections[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
            crypto_box_keypair(crypto_connections[i].sessionpublic_key, crypto_connections[i].sessionsecret_key);

            if(send_cryptohandshake(id, public_key, crypto_connections[i].recv_nonce, 
                                                               crypto_connections[i].sessionpublic_key) == 1)
            {
                increment_nonce(crypto_connections[i].recv_nonce);
                return i;
            }
            return -1; /* this should never happen. */
        }
    }
    return -1;
}

/* handle an incoming connection
   return -1 if no crypto inbound connection
   return incoming connection id (Lossless_UDP one) if there is an incoming crypto connection
   Put the public key of the peer in public_key, the secret_nonce from the handshake into secret_nonce
   and the session public key for the connection in session_key
   to accept it see: accept_crypto_inbound(...)
   to refuse it just call kill_connection(...) on the connection id */
int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key)
{
    uint32_t i;
    for(i = 0; i < MAX_INCOMING; ++i)
    {
        if(incoming_connections[i] != -1)
        {
            if(is_connected(incoming_connections[i]) == 4 || is_connected(incoming_connections[i]) == 0)
            {
                kill_connection(incoming_connections[i]);
                incoming_connections[i] = -1;
                continue;
            }
            if(id_packet(incoming_connections[i]) == 2)
            {
                uint8_t temp_data[MAX_DATA_SIZE];
                uint16_t len = read_packet(incoming_connections[i], temp_data);
                if(handle_cryptohandshake(public_key, secret_nonce, session_key, temp_data, len))
                {
                    int connection_id = incoming_connections[i];
                    incoming_connections[i] = -1; /* remove this connection from the incoming connection list. */
                    return connection_id;
                }
            }
        }
    }
    return -1;
}

/* kill a crypto connection
   return 0 if killed successfully
   return 1 if there was a problem. */
int crypto_kill(int crypt_connection_id)
{ 
    if(crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS)
    {
        return 1;   
    }
    if(crypto_connections[crypt_connection_id].status != 0)
    {
        crypto_connections[crypt_connection_id].status = 0;
        kill_connection(crypto_connections[crypt_connection_id].number);
        crypto_connections[crypt_connection_id].number = ~0;
        return 0;
    }
    return 1;
}


/* accept an incoming connection using the parameters provided by crypto_inbound
   return -1 if not successful
   returns the crypt_connection_id if successful */
int accept_crypto_inbound(int connection_id, uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key)
{
    uint32_t i;
    if(connection_id == -1)
    {
        return -1;
    }
    /*
    if(getcryptconnection_id(public_key) != -1)
    {
        return -1;
    }*/
    for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i)
    {
        if(crypto_connections[i].status == 0)
        {
            crypto_connections[i].number = connection_id;
            crypto_connections[i].status = 2;
            random_nonce(crypto_connections[i].recv_nonce);
            memcpy(crypto_connections[i].sent_nonce, secret_nonce, crypto_box_NONCEBYTES);
            memcpy(crypto_connections[i].peersessionpublic_key, session_key, crypto_box_PUBLICKEYBYTES);
            increment_nonce(crypto_connections[i].sent_nonce);
            memcpy(crypto_connections[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);

            crypto_box_keypair(crypto_connections[i].sessionpublic_key, crypto_connections[i].sessionsecret_key);

            if(send_cryptohandshake(connection_id, public_key, crypto_connections[i].recv_nonce, 
                                                               crypto_connections[i].sessionpublic_key) == 1)
            {
                increment_nonce(crypto_connections[i].recv_nonce);
                uint32_t zero = 0;
                crypto_connections[i].status = 3; /* connection status needs to be 3 for write_cryptpacket() to work */
                write_cryptpacket(i, ((uint8_t *)&zero), sizeof(zero));
                crypto_connections[i].status = 2; /* set it to its proper value right after. */
                return i;
            }
            return -1; /* this should never happen. */
        }
    }
    return -1;    
}

/* return 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet 
   (we have received a handshake but no empty data packet), 3 if the connection is established.
   4 if the connection is timed out and waiting to be killed */
int is_cryptoconnected(int crypt_connection_id)
{
    if(crypt_connection_id >= 0 && crypt_connection_id < MAX_CRYPTO_CONNECTIONS)
    {
        return crypto_connections[crypt_connection_id].status;
    }
    return 0;
}


/* Generate our public and private keys
   Only call this function the first time the program starts. */
void new_keys()
{
    crypto_box_keypair(self_public_key,self_secret_key);
}

/* save the public and private keys to the keys array
   Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES */
void save_keys(uint8_t * keys)
{
    memcpy(keys, self_public_key, crypto_box_PUBLICKEYBYTES);
    memcpy(keys + crypto_box_PUBLICKEYBYTES, self_secret_key, crypto_box_SECRETKEYBYTES);
}

/* load the public and private keys from the keys array
   Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES */
void load_keys(uint8_t * keys)
{
    memcpy(self_public_key, keys, crypto_box_PUBLICKEYBYTES);
    memcpy(self_secret_key, keys + crypto_box_PUBLICKEYBYTES, crypto_box_SECRETKEYBYTES);
}

/* TODO: optimize this
   adds an incoming connection to the incoming_connection list.
   returns 0 if successful
   returns 1 if failure */
int new_incoming(int id)
{
    uint32_t i;
    for(i = 0; i < MAX_INCOMING; ++i)
    {
        if(incoming_connections[i] == -1)
        {
            incoming_connections[i] = id;
            return 0;
        }
    }
    return 1;
}

/* TODO: optimize this
   handle all new incoming connections. */
static void handle_incomings()
{
    int income;
    while(1)
    {
         income = incoming_connection();
         if(income == -1 || new_incoming(income) )
         {
             break;
         }
    }
}

/* handle received packets for not yet established crypto connections. */
static void receive_crypto()
{
    uint32_t i;
    for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i)
    {
        if(crypto_connections[i].status == 1)
        {
            uint8_t temp_data[MAX_DATA_SIZE];
            uint8_t secret_nonce[crypto_box_NONCEBYTES];
            uint8_t public_key[crypto_box_PUBLICKEYBYTES];
            uint8_t session_key[crypto_box_PUBLICKEYBYTES];
            uint16_t len;
            if(id_packet(crypto_connections[i].number) == 1) 
            /* if the packet is a friend request drop it (because we are already friends) */
            {
                len = read_packet(crypto_connections[i].number, temp_data);
                
            }
            if(id_packet(crypto_connections[i].number) == 2) /* handle handshake packet. */
            {
                len = read_packet(crypto_connections[i].number, temp_data);
                if(handle_cryptohandshake(public_key, secret_nonce, session_key, temp_data, len))
                {
                    if(memcmp(public_key, crypto_connections[i].public_key, crypto_box_PUBLICKEYBYTES) == 0)
                    {
                        memcpy(crypto_connections[i].sent_nonce, secret_nonce, crypto_box_NONCEBYTES);
                        memcpy(crypto_connections[i].peersessionpublic_key, session_key, crypto_box_PUBLICKEYBYTES);
                        increment_nonce(crypto_connections[i].sent_nonce);
                        uint32_t zero = 0;
                        crypto_connections[i].status = 3; /* connection status needs to be 3 for write_cryptpacket() to work */
                        write_cryptpacket(i, ((uint8_t *)&zero), sizeof(zero));
                        crypto_connections[i].status = 2; /* set it to its proper value right after. */
                    }
                }
            }
            else if(id_packet(crypto_connections[i].number) != -1)
            {
                /* This should not happen
                   kill the connection if it does */
                crypto_kill(crypto_connections[i].number);
            }
            
        }
        if(crypto_connections[i].status == 2)
        {
            if(id_packet(crypto_connections[i].number) == 3)
            {
                uint8_t temp_data[MAX_DATA_SIZE];
                uint8_t data[MAX_DATA_SIZE];
                int length = read_packet(crypto_connections[i].number, temp_data);
                int len = decrypt_data(crypto_connections[i].peersessionpublic_key, 
                                       crypto_connections[i].sessionsecret_key,
                                       crypto_connections[i].recv_nonce, temp_data + 1, length - 1, data);
                uint32_t zero = 0;
                if(len == sizeof(uint32_t) && memcmp(((uint8_t *)&zero), data, sizeof(uint32_t)) == 0)
                {
                    increment_nonce(crypto_connections[i].recv_nonce);
                    crypto_connections[i].status = 3;
                    
                    /* connection is accepted so we disable the auto kill by setting it to about 1 month from now. */
                    kill_connection_in(crypto_connections[i].number, 3000000);
                }
                else
                {
                    /* This should not happen
                       kill the connection if it does */
                    crypto_kill(crypto_connections[i].number);
                }
            }
            else if(id_packet(crypto_connections[i].number) != -1)
            {
                /* This should not happen
                   kill the connection if it does */
                crypto_kill(crypto_connections[i].number);
            }
        }
    }
}

/* run this to (re)initialize net_crypto
   sets all the global connection variables to their default values. */
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)
    {
        crypto_connections[i].number = ~0;
    }
}

static void killTimedout()
{
    uint32_t i;
    for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i)
    {
        if(crypto_connections[i].status != 0 && is_connected(crypto_connections[i].number) == 4)
        {
            crypto_connections[i].status = 4;
        }
        else if(is_connected(crypto_connections[i].number) == 4)
        {
            kill_connection(crypto_connections[i].number);
            crypto_connections[i].number = ~0;
        }
    }
}

/* main loop */
void doNetCrypto()
{
    /* TODO:check if friend requests were sent correctly
       handle new incoming connections
       handle friend requests */
    handle_incomings();
    receive_crypto();
    killTimedout();
}