- unify logging format

3 files changed, 56 insertions, 58 deletions

diff --git a/src/cadet/cadet_common.c b/src/cadet/cadet_common.c
index 7df22b396..8ac85fe17 100644
--- a/src/cadet/cadet_common.c
+++ b/src/cadet/cadet_common.c
@@ -105,7 +105,7 @@ GC_m2s (uint16_t m)
 {
   static char buf[2][16];
   static int idx;
-  const char *t;
+  const char *s;
 
   idx = (idx + 1) % 2;
   switch (m)
@@ -120,238 +120,238 @@ GC_m2s (uint16_t m)
        * Request the creation of a path
        */
     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
-      t = "CONN_CREATE";
+      s = "CONN_CREAT";
       break;
 
       /**
        * Request the modification of an existing path
        */
     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
-      t = "CONN_ACK";
+      s = "CONN_ACK";
       break;
 
       /**
        * Notify that a connection of a path is no longer valid
        */
     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
-      t = "CONN_BROKEN";
+      s = "CONN_BRKN";
       break;
 
       /**
        * At some point, the route will spontaneously change
        */
     case GNUNET_MESSAGE_TYPE_CADET_PATH_CHANGED:
-      t = "PATH_CHANGED";
+      s = "PATH_CHNGD";
       break;
 
       /**
        * Transport payload data.
        */
     case GNUNET_MESSAGE_TYPE_CADET_DATA:
-      t = "DATA";
+      s = "DATA";
       break;
 
     /**
      * Confirm receipt of payload data.
      */
     case GNUNET_MESSAGE_TYPE_CADET_DATA_ACK:
-      t = "DATA_ACK";
+      s = "DATA_ACK";
       break;
 
       /**
        * Key exchange encapsulation.
        */
     case GNUNET_MESSAGE_TYPE_CADET_KX:
-      t = "KX";
+      s = "KX";
       break;
 
       /**
        * Axolotl key exchange message.
        */
     case GNUNET_MESSAGE_TYPE_CADET_AX_KX:
-      t = "AX_KX";
+      s = "AX_KX";
       break;
 
       /**
        * New ephemeral key.
        */
     case GNUNET_MESSAGE_TYPE_CADET_KX_EPHEMERAL:
-      t = "KX_EPHEMERAL";
+      s = "KX_EPHM";
       break;
 
       /**
        * Answer to session key challenge.
        */
     case GNUNET_MESSAGE_TYPE_CADET_KX_PONG:
-      t = "KX_PONG";
+      s = "KX_PONG";
       break;
 
       /**
        * Request the destuction of a path
        */
     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
-      t = "CONN_DESTROY";
+      s = "CONN_DSTRY";
       break;
 
       /**
        * ACK for a data packet.
        */
     case GNUNET_MESSAGE_TYPE_CADET_ACK:
-      t = "ACK";
+      s = "ACK";
       break;
 
       /**
        * POLL for ACK.
        */
     case GNUNET_MESSAGE_TYPE_CADET_POLL:
-      t = "POLL";
+      s = "POLL";
       break;
 
       /**
        * Announce origin is still alive.
        */
     case GNUNET_MESSAGE_TYPE_CADET_KEEPALIVE:
-      t = "KEEPALIVE";
+      s = "KEEPALIVE";
       break;
 
     /**
        * Connect to the cadet service, specifying subscriptions
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_CONNECT:
-      t = "LOCAL_CONNECT";
+      s = "LOC_CONNCT";
       break;
 
       /**
        * Ask the cadet service to create a new tunnel
        */
     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
-      t = "CHAN_CREATE";
+      s = "CHAN_CREAT";
       break;
 
       /**
        * Ask the cadet service to destroy a tunnel
        */
     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
-      t = "CHAN_DESTROY";
+      s = "CHAN_DSTRY";
       break;
 
       /**
        * Confirm the creation of a channel.
        */
     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_ACK:
-      t = "CHAN_ACK";
+      s = "CHAN_ACK";
       break;
 
       /**
        * Confirm the creation of a channel.
        */
     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_NACK:
-      t = "CHAN_NACK";
+      s = "CHAN_NACK";
       break;
 
       /**
        * OTR encrypted payload.
        */
     case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
-      t = "OTR";
+      s = "OTR";
       break;
 
       /**
        * Axolotl encrypted payload.
        */
     case GNUNET_MESSAGE_TYPE_CADET_AX:
-      t = "AX";
+      s = "AX";
       break;
 
       /**
        * Local payload traffic
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA:
-      t = "LOCAL_DATA";
+      s = "LOC_DATA";
       break;
 
       /**
        * Local ACK for data.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK:
-      t = "LOCAL_ACK";
+      s = "LOC_ACK";
       break;
 
       /**
        * Local monitoring of channels.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNELS:
-      t = "INFO_CHANS";
+      s = "INFO_CHANS";
       break;
 
       /**
        * Local monitoring of a channel.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL:
-      t = "INFO_CHAN";
+      s = "INFO_CHAN";
       break;
 
       /**
        * Local monitoring of service.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS:
-      t = "INFO_TUNS";
+      s = "INFO_TUNS";
       break;
 
       /**
        * Local monitoring of service.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL:
-      t = "INFO_TUN";
+      s = "INFO_TUN";
       break;
 
       /**
        * Local information about all connections of service.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CONNECTIONS:
-      t = "INFO_CONNS";
+      s = "INFO_CONNS";
       break;
 
       /**
        * Local information of service about a specific connection.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CONNECTION:
-      t = "INFO_CONN";
+      s = "INFO_CONN";
       break;
 
       /**
        * Local information about all peers known to the service.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS:
-      t = "INFO_PEERS";
+      s = "INFO_PEERS";
       break;
 
       /**
        * Local information of service about a specific peer.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER:
-      t = "INFO_PEER";
+      s = "INFO_PEER";
       break;
 
       /**
        * Traffic (net-cat style) used by the Command Line Interface.
        */
     case GNUNET_MESSAGE_TYPE_CADET_CLI:
-      t = "CLI";
+      s = "CLI";
       break;
 
       /**
        * Debug request.
        */
     case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_DUMP:
-      t = "INFO_DUMP";
+      s = "INFO_DUMP";
       break;
 
     default:
-      SPRINTF(buf[idx], "%u (UNKNOWN)", m);
+      SPRINTF (buf[idx], "%u (UNKNOWN)", m);
       return buf[idx];
   }
-  SPRINTF(buf[idx], "{%13s}", t);
+  SPRINTF (buf[idx], "{%10s}", s);
   return buf[idx];
 }
 #else
diff --git a/src/cadet/gnunet-service-cadet_connection.c b/src/cadet/gnunet-service-cadet_connection.c
index f27637c7d..a9cf8c196 100644
--- a/src/cadet/gnunet-service-cadet_connection.c
+++ b/src/cadet/gnunet-service-cadet_connection.c
@@ -583,7 +583,7 @@ send_ack (struct CadetConnection *c, unsigned int buffer, int fwd, int force)
 
   prev_fc->last_ack_sent = ack;
 
-  /* Build ACK message and send on connection */
+  /* Build ACK message and send on conn */
   msg.header.size = htons (sizeof (msg));
   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_ACK);
   msg.ack = htonl (ack);
@@ -969,7 +969,7 @@ send_connection_ack (struct CadetConnection *connection, int fwd)
 
   GCC_check_connections ();
   t = connection->t;
-  LOG (GNUNET_ERROR_TYPE_INFO, "---> {%14s ACK} on connection %s\n",
+  LOG (GNUNET_ERROR_TYPE_INFO, "--> {%14s ACK} on conn %s\n",
        GC_f2s (!fwd), GCC_2s (connection));
   GCP_queue_add (get_hop (connection, fwd), NULL,
                  GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK, 0, 0,
@@ -1032,7 +1032,7 @@ send_broken_unknown (const struct GNUNET_CADET_Hash *connection_id,
   struct CadetPeer *neighbor;
 
   GCC_check_connections ();
-  LOG (GNUNET_ERROR_TYPE_INFO, "---> BROKEN on unknown connection %s\n",
+  LOG (GNUNET_ERROR_TYPE_INFO, "--> BROKEN on unknown connection %s\n",
        GNUNET_h2s (GC_h2hc (connection_id)));
 
   msg = GNUNET_new (struct GNUNET_CADET_ConnectionBroken);
@@ -1886,7 +1886,7 @@ log_message (const struct GNUNET_MessageHeader *message,
   size = ntohs (message->size);
   LOG (GNUNET_ERROR_TYPE_INFO, "\n");
   LOG (GNUNET_ERROR_TYPE_INFO, "\n");
-  LOG (GNUNET_ERROR_TYPE_INFO, "<-- %s on connection %s from %s, %6u bytes\n",
+  LOG (GNUNET_ERROR_TYPE_INFO, "<-- %s on conn %s from %s, %6u bytes\n",
        GC_m2s (ntohs (message->type)), GNUNET_h2s (GC_h2hc (hash)),
        GNUNET_i2s (peer), (unsigned int) size);
 }
@@ -3438,8 +3438,10 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
   data = GNUNET_malloc (size);
   memcpy (data, message, size);
   type = ntohs (message->type);
-  LOG (GNUNET_ERROR_TYPE_INFO, "--> %s (%s %4u) on connection %s (%u bytes)\n",
-       GC_m2s (type), GC_m2s (payload_type), payload_id, GCC_2s (c), size);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "--> %s (%s %4u) on conn %s (%p) %s (%u bytes)\n",
+       GC_m2s (type), GC_m2s (payload_type), payload_id, GCC_2s (c), c,
+       GC_f2s(fwd), size);
 
   fc = fwd ? &c->fwd_fc : &c->bck_fc;
   droppable = GNUNET_NO == force;
@@ -3601,7 +3603,7 @@ GCC_send_create (struct CadetConnection *connection)
   size = sizeof (struct GNUNET_CADET_ConnectionCreate);
   size += connection->path->length * sizeof (struct GNUNET_PeerIdentity);
 
-  LOG (GNUNET_ERROR_TYPE_INFO, "---> %s on connection %s  (%u bytes)\n",
+  LOG (GNUNET_ERROR_TYPE_INFO, "--> %s on conn %s  (%u bytes)\n",
        GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE),
        GCC_2s (connection), size);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "  C_P+ %p %u (create)\n",
diff --git a/src/cadet/gnunet-service-cadet_peer.c b/src/cadet/gnunet-service-cadet_peer.c
index e7da408c5..165553d1c 100644
--- a/src/cadet/gnunet-service-cadet_peer.c
+++ b/src/cadet/gnunet-service-cadet_peer.c
@@ -1150,6 +1150,7 @@ queue_send (void *cls, size_t size, void *buf)
   struct CadetConnection *c;
   struct CadetPeerQueue *queue;
   struct GNUNET_TIME_Relative core_wait_time;
+  const char *wait_s;
   const struct GNUNET_PeerIdentity *dst_id;
   size_t msg_size;
   size_t total_size;
@@ -1175,7 +1176,7 @@ queue_send (void *cls, size_t size, void *buf)
         peer->core_transmit = NULL;
         peer->tmt_time.abs_value_us = 0;
         GCC_check_connections ();
-        return;
+        return 0;
       }
       dst_id = GNUNET_PEER_resolve2 (peer->id);
       peer->core_transmit =
@@ -1211,18 +1212,12 @@ queue_send (void *cls, size_t size, void *buf)
     return 0;
   }
   core_wait_time = GNUNET_TIME_absolute_get_duration (peer->tmt_time);
+  wait_s = GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_YES);
   if (core_wait_time.rel_value_us >= 1000000)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          " %s: core wait time %s (> 1 second) for %u bytes\n",
-         GCP_2s (peer),
-         GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_YES),
-         queue->size);
-  }
-  else
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, " core wait time %s\n",
-         GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_YES));
+         GCP_2s (peer), wait_s, queue->size);
   }
   peer->tmt_time.abs_value_us = 0;
 
@@ -1231,7 +1226,7 @@ queue_send (void *cls, size_t size, void *buf)
   {
     c = queue->c;
 
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  on connection %s %s\n",
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "  on conn %s %s\n",
          GCC_2s (c), GC_f2s(queue->fwd));
     LOG (GNUNET_ERROR_TYPE_DEBUG, "  size %u ok (%u/%u)\n",
          queue->size, total_size, size);
@@ -1241,7 +1236,7 @@ queue_send (void *cls, size_t size, void *buf)
     if (0 < drop_percent &&
         GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
     {
-      LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on connection %s %s\n",
+      LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n",
            GC_m2s (queue->type), GC_m2s (queue->payload_type),
            queue->payload_id, GCC_2s (c), GC_f2s (queue->fwd));
       msg_size = 0;
@@ -1249,9 +1244,10 @@ queue_send (void *cls, size_t size, void *buf)
     else
     {
       LOG (GNUNET_ERROR_TYPE_INFO,
-           "snd %s (%s %4u) on connection %s (%p) %s (size %u)\n",
+           ">>> %s (%s %4u) on conn %s (%p) %s (%u bytes), after %s\n",
            GC_m2s (queue->type), GC_m2s (queue->payload_type),
-           queue->payload_id, GCC_2s (c), c, GC_f2s (queue->fwd), msg_size);
+           queue->payload_id, GCC_2s (c), c,
+           GC_f2s (queue->fwd), msg_size, wait_s);
     }
     total_size += msg_size;
     rest -= msg_size;
@@ -1429,7 +1425,7 @@ GCP_queue_add (struct CadetPeer *peer,
 
   GCC_check_connections ();
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "que %s (%s %4u) on connection %s (%p) %s towards %s (size %u)\n",
+       "que %s (%s %4u) on conn %s (%p) %s towards %s (size %u)\n",
        GC_m2s (type), GC_m2s (payload_type), payload_id,
        GCC_2s (c), c, GC_f2s (fwd), GCP_2s (peer), size);
 
@@ -1627,7 +1623,7 @@ GCP_connection_pop (struct CadetPeer *peer,
 
   GCC_check_connections ();
   GNUNET_assert (NULL != destroyed);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on connection %p\n", c);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on conn %p\n", c);
   for (q = peer->queue_head; NULL != q; q = next)
   {
     next = q->next;