Merge pull request #506 from irungentoo/refactor

Refactored Everything.

4 files changed, 436 insertions, 49 deletions

diff --git a/other/DHT_bootstrap.c b/other/DHT_bootstrap.c
index 299e030c..5d97b37a 100644
--- a/other/DHT_bootstrap.c
+++ b/other/DHT_bootstrap.c
@@ -44,7 +44,7 @@
 
 
 
-void manage_keys()
+void manage_keys(DHT *dht)
 {
     const uint32_t KEYS_SIZE = crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES;
     uint8_t keys[KEYS_SIZE];
@@ -60,12 +60,12 @@ void manage_keys()
             exit(1);
         }
 
-        load_keys(keys);
+        load_keys(dht->c, keys);
         printf("Keys loaded successfully\n");
     } else {
         //otherwise save new keys
-        new_keys();
-        save_keys(keys);
+        new_keys(dht->c);
+        save_keys(dht->c, keys);
         keys_file = fopen("key", "w");
 
         if (fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keys_file) != KEYS_SIZE) {
@@ -81,7 +81,13 @@ void manage_keys()
 
 int main(int argc, char *argv[])
 {
-    manage_keys();
+    //initialize networking
+    //bind to ip 0.0.0.0:PORT
+    IP ip;
+    ip.i = 0;
+    DHT *dht = new_DHT(new_net_crypto(new_networking(ip, PORT)));
+    init_cryptopackets(dht);
+    manage_keys(dht);
     printf("Public key: ");
     uint32_t i;
 
@@ -89,22 +95,17 @@ int main(int argc, char *argv[])
     file = fopen("PUBLIC_ID.txt", "w");
 
     for (i = 0; i < 32; i++) {
-        if (self_public_key[i] < 16)
+        if (dht->c->self_public_key[i] < 16)
             printf("0");
 
-        printf("%hhX", self_public_key[i]);
-        fprintf(file, "%hhX", self_public_key[i]);
+        printf("%hhX", dht->c->self_public_key[i]);
+        fprintf(file, "%hhX", dht->c->self_public_key[i]);
     }
 
     fclose(file);
 
     printf("\n");
     printf("Port: %u\n", PORT);
-    //initialize networking
-    //bind to ip 0.0.0.0:PORT
-    IP ip;
-    ip.i = 0;
-    init_networking(ip, PORT);
 
     perror("Initialization");
 
@@ -114,28 +115,24 @@ int main(int argc, char *argv[])
         bootstrap_info.ip.i = inet_addr(argv[1]);
         bootstrap_info.port = htons(atoi(argv[2]));
         uint8_t *bootstrap_key = hex_string_to_bin(argv[3]);
-        DHT_bootstrap(bootstrap_info, bootstrap_key);
+        DHT_bootstrap(dht, bootstrap_info, bootstrap_key);
         free(bootstrap_key);
     }
 
-    DHT_init();
-    friendreq_init();
-
     int is_waiting_for_dht_connection = 1;
 
     while (1) {
-        if (is_waiting_for_dht_connection && DHT_isconnected()) {
+        if (is_waiting_for_dht_connection && DHT_isconnected(dht)) {
             printf("Connected to other bootstrap server successfully.\n");
             is_waiting_for_dht_connection = 0;
         }
 
-        doDHT();
+        do_DHT(dht);
 
-        networking_poll();
+        networking_poll(dht->c->lossless_udp->net);
 
         c_sleep(1);
     }
 
-    shutdown_networking();
     return 0;
 }
diff --git a/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c b/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c
index 896d6a69..81ac538b 100644
--- a/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c
+++ b/other/bootstrap_serverdaemon/DHT_bootstrap_daemon.c
@@ -77,7 +77,7 @@ and connect to them.
 returns 1 if the connection to the DHT is up
 returns -1 if all attempts failed
 */
-int connect_to_servers(struct server_info_s *info)
+int connect_to_servers(DHT *dht, struct server_info_s *info)
 {
     int i;
     int c;
@@ -86,7 +86,7 @@ int connect_to_servers(struct server_info_s *info)
         if (info[i].valid) {
             /* Actual bootstrapping code goes here */
             //puts("Calling DHT_bootstrap");
-            DHT_bootstrap(info[i].conn, info[i].bs_pk);
+            DHT_bootstrap(dht, info[i].conn, info[i].bs_pk);
         }
     }
 
@@ -94,28 +94,28 @@ int connect_to_servers(struct server_info_s *info)
     for (c = 0; c != 100; ++c) {
         usleep(10000);
 
-        if (DHT_isconnected()) {
+        if (DHT_isconnected(dht)) {
             //puts("Connected");
             return 1;
             break;
         }
 
-        if (DHT_isconnected() == 0 && c == 99) {
+        if (DHT_isconnected(dht) == 0 && c == 99) {
             //puts("Not connected");
             return -1;
             break;
         }
 
-        doDHT();
+        do_DHT(dht);
 
-        networking_poll();
+        networking_poll(dht->c->lossless_udp->net);
     }
 
     /* This probably never happens */
     return 0;
 }
 
-void manage_keys(char *keys_file)
+void manage_keys(DHT *dht, char *keys_file)
 {
     const uint32_t KEYS_SIZE = crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES;
     uint8_t keys[KEYS_SIZE];
@@ -134,13 +134,13 @@ void manage_keys(char *keys_file)
             printf("Keys loaded successfully\n");
         }
 
-        load_keys(keys);
+        load_keys(dht->c, keys);
 
     } else {
         /* otherwise save new keys */
         /* Silly work-around to ignore any errors coming from new_keys() */
-        new_keys();
-        save_keys(keys);
+        new_keys(dht->c);
+        save_keys(dht->c, keys);
         keysf = fopen(keys_file, "w");
 
         if (fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keysf) != KEYS_SIZE) {
@@ -294,9 +294,14 @@ int main(int argc, char *argv[])
         exit(EXIT_FAILURE);
     }
 
-    /* Read the config file */
     server_conf = configure_server(argv[1]);
 
+    /* initialize networking
+    bind to ip 0.0.0.0:PORT */
+    IP ip;
+    ip.i = 0;
+    DHT *dht = new_DHT(new_net_crypto(new_networking(ip, server_conf.port)));
+    /* Read the config file */
     printf("PID file: %s\n", server_conf.pid_file);
     printf("Key file: %s\n", server_conf.keys_file);
 
@@ -313,38 +318,32 @@ int main(int argc, char *argv[])
     /* Manage the keys */
     /* for now, just ignore any errors after this call. */
     int tmperr = errno;
-    manage_keys(server_conf.keys_file);
+    manage_keys(dht, server_conf.keys_file);
     errno = tmperr;
 
+    init_cryptopackets(dht);
     /* Public key */
     int i;
     printf("\nPublic Key: ");
 
     for (i = 0; i < 32; ++i) {
         uint8_t ln, hn;
-        ln = 0x0F & self_public_key[i];
-        hn = 0xF0 & self_public_key[i];
+        ln = 0x0F & dht->c->self_public_key[i];
+        hn = 0xF0 & dht->c->self_public_key[i];
         hn = hn >> 4;
         printf("%X%X", hn, ln);
     }
 
     printf("\n");
 
-    /* initialize networking
-    bind to ip 0.0.0.0:PORT */
-    IP ip;
-    ip.i = 0;
-    init_networking(ip, server_conf.port);
-
     /* Bootstrap the DHT
     This one throws odd errors, too. Ignore. I assume they come
     from somewhere in the core. */
-    DHT_init();
     tmperr = errno;
-    connect_to_servers(server_conf.info);
+    connect_to_servers(dht, server_conf.info);
     errno = tmperr;
 
-    if (!DHT_isconnected()) {
+    if (!DHT_isconnected(dht)) {
         puts("Could not establish DHT connection. Check server settings.\n");
         exit(EXIT_FAILURE);
     } else {
@@ -404,13 +403,10 @@ int main(int argc, char *argv[])
     close(STDIN_FILENO);
     close(STDERR_FILENO);
 
-    /* Main loop */
-    friendreq_init();
-
     while (1) {
-        doDHT();
+        do_DHT(dht);
 
-        networking_poll();
+        networking_poll(dht->c->lossless_udp->net);
         usleep(10000);
     }
 
diff --git a/other/unused/timer.c b/other/unused/timer.c
new file mode 100644
index 00000000..29190921
--- /dev/null
+++ b/other/unused/timer.c
@@ -0,0 +1,290 @@
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+
+#include "timer.h"
+#include "network.h"
+
+/*
+A nested linked list increases efficiency of insertions.
+Depending on the number of timers we have, we might need to have nested linked lists
+in order to improve insertion efficiency.
+The code below is preperation for that end, should it be necessary.
+
+typedef struct {
+    struct timer_package* _next;
+    union {
+        timer_packet* _inner;
+        timer* queue;
+    };
+    uint64_t pkgtime;
+} timer_package;
+
+timer_package* timer_package_pool;
+
+static timer_package* new_package()
+{
+    timer_package* ret;
+    if (timer_package_pool) {
+        ret = timer_package_pool;
+        timer_package_pool = timer_package_pool->_next;
+    } else {
+        ret = calloc(1, sizeof(struct timer_package));
+    }
+    return ret;
+}
+
+static void delete_package(timer_package* p)
+{
+    p->_next = timer_package_pool;
+    timer_package_pool = p;
+}
+*/
+
+enum timer_state {
+    STATE_INACTIVE = 0,
+    STATE_ACTIVE,
+    STATE_CALLBACK
+};
+
+struct timer {
+    enum timer_state state;
+    timer *_prev;
+    timer *_next;
+    timer_callback cb;
+    void *userdata;
+    uint64_t deadline;
+};
+
+static timer *timer_main_queue;
+static timer *timer_us_queue; /* hi-speed queue */
+
+inline static void timer_dequeue(timer *t, timer **queue)
+{
+    if (t->state == STATE_INACTIVE) return; /* not in a queue */
+
+    if (t->_prev) {
+        t->_prev->_next = t->_next;
+    } else {
+        *queue = t->_next;
+    }
+
+    if (t->_next) t->_next->_prev = t->_prev;
+
+    t->state = STATE_INACTIVE;
+}
+
+static void timer_enqueue(timer *t, timer **queue, timer *prev)
+{
+    t->state = STATE_ACTIVE;
+
+    while (true) {
+        if (!*queue) {
+            t->_next = 0;
+            t->_prev = prev;
+            *queue = t;
+            return;
+        }
+
+        if ((*queue)->deadline > t->deadline) {
+            (*queue)->_prev = t;
+            t->_next = *queue;
+            t->_prev = prev;
+            *queue = t;
+            return;
+        }
+
+        prev = *queue;
+        queue = &((*queue)->_next);
+    }
+}
+
+/*** interface ***/
+
+void timer_init()
+{
+    /* Nothing needs to be done... yet. */
+}
+
+/* Do not depend on fields being zeroed */
+static timer *timer_pool; /* timer_pool is SINGLY LINKED!! */
+
+timer *new_timer(void)
+{
+    timer *ret;
+
+    if (timer_pool) {
+        ret = timer_pool;
+        timer_pool = timer_pool->_next;
+    } else {
+        ret = calloc(1, sizeof(struct timer));
+    }
+
+    ret->state = STATE_INACTIVE;
+    return ret;
+}
+
+void delete_timer(timer *t)
+{
+    timer_dequeue(t, &timer_main_queue);
+    t->_next = timer_pool;
+    t->state = STATE_INACTIVE;
+    timer_pool = t;
+}
+
+void timer_setup(timer *t, timer_callback cb, void *userarg)
+{
+    t->cb = cb;
+    t->userdata = userarg;
+}
+
+void *timer_get_userdata(timer *t)
+{
+    return t->userdata;
+}
+
+static void timer_delay_us(timer *t, int us)
+{
+    t->deadline += us;
+    timer **queue = t->_prev ? &(t->_prev->_next) : &timer_main_queue;
+    timer_dequeue(t, &timer_main_queue);
+    timer_enqueue(t, queue, t->_prev);
+}
+
+/* Starts the timer so that it's called in sec seconds in the future.
+ * A non-positive value of sec results in the callback being called immediately.
+ * This function may be called again after a timer has been started to adjust
+ * the expiry time. */
+void timer_start(timer *t, int sec)
+{
+    uint64_t newdeadline = current_time() + sec * US_PER_SECOND;
+
+    if (timer_is_active(t)) {
+        if (t->deadline < newdeadline) {
+            timer_delay_us(t, newdeadline - t->deadline);
+            return;
+        }
+
+        timer_dequeue(t, &timer_main_queue);
+    }
+
+    t->deadline = newdeadline;
+    timer_enqueue(t, &timer_main_queue, 0);
+}
+
+/* Stops the timer. Returns -1 if the timer was not active. */
+int timer_stop(timer *t)
+{
+    int ret = timer_is_active(t) ? -1 : 0;
+    timer_dequeue(t, &timer_main_queue);
+    return ret;
+}
+
+/* Adds additionalsec seconds to the timer.
+ * Returns -1 and does nothing if the timer was not active. */
+int timer_delay(timer *t, int additonalsec)
+{
+    if (!timer_is_active(t)) return -1;
+
+    timer_delay_us(t, additonalsec * US_PER_SECOND);
+    return 0;
+}
+
+static uint64_t timer_diff(timer *t, uint64_t time)
+{
+    if (t->deadline <= time) return 0;
+
+    return time - t->deadline;
+}
+
+/* Returns the time remaining on a timer in seconds.
+ * Returns -1 if the timer is not active.
+ * Returns 0 if the timer has expired and will be called upon the next call to timer_poll. */
+int timer_time_remaining(timer *t)
+{
+    if (!timer_is_active(t)) return -1;
+
+    return timer_diff(t, current_time()) / US_PER_SECOND;
+}
+
+bool timer_is_active(timer *t)
+{
+    return t->state != STATE_INACTIVE;
+}
+
+/* Single-use timer.
+ * Creates a new timer, preforms setup and starts it. */
+void timer_single(timer_callback cb, void *userarg, int sec)
+{
+    timer *t = new_timer();
+    timer_setup(t, cb, userarg);
+    timer_start(t, sec);
+}
+
+/* Single-use microsecond timer. */
+void timer_us(timer_callback cb, void *userarg, int us)
+{
+    timer *t = new_timer();
+    timer_setup(t, cb, userarg);
+    t->deadline = current_time() + us;
+    t->state = STATE_ACTIVE;
+    timer_enqueue(t, &timer_us_queue, 0);
+}
+
+uint64_t prevtime = 0;
+void timer_poll(void)
+{
+    uint64_t time = current_time();
+
+    /* Handle millisecond timers */
+    while (timer_us_queue) {
+        if (timer_diff(timer_us_queue, time) != 0) break;
+
+        timer *t = timer_us_queue;
+        timer_dequeue(t, &timer_us_queue);
+        t->cb(0, t->userdata);
+        delete_timer(t);
+    }
+
+    if (time - prevtime > US_PER_SECOND || prevtime == 0 || prevtime > time) {
+        /* time moving backwards is just a sanity check */
+        prevtime = time;
+
+        while (timer_main_queue) {
+            if (timer_diff(timer_main_queue, time) != 0) break;
+
+            timer *t = timer_main_queue;
+            t->state = STATE_CALLBACK;
+            int rv = t->cb(t, t->userdata);
+
+            if (rv != 0) {
+                timer_dequeue(t, &timer_main_queue);
+                delete_timer(t);
+                continue;
+            }
+
+            if (t->state != STATE_ACTIVE) {
+                timer_dequeue(t, &timer_main_queue);
+            }
+        }
+    }
+}
+
+/*** Internal Testing ***/
+
+/* I do not want to expose internals to the public,
+ * which is why internals testing is done this way. */
+void timer_internal_tests(bool (*assert)(bool, char *))
+{
+
+}
+
+void timer_debug_print()
+{
+    timer *t = timer_main_queue;
+    printf("Queue:\n");
+
+    while (t) {
+        printf("%" PRIu64 " (%" PRIu64 ") : %s\n", t->deadline, t->deadline / US_PER_SECOND, (char *)t->userdata);
+        t = t->_next;
+    }
+}
diff --git a/other/unused/timer.h b/other/unused/timer.h
new file mode 100644
index 00000000..15491326
--- /dev/null
+++ b/other/unused/timer.h
@@ -0,0 +1,104 @@
+/*  timer.h
+ *
+ *  Timing subsystem. Provides deadline timers.
+ *  All times are aliased to a second for efficiency.
+ *
+ *  Timer Guarantees:
+ *  - The callback will not be called before the timer expires.
+ *  - The callback will be called sometime after the timer expires,
+ *    on a best effort basis.
+ *  - If timer_poll is called at least once a second, the callback
+ *    will be called at most one second after it expires.
+ *
+ *  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/>.
+ *
+ */
+
+#ifndef TIMER_H
+#define TIMER_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define US_PER_SECOND 1000000 /* 1 s = 10^6 us */
+
+struct timer;
+typedef struct timer timer;
+
+/* If time_callback returns a non-zero value, timer t is deleted.
+ * You may call any of the timer functions within the callback:
+ * For example, you may call timer_start to restart the timer from
+ * within a callback. */
+typedef int (*timer_callback)(timer *t, void *userarg);
+
+/* Initisalise timer subsystem */
+void timer_init(void);
+
+/* Poll. (I will eventually replace all polling in Tox with an async system.) */
+void timer_poll(void);
+
+/* Creates a new timer. Does not enqueue/start it. */
+timer *new_timer(void);
+
+/* Destroys a timer instance. */
+void delete_timer(timer *t);
+
+/* Sets up the timer callback. */
+void timer_setup(timer *t, timer_callback cb, void *userarg);
+
+/* Accessor Function. */
+void *timer_get_userdata(timer *t);
+
+/* Starts the timer so that it's called in sec seconds in the future from now.
+ * A non-positive value of sec results in the callback being called immediately.
+ * This function may be called again after a timer has been started to adjust
+ * the expiry time. */
+void timer_start(timer *t, int sec);
+
+/* Stops the timer. Returns -1 if the timer was not active. */
+int timer_stop(timer *t);
+
+/* Adds additionalsec seconds to the timer.
+ * Returns -1 and does nothing if the timer was not active. */
+int timer_delay(timer *t, int additonalsec);
+
+/* Returns the time remaining on a timer in seconds.
+ * Returns -1 if the timer is not active.
+ * Returns 0 if the timer has expired and the callback hasn't been called yet. */
+int timer_time_remaining(timer *t);
+
+/* Determines if timer is active. Returns TRUE if it is active */
+bool timer_is_active(timer *t);
+
+/* Single-use timer.
+ * Creates a new timer, preforms setup and starts it.
+ * Callback must return a non-zero value to prevent memory leak. */
+void timer_single(timer_callback cb, void *userarg, int sec);
+
+/* Single-use microsecond timer.
+ * Creates a new timer, preforms setup and starts it.
+ * Please do not use this when accuracy is not absolutely required.
+ * Use when one needs to time a period < 1 s.
+ * Use the more coarse timers above for periods > 5 s.
+ * WARNING: the callback will be called with NULL as the first argument */
+void timer_us(timer_callback cb, void *userarg, int us);
+
+/* Internal Testing */
+void timer_internal_tests(bool( *)(bool, char *));
+
+#endif