1 files changed, 577 insertions, 586 deletions

diff --git a/src/transport/test_plugin_transport_http.c b/src/transport/test_plugin_transport_http.c
index 5ba8c573a..921f9ec32 100644
--- a/src/transport/test_plugin_transport_http.c
+++ b/src/transport/test_plugin_transport_http.c
@@ -75,12 +75,12 @@ struct Plugin_Address
   /**
    * Next field for linked list
    */
-  struct Plugin_Address * next;
+  struct Plugin_Address *next;
 
   /**
    * buffer containing data to send
    */
-  void * addr;
+  void *addr;
 
   /**
    * amount of data to sent
@@ -162,9 +162,9 @@ struct HTTP_Transfer
  */
 struct IPv4HttpAddress
 {
-  struct IPv4HttpAddress * next;
+  struct IPv4HttpAddress *next;
 
-  struct IPv4HttpAddress * prev;
+  struct IPv4HttpAddress *prev;
 
   /**
    * IPv4 address, in network byte order.
@@ -184,9 +184,9 @@ struct IPv4HttpAddress
  */
 struct IPv6HttpAddress
 {
-  struct IPv6HttpAddress * next;
+  struct IPv6HttpAddress *next;
 
-  struct IPv6HttpAddress * prev;
+  struct IPv6HttpAddress *prev;
 
   /**
    * IPv6 address.
@@ -229,7 +229,7 @@ static long long unsigned int port;
 /**
  * Peer's addr
  */
-static char * test_addr;
+static char *test_addr;
 
 /**
  * Our statistics handle.
@@ -277,12 +277,13 @@ static struct HTTP_Message buffer_out;
 static struct HTTP_Message buffer_in;
 
 
-struct Plugin_Address * addr_head;
+struct Plugin_Address *addr_head;
 
 /**
  * Did the test pass or fail?
  */
 static int fail_notify_address;
+
 /**
  * Did the test pass or fail?
  */
@@ -386,7 +387,7 @@ static CURLM *multi_handle;
  */
 static GNUNET_SCHEDULER_TaskIdentifier http_task_send;
 
-static char * servicehome;
+static char *servicehome;
 
 /**
  * Shutdown testcase
@@ -394,53 +395,51 @@ static char * servicehome;
 static void
 shutdown_clean ()
 {
-  struct Plugin_Address * tmp;
+  struct Plugin_Address *tmp;
 
   /* Evaluate results  */
   fail = 0;
-  if ( (fail_notify_address == GNUNET_YES) || 
-       (fail_pretty_printer == GNUNET_YES) || 
-       (fail_addr_to_str == GNUNET_YES))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "Phase 0: Test plugin functions failed\n");
-      fail = 1;
-    }
-  if ( (test_no_ident.test_failed == GNUNET_YES) || 
-       (test_too_short_ident.test_failed == GNUNET_YES) || 
-       (test_too_long_ident.test_failed == GNUNET_YES) || 
-       (test_valid_ident.test_failed == GNUNET_YES) )
+  if ((fail_notify_address == GNUNET_YES) ||
+      (fail_pretty_printer == GNUNET_YES) || (fail_addr_to_str == GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Phase 0: Test plugin functions failed\n");
+    fail = 1;
+  }
+  if ((test_no_ident.test_failed == GNUNET_YES) ||
+      (test_too_short_ident.test_failed == GNUNET_YES) ||
+      (test_too_long_ident.test_failed == GNUNET_YES) ||
+      (test_valid_ident.test_failed == GNUNET_YES))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Phase 1: Test connect with wrong data failed\n");
     fail = 1;
   }
-  if ( (fail_session_selection_any != GNUNET_NO) || 
-       (fail_session_selection_reliable != GNUNET_NO) ||
-       (fail_session_selection_session != GNUNET_NO) || 
-       (fail_session_selection_session_big != GNUNET_NO) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "Phase 2: Test session selection failed\n");
-      fail = 1;
-    }
-  if ( (fail_msgs_transmited_to_local_addrs != count_str_addr) ||
-       (fail_multiple_msgs_in_transmission != 2) || 
-       (fail_msg_transmited_max_size == GNUNET_YES) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                  "Phase 3: Test sending with plugin failed\n");
-      fail = 1;
-    }
+  if ((fail_session_selection_any != GNUNET_NO) ||
+      (fail_session_selection_reliable != GNUNET_NO) ||
+      (fail_session_selection_session != GNUNET_NO) ||
+      (fail_session_selection_session_big != GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Phase 2: Test session selection failed\n");
+    fail = 1;
+  }
+  if ((fail_msgs_transmited_to_local_addrs != count_str_addr) ||
+      (fail_multiple_msgs_in_transmission != 2) ||
+      (fail_msg_transmited_max_size == GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Phase 3: Test sending with plugin failed\n");
+    fail = 1;
+  }
   if (fail != 1)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "All tests successful\n");
-    }
-  
-  api->disconnect(api->cls,&my_identity);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All tests successful\n");
+  }
+
+  api->disconnect (api->cls, &my_identity);
 
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup (multi_handle);
 
   if (NULL != curl_handle)
     curl_easy_cleanup (curl_handle);
@@ -451,37 +450,37 @@ shutdown_clean ()
     tmp = addr_head->next;
     GNUNET_free (addr_head->addr);
     GNUNET_free (addr_head);
-    addr_head=tmp;
+    addr_head = tmp;
   }
 
   if (ti_send != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ti_send);
+    GNUNET_SCHEDULER_cancel (ti_send);
     ti_send = GNUNET_SCHEDULER_NO_TASK;
   }
 
   if (http_task_send != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(http_task_send);
+    GNUNET_SCHEDULER_cancel (http_task_send);
     http_task_send = GNUNET_SCHEDULER_NO_TASK;
   }
 
   if (ti_timeout != GNUNET_SCHEDULER_NO_TASK)
   {
-    GNUNET_SCHEDULER_cancel(ti_timeout);
+    GNUNET_SCHEDULER_cancel (ti_timeout);
     ti_timeout = GNUNET_SCHEDULER_NO_TASK;
   }
 
-  GNUNET_free(test_addr);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Unloading http plugin\n");
-  GNUNET_assert (NULL == GNUNET_PLUGIN_unload ("libgnunet_gnunet_transport_plugin_http", api));
+  GNUNET_free (test_addr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unloading http plugin\n");
+  GNUNET_assert (NULL ==
+                 GNUNET_PLUGIN_unload ("libgnunet_gnunet_transport_plugin_http",
+                                       api));
 
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   GNUNET_DISK_directory_remove ("/tmp/test_gnunet_transport_plugin_http");
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "Exiting testcase\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Exiting testcase\n");
 
   if (servicehome != NULL)
   {
@@ -489,7 +488,7 @@ shutdown_clean ()
     GNUNET_free (servicehome);
   }
 
-  exit(fail);
+  exit (fail);
   return;
 }
 
@@ -502,102 +501,98 @@ shutdown_clean ()
  */
 
 static void
-task_send_cont (void *cls,
-                const struct GNUNET_PeerIdentity * target,
-                int result)
+task_send_cont (void *cls, const struct GNUNET_PeerIdentity *target, int result)
 {
-  if ((cls == &fail_msg_transmited_bigger_max_size) && (result == GNUNET_SYSERR))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Message bigger max msg size was not sent!\n");
-      fail_msg_transmited_bigger_max_size = GNUNET_NO;
-      return;
-    }
+  if ((cls == &fail_msg_transmited_bigger_max_size) &&
+      (result == GNUNET_SYSERR))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message bigger max msg size was not sent!\n");
+    fail_msg_transmited_bigger_max_size = GNUNET_NO;
+    return;
+  }
 
   if ((cls == &fail_msg_transmited_max_size) && (result == GNUNET_OK))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Message with max msg size succesfully sent!\n",
-                  fail_msgs_transmited_to_local_addrs);
-      fail_msg_transmited_max_size = GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Message with max msg size succesfully sent!\n",
+                fail_msgs_transmited_to_local_addrs);
+    fail_msg_transmited_max_size = GNUNET_NO;
+  }
 }
 
 
-static void run_connection_tests( int phase , void * cls);
+static void run_connection_tests (int phase, void *cls);
 
 /**
  * Recieves messages from plugin, in real world transport
  */
 static struct GNUNET_TIME_Relative
 receive (void *cls, const struct GNUNET_PeerIdentity *peer,
-        const struct GNUNET_MessageHeader *message,
-        const struct GNUNET_TRANSPORT_ATS_Information *ats,
-        uint32_t ats_count,
-        struct Session *session,
-        const char *sender_address,
-        uint16_t sender_address_len)
+         const struct GNUNET_MessageHeader *message,
+         const struct GNUNET_TRANSPORT_ATS_Information *ats,
+         uint32_t ats_count,
+         struct Session *session,
+         const char *sender_address, uint16_t sender_address_len)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Testcase recieved new message from peer `%s' with type %u and length %u, session %X\n",
-              GNUNET_i2s(peer),
-              ntohs(message->type),
-              ntohs(message->size),
-              session);
+              GNUNET_i2s (peer),
+              ntohs (message->type), ntohs (message->size), session);
 
-  if ( (ntohs(message->type)>=10) && 
-       (ntohs(message->type)<20) )
-    {
-      fail_msgs_transmited_to_local_addrs++;
-      if (fail_msgs_transmited_to_local_addrs == count_str_addr)
-        run_connection_tests(2, session);
-    }
-  if ((ntohs(message->type)==20))
-    {
-      fail_session_selection_reliable = GNUNET_NO;
-    }  
-  if ((ntohs(message->type)==21))
-    {
-      fail_session_selection_any = GNUNET_NO;
-    }
-  if ((ntohs(message->type)==22))
-    {
-      fail_session_selection_session = GNUNET_NO;
-    }  
-  if ((ntohs(message->type)==23))
-    {
-      fail_session_selection_session_big = GNUNET_NO;
-      run_connection_tests(3, NULL);
-    }  
-  if ((ntohs(message->type)==30) || (ntohs(message->type)==31))
-    {
-      fail_multiple_msgs_in_transmission ++;
-    }  
-  if ((ntohs(message->type)==32) && (ntohs(message->size) == GNUNET_SERVER_MAX_MESSAGE_SIZE-1))
-    {
-      fail_msg_transmited_max_size = GNUNET_NO;
-      shutdown_clean();
-    }  
+  if ((ntohs (message->type) >= 10) && (ntohs (message->type) < 20))
+  {
+    fail_msgs_transmited_to_local_addrs++;
+    if (fail_msgs_transmited_to_local_addrs == count_str_addr)
+      run_connection_tests (2, session);
+  }
+  if ((ntohs (message->type) == 20))
+  {
+    fail_session_selection_reliable = GNUNET_NO;
+  }
+  if ((ntohs (message->type) == 21))
+  {
+    fail_session_selection_any = GNUNET_NO;
+  }
+  if ((ntohs (message->type) == 22))
+  {
+    fail_session_selection_session = GNUNET_NO;
+  }
+  if ((ntohs (message->type) == 23))
+  {
+    fail_session_selection_session_big = GNUNET_NO;
+    run_connection_tests (3, NULL);
+  }
+  if ((ntohs (message->type) == 30) || (ntohs (message->type) == 31))
+  {
+    fail_multiple_msgs_in_transmission++;
+  }
+  if ((ntohs (message->type) == 32) &&
+      (ntohs (message->size) == GNUNET_SERVER_MAX_MESSAGE_SIZE - 1))
+  {
+    fail_msg_transmited_max_size = GNUNET_NO;
+    shutdown_clean ();
+  }
   return GNUNET_TIME_UNIT_ZERO;
 }
 
 
-static size_t 
+static size_t
 send_function (void *stream, size_t size, size_t nmemb, void *ptr)
 {
   unsigned int len;
 
   len = buffer_out.len;
 
-  if (( buffer_out.pos == len) || (len > (size * nmemb)))
+  if ((buffer_out.pos == len) || (len > (size * nmemb)))
     return 0;
-  memcpy(stream, buffer_out.buf, len);
+  memcpy (stream, buffer_out.buf, len);
   buffer_out.pos = len;
   return len;
 
 }
 
-static size_t 
+static size_t
 recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
 {
 
@@ -613,54 +608,50 @@ recv_function (void *ptr, size_t size, size_t nmemb, void *ctx)
 }
 
 static size_t
-header_function( void *ptr, size_t size, size_t nmemb, void *stream)
+header_function (void *ptr, size_t size, size_t nmemb, void *stream)
 {
-  struct HTTP_Transfer * res = stream;
-  char * tmp;
+  struct HTTP_Transfer *res = stream;
+  char *tmp;
   unsigned int len = size * nmemb;
 
-  tmp = GNUNET_malloc (  len+1 );
-  memcpy(tmp,ptr,len);
-  if (tmp[len-2] == 13)
-    tmp[len-2]= '\0';
+  tmp = GNUNET_malloc (len + 1);
+  memcpy (tmp, ptr, len);
+  if (tmp[len - 2] == 13)
+    tmp[len - 2] = '\0';
 #if DEBUG_CURL
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Header: `%s'\n",
-              tmp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Header: `%s'\n", tmp);
 #endif
-  if (0==strcmp (tmp,"HTTP/1.1 100 Continue"))
-    {
-      res->http_result_code=100;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 200 OK"))
-    {
-      res->http_result_code=200;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 400 Bad Request"))
-    {
-      res->http_result_code=400;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 404 Not Found"))
-    {
-      res->http_result_code=404;
-    }
-  if (0==strcmp (tmp,"HTTP/1.1 413 Request entity too large"))
-    {
-      res->http_result_code=413;
-    }
-  
+  if (0 == strcmp (tmp, "HTTP/1.1 100 Continue"))
+  {
+    res->http_result_code = 100;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 200 OK"))
+  {
+    res->http_result_code = 200;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 400 Bad Request"))
+  {
+    res->http_result_code = 400;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 404 Not Found"))
+  {
+    res->http_result_code = 404;
+  }
+  if (0 == strcmp (tmp, "HTTP/1.1 413 Request entity too large"))
+  {
+    res->http_result_code = 413;
+  }
+
   GNUNET_free (tmp);
   return size * nmemb;
 }
 
 
-static size_t 
-send_prepare( struct HTTP_Transfer * result);
+static size_t send_prepare (struct HTTP_Transfer *result);
 
 
-static void 
-send_execute (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+send_execute (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct HTTP_Transfer *res;
 
@@ -674,104 +665,106 @@ send_execute (void *cls,
     return;
 
   do
+  {
+    running = 0;
+    mret = curl_multi_perform (multi_handle, &running);
+    if (running == 0)
     {
-      running = 0;
-      mret = curl_multi_perform (multi_handle, &running);
-      if (running == 0)
-        {
-          do
-            {
+      do
+      {
 
-              msg = curl_multi_info_read (multi_handle, &running);
-              if (msg == NULL)
-                break;
-              /* get session for affected curl handle */
-              //cs = find_session_by_curlhandle (msg->easy_handle);
-              //GNUNET_assert ( cs != NULL );
-              switch (msg->msg)
-                {
-
-                case CURLMSG_DONE:
-                  if ( (msg->data.result != CURLE_OK) &&
-                       (msg->data.result != CURLE_GOT_NOTHING) )
-                    {
-
-                    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                               _("curl failed for `%s' at %s:%d: `%s'\n"),
-                               "curl_multi_perform",
-                               __FILE__,
-                               __LINE__,
-                               curl_easy_strerror (msg->data.result));
-                    /* sending msg failed*/
-                    curl_easy_cleanup(curl_handle);
-                    curl_handle=NULL;
-
-                    run_connection_tests(0, NULL);
-                    }
-                  if (res == &test_no_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                      {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer without any peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  _("Connecting to peer without any peer identification: test failed\n"));
-                  }
-                  if (res == &test_too_short_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer with too short peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  _("Connecting to peer with too short peer identification: test failed\n"));
-                  }
-                  if (res == &test_too_long_ident)
-                  {
-                    if  ((res->http_result_code==404) && (buffer_in.len==208))
-                      {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer with too long peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                      }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  _("Connecting to peer with too long peer identification: test failed\n"));
-                  }
-                  if (res == &test_valid_ident)
-                  {
-                    if  ((res->http_result_code==200))
-                    {
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Connecting to peer with valid peer identification: test passed\n");
-                      res->test_failed = GNUNET_NO;
-                    }
-                    else
-                      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  "Connecting to peer with valid peer identification: test failed\n");
-                  }
-                  curl_easy_cleanup(curl_handle);
-                  curl_handle=NULL;
-                  if ((res == &test_valid_ident) && (res->test_failed == GNUNET_NO))
-                    run_connection_tests(1, NULL);
-                  run_connection_tests(0, NULL);
-                  return;
-                default:
-                  break;
-                }
+        msg = curl_multi_info_read (multi_handle, &running);
+        if (msg == NULL)
+          break;
+        /* get session for affected curl handle */
+        //cs = find_session_by_curlhandle (msg->easy_handle);
+        //GNUNET_assert ( cs != NULL );
+        switch (msg->msg)
+        {
 
+        case CURLMSG_DONE:
+          if ((msg->data.result != CURLE_OK) &&
+              (msg->data.result != CURLE_GOT_NOTHING))
+          {
+
+            GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                        _("curl failed for `%s' at %s:%d: `%s'\n"),
+                        "curl_multi_perform",
+                        __FILE__,
+                        __LINE__, curl_easy_strerror (msg->data.result));
+            /* sending msg failed */
+            curl_easy_cleanup (curl_handle);
+            curl_handle = NULL;
+
+            run_connection_tests (0, NULL);
+          }
+          if (res == &test_no_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer without any peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer without any peer identification: test failed\n"));
+          }
+          if (res == &test_too_short_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer with too short peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with too short peer identification: test failed\n"));
+          }
+          if (res == &test_too_long_ident)
+          {
+            if ((res->http_result_code == 404) && (buffer_in.len == 208))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer with too long peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
             }
-          while ( (running > 0) );
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Connecting to peer with too long peer identification: test failed\n"));
+          }
+          if (res == &test_valid_ident)
+          {
+            if ((res->http_result_code == 200))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Connecting to peer with valid peer identification: test passed\n");
+              res->test_failed = GNUNET_NO;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          "Connecting to peer with valid peer identification: test failed\n");
+          }
+          curl_easy_cleanup (curl_handle);
+          curl_handle = NULL;
+          if ((res == &test_valid_ident) && (res->test_failed == GNUNET_NO))
+            run_connection_tests (1, NULL);
+          run_connection_tests (0, NULL);
+          return;
+        default:
+          break;
         }
+
+      }
+      while ((running > 0));
     }
+  }
   while (mret == CURLM_CALL_MULTI_PERFORM);
-  send_prepare(cls);
+  send_prepare (cls);
 }
 
 
@@ -781,7 +774,7 @@ send_execute (void *cls,
  * @return bytes sent to peer
  */
 static size_t
-send_prepare( struct HTTP_Transfer * result)
+send_prepare (struct HTTP_Transfer *result)
 {
   fd_set rs;
   fd_set ws;
@@ -798,34 +791,33 @@ send_prepare( struct HTTP_Transfer * result)
   FD_ZERO (&es);
   mret = curl_multi_fdset (multi_handle, &rs, &ws, &es, &max);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_fdset", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return -1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_fdset", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return -1;
+  }
   mret = curl_multi_timeout (multi_handle, &to);
   if (mret != CURLM_OK)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("%s failed at %s:%d: `%s'\n"),
-                  "curl_multi_timeout", __FILE__, __LINE__,
-                  curl_multi_strerror (mret));
-      return -1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("%s failed at %s:%d: `%s'\n"),
+                "curl_multi_timeout", __FILE__, __LINE__,
+                curl_multi_strerror (mret));
+    return -1;
+  }
 
   grs = GNUNET_NETWORK_fdset_create ();
   gws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
   GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
-  http_task_send = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                                GNUNET_SCHEDULER_NO_TASK,
-                                                GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 0),
-                                                grs,
-                                                gws,
-                                                &send_execute,
-                                                result);
+  http_task_send =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_relative_multiply
+                                   (GNUNET_TIME_UNIT_SECONDS, 0), grs, gws,
+                                   &send_execute, result);
   GNUNET_NETWORK_fdset_destroy (gws);
   GNUNET_NETWORK_fdset_destroy (grs);
 
@@ -836,35 +828,35 @@ send_prepare( struct HTTP_Transfer * result)
 /**
  * function to send data to server
  */
-static int 
-send_data(struct HTTP_Transfer * result,
-          char * url)
+static int
+send_data (struct HTTP_Transfer *result, char *url)
 {
 
-  curl_handle = curl_easy_init();
-  if( NULL == curl_handle)
-    {
-      printf("easy_init failed \n");
-      return GNUNET_SYSERR;
-    }
+  curl_handle = curl_easy_init ();
+  if (NULL == curl_handle)
+  {
+    printf ("easy_init failed \n");
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_CURL
-  curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt (curl_handle, CURLOPT_VERBOSE, 1L);
 #endif
-  curl_easy_setopt(curl_handle, CURLOPT_URL, url);
-  curl_easy_setopt(curl_handle, CURLOPT_PUT, 1L);
+  curl_easy_setopt (curl_handle, CURLOPT_URL, url);
+  curl_easy_setopt (curl_handle, CURLOPT_PUT, 1L);
   curl_easy_setopt (curl_handle, CURLOPT_HEADERFUNCTION, &header_function);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEHEADER, result);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEFUNCTION, &recv_function);
   curl_easy_setopt (curl_handle, CURLOPT_WRITEDATA, result);
   curl_easy_setopt (curl_handle, CURLOPT_READFUNCTION, &send_function);
   curl_easy_setopt (curl_handle, CURLOPT_READDATA, result);
-  curl_easy_setopt(curl_handle, CURLOPT_INFILESIZE_LARGE, (curl_off_t) buffer_out.len);
-  curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 30);
-  curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 20);
+  curl_easy_setopt (curl_handle, CURLOPT_INFILESIZE_LARGE,
+                    (curl_off_t) buffer_out.len);
+  curl_easy_setopt (curl_handle, CURLOPT_TIMEOUT, 30);
+  curl_easy_setopt (curl_handle, CURLOPT_CONNECTTIMEOUT, 20);
 
-  curl_multi_add_handle(multi_handle, curl_handle);
+  curl_multi_add_handle (multi_handle, curl_handle);
 
-  send_prepare(result);
+  send_prepare (result);
 
   return GNUNET_OK;
 }
@@ -873,58 +865,54 @@ send_data(struct HTTP_Transfer * result,
  * Plugin notifies transport (aka testcase) about its addresses
  */
 static void
-notify_address (void *cls,
-                int add_remove,
-                const void *addr,
-                size_t addrlen)
+notify_address (void *cls, int add_remove, const void *addr, size_t addrlen)
 {
   char address[INET6_ADDRSTRLEN];
   unsigned int port;
-  struct Plugin_Address * pl_addr;
-  struct Plugin_Address * cur;
+  struct Plugin_Address *pl_addr;
+  struct Plugin_Address *cur;
 
   if (addrlen == (sizeof (struct IPv4HttpAddress)))
-    {
-      inet_ntop(AF_INET, (struct in_addr *) addr,address,INET_ADDRSTRLEN);
-      port = ntohs(((struct IPv4HttpAddress *) addr)->u_port);
-    }
+  {
+    inet_ntop (AF_INET, (struct in_addr *) addr, address, INET_ADDRSTRLEN);
+    port = ntohs (((struct IPv4HttpAddress *) addr)->u_port);
+  }
   else if (addrlen == (sizeof (struct IPv6HttpAddress)))
-    {
-      inet_ntop(AF_INET6, (struct in6_addr *) addr,address,INET6_ADDRSTRLEN);
-      port = ntohs(((struct IPv6HttpAddress *) addr)->u6_port);
-    }
+  {
+    inet_ntop (AF_INET6, (struct in6_addr *) addr, address, INET6_ADDRSTRLEN);
+    port = ntohs (((struct IPv6HttpAddress *) addr)->u6_port);
+  }
   else
-    {
+  {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _("Unknown address size: ipv6 has %u ipv4 has %u but this has %u\n"),
+                _
+                ("Unknown address size: ipv6 has %u ipv4 has %u but this has %u\n"),
                 sizeof (struct IPv6HttpAddress),
-                sizeof (struct IPv4HttpAddress),
-                addrlen);
-      return;
-    }
+                sizeof (struct IPv4HttpAddress), addrlen);
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _("Transport plugin notification for address: `%s':%u\n"),
-              address,
-              port);
-  pl_addr = GNUNET_malloc (sizeof (struct Plugin_Address) );
+              address, port);
+  pl_addr = GNUNET_malloc (sizeof (struct Plugin_Address));
   pl_addr->addrlen = addrlen;
-  pl_addr->addr = GNUNET_malloc(addrlen);
-  memcpy(pl_addr->addr,addr,addrlen);
+  pl_addr->addr = GNUNET_malloc (addrlen);
+  memcpy (pl_addr->addr, addr, addrlen);
   pl_addr->next = NULL;
 
-  if ( NULL == addr_head)
-    {
-      addr_head = pl_addr;
-    }
+  if (NULL == addr_head)
+  {
+    addr_head = pl_addr;
+  }
   else
+  {
+    cur = addr_head;
+    while (NULL != cur->next)
     {
-      cur = addr_head;
-      while (NULL != cur->next)
-        {
-          cur = cur->next;
-        }
-      cur->next = pl_addr;
+      cur = cur->next;
     }
+    cur->next = pl_addr;
+  }
   fail_notify_address_count++;
   fail_notify_address = GNUNET_NO;
 }
@@ -936,8 +924,7 @@ plugin_env_session_end (void *cls,
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Pluging tells me: session %X to peer `%s' ended\n",
-              session,
-              GNUNET_i2s(peer));
+              session, GNUNET_i2s (peer));
 }
 
 
@@ -962,8 +949,7 @@ setup_plugin_environment ()
  * Task shutting down testcase if it a timeout occurs
  */
 static void
-task_timeout (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ti_timeout = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
@@ -971,35 +957,34 @@ task_timeout (void *cls,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testcase timeout\n");
   fail = GNUNET_YES;
-  shutdown_clean();
+  shutdown_clean ();
   return;
 }
 
 
-static void 
-pretty_printer_cb (void *cls,
-                   const char *address)
+static void
+pretty_printer_cb (void *cls, const char *address)
 {
-  if (NULL==address)
+  if (NULL == address)
     return;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Plugin returned pretty address: `%s'\n",
-              address);
+              "Plugin returned pretty address: `%s'\n", address);
   fail_pretty_printer_count++;
 }
 
 /**
  * Runs every single test to test the plugin
  */
-static void 
-run_connection_tests( int phase , void * cls)
+static void
+run_connection_tests (int phase, void *cls)
 {
-  struct GNUNET_MessageHeader * msg;
+  struct GNUNET_MessageHeader *msg;
   unsigned int size;
 
-  if (phase==0)
+  if (phase == 0)
   {
-    char * host_str = NULL;
+    char *host_str = NULL;
+
     /* resetting buffers */
     buffer_in.size = HTTP_BUFFER_SIZE;
     buffer_in.pos = 0;
@@ -1010,217 +995,210 @@ run_connection_tests( int phase , void * cls)
     buffer_out.len = 0;
 
     if (test_no_ident.test_executed == GNUNET_NO)
-      {
-        /* Connecting to peer without identification */
-        const char * ident = "";
-        GNUNET_asprintf (&host_str,
-                         "%s://%s/%s",
-                         PROTOCOL_PREFIX,
-                         test_addr,ident);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer without any peer identification.\n"));
-        test_no_ident.test_executed = GNUNET_YES;
-        send_data ( &test_no_ident, host_str);
-        GNUNET_free (host_str);
-        return;
-      }
+    {
+      /* Connecting to peer without identification */
+      const char *ident = "";
+
+      GNUNET_asprintf (&host_str,
+                       "%s://%s/%s", PROTOCOL_PREFIX, test_addr, ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Connecting to peer without any peer identification.\n"));
+      test_no_ident.test_executed = GNUNET_YES;
+      send_data (&test_no_ident, host_str);
+      GNUNET_free (host_str);
+      return;
+    }
     if (test_too_short_ident.test_executed == GNUNET_NO)
-      {
-        const char * ident = "AAAAAAAAAA";
-        /* Connecting to peer with too short identification */
-        GNUNET_asprintf (&host_str,
-                         "%s://%s/%s",
-                         PROTOCOL_PREFIX,
-                         test_addr,
-                         ident);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer with too short peer identification.\n"));
-        test_too_short_ident.test_executed = GNUNET_YES;
-        send_data ( &test_too_short_ident, host_str);
-        GNUNET_free (host_str);
-        return;
-      }
+    {
+      const char *ident = "AAAAAAAAAA";
+
+      /* Connecting to peer with too short identification */
+      GNUNET_asprintf (&host_str,
+                       "%s://%s/%s", PROTOCOL_PREFIX, test_addr, ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _
+                  ("Connecting to peer with too short peer identification.\n"));
+      test_too_short_ident.test_executed = GNUNET_YES;
+      send_data (&test_too_short_ident, host_str);
+      GNUNET_free (host_str);
+      return;
+    }
 
     if (test_too_long_ident.test_executed == GNUNET_NO)
-      {
-        const char * ident = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+    {
+      const char *ident =
+          "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 
-        /* Connecting to peer with too long identification */
-        GNUNET_asprintf (&host_str, "%s://%s/%s",PROTOCOL_PREFIX, test_addr,ident);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer with too long peer identification.\n"));
-        test_too_long_ident.test_executed = GNUNET_YES;
-        send_data ( &test_too_long_ident, host_str);
-        GNUNET_free (host_str);
-        return;
+      /* Connecting to peer with too long identification */
+      GNUNET_asprintf (&host_str, "%s://%s/%s", PROTOCOL_PREFIX, test_addr,
+                       ident);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Connecting to peer with too long peer identification.\n"));
+      test_too_long_ident.test_executed = GNUNET_YES;
+      send_data (&test_too_long_ident, host_str);
+      GNUNET_free (host_str);
+      return;
     }
     if (test_valid_ident.test_executed == GNUNET_NO)
-      {
-        struct GNUNET_CRYPTO_HashAsciiEncoded ident;
-        GNUNET_CRYPTO_hash_to_enc(&my_identity.hashPubKey,&ident);
-        GNUNET_asprintf (&host_str,
-                         "%s://%s/%s%s",
-                         PROTOCOL_PREFIX,
-                         test_addr,
-                         (char *) &ident,
-                         ";0");
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    _("Connecting to peer with valid peer identification.\n"));
-        test_valid_ident.test_executed = GNUNET_YES;
-        send_data ( &test_valid_ident, host_str);
-        GNUNET_free (host_str);
-        return;
-      }
-  }
-  if (phase==1)
     {
+      struct GNUNET_CRYPTO_HashAsciiEncoded ident;
+
+      GNUNET_CRYPTO_hash_to_enc (&my_identity.hashPubKey, &ident);
+      GNUNET_asprintf (&host_str,
+                       "%s://%s/%s%s",
+                       PROTOCOL_PREFIX, test_addr, (char *) &ident, ";0");
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "\nPhase 1: transmit data to all suggested addresses\n\n");
-      /* Using one of the addresses the plugin proposed */
-      GNUNET_assert (addr_head->addr != NULL);
-      
-      struct Plugin_Address * tmp_addr;
-      struct GNUNET_MessageHeader msg;
-      char * tmp = GNUNET_malloc(sizeof(struct GNUNET_MessageHeader));
-      char address[INET6_ADDRSTRLEN];
-      unsigned int port;
-      unsigned int type = 10;
-      
-      msg.size=htons(sizeof(struct GNUNET_MessageHeader));
-      tmp_addr = addr_head;
-      /* send a message to all addresses advertised by plugin */
-      
-      int count = 0;
-      while (tmp_addr != NULL)
-        {
-          if (tmp_addr->addrlen == (sizeof (struct IPv4HttpAddress)))
-            {
-              inet_ntop(AF_INET, (struct in_addr *) tmp_addr->addr,address,INET_ADDRSTRLEN);
-              port = ntohs(((struct IPv4HttpAddress *) tmp_addr->addr)->u_port);
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Sending message to addres no. %u: `%s':%u\n",
-                          count,
-                          address,
-                          port);
-            }
-          if (tmp_addr->addrlen == (sizeof (struct IPv6HttpAddress)))
-            {
-              inet_ntop(AF_INET6, (struct in6_addr *) tmp_addr->addr,address,INET6_ADDRSTRLEN);
-              port = ntohs(((struct IPv6HttpAddress *) tmp_addr->addr)->u6_port);
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Sending message to addres no. %u: `%s':%u\n",
-                          count,
-                          address,
-                          port);
-            }
-          msg.type=htons(type);
-          memcpy(tmp,&msg,sizeof(struct GNUNET_MessageHeader));
-          api->send(api->cls,
-                    &my_identity,
-                    tmp, sizeof(struct GNUNET_MessageHeader),
-                    0, TIMEOUT,
-                    NULL,
-                    tmp_addr->addr, tmp_addr->addrlen,
-                    GNUNET_YES,
-                    &task_send_cont, &fail_msgs_transmited_to_local_addrs);
-          tmp_addr = tmp_addr->next;
-          count++;
-          type++;
-        }
-      GNUNET_free(tmp);
+                  _("Connecting to peer with valid peer identification.\n"));
+      test_valid_ident.test_executed = GNUNET_YES;
+      send_data (&test_valid_ident, host_str);
+      GNUNET_free (host_str);
       return;
     }
+  }
+  if (phase == 1)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "\nPhase 1: transmit data to all suggested addresses\n\n");
+    /* Using one of the addresses the plugin proposed */
+    GNUNET_assert (addr_head->addr != NULL);
+
+    struct Plugin_Address *tmp_addr;
+    struct GNUNET_MessageHeader msg;
+    char *tmp = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
+    char address[INET6_ADDRSTRLEN];
+    unsigned int port;
+    unsigned int type = 10;
+
+    msg.size = htons (sizeof (struct GNUNET_MessageHeader));
+    tmp_addr = addr_head;
+    /* send a message to all addresses advertised by plugin */
 
-  if (phase==2)
+    int count = 0;
+
+    while (tmp_addr != NULL)
     {
-      struct Session * session = cls;
-      msg = GNUNET_malloc (sizeof(struct GNUNET_MessageHeader));
-      
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Phase 2: session selection\n\n");
-      size = sizeof(struct GNUNET_MessageHeader);
-      msg->size=htons(size);
-      msg->type = htons(20);
-      api->send(api->cls, 
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, NULL, NULL, 0, GNUNET_NO,
-                &task_send_cont, NULL);
-      
-      msg->type = htons(21);
-      api->send(api->cls, 
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, NULL, NULL, 0, GNUNET_SYSERR,
-                &task_send_cont, NULL);
-      
-      /* answer on session*/
-      size = sizeof( struct GNUNET_MessageHeader);
-      msg->size = htons(size);
-      msg->type = htons(22);
-      api->send(api->cls, 
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, session, NULL, 0, GNUNET_SYSERR,
-                &task_send_cont, NULL);
-      GNUNET_free(msg);
-      
-      /* answer on session with big message not fitting in mhd send buffer*/
-      size = GNUNET_SERVER_MAX_MESSAGE_SIZE-1;
-      msg = GNUNET_malloc (size);
-      msg->size=htons(size);
-      msg->type = htons(23);
-      api->send(api->cls,
-                &my_identity,
-                (const char *) msg, size,
-                0, TIMEOUT, session, NULL, 0, GNUNET_NO,
-                &task_send_cont, NULL);
-      GNUNET_free(msg);
-      return;
+      if (tmp_addr->addrlen == (sizeof (struct IPv4HttpAddress)))
+      {
+        inet_ntop (AF_INET, (struct in_addr *) tmp_addr->addr, address,
+                   INET_ADDRSTRLEN);
+        port = ntohs (((struct IPv4HttpAddress *) tmp_addr->addr)->u_port);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Sending message to addres no. %u: `%s':%u\n",
+                    count, address, port);
+      }
+      if (tmp_addr->addrlen == (sizeof (struct IPv6HttpAddress)))
+      {
+        inet_ntop (AF_INET6, (struct in6_addr *) tmp_addr->addr, address,
+                   INET6_ADDRSTRLEN);
+        port = ntohs (((struct IPv6HttpAddress *) tmp_addr->addr)->u6_port);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Sending message to addres no. %u: `%s':%u\n",
+                    count, address, port);
+      }
+      msg.type = htons (type);
+      memcpy (tmp, &msg, sizeof (struct GNUNET_MessageHeader));
+      api->send (api->cls,
+                 &my_identity,
+                 tmp, sizeof (struct GNUNET_MessageHeader),
+                 0, TIMEOUT,
+                 NULL,
+                 tmp_addr->addr, tmp_addr->addrlen,
+                 GNUNET_YES,
+                 &task_send_cont, &fail_msgs_transmited_to_local_addrs);
+      tmp_addr = tmp_addr->next;
+      count++;
+      type++;
     }
-  
-  if (phase==3)
-    {
-      
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+    GNUNET_free (tmp);
+    return;
+  }
+
+  if (phase == 2)
+  {
+    struct Session *session = cls;
+
+    msg = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Phase 2: session selection\n\n");
+    size = sizeof (struct GNUNET_MessageHeader);
+    msg->size = htons (size);
+    msg->type = htons (20);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, NULL, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
+
+    msg->type = htons (21);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, NULL, NULL, 0, GNUNET_SYSERR, &task_send_cont, NULL);
+
+    /* answer on session */
+    size = sizeof (struct GNUNET_MessageHeader);
+    msg->size = htons (size);
+    msg->type = htons (22);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, session, NULL, 0, GNUNET_SYSERR,
+               &task_send_cont, NULL);
+    GNUNET_free (msg);
+
+    /* answer on session with big message not fitting in mhd send buffer */
+    size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
+    msg = GNUNET_malloc (size);
+    msg->size = htons (size);
+    msg->type = htons (23);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, session, NULL, 0, GNUNET_NO, &task_send_cont, NULL);
+    GNUNET_free (msg);
+    return;
+  }
+
+  if (phase == 3)
+  {
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Phase 3: send multiple or big messages after disconnect\n\n");
     /* disconnect from peer, so new connections are created */
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Disconnect from peer: `%s'\n", GNUNET_i2s(&my_identity));
-    api->disconnect(api->cls, &my_identity);
-    
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect from peer: `%s'\n",
+                GNUNET_i2s (&my_identity));
+    api->disconnect (api->cls, &my_identity);
+
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Phase 3: sending messages\n");
-    /* send a multiple GNUNET_messages at a time*/
-    size = 2 * sizeof(struct GNUNET_MessageHeader);
-    msg = GNUNET_malloc( 2* size);
-    msg->size = htons(size);
-    msg->type = htons(30);
-    struct GNUNET_MessageHeader * msg2 = &msg[2];
-    msg2->size = htons(2 * sizeof(struct GNUNET_MessageHeader));
-    msg2->type = htons(31);
-    api->send(api->cls,
-              &my_identity,
-              (const char *) msg, 4 * sizeof(struct GNUNET_MessageHeader),
-              0, TIMEOUT, NULL,
-              addr_head->addr, addr_head->addrlen,
-              GNUNET_NO,
-              &task_send_cont, &fail_multiple_msgs_in_transmission);
-    GNUNET_free(msg);
+    /* send a multiple GNUNET_messages at a time */
+    size = 2 * sizeof (struct GNUNET_MessageHeader);
+    msg = GNUNET_malloc (2 * size);
+    msg->size = htons (size);
+    msg->type = htons (30);
+    struct GNUNET_MessageHeader *msg2 = &msg[2];
+
+    msg2->size = htons (2 * sizeof (struct GNUNET_MessageHeader));
+    msg2->type = htons (31);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, 4 * sizeof (struct GNUNET_MessageHeader),
+               0, TIMEOUT, NULL,
+               addr_head->addr, addr_head->addrlen,
+               GNUNET_NO, &task_send_cont, &fail_multiple_msgs_in_transmission);
+    GNUNET_free (msg);
     /* send a message with size GNUNET_SERVER_MAX_MESSAGE_SIZE-1  */
 
-    size = GNUNET_SERVER_MAX_MESSAGE_SIZE-1;
-    msg = GNUNET_malloc(size);
-    msg->size = htons(size);
-    msg->type = htons(32);
-    api->send(api->cls,
-              &my_identity,
-              (const char *) msg, size,
-              0, TIMEOUT, NULL,
-              addr_head->addr, addr_head->addrlen,
-              GNUNET_NO,
-              &task_send_cont, &fail_msg_transmited_max_size);
-    GNUNET_free(msg);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "No more tests to run\n");
+    size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
+    msg = GNUNET_malloc (size);
+    msg->size = htons (size);
+    msg->type = htons (32);
+    api->send (api->cls,
+               &my_identity,
+               (const char *) msg, size,
+               0, TIMEOUT, NULL,
+               addr_head->addr, addr_head->addrlen,
+               GNUNET_NO, &task_send_cont, &fail_msg_transmited_max_size);
+    GNUNET_free (msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No more tests to run\n");
   }
 }
 
@@ -1236,12 +1214,13 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  char * libname;
+  char *libname;
+
   cfg = c;
   char *keyfile;
   unsigned long long tneigh;
-  struct Plugin_Address * cur;
-  const char * addr_str;
+  struct Plugin_Address *cur;
+  const char *addr_str;
 
 
   unsigned int suggest_res;
@@ -1260,8 +1239,9 @@ run (void *cls,
   addr_head = NULL;
   count_str_addr = 0;
   /* parse configuration */
-  if (GNUNET_CONFIGURATION_have_value (c,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (c, "PATHS", "SERVICEHOME", &servicehome);
+  if (GNUNET_CONFIGURATION_have_value (c, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (c, "PATHS", "SERVICEHOME",
+                                           &servicehome);
 
   if ((GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_number (c,
@@ -1272,20 +1252,21 @@ run (void *cls,
        GNUNET_CONFIGURATION_get_value_filename (c,
                                                 "GNUNETD",
                                                 "HOSTKEY", &keyfile)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      fail = 1;
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Transport service is lacking key configuration settings.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    fail = 1;
+    return;
+  }
 
   if ((GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (cfg,
-                                             "transport-http",
-                                             "PORT",
-                                             &port)) ||
-     (port > 65535) || (port == 0))
+       GNUNET_CONFIGURATION_get_value_number (cfg,
+                                              "transport-http",
+                                              "PORT",
+                                              &port)) ||
+      (port > 65535) || (port == 0))
   {
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                      "http",
@@ -1298,16 +1279,17 @@ run (void *cls,
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Transport service could not access hostkey.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      fail = 1;
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    fail = 1;
+    return;
+  }
 
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
-  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_identity.hashPubKey);
+  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
+                      &my_identity.hashPubKey);
 
   /* assertions before start */
   GNUNET_assert ((port > 0) && (port <= 65535));
@@ -1315,9 +1297,8 @@ run (void *cls,
   /* load plugins... */
   setup_plugin_environment ();
   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_http");
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              _("Loading HTTP transport plugin `%s'\n"),
-              libname);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Loading HTTP transport plugin `%s'\n"), libname);
   api = GNUNET_PLUGIN_load (libname, &env);
   GNUNET_free (libname);
   if (api == NULL)
@@ -1332,49 +1313,51 @@ run (void *cls,
   ti_timeout = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &task_timeout, NULL);
 
   /* testing plugin functionality */
-  GNUNET_assert (0!=fail_notify_address_count);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+  GNUNET_assert (0 != fail_notify_address_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transport plugin returned %u addresses to connect to\n",
               fail_notify_address_count);
 
-  /* testing pretty printer with all addresses obtained from the plugin*/
+  /* testing pretty printer with all addresses obtained from the plugin */
   cur = addr_head;
   while (cur != NULL)
   {
     api->address_pretty_printer (api->cls, "http",
-                                 cur->addr,cur->addrlen, GNUNET_NO,TEST_TIMEOUT,
-                                 &pretty_printer_cb, NULL);
+                                 cur->addr, cur->addrlen, GNUNET_NO,
+                                 TEST_TIMEOUT, &pretty_printer_cb, NULL);
     addr_str = api->address_to_string (api->cls, cur->addr, cur->addrlen);
     suggest_res = api->check_address (api->cls, cur->addr, cur->addrlen);
 
     GNUNET_assert (GNUNET_OK == suggest_res);
     GNUNET_assert (NULL != addr_str);
     count_str_addr++;
-    GNUNET_free ( (char *) addr_str);
+    GNUNET_free ((char *) addr_str);
     cur = cur->next;
   }
   GNUNET_assert (fail_pretty_printer_count > 0);
-  GNUNET_assert (fail_pretty_printer_count==fail_notify_address_count);
-  GNUNET_assert (fail_pretty_printer_count==count_str_addr);
-  fail_pretty_printer=GNUNET_NO;
-  fail_addr_to_str=GNUNET_NO;
+  GNUNET_assert (fail_pretty_printer_count == fail_notify_address_count);
+  GNUNET_assert (fail_pretty_printer_count == count_str_addr);
+  fail_pretty_printer = GNUNET_NO;
+  fail_addr_to_str = GNUNET_NO;
 
   struct IPv4HttpAddress failing_addr;
 
-  /* Suggesting addresses with wrong size*/
-  failing_addr.ipv4_addr = htonl(INADDR_LOOPBACK);
-  failing_addr.u_port = htons(0);
-  suggest_res = api->check_address (api->cls,&failing_addr,sizeof (struct IPv6HttpAddress));
+  /* Suggesting addresses with wrong size */
+  failing_addr.ipv4_addr = htonl (INADDR_LOOPBACK);
+  failing_addr.u_port = htons (0);
+  suggest_res =
+      api->check_address (api->cls, &failing_addr,
+                          sizeof (struct IPv6HttpAddress));
   GNUNET_assert (GNUNET_SYSERR == suggest_res);
 
-  /* Suggesting addresses with wrong address*/
-  failing_addr.ipv4_addr = htonl(0xffc00000);
-  failing_addr.u_port = htons(12389);
-  suggest_res = api->check_address (api->cls,&failing_addr,100);
+  /* Suggesting addresses with wrong address */
+  failing_addr.ipv4_addr = htonl (0xffc00000);
+  failing_addr.u_port = htons (12389);
+  suggest_res = api->check_address (api->cls, &failing_addr, 100);
   GNUNET_assert (GNUNET_SYSERR == suggest_res);
 
   /* test sending to client */
-  multi_handle = curl_multi_init();
+  multi_handle = curl_multi_init ();
 
   /* Setting up buffers */
   buffer_in.size = HTTP_BUFFER_SIZE;
@@ -1403,10 +1386,12 @@ run (void *cls,
   test_valid_ident.test_executed = GNUNET_NO;
   test_valid_ident.test_failed = GNUNET_YES;
 
-  test_addr = (char *) api->address_to_string (api->cls,addr_head->addr,addr_head->addrlen);
+  test_addr =
+      (char *) api->address_to_string (api->cls, addr_head->addr,
+                                       addr_head->addrlen);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Phase 0\n\n"));
-  run_connection_tests(0, NULL);
+  run_connection_tests (0, NULL);
   /* testing finished */
 }
 
@@ -1425,6 +1410,7 @@ main (int argc, char *const *argv)
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
+
   char *const argv_prog[] = {
     "test_gnunet_transport_plugin_http",
     "-c",
@@ -1446,11 +1432,15 @@ main (int argc, char *const *argv)
                     NULL);
 
   struct GNUNET_CONFIGURATION_Handle *cfg;
+
   cfg = GNUNET_CONFIGURATION_create ();
 
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, "test_plugin_transport_data_http.conf"));
-  if (GNUNET_CONFIGURATION_have_value (cfg,"PATHS", "SERVICEHOME"))
-      GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME", &servicehome);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (cfg,
+                                            "test_plugin_transport_data_http.conf"));
+  if (GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "SERVICEHOME"))
+    GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME",
+                                           &servicehome);
   GNUNET_DISK_directory_remove (servicehome);
   GNUNET_CONFIGURATION_destroy (cfg);
 
@@ -1458,7 +1448,8 @@ main (int argc, char *const *argv)
          GNUNET_PROGRAM_run (5,
                              argv_prog,
                              "test_gnunet_transport_plugin_http",
-                             "testcase", options, &run, NULL)) ? GNUNET_NO : GNUNET_YES;
+                             "testcase", options, &run,
+                             NULL)) ? GNUNET_NO : GNUNET_YES;
 
   if (servicehome != NULL)
   {