Made chicago's get time function a callback in order to prepare for unit testing

Author: maglar00

libcurvecpr/include/curvecpr/chicago.h

@@ -1,6 +1,21 @@
 #ifndef __CURVECPR_CHICAGO_H
 #define __CURVECPR_CHICAGO_H
 
+struct curvecpr_chicago_ops {
+    /* Get current time in nanoseconds. The time 0 can be any time as long
+       as present time is not too close to it (>100 seconds should be ok) and
+       it doesn't change during the lifetime of this chicago instance (i.e.
+       it doesn't have to be for example 1970-01-01, but can be the number of
+       nanoseconds since the computer booted+100s or whatever).
+       You can pass in curvecpr_util_nanoseconds() here if you want. */
+    long long (*get_nanoseconds)(void *priv);
+};
+
+struct curvecpr_chicago_cf {
+    struct curvecpr_chicago_ops ops;
+    void *priv;
+};
+
 struct curvecpr_chicago {
     long long clock;
 
@@ -24,9 +39,11 @@ struct curvecpr_chicago {
     long long ns_last_edge;
     long long ns_last_doubling;
     long long ns_last_panic;
+    
+    struct curvecpr_chicago_cf cf;
 };
 
-void curvecpr_chicago_new (struct curvecpr_chicago *chicago);
+void curvecpr_chicago_new (struct curvecpr_chicago *chicago, const struct curvecpr_chicago_cf *cf);
 void curvecpr_chicago_refresh_clock (struct curvecpr_chicago *chicago);
 void curvecpr_chicago_on_timeout (struct curvecpr_chicago *chicago);
 void curvecpr_chicago_on_recv (struct curvecpr_chicago *chicago, long long ns_sent);

libcurvecpr/include/curvecpr/messager.h

@@ -10,6 +10,28 @@
 
 struct curvecpr_messager;
 
+
+/* The callbacks you need to implement to get a reliable stream transport.
+   You need to implement the three data structures mentioned below.
+   Terminology:
+        sendq (send queue): The data waiting to get sent. When you want to send 
+            something, you divide it into curvecpr_block:s (each at most 
+            messager->my_maximum_send_bytes in size) and put it in this
+            queue (you have to do this yourself). When you call 
+            curvecpr_messager_process_sendq() it will check
+            this queue for data ready to be sent. It might not happen
+            immediately, but at a later invocation depending on the 
+            decongestion algorithm and packets waiting to be resent etc.
+        sendmarkq (sent-to-be-marked queue): When a curvecpr_block is sent
+            (using the send() callback function), it is moved from sendq to
+            sendmarkq (if it wasn't moved earlier and this is just a resend). 
+            It waits here until it has been acknowledged by the recipient.
+        recvmarkq (received-to-be-marked): Received curvecpr_block:s are stored
+            here until we have sent an ACK (which happens right after they are
+            stored actually). You need to assemble the stream data from this 
+            data structure yourself.
+ 
+*/
 struct curvecpr_messager_ops {
     int (*sendq_head)(struct curvecpr_messager *messager, struct curvecpr_block **block_stored);
     int (*sendq_move_to_sendmarkq)(struct curvecpr_messager *messager, const struct curvecpr_block *block, struct curvecpr_block **block_stored);
@@ -19,17 +41,22 @@ struct curvecpr_messager_ops {
        the time at which they were last sent. */
     int (*sendmarkq_head)(struct curvecpr_messager *messager, struct curvecpr_block **block_stored);
     int (*sendmarkq_get)(struct curvecpr_messager *messager, crypto_uint32 acknowledging_id, struct curvecpr_block **block_stored);
+    
+    /* This is called for all ranges in incoming messages's acknowledge structure */
     int (*sendmarkq_remove_range)(struct curvecpr_messager *messager, unsigned long long start, unsigned long long end);
     unsigned char (*sendmarkq_is_full)(struct curvecpr_messager *messager);
 
+    /* This is called once for each message coming in that is not a pure acknowledgement */
     int (*recvmarkq_put)(struct curvecpr_messager *messager, const struct curvecpr_block *block, struct curvecpr_block **block_stored);
+    
     int (*recvmarkq_get_nth_unacknowledged)(struct curvecpr_messager *messager, unsigned int n, struct curvecpr_block **block_stored);
     unsigned char (*recvmarkq_is_empty)(struct curvecpr_messager *messager);
     int (*recvmarkq_remove_range)(struct curvecpr_messager *messager, unsigned long long start, unsigned long long end);
 
     int (*send)(struct curvecpr_messager *messager, const unsigned char *buf, size_t num);
 
     void (*put_next_timeout)(struct curvecpr_messager *messager, const long long timeout_ns);
+    long long (*get_nanoseconds)(void *priv);
 };
 
 struct curvecpr_messager_cf {
@@ -50,6 +77,9 @@ struct curvecpr_messager {
     unsigned char my_eof;
     unsigned char my_final;
 
+    /* The client can only send 512 bytes/message until we know that an 
+        initiation packet has reached the server. Then this variable is raised 
+        to 1024 bytes. The server can send 1024 bytes/message from the start. */
     size_t my_maximum_send_bytes;
 
     crypto_uint64 my_sent_bytes;
@@ -68,6 +98,7 @@ struct curvecpr_messager {
 
 void curvecpr_messager_new (struct curvecpr_messager *messager, const struct curvecpr_messager_cf *cf, unsigned char client);
 int curvecpr_messager_recv (struct curvecpr_messager *messager, const unsigned char *buf, size_t num);
+/* Call this function on timeout and when you have added things to sendq if it was empty. */
 int curvecpr_messager_process_sendq (struct curvecpr_messager *messager);
 long long curvecpr_messager_next_timeout (struct curvecpr_messager *messager);
 

libcurvecpr/include/curvecpr/util.h

@@ -2,7 +2,7 @@
 #define __CURVECPR_UTIL_H
 
 long long curvecpr_util_random_mod_n (long long n);
-long long curvecpr_util_nanoseconds (void);
+long long curvecpr_util_nanoseconds (void *);
 int curvecpr_util_encode_domain_name (unsigned char *destination, const char *source);
 
 #endif

libcurvecpr/lib/chicago.c

@@ -123,10 +123,13 @@ static void _update_on_timeout (struct curvecpr_chicago *chicago)
     }
 }
 
-void curvecpr_chicago_new (struct curvecpr_chicago *chicago)
+void curvecpr_chicago_new (struct curvecpr_chicago *chicago, const struct curvecpr_chicago_cf *cf)
 {
     curvecpr_bytes_zero(chicago, sizeof(struct curvecpr_chicago));
 
+    if (cf)
+        curvecpr_bytes_copy(&chicago->cf, cf, sizeof(struct curvecpr_chicago_cf));
+
     curvecpr_chicago_refresh_clock(chicago);
 
     chicago->rtt_latest = 0;
@@ -153,7 +156,7 @@ void curvecpr_chicago_new (struct curvecpr_chicago *chicago)
 
 void curvecpr_chicago_refresh_clock (struct curvecpr_chicago *chicago)
 {
-    chicago->clock = curvecpr_util_nanoseconds();
+    chicago->clock = chicago->cf.ops.get_nanoseconds(chicago->cf.priv);
 }
 
 void curvecpr_chicago_on_timeout (struct curvecpr_chicago *chicago)

libcurvecpr/lib/messager.c

@@ -52,11 +52,17 @@ void curvecpr_messager_new (struct curvecpr_messager *messager, const struct cur
     curvecpr_bytes_zero(messager, sizeof(struct curvecpr_messager));
 
     /* Initialize configuration. */
-    if (cf)
-        curvecpr_bytes_copy(&messager->cf, cf, sizeof(struct curvecpr_messager_cf));
+    curvecpr_bytes_copy(&messager->cf, cf, sizeof(struct curvecpr_messager_cf));
 
     /* Initialize congestion handling. */
-    curvecpr_chicago_new(&messager->chicago);
+    struct curvecpr_chicago_ops chicago_ops = {
+        .get_nanoseconds = cf->ops.get_nanoseconds
+    };
+    struct curvecpr_chicago_cf chicago_cf = {
+        .ops = chicago_ops,
+        .priv = cf->priv
+    };
+    curvecpr_chicago_new(&messager->chicago, &chicago_cf);
 
     /* If we're in client mode, initiate packets have a maximum size of 512 bytes.
        Otherwise, we're in server mode, and we can start at 1024. */

libcurvecpr/lib/util.c

@@ -34,7 +34,7 @@ long long curvecpr_util_random_mod_n (long long n)
 
 /* XXX: Y2036 problems; should upgrade to a 128-bit type for this. */
 /* XXX: Nanosecond granularity limits users to 1 terabyte per second. */
-long long curvecpr_util_nanoseconds (void)
+long long curvecpr_util_nanoseconds (void *priv)
 {
     /* XXX: host_get_clock_service() has been officially deprecated for years;
        this may need to be updated in the future. */

libcurvecpr/test/messager/test_new_configures_object.c

@@ -2,6 +2,7 @@
 #include <check_extras.h>
 
 #include <curvecpr/messager.h>
+#include <curvecpr/util.h>
 
 static char static_priv[] = "Hello!";
 
@@ -27,7 +28,8 @@ START_TEST (test_new_configures_object)
         .ops = {
             .sendmarkq_is_full = t_sendmarkq_is_full,
             .sendq_is_empty = t_sendq_is_empty,
-            .sendmarkq_head = t_sendmarkq_head
+            .sendmarkq_head = t_sendmarkq_head,
+            .get_nanoseconds = curvecpr_util_nanoseconds
         },
         .priv = static_priv
     };

libcurvecpr/test/messager/test_recv_requests_removal_from_sendmarkq.c

@@ -4,6 +4,7 @@
 #include <curvecpr/messager.h>
 
 #include <curvecpr/bytes.h>
+#include <curvecpr/util.h>
 
 static unsigned char t_sendmarkq_is_full (struct curvecpr_messager *messager)
 {
@@ -36,7 +37,8 @@ START_TEST (test_recv_requests_removal_from_sendmarkq)
             .sendmarkq_is_full = t_sendmarkq_is_full,
             .sendq_is_empty = t_sendq_is_empty,
             .sendmarkq_head = t_sendmarkq_head,
-            .sendmarkq_remove_range = t_sendmarkq_remove_range
+            .sendmarkq_remove_range = t_sendmarkq_remove_range,
+            .get_nanoseconds = curvecpr_util_nanoseconds
         }
     };
     unsigned char buf[1024] = { 0 };

libcurvecpr/test/messager/test_send_with_1_failure_moves_message_from_sendq.c

@@ -2,6 +2,7 @@
 #include <check_extras.h>
 
 #include <curvecpr/messager.h>
+#include <curvecpr/util.h>
 
 static struct curvecpr_block static_block = {
     .id = 0,
@@ -74,7 +75,8 @@ START_TEST (test_send_with_1_failure_moves_message_from_sendq)
             .sendmarkq_head = t_sendmarkq_head,
             .sendq_head = t_sendq_head,
             .send = t_send,
-            .sendq_move_to_sendmarkq = t_sendq_move_to_sendmarkq
+            .sendq_move_to_sendmarkq = t_sendq_move_to_sendmarkq,
+            .get_nanoseconds = curvecpr_util_nanoseconds
         },
         .priv = &send_counter
     };

libcurvecpr/test/messager/test_timeout_callback_fires.c

@@ -2,6 +2,7 @@
 #include <check_extras.h>
 
 #include <curvecpr/messager.h>
+#include <curvecpr/util.h>
 
 long long test_timeout = -1LL;
 
@@ -67,7 +68,8 @@ START_TEST (test_timeout_callback_fires)
             .sendq_head = t_sendq_head,
             .send = t_send,
             .sendq_move_to_sendmarkq = t_sendq_move_to_sendmarkq,
-            .put_next_timeout = t_put_next_timeout
+            .put_next_timeout = t_put_next_timeout,
+            .get_nanoseconds = curvecpr_util_nanoseconds
         }
     };