Merge branch 'master' of git://github.com/irungentoo/ProjectTox-Core

cmake/FindLIBCONFIG.cmake

@@ -5,7 +5,12 @@
 # LIBCONFIG_FOUND
 #
 
-FIND_PATH(LIBCONFIG_INCLUDE_DIR NAMES libconfig.h)
+if (UNIX)
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(_LIBCONFIG QUIET libconfig)
+endif ()
+
+FIND_PATH(LIBCONFIG_INCLUDE_DIR NAMES libconfig.h HINTS ${_LIBCONFIG_INCLUDEDIR})
 
 FIND_LIBRARY(LIBCONFIG_LIBRARY NAMES config)
 

core/DHT.c

@@ -24,6 +24,7 @@
 /*----------------------------------------------------------------------------------*/
 
 #include "DHT.h"
+#include "packets.h"
 #include "ping.h"
 
 /* maximum number of clients stored per friend. */
@@ -351,7 +352,7 @@ static int replace_good(   Client_data *   list,
 /* Attempt to add client with ip_port and client_id to the friends client list 
  * and close_clientlist 
  */
-static void addto_lists(IP_Port ip_port, uint8_t * client_id)
+void addto_lists(IP_Port ip_port, uint8_t * client_id)
 {
     uint32_t i;
 
@@ -472,71 +473,6 @@ static uint64_t add_gettingnodes(IP_Port ip_port)
     return 0;
 }
 
-/* send a ping request, only works if none has been sent to that ip/port
- * in the last 5 seconds. 
- */
-static int pingreq(IP_Port ip_port, uint8_t * public_key)
-{ 
-    /* check if packet is gonna be sent to ourself */
-    if(id_equal(public_key, self_public_key) || is_pinging(ip_port, 0))
-        return 1;
-
-    uint64_t ping_id = add_ping(ip_port);
-    if(ping_id == 0)
-        return 1;
-
-    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING];
-    uint8_t encrypt[sizeof(ping_id) + ENCRYPTION_PADDING];
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    random_nonce(nonce);
-
-    int len = encrypt_data( public_key, 
-                            self_secret_key, 
-                            nonce, 
-                            (uint8_t *)&ping_id, 
-                            sizeof(ping_id), 
-                            encrypt );
-
-    if(len != sizeof(ping_id) + ENCRYPTION_PADDING)
-        return -1;
-
-    data[0] = 0;
-    memcpy(data + 1, self_public_key, CLIENT_ID_SIZE);
-    memcpy(data + 1 + CLIENT_ID_SIZE, nonce, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, encrypt, len);
-
-    return sendpacket(ip_port, data, sizeof(data));
-}
-
-/* send a ping response */
-static int pingres(IP_Port ip_port, uint8_t * public_key, uint64_t ping_id)
-{
-    /* check if packet is gonna be sent to ourself */
-    if(id_equal(public_key, self_public_key))
-        return 1;
-
-    uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING];
-    uint8_t encrypt[sizeof(ping_id) + ENCRYPTION_PADDING];
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    random_nonce(nonce);
-
-    int len = encrypt_data( public_key, 
-                            self_secret_key, nonce, 
-                            (uint8_t *)&ping_id, 
-                            sizeof(ping_id), 
-                            encrypt );
-
-    if(len != sizeof(ping_id) + ENCRYPTION_PADDING)
-        return -1;
-
-    data[0] = 1;
-    memcpy(data + 1, self_public_key, CLIENT_ID_SIZE);
-    memcpy(data + 1 + CLIENT_ID_SIZE, nonce, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, encrypt, len);
-
-    return sendpacket(ip_port, data, sizeof(data));
-}
-
 /* send a getnodes request */
 static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id)
 {
@@ -618,62 +554,6 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id,
     return sendpacket(ip_port, data, 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + len);
 }
 
-/* Packet handling functions, one to handle each types of packets we receive
- * Returns 0 if handled correctly, 1 if packet is bad.
- */
-static int handle_pingreq(uint8_t * packet, uint32_t length, IP_Port source)
-{
-    uint64_t ping_id;
-    if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING)
-        return 1;
-
-    /* check if packet is from ourself. */
-    if(id_equal(packet + 1, self_public_key))
-        return 1;
-
-    int len = decrypt_data( packet + 1, 
-                            self_secret_key, 
-                            packet + 1 + CLIENT_ID_SIZE,
-                            packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                            sizeof(ping_id) + ENCRYPTION_PADDING, 
-                            (uint8_t *)&ping_id );
-
-    if(len != sizeof(ping_id))
-        return 1;
-
-    pingres(source, packet + 1, ping_id);
-    pingreq(source, packet + 1); /* TODO: make this smarter? */
-
-    return 0;
-}
-
-static int handle_pingres(uint8_t * packet, uint32_t length, IP_Port source)
-{
-    uint64_t ping_id;
-    if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING)
-        return 1;
-
-    /* check if packet is from ourself. */
-    if(id_equal(packet + 1, self_public_key))
-        return 1;
-
-    int len = decrypt_data( packet + 1, 
-                            self_secret_key, 
-                            packet + 1 + CLIENT_ID_SIZE,
-                            packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                            sizeof(ping_id) + ENCRYPTION_PADDING, 
-                            (uint8_t *)&ping_id );
-
-    if(len != sizeof(ping_id))
-        return 1;
-
-    if(is_pinging(source, ping_id)) {
-        addto_lists(source, packet + 1);
-        return 0;
-    }
-    return 1;
-}
-
 static int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source)
 {
     uint64_t ping_id;
@@ -701,7 +581,7 @@ static int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source)
     memcpy(&ping_id, plain, sizeof(ping_id));
     sendnodes(source, packet + 1, plain + sizeof(ping_id), ping_id);
 
-    pingreq(source, packet + 1); /* TODO: make this smarter? */
+    send_ping_request(source, (clientid_t*) (packet + 1)); /* TODO: make this smarter? */
 
     return 0;
 }
@@ -741,7 +621,7 @@ static int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source)
 
     uint32_t i;
     for(i = 0; i < num_nodes; ++i)  {
-        pingreq(nodes_list[i].ip_port, nodes_list[i].client_id);
+        send_ping_request(nodes_list[i].ip_port, (clientid_t*) &nodes_list[i].client_id);
         returnedip_ports(nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1);
     }
 
@@ -831,8 +711,8 @@ static void doDHTFriends(void)
             /* if node is not dead. */
           if (!is_timeout(temp_time, friends_list[i].client_list[j].timestamp, Kill_NODE_TIMEOUT)) {
                 if ((friends_list[i].client_list[j].last_pinged + PING_INTERVAL) <= temp_time) {
-                    pingreq( friends_list[i].client_list[j].ip_port, 
+                    send_ping_request( friends_list[i].client_list[j].ip_port, 
-                             friends_list[i].client_list[j].client_id );
+                                       (clientid_t*) &friends_list[i].client_list[j].client_id );
                     friends_list[i].client_list[j].last_pinged = temp_time;
                 }
                 /* if node is good. */
@@ -869,8 +749,8 @@ static void doClose(void)
         /* if node is not dead. */
         if (!is_timeout(temp_time, close_clientlist[i].timestamp, Kill_NODE_TIMEOUT)) {
             if ((close_clientlist[i].last_pinged + PING_INTERVAL) <= temp_time) {
-                pingreq( close_clientlist[i].ip_port, 
+                send_ping_request( close_clientlist[i].ip_port, 
-                         close_clientlist[i].client_id );
+                                   (clientid_t*) &close_clientlist[i].client_id );
                 close_clientlist[i].last_pinged = temp_time;
             }
             /* if node is good. */
@@ -1151,7 +1031,7 @@ static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t
         /*TODO: improve port guessing algorithm*/
         uint16_t port = port_list[(i/2) % numports] + (i/(2*numports))*((i % 2) ? -1 : 1);
         IP_Port pinging = {ip, htons(port)};
-        pingreq(pinging, friends_list[friend_num].client_id);
+        send_ping_request(pinging, (clientid_t*) &friends_list[friend_num].client_id);
     }
     friends_list[friend_num].punching_index = i;
 }
@@ -1198,10 +1078,10 @@ int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source)
 {
     switch (packet[0]) {
     case 0:
-        return handle_pingreq(packet, length, source);
+        return handle_ping_request(packet, length, source);
 
     case 1:
-        return handle_pingres(packet, length, source);
+        return handle_ping_response(packet, length, source);
 
     case 2:
         return handle_getnodes(packet, length, source);

core/DHT.h

@@ -104,6 +104,8 @@ int DHT_load(uint8_t *data, uint32_t size);
     returns 1 if we are */
 int DHT_isconnected();
 
+void addto_lists(IP_Port ip_port, uint8_t * client_id);
+
 #ifdef __cplusplus
 }
 #endif

core/LAN_discovery.c

@@ -70,6 +70,10 @@ static uint32_t get_broadcast(void)
         }
     }
     close(sock);
+    if(sock_holder == NULL) {
+        perror("[!] no broadcast device found");
+        return 0;
+    }
 
     return sock_holder->sin_addr.s_addr;
 }

core/Messenger.c

@@ -116,7 +116,7 @@ int m_addfriend(uint8_t *client_id, uint8_t *data, uint16_t length)
         return FAERR_ALREADYSENT;
 
     uint32_t i;
-    for (i = 0; i <= numfriends && i <= MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
+    for (i = 0; i < numfriends && i < MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
         if(friendlist[i].status == NOFRIEND) {
             DHT_addfriend(client_id);
             friendlist[i].status = FRIEND_ADDED;
@@ -141,7 +141,7 @@ int m_addfriend_norequest(uint8_t * client_id)
     if (getfriend_id(client_id) != -1)
         return -1;
     uint32_t i;
-    for (i = 0; i <= numfriends && i <= MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
+    for (i = 0; i < numfriends && i < MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
         if(friendlist[i].status == NOFRIEND) {
             DHT_addfriend(client_id);
             friendlist[i].status = FRIEND_REQUESTED;
@@ -352,7 +352,7 @@ static int send_userstatus(int friendnumber, uint8_t * status, uint16_t length)
     memcpy(thepacket + 2, status, length);
     thepacket[0] = PACKET_ID_USERSTATUS;
     thepacket[1] = self_userstatus_kind;
-    int written = write_cryptpacket(friendlist[friendnumber].crypt_connection_id, thepacket, length + 1);
+    int written = write_cryptpacket(friendlist[friendnumber].crypt_connection_id, thepacket, length + 2);
     free(thepacket);
     return written;
 }

core/packets.h

@@ -0,0 +1,37 @@
+/*
+ * packet.h -- Packet structure
+ *
+ * This file is donated to the Tox Project.
+ * Copyright 2013  plutooo
+ */
+
+typedef struct {
+    uint8_t id[CLIENT_ID_SIZE];
+
+} __attribute__((packed)) clientid_t;
+
+typedef enum {
+    PACKET_PING_REQ = 0,
+    PACKET_PING_RES = 1
+
+} packetid_t;
+
+// Ping packet
+typedef struct {
+    uint8_t    magic;
+    clientid_t client_id;
+    uint8_t    nonce[crypto_box_NONCEBYTES];
+    uint64_t   ping_id;
+    uint8_t    padding[ENCRYPTION_PADDING];
+
+} __attribute__((packed)) pingreq_t;
+
+// Pong packet
+typedef struct {
+    uint8_t    magic;
+    clientid_t client_id;
+    uint8_t    nonce[crypto_box_NONCEBYTES];
+    uint64_t   ping_id;
+    uint8_t    padding[ENCRYPTION_PADDING];
+
+} __attribute__((packed)) pingres_t;

core/ping.c

@@ -8,6 +8,9 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "DHT.h"
+#include "net_crypto.h"
+#include "packets.h"
 #include "network.h"
 #include "util.h"
 
@@ -23,7 +26,9 @@ typedef struct {
 static pinged_t    pings[PING_NUM_MAX];
 static size_t      num_pings;
 static size_t      pos_pings;
+static clientid_t* self_id = (clientid_t*) &self_public_key;
 
+extern uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; // DHT.c
 
 void init_ping()
 {
@@ -51,9 +56,10 @@ static void remove_timeouts()   // O(n)
             new_num--;
         }
         // Break here because list is sorted.
-        else
+        else {
             break;
         }
+    }
 
     num_pings = new_num;
     pos_pings = new_pos % PING_NUM_MAX;
@@ -94,6 +100,7 @@ bool is_pinging(IP_Port ipp, uint64_t ping_id)   // O(n) TODO: replace this with
     for (i=0; i<num_pings; i++) {
         id = (pos_pings + i) % PING_NUM_MAX;
 
+        // ping_id = 0 means match any id
         if ((ipp_eq(pings[id].ipp, ipp) || ipp.ip.i == 0) && (pings[id].id == ping_id || ping_id == 0)) {
             return true;
         }
@@ -101,3 +108,113 @@ bool is_pinging(IP_Port ipp, uint64_t ping_id)   // O(n) TODO: replace this with
 
     return false;
 }
+
+int send_ping_request(IP_Port ipp, clientid_t* client_id)
+{
+    pingreq_t pk;
+    int       rc;
+    uint64_t  ping_id;
+
+    if (is_pinging(ipp, 0) || id_eq(client_id, self_id))
+        return 1;
+
+    // Generate random ping_id
+    ping_id = add_ping(ipp);
+
+    pk.magic = PACKET_PING_REQ;
+    id_cpy(&pk.client_id, self_id);     // Our pubkey
+    random_nonce((uint8_t*) &pk.nonce); // Generate random nonce
+
+    // Encrypt ping_id using recipient privkey
+    rc = encrypt_data((uint8_t*) client_id,
+                      self_secret_key,
+                      (uint8_t*) &pk.nonce,
+                      (uint8_t*) &ping_id, sizeof(ping_id),
+                      (uint8_t*) &pk.ping_id);
+
+    if (rc != sizeof(ping_id) + ENCRYPTION_PADDING)
+        return 1;
+
+    return sendpacket(ipp, (uint8_t*) &pk, sizeof(pk));
+}
+
+int send_ping_response(IP_Port ipp, clientid_t* client_id, uint64_t ping_id)
+{
+    pingres_t pk;
+    int       rc;
+
+    if (id_eq(client_id, self_id))
+        return 1;
+
+    pk.magic = PACKET_PING_RES;
+    id_cpy(&pk.client_id, self_id);     // Our pubkey
+    random_nonce((uint8_t*) &pk.nonce); // Generate random nonce
+
+    // Encrypt ping_id using recipient privkey
+    rc = encrypt_data((uint8_t*) client_id,
+                      self_secret_key,
+                      (uint8_t*) &pk.nonce,
+                      (uint8_t*) &ping_id, sizeof(ping_id),
+                      (uint8_t*) &pk.ping_id);
+
+    if (rc != sizeof(ping_id) + ENCRYPTION_PADDING)
+        return 1;
+
+    return sendpacket(ipp, (uint8_t*) &pk, sizeof(pk));
+}
+
+int handle_ping_request(uint8_t* packet, uint32_t length, IP_Port source)
+{
+    pingreq_t* p = (pingreq_t*) packet;
+    int        rc;
+    uint64_t   ping_id;
+
+    if (length != sizeof(pingreq_t) || id_eq(&p->client_id, self_id))
+        return 1;
+
+    // Decrypt ping_id
+    rc = decrypt_data((uint8_t*) &p->client_id,
+                      self_secret_key,
+                      (uint8_t*) &p->nonce,
+                      (uint8_t*) &p->ping_id,
+                      sizeof(ping_id) + ENCRYPTION_PADDING,
+                      (uint8_t*) &ping_id);
+
+    if (rc != sizeof(ping_id))
+        return 1;
+
+    // Send response
+    send_ping_response(source, &p->client_id, ping_id);
+    send_ping_request(source, &p->client_id); // Make this smarter?
+
+    return 0;
+}
+
+int handle_ping_response(uint8_t* packet, uint32_t length, IP_Port source)
+{
+    pingres_t* p = (pingres_t*) packet;
+    int       rc;
+    uint64_t  ping_id;
+
+    if (length != sizeof(pingres_t) || id_eq(&p->client_id, self_id))
+        return 1;
+
+    // Decrypt ping_id
+    rc = decrypt_data((uint8_t*) &p->client_id,
+                      self_secret_key,
+                      (uint8_t*) &p->nonce,
+                      (uint8_t*) &p->ping_id,
+                      sizeof(ping_id) + ENCRYPTION_PADDING,
+                      (uint8_t*) &ping_id);
+
+    if (rc != sizeof(ping_id))
+        return 1;
+
+    // Make sure ping_id is correct
+    if(!is_pinging(source, ping_id))
+        return 1;
+
+    // Associate source ip with client_id
+    addto_lists(source, (uint8_t*) &p->client_id);
+    return 0;
+}

core/ping.h

@@ -10,4 +10,7 @@
 void init_ping();
 uint64_t add_ping(IP_Port ipp);
 bool is_pinging(IP_Port ipp, uint64_t ping_id);
-
+int send_ping_request(IP_Port ipp, clientid_t* client_id);
+int send_ping_response(IP_Port ipp, clientid_t* client_id, uint64_t ping_id);
+int handle_ping_request(uint8_t* packet, uint32_t length, IP_Port source);
+int handle_ping_response(uint8_t* packet, uint32_t length, IP_Port source);

core/util.c

@@ -9,7 +9,8 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-#include "network.h"
+#include "DHT.h"
+#include "packets.h"
 
 uint64_t now()
 {
@@ -32,3 +33,13 @@ bool ipp_eq(IP_Port a, IP_Port b)
 {
     return (a.ip.i == b.ip.i) && (a.port == b.port);
 }
+
+bool id_eq(clientid_t* dest, clientid_t* src)
+{
+    return memcmp(dest, src, sizeof(clientid_t)) == 0;
+}
+
+void id_cpy(clientid_t* dest, clientid_t* src)
+{
+    memcpy(dest, src, sizeof(clientid_t));
+}

core/util.h

@@ -8,3 +8,6 @@
 uint64_t now();
 uint64_t random_64b();
 bool ipp_eq(IP_Port a, IP_Port b);
+bool id_eq(clientid_t* dest, clientid_t* src);
+void id_cpy(clientid_t* dest, clientid_t* src);
+

testing/misc_tools.c

@@ -25,7 +25,11 @@
 
 #include <string.h>
 #include <stdlib.h>
-#include <stdio.h> /* for sscanf */
+#include <stdio.h>
+
+#ifdef DEBUG
+#include <assert.h>
+#endif // DEBUG
 
 /* TODO: rewrite */
 unsigned char * hex_string_to_bin(char hex_string[])
@@ -39,3 +43,9 @@ unsigned char * hex_string_to_bin(char hex_string[])
 
     return val;
 }
+
+
+
+
+
+

testing/misc_tools.h

@@ -26,4 +26,144 @@
 
 unsigned char * hex_string_to_bin(char hex_string[]);
 
+/* WARNING(msg) takes a printf()-styled string and prints it
+ * with some additional details.
+ * ERROR(exit_status, msg) does the same thing as WARNING(), but
+ * also exits the program with the given exit status.
+ * Examples:
+ * WARNING("<insert warning message here>");
+ * int exit_status = 2;
+ * ERROR(exit_status, "exiting with status %i", exit_status);
+ */
+#ifdef DEBUG
+    #include <assert.h>
+    #include <stdio.h>
+    #include <string.h>
+
+    #define DEBUG_PRINT(str, ...) do { \
+        char msg[1000]; \
+        sprintf(msg, "%s(): line %d (file %s): %s%%c\n", __FUNCTION__, __LINE__, __FILE__, str); \
+        fprintf(stderr, msg, __VA_ARGS__); \
+    } while (0)
+
+    #define WARNING(...) do { \
+        fprintf(stderr, "warning in "); \
+        DEBUG_PRINT(__VA_ARGS__, ' '); \
+    } while (0)
+
+    #define ERROR(exit_status, ...) do { \
+        fprintf(stderr, "error in "); \
+        DEBUG_PRINT(__VA_ARGS__, ' '); \
+        exit(exit_status); \
+    } while (0)
+#else
+    #define WARNING(...)
+    #define ERROR(...)
+#endif // DEBUG
+
+/************************Linked List***********************
+ * This is a simple linked list implementation, very similar
+ * to Linux kernel's /include/linux/list.h (which we can't 
+ * use because Tox is GPLv3 and Linux is GPLv2.)
+ *
+ * TODO: Make the lists easier to use with some sweat pre-
+ * processor syntactic sugar.
+ **********************************************************/
+
+/* Example usage
+
+This sample program makes a new struct which contains a
+character and a tox_list_t. It then prompts a user for
+input until he enters q or e. It then adds each character
+to the list, and uses a special for loop to print them.
+It then removes all the 'z' characters, and prints the list
+again.
+
+//Notice that the data to be put in the list *contains* tox_list_t;
+//usually, this is the other way around!
+typedef struct tox_string {
+   char c;
+   tox_list_t tox_lst; //Notice that tox_lst is *NOT* a pointer.
+} tox_string_t;
+
+int main()
+{
+   tox_list_t head;
+   tox_list_new(&head); //initialize head
+   
+   //input a new character, until user enters q or e
+   char c = '\0';
+   while (c != 'q' && c != 'e') {
+      scanf("%c", &c);
+      tox_string_t* tmp = malloc(sizeof(tox_string_t));
+      tmp->c = c;
+      tox_list_add(&head, &tmp->tox_lst); //add it to the list
+   }
+   
+TOX_LIST_FOR_EACH() takes a struct tox_list and a name for a temporary pointer to use in the loop.
+   
+TOX_LIST_GET_VALUE() uses magic to return an instance of a structure that contains tox_list_t.
+You have to give it a temporary tox_string_t, name of tox_list_t member inside our structure (tox_lst),
+and the type of structure to return.
+   
+   TOX_LIST_FOR_EACH(head, tmp)
+      printf("%c", TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c);
+   
+   TOX_LIST_FOR_EACH(head, tmp) {
+      if (TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c == 'z') {
+         //If you delete tmp, you have to quit the loop, or it will go on infinitly.
+         //This will be fixed later on.
+         tox_list_remove(tmp);
+         break;
+      }
+   }
+   
+   printf("\n");
+   TOX_LIST_FOR_EACH(head, tmp)
+      printf("%c", TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c);
+   
+   
+   return 0;
+}
+*/
+
+#define MEMBER_OFFSET(var_name_in_parent, parent_type) \
+   (&(((parent_type*)0)->var_name_in_parent))
+
+#define GET_PARENT(var, var_name_in_parent, parent_type) \
+   (*((parent_type*)((uint64_t)(&(var)) - (uint64_t)(MEMBER_OFFSET(var_name_in_parent, parent_type)))))
+
+#define TOX_LIST_FOR_EACH(lst, tmp_name) \
+   for (tox_list_t* tmp_name = lst.next; tmp_name != &lst; tmp_name = tmp_name->next)
+
+#define TOX_LIST_GET_VALUE(tmp_name, name_in_parent, parent_type) GET_PARENT(tmp_name, name_in_parent, parent_type)
+
+typedef struct tox_list {
+   struct tox_list *prev, *next;
+} tox_list_t;
+
+/* Returns a new tox_list_t. */
+static inline void tox_list_new(tox_list_t* lst) {
+   lst->prev = lst->next = lst;
+}
+      
+/* Inserts a new tox_lst after lst and returns it. */
+static inline void tox_list_add(tox_list_t* lst, tox_list_t* new_lst) {
+   tox_list_new(new_lst);
+
+   new_lst->next = lst->next;
+   new_lst->next->prev = new_lst;
+
+   lst->next = new_lst;
+   new_lst->prev = lst;
+}
+
+static inline void tox_list_remove(tox_list_t* lst) {
+#ifdef DEBUG /* TODO: check how debugging is done in Tox. */
+   assert(lst->next != lst && lst->prev != lst);
+#endif
+   lst->prev->next = lst->next;
+   lst->next->prev = lst->prev;
+}
+
 #endif // MISC_TOOLS_H

testing/nTox.c

@@ -410,6 +410,8 @@ void load_key(char *path)
         }
     }
 
+    if(fclose(data_file) < 0)
+        perror("[!] fclose failed");
     return;
 
 FILE_ERROR:

testing/toxic/chat.c

@@ -16,23 +16,23 @@
 
 typedef struct {
   int friendnum;
-
   char line[256];
   size_t pos;
-
   WINDOW* history;
   WINDOW* linewin;
-
 } ChatContext;
 
+extern int active_window;
+
+extern void del_window(ToxWindow *w, int f_num);
 extern void fix_name(uint8_t *name);
 void print_help(ChatContext *self);
 void execute(ToxWindow *self, ChatContext *ctx, char *cmd);
 
-static void chat_onMessage(ToxWindow* self, int num, uint8_t* msg, uint16_t len) {
+static void chat_onMessage(ToxWindow *self, int num, uint8_t *msg, uint16_t len)
+{
   ChatContext *ctx = (ChatContext*) self->x;
   uint8_t nick[MAX_NAME_LENGTH] = {0};
-  
   time_t now;
   time(&now);
   struct tm * timeinfo;
@@ -42,15 +42,13 @@ static void chat_onMessage(ToxWindow* self, int num, uint8_t* msg, uint16_t len)
     return;
 
   getname(num, (uint8_t*) &nick);
-
   msg[len-1] = '\0';
   nick[MAX_NAME_LENGTH-1] = '\0';
-
   fix_name(msg);
   fix_name(nick);
 
   wattron(ctx->history, COLOR_PAIR(2));
-  wprintw(ctx->history, "%02d:%02d:%02d  ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
+  wprintw(ctx->history, "[%02d:%02d:%02d] ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
   wattroff(ctx->history, COLOR_PAIR(2));
   wattron(ctx->history, COLOR_PAIR(4));
   wprintw(ctx->history, "%s: ", nick);
@@ -62,15 +60,14 @@ static void chat_onMessage(ToxWindow* self, int num, uint8_t* msg, uint16_t len)
   flash();
 }
 
-static void chat_onNickChange(ToxWindow* self, int num, uint8_t* nick, uint16_t len) {
+static void chat_onNickChange(ToxWindow *self, int num, uint8_t *nick, uint16_t len)
+{
   ChatContext *ctx = (ChatContext*) self->x;
-
   if (ctx->friendnum != num)
     return;
 
   nick[len-1] = '\0';
   fix_name(nick);
-
   snprintf(self->title, sizeof(self->title), "[%s (%d)]", nick, num);
 
   wattron(ctx->history, COLOR_PAIR(3));
@@ -78,7 +75,8 @@ static void chat_onNickChange(ToxWindow* self, int num, uint8_t* nick, uint16_t
   wattroff(ctx->history, COLOR_PAIR(3));
 }
 
-static void chat_onStatusChange(ToxWindow* self, int num, uint8_t* status, uint16_t len) {
+static void chat_onStatusChange(ToxWindow *self, int num, uint8_t *status, uint16_t len)
+{
 
 }
 
@@ -87,22 +85,20 @@ int string_is_empty(char *string)
 {
   int rc = 0;
   char *copy = strdup(string);
-
   rc = ((strtok(copy, " ") == NULL) ? 1:0);
   free(copy);
-
   return rc;
 }
 
-static void chat_onKey(ToxWindow* self, int key) {
+static void chat_onKey(ToxWindow *self, int key)
+{
   ChatContext *ctx = (ChatContext*) self->x;
-
   time_t now;
   time(&now);
   struct tm * timeinfo;
   timeinfo = localtime(&now);
 
-  /* PRINTABLE characters: Add to line */
+  /* Add printable characters to line */
   if (isprint(key)) {
     if (ctx->pos != sizeof(ctx->line)-1) {
       ctx->line[ctx->pos++] = key;
@@ -118,7 +114,7 @@ static void chat_onKey(ToxWindow* self, int key) {
       if (!string_is_empty(ctx->line)) {
         /* make sure the string has at least non-space character */
         wattron(ctx->history, COLOR_PAIR(2));
-        wprintw(ctx->history, "%02d:%02d:%02d ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
+        wprintw(ctx->history, "[%02d:%02d:%02d] ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
         wattroff(ctx->history, COLOR_PAIR(2));
         wattron(ctx->history, COLOR_PAIR(1));
         wprintw(ctx->history, "you: ", ctx->line);
@@ -149,12 +145,15 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
     wclear(self->window);
     wclear(ctx->history);
   }
+
   else if (!strcmp(cmd, "/help") || !strcmp(cmd, "/h"))
     print_help(ctx);
+
   else if (!strcmp(cmd, "/quit") || !strcmp(cmd, "/exit") || !strcmp(cmd, "/q")) {
     endwin();
     exit(0);
   }
+
   else if (!strncmp(cmd, "/status ", strlen("/status "))) {
     char *msg;
     msg = strchr(cmd, ' ');
@@ -166,6 +165,7 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
     m_set_userstatus(USERSTATUS_KIND_RETAIN, (uint8_t*) msg, strlen(msg)+1);
     wprintw(ctx->history, "Status set to: %s\n", msg);
   }
+
   else if (!strncmp(cmd, "/nick ", strlen("/nick "))) {
     char *nick;
     nick = strchr(cmd, ' ');
@@ -177,6 +177,7 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
     setname((uint8_t*) nick, strlen(nick)+1);
     wprintw(ctx->history, "Nickname set to: %s\n", nick);
   }
+
   else if (!strcmp(cmd, "/myid")) {
     char id[32*2 + 1] = {0};
     int i;
@@ -187,58 +188,64 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
     }
     wprintw(ctx->history, "Your ID: %s\n", id);
   }
+
+  else if (strcmp(ctx->line, "/close") == 0) {
+    active_window = 0;    // Go to prompt screen
+    int f_num = ctx->friendnum;
+    delwin(ctx->linewin);
+    del_window(self, f_num);
+  }
+
   else
     wprintw(ctx->history, "Invalid command.\n");
 }
 
-static void chat_onDraw(ToxWindow* self) {
+static void chat_onDraw(ToxWindow *self)
+{
   curs_set(1);
   int x, y;
   ChatContext *ctx = (ChatContext*) self->x;
-
   getmaxyx(self->window, y, x);
-
   (void) x;
-  if(y < 3)
+  if (y < 3) return;
-    return;
 
   wclear(ctx->linewin);
   mvwhline(ctx->linewin, 0, 0, '_', COLS);
   mvwprintw(self->window, y-1, 0, "%s\n", ctx->line);
-
   wrefresh(self->window);
 }
 
-static void chat_onInit(ToxWindow* self) {
+static void chat_onInit(ToxWindow *self)
+{
   int x, y;
   ChatContext *ctx = (ChatContext*) self->x;
-
   getmaxyx(self->window, y, x);
-
   ctx->history = subwin(self->window, y - 4, x, 0, 0);
   scrollok(ctx->history, 1);
-
   ctx->linewin = subwin(self->window, 2, x, y - 3, 0);
+  print_help(ctx);
 }
 
-void print_help(ChatContext* self) {
+void print_help(ChatContext *self)
+{
   wattron(self->history, COLOR_PAIR(2) | A_BOLD);
-  wprintw(self->history, "\nCommands:\n");
+  wprintw(self->history, "Commands:\n");
   wattroff(self->history, A_BOLD);
   
   wprintw(self->history, "      /status <message>          : Set your status\n");
   wprintw(self->history, "      /nick <nickname>           : Set your nickname\n");
   wprintw(self->history, "      /myid                      : Print your ID\n");
   wprintw(self->history, "      /clear                     : Clear the screen\n");
+  wprintw(self->history, "      /close                     : Close the current chat window\n");
   wprintw(self->history, "      /quit or /exit             : Exit program\n");
   wprintw(self->history, "      /help                      : Print this message again\n\n");
 
   wattroff(self->history, COLOR_PAIR(2));
 }
 
-ToxWindow new_chat(int friendnum) {
+ToxWindow new_chat(int friendnum)
+{
   ToxWindow ret;
-
   memset(&ret, 0, sizeof(ret));
 
   ret.onKey = &chat_onKey;
@@ -256,7 +263,6 @@ ToxWindow new_chat(int friendnum) {
 
   ChatContext *x = calloc(1, sizeof(ChatContext));
   x->friendnum = friendnum;
-
   ret.x = (void*) x;
   return ret;
 }

testing/toxic/friendlist.c

@@ -12,11 +12,11 @@
 
 #include "windows.h"
 
-extern int add_window(ToxWindow w);
+extern char WINDOW_STATUS[TOXWINDOWS_MAX_NUM];
-extern int focus_window(int num);
+extern int add_window(ToxWindow w, int n);
 extern ToxWindow new_chat(int friendnum);
 
-#define MAX_FRIENDS_NUM 100
+extern int active_window;
 
 typedef struct {
   uint8_t name[MAX_NAME_LENGTH];
@@ -29,36 +29,41 @@ static friend_t friends[MAX_FRIENDS_NUM];
 static int num_friends = 0;
 static int num_selected = 0;
 
-
+void fix_name(uint8_t *name)
-void fix_name(uint8_t* name) {
+{
-
+  /* Remove all non alphanumeric characters */
-  // Remove all non alphanumeric characters.
   uint8_t *p = name;
   uint8_t *q = name;
-
   while(*p != 0) {
-    if(isprint(*p)) {
+    if (isprint(*p))
       *q++ = *p;
-    }
-
     p++;
   }
-
   *q = 0;
 }
 
-void friendlist_onMessage(ToxWindow* self, int num, uint8_t* str, uint16_t len) {
+void friendlist_onMessage(ToxWindow *self, int num, uint8_t *str, uint16_t len)
-
+{
   if (num >= num_friends)
     return;
 
   if (friends[num].chatwin == -1) {
-    friends[num].chatwin = add_window(new_chat(num));
+    friends[num].chatwin = num;
+    int i;
+    /* Find first open slot to hold chat window */
+    for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
+      if (WINDOW_STATUS[i] == -1) {
+        WINDOW_STATUS[i] = num;
+        add_window(new_chat(num), i);
+        active_window = i;
+        break;
+      }
+    }
   }
 }
 
-void friendlist_onNickChange(ToxWindow* self, int num, uint8_t* str, uint16_t len) {
+void friendlist_onNickChange(ToxWindow *self, int num, uint8_t *str, uint16_t len)
-
+{
   if (len >= MAX_NAME_LENGTH || num >= num_friends)
     return;
 
@@ -67,8 +72,8 @@ void friendlist_onNickChange(ToxWindow* self, int num, uint8_t* str, uint16_t le
   fix_name(friends[num].name);
 }
 
-void friendlist_onStatusChange(ToxWindow* self, int num, uint8_t* str, uint16_t len) {
+void friendlist_onStatusChange(ToxWindow *self, int num, uint8_t *str, uint16_t len)
-
+{
   if (len >= MAX_USERSTATUS_LENGTH || num >= num_friends)
     return;
 
@@ -77,8 +82,8 @@ void friendlist_onStatusChange(ToxWindow* self, int num, uint8_t* str, uint16_t
   fix_name(friends[num].status);
 }
 
-int friendlist_onFriendAdded(int num) {
+int friendlist_onFriendAdded(int num)
-
+{
   if (num_friends == MAX_FRIENDS_NUM)
     return -1;
 
@@ -86,38 +91,49 @@ int friendlist_onFriendAdded(int num) {
   getname(num, friends[num_friends].name);
   strcpy((char*) friends[num_friends].name, "unknown");
   strcpy((char*) friends[num_friends].status, "unknown");
-  friends[num_friends].chatwin = -1;
+  friends[num_friends++].chatwin = -1;
-
-  num_friends++;
   return 0;
 }
 
-static void friendlist_onKey(ToxWindow* self, int key) {
+static void friendlist_onKey(ToxWindow *self, int key)
-
+{
   if (key == KEY_UP) {
-    if(num_selected != 0)
+    if (--num_selected < 0)
-      num_selected--;
+      num_selected = num_friends-1;
   }
   else if (key == KEY_DOWN) {
     if (num_friends != 0)
       num_selected = (num_selected+1) % num_friends;
   }
   else if (key == '\n') {
-
+    /* Jump to chat window if already open */
-    if(friends[num_selected].chatwin != -1)
+    if (friends[num_selected].chatwin != -1) {
-      return;
+      int i;
-
+      for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
-    friends[num_selected].chatwin = add_window(new_chat(num_selected));
+        if (WINDOW_STATUS[i] == num_selected) {
-    focus_window(friends[num_selected].chatwin);
+          active_window = i;
+          break;
+        }
+      }
+    }else {
+      int i;
+      for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
+        if (WINDOW_STATUS[i] == -1) {
+          WINDOW_STATUS[i] = num_selected;
+          friends[num_selected].chatwin = num_selected;
+          add_window(new_chat(num_selected), i);
+          active_window = i;
+          break;
+        }
+      }
+    }
   }
 }
 
-static void friendlist_onDraw(ToxWindow* self) {
+static void friendlist_onDraw(ToxWindow *self)
+{
   curs_set(0);
-  size_t i;
-
   werase(self->window);
-
   if (num_friends == 0) {
     wprintw(self->window, "Empty. Add some friends! :-)\n");
   }
@@ -128,9 +144,8 @@ static void friendlist_onDraw(ToxWindow* self) {
   }
 
   wprintw(self->window, "\n");
-
+  int i;
-  for(i=0; i<num_friends; i++) {
+  for (i = 0; i < num_friends; ++i) {
-
     if (i == num_selected) wattron(self->window, COLOR_PAIR(3));
     wprintw(self->window, "  [#%d] ", friends[i].num);
     if (i == num_selected) wattroff(self->window, COLOR_PAIR(3));
@@ -141,18 +156,21 @@ static void friendlist_onDraw(ToxWindow* self) {
 
     wprintw(self->window, "(%s)\n", friends[i].status);
   }
-
   wrefresh(self->window);
 }
 
-static void friendlist_onInit(ToxWindow* self) {
+void disable_chatwin(int f_num)
+{
+  friends[f_num].chatwin = -1;
+}
+
+static void friendlist_onInit(ToxWindow *self) 
+{
 
 }
 
-
 ToxWindow new_friendlist() {
   ToxWindow ret;
-
   memset(&ret, 0, sizeof(ret));
 
   ret.onKey = &friendlist_onKey;
@@ -161,7 +179,7 @@ ToxWindow new_friendlist() {
   ret.onMessage = &friendlist_onMessage;
   ret.onNickChange = &friendlist_onNickChange;
   ret.onStatusChange = &friendlist_onStatusChange;
-  strcpy(ret.title, "[friends]");
 
+  strcpy(ret.title, "[friends]");
   return ret;
 }

testing/toxic/main.c

@@ -17,76 +17,76 @@ extern ToxWindow new_prompt();
 extern ToxWindow new_friendlist();
 
 extern int friendlist_onFriendAdded(int num);
-
+extern void disable_chatwin(int f_num);
 extern int add_req(uint8_t *public_key); // XXX
 
-#define TOXWINDOWS_MAX_NUM 32
+/* Holds status of chat windows */
+char WINDOW_STATUS[MAX_WINDOW_SLOTS];
 
-static ToxWindow windows[TOXWINDOWS_MAX_NUM];
+static ToxWindow windows[MAX_WINDOW_SLOTS];
-static int w_num;
-static int w_active;
 static ToxWindow* prompt;
 
-// CALLBACKS START
+int w_num;
-void on_request(uint8_t* public_key, uint8_t* data, uint16_t length) {
+int active_window;
-  size_t i;
-  int n = add_req(public_key);
 
+/* CALLBACKS START */
+void on_request(uint8_t *public_key, uint8_t *data, uint16_t length)
+{
+  int n = add_req(public_key);
   wprintw(prompt->window, "\nFriend request from:\n");
 
-  for(i=0; i<32; i++) {
+  int i;
+  for (i = 0; i < 32; ++i) {
     wprintw(prompt->window, "%02x", public_key[i] & 0xff);
   }
+
   wprintw(prompt->window, "\n");
-
   wprintw(prompt->window, "Use \"accept %d\" to accept it.\n", n);
-
+  for (i = 0; i < MAX_WINDOW_SLOTS; ++i) {
-  for(i=0; i<w_num; i++) {
     if (windows[i].onFriendRequest != NULL)
       windows[i].onFriendRequest(&windows[i], public_key, data, length);
   }
 }
 
-void on_message(int friendnumber, uint8_t* string, uint16_t length) {
+void on_message(int friendnumber, uint8_t *string, uint16_t length)
-  size_t i;
+{
-
   wprintw(prompt->window, "\n(message) %d: %s\n", friendnumber, string);
-
+  int i;
-  for(i=0; i<w_num; i++) {
+  for (i = 0; i < MAX_WINDOW_SLOTS; ++i) {
     if (windows[i].onMessage != NULL)
       windows[i].onMessage(&windows[i], friendnumber, string, length);
   }
 }
 
-void on_nickchange(int friendnumber, uint8_t* string, uint16_t length) {
+void on_nickchange(int friendnumber, uint8_t *string, uint16_t length)
-  size_t i;
+{
-
   wprintw(prompt->window, "\n(nickchange) %d: %s!\n", friendnumber, string);
-
+  int i;
-  for(i=0; i<w_num; i++) {
+  for (i = 0; i < MAX_WINDOW_SLOTS; ++i) {
     if (windows[i].onNickChange != NULL)
       windows[i].onNickChange(&windows[i], friendnumber, string, length);
   }
 }
 
-void on_statuschange(int friendnumber, USERSTATUS_KIND kind, uint8_t* string, uint16_t length) {
+void on_statuschange(int friendnumber, USERSTATUS_KIND kind, uint8_t *string, uint16_t length)
-  size_t i;
+{
-
   wprintw(prompt->window, "\n(statuschange) %d: %s\n", friendnumber, string);
-
+  int i;
-  for(i=0; i<w_num; i++) {
+  for (i=0; i<MAX_WINDOW_SLOTS; ++i) {
     if (windows[i].onStatusChange != NULL)
       windows[i].onStatusChange(&windows[i], friendnumber, string, length);
   }
 }
 
-void on_friendadded(int friendnumber) {
+void on_friendadded(int friendnumber)
+{
   friendlist_onFriendAdded(friendnumber);
 }
-// CALLBACKS END
+/* CALLBACKS END */
 
-static void init_term() {
+static void init_term()
-  // Setup terminal.
+{
+  /* Setup terminal */
   initscr();
   cbreak();
   keypad(stdscr, 1);
@@ -100,64 +100,84 @@ static void init_term() {
     init_pair(3, COLOR_RED, COLOR_BLACK);
     init_pair(4, COLOR_BLUE, COLOR_BLACK);
   }
-
   refresh();
 }
 
-static void init_tox() {
+static void init_tox()
-  // Init core.
+{
+  /* Init core */
   initMessenger();
 
-  // Callbacks.
+  /* Callbacks */
   m_callback_friendrequest(on_request);
   m_callback_friendmessage(on_message);
   m_callback_namechange(on_nickchange);
   m_callback_userstatus(on_statuschange);
 }
 
-int add_window(ToxWindow w) {
+void init_window_status()
-  if(w_num == TOXWINDOWS_MAX_NUM)
+{
+  /* Default window values decrement from -2 */
+  int i;
+  for (i = 0; i < N_DEFAULT_WINS; ++i)
+    WINDOW_STATUS[i] = -(i+2);
+
+  int j;
+  for (j = N_DEFAULT_WINS; j < MAX_WINDOW_SLOTS; j++)
+    WINDOW_STATUS[j] = -1;
+}
+
+int add_window(ToxWindow w, int n)
+{
+  if (w_num >= TOXWINDOWS_MAX_NUM)
     return -1;
 
   if (LINES < 2)
     return -1;
 
   w.window = newwin(LINES - 2, COLS, 0, 0);
-
   if (w.window == NULL)
     return -1;
 
-  windows[w_num++] = w;
+  windows[n] = w;
   w.onInit(&w);
-
+  w_num++;
-  return w_num - 1;
+  return n;
 }
 
-int focus_window(int num) {
+/* Deletes window w and cleans up */
-  if(num >= w_num || num < 0)
+void del_window(ToxWindow *w, int f_num)
-    return -1;
+{
-
+  delwin(w->window);
-  w_active = num;
+  int i;
-  return 0;
+  for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
+    if (WINDOW_STATUS[i] == f_num) {
+      WINDOW_STATUS[i] = -1;
+      disable_chatwin(f_num);
+      break;
+    }
+  }
+  clear();
+  refresh();
 }
 
-static void init_windows() {
+static void init_windows()
+{
   w_num = 0;
-  w_active = 0;
+  int n_prompt = 0;
-
+  int n_friendslist = 1;
-  if(add_window(new_prompt()) == -1 || add_window(new_friendlist()) == -1) {
+  if (add_window(new_prompt(), n_prompt) == -1 
+                        || add_window(new_friendlist(), n_friendslist) == -1) {
     fprintf(stderr, "add_window() failed.\n");
-
     endwin();
     exit(1);
   }
-
+  prompt = &windows[n_prompt];
-  prompt = &windows[0];
 }
 
-static void do_tox() {
+static void do_tox()
+{
   static bool dht_on = false;
-
   if (!dht_on && DHT_isconnected()) {
     dht_on = true;
     wprintw(prompt->window, "\nDHT connected!\n");
@@ -166,11 +186,11 @@ static void do_tox() {
     dht_on = false;
     wprintw(prompt->window, "\nDHT disconnected!\n");
   }
-
   doMessenger();
 }
 
-static void load_data(char *path) {
+static void load_data(char *path)
+{
   FILE *fd;
   size_t len;
   uint8_t *buf;
@@ -181,42 +201,34 @@ static void load_data(char *path) {
     fseek(fd, 0, SEEK_SET);
 
     buf = malloc(len);
-
     if (buf == NULL) {
       fprintf(stderr, "malloc() failed.\n");
-
       fclose(fd);
       endwin();
       exit(1);
     }
-
     if (fread(buf, len, 1, fd) != 1){
       fprintf(stderr, "fread() failed.\n");
-
       free(buf);
       fclose(fd);
       endwin();
       exit(1);
     }
-
     Messenger_load(buf, len);
   }
   else {
     len = Messenger_size();
     buf = malloc(len);
-
     if (buf == NULL) {
       fprintf(stderr, "malloc() failed.\n");
       endwin();
       exit(1);
     }
-
     Messenger_save(buf);
 
     fd = fopen(path, "w");
     if (fd == NULL) {
       fprintf(stderr, "fopen() failed.\n");
-
       free(buf);
       endwin();
       exit(1);
@@ -224,21 +236,19 @@ static void load_data(char *path) {
 
     if (fwrite(buf, len, 1, fd) != 1){
       fprintf(stderr, "fwrite() failed.\n");
-
       free(buf);
       fclose(fd);
       endwin();
       exit(1);
     }
   }
-
   free(buf);
   fclose(fd);
 }
 
-static void draw_bar() {
+static void draw_bar()
+{
   static int odd = 0;
-  size_t i;
 
   attron(COLOR_PAIR(4));
   mvhline(LINES - 2, 0, '_', COLS);
@@ -250,61 +260,98 @@ static void draw_bar() {
   printw(" TOXIC 1.0 |");
   attroff(COLOR_PAIR(4) | A_BOLD);
 
-  for(i=0; i<w_num; i++) {
+  int i;
-    if(i == w_active) {
+  for (i = 0; i < (MAX_WINDOW_SLOTS); ++i) {
+    if (WINDOW_STATUS[i] != -1) {
+      if (i == active_window)
         attron(A_BOLD);
-    }
 
       odd = (odd+1) % 10;
-
       if (windows[i].blink && (odd < 5)) {
         attron(COLOR_PAIR(3));
       }
 
       printw(" %s", windows[i].title);
-
       if (windows[i].blink && (odd < 5)) {
         attron(COLOR_PAIR(3));
       }
-
+      if (i == active_window) {
-    if(i == w_active) {
         attroff(A_BOLD);
       }
     }
-
+  }
   refresh();
 }
 
-void prepare_window(WINDOW* w) {
+void prepare_window(WINDOW *w)
+{
   mvwin(w, 0, 0);
   wresize(w, LINES-2, COLS);
 }
 
-int main(int argc, char* argv[]) {
+/* Shows next window when tab or back-tab is pressed */
+void set_active_window(int ch)
+{
+  int f_inf = 0;
+  int max = MAX_WINDOW_SLOTS-1;
+  if (ch == '\t') {
+    int i = (active_window + 1) % max;
+    while (true) {
+      if (WINDOW_STATUS[i] != -1) {
+        active_window = i;
+        return;
+      }
+      i = (i  + 1) % max;
+      if (f_inf++ > max) {    // infinite loop check
+        endwin();
+        clear();
+        exit(2);
+      }
+    }
+  }else {
+    int i = active_window - 1;
+    if (i < 0) i = max;
+    while (true) {
+      if (WINDOW_STATUS[i] != -1) {
+        active_window = i;
+        return;
+      }
+      if (--i < 0) i = max;
+      if (f_inf++ > max) {
+        endwin();
+        clear();
+        exit(2);
+      }
+    }
+  }
+}
+
+int main(int argc, char *argv[])
+{
   int ch;
-  int i = 0;
   int f_flag = 0;
   char *filename = "data";
   ToxWindow* a;
 
-    for(i = 0; i < argc; i++) {
+  int i = 0;
-      if (argv[i] == NULL){
+  for (i = 0; i < argc; ++i) {
+    if (argv[i] == NULL)
       break;
-      } else if(argv[i][0] == '-') {
+    else if (argv[i][0] == '-') {
       if (argv[i][1] == 'f') {
         if (argv[i + 1] != NULL)
           filename = argv[i + 1];
-                else {
+        else
           f_flag = -1;
       }
     }
   }
-    }
 
   init_term();
   init_tox();
   load_data(filename);
   init_windows();
+  init_window_status();
 
   if (f_flag == -1) {
     attron(COLOR_PAIR(3) | A_BOLD);
@@ -313,32 +360,24 @@ int main(int argc, char* argv[]) {
     attroff(COLOR_PAIR(3) | A_BOLD);
   }
   
-
   while(true) {
-    // Update tox.
+    /* Update tox */
     do_tox();
 
-    // Draw.
+    /* Draw */
-    a = &windows[w_active];
+    a = &windows[active_window];
     prepare_window(a->window);
     a->blink = false;
     draw_bar();
     a->onDraw(a);
 
-    // Handle input.
+    /* Handle input */
     ch = getch();
-    if(ch == '\t') {
+    if (ch == '\t' || ch == KEY_BTAB)
-      w_active = (w_active + 1) % w_num;
+      set_active_window(ch);
-    }
-    else if(ch == KEY_BTAB) {
-      w_active = (w_active + w_num - 1) % w_num;
-    }
     else if (ch != ERR) {
       a->onKey(a, ch);
     }
-
   }
-
   return 0;
 }
-

testing/toxic/prompt.c

@@ -17,12 +17,14 @@ uint8_t num_requests=0; // XXX
 
 extern void on_friendadded(int friendnumber);
 static void print_usage(ToxWindow *self);
+static char prompt_buf[256] = {0};
+static int prompt_buf_pos = 0;
 
 // XXX:
-int add_req(uint8_t* public_key) {
+int add_req(uint8_t *public_key)
+{
   memcpy(pending_requests[num_requests], public_key, CLIENT_ID_SIZE);
   ++num_requests;
-
   return num_requests-1;
 }
 
@@ -38,29 +40,33 @@ unsigned char * hex_string_to_bin(char hex_string[])
   return val;
 }
 
-static char prompt_buf[256] = {0};
+static void execute(ToxWindow *self, char *u_cmd)
-static int prompt_buf_pos=0;
+{
-
+  int newlines = 0;
-static void execute(ToxWindow* self, char* cmd) {
+  char cmd[256] = {0};
+  int i;
+  for (i = 0; i < strlen(prompt_buf); ++i) {
+    if (u_cmd[i] == '\n')
+      ++newlines;
+    else
+      cmd[i - newlines] = u_cmd[i];
+  }
 
   if (!strcmp(cmd, "quit") || !strcmp(cmd, "exit") || !strcmp(cmd, "q")) {
     endwin();
     exit(0);
   }
-  else if(!strncmp(cmd, "connect ", strlen("connect "))) {
-    char* ip;
-    char* port;
-    char* key;
-    IP_Port dht;
 
-    ip = strchr(cmd, ' ');
+  else if (!strncmp(cmd, "connect ", strlen("connect "))) {
+    IP_Port dht;
+    char *ip = strchr(cmd, ' ');
     if (ip == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
     ip++;
 
-    port = strchr(ip, ' ');
+    char *port = strchr(ip, ' ');
     if (port == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
@@ -68,7 +74,7 @@ static void execute(ToxWindow* self, char* cmd) {
     port[0] = 0;
     port++;
 
-    key = strchr(port, ' ');
+    char *key = strchr(port, ' ');
     if (key == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
@@ -82,7 +88,6 @@ static void execute(ToxWindow* self, char* cmd) {
     }
 
     dht.port = htons(atoi(port));
-
     uint32_t resolved_address = resolve_addr(ip);
     if (resolved_address == 0) {
       return;
@@ -93,49 +98,39 @@ static void execute(ToxWindow* self, char* cmd) {
     DHT_bootstrap(dht, binary_string);
     free(binary_string);
   }
+
   else if (!strncmp(cmd, "add ", strlen("add "))) {
     uint8_t id_bin[32];
-    size_t i;
     char xx[3];
     uint32_t x;
-
+    char *id = strchr(cmd, ' ');
-    char* id;
-    char* msg;
-    int num;
-
-    id = strchr(cmd, ' ');
     if (id == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
     id++;
-
+    char *msg = strchr(id, ' ');
-    msg = strchr(id, ' ');
     if (msg != NULL) {
       msg[0] = 0;
       msg++;
     }
     else msg = "";
-
     if (strlen(id) != 2*32) {
       wprintw(self->window, "Invalid ID length.\n");
       return;
     }
-
+    int i;
-    for(i=0; i<32; i++) {
+    for (i = 0; i < 32; ++i) {
       xx[0] = id[2*i];
       xx[1] = id[2*i+1];
       xx[2] = '\0';
-
       if (sscanf(xx, "%02x", &x) != 1) {
         wprintw(self->window, "Invalid ID.\n");
         return;
       }
-
       id_bin[i] = x;
     }
-
+    int num = m_addfriend(id_bin, (uint8_t*) msg, strlen(msg)+1);
-    num = m_addfriend(id_bin, (uint8_t*) msg, strlen(msg)+1);
     switch (num) {
     case -1:
       wprintw(self->window, "Message is too long.\n");
@@ -158,121 +153,116 @@ static void execute(ToxWindow* self, char* cmd) {
       break;
     }
   }
+
   else if (!strcmp(cmd, "clear")) {
     wclear(self->window);
   }
+
   else if (!strcmp(cmd, "help")) {
+    wclear(self->window);
     print_usage(self);
   }
-  else if(!strncmp(cmd, "status ", strlen("status "))) {
-    char* msg;
 
-    msg = strchr(cmd, ' ');
+  else if (!strncmp(cmd, "status ", strlen("status "))) {
+    char *msg = strchr(cmd, ' ');
     if (msg == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
     msg++;
-
     m_set_userstatus(USERSTATUS_KIND_RETAIN, (uint8_t*) msg, strlen(msg)+1);
     wprintw(self->window, "Status set to: %s\n", msg);
   }
-  else if(!strncmp(cmd, "nick ", strlen("nick "))) {
-    char* nick;
 
-    nick = strchr(cmd, ' ');
+  else if (!strncmp(cmd, "nick ", strlen("nick "))) {
+    char *nick = strchr(cmd, ' ');
     if (nick == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
     nick++;
-
     setname((uint8_t*) nick, strlen(nick)+1);
     wprintw(self->window, "Nickname set to: %s\n", nick);
   }
+
   else if (!strcmp(cmd, "myid")) {
     char id[32*2 + 1] = {0};
     size_t i;
-
+    for (i = 0; i < 32; ++i) {
-    for(i=0; i<32; i++) {
       char xx[3];
       snprintf(xx, sizeof(xx), "%02x", self_public_key[i] & 0xff);
       strcat(id, xx);
     }
-    
     wprintw(self->window, "Your ID: %s\n", id);
   }
-  else if(!strncmp(cmd, "accept ", strlen("accept "))) {
-    char* id;
-    int num;
 
-    id = strchr(cmd, ' ');
+  else if (!strncmp(cmd, "accept ", strlen("accept "))) {
+    char *id = strchr(cmd, ' ');
     if (id == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
     id++;
 
-    num = atoi(id);
+    int num = atoi(id);
     if (num >= num_requests) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
 
     num = m_addfriend_norequest(pending_requests[num]);
-
+    if (num == -1)
-    if(num == -1) {
       wprintw(self->window, "Failed to add friend.\n");
-    }
     else {
       wprintw(self->window, "Friend accepted as: %d.\n", num);
       on_friendadded(num);
     }
   }
+
   else if (!strncmp(cmd, "msg ", strlen("msg "))) {
-    char* id;
+    char *id = strchr(cmd, ' ');
-    char* msg;
-
-    id = strchr(cmd, ' ');
-
     if (id == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
-    id++;
+    char *msg = strchr(++id, ' ');
-
-    msg = strchr(id, ' ');
     if (msg == NULL) {
       wprintw(self->window, "Invalid syntax.\n");
       return;
     }
     msg[0] = 0;
     msg++;
-
+    if (m_sendmessage(atoi(id), (uint8_t*) msg, strlen(msg)+1) < 0)
-    if(m_sendmessage(atoi(id), (uint8_t*) msg, strlen(msg)+1) < 0) {
       wprintw(self->window, "Error occurred while sending message.\n");
-    }
+    else
-    else {
       wprintw(self->window, "Message successfully sent.\n");
   }
-  }
+  else
-
-  else {
     wprintw(self->window, "Invalid command.\n");
 }
-}
 
-static void prompt_onKey(ToxWindow* self, int key) {
+static void prompt_onKey(ToxWindow *self, int key)
-  // PRINTABLE characters: Add to line.
+{
+  /* Add printable characters to line */
   if (isprint(key)) {
     if (prompt_buf_pos == (sizeof(prompt_buf) - 1)) {
-      return;
+      wprintw(self->window, "\nToo Long.\n");
+      prompt_buf_pos = 0;
+      prompt_buf[0] = 0;
+    }
+    else if (!(prompt_buf_pos == 0) && (prompt_buf_pos < COLS)
+                                 && (prompt_buf_pos % (COLS - 3) == 0)) {
+      prompt_buf[prompt_buf_pos++] = '\n';
+    }
+    else if (!(prompt_buf_pos == 0) && (prompt_buf_pos > COLS)
+                 && ((prompt_buf_pos - (COLS - 3)) % (COLS) == 0)) {
+      prompt_buf[prompt_buf_pos++] = '\n';
     }
     prompt_buf[prompt_buf_pos++] = key;
     prompt_buf[prompt_buf_pos] = 0;
   }
 
-  // RETURN key: execute command.
+  /* RETURN key: execute command */
   else if (key == '\n') {
     wprintw(self->window, "\n");
     execute(self, prompt_buf);
@@ -280,7 +270,7 @@ static void prompt_onKey(ToxWindow* self, int key) {
     prompt_buf[0] = 0;
   }
 
-  // BACKSPACE key: Remove one character from line.
+  /* BACKSPACE key: Remove one character from line */
   else if (key == 0x107 || key == 0x8 || key == 0x7f) {
     if (prompt_buf_pos != 0) {
       prompt_buf[--prompt_buf_pos] = 0;
@@ -288,24 +278,28 @@ static void prompt_onKey(ToxWindow* self, int key) {
   }
 }
 
-static void prompt_onDraw(ToxWindow* self) {
+static void prompt_onDraw(ToxWindow *self)
+{
   curs_set(1);
   int x, y;
-
   getyx(self->window, y, x);
   (void) x;
+  int i;
+  for (i = 0; i < (strlen(prompt_buf)); ++i) {
+    if ((prompt_buf[i] == '\n') && (y != 0))
+      --y;
+  }
 
   wattron(self->window, COLOR_PAIR(1));
   mvwprintw(self->window, y, 0, "# ");
   wattroff(self->window, COLOR_PAIR(1));
-
   mvwprintw(self->window, y, 2, "%s", prompt_buf);
   wclrtoeol(self->window);
-
   wrefresh(self->window);
 }
 
-static void print_usage(ToxWindow* self) {
+static void print_usage(ToxWindow *self)
+{
   wattron(self->window, COLOR_PAIR(2) | A_BOLD);
   wprintw(self->window, "Commands:\n");
   wattroff(self->window, A_BOLD);
@@ -327,22 +321,20 @@ static void print_usage(ToxWindow* self) {
   wattroff(self->window, COLOR_PAIR(2));
 }
 
-static void prompt_onInit(ToxWindow* self) {
+static void prompt_onInit(ToxWindow *self)
+{
   scrollok(self->window, 1);
-
   print_usage(self);
   wclrtoeol(self->window);
 }
 
-ToxWindow new_prompt() {
+ToxWindow new_prompt()
+{
   ToxWindow ret;
-
   memset(&ret, 0, sizeof(ret));
-
   ret.onKey = &prompt_onKey;
   ret.onDraw = &prompt_onDraw;
   ret.onInit = &prompt_onInit;
   strcpy(ret.title, "[prompt]");
-
   return ret;
 }

testing/toxic/windows.h

@@ -3,6 +3,14 @@
  */
 
 #include <stdbool.h>
+#define TOXWINDOWS_MAX_NUM 32
+#define MAX_FRIENDS_NUM 100
+ 
+/* number of permanent default windows */
+#define N_DEFAULT_WINS 2  
+
+/* maximum window slots for WINDOW_STATUS array */
+#define MAX_WINDOW_SLOTS N_DEFAULT_WINS+MAX_FRIENDS_NUM
 
 typedef struct ToxWindow_ ToxWindow;