gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[GNUnet-SVN] r9429 - gnunet/src/util


From: gnunet
Subject: [GNUnet-SVN] r9429 - gnunet/src/util
Date: Sun, 8 Nov 2009 14:31:28 -0700

Author: grothoff
Date: 2009-11-08 14:31:27 -0700 (Sun, 08 Nov 2009)
New Revision: 9429

Modified:
   gnunet/src/util/client.c
   gnunet/src/util/connection.c
   gnunet/src/util/container_heap.c
   gnunet/src/util/disk.c
   gnunet/src/util/disk.h
   gnunet/src/util/gnunet-service-resolver.c
   gnunet/src/util/perf_crypto_hash.c
   gnunet/src/util/scheduler.c
   gnunet/src/util/server.c
   gnunet/src/util/service.c
   gnunet/src/util/test_bio.c
   gnunet/src/util/test_crypto_rsa.c
   gnunet/src/util/test_scheduler.c
   gnunet/src/util/test_server_with_client.c
   gnunet/src/util/test_service.c
Log:
indenting

Modified: gnunet/src/util/client.c
===================================================================
--- gnunet/src/util/client.c    2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/client.c    2009-11-08 21:31:27 UTC (rev 9429)
@@ -344,8 +344,7 @@
     GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
   if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (sock->sched,
-                              sock->receive_task);
+      GNUNET_SCHEDULER_cancel (sock->sched, sock->receive_task);
       sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
     }
   GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
@@ -363,8 +362,8 @@
 {
   if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) &&
       (conn->received_pos >=
-       ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)->
-              size)))
+       ntohs (((const struct GNUNET_MessageHeader *) conn->
+               received_buf)->size)))
     conn->msg_complete = GNUNET_YES;
 }
 
@@ -399,7 +398,7 @@
       /* signal timeout! */
       if (NULL != (receive_handler = conn->receiver_handler))
         {
-         receive_handler_cls = conn->receiver_handler_cls;
+          receive_handler_cls = conn->receiver_handler_cls;
           conn->receiver_handler = NULL;
           receive_handler (receive_handler_cls, NULL);
         }
@@ -491,15 +490,15 @@
   if (GNUNET_YES == sock->msg_complete)
     {
       sock->receive_task = GNUNET_SCHEDULER_add_after (sock->sched,
-                                                      GNUNET_SCHEDULER_NO_TASK,
-                                                      &receive_task, sock);
+                                                       
GNUNET_SCHEDULER_NO_TASK,
+                                                       &receive_task, sock);
     }
   else
     {
       sock->in_receive = GNUNET_YES;
       GNUNET_CONNECTION_receive (sock->sock,
-                                GNUNET_SERVER_MAX_MESSAGE_SIZE,
-                                timeout, &receive_helper, sock);
+                                 GNUNET_SERVER_MAX_MESSAGE_SIZE,
+                                 timeout, &receive_helper, sock);
     }
 }
 
@@ -611,8 +610,7 @@
     }
 #if DEBUG_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Transmitting `%s' request.\n",
-             "TEST");
+              "Transmitting `%s' request.\n", "TEST");
 #endif
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
@@ -706,11 +704,11 @@
     {
 #if DEBUG_CLIENT
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Transmission failed due to shutdown.\n");
+                  "Transmission failed due to shutdown.\n");
 #endif
       th->sock->th = NULL;
       th->notify (th->notify_cls, 0, NULL);
-      GNUNET_free (th);      
+      GNUNET_free (th);
       return;
     }
   th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock,
@@ -758,9 +756,9 @@
           (0 == --th->attempts_left) || (delay.value < 1))
         {
 #if DEBUG_CLIENT
-         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                     "Transmission failed %u times, giving up.\n",
-                     MAX_ATTEMPTS - th->attempts_left);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Transmission failed %u times, giving up.\n",
+                      MAX_ATTEMPTS - th->attempts_left);
 #endif
           GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
           GNUNET_free (th);
@@ -774,13 +772,14 @@
       delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS);
 #if DEBUG_CLIENT
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Transmission failed %u times, trying again in %llums.\n",
-                 MAX_ATTEMPTS - th->attempts_left,
-                 (unsigned long long) delay.value);
+                  "Transmission failed %u times, trying again in %llums.\n",
+                  MAX_ATTEMPTS - th->attempts_left,
+                  (unsigned long long) delay.value);
 #endif
       th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
-                                                        delay,
-                                                        &client_delayed_retry, 
th);
+                                                         delay,
+                                                         &client_delayed_retry,
+                                                         th);
       th->sock->th = th;
       return 0;
     }

Modified: gnunet/src/util/connection.c
===================================================================
--- gnunet/src/util/connection.c        2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/connection.c        2009-11-08 21:31:27 UTC (rev 9429)
@@ -785,16 +785,14 @@
   delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT;
   if (h->nth.notify_ready != NULL)
     delay = GNUNET_TIME_relative_min (delay,
-                                      GNUNET_TIME_absolute_get_remaining (h->
-                                                                          nth.
-                                                                          
transmit_timeout));
+                                      GNUNET_TIME_absolute_get_remaining
+                                      (h->nth.transmit_timeout));
   if (h->receiver != NULL)
     delay = GNUNET_TIME_relative_min (delay,
-                                      GNUNET_TIME_absolute_get_remaining (h->
-                                                                          
receive_timeout));
+                                      GNUNET_TIME_absolute_get_remaining
+                                      (h->receive_timeout));
   ap->task =
-    GNUNET_SCHEDULER_add_write_net (h->sched, 
-                                    delay, ap->sock,
+    GNUNET_SCHEDULER_add_write_net (h->sched, delay, ap->sock,
                                     &connect_probe_continuation, ap);
 }
 
@@ -813,11 +811,12 @@
 
   GNUNET_assert (sock->dns_active == NULL);
   sock->dns_active = GNUNET_RESOLVER_ip_get (sock->sched,
-                                            sock->cfg,
-                                            sock->hostname,
-                                            AF_UNSPEC,
-                                            
GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
-                                            &try_connect_using_address, sock);
+                                             sock->cfg,
+                                             sock->hostname,
+                                             AF_UNSPEC,
+                                             
GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
+                                             &try_connect_using_address,
+                                             sock);
 }
 
 
@@ -1000,8 +999,9 @@
         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                     "Receive from `%s' encounters error: time out by %llums... 
(%p)\n",
                     GNUNET_a2s (sh->addr, sh->addrlen),
-                    GNUNET_TIME_absolute_get_duration (sh->receive_timeout).
-                    value, sh);
+                    GNUNET_TIME_absolute_get_duration (sh->
+                                                       receive_timeout).value,
+                    sh);
 #endif
       signal_timeout (sh);
       return;
@@ -1348,8 +1348,8 @@
   GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size);
 RETRY:
   ret = GNUNET_NETWORK_socket_send (sock->sock,
-                                    &sock->write_buffer[sock->
-                                                        write_buffer_pos],
+                                    &sock->
+                                    write_buffer[sock->write_buffer_pos],
                                     have);
   if (ret == -1)
     {
@@ -1446,8 +1446,8 @@
 #endif
       sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched,
                                                          
GNUNET_TIME_absolute_get_remaining
-                                                         (sock->nth.
-                                                          transmit_timeout),
+                                                         (sock->
+                                                          
nth.transmit_timeout),
                                                          sock->sock,
                                                          &transmit_ready,
                                                          sock);

Modified: gnunet/src/util/container_heap.c
===================================================================
--- gnunet/src/util/container_heap.c    2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/container_heap.c    2009-11-08 21:31:27 UTC (rev 9429)
@@ -392,9 +392,7 @@
   struct GNUNET_CONTAINER_heap_node *root_node;
   struct GNUNET_CONTAINER_heap_node *last;
 
-  if ( (root == NULL) || 
-       (root->size == 0) || 
-       (root->root == NULL) )
+  if ((root == NULL) || (root->size == 0) || (root->root == NULL))
     {
       GNUNET_break (0);
       return NULL;
@@ -404,7 +402,7 @@
   ret = root_node->element;
   last = getPos (root, root->size);
 
-  if ( (root_node == last) && (root->size == 1))
+  if ((root_node == last) && (root->size == 1))
     {
       /* We are removing the last node in the heap! */
       GNUNET_free (last);
@@ -423,7 +421,7 @@
   root_node->cost = last->cost;
 
   if (root->traversal_pos == last)
-    root->traversal_pos = root->root;   
+    root->traversal_pos = root->root;
   GNUNET_free (last);
   root->size--;
   percolateDownHeap (root->root, root);

Modified: gnunet/src/util/disk.c
===================================================================
--- gnunet/src/util/disk.c      2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/disk.c      2009-11-08 21:31:27 UTC (rev 9429)
@@ -857,8 +857,8 @@
       return GNUNET_NO;
     }
   GNUNET_SCHEDULER_add_with_priority (iter->sched,
-                                     iter->priority,
-                                     &directory_iterator_task, iter);
+                                      iter->priority,
+                                      &directory_iterator_task, iter);
   return GNUNET_YES;
 }
 

Modified: gnunet/src/util/disk.h
===================================================================
--- gnunet/src/util/disk.h      2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/disk.h      2009-11-08 21:31:27 UTC (rev 9429)
@@ -43,14 +43,14 @@
    */ 
   HANDLE h;
   
-#else   /* 
+#else                           /* 
  */
   /**
    * File handle on other OSes.
    */ 
   int fd;
    
-#endif  /* 
+#endif                          /* 
  */
 };
 
Modified: gnunet/src/util/gnunet-service-resolver.c
===================================================================
--- gnunet/src/util/gnunet-service-resolver.c   2009-11-08 21:29:03 UTC (rev 
9428)
+++ gnunet/src/util/gnunet-service-resolver.c   2009-11-08 21:31:27 UTC (rev 
9429)
@@ -517,7 +517,7 @@
          GNUNET_SERVICE_run (argc,
                              argv,
                              "resolver", GNUNET_SERVICE_OPTION_NONE,
-                            &run, NULL)) ? 0 : 1;
+                             &run, NULL)) ? 0 : 1;
 
   while (head != NULL)
     {

Modified: gnunet/src/util/perf_crypto_hash.c
===================================================================
--- gnunet/src/util/perf_crypto_hash.c  2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/perf_crypto_hash.c  2009-11-08 21:31:27 UTC (rev 9429)
@@ -57,8 +57,8 @@
   start = GNUNET_TIME_absolute_get ();
   perfHash ();
   printf ("Hash perf took %llu ms\n",
-          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
-          value);
+          (unsigned long long)
+          GNUNET_TIME_absolute_get_duration (start).value);
   return 0;
 }
 

Modified: gnunet/src/util/scheduler.c
===================================================================
--- gnunet/src/util/scheduler.c 2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/scheduler.c 2009-11-08 21:31:27 UTC (rev 9429)
@@ -250,7 +250,7 @@
       if (pos->write_set != NULL)
         GNUNET_NETWORK_fdset_add (ws, pos->write_set);
       if (pos->reason != 0)
-       *timeout = GNUNET_TIME_UNIT_ZERO;
+        *timeout = GNUNET_TIME_UNIT_ZERO;
       pos = pos->next;
     }
 }
@@ -300,7 +300,7 @@
           const struct GNUNET_NETWORK_FDSet *rs,
           const struct GNUNET_NETWORK_FDSet *ws)
 {
-  if (now.value >= task->timeout.value) 
+  if (now.value >= task->timeout.value)
     task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
       (rs != NULL) && (set_overlaps (rs, task->read_set)))
@@ -399,8 +399,8 @@
     {
       pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
       /* we don't move the task into the ready queue yet; check_ready
-        will do that later, possibly adding additional
-        readyness-factors */
+         will do that later, possibly adding additional
+         readyness-factors */
       pos = pos->next;
     }
 }
@@ -532,20 +532,20 @@
   GNUNET_assert (sigpipe != NULL);
   pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
   GNUNET_assert (pr != NULL);
-  shc_int  = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
+  shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
   shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown);
   shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown);
-  shc_hup  = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
+  shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
 #endif
   memset (&sched, 0, sizeof (sched));
   sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
   GNUNET_SCHEDULER_add_continuation (&sched,
                                      task,
-                                     task_cls, 
-                                    GNUNET_SCHEDULER_REASON_STARTUP);
+                                     task_cls,
+                                     GNUNET_SCHEDULER_REASON_STARTUP);
   last_tr = 0;
   busy_wait_warning = 0;
-  while ( (sched.pending != NULL) || (sched.ready_count > 0) )
+  while ((sched.pending != NULL) || (sched.ready_count > 0))
     {
       GNUNET_NETWORK_fdset_zero (rs);
       GNUNET_NETWORK_fdset_zero (ws);
@@ -567,12 +567,12 @@
         }
 #ifndef MINGW
       if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
-       {
-         /* consume the signal */
-         GNUNET_DISK_file_read (pr, &c, sizeof(c));
-         /* mark all active tasks as ready due to shutdown */
-         GNUNET_SCHEDULER_shutdown (&sched);
-       }
+        {
+          /* consume the signal */
+          GNUNET_DISK_file_read (pr, &c, sizeof (c));
+          /* mark all active tasks as ready due to shutdown */
+          GNUNET_SCHEDULER_shutdown (&sched);
+        }
 #endif
       if (last_tr == sched.tasks_run)
         {
@@ -755,11 +755,10 @@
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
                             GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
-                            GNUNET_SCHEDULER_Task task,
-                           void *task_cls)
+                            GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (sched, 
-                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
+  return GNUNET_SCHEDULER_add_select (sched,
+                                      GNUNET_SCHEDULER_PRIORITY_KEEP,
                                       prerequisite_task,
                                       GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
@@ -777,13 +776,13 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched,
-                                   enum GNUNET_SCHEDULER_Priority prio,
-                                   GNUNET_SCHEDULER_Task task,
-                                   void *task_cls)
+GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle * sched,
+                                    enum GNUNET_SCHEDULER_Priority prio,
+                                    GNUNET_SCHEDULER_Task task,
+                                    void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (sched, 
-                                     prio,
+  return GNUNET_SCHEDULER_add_select (sched,
+                                      prio,
                                       GNUNET_SCHEDULER_NO_TASK,
                                       GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
@@ -805,13 +804,12 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
                               struct GNUNET_TIME_Relative delay,
-                              GNUNET_SCHEDULER_Task task,
-                             void *task_cls)
+                              GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (sched,
-                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                      GNUNET_SCHEDULER_PRIORITY_KEEP,
                                       GNUNET_SCHEDULER_NO_TASK, delay,
                                       NULL, NULL, task, task_cls);
 }
@@ -835,11 +833,10 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched,
-                              struct GNUNET_TIME_Relative delay,
-                              struct GNUNET_NETWORK_Handle *rfd,
-                              GNUNET_SCHEDULER_Task task,
-                              void *task_cls)
+GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched,
+                               struct GNUNET_TIME_Relative delay,
+                               struct GNUNET_NETWORK_Handle * rfd,
+                               GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct GNUNET_NETWORK_FDSet *rs;
   GNUNET_SCHEDULER_TaskIdentifier ret;
@@ -847,11 +844,10 @@
   GNUNET_assert (rfd != NULL);
   rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_set (rs, rfd);
-  ret = GNUNET_SCHEDULER_add_select (sched, 
-                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                     GNUNET_SCHEDULER_NO_TASK, 
-                                    delay,
-                                     rs, NULL, task, task_cls);
+  ret = GNUNET_SCHEDULER_add_select (sched,
+                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     delay, rs, NULL, task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
   return ret;
 }
@@ -875,11 +871,10 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched,
-                               struct GNUNET_TIME_Relative delay,
-                               struct GNUNET_NETWORK_Handle *wfd, 
-                               GNUNET_SCHEDULER_Task task, 
-                               void *task_cls)
+GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched,
+                                struct GNUNET_TIME_Relative delay,
+                                struct GNUNET_NETWORK_Handle * wfd,
+                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct GNUNET_NETWORK_FDSet *ws;
   GNUNET_SCHEDULER_TaskIdentifier ret;
@@ -887,8 +882,8 @@
   GNUNET_assert (wfd != NULL);
   ws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_set (ws, wfd);
-  ret = GNUNET_SCHEDULER_add_select (sched, 
-                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
+  ret = GNUNET_SCHEDULER_add_select (sched,
+                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
                                      GNUNET_SCHEDULER_NO_TASK, delay,
                                      NULL, ws, task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
@@ -914,11 +909,10 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched,
-                               struct GNUNET_TIME_Relative delay,
-                               const struct GNUNET_DISK_FileHandle *rfd, 
-                               GNUNET_SCHEDULER_Task task,
-                               void *task_cls)
+GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
+                                struct GNUNET_TIME_Relative delay,
+                                const struct GNUNET_DISK_FileHandle * rfd,
+                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct GNUNET_NETWORK_FDSet *rs;
   GNUNET_SCHEDULER_TaskIdentifier ret;
@@ -927,8 +921,8 @@
   rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_handle_set (rs, rfd);
   ret = GNUNET_SCHEDULER_add_select (sched,
-                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                    GNUNET_SCHEDULER_NO_TASK, delay,
+                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                     GNUNET_SCHEDULER_NO_TASK, delay,
                                      rs, NULL, task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
   return ret;
@@ -953,11 +947,10 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched,
-                                struct GNUNET_TIME_Relative delay,
-                                const struct GNUNET_DISK_FileHandle *wfd,
-                                GNUNET_SCHEDULER_Task task, 
-                                void *task_cls)
+GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
+                                 struct GNUNET_TIME_Relative delay,
+                                 const struct GNUNET_DISK_FileHandle * wfd,
+                                 GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct GNUNET_NETWORK_FDSet *ws;
   GNUNET_SCHEDULER_TaskIdentifier ret;
@@ -965,11 +958,10 @@
   GNUNET_assert (wfd != NULL);
   ws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_handle_set (ws, wfd);
-  ret = GNUNET_SCHEDULER_add_select (sched, 
-                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                     GNUNET_SCHEDULER_NO_TASK, 
-                                    delay,
-                                     NULL, ws, task, task_cls);
+  ret = GNUNET_SCHEDULER_add_select (sched,
+                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     delay, NULL, ws, task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   return ret;
 }
@@ -1010,15 +1002,14 @@
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
                              enum GNUNET_SCHEDULER_Priority prio,
                              GNUNET_SCHEDULER_TaskIdentifier
                              prerequisite_task,
                              struct GNUNET_TIME_Relative delay,
                              const struct GNUNET_NETWORK_FDSet * rs,
-                            const struct GNUNET_NETWORK_FDSet * ws,
-                             GNUNET_SCHEDULER_Task task, 
-                            void *task_cls)
+                             const struct GNUNET_NETWORK_FDSet * ws,
+                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
 

Modified: gnunet/src/util/server.c
===================================================================
--- gnunet/src/util/server.c    2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/server.c    2009-11-08 21:31:27 UTC (rev 9429)
@@ -275,16 +275,17 @@
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     {
       server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
-                                                        
GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                        
GNUNET_SCHEDULER_NO_TASK,
-                                                        
GNUNET_TIME_UNIT_FOREVER_REL,
-                                                        r, NULL, 
&process_listen_socket, 
-                                                        server);
+                                                         
GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                                         
GNUNET_SCHEDULER_NO_TASK,
+                                                         
GNUNET_TIME_UNIT_FOREVER_REL,
+                                                         r, NULL,
+                                                         
&process_listen_socket,
+                                                         server);
       GNUNET_NETWORK_fdset_destroy (r);
-      return; /* ignore shutdown, someone else will take care of it! */
+      return;                   /* ignore shutdown, someone else will take 
care of it! */
     }
   GNUNET_assert (GNUNET_NETWORK_fdset_isset
-                 (tc->read_ready, server->listen_socket));  
+                 (tc->read_ready, server->listen_socket));
   sock =
     GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
                                           server->access_cls,
@@ -302,10 +303,12 @@
     }
   /* listen for more! */
   server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
-                                                    
GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                    GNUNET_SCHEDULER_NO_TASK,
-                                                    
GNUNET_TIME_UNIT_FOREVER_REL,
-                                                    r, NULL, 
&process_listen_socket, server);
+                                                     
GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                                     GNUNET_SCHEDULER_NO_TASK,
+                                                     
GNUNET_TIME_UNIT_FOREVER_REL,
+                                                     r, NULL,
+                                                     &process_listen_socket,
+                                                     server);
   GNUNET_NETWORK_fdset_destroy (r);
 }
 
@@ -418,11 +421,13 @@
     {
       r = GNUNET_NETWORK_fdset_create ();
       GNUNET_NETWORK_fdset_set (r, ret->listen_socket);
-      ret->listen_task = GNUNET_SCHEDULER_add_select (sched, 
-                                                     
GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                     GNUNET_SCHEDULER_NO_TASK,
-                                                     
GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
-                                                     &process_listen_socket, 
ret);
+      ret->listen_task = GNUNET_SCHEDULER_add_select (sched,
+                                                      
GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                                      GNUNET_SCHEDULER_NO_TASK,
+                                                      
GNUNET_TIME_UNIT_FOREVER_REL,
+                                                      r, NULL,
+                                                      &process_listen_socket,
+                                                      ret);
       GNUNET_NETWORK_fdset_destroy (r);
     }
   return ret;
@@ -444,12 +449,10 @@
 #endif
   if (GNUNET_SCHEDULER_NO_TASK != s->listen_task)
     {
-      GNUNET_SCHEDULER_cancel (s->sched,
-                              s->listen_task);
+      GNUNET_SCHEDULER_cancel (s->sched, s->listen_task);
       s->listen_task = GNUNET_SCHEDULER_NO_TASK;
     }
-  GNUNET_break (GNUNET_OK ==
-               GNUNET_NETWORK_socket_close (s->listen_socket));
+  GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s->listen_socket));
   s->listen_socket = NULL;
   while (s->clients != NULL)
     {

Modified: gnunet/src/util/service.c
===================================================================
--- gnunet/src/util/service.c   2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/service.c   2009-11-08 21:31:27 UTC (rev 9429)
@@ -799,8 +799,7 @@
     {
       if (GNUNET_SYSERR ==
           (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
-                                                             sctx->
-                                                             serviceName,
+                                                             sctx->serviceName,
                                                              "DISABLEV6")))
         return GNUNET_SYSERR;
     }
@@ -1079,8 +1078,7 @@
  * @param tc unused
  */
 static void
-shutdown_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_SERVER_Handle *server = cls;
 
@@ -1116,11 +1114,10 @@
   if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN))
     {
       /* install a task that will kill the server
-        process if the scheduler ever gets a shutdown signal */
+         process if the scheduler ever gets a shutdown signal */
       GNUNET_SCHEDULER_add_delayed (tc->sched,
-                                   GNUNET_TIME_UNIT_FOREVER_REL,
-                                   &shutdown_task,
-                                   sctx->server);
+                                    GNUNET_TIME_UNIT_FOREVER_REL,
+                                    &shutdown_task, sctx->server);
     }
   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
   memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
@@ -1297,9 +1294,8 @@
 GNUNET_SERVICE_run (int argc,
                     char *const *argv,
                     const char *serviceName,
-                   enum GNUNET_SERVICE_Options opt,
-                    GNUNET_SERVICE_Main task,
-                    void *task_cls)
+                    enum GNUNET_SERVICE_Options opt,
+                    GNUNET_SERVICE_Main task, void *task_cls)
 {
   char *cfg_fn;
   char *loglev;

Modified: gnunet/src/util/test_bio.c
===================================================================
--- gnunet/src/util/test_bio.c  2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/test_bio.c  2009-11-08 21:31:27 UTC (rev 9429)
@@ -31,282 +31,326 @@
 #define TESTNUMBER64 100000L
 
 static int
-test_normal_rw(void){
-       char *msg;
-       int64_t testNum;
-       char *readResultString;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-    struct GNUNET_CONTAINER_MetaData *metaDataW;
-    struct GNUNET_CONTAINER_MetaData *metaDataR;
-    metaDataW = GNUNET_CONTAINER_meta_data_create ();
-    metaDataR = GNUNET_CONTAINER_meta_data_create ();
-    GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+test_normal_rw (void)
+{
+  char *msg;
+  int64_t testNum;
+  char *readResultString;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  struct GNUNET_CONTAINER_MetaData *metaDataW;
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+  metaDataW = GNUNET_CONTAINER_meta_data_create ();
+  metaDataR = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 
-    fileW = GNUNET_BIO_write_open (fileName);
-    GNUNET_assert (NULL != fileW);
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, 
(int64_t)TESTNUMBER64));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_int64 (fileW, (int64_t) TESTNUMBER64));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-    fileR = GNUNET_BIO_read_open (fileName);
-    GNUNET_assert (NULL != fileR);
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string 
error", &readResultString, 200));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_meta_data (fileR, "Read meta 
error", &metaDataR));
-    GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal 
(metaDataR, metaDataW));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
-    GNUNET_BIO_read_close (fileR, &msg);
-    GNUNET_CONTAINER_meta_data_destroy (metaDataW);
-    GNUNET_CONTAINER_meta_data_destroy (metaDataR);
-    GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-    return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 200));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
+                                                        metaDataW));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_CONTAINER_meta_data_destroy (metaDataW);
+  GNUNET_CONTAINER_meta_data_destroy (metaDataR);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-test_nullstring_rw(){
-       char *msg;
-       char *readResultString = (char*) "not null";
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+test_nullstring_rw ()
+{
+  char *msg;
+  char *readResultString = (char *) "not null";
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-    fileR = GNUNET_BIO_read_open (fileName);
-    GNUNET_assert (NULL != fileR);
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string 
error", &readResultString, 200));
-    GNUNET_assert (NULL == readResultString);
-    GNUNET_BIO_read_close (fileR, &msg);
-    GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 200));
+  GNUNET_assert (NULL == readResultString);
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
 
-    return 0;
+  return 0;
 }
 
 static int
-test_emptystring_rw(void){
-       char *msg;
-       char *readResultString;
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+test_emptystring_rw (void)
+{
+  char *msg;
+  char *readResultString;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-    fileR = GNUNET_BIO_read_open (fileName);
-    GNUNET_assert (NULL != fileR);
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string 
error", &readResultString, 200));
-    GNUNET_BIO_read_close (fileR, &msg);
-    GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-    return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 200));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-test_bigstring_rw(void){
-       char *msg;
-       char *readResultString;
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+test_bigstring_rw (void)
+{
+  char *msg;
+  char *readResultString;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, 
TESTSTRING));
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-    fileR = GNUNET_BIO_read_open (fileName);
-    GNUNET_assert (NULL != fileR);
-    GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read 
string error", &readResultString, 1));
-    GNUNET_BIO_read_close (fileR, &msg);
-    GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-    return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 1));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-test_bigmeta_rw(){
-       char *msg;
-       static char meta[1024 * 1024 * 10];
-       memset(meta,'b',sizeof(meta));
-       meta[sizeof(meta)-1]='\0';
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-       struct GNUNET_CONTAINER_MetaData *metaDataW;
-       struct GNUNET_CONTAINER_MetaData *metaDataR;
-       metaDataW = GNUNET_CONTAINER_meta_data_create ();
-    metaDataR = GNUNET_CONTAINER_meta_data_create ();
-    GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
-    GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (metaDataW, 
EXTRACTOR_COMMENT, meta));
+test_bigmeta_rw ()
+{
+  char *msg;
+  static char meta[1024 * 1024 * 10];
+  memset (meta, 'b', sizeof (meta));
+  meta[sizeof (meta) - 1] = '\0';
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_CONTAINER_MetaData *metaDataW;
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+  metaDataW = GNUNET_CONTAINER_meta_data_create ();
+  metaDataR = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_meta_data_insert (metaDataW,
+                                                    EXTRACTOR_COMMENT, meta));
 
-    fileW = GNUNET_BIO_write_open (fileName);
-    GNUNET_assert (NULL != fileW);
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
-    GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-    fileR = GNUNET_BIO_read_open (fileName);
-    GNUNET_assert (NULL != fileR);
-    GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read 
meta error", &metaDataR));
-    GNUNET_BIO_read_close (fileR, &msg);
-    GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-    return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-test_nullfile_rw(void){
-       char *msg;
-       int64_t testNum;
-       char *readResultString;
-       static char fileNameNO[102401];
-       char readResult[200];
-       memset(fileNameNO,'a',sizeof(fileNameNO));
-       fileNameNO[sizeof(fileNameNO)-1] = '\0';
-       const char *fileName = "/dev/full";
-    const char *fileNameR = "/dev/null";
-       struct GNUNET_BIO_WriteHandle *fileW,*fileWNO;
-       struct GNUNET_BIO_ReadHandle *fileR,*fileRNO;
-       struct GNUNET_CONTAINER_MetaData *metaDataW;
-       struct GNUNET_CONTAINER_MetaData *metaDataR;
-       metaDataW = GNUNET_CONTAINER_meta_data_create ();
-       metaDataR = GNUNET_CONTAINER_meta_data_create ();
-       GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+test_nullfile_rw (void)
+{
+  char *msg;
+  int64_t testNum;
+  char *readResultString;
+  static char fileNameNO[102401];
+  char readResult[200];
+  memset (fileNameNO, 'a', sizeof (fileNameNO));
+  fileNameNO[sizeof (fileNameNO) - 1] = '\0';
+  const char *fileName = "/dev/full";
+  const char *fileNameR = "/dev/null";
+  struct GNUNET_BIO_WriteHandle *fileW, *fileWNO;
+  struct GNUNET_BIO_ReadHandle *fileR, *fileRNO;
+  struct GNUNET_CONTAINER_MetaData *metaDataW;
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+  metaDataW = GNUNET_CONTAINER_meta_data_create ();
+  metaDataR = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 
-       fileWNO = GNUNET_BIO_write_open(fileNameNO);
-       GNUNET_assert (NULL == fileWNO);
+  fileWNO = GNUNET_BIO_write_open (fileNameNO);
+  GNUNET_assert (NULL == fileWNO);
 
-       fileRNO = GNUNET_BIO_read_open (fileNameNO);
-       GNUNET_assert (NULL == fileRNO);
+  fileRNO = GNUNET_BIO_read_open (fileNameNO);
+  GNUNET_assert (NULL == fileRNO);
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write (fileW, TESTSTRING, 
65537));
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_string (fileW, 
TESTSTRING));
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_meta_data (fileW, 
metaDataW));
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_write (fileW, TESTSTRING, 65537));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_write_string (fileW, TESTSTRING));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_write_meta_data (fileW, metaDataW));
+  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 
-       fileR = GNUNET_BIO_read_open (fileNameR);
-       GNUNET_assert (NULL != fileR);
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", 
readResult, 65537));
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read 
string error", &readResultString, 200));
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, 
&testNum));
-    GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read 
meta error", &metaDataR));
-    GNUNET_BIO_read_close (fileR, &msg);
-    return 0;
+  fileR = GNUNET_BIO_read_open (fileNameR);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 200));
+  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  GNUNET_BIO_read_close (fileR, &msg);
+  return 0;
 }
 
 static int
-test_fakestring_rw(void){
-       char *msg;
-       int32_t tmpInt = 2;
-       char *readResult;
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+test_fakestring_rw (void)
+{
+  char *msg;
+  int32_t tmpInt = 2;
+  char *readResult;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-       fileR = GNUNET_BIO_read_open (fileName);
-       GNUNET_assert (NULL != fileR);
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string(fileR, "Read 
string error", &readResult, 200));
-       GNUNET_BIO_read_close (fileR, &msg);
-       GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-       return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResult, 200));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-test_fakemeta_rw(void){
-       char *msg;
-       int32_t tmpInt = 2;
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-       struct GNUNET_CONTAINER_MetaData *metaDataR;
-       metaDataR = GNUNET_CONTAINER_meta_data_create ();
+test_fakemeta_rw (void)
+{
+  char *msg;
+  int32_t tmpInt = 2;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+  metaDataR = GNUNET_CONTAINER_meta_data_create ();
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW,tmpInt));
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-       fileR = GNUNET_BIO_read_open (fileName);
-       GNUNET_assert (NULL != fileR);
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read 
meta error", &metaDataR));
-       GNUNET_BIO_read_close (fileR, &msg);
-       GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-       return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-test_fakebigmeta_rw(void){
-       char *msg;
-       int32_t tmpInt = 1024*1024*10;
-       struct GNUNET_BIO_WriteHandle *fileW;
-       struct GNUNET_BIO_ReadHandle *fileR;
-       char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-       struct GNUNET_CONTAINER_MetaData *metaDataR;
-       metaDataR = GNUNET_CONTAINER_meta_data_create ();
+test_fakebigmeta_rw (void)
+{
+  char *msg;
+  int32_t tmpInt = 1024 * 1024 * 10;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+  metaDataR = GNUNET_CONTAINER_meta_data_create ();
 
-       fileW = GNUNET_BIO_write_open (fileName);
-       GNUNET_assert (NULL != fileW);
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
-       GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 
-       fileR = GNUNET_BIO_read_open (fileName);
-       GNUNET_assert (NULL != fileR);
-       GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read 
meta error", &metaDataR));
-       GNUNET_BIO_read_close (fileR, &msg);
-       GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
-    GNUNET_free (fileName);
-    return 0;
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
 }
 
 static int
-check_string_rw(void){
-       GNUNET_assert (0 == test_nullstring_rw());
-       GNUNET_assert (0 == test_emptystring_rw());
-       GNUNET_assert (0 == test_bigstring_rw());
-       GNUNET_assert (0 == test_fakestring_rw());
-       return 0;
+check_string_rw (void)
+{
+  GNUNET_assert (0 == test_nullstring_rw ());
+  GNUNET_assert (0 == test_emptystring_rw ());
+  GNUNET_assert (0 == test_bigstring_rw ());
+  GNUNET_assert (0 == test_fakestring_rw ());
+  return 0;
 }
 
 static int
-check_metadata_rw(void){
-       GNUNET_assert (0 == test_fakebigmeta_rw());
-       GNUNET_assert (0 == test_fakemeta_rw());
-       GNUNET_assert (0 == test_bigmeta_rw());
-       return 0;
+check_metadata_rw (void)
+{
+  GNUNET_assert (0 == test_fakebigmeta_rw ());
+  GNUNET_assert (0 == test_fakemeta_rw ());
+  GNUNET_assert (0 == test_bigmeta_rw ());
+  return 0;
 }
 
 static int
-check_file_rw(void){
-    GNUNET_assert (0 == test_normal_rw());
-       GNUNET_assert (0 == test_nullfile_rw());
-       return 0;
+check_file_rw (void)
+{
+  GNUNET_assert (0 == test_normal_rw ());
+  GNUNET_assert (0 == test_nullfile_rw ());
+  return 0;
 }
 
 int
-main (int argc, char *argv[]){
-    GNUNET_assert (0 == check_file_rw());
-    GNUNET_assert (0 == check_metadata_rw());
-    GNUNET_assert (0 == check_string_rw());
-    return 0;
+main (int argc, char *argv[])
+{
+  GNUNET_assert (0 == check_file_rw ());
+  GNUNET_assert (0 == check_metadata_rw ());
+  GNUNET_assert (0 == check_string_rw ());
+  return 0;
 }                               /* end of main */

Modified: gnunet/src/util/test_crypto_rsa.c
===================================================================
--- gnunet/src/util/test_crypto_rsa.c   2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/test_crypto_rsa.c   2009-11-08 21:31:27 UTC (rev 9429)
@@ -273,8 +273,8 @@
         }
     }
   printf ("%d RSA sign operations %llu ms\n", ITER,
-          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
-          value);
+          (unsigned long long)
+          GNUNET_TIME_absolute_get_duration (start).value);
   GNUNET_CRYPTO_rsa_key_free (hostkey);
   return ok;
 }

Modified: gnunet/src/util/test_scheduler.c
===================================================================
--- gnunet/src/util/test_scheduler.c    2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/test_scheduler.c    2009-11-08 21:31:27 UTC (rev 9429)
@@ -48,9 +48,9 @@
   GNUNET_assert (2 == *ok);
   (*ok) = 3;
   /* t3 will go before t4: higher priority */
-  GNUNET_SCHEDULER_add_with_priority (tc->sched,                               
  
-                                     GNUNET_SCHEDULER_PRIORITY_UI,
-                                     &task3, cls);
+  GNUNET_SCHEDULER_add_with_priority (tc->sched,
+                                      GNUNET_SCHEDULER_PRIORITY_UI,
+                                      &task3, cls);
 }
 
 static void
@@ -102,8 +102,8 @@
   GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
   (*ok) = 8;
   GNUNET_SCHEDULER_add_with_priority (tc->sched,
-                                     GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                     &taskLast, cls);
+                                      GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                      &taskLast, cls);
   GNUNET_SCHEDULER_shutdown (tc->sched);
 }
 
@@ -140,11 +140,9 @@
   t2 = GNUNET_SCHEDULER_add_after (tc->sched,
                                    GNUNET_SCHEDULER_NO_TASK, &task2, cls);
   /* t4 will go after t2 ('add after') and after t3 (priority) */
-  t4 = GNUNET_SCHEDULER_add_after (tc->sched,
-                                   t2, &task4, cls);
+  t4 = GNUNET_SCHEDULER_add_after (tc->sched, t2, &task4, cls);
   /* t5 will go last (after p4) */
-  GNUNET_SCHEDULER_add_after (tc->sched,
-                              t4, &task5, cls);
+  GNUNET_SCHEDULER_add_after (tc->sched, t4, &task5, cls);
 }
 
 
@@ -171,8 +169,7 @@
   GNUNET_assert (1 == *ok);
   *ok = 8;
   GNUNET_SCHEDULER_add_delayed (tc->sched,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               &taskLast, cls);
+                                GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
   GNUNET_SCHEDULER_shutdown (tc->sched);
 }
 
@@ -199,8 +196,7 @@
   GNUNET_assert (1 == *ok);
   *ok = 8;
   GNUNET_SCHEDULER_add_delayed (tc->sched,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               &taskLast, cls);
+                                GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
 #ifndef MINGW
   GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM));
 #else

Modified: gnunet/src/util/test_server_with_client.c
===================================================================
--- gnunet/src/util/test_server_with_client.c   2009-11-08 21:29:03 UTC (rev 
9428)
+++ gnunet/src/util/test_server_with_client.c   2009-11-08 21:31:27 UTC (rev 
9429)
@@ -126,8 +126,7 @@
   GNUNET_assert (ok == 5);
   ok = 0;
   GNUNET_SCHEDULER_add_delayed (sched,
-                               GNUNET_TIME_UNIT_ZERO,
-                               &clean_up, NULL); 
+                                GNUNET_TIME_UNIT_ZERO, &clean_up, NULL);
 }
 
 

Modified: gnunet/src/util/test_service.c
===================================================================
--- gnunet/src/util/test_service.c      2009-11-08 21:29:03 UTC (rev 9428)
+++ gnunet/src/util/test_service.c      2009-11-08 21:31:27 UTC (rev 9429)
@@ -51,7 +51,7 @@
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n");
   GNUNET_CLIENT_service_shutdown (client);
-  if (sctx != NULL)    
+  if (sctx != NULL)
     GNUNET_SERVICE_stop (sctx);
   else
     GNUNET_SCHEDULER_shutdown (sched);
@@ -152,13 +152,13 @@
                  GNUNET_SERVICE_run (5,
                                      argv,
                                      "test_service",
-                                    GNUNET_SERVICE_OPTION_NONE,
+                                     GNUNET_SERVICE_OPTION_NONE,
                                      &runner, &ok));
   GNUNET_assert (0 == ok);
   return ok;
 }
 
-static void 
+static void
 ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
@@ -214,7 +214,7 @@
                  GNUNET_SERVICE_run (5,
                                      argv,
                                      "test_service6",
-                                    GNUNET_SERVICE_OPTION_NONE,
+                                     GNUNET_SERVICE_OPTION_NONE,
                                      &runner6, &ok));
   GNUNET_assert (0 == ok);
   return ok;
@@ -247,7 +247,7 @@
                  GNUNET_SERVICE_run (6,
                                      argv,
                                      "test_service6",
-                                    GNUNET_SERVICE_OPTION_NONE,
+                                     GNUNET_SERVICE_OPTION_NONE,
                                      &runner6, &ok));
   GNUNET_break (0 == ok);
   return ok;





reply via email to

[Prev in Thread] Current Thread [Next in Thread]