21 files changed, 376 insertions, 347 deletions

diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c
index 60cb50529..5caaec03c 100644
--- a/src/util/bandwidth.c
+++ b/src/util/bandwidth.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2010 Christian Grothoff (and other contributing authors)
+     (C) 2010, 2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -83,9 +83,9 @@ GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO
   b = ntohl (bps.value__);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Bandwidth has %llu bytes available until deadline in %s\n",
-       (unsigned long long) ((b * deadline.rel_value + 500LL) / 1000LL),
+       (unsigned long long) ((b * deadline.rel_value_us + 500000LL) / 1000000LL),
        GNUNET_STRINGS_relative_time_to_string (deadline, GNUNET_YES));
-  return (b * deadline.rel_value + 500LL) / 1000LL;
+  return (b * deadline.rel_value_us + 500000LL) / 1000000LL;
 }
 
 
@@ -105,16 +105,17 @@ GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps,
   struct GNUNET_TIME_Relative ret;
 
   b = ntohl (bps.value__);
-  if (b == 0)
+  if (0 == b)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Bandwidth suggests delay of infinity (zero bandwidth)\n");
     return GNUNET_TIME_UNIT_FOREVER_REL;
   }
-  ret.rel_value = size * 1000LL / b;
+  ret.rel_value_us = size * 1000LL * 1000LL / b;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Bandwidth suggests delay of %llu ms for %llu bytes of traffic\n",
-       (unsigned long long) ret.rel_value, (unsigned long long) size);
+       "Bandwidth suggests delay of %s for %llu bytes of traffic\n",
+       GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES),
+       (unsigned long long) size);
   return ret;
 }
 
@@ -158,16 +159,17 @@ static void
 update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
 {
   struct GNUNET_TIME_Absolute now;
+  struct GNUNET_TIME_Relative delta;
   uint64_t delta_time;
   uint64_t delta_avail;
   uint64_t left_bytes;
   uint64_t max_carry;
 
   now = GNUNET_TIME_absolute_get ();
-  delta_time = now.abs_value - av->last_update__.abs_value;
+  delta_time = now.abs_value_us - av->last_update__.abs_value_us;
   delta_avail =
       (delta_time * ((unsigned long long) av->available_bytes_per_s__) +
-       500LL) / 1000LL;
+       500000LL) / 1000000LL;
   av->consumption_since_last_update__ -= delta_avail;
   av->last_update__ = now;
   if (av->consumption_since_last_update__ < 0)
@@ -181,10 +183,11 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
     else
       av->consumption_since_last_update__ = -max_carry;
   }
+  delta.rel_value_us = delta_time;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p  updated, have %u Bps, last update was %llu ms ago\n", av,
+       "Tracker %p updated, have %u Bps, last update was %s ago\n", av,
        (unsigned int) av->available_bytes_per_s__,
-       (unsigned long long) delta_time);
+       GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
 }
 
 
@@ -251,22 +254,26 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
 
   if (av->available_bytes_per_s__ == 0)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, 
+         "Tracker %p delay is infinity\n", av);
     return GNUNET_TIME_UNIT_FOREVER_REL;
   }
   update_tracker (av);
   bytes_needed = size + av->consumption_since_last_update__;
   if (bytes_needed <= 0)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is zero\n", av,
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Tracker %p delay for %u bytes is zero\n", av,
          (unsigned int) size);
     return GNUNET_TIME_UNIT_ZERO;
   }
-  ret.rel_value =
-      (1000LL * bytes_needed) /
+  ret.rel_value_us =
+      (1000LL * 1000LL * bytes_needed) /
       (unsigned long long) av->available_bytes_per_s__;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is %llu ms\n",
-       av, (unsigned int) size, (unsigned long long) ret.rel_value);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "Tracker %p delay for %u bytes is %s\n",
+       av, (unsigned int) size, 
+       GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
   return ret;
 }
 
@@ -293,7 +300,7 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker * av)
                                                   (av->last_update__));
   used = av->consumption_since_last_update__;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p  available bandwidth is %lld bytes\n", av,
+       "Tracker %p available bandwidth is %lld bytes\n", av,
        (long long) (int64_t) (avail - used));
   return (int64_t) (avail - used);
 }
@@ -314,7 +321,8 @@ GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av,
   uint32_t new_limit;
 
   new_limit = ntohl (bytes_per_second_limit.value__);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p bandwidth changed to %u Bps\n", av,
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "Tracker %p bandwidth changed to %u Bps\n", av,
        (unsigned int) new_limit);
   update_tracker (av);
   old_limit = av->available_bytes_per_s__;
diff --git a/src/util/client.c b/src/util/client.c
index 811bb8e12..6c5e93ce4 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2006, 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2001-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -409,7 +409,7 @@ GNUNET_CLIENT_connect (const char *service_name,
                                   cfg))
     return NULL;
   connection = do_connect (service_name, cfg, 0);
-  client = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_Connection));
+  client = GNUNET_new (struct GNUNET_CLIENT_Connection);
   client->first_message = GNUNET_YES;
   client->attempts = 1;
   client->connection = connection;
@@ -536,7 +536,7 @@ receive_helper (void *cls, const void *buf, size_t available,
   check_complete (client);
   /* check for timeout */
   remaining = GNUNET_TIME_absolute_get_remaining (client->receive_timeout);
-  if (0 == remaining.rel_value)
+  if (0 == remaining.rel_value_us)
   {
     /* signal timeout! */
     if (NULL != client->receiver_handler)
@@ -1094,9 +1094,9 @@ client_notify (void *cls, size_t size, void *buf)
   if (NULL == buf)
   {
     delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
-    delay.rel_value /= 2;
+    delay.rel_value_us /= 2;
     if ((GNUNET_YES != th->auto_retry) || (0 == --th->attempts_left) ||
-        (delay.rel_value < 1)||
+        (delay.rel_value_us < 1)||
         (0 != (GNUNET_SCHEDULER_get_reason() & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/util/common_logging.c b/src/util/common_logging.c
index 5b355b2e1..8f1c8e876 100644
--- a/src/util/common_logging.c
+++ b/src/util/common_logging.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2006-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -26,17 +26,15 @@
  */
 #include "platform.h"
 #include "gnunet_common.h"
-#include "gnunet_crypto_lib.h"
-#include "gnunet_strings_lib.h"
-#include "gnunet_time_lib.h"
-
+#include "gnunet_util_lib.h"
 #include <regex.h>
 
+
 /**
  * After how many milliseconds do we always print
  * that "message X was repeated N times"?  Use 12h.
  */
-#define BULK_DELAY_THRESHOLD (12 * 60 * 60 * 1000)
+#define BULK_DELAY_THRESHOLD (12 * 60 * 60 * 1000LL * 1000LL)
 
 /**
  * After how many repetitions do we always print
@@ -800,7 +798,7 @@ flush_bulk (const char *datestr)
   char *last;
   const char *ft;
 
-  if ((last_bulk_time.abs_value == 0) || (last_bulk_repeat == 0))
+  if ((0 == last_bulk_time.abs_value_us) || (0 == last_bulk_repeat))
     return;
   rev = 0;
   last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
@@ -951,12 +949,13 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
     if (NULL != tmptr)
       (void) setup_log_file (tmptr);
     if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
-        (last_bulk_time.abs_value != 0) &&
+        (0 != last_bulk_time.abs_value_us) &&
         (0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
     {
       last_bulk_repeat++;
-      if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value >
-           BULK_DELAY_THRESHOLD) || (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
+      if ( (GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value_us >
+            BULK_DELAY_THRESHOLD) || 
+           (last_bulk_repeat > BULK_REPEAT_THRESHOLD) )
         flush_bulk (date);
       return;
     }
diff --git a/src/util/connection.c b/src/util/connection.c
index ea35b04e1..bdfcd1add 100644
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -33,11 +33,8 @@
 
 #include "platform.h"
 #include "gnunet_common.h"
-#include "gnunet_connection_lib.h"
-#include "gnunet_container_lib.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_resolver_service.h"
-#include "gnunet_scheduler_lib.h"
-#include "gnunet_server_lib.h"
 
 
 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
@@ -304,7 +301,7 @@ GNUNET_CONNECTION_create_from_existing (struct GNUNET_NETWORK_Handle *osSocket)
 {
   struct GNUNET_CONNECTION_Handle *connection;
 
-  connection = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
+  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
   connection->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
   connection->sock = osSocket;
@@ -362,7 +359,7 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
   if ((AF_INET6 == sa->sa_family) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))
   {
     /* convert to V4 address */
-    v4 = GNUNET_malloc (sizeof (struct sockaddr_in));
+    v4 = GNUNET_new (struct sockaddr_in);
     memset (v4, 0, sizeof (struct sockaddr_in));
     v4->sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
@@ -432,7 +429,7 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
     GNUNET_free (uaddr);
     return NULL;
   }
-  connection = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
+  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
   connection->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
   connection->addr = uaddr;
@@ -800,7 +797,7 @@ GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle
   struct GNUNET_CONNECTION_Handle *connection;
 
   GNUNET_assert (0 < strlen (hostname));        /* sanity check */
-  connection = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
+  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
   connection->cfg = cfg;
   connection->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
@@ -834,7 +831,7 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
   size_t slen;
 
   GNUNET_assert (0 < strlen (unixpath));        /* sanity check */
-  un = GNUNET_malloc (sizeof (struct sockaddr_un));
+  un = GNUNET_new (struct sockaddr_un);
   un->sun_family = AF_UNIX;
   slen = strlen (unixpath);
   if (slen >= sizeof (un->sun_path))
@@ -848,7 +845,7 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
 #if LINUX
   un->sun_path[0] = '\0';
 #endif
-  connection = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
+  connection = GNUNET_new (struct GNUNET_CONNECTION_Handle);
   connection->cfg = cfg;
   connection->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
@@ -1042,9 +1039,9 @@ receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Receive from `%s' encounters error: timeout (%p)\n",
+         "Receive from `%s' encounters error: timeout (%s, %p)\n",
          GNUNET_a2s (connection->addr, connection->addrlen),
-         GNUNET_TIME_absolute_get_duration (connection->receive_timeout).rel_value,
+         GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (connection->receive_timeout), GNUNET_YES),
          connection);
     signal_receive_timeout (connection);
     return;
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c
index 507ecf661..cab13ae57 100644
--- a/src/util/gnunet-service-resolver.c
+++ b/src/util/gnunet-service-resolver.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2007, 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2007-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -217,8 +217,8 @@ get_ip_as_string (struct GNUNET_SERVER_Client *client,
             (0 != memcmp (pos->ip, ip, ip_len))) )
   {
     next = pos->next;
-    if (GNUNET_TIME_absolute_get_duration (pos->last_request).rel_value <
-        60 * 60 * 1000)
+    if (GNUNET_TIME_absolute_get_duration (pos->last_request).rel_value_us <
+        60 * 60 * 1000 * 1000LL)
     {
       GNUNET_CONTAINER_DLL_remove (cache_head,
                                    cache_tail,
@@ -231,8 +231,8 @@ get_ip_as_string (struct GNUNET_SERVER_Client *client,
   if (pos != NULL)
   {
     pos->last_request = now;
-    if (GNUNET_TIME_absolute_get_duration (pos->last_request).rel_value <
-        60 * 60 * 1000)
+    if (GNUNET_TIME_absolute_get_duration (pos->last_request).rel_value_us <
+        60 * 60 * 1000 * 1000LL)
     {
       GNUNET_free_non_null (pos->addr);
       pos->addr = NULL;
diff --git a/src/util/load.c b/src/util/load.c
index 146e85095..06e284c4c 100644
--- a/src/util/load.c
+++ b/src/util/load.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2010 Christian Grothoff (and other contributing authors)
+     (C) 2010, 2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -24,7 +24,7 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
-#include "gnunet_load_lib.h"
+#include "gnunet_util_lib.h"
 
 
 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
@@ -87,18 +87,18 @@ internal_update (struct GNUNET_LOAD_Value *load)
   struct GNUNET_TIME_Relative delta;
   unsigned int n;
 
-  if (load->autodecline.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+  if (load->autodecline.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
     return;
   delta = GNUNET_TIME_absolute_get_duration (load->last_update);
-  if (delta.rel_value < load->autodecline.rel_value)
+  if (delta.rel_value_us < load->autodecline.rel_value_us)
     return;
-  if (load->autodecline.rel_value == 0)
+  if (0 == load->autodecline.rel_value_us)
   {
     load->runavg_delay = 0.0;
     load->load = 0;
     return;
   }
-  n = delta.rel_value / load->autodecline.rel_value;
+  n = delta.rel_value_us / load->autodecline.rel_value_us;
   if (n > 16)
   {
     load->runavg_delay = 0.0;
@@ -126,7 +126,7 @@ GNUNET_LOAD_value_init (struct GNUNET_TIME_Relative autodecline)
 {
   struct GNUNET_LOAD_Value *ret;
 
-  ret = GNUNET_malloc (sizeof (struct GNUNET_LOAD_Value));
+  ret = GNUNET_new (struct GNUNET_LOAD_Value);
   ret->autodecline = autodecline;
   ret->last_update = GNUNET_TIME_absolute_get ();
   return ret;
diff --git a/src/util/network.c b/src/util/network.c
index 7a51a8b67..8398b9fab 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -1332,7 +1332,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   }
 
   if ((nfds == 0) &&
-      (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+      (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
 #ifdef MINGW
       && handles == 0
 #endif
@@ -1345,25 +1345,26 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
          "select");
   }
 #ifndef MINGW
-  tv.tv_sec = timeout.rel_value / GNUNET_TIME_UNIT_SECONDS.rel_value;
+  tv.tv_sec = timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us;
   tv.tv_usec =
-      1000 * (timeout.rel_value -
-              (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value));
-  return select (nfds, (rfds != NULL) ? &rfds->sds : NULL,
-                 (wfds != NULL) ? &wfds->sds : NULL,
-                 (efds != NULL) ? &efds->sds : NULL,
-                 (timeout.rel_value ==
-                  GNUNET_TIME_UNIT_FOREVER_REL.rel_value) ? NULL : &tv);
+    (timeout.rel_value_us -
+     (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value_us));
+  return select (nfds, 
+                 (NULL != rfds) ? &rfds->sds : NULL,
+                 (NULL != wfds) ? &wfds->sds : NULL,
+                 (NULL != efds) ? &efds->sds : NULL,
+                 (timeout.rel_value_us ==
+                  GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) ? NULL : &tv);
 
 #else
 #define SAFE_FD_ISSET(fd, set)  (set != NULL && FD_ISSET(fd, set))
   /* calculate how long we need to wait in milliseconds */
-  if (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+  if (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
     ms_total = INFINITE;
   else
   {
-    ms_total = timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value;
-    if (timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value > 0xFFFFFFFFLL - 1)
+    ms_total = timeout.rel_value_us / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us;
+    if (timeout.rel_value_us / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us > 0xFFFFFFFFLL - 1)
     {
       GNUNET_break (0);
       ms_total = 0xFFFFFFFF - 1;
@@ -1376,7 +1377,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     return 0;
   }
 
-  if (select_thread == NULL)
+  if (NULL == select_thread)
   {
     SOCKET select_listening_socket = -1;
     struct sockaddr_in s_in;
@@ -1742,15 +1743,16 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   if (nfds > 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Adding the socket event to the array as %d\n", nhandles);
+         "Adding the socket event to the array as %d\n",
+         nhandles);
     handle_array[nhandles++] = select_finished_event;
-    if (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+    if (timeout.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
       sp.tv = NULL;
     else
     {
-      select_timeout.tv_sec = timeout.rel_value / GNUNET_TIME_UNIT_SECONDS.rel_value;
-      select_timeout.tv_usec = 1000 * (timeout.rel_value -
-          (select_timeout.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value));
+      select_timeout.tv_sec = timeout.rel_value_us / GNUNET_TIME_UNIT_SECONDS.rel_value_us;
+      select_timeout.tv_usec =(timeout.rel_value_us -
+          (select_timeout.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value_us));
       sp.tv = &select_timeout;
     }
     FD_SET (select_wakeup_socket, &aread);
diff --git a/src/util/perf_crypto_hash.c b/src/util/perf_crypto_hash.c
index 930e99844..affd4a2d5 100644
--- a/src/util/perf_crypto_hash.c
+++ b/src/util/perf_crypto_hash.c
@@ -53,9 +53,9 @@ main (int argc, char *argv[])
           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
                                                   GNUNET_YES));
   GAUGER ("UTIL", "Cryptographic hashing",
-          1024 * 64 * 1024 / (1 +
-                              GNUNET_TIME_absolute_get_duration
-                              (start).rel_value), "kb/s");
+          64 * 1024 / (1 +
+                       GNUNET_TIME_absolute_get_duration
+                       (start).rel_value_us / 1000LL), "kb/ms");
   return 0;
 }
 
diff --git a/src/util/perf_malloc.c b/src/util/perf_malloc.c
index 31f08dff0..f25529269 100644
--- a/src/util/perf_malloc.c
+++ b/src/util/perf_malloc.c
@@ -53,13 +53,13 @@ main (int argc, char *argv[])
 
   start = GNUNET_TIME_absolute_get ();
   kb = perfMalloc ();
-  printf ("Malloc perf took %llu ms\n",
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+  printf ("Malloc perf took %s\n",
+          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
+                                                  GNUNET_YES));
   GAUGER ("UTIL", "Allocation",
           kb / 1024 / (1 +
-                              GNUNET_TIME_absolute_get_duration
-                              (start).rel_value), "kb/s");
+                       GNUNET_TIME_absolute_get_duration
+                       (start).rel_value_us / 1000LL), "kb/ms");
   return 0;
 }
 
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index 7acc0f87f..9a2228da0 100644
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2011 Christian Grothoff (and other contributing authors)
+     (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -24,13 +24,9 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_os_lib.h"
-#include "gnunet_client_lib.h"
-#include "gnunet_container_lib.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_protocols.h"
 #include "gnunet_resolver_service.h"
-#include "gnunet_server_lib.h"
 #include "resolver.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "resolver-api", __VA_ARGS__)
@@ -703,8 +699,8 @@ reconnect ()
     }
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Will try to connect to DNS service in %llu ms\n",
-       (unsigned long long) backoff.rel_value);
+       "Will try to connect to DNS service in %s\n",
+       GNUNET_STRINGS_relative_time_to_string (backoff, GNUNET_YES));
   GNUNET_assert (NULL != resolver_cfg);
   r_task = GNUNET_SCHEDULER_add_delayed (backoff, &reconnect_task, NULL);
   backoff = GNUNET_TIME_STD_BACKOFF (backoff);
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 23f683808..5b90d7e4f 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -1,10 +1,10 @@
 /*
       This file is part of GNUnet
-      (C) 2009, 2011 Christian Grothoff (and other contributing authors)
+      (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
       GNUnet 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 2, or (at your
+      by the Free Software Foundation; either version 3, or (at your
       option) any later version.
 
       GNUnet is distributed in the hope that it will be useful, but
@@ -300,7 +300,7 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
   if (pos != NULL)
   {
     to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-    if (timeout->rel_value > to.rel_value)
+    if (timeout->rel_value_us > to.rel_value_us)
       *timeout = to;
     if (pos->reason != 0)
       *timeout = GNUNET_TIME_UNIT_ZERO;
@@ -308,10 +308,10 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
   pos = pending;
   while (pos != NULL)
   {
-    if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+    if (pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
     {
       to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-      if (timeout->rel_value > to.rel_value)
+      if (timeout->rel_value_us > to.rel_value_us)
         *timeout = to;
     }
     if (pos->read_fd != -1)
@@ -373,7 +373,7 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
   enum GNUNET_SCHEDULER_Reason reason;
 
   reason = task->reason;
-  if (now.abs_value >= task->timeout.abs_value)
+  if (now.abs_value_us >= task->timeout.abs_value_us)
     reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
       (((task->read_fd != -1) &&
@@ -433,7 +433,7 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs,
   while (pos != NULL)
   {
     next = pos->next;
-    if (now.abs_value >= pos->timeout.abs_value)
+    if (now.abs_value_us >= pos->timeout.abs_value_us)
       pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
     if (0 == pos->reason)
       break;
@@ -569,8 +569,8 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
     current_lifeness = pos->lifeness;
     active_task = pos;
 #if PROFILE_DELAYS
-    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
-        DELAY_THRESHOLD.rel_value)
+    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
+        DELAY_THRESHOLD.rel_value_us)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG, 
            "Task %llu took %s to be scheduled\n",
@@ -777,7 +777,7 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
       GNUNET_abort ();
       break;
     }
-    if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
+    if ((0 == ret) && (0 == timeout.rel_value_us) && (busy_wait_warning > 16))
     {
       LOG (GNUNET_ERROR_TYPE_WARNING, _("Looks like we're busy waiting...\n"));
       sleep (1);                /* mitigate */
@@ -1091,7 +1091,7 @@ GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
   prev = pending_timeout_last;
   if (prev != NULL)
   {
-    if (prev->timeout.abs_value > t->timeout.abs_value)
+    if (prev->timeout.abs_value_us > t->timeout.abs_value_us)
       prev = NULL;
     else
       pos = prev->next;         /* heuristic success! */
@@ -1102,8 +1102,8 @@ GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
     pos = pending_timeout;
   }
   while ((pos != NULL) &&
-         ((pos->timeout.abs_value <= t->timeout.abs_value) ||
-          (pos->reason != 0)))
+         ((pos->timeout.abs_value_us <= t->timeout.abs_value_us) ||
+          (0 != pos->reason)))
   {
     prev = pos;
     pos = pos->next;
diff --git a/src/util/server.c b/src/util/server.c
index b2264479a..05463e1cb 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -1032,8 +1032,8 @@ process_mst (struct GNUNET_SERVER_Client *client, int ret)
     if (GNUNET_OK == ret)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Server re-enters receive loop, timeout: %llu.\n",
-           client->idle_timeout.rel_value);
+           "Server re-enters receive loop, timeout: %s.\n",
+           GNUNET_STRINGS_relative_time_to_string (client->idle_timeout, GNUNET_YES));
       client->receive_pending = GNUNET_YES;
       GNUNET_CONNECTION_receive (client->connection,
                                  GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
@@ -1094,7 +1094,7 @@ process_incoming (void *cls, const void *buf, size_t available,
   if ((NULL == buf) && (0 == available) && (NULL == addr) && (0 == errCode) &&
       (GNUNET_YES != client->shutdown_now) && (NULL != server) &&
       (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
-      (end.abs_value > now.abs_value))
+      (end.abs_value_us > now.abs_value_us))
   {
     /* wait longer, timeout changed (i.e. due to us sending) */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/util/speedup.c b/src/util/speedup.c
index 6cb8a4e05..2482decea 100644
--- a/src/util/speedup.c
+++ b/src/util/speedup.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2006, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2011-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -24,8 +24,7 @@
  * @brief functions to speedup peer execution by manipulation system time
  */
 #include "platform.h"
-#include "gnunet_time_lib.h"
-#include "gnunet_scheduler_lib.h"
+#include "gnunet_util_lib.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
 
@@ -45,10 +44,11 @@ do_speedup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   speedup_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     return;
-  current_offset += delta.rel_value;
+  current_offset += delta.rel_value_us;
   GNUNET_TIME_set_offset (current_offset);
   LOG (GNUNET_ERROR_TYPE_DEBUG, 
-       "Speeding up execution time by %llu ms\n", delta.rel_value);
+       "Speeding up execution time by %s\n", 
+       GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_NO));
   speedup_task = GNUNET_SCHEDULER_add_delayed (interval, &do_speedup, NULL);
 }
 
@@ -67,15 +67,18 @@ GNUNET_SPEEDUP_start_ (const struct GNUNET_CONFIGURATION_Handle *cfg)
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, "testing", "SPEEDUP_DELTA", &delta))
     return GNUNET_SYSERR;
 
-  if ((0 == interval.rel_value) || (0 == delta.rel_value))
+  if ((0 == interval.rel_value_us) || (0 == delta.rel_value_us))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Speed up disabled\n");
     return GNUNET_OK;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Speed up execution time %llu ms every %llu ms\n",
-       delta.rel_value, interval.rel_value);
+       "Speed up execution by %s\n",
+       GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_NO));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Speed up executed every %s\n",
+       GNUNET_STRINGS_relative_time_to_string (interval, GNUNET_NO));
   speedup_task = GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO, &do_speedup, NULL);
   return GNUNET_OK;
 }
@@ -92,7 +95,8 @@ GNUNET_SPEEDUP_stop_ ( )
     GNUNET_SCHEDULER_cancel (speedup_task);
     speedup_task = GNUNET_SCHEDULER_NO_TASK;
   }
-  if ((0 != interval.rel_value) && (0 != delta.rel_value))
+  if ( (0 != interval.rel_value_us) && 
+       (0 != delta.rel_value_us) )
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Stopped execution speed up\n");
 }
diff --git a/src/util/strings.c b/src/util/strings.c
index 8bbc904bc..da02a9c4f 100644
--- a/src/util/strings.c
+++ b/src/util/strings.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2005, 2006 Christian Grothoff (and other contributing authors)
+     (C) 2005-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -300,18 +300,19 @@ GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time,
 {
   static const struct ConversionTable table[] =
   {
-    { "ms", 1},
-    { "s", 1000},
-    { "\"", 1000},
-    { "m", 60 * 1000},
-    { "min", 60 * 1000},
-    { "minutes", 60 * 1000},
-    { "'", 60 * 1000},
-    { "h", 60 * 60 * 1000},
-    { "d", 24 * 60 * 60 * 1000},
-    { "day", 24 * 60 * 60 * 1000},
-    { "days", 24 * 60 * 60 * 1000},
-    { "a", 31536000000LL /* year */ },
+    { "us", 1},
+    { "ms", 1000 },
+    { "s", 1000 * 1000LL },
+    { "\"", 1000  * 1000LL },
+    { "m", 60 * 1000  * 1000LL},
+    { "min", 60 * 1000  * 1000LL},
+    { "minutes", 60 * 1000  * 1000LL},
+    { "'", 60 * 1000  * 1000LL},
+    { "h", 60 * 60 * 1000  * 1000LL},
+    { "d", 24 * 60 * 60 * 1000LL * 1000LL},
+    { "day", 24 * 60 * 60 * 1000LL * 1000LL},
+    { "days", 24 * 60 * 60 * 1000LL * 1000LL},
+    { "a", 31536000000000LL /* year */ },
     { NULL, 0}
   };
   int ret;
@@ -325,7 +326,7 @@ GNUNET_STRINGS_fancy_time_to_relative (const char *fancy_time,
   ret = convert_with_table (fancy_time,
                             table,
                             &val);
-  rtime->rel_value = (uint64_t) val;
+  rtime->rel_value_us = (uint64_t) val;
   return ret;
 }
 
@@ -363,9 +364,9 @@ GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time,
        (NULL == strptime (fancy_time, "%Y", &tv)) )
     return GNUNET_SYSERR;
   t = mktime (&tv);
-  atime->abs_value = (uint64_t) ((uint64_t) t * 1000LL);
+  atime->abs_value_us = (uint64_t) ((uint64_t) t * 1000LL * 1000LL);
 #if LINUX
-  atime->abs_value -= 1000LL * timezone;
+  atime->abs_value_us -= 1000LL * 1000LL * timezone;
 #endif
   return GNUNET_OK;
 }
@@ -380,7 +381,10 @@ GNUNET_STRINGS_fancy_time_to_absolute (const char *fancy_time,
  *  string is returned.
  */
 char *
-GNUNET_STRINGS_conv (const char *input, size_t len, const char *input_charset, const char *output_charset)
+GNUNET_STRINGS_conv (const char *input,
+                     size_t len, 
+                     const char *input_charset, 
+                     const char *output_charset)
 {
   char *ret;
   uint8_t *u8_string;
@@ -634,41 +638,48 @@ GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta,
                                         int do_round)
 {
   static char buf[128];
-  const char *unit = _( /* time unit */ "ms");
-  uint64_t dval = delta.rel_value;
+  const char *unit = _( /* time unit */ "µs");
+  uint64_t dval = delta.rel_value_us;
 
-  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value == delta.rel_value)
+  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == delta.rel_value_us)
     return _("forever");
-  if (0 == delta.rel_value)
+  if (0 == delta.rel_value_us)
     return _("0 ms");
   if ( ( (GNUNET_YES == do_round) && 
          (dval > 5 * 1000) ) || 
        (0 == (dval % 1000) ))
   {
     dval = dval / 1000;
-    unit = _( /* time unit */ "s");
-    if ( ( (GNUNET_YES == do_round) &&
-           (dval > 5 * 60) ) ||
-         (0 == (dval % 60) ) )
+    unit = _( /* time unit */ "ms");
+    if ( ( (GNUNET_YES == do_round) && 
+           (dval > 5 * 1000) ) || 
+         (0 == (dval % 1000) ))
     {
-      dval = dval / 60;
-      unit = _( /* time unit */ "m");
+      dval = dval / 1000;
+      unit = _( /* time unit */ "s");
       if ( ( (GNUNET_YES == do_round) &&
-             (dval > 5 * 60) ) || 
-           (0 == (dval % 60) ))
+             (dval > 5 * 60) ) ||
+           (0 == (dval % 60) ) )
       {
-        dval = dval / 60;
-        unit = _( /* time unit */ "h");
-        if ( ( (GNUNET_YES == do_round) &&
-               (dval > 5 * 24) ) ||
-             (0 == (dval % 24)) )
+        dval = dval / 60;
+        unit = _( /* time unit */ "m");
+        if ( ( (GNUNET_YES == do_round) &&
+               (dval > 5 * 60) ) || 
+             (0 == (dval % 60) ))
         {
-          dval = dval / 24;
-          if (1 == dval)
-            unit = _( /* time unit */ "day");
-          else
-            unit = _( /* time unit */ "days");
-        }
+          dval = dval / 60;
+          unit = _( /* time unit */ "h");
+          if ( ( (GNUNET_YES == do_round) &&
+                 (dval > 5 * 24) ) ||
+               (0 == (dval % 24)) )
+          {
+            dval = dval / 24;
+            if (1 == dval)
+              unit = _( /* time unit */ "day");
+            else
+              unit = _( /* time unit */ "days");
+          }
+        }
       }
     }
   }
@@ -693,9 +704,9 @@ GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t)
   time_t tt;
   struct tm *tp;
 
-  if (t.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+  if (t.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
     return _("end of time");
-  tt = t.abs_value / 1000;
+  tt = t.abs_value_us / 1000LL / 1000LL;
   tp = gmtime (&tt);
   strftime (buf, sizeof (buf), "%a %b %d %H:%M:%S %Y", tp);
   return buf;
diff --git a/src/util/test_common_logging_dummy.c b/src/util/test_common_logging_dummy.c
index a1f479976..a360d5dee 100644
--- a/src/util/test_common_logging_dummy.c
+++ b/src/util/test_common_logging_dummy.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2008 Christian Grothoff (and other contributing authors)
+     (C) 2008-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -59,7 +59,7 @@ expensive_func ()
   GNUNET_log (kind, "L%s %d\n", lvl, expensive_func());\
   t2 = GNUNET_TIME_absolute_get ();\
   printf ("1%s %llu\n", lvl,\
-          (unsigned long long) GNUNET_TIME_absolute_get_difference (t1, t2).rel_value); \
+          (unsigned long long) GNUNET_TIME_absolute_get_difference (t1, t2).rel_value_us); \
 }
 
 #define pr2(kind,lvl) {\
@@ -68,7 +68,7 @@ expensive_func ()
   GNUNET_log (kind, "L%s %d\n", lvl, expensive_func());\
   t2 = GNUNET_TIME_absolute_get ();\
   printf ("2%s %llu\n", lvl,\
-          (unsigned long long) GNUNET_TIME_absolute_get_difference (t1, t2).rel_value); \
+          (unsigned long long) GNUNET_TIME_absolute_get_difference (t1, t2).rel_value_us); \
 }
 
 int
diff --git a/src/util/test_crypto_ecc.c b/src/util/test_crypto_ecc.c
index 00d264e0f..bb5fb002f 100644
--- a/src/util/test_crypto_ecc.c
+++ b/src/util/test_crypto_ecc.c
@@ -166,9 +166,9 @@ testSignPerformance ()
       continue;
     }
   }
-  printf ("%d ECC sign operations %llu ms\n", ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+  printf ("%d ECC sign operations %s\n", ITER,
+          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
+                                                  GNUNET_YES));
   return ok;
 }
 #endif
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
index 132066979..ce96213c7 100644
--- a/src/util/test_scheduler_delay.c
+++ b/src/util/test_scheduler_delay.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2003, 2004, 2006 Christian Grothoff (and other contributing authors)
+     (C) 2001-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -20,13 +20,11 @@
 /**
  * @file util/test_scheduler_delay.c
  * @brief testcase for delay of scheduler, measures how
- *  precise the timers are.  Expect values between 10 and 20 ms on
+ *  precise the timers are.  Expect values between 0.2 and 2 ms on
  *  modern machines.
  */
 #include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_scheduler_lib.h"
-#include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"
 
 static struct GNUNET_TIME_Absolute target;
 
@@ -36,7 +34,8 @@ static unsigned long long cumDelta;
 
 #define INCR 47
 
-#define MAXV 1500
+#define MAXV 5000
+
 
 /**
  * Signature of the main function of a task.
@@ -45,18 +44,19 @@ static unsigned long long cumDelta;
  * @param tc context
  */
 static void
-test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+test_task (void *cls,
+           const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TIME_Absolute now;
 
   now = GNUNET_TIME_absolute_get ();
-  if (now.abs_value > target.abs_value)
-    cumDelta += (now.abs_value - target.abs_value);
+  if (now.abs_value_us > target.abs_value_us)
+    cumDelta += (now.abs_value_us - target.abs_value_us);
   else
-    cumDelta += (target.abs_value - now.abs_value);
+    cumDelta += (target.abs_value_us - now.abs_value_us);
   target =
       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply
-                                        (GNUNET_TIME_UNIT_MILLISECONDS, i));
+                                        (GNUNET_TIME_UNIT_MICROSECONDS, i));
   FPRINTF (stderr, "%s",  ".");
   if (i > MAXV)
   {
@@ -64,7 +64,7 @@ test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   }
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_MILLISECONDS, i), &test_task,
+                                (GNUNET_TIME_UNIT_MICROSECONDS, i), &test_task,
                                 NULL);
   i += INCR;
 }
@@ -76,13 +76,14 @@ main (int argc, char *argv[])
   GNUNET_log_setup ("test-scheduler-delay", "WARNING", NULL);
   target = GNUNET_TIME_absolute_get ();
   GNUNET_SCHEDULER_run (&test_task, NULL);
-  FPRINTF (stdout, "Sleep precision: %llu ms. ",
-           cumDelta / 1000 / (MAXV / INCR));
-  if (cumDelta <= 10 * MAXV / INCR)
+  FPRINTF (stdout, 
+           "Sleep precision: %llu microseconds (average delta). ",
+           cumDelta / (MAXV / INCR));
+  if (cumDelta <= 500 * MAXV / INCR)
     FPRINTF (stdout, "%s",  "Timer precision is excellent.\n");
-  else if (cumDelta <= 50 * MAXV / INCR)        /* 50 ms average deviation */
+  else if (cumDelta <= 5000 * MAXV / INCR)        /* 5 ms average deviation */
     FPRINTF (stdout, "%s",  "Timer precision is good.\n");
-  else if (cumDelta > 250 * MAXV / INCR)
+  else if (cumDelta > 25000 * MAXV / INCR)
     FPRINTF (stdout, "%s",  "Timer precision is awful.\n");
   else
     FPRINTF (stdout, "%s",  "Timer precision is acceptable.\n");
diff --git a/src/util/test_speedup.c b/src/util/test_speedup.c
index 03cffbd54..a2e6bb29c 100644
--- a/src/util/test_speedup.c
+++ b/src/util/test_speedup.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2003, 2004, 2006, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2011-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -22,10 +22,7 @@
  * @brief testcase for speedup.c
  */
 #include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_program_lib.h"
-#include "gnunet_time_lib.h"
-#include "gnunet_strings_lib.h"
+#include "gnunet_util_lib.h"
 
 /**
  * Start time of the testcase
@@ -100,19 +97,23 @@ main (int argc, char *argv[])
                       "nohelp", options, &check, NULL);
 
   end_real = time (NULL);
-  delta = GNUNET_TIME_absolute_get_difference(start, end);
+  delta = GNUNET_TIME_absolute_get_difference (start, end);
 
-  if (delta.rel_value >  ((end_real - start_real) * 1500LL))
+  if (delta.rel_value_us >  ((end_real - start_real) * 1500LL * 1000LL))
   {
-    GNUNET_log  (GNUNET_ERROR_TYPE_DEBUG, "Execution time in GNUnet time: %llu ms\n", 
-                 (unsigned long long) delta.rel_value);
-    GNUNET_log  (GNUNET_ERROR_TYPE_DEBUG, "Execution time in system time: %llu ms\n", 
+    GNUNET_log  (GNUNET_ERROR_TYPE_DEBUG, 
+                 "Execution time in GNUnet time: %s\n", 
+                 GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
+    GNUNET_log  (GNUNET_ERROR_TYPE_DEBUG,
+                 "Execution time in system time: %llu ms\n", 
                  (unsigned long long) ((end_real - start_real) * 1000LL));
     return 0;
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Execution time in GNUnet time: %llu ms\n", 
-              (unsigned long long) delta.rel_value);
-  GNUNET_log  (GNUNET_ERROR_TYPE_ERROR, "Execution time in system time: %llu ms\n", 
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
+              "Execution time in GNUnet time: %s\n", 
+              GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
+  GNUNET_log  (GNUNET_ERROR_TYPE_ERROR, 
+               "Execution time in system time: %llu ms\n", 
                (unsigned long long) ((end_real - start_real) * 1000LL));
   return 1;
 }
diff --git a/src/util/test_strings.c b/src/util/test_strings.c
index e5247ad91..e0c3cfebf 100644
--- a/src/util/test_strings.c
+++ b/src/util/test_strings.c
@@ -87,7 +87,7 @@ main (int argc, char *argv[])
   WANT ("btx", b);
   if (0 != GNUNET_STRINGS_buffer_tokenize (buf, 2, 2, &r, &b))
     return 1;
-  at.abs_value = 5000;
+  at.abs_value_us = 5000000;
   bc = GNUNET_STRINGS_absolute_time_to_string (at);
   /* bc should be something like "Wed Dec 31 17:00:05 1969"
    * where the details of the day and hour depend on the timezone;
@@ -105,7 +105,7 @@ main (int argc, char *argv[])
   bc = GNUNET_STRINGS_absolute_time_to_string (at);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_STRINGS_fancy_time_to_absolute (bc, &atx));
-  GNUNET_assert (atx.abs_value == at.abs_value);
+  GNUNET_assert (atx.abs_value_us == at.abs_value_us);
 
   GNUNET_log_skip (2, GNUNET_NO);
   b = GNUNET_STRINGS_to_utf8 ("TEST", 4, "unknown");
@@ -116,7 +116,7 @@ main (int argc, char *argv[])
       GNUNET_STRINGS_fancy_time_to_relative ("15m", &rt));
   GNUNET_assert (GNUNET_OK ==
       GNUNET_STRINGS_fancy_time_to_relative ("15 m", &rtx));
-  GNUNET_assert (rt.rel_value == rtx.rel_value);
+  GNUNET_assert (rt.rel_value_us == rtx.rel_value_us);
 
   return 0;
 }
diff --git a/src/util/test_time.c b/src/util/test_time.c
index cd1175416..467336e0a 100644
--- a/src/util/test_time.c
+++ b/src/util/test_time.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2003, 2004, 2006, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2001-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -22,8 +22,7 @@
  * @brief testcase for time.c
  */
 #include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"
 
 
 int
@@ -46,186 +45,186 @@ main (int argc, char *argv[])
   forever = GNUNET_TIME_UNIT_FOREVER_ABS;
   relForever = GNUNET_TIME_UNIT_FOREVER_REL;
   relUnit = GNUNET_TIME_UNIT_MILLISECONDS;
-  zero.abs_value = 0;
+  zero.abs_value_us = 0;
 
   last = now = GNUNET_TIME_absolute_get ();
-  while (now.abs_value == last.abs_value)
+  while (now.abs_value_us == last.abs_value_us)
     now = GNUNET_TIME_absolute_get ();
-  GNUNET_assert (now.abs_value > last.abs_value);
+  GNUNET_assert (now.abs_value_us > last.abs_value_us);
 
   /* test overflow checking in multiply */
-  rel = GNUNET_TIME_UNIT_SECONDS;
+  rel = GNUNET_TIME_UNIT_MILLISECONDS;
   GNUNET_log_skip (1, GNUNET_NO);
   for (i = 0; i < 55; i++)
     rel = GNUNET_TIME_relative_multiply (rel, 2);
   GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (rel.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value);
+  GNUNET_assert (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
   /*check zero */
-  rel.rel_value = (UINT64_MAX) - 1024;
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value ==
-                 GNUNET_TIME_relative_multiply (rel, 0).rel_value);
+  rel.rel_value_us = (UINT64_MAX) - 1024;
+  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
+                 GNUNET_TIME_relative_multiply (rel, 0).rel_value_us);
 
   /* test infinity-check for relative to absolute */
   GNUNET_log_skip (1, GNUNET_NO);
   last = GNUNET_TIME_relative_to_absolute (rel);
-  GNUNET_assert (last.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value);
+  GNUNET_assert (last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
   GNUNET_log_skip (0, GNUNET_YES);
 
   /*check relative to absolute */
-  rel.rel_value = 0;
-  GNUNET_assert (GNUNET_TIME_absolute_get ().abs_value ==
-                 GNUNET_TIME_relative_to_absolute (rel).abs_value);
+  rel.rel_value_us = 0;
+  GNUNET_assert (GNUNET_TIME_absolute_get ().abs_value_us ==
+                 GNUNET_TIME_relative_to_absolute (rel).abs_value_us);
   /*check forever */
-  rel.rel_value = UINT64_MAX;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value ==
-                 GNUNET_TIME_relative_to_absolute (rel).abs_value);
+  rel.rel_value_us = UINT64_MAX;
+  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us ==
+                 GNUNET_TIME_relative_to_absolute (rel).abs_value_us);
   /* check overflow for r2a */
-  rel.rel_value = (UINT64_MAX) - 1024;
+  rel.rel_value_us = (UINT64_MAX) - 1024;
   GNUNET_log_skip (1, GNUNET_NO);
   last = GNUNET_TIME_relative_to_absolute (rel);
   GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (last.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value);
+  GNUNET_assert (last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
 
   /* check overflow for relative add */
   GNUNET_log_skip (1, GNUNET_NO);
   rel = GNUNET_TIME_relative_add (rel, rel);
   GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (rel.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value);
+  GNUNET_assert (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
 
   GNUNET_log_skip (1, GNUNET_NO);
   rel = GNUNET_TIME_relative_add (relForever, relForever);
   GNUNET_log_skip (0, GNUNET_NO);
-  GNUNET_assert (rel.rel_value == relForever.rel_value);
+  GNUNET_assert (rel.rel_value_us == relForever.rel_value_us);
 
   GNUNET_log_skip (1, GNUNET_NO);
   rel = GNUNET_TIME_relative_add (relUnit, relUnit);
-  GNUNET_assert (rel.rel_value == 2 * relUnit.rel_value);
+  GNUNET_assert (rel.rel_value_us == 2 * relUnit.rel_value_us);
 
   /* check relation check in get_duration */
-  future.abs_value = now.abs_value + 1000000;
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).rel_value ==
+  future.abs_value_us = now.abs_value_us + 1000000;
+  GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).rel_value_us ==
                  1000000);
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).rel_value ==
+  GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).rel_value_us ==
                  0);
 
-  GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).rel_value
-                 == forever.abs_value);
+  GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).rel_value_us
+                 == forever.abs_value_us);
 
-  past.abs_value = now.abs_value - 1000000;
+  past.abs_value_us = now.abs_value_us - 1000000;
   rel = GNUNET_TIME_absolute_get_duration (future);
-  GNUNET_assert (rel.rel_value == 0);
+  GNUNET_assert (rel.rel_value_us == 0);
   rel = GNUNET_TIME_absolute_get_duration (past);
-  GNUNET_assert (rel.rel_value >= 1000000);
+  GNUNET_assert (rel.rel_value_us >= 1000000);
 
   /* check get remaining */
   rel = GNUNET_TIME_absolute_get_remaining (now);
-  GNUNET_assert (rel.rel_value == 0);
+  GNUNET_assert (rel.rel_value_us == 0);
   rel = GNUNET_TIME_absolute_get_remaining (past);
-  GNUNET_assert (rel.rel_value == 0);
+  GNUNET_assert (rel.rel_value_us == 0);
   rel = GNUNET_TIME_absolute_get_remaining (future);
-  GNUNET_assert (rel.rel_value > 0);
-  GNUNET_assert (rel.rel_value <= 1000000);
+  GNUNET_assert (rel.rel_value_us > 0);
+  GNUNET_assert (rel.rel_value_us <= 1000000);
   forever = GNUNET_TIME_UNIT_FOREVER_ABS;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
-                 GNUNET_TIME_absolute_get_remaining (forever).rel_value);
+  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                 GNUNET_TIME_absolute_get_remaining (forever).rel_value_us);
 
   /* check endianess */
   reln = GNUNET_TIME_relative_hton (rel);
-  GNUNET_assert (rel.rel_value == GNUNET_TIME_relative_ntoh (reln).rel_value);
+  GNUNET_assert (rel.rel_value_us == GNUNET_TIME_relative_ntoh (reln).rel_value_us);
   nown = GNUNET_TIME_absolute_hton (now);
-  GNUNET_assert (now.abs_value == GNUNET_TIME_absolute_ntoh (nown).abs_value);
+  GNUNET_assert (now.abs_value_us == GNUNET_TIME_absolute_ntoh (nown).abs_value_us);
 
   /* check absolute addition */
   future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_SECONDS);
-  GNUNET_assert (future.abs_value == now.abs_value + 1000);
+  GNUNET_assert (future.abs_value_us == now.abs_value_us + 1000 * 1000LL);
 
   future = GNUNET_TIME_absolute_add (forever, GNUNET_TIME_UNIT_ZERO);
-  GNUNET_assert (future.abs_value == forever.abs_value);
+  GNUNET_assert (future.abs_value_us == forever.abs_value_us);
 
-  rel.rel_value = (UINT64_MAX) - 1024;
-  now.abs_value = rel.rel_value;
+  rel.rel_value_us = (UINT64_MAX) - 1024;
+  now.abs_value_us = rel.rel_value_us;
   future = GNUNET_TIME_absolute_add (now, rel);
-  GNUNET_assert (future.abs_value == forever.abs_value);
+  GNUNET_assert (future.abs_value_us == forever.abs_value_us);
 
   /* check zero */
   future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_ZERO);
-  GNUNET_assert (future.abs_value == now.abs_value);
+  GNUNET_assert (future.abs_value_us == now.abs_value_us);
 
-  GNUNET_assert (forever.abs_value ==
+  GNUNET_assert (forever.abs_value_us ==
                  GNUNET_TIME_absolute_subtract (forever,
-                                                GNUNET_TIME_UNIT_MINUTES).abs_value);
+                                                GNUNET_TIME_UNIT_MINUTES).abs_value_us);
   /*check absolute subtract */
-  now.abs_value = 50000;
-  rel.rel_value = 100000;
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value ==
-                 (GNUNET_TIME_absolute_subtract (now, rel)).abs_value);
-  rel.rel_value = 10000;
-  GNUNET_assert (40000 == (GNUNET_TIME_absolute_subtract (now, rel)).abs_value);
+  now.abs_value_us = 50000;
+  rel.rel_value_us = 100000;
+  GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
+                 (GNUNET_TIME_absolute_subtract (now, rel)).abs_value_us);
+  rel.rel_value_us = 10000;
+  GNUNET_assert (40000 == (GNUNET_TIME_absolute_subtract (now, rel)).abs_value_us);
 
   /*check relative divide */
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
-                 (GNUNET_TIME_relative_divide (rel, 0)).rel_value);
+  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                 (GNUNET_TIME_relative_divide (rel, 0)).rel_value_us);
 
   rel = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
-                 (GNUNET_TIME_relative_divide (rel, 2)).rel_value);
+  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                 (GNUNET_TIME_relative_divide (rel, 2)).rel_value_us);
 
   rel = GNUNET_TIME_relative_divide (relUnit, 2);
-  GNUNET_assert (rel.rel_value == relUnit.rel_value / 2);
+  GNUNET_assert (rel.rel_value_us == relUnit.rel_value_us / 2);
 
 
   /* check Return absolute time of 0ms */
   zero = GNUNET_TIME_UNIT_ZERO_ABS;
 
   /* check GNUNET_TIME_calculate_eta */
-  last.abs_value = GNUNET_TIME_absolute_get ().abs_value - 1024;
+  last.abs_value_us = GNUNET_TIME_absolute_get ().abs_value_us - 1024;
   forever = GNUNET_TIME_UNIT_FOREVER_ABS;
-  forever.abs_value = forever.abs_value - 1024;
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value ==
-                 GNUNET_TIME_calculate_eta (forever, 50000, 100000).rel_value);
+  forever.abs_value_us = forever.abs_value_us - 1024;
+  GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
+                 GNUNET_TIME_calculate_eta (forever, 50000, 100000).rel_value_us);
   /* check zero */
   GNUNET_log_skip (1, GNUNET_NO);
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value ==
-                 (GNUNET_TIME_calculate_eta (last, 60000, 50000)).rel_value);
+  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
+                 (GNUNET_TIME_calculate_eta (last, 60000, 50000)).rel_value_us);
   GNUNET_log_skip (0, GNUNET_YES);
   /*check forever */
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
-                 (GNUNET_TIME_calculate_eta (last, 0, 50000)).rel_value);
+  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                 (GNUNET_TIME_calculate_eta (last, 0, 50000)).rel_value_us);
 
   /*check relative subtract */
   now = GNUNET_TIME_absolute_get ();
-  rel.rel_value = now.abs_value;
-  relForever.rel_value = rel.rel_value + 1024;
+  rel.rel_value_us = now.abs_value_us;
+  relForever.rel_value_us = rel.rel_value_us + 1024;
   GNUNET_assert (1024 ==
-                 GNUNET_TIME_relative_subtract (relForever, rel).rel_value);
+                 GNUNET_TIME_relative_subtract (relForever, rel).rel_value_us);
   /*check zero */
-  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value ==
-                 GNUNET_TIME_relative_subtract (rel, relForever).rel_value);
+  GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
+                 GNUNET_TIME_relative_subtract (rel, relForever).rel_value_us);
   /*check forever */
-  rel.rel_value = UINT64_MAX;
-  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
-                 GNUNET_TIME_relative_subtract (rel, relForever).rel_value);
+  rel.rel_value_us = UINT64_MAX;
+  GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
+                 GNUNET_TIME_relative_subtract (rel, relForever).rel_value_us);
 
   /*check GNUNET_TIME_relative_min */
   now = GNUNET_TIME_absolute_get ();
-  rel.rel_value = now.abs_value;
-  relForever.rel_value = rel.rel_value - 1024;
-  GNUNET_assert (relForever.rel_value ==
-                 GNUNET_TIME_relative_min (rel, relForever).rel_value);
+  rel.rel_value_us = now.abs_value_us;
+  relForever.rel_value_us = rel.rel_value_us - 1024;
+  GNUNET_assert (relForever.rel_value_us ==
+                 GNUNET_TIME_relative_min (rel, relForever).rel_value_us);
 
   /*check GNUNET_TIME_relative_max */
-  GNUNET_assert (rel.rel_value ==
-                 GNUNET_TIME_relative_max (rel, relForever).rel_value);
+  GNUNET_assert (rel.rel_value_us ==
+                 GNUNET_TIME_relative_max (rel, relForever).rel_value_us);
 
   /*check GNUNET_TIME_absolute_min */
   now = GNUNET_TIME_absolute_get ();
-  last.abs_value = now.abs_value - 1024;
-  GNUNET_assert (last.abs_value ==
-                 GNUNET_TIME_absolute_min (now, last).abs_value);
+  last.abs_value_us = now.abs_value_us - 1024;
+  GNUNET_assert (last.abs_value_us ==
+                 GNUNET_TIME_absolute_min (now, last).abs_value_us);
 
   /*check  GNUNET_TIME_absolute_max */
-  GNUNET_assert (now.abs_value ==
-                 GNUNET_TIME_absolute_max (now, last).abs_value);
+  GNUNET_assert (now.abs_value_us ==
+                 GNUNET_TIME_absolute_max (now, last).abs_value_us);
 
   return 0;
 }
diff --git a/src/util/time.c b/src/util/time.c
index 825b7f8ca..5e9a01b09 100644
--- a/src/util/time.c
+++ b/src/util/time.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2006, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2001-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet 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 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -70,9 +70,9 @@ GNUNET_TIME_absolute_get ()
   struct timeval tv;
 
   GETTIMEOFDAY (&tv, NULL);
-  ret.abs_value =
-      (uint64_t) (((uint64_t) tv.tv_sec * 1000LL) +
-                  ((uint64_t) tv.tv_usec / 1000LL)) + timestamp_offset;
+  ret.abs_value_us =
+      (uint64_t) (((uint64_t) tv.tv_sec * 1000LL * 1000LL) +
+                  ((uint64_t) tv.tv_usec)) + timestamp_offset;
   return ret;
 }
 
@@ -102,7 +102,7 @@ GNUNET_TIME_absolute_get_zero_ ()
 
 
 /**
- * Return relative time of 1ms.
+ * Return relative time of 1us.
  */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_unit_ ()
@@ -113,12 +113,23 @@ GNUNET_TIME_relative_get_unit_ ()
 
 
 /**
+ * Return relative time of 1ms.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_millisecond_ ()
+{
+  static struct GNUNET_TIME_Relative one = { 1000 };
+  return one;
+}
+
+
+/**
  * Return relative time of 1s.
  */
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_second_ ()
 {
-  static struct GNUNET_TIME_Relative one = { 1000 };
+  static struct GNUNET_TIME_Relative one = { 1000 * 1000LL };
   return one;
 }
 
@@ -129,7 +140,7 @@ GNUNET_TIME_relative_get_second_ ()
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_minute_ ()
 {
-  static struct GNUNET_TIME_Relative one = { 60 * 1000 };
+  static struct GNUNET_TIME_Relative one = { 60 * 1000 * 1000LL };
   return one;
 }
 
@@ -140,7 +151,7 @@ GNUNET_TIME_relative_get_minute_ ()
 struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_get_hour_ ()
 {
-  static struct GNUNET_TIME_Relative one = { 60 * 60 * 1000 };
+  static struct GNUNET_TIME_Relative one = { 60 * 60 * 1000 * 1000LL };
   return one;
 }
 
@@ -176,16 +187,16 @@ GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
 {
   struct GNUNET_TIME_Absolute ret;
 
-  if (rel.rel_value == UINT64_MAX)
+  if (rel.rel_value_us == UINT64_MAX)
     return GNUNET_TIME_UNIT_FOREVER_ABS;
   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
-  if (rel.rel_value + now.abs_value < rel.rel_value)
+  if (rel.rel_value_us + now.abs_value_us < rel.rel_value_us)
   {
     GNUNET_break (0);           /* overflow... */
     return GNUNET_TIME_UNIT_FOREVER_ABS;
   }
-  ret.abs_value = rel.rel_value + now.abs_value;
+  ret.abs_value_us = rel.rel_value_us + now.abs_value_us;
   return ret;
 }
 
@@ -201,7 +212,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_min (struct GNUNET_TIME_Relative t1,
                           struct GNUNET_TIME_Relative t2)
 {
-  return (t1.rel_value < t2.rel_value) ? t1 : t2;
+  return (t1.rel_value_us < t2.rel_value_us) ? t1 : t2;
 }
 
 
@@ -216,7 +227,7 @@ struct GNUNET_TIME_Relative
 GNUNET_TIME_relative_max (struct GNUNET_TIME_Relative t1,
                           struct GNUNET_TIME_Relative t2)
 {
-  return (t1.rel_value > t2.rel_value) ? t1 : t2;
+  return (t1.rel_value_us > t2.rel_value_us) ? t1 : t2;
 }
 
 
@@ -232,7 +243,7 @@ struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_min (struct GNUNET_TIME_Absolute t1,
                           struct GNUNET_TIME_Absolute t2)
 {
-  return (t1.abs_value < t2.abs_value) ? t1 : t2;
+  return (t1.abs_value_us < t2.abs_value_us) ? t1 : t2;
 }
 
 
@@ -247,7 +258,7 @@ struct GNUNET_TIME_Absolute
 GNUNET_TIME_absolute_max (struct GNUNET_TIME_Absolute t1,
                           struct GNUNET_TIME_Absolute t2)
 {
-  return (t1.abs_value > t2.abs_value) ? t1 : t2;
+  return (t1.abs_value_us > t2.abs_value_us) ? t1 : t2;
 }
 
 
@@ -262,13 +273,13 @@ GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
 {
   struct GNUNET_TIME_Relative ret;
 
-  if (future.abs_value == UINT64_MAX)
+  if (future.abs_value_us == UINT64_MAX)
     return GNUNET_TIME_UNIT_FOREVER_REL;
   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
-  if (now.abs_value > future.abs_value)
+  if (now.abs_value_us > future.abs_value_us)
     return GNUNET_TIME_UNIT_ZERO;
-  ret.rel_value = future.abs_value - now.abs_value;
+  ret.rel_value_us = future.abs_value_us - now.abs_value_us;
   return ret;
 }
 
@@ -285,11 +296,11 @@ GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
 {
   struct GNUNET_TIME_Relative ret;
 
-  if (end.abs_value == UINT64_MAX)
+  if (end.abs_value_us == UINT64_MAX)
     return GNUNET_TIME_UNIT_FOREVER_REL;
-  if (end.abs_value < start.abs_value)
+  if (end.abs_value_us < start.abs_value_us)
     return GNUNET_TIME_UNIT_ZERO;
-  ret.rel_value = end.abs_value - start.abs_value;
+  ret.rel_value_us = end.abs_value_us - start.abs_value_us;
   return ret;
 }
 
@@ -306,10 +317,10 @@ GNUNET_TIME_absolute_get_duration (struct GNUNET_TIME_Absolute whence)
   struct GNUNET_TIME_Relative ret;
 
   now = GNUNET_TIME_absolute_get ();
-  GNUNET_assert (whence.abs_value != UINT64_MAX);
-  if (whence.abs_value > now.abs_value)
+  GNUNET_assert (whence.abs_value_us != UINT64_MAX);
+  if (whence.abs_value_us > now.abs_value_us)
     return GNUNET_TIME_UNIT_ZERO;
-  ret.rel_value = now.abs_value - whence.abs_value;
+  ret.rel_value_us = now.abs_value_us - whence.abs_value_us;
   return ret;
 }
 
@@ -326,14 +337,14 @@ GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
 {
   struct GNUNET_TIME_Absolute ret;
 
-  if ((start.abs_value == UINT64_MAX) || (duration.rel_value == UINT64_MAX))
+  if ((start.abs_value_us == UINT64_MAX) || (duration.rel_value_us == UINT64_MAX))
     return GNUNET_TIME_UNIT_FOREVER_ABS;
-  if (start.abs_value + duration.rel_value < start.abs_value)
+  if (start.abs_value_us + duration.rel_value_us < start.abs_value_us)
   {
     GNUNET_break (0);
     return GNUNET_TIME_UNIT_FOREVER_ABS;
   }
-  ret.abs_value = start.abs_value + duration.rel_value;
+  ret.abs_value_us = start.abs_value_us + duration.rel_value_us;
   return ret;
 }
 
@@ -352,11 +363,11 @@ GNUNET_TIME_absolute_subtract (struct GNUNET_TIME_Absolute start,
 {
   struct GNUNET_TIME_Absolute ret;
 
-  if (start.abs_value <= duration.rel_value)
+  if (start.abs_value_us <= duration.rel_value_us)
     return GNUNET_TIME_UNIT_ZERO_ABS;
-  if (start.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+  if (start.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
     return GNUNET_TIME_UNIT_FOREVER_ABS;
-  ret.abs_value = start.abs_value - duration.rel_value;
+  ret.abs_value_us = start.abs_value_us - duration.rel_value_us;
   return ret;
 }
 
@@ -372,10 +383,10 @@ GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
 {
   struct GNUNET_TIME_Relative ret;
 
-  if (factor == 0)
+  if (0 == factor)
     return GNUNET_TIME_UNIT_ZERO;
-  ret.rel_value = rel.rel_value * (unsigned long long) factor;
-  if (ret.rel_value / factor != rel.rel_value)
+  ret.rel_value_us = rel.rel_value_us * (unsigned long long) factor;
+  if (ret.rel_value_us / factor != rel.rel_value_us)
   {
     GNUNET_break (0);
     return GNUNET_TIME_UNIT_FOREVER_REL;
@@ -397,10 +408,10 @@ GNUNET_TIME_relative_divide (struct GNUNET_TIME_Relative rel,
 {
   struct GNUNET_TIME_Relative ret;
 
-  if ((factor == 0) ||
-      (rel.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value))
+  if ((0 == factor) ||
+      (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us))
     return GNUNET_TIME_UNIT_FOREVER_REL;
-  ret.rel_value = rel.rel_value / (unsigned long long) factor;
+  ret.rel_value_us = rel.rel_value_us / (unsigned long long) factor;
   return ret;
 }
 
@@ -426,11 +437,11 @@ GNUNET_TIME_calculate_eta (struct GNUNET_TIME_Absolute start, uint64_t finished,
   GNUNET_break (finished <= total);
   if (finished >= total)
     return GNUNET_TIME_UNIT_ZERO;
-  if (finished == 0)
+  if (0 == finished)
     return GNUNET_TIME_UNIT_FOREVER_REL;
   dur = GNUNET_TIME_absolute_get_duration (start);
-  exp = ((double) dur.rel_value) * ((double) total) / ((double) finished);
-  ret.rel_value = ((uint64_t) exp) - dur.rel_value;
+  exp = ((double) dur.rel_value_us) * ((double) total) / ((double) finished);
+  ret.rel_value_us = ((uint64_t) exp) - dur.rel_value_us;
   return ret;
 }
 
@@ -448,14 +459,14 @@ GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
 {
   struct GNUNET_TIME_Relative ret;
 
-  if ((a1.rel_value == UINT64_MAX) || (a2.rel_value == UINT64_MAX))
+  if ((a1.rel_value_us == UINT64_MAX) || (a2.rel_value_us == UINT64_MAX))
     return GNUNET_TIME_UNIT_FOREVER_REL;
-  if (a1.rel_value + a2.rel_value < a1.rel_value)
+  if (a1.rel_value_us + a2.rel_value_us < a1.rel_value_us)
   {
     GNUNET_break (0);
     return GNUNET_TIME_UNIT_FOREVER_REL;
   }
-  ret.rel_value = a1.rel_value + a2.rel_value;
+  ret.rel_value_us = a1.rel_value_us + a2.rel_value_us;
   return ret;
 }
 
@@ -473,11 +484,11 @@ GNUNET_TIME_relative_subtract (struct GNUNET_TIME_Relative a1,
 {
   struct GNUNET_TIME_Relative ret;
 
-  if (a2.rel_value >= a1.rel_value)
+  if (a2.rel_value_us >= a1.rel_value_us)
     return GNUNET_TIME_UNIT_ZERO;
-  if (a1.rel_value == UINT64_MAX)
+  if (a1.rel_value_us == UINT64_MAX)
     return GNUNET_TIME_UNIT_FOREVER_REL;
-  ret.rel_value = a1.rel_value - a2.rel_value;
+  ret.rel_value_us = a1.rel_value_us - a2.rel_value_us;
   return ret;
 }
 
@@ -493,7 +504,7 @@ GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
 {
   struct GNUNET_TIME_RelativeNBO ret;
 
-  ret.rel_value__ = GNUNET_htonll (a.rel_value);
+  ret.rel_value_us__ = GNUNET_htonll (a.rel_value_us);
   return ret;
 }
 
@@ -509,7 +520,7 @@ GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
 {
   struct GNUNET_TIME_Relative ret;
 
-  ret.rel_value = GNUNET_ntohll (a.rel_value__);
+  ret.rel_value_us = GNUNET_ntohll (a.rel_value_us__);
   return ret;
 
 }
@@ -526,7 +537,7 @@ GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
 {
   struct GNUNET_TIME_AbsoluteNBO ret;
 
-  ret.abs_value__ = GNUNET_htonll (a.abs_value);
+  ret.abs_value_us__ = GNUNET_htonll (a.abs_value_us);
   return ret;
 }
 
@@ -542,7 +553,7 @@ GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
 {
   struct GNUNET_TIME_Absolute ret;
 
-  ret.abs_value = GNUNET_ntohll (a.abs_value__);
+  ret.abs_value_us = GNUNET_ntohll (a.abs_value_us__);
   return ret;
 
 }