1 files changed, 342 insertions, 343 deletions

diff --git a/src/cadet/gnunet-cadet.c b/src/cadet/gnunet-cadet.c
index f5cf86211..d85a3c6ba 100644
--- a/src/cadet/gnunet-cadet.c
+++ b/src/cadet/gnunet-cadet.c
@@ -143,7 +143,7 @@ static unsigned int sent_pkt;
  * Wait for input on STDIO and send it out over the #ch.
  */
 static void
-listen_stdio(void);
+listen_stdio (void);
 
 
 /**
@@ -154,25 +154,25 @@ listen_stdio(void);
  * @return Human readable string.
  */
 static const char *
-enc_2s(uint16_t status)
+enc_2s (uint16_t status)
 {
   switch (status)
-    {
-    case 0:
-      return "NULL ";
+  {
+  case 0:
+    return "NULL ";
 
-    case 1:
-      return "KSENT";
+  case 1:
+    return "KSENT";
 
-    case 2:
-      return "KRECV";
+  case 2:
+    return "KRECV";
 
-    case 3:
-      return "READY";
+  case 3:
+    return "READY";
 
-    default:
-      return "";
-    }
+  default:
+    return "";
+  }
 }
 
 
@@ -184,28 +184,28 @@ enc_2s(uint16_t status)
  * @return Human readable string.
  */
 static const char *
-conn_2s(uint16_t status)
+conn_2s (uint16_t status)
 {
   switch (status)
-    {
-    case 0:
-      return "NEW  ";
+  {
+  case 0:
+    return "NEW  ";
 
-    case 1:
-      return "SRCH ";
+  case 1:
+    return "SRCH ";
 
-    case 2:
-      return "WAIT ";
+  case 2:
+    return "WAIT ";
 
-    case 3:
-      return "READY";
+  case 3:
+    return "READY";
 
-    case 4:
-      return "SHUTD";
+  case 4:
+    return "SHUTD";
 
-    default:
-      return "";
-    }
+  default:
+    return "";
+  }
 }
 
 
@@ -215,60 +215,60 @@ conn_2s(uint16_t status)
  * @param cls Closure (unused).
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n");
   if (NULL != lp)
-    {
-      GNUNET_CADET_close_port(lp);
-      lp = NULL;
-    }
+  {
+    GNUNET_CADET_close_port (lp);
+    lp = NULL;
+  }
   if (NULL != ch)
-    {
-      GNUNET_CADET_channel_destroy(ch);
-      ch = NULL;
-    }
+  {
+    GNUNET_CADET_channel_destroy (ch);
+    ch = NULL;
+  }
   if (NULL != gpo)
-    {
-      GNUNET_CADET_get_path_cancel(gpo);
-      gpo = NULL;
-    }
+  {
+    GNUNET_CADET_get_path_cancel (gpo);
+    gpo = NULL;
+  }
   if (NULL != plo)
-    {
-      GNUNET_CADET_list_peers_cancel(plo);
-      plo = NULL;
-    }
+  {
+    GNUNET_CADET_list_peers_cancel (plo);
+    plo = NULL;
+  }
   if (NULL != tio)
-    {
-      GNUNET_CADET_list_tunnels_cancel(tio);
-      tio = NULL;
-    }
+  {
+    GNUNET_CADET_list_tunnels_cancel (tio);
+    tio = NULL;
+  }
   if (NULL != mh)
-    {
-      GNUNET_CADET_disconnect(mh);
-      mh = NULL;
-    }
+  {
+    GNUNET_CADET_disconnect (mh);
+    mh = NULL;
+  }
   if (NULL != rd_task)
-    {
-      GNUNET_SCHEDULER_cancel(rd_task);
-      rd_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (rd_task);
+    rd_task = NULL;
+  }
   if (NULL != echo_task)
-    {
-      GNUNET_SCHEDULER_cancel(echo_task);
-      echo_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (echo_task);
+    echo_task = NULL;
+  }
   if (NULL != job)
-    {
-      GNUNET_SCHEDULER_cancel(job);
-      job = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (job);
+    job = NULL;
+  }
 }
 
 void
-mq_cb(void *cls)
+mq_cb (void *cls)
 {
-  listen_stdio();
+  listen_stdio ();
 }
 
 
@@ -278,7 +278,7 @@ mq_cb(void *cls)
  * @param cls Closure (unused).
  */
 static void
-read_stdio(void *cls)
+read_stdio (void *cls)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
@@ -286,41 +286,41 @@ read_stdio(void *cls)
   ssize_t data_size;
 
   rd_task = NULL;
-  data_size = read(0, buf, 60000);
+  data_size = read (0, buf, 60000);
   if (data_size < 1)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "read() returned  %s\n",
-                 strerror(errno));
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Read %u bytes from stdio\n",
-             (unsigned int)data_size);
-  env = GNUNET_MQ_msg_extra(msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
-  GNUNET_memcpy(&msg[1], buf, data_size);
-  GNUNET_MQ_send(GNUNET_CADET_get_mq(ch), env);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "read() returned  %s\n",
+                strerror (errno));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Read %u bytes from stdio\n",
+              (unsigned int) data_size);
+  env = GNUNET_MQ_msg_extra (msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
+  GNUNET_memcpy (&msg[1], buf, data_size);
+  GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env);
 
   sent_pkt++;
 
   if (GNUNET_NO == echo)
+  {
+    // Use MQ's notification if too much data of stdin is pooring in too fast.
+    if (STREAM_BUFFER_SIZE < sent_pkt)
     {
-      // Use MQ's notification if too much data of stdin is pooring in too fast.
-      if (STREAM_BUFFER_SIZE < sent_pkt)
-        {
-          GNUNET_MQ_notify_sent(env, mq_cb, cls);
-          sent_pkt = 0;
-        }
-      else
-        {
-          listen_stdio();
-        }
+      GNUNET_MQ_notify_sent (env, mq_cb, cls);
+      sent_pkt = 0;
     }
-  else
+    else
     {
-      echo_time = GNUNET_TIME_absolute_get();
+      listen_stdio ();
     }
+  }
+  else
+  {
+    echo_time = GNUNET_TIME_absolute_get ();
+  }
 }
 
 
@@ -328,20 +328,20 @@ read_stdio(void *cls)
  * Wait for input on STDIO and send it out over the #ch.
  */
 static void
-listen_stdio()
+listen_stdio ()
 {
   struct GNUNET_NETWORK_FDSet *rs;
 
   /* FIXME: why use 'rs' here, seems overly complicated... */
-  rs = GNUNET_NETWORK_fdset_create();
-  GNUNET_NETWORK_fdset_set_native(rs, 0);  /* STDIN */
-  rd_task = GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                        GNUNET_TIME_UNIT_FOREVER_REL,
-                                        rs,
-                                        NULL,
-                                        &read_stdio,
-                                        NULL);
-  GNUNET_NETWORK_fdset_destroy(rs);
+  rs = GNUNET_NETWORK_fdset_create ();
+  GNUNET_NETWORK_fdset_set_native (rs, 0);  /* STDIN */
+  rd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         rs,
+                                         NULL,
+                                         &read_stdio,
+                                         NULL);
+  GNUNET_NETWORK_fdset_destroy (rs);
 }
 
 
@@ -355,12 +355,12 @@ listen_stdio()
  * @param channel connection to the other end (henceforth invalid)
  */
 static void
-channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel)
+channel_ended (void *cls, const struct GNUNET_CADET_Channel *channel)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n");
-  GNUNET_assert(channel == ch);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n");
+  GNUNET_assert (channel == ch);
   ch = NULL;
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -379,20 +379,20 @@ channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel)
  * @return initial channel context for the channel, we use @a channel
  */
 static void *
-channel_incoming(void *cls,
-                 struct GNUNET_CADET_Channel *channel,
-                 const struct GNUNET_PeerIdentity *initiator)
+channel_incoming (void *cls,
+                  struct GNUNET_CADET_Channel *channel,
+                  const struct GNUNET_PeerIdentity *initiator)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE,
-             "Incoming connection from %s\n",
-             GNUNET_i2s_full(initiator));
-  GNUNET_assert(NULL == ch);
-  GNUNET_assert(NULL != lp);
-  GNUNET_CADET_close_port(lp);
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Incoming connection from %s\n",
+              GNUNET_i2s_full (initiator));
+  GNUNET_assert (NULL == ch);
+  GNUNET_assert (NULL != lp);
+  GNUNET_CADET_close_port (lp);
   lp = NULL;
   ch = channel;
   if (GNUNET_NO == echo)
-    listen_stdio();
+    listen_stdio ();
   return channel;
 }
 
@@ -403,7 +403,7 @@ channel_incoming(void *cls,
  * @param cls Closure (NULL).
  */
 static void
-send_echo(void *cls)
+send_echo (void *cls)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
@@ -411,8 +411,8 @@ send_echo(void *cls)
   echo_task = NULL;
   if (NULL == ch)
     return;
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_CLI);
-  GNUNET_MQ_send(GNUNET_CADET_get_mq(ch), env);
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_CLI);
+  GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env);
 }
 
 
@@ -425,7 +425,7 @@ send_echo(void *cls)
  *         #GNUNET_SYSERR to close it (signal serious error).
  */
 static int
-check_data(void *cls, const struct GNUNET_MessageHeader *message)
+check_data (void *cls, const struct GNUNET_MessageHeader *message)
 {
   return GNUNET_OK; /* all is well-formed */
 }
@@ -442,59 +442,59 @@ check_data(void *cls, const struct GNUNET_MessageHeader *message)
  * @param message The actual message.
  */
 static void
-handle_data(void *cls, const struct GNUNET_MessageHeader *message)
+handle_data (void *cls, const struct GNUNET_MessageHeader *message)
 {
-  size_t payload_size = ntohs(message->size) - sizeof(*message);
+  size_t payload_size = ntohs (message->size) - sizeof(*message);
   uint16_t len;
   ssize_t done;
   uint16_t off;
   const char *buf;
 
-  GNUNET_CADET_receive_done(ch);
+  GNUNET_CADET_receive_done (ch);
   if (GNUNET_YES == echo)
+  {
+    if (NULL != listen_port)
     {
-      if (NULL != listen_port)
-        {
-          struct GNUNET_MQ_Envelope *env;
-          struct GNUNET_MessageHeader *msg;
-
-          env =
-            GNUNET_MQ_msg_extra(msg, payload_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
-          GNUNET_memcpy(&msg[1], &message[1], payload_size);
-          GNUNET_MQ_send(GNUNET_CADET_get_mq(ch), env);
-          return;
-        }
-      else
-        {
-          struct GNUNET_TIME_Relative latency;
-
-          latency = GNUNET_TIME_absolute_get_duration(echo_time);
-          echo_time = GNUNET_TIME_UNIT_FOREVER_ABS;
-          GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE,
-                     "time: %s\n",
-                     GNUNET_STRINGS_relative_time_to_string(latency, GNUNET_NO));
-          echo_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
-                                                   &send_echo,
-                                                   NULL);
-        }
+      struct GNUNET_MQ_Envelope *env;
+      struct GNUNET_MessageHeader *msg;
+
+      env =
+        GNUNET_MQ_msg_extra (msg, payload_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
+      GNUNET_memcpy (&msg[1], &message[1], payload_size);
+      GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env);
+      return;
     }
+    else
+    {
+      struct GNUNET_TIME_Relative latency;
+
+      latency = GNUNET_TIME_absolute_get_duration (echo_time);
+      echo_time = GNUNET_TIME_UNIT_FOREVER_ABS;
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+                  "time: %s\n",
+                  GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_NO));
+      echo_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                                &send_echo,
+                                                NULL);
+    }
+  }
 
-  len = ntohs(message->size) - sizeof(*message);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len);
-  buf = (const char *)&message[1];
+  len = ntohs (message->size) - sizeof(*message);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len);
+  buf = (const char *) &message[1];
   off = 0;
   while (off < len)
+  {
+    done = write (1, &buf[off], len - off);
+    if (done <= 0)
     {
-      done = write(1, &buf[off], len - off);
-      if (done <= 0)
-        {
-          if (-1 == done)
-            GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "write");
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      off += done;
+      if (-1 == done)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
+      GNUNET_SCHEDULER_shutdown ();
+      return;
     }
+    off += done;
+  }
 }
 
 
@@ -508,19 +508,19 @@ handle_data(void *cls, const struct GNUNET_MessageHeader *message)
  * @param ple information about peer, or NULL on "EOF".
  */
 static void
-peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
+peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
 {
   if (NULL == ple)
-    {
-      plo = NULL;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  fprintf(stdout,
-          "%s tunnel: %c, paths: %u\n",
-          GNUNET_i2s_full(&ple->peer),
-          ple->have_tunnel ? 'Y' : 'N',
-          ple->n_paths);
+  {
+    plo = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  fprintf (stdout,
+           "%s tunnel: %c, paths: %u\n",
+           GNUNET_i2s_full (&ple->peer),
+           ple->have_tunnel ? 'Y' : 'N',
+           ple->n_paths);
 }
 
 
@@ -532,20 +532,20 @@ peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
  * @param ppd path detail
  */
 static void
-path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
+path_callback (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
 {
   if (NULL == ppd)
-    {
-      gpo = NULL;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  fprintf(stdout, "Path of length %u: ", ppd->path_length);
+  {
+    gpo = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  fprintf (stdout, "Path of length %u: ", ppd->path_length);
   for (unsigned int i = 0; i < ppd->path_length; i++)
-    fprintf(stdout,
-            (i == ppd->target_offset) ? "*%s* " : "%s ",
-            GNUNET_i2s(&ppd->path[i]));
-  fprintf(stdout, "\n");
+    fprintf (stdout,
+             (i == ppd->target_offset) ? "*%s* " : "%s ",
+             GNUNET_i2s (&ppd->path[i]));
+  fprintf (stdout, "\n");
 }
 
 
@@ -556,21 +556,21 @@ path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
  * @param td tunnel details
  */
 static void
-tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td)
+tunnels_callback (void *cls, const struct GNUNET_CADET_TunnelDetails *td)
 {
   if (NULL == td)
-    {
-      tio = NULL;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  fprintf(stdout,
-          "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
-          GNUNET_i2s_full(&td->peer),
-          enc_2s(td->estate),
-          conn_2s(td->cstate),
-          td->channels,
-          td->connections);
+  {
+    tio = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  fprintf (stdout,
+           "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
+           GNUNET_i2s_full (&td->peer),
+           enc_2s (td->estate),
+           conn_2s (td->cstate),
+           td->channels,
+           td->connections);
 }
 
 
@@ -580,10 +580,10 @@ tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td)
  * @param cls Closure (unused).
  */
 static void
-get_peers(void *cls)
+get_peers (void *cls)
 {
   job = NULL;
-  plo = GNUNET_CADET_list_peers(my_cfg, &peers_callback, NULL);
+  plo = GNUNET_CADET_list_peers (my_cfg, &peers_callback, NULL);
 }
 
 
@@ -593,20 +593,20 @@ get_peers(void *cls)
  * @param cls Closure (unused).
  */
 static void
-show_peer(void *cls)
+show_peer (void *cls)
 {
   struct GNUNET_PeerIdentity pid;
 
   job = NULL;
-  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string(peer_id,
-                                                              strlen(peer_id),
-                                                              &pid.public_key))
-    {
-      fprintf(stderr, _("Invalid peer ID `%s'\n"), peer_id);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  gpo = GNUNET_CADET_get_path(my_cfg, &pid, &path_callback, NULL);
+  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id,
+                                                               strlen (peer_id),
+                                                               &pid.public_key))
+  {
+    fprintf (stderr, _ ("Invalid peer ID `%s'\n"), peer_id);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  gpo = GNUNET_CADET_get_path (my_cfg, &pid, &path_callback, NULL);
 }
 
 
@@ -616,10 +616,10 @@ show_peer(void *cls)
  * @param cls Closure (unused).
  */
 static void
-get_tunnels(void *cls)
+get_tunnels (void *cls)
 {
   job = NULL;
-  tio = GNUNET_CADET_list_tunnels(my_cfg, &tunnels_callback, NULL);
+  tio = GNUNET_CADET_list_tunnels (my_cfg, &tunnels_callback, NULL);
 }
 
 
@@ -629,10 +629,10 @@ get_tunnels(void *cls)
  * @param cls Closure (unused).
  */
 static void
-show_channel(void *cls)
+show_channel (void *cls)
 {
   job = NULL;
-  GNUNET_break(0);
+  GNUNET_break (0);
 }
 
 
@@ -642,10 +642,10 @@ show_channel(void *cls)
  * @param cls Closure (unused).
  */
 static void
-show_connection(void *cls)
+show_connection (void *cls)
 {
   job = NULL;
-  GNUNET_break(0);
+  GNUNET_break (0);
 }
 
 
@@ -658,17 +658,17 @@ show_connection(void *cls)
  * @param cfg configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_MQ_MessageHandler handlers[] =
-  { GNUNET_MQ_hd_var_size(data,
-                          GNUNET_MESSAGE_TYPE_CADET_CLI,
-                          struct GNUNET_MessageHeader,
-                          NULL),
-    GNUNET_MQ_handler_end() };
+  { GNUNET_MQ_hd_var_size (data,
+                           GNUNET_MESSAGE_TYPE_CADET_CLI,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+    GNUNET_MQ_handler_end () };
 
   /* FIXME add option to monitor apps */
   my_cfg = cfg;
@@ -676,105 +676,105 @@ run(void *cls,
   if (target_id && args[1])
     target_port = args[1];
 
-  if ((0 != (request_peers | request_tunnels) || NULL != conn_id ||
-       NULL != channel_id) &&
-      target_id != NULL)
-    {
-      fprintf(stderr,
-              _("Extra arguments are not applicable "
+  if (((0 != (request_peers | request_tunnels))||(NULL != conn_id)||
+       (NULL != channel_id) ) &&
+      (target_id != NULL) )
+  {
+    fprintf (stderr,
+             _ ("Extra arguments are not applicable "
                 "in combination with this option.\n"));
-      return;
-    }
+    return;
+  }
 
   if (NULL != peer_id)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show peer\n");
-      job = GNUNET_SCHEDULER_add_now(&show_peer, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show peer\n");
+    job = GNUNET_SCHEDULER_add_now (&show_peer, NULL);
+  }
   else if (NULL != channel_id)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show channel\n");
-      job = GNUNET_SCHEDULER_add_now(&show_channel, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show channel\n");
+    job = GNUNET_SCHEDULER_add_now (&show_channel, NULL);
+  }
   else if (NULL != conn_id)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show connection\n");
-      job = GNUNET_SCHEDULER_add_now(&show_connection, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show connection\n");
+    job = GNUNET_SCHEDULER_add_now (&show_connection, NULL);
+  }
   else if (GNUNET_YES == request_peers)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n");
-      job = GNUNET_SCHEDULER_add_now(&get_peers, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n");
+    job = GNUNET_SCHEDULER_add_now (&get_peers, NULL);
+  }
   else if (GNUNET_YES == request_tunnels)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n");
-      job = GNUNET_SCHEDULER_add_now(&get_tunnels, NULL);
-    }
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n");
-  mh = GNUNET_CADET_connect(cfg);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n");
+    job = GNUNET_SCHEDULER_add_now (&get_tunnels, NULL);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n");
+  mh = GNUNET_CADET_connect (cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
   if (NULL == mh)
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if (NULL != listen_port)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n");
+    GNUNET_CRYPTO_hash (listen_port, strlen (listen_port), &porthash);
+    lp = GNUNET_CADET_open_port (mh,
+                                 &porthash,
+                                 &channel_incoming,
+                                 NULL,
+                                 NULL /* window changes */,
+                                 &channel_ended,
+                                 handlers);
+  }
+  if (NULL != target_id)
+  {
+    struct GNUNET_PeerIdentity pid;
+
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_eddsa_public_key_from_string (target_id,
+                                                    strlen (target_id),
+                                                    &pid.public_key))
     {
-      GNUNET_SCHEDULER_shutdown();
+      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+                  _ ("Invalid target `%s'\n"),
+                  target_id);
+      GNUNET_SCHEDULER_shutdown ();
       return;
     }
-  if (NULL != listen_port)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connecting to `%s:%s'\n",
+                target_id,
+                target_port);
+    GNUNET_CRYPTO_hash (target_port, strlen (target_port), &porthash);
+    ch = GNUNET_CADET_channel_create (mh,
+                                      NULL,
+                                      &pid,
+                                      &porthash,
+                                      NULL /* window changes */,
+                                      &channel_ended,
+                                      handlers);
+    if (GNUNET_YES == echo)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n");
-      GNUNET_CRYPTO_hash(listen_port, strlen(listen_port), &porthash);
-      lp = GNUNET_CADET_open_port(mh,
-                                  &porthash,
-                                  &channel_incoming,
-                                  NULL,
-                                  NULL /* window changes */,
-                                  &channel_ended,
-                                  handlers);
+      echo_task = GNUNET_SCHEDULER_add_now (&send_echo, NULL);
     }
-  if (NULL != target_id)
+    else
     {
-      struct GNUNET_PeerIdentity pid;
-
-      if (GNUNET_OK !=
-          GNUNET_CRYPTO_eddsa_public_key_from_string(target_id,
-                                                     strlen(target_id),
-                                                     &pid.public_key))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE,
-                     _("Invalid target `%s'\n"),
-                     target_id);
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Connecting to `%s:%s'\n",
-                 target_id,
-                 target_port);
-      GNUNET_CRYPTO_hash(target_port, strlen(target_port), &porthash);
-      ch = GNUNET_CADET_channel_create(mh,
-                                       NULL,
-                                       &pid,
-                                       &porthash,
-                                       NULL /* window changes */,
-                                       &channel_ended,
-                                       handlers);
-      if (GNUNET_YES == echo)
-        {
-          echo_task = GNUNET_SCHEDULER_add_now(&send_echo, NULL);
-        }
-      else
-        {
-          listen_stdio();
-        }
+      listen_stdio ();
     }
+  }
 
   if ((NULL == lp) && (NULL == job) && (NULL == ch))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, _("No action requested\n"));
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _ ("No action requested\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 }
 
 
@@ -786,61 +786,60 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   int res;
   const char helpstr[] =
     "Create tunnels and retrieve info about CADET's status.";
-  struct GNUNET_GETOPT_CommandLineOption options[] =
-  {  /* I would use the terminology 'circuit' here...  --lynX */
-    GNUNET_GETOPT_option_string(
+  struct GNUNET_GETOPT_CommandLineOption options[] = {  /* I would use the terminology 'circuit' here...  --lynX */
+    GNUNET_GETOPT_option_string (
       'C',
       "connection",
       "CONNECTION_ID",
-      gettext_noop("Provide information about a particular connection"),
+      gettext_noop ("Provide information about a particular connection"),
       &conn_id),
-    GNUNET_GETOPT_option_flag('e',
-                              "echo",
-                              gettext_noop("Activate echo mode"),
-                              &echo),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_flag ('e',
+                               "echo",
+                               gettext_noop ("Activate echo mode"),
+                               &echo),
+    GNUNET_GETOPT_option_string (
       'o',
       "open-port",
       "SHARED_SECRET",
-      gettext_noop(
+      gettext_noop (
         "Listen for connections using a shared secret among sender and recipient"),
       &listen_port),
-    GNUNET_GETOPT_option_string('p',
-                                "peer",
-                                "PEER_ID",
-                                gettext_noop(
-                                  "Provide information about a patricular peer"),
-                                &peer_id),
-    GNUNET_GETOPT_option_flag('P',
-                              "peers",
-                              gettext_noop(
-                                "Provide information about all peers"),
-                              &request_peers),
-    GNUNET_GETOPT_option_flag('T',
-                              "tunnels",
-                              gettext_noop(
-                                "Provide information about all tunnels"),
-                              &request_tunnels),
+    GNUNET_GETOPT_option_string ('p',
+                                 "peer",
+                                 "PEER_ID",
+                                 gettext_noop (
+                                   "Provide information about a patricular peer"),
+                                 &peer_id),
+    GNUNET_GETOPT_option_flag ('P',
+                               "peers",
+                               gettext_noop (
+                                 "Provide information about all peers"),
+                               &request_peers),
+    GNUNET_GETOPT_option_flag ('T',
+                               "tunnels",
+                               gettext_noop (
+                                 "Provide information about all tunnels"),
+                               &request_tunnels),
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
-  res = GNUNET_PROGRAM_run(argc,
-                           argv,
-                           "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
-                           gettext_noop(helpstr),
-                           options,
-                           &run,
-                           NULL);
+  res = GNUNET_PROGRAM_run (argc,
+                            argv,
+                            "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
+                            gettext_noop (helpstr),
+                            options,
+                            &run,
+                            NULL);
 
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
 
   if (GNUNET_OK == res)
     return 0;