gnunet-svn
[Top][All Lists]
Advanced

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

[GNUnet-SVN] r25920 - in gnunet/src: include testbed


From: gnunet
Subject: [GNUnet-SVN] r25920 - in gnunet/src: include testbed
Date: Sat, 26 Jan 2013 15:00:28 +0100

Author: harsha
Date: 2013-01-26 15:00:28 +0100 (Sat, 26 Jan 2013)
New Revision: 25920

Modified:
   gnunet/src/include/gnunet_protocols.h
   gnunet/src/testbed/gnunet-service-testbed.c
   gnunet/src/testbed/gnunet-service-testbed.h
   gnunet/src/testbed/gnunet-service-testbed_oc.c
   gnunet/src/testbed/testbed.h
   gnunet/src/testbed/testbed_api.c
   gnunet/src/testbed/testbed_api_peers.c
   gnunet/src/testbed/testbed_api_services.c
Log:
- rename

Modified: gnunet/src/include/gnunet_protocols.h
===================================================================
--- gnunet/src/include/gnunet_protocols.h       2013-01-26 09:50:37 UTC (rev 
25919)
+++ gnunet/src/include/gnunet_protocols.h       2013-01-26 14:00:28 UTC (rev 
25920)
@@ -1480,119 +1480,114 @@
 /**
  * Message to add host
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST 461
+#define GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST 461
 
 /**
  * Message to signal that a add host succeeded
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM 462
+#define GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS 462
 
 /**
  * Message to configure a service to be shared among peers
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_SERVICESHARE 463
+#define GNUNET_MESSAGE_TYPE_TESTBED_SHARE_SERVICE 463
 
 /**
  * Message to link delegated controller to slave controller
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS 464
+#define GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS 464
 
 /**
  * Message to create a peer at a host
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER 465
+#define GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER 465
 
 /**
  * Message to reconfigure a peer
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_PEERRECONF 466
+#define GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER 466
 
 /**
  * Message to start a peer at a host
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_STARTPEER 467
+#define GNUNET_MESSAGE_TYPE_TESTBED_START_PEER 467
 
 /**
  * Message to stop a peer at a host
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_STOPPEER 468
+#define GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER 468
 
 /**
  * Message to destroy a peer
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER 469
+#define GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER 469
 
 /**
  * Configure underlay link message
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_CONFIGULLINK 470
+#define GNUNET_MESSAGE_TYPE_TESTBED_CONFIGURE_UNDERLAY_LINK 470
 
 /**
  * Message to connect peers in a overlay
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT 471
+#define GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT 471
 
 /**
  * Message for peer events
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT 472
+#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT 472
 
 /**
  * Message for peer connect events
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_PEERCONEVENT 473
+#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT 473
 
 /**
  * Message for operation events
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONFAILEVENT 474
+#define GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT 474
 
 /**
  * Message to signal successful peer creation
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS 475
+#define GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS 475
 
 /**
  * Message to signal a generic operation has been successful
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS 476
+#define GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS 476
 
 /**
  * Message to get the configuration of a peer
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG 477
+#define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION 477
 
 /**
  * Message containing the peer configuration
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG 478
+#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION 478
 
 /**
  * Message to request a controller to make one of its peer to connect to 
another
  * peer using the contained HELLO
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT 479
+#define GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT 479
 
 /**
- * Message to cancel a REQUESTCONNECT request
- */
-#define GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECTCANCEL 480
-
-/**
  * Message to request configuration of a slave controller
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG 481
+#define GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION 480
 
 /**
  * Message which contains the configuration of slave controller
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG 482
+#define GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION 481
 
 /**
  * Not really a message, but for careful checks on the testbed messages; Should
  * always be the maximum and never be used to send messages with this type
  */
-#define GNUNET_MESSAGE_TYPE_TESTBED_MAX 483
+#define GNUNET_MESSAGE_TYPE_TESTBED_MAX 482
 
 /**
  * The initialization message towards gnunet-testbed-helper

Modified: gnunet/src/testbed/gnunet-service-testbed.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed.c 2013-01-26 09:50:37 UTC (rev 
25919)
+++ gnunet/src/testbed/gnunet-service-testbed.c 2013-01-26 14:00:28 UTC (rev 
25920)
@@ -436,7 +436,7 @@
   msize += emsg_len;
   msg = GNUNET_malloc (msize);
   msg->header.size = htons (msize);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONFAILEVENT);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT);
   msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
   msg->operation_id = GNUNET_htonll (operation_id);
   if (0 != emsg_len)
@@ -461,7 +461,8 @@
   msize = sizeof (struct GNUNET_TESTBED_GenericOperationSuccessEventMessage);
   msg = GNUNET_malloc (msize);
   msg->header.size = htons (msize);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS);
+  msg->header.type =
+      htons (GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS);
   msg->operation_id = GNUNET_htonll (operation_id);
   msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
   GST_queue_message (client, &msg->header);
@@ -1018,7 +1019,7 @@
     LOG_DEBUG ("Added host %u at %u\n", host_id, GST_context->host_id);
     reply = GNUNET_malloc (reply_size);
   }
-  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM);
+  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS);
   reply->header.size = htons (reply_size);
   reply->host_id = htonl (host_id);
   GST_queue_message (client, &reply->header);
@@ -1351,7 +1352,7 @@
   struct ForwardedOperationContext *fopc = cls;
   struct Peer *remote_peer;
 
-  if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS)
+  if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS)
   {
     GNUNET_assert (NULL != fopc->cls);
     remote_peer = fopc->cls;
@@ -1401,7 +1402,8 @@
   struct ForwardedOperationContext *fopc = cls;
   struct Peer *remote_peer;
 
-  if (GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS == ntohs (msg->type))
+  if (GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS ==
+      ntohs (msg->type))
   {
     remote_peer = fopc->cls;
     GNUNET_assert (NULL != remote_peer);
@@ -1520,7 +1522,8 @@
                        (struct GNUNET_TESTBED_PeerCreateSuccessEventMessage));
     reply->header.size =
         htons (sizeof (struct GNUNET_TESTBED_PeerCreateSuccessEventMessage));
-    reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS);
+    reply->header.type =
+        htons (GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS);
     reply->peer_id = msg->peer_id;
     reply->operation_id = msg->operation_id;
     GST_queue_message (client, &reply->header);
@@ -1681,7 +1684,7 @@
   }
   peer->details.local.is_running = GNUNET_YES;
   reply = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
-  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT);
+  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT);
   reply->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
   reply->event_type = htonl (GNUNET_TESTBED_ET_PEER_START);
   reply->host_id = htonl (GST_context->host_id);
@@ -1753,7 +1756,7 @@
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Peer %u successfully stopped\n", peer_id);
   peer->details.local.is_running = GNUNET_NO;
   reply = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
-  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT);
+  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT);
   reply->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
   reply->event_type = htonl (GNUNET_TESTBED_ET_PEER_STOP);
   reply->host_id = htonl (GST_context->host_id);
@@ -1830,7 +1833,7 @@
   reply = GNUNET_realloc (xconfig, msize);
   (void) memmove (&reply[1], reply, xc_size);
   reply->header.size = htons (msize);
-  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG);
+  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION);
   reply->peer_id = msg->peer_id;
   reply->operation_id = msg->operation_id;
   GNUNET_TESTING_peer_get_identity (GST_peer_list[peer_id]->details.local.peer,
@@ -1890,7 +1893,7 @@
   GNUNET_break (config_size <= UINT16_MAX);
   reply = GNUNET_realloc (xconfig, reply_size);
   (void) memmove (&reply[1], reply, xconfig_size);
-  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG);
+  reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION);
   reply->header.size = htons ((uint16_t) reply_size);
   reply->slave_id = msg->slave_id;
   reply->operation_id = msg->operation_id;
@@ -2150,25 +2153,28 @@
 {
   static const struct GNUNET_SERVER_MessageHandler message_handlers[] = {
     {&handle_init, NULL, GNUNET_MESSAGE_TYPE_TESTBED_INIT, 0},
-    {&handle_add_host, NULL, GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST, 0},
+    {&handle_add_host, NULL, GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST, 0},
     {&handle_configure_shared_service, NULL,
-     GNUNET_MESSAGE_TYPE_TESTBED_SERVICESHARE, 0},
+     GNUNET_MESSAGE_TYPE_TESTBED_SHARE_SERVICE, 0},
     {&handle_link_controllers, NULL,
-     GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS, 0},
-    {&handle_peer_create, NULL, GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER, 0},
-    {&handle_peer_destroy, NULL, GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER,
+     GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS, 0},
+    {&handle_peer_create, NULL, GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER, 0},
+    {&handle_peer_destroy, NULL, GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER,
      sizeof (struct GNUNET_TESTBED_PeerDestroyMessage)},
-    {&handle_peer_start, NULL, GNUNET_MESSAGE_TYPE_TESTBED_STARTPEER,
+    {&handle_peer_start, NULL, GNUNET_MESSAGE_TYPE_TESTBED_START_PEER,
      sizeof (struct GNUNET_TESTBED_PeerStartMessage)},
-    {&handle_peer_stop, NULL, GNUNET_MESSAGE_TYPE_TESTBED_STOPPEER,
+    {&handle_peer_stop, NULL, GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER,
      sizeof (struct GNUNET_TESTBED_PeerStopMessage)},
-    {&handle_peer_get_config, NULL, GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG,
+    {&handle_peer_get_config, NULL,
+     GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION,
      sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage)},
-    {&GST_handle_overlay_connect, NULL, GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT,
+    {&GST_handle_overlay_connect, NULL,
+     GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT,
      sizeof (struct GNUNET_TESTBED_OverlayConnectMessage)},
-    {&GST_handle_overlay_request_connect, NULL,
-     GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT, 0},
-    {handle_slave_get_config, NULL, GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG,
+    {&GST_handle_remote_overlay_connect, NULL,
+     GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT, 0},
+    {handle_slave_get_config, NULL,
+     GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION,
      sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage)},
     {NULL}
   };
@@ -2189,10 +2195,8 @@
   GST_cache_init ((unsigned int) num);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_number (cfg, "TESTBED",
-                                                        "MAX_OPEN_FDS",
-                                                        &num));
-  GST_opq_openfds = 
-      GNUNET_TESTBED_operation_queue_create_ ((unsigned int) num);
+                                                        "MAX_OPEN_FDS", &num));
+  GST_opq_openfds = GNUNET_TESTBED_operation_queue_create_ ((unsigned int) 
num);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, "testbed",
                                                         "HOSTNAME", 
&hostname));

Modified: gnunet/src/testbed/gnunet-service-testbed.h
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed.h 2013-01-26 09:50:37 UTC (rev 
25919)
+++ gnunet/src/testbed/gnunet-service-testbed.h 2013-01-26 14:00:28 UTC (rev 
25920)
@@ -764,9 +764,9 @@
  * @param message the actual message
  */
 void
-GST_handle_overlay_request_connect (void *cls,
-                                    struct GNUNET_SERVER_Client *client,
-                                    const struct GNUNET_MessageHeader 
*message);
+GST_handle_remote_overlay_connect (void *cls,
+                                   struct GNUNET_SERVER_Client *client,
+                                   const struct GNUNET_MessageHeader *message);
 
 
 /**

Modified: gnunet/src/testbed/gnunet-service-testbed_oc.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_oc.c      2013-01-26 09:50:37 UTC 
(rev 25919)
+++ gnunet/src/testbed/gnunet-service-testbed_oc.c      2013-01-26 14:00:28 UTC 
(rev 25920)
@@ -191,17 +191,17 @@
  * hosts and the host controller for peer B is asked by the host controller of
  * peer A to make peer B connect to peer A
  */
-struct RequestOverlayConnectContext
+struct RemoteOverlayConnectCtx
 {
   /**
    * the next pointer for DLL
    */
-  struct RequestOverlayConnectContext *next;
+  struct RemoteOverlayConnectCtx *next;
 
   /**
    * the prev pointer for DLL
    */
-  struct RequestOverlayConnectContext *prev;
+  struct RemoteOverlayConnectCtx *prev;
 
   /**
    * The peer handle of peer B
@@ -219,6 +219,11 @@
   struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;
 
   /**
+   * The local operation we create for this overlay connection
+   */
+  struct GNUNET_TESTBED_Operation *lop;
+
+  /**
    * The transport try connect context
    */
   struct TryConnectContext tcc;
@@ -259,12 +264,12 @@
  * DLL head for RequectOverlayConnectContext DLL - to be used to clean up 
during
  * shutdown
  */
-static struct RequestOverlayConnectContext *roccq_head;
+static struct RemoteOverlayConnectCtx *roccq_head;
 
 /**
  * DLL tail for RequectOverlayConnectContext DLL
  */
-static struct RequestOverlayConnectContext *roccq_tail;
+static struct RemoteOverlayConnectCtx *roccq_tail;
 
 
 /**
@@ -526,7 +531,7 @@
   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
   msg->header.size =
       htons (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEERCONEVENT);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT);
   msg->event_type = htonl (GNUNET_TESTBED_ET_CONNECT);
   msg->peer1 = htonl (occ->peer_id);
   msg->peer2 = htonl (occ->other_peer_id);
@@ -658,7 +663,7 @@
   other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
   if (NULL != occ->peer2_controller)
   {
-    struct GNUNET_TESTBED_RequestConnectMessage *msg;
+    struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg;
     uint16_t msize;
     uint16_t hello_size;
 
@@ -667,9 +672,11 @@
                GNUNET_i2s (&occ->peer_identity), ntohs (occ->hello->size),
                other_peer_str);
     hello_size = ntohs (occ->hello->size);
-    msize = sizeof (struct GNUNET_TESTBED_RequestConnectMessage) + hello_size;
+    msize =
+        sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + 
hello_size;
     msg = GNUNET_malloc (msize);
-    msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT);
+    msg->header.type =
+        htons (GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT);
     msg->header.size = htons (msize);
     msg->peer = htonl (occ->other_peer_id);
     msg->operation_id = GNUNET_htonll (occ->op_id);
@@ -929,7 +936,7 @@
   const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *cmsg;
 
   occ->opc = NULL;
-  if (GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG != ntohs (msg->type))
+  if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION != ntohs (msg->type))
   {
     GNUNET_SCHEDULER_cancel (occ->timeout_task);
     occ->timeout_task =
@@ -1234,7 +1241,8 @@
 
     cmsg.header.size =
         htons (sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
-    cmsg.header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG);
+    cmsg.header.type =
+        htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION);
     cmsg.peer_id = msg->peer2;
     cmsg.operation_id = msg->operation_id;
     occ->opc =
@@ -1266,13 +1274,13 @@
 
 
 /**
- * Function to cleanup RequestOverlayConnectContext and any associated tasks
+ * Function to cleanup RemoteOverlayConnectCtx and any associated tasks
  * with it
  *
- * @param rocc the RequestOverlayConnectContext
+ * @param rocc the RemoteOverlayConnectCtx
  */
 static void
-cleanup_rocc (struct RequestOverlayConnectContext *rocc)
+cleanup_rocc (struct RemoteOverlayConnectCtx *rocc)
 {
   LOG_DEBUG ("0x%llx: Cleaning up rocc\n", rocc->op_id);
   if (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id)
@@ -1299,13 +1307,13 @@
 /**
  * Task to timeout rocc and cleanit up
  *
- * @param cls the RequestOverlayConnectContext
+ * @param cls the RemoteOverlayConnectCtx
  * @param tc the TaskContext from scheduler
  */
 static void
 timeout_rocc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct RequestOverlayConnectContext *rocc = cls;
+  struct RemoteOverlayConnectCtx *rocc = cls;
 
   GNUNET_assert (rocc->timeout_rocc_task_id != GNUNET_SCHEDULER_NO_TASK);
   rocc->timeout_rocc_task_id = GNUNET_SCHEDULER_NO_TASK;
@@ -1328,7 +1336,7 @@
                           const struct GNUNET_ATS_Information *ats,
                           uint32_t ats_count)
 {
-  struct RequestOverlayConnectContext *rocc = cls;
+  struct RemoteOverlayConnectCtx *rocc = cls;
 
   LOG_DEBUG ("0x%llx: Request Overlay connect notify\n", rocc->op_id);
   if (0 != memcmp (new_peer, &rocc->a_id, sizeof (struct GNUNET_PeerIdentity)))
@@ -1341,9 +1349,9 @@
 
 /**
  * Task to offer the HELLO message to the peer and ask it to connect to the 
peer
- * whose identity is in RequestOverlayConnectContext
+ * whose identity is in RemoteOverlayConnectCtx
  *
- * @param cls the RequestOverlayConnectContext
+ * @param cls the RemoteOverlayConnectCtx
  * @param tc the TaskContext from scheduler
  */
 static void
@@ -1361,7 +1369,7 @@
 static void
 rocc_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct RequestOverlayConnectContext *rocc = cls;
+  struct RemoteOverlayConnectCtx *rocc = cls;
 
   rocc->ohh = NULL;
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rocc->attempt_connect_task_id);
@@ -1382,15 +1390,15 @@
 
 /**
  * Task to offer the HELLO message to the peer and ask it to connect to the 
peer
- * whose identity is in RequestOverlayConnectContext
+ * whose identity is in RemoteOverlayConnectCtx
  *
- * @param cls the RequestOverlayConnectContext
+ * @param cls the RemoteOverlayConnectCtx
  * @param tc the TaskContext from scheduler
  */
 static void
 attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct RequestOverlayConnectContext *rocc = cls;
+  struct RemoteOverlayConnectCtx *rocc = cls;
 
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id);
   rocc->attempt_connect_task_id = GNUNET_SCHEDULER_NO_TASK;
@@ -1418,25 +1426,25 @@
  * @param message the actual message
  */
 void
-GST_handle_overlay_request_connect (void *cls,
-                                    struct GNUNET_SERVER_Client *client,
-                                    const struct GNUNET_MessageHeader *message)
+GST_handle_remote_overlay_connect (void *cls,
+                                   struct GNUNET_SERVER_Client *client,
+                                   const struct GNUNET_MessageHeader *message)
 {
-  const struct GNUNET_TESTBED_RequestConnectMessage *msg;
-  struct RequestOverlayConnectContext *rocc;
+  const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg;
+  struct RemoteOverlayConnectCtx *rocc;
   struct Peer *peer;
   uint32_t peer_id;
   uint16_t msize;
   uint16_t hsize;
 
   msize = ntohs (message->size);
-  if (sizeof (struct GNUNET_TESTBED_RequestConnectMessage) >= msize)
+  if (sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) >= msize)
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  msg = (const struct GNUNET_TESTBED_RequestConnectMessage *) message;
+  msg = (const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *) message;
   if ((NULL == msg->hello) ||
       (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type)))
   {
@@ -1445,7 +1453,8 @@
     return;
   }
   hsize = ntohs (msg->hello->size);
-  if ((sizeof (struct GNUNET_TESTBED_RequestConnectMessage) + hsize) != msize)
+  if ((sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) !=
+      msize)
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -1469,7 +1478,7 @@
     GNUNET_SERVER_receive_done (client, GNUNET_OK);
     return;
   }
-  rocc = GNUNET_malloc (sizeof (struct RequestOverlayConnectContext));
+  rocc = GNUNET_malloc (sizeof (struct RemoteOverlayConnectCtx));
   rocc->op_id = GNUNET_ntohll (msg->operation_id);
   GNUNET_CONTAINER_DLL_insert_tail (roccq_head, roccq_tail, rocc);
   memcpy (&rocc->a_id, &msg->peer_identity,
@@ -1520,7 +1529,7 @@
 void
 GST_free_roccq ()
 {
-  struct RequestOverlayConnectContext *rocc;
+  struct RemoteOverlayConnectCtx *rocc;
 
   while (NULL != (rocc = roccq_head))
     cleanup_rocc (rocc);

Modified: gnunet/src/testbed/testbed.h
===================================================================
--- gnunet/src/testbed/testbed.h        2013-01-26 09:50:37 UTC (rev 25919)
+++ gnunet/src/testbed/testbed.h        2013-01-26 14:00:28 UTC (rev 25920)
@@ -33,7 +33,7 @@
 /**
  * Initial message from a client to a testing control service.
  */
-struct GNUNET_TESTBED_InitMessage
+    struct GNUNET_TESTBED_InitMessage
 {
 
   /**
@@ -66,7 +66,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST
    */
   struct GNUNET_MessageHeader header;
 
@@ -103,7 +103,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRMED
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS
    */
   struct GNUNET_MessageHeader header;
 
@@ -126,7 +126,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_SERVICESHARE
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_SHARE_SERVICE
    */
   struct GNUNET_MessageHeader header;
 
@@ -155,7 +155,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS
    */
   struct GNUNET_MessageHeader header;
 
@@ -199,7 +199,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER
    */
   struct GNUNET_MessageHeader header;
 
@@ -237,7 +237,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPDE_TESTBED_PEERRECONF
+   * Type is GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER
    */
   struct GNUNET_MessageHeader header;
 
@@ -265,7 +265,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_STARTPEER
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_START_PEER
    */
   struct GNUNET_MessageHeader header;
 
@@ -290,7 +290,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_STOPPEER
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER
    */
   struct GNUNET_MessageHeader header;
 
@@ -315,7 +315,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER
    */
   struct GNUNET_MessageHeader header;
 
@@ -340,7 +340,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_CONFIGULLINK
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_CONFIGURE_UNDERLAY_LINK
    */
   struct GNUNET_MessageHeader header;
 
@@ -377,7 +377,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT
    */
   struct GNUNET_MessageHeader header;
 
@@ -408,10 +408,10 @@
  * Message sent from host controller of a peer(A) to the host controller of
  * another peer(B) to request B to connect to A
  */
-struct GNUNET_TESTBED_RequestConnectMessage
+struct GNUNET_TESTBED_RemoteOverlayConnectMessage
 {
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT
    */
   struct GNUNET_MessageHeader header;
 
@@ -445,7 +445,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT
    */
   struct GNUNET_MessageHeader header;
 
@@ -480,7 +480,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEERCONEVENT
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT
    */
   struct GNUNET_MessageHeader header;
 
@@ -515,7 +515,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONFAILEVENT
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT
    */
   struct GNUNET_MessageHeader header;
 
@@ -542,7 +542,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS
    */
   struct GNUNET_MessageHeader header;
 
@@ -568,7 +568,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS
    */
   struct GNUNET_MessageHeader header;
 
@@ -594,7 +594,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION
    */
   struct GNUNET_MessageHeader header;
 
@@ -618,7 +618,7 @@
 {
 
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION
    */
   struct GNUNET_MessageHeader header;
 
@@ -653,7 +653,7 @@
 struct GNUNET_TESTBED_SlaveGetConfigurationMessage
 {
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION
    */
   struct GNUNET_MessageHeader header;
 
@@ -671,12 +671,12 @@
 
 
 /**
- * Reply to GETSLAVECONFIG message
+ * Reply to GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIG message
  */
 struct GNUNET_TESTBED_SlaveConfiguration
 {
   /**
-   * Type is GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG
+   * Type is GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION
    */
   struct GNUNET_MessageHeader header;
 

Modified: gnunet/src/testbed/testbed_api.c
===================================================================
--- gnunet/src/testbed/testbed_api.c    2013-01-26 09:50:37 UTC (rev 25919)
+++ gnunet/src/testbed/testbed_api.c    2013-01-26 14:00:28 UTC (rev 25920)
@@ -975,7 +975,8 @@
   msize = sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage);
   msg = GNUNET_malloc (msize);
   msg->header.size = htons (msize);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG);
+  msg->header.type =
+      htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION);
   msg->operation_id = GNUNET_htonll (op_id);
   msg->slave_id = htonl (slave_id);
   return msg;
@@ -1053,7 +1054,7 @@
   msize = ntohs (msg->size);
   switch (ntohs (msg->type))
   {
-  case GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM:
+  case GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS:
     GNUNET_assert (msize >=
                    sizeof (struct GNUNET_TESTBED_HostConfirmedMessage));
     status =
@@ -1061,7 +1062,7 @@
                                (const struct 
GNUNET_TESTBED_HostConfirmedMessage
                                 *) msg);
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS:
+  case GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS:
     GNUNET_assert (msize ==
                    sizeof (struct
                            
GNUNET_TESTBED_GenericOperationSuccessEventMessage));
@@ -1071,7 +1072,7 @@
                            GNUNET_TESTBED_GenericOperationSuccessEventMessage 
*)
                           msg);
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS:
+  case GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS:
     GNUNET_assert (msize ==
                    sizeof (struct
                            GNUNET_TESTBED_PeerCreateSuccessEventMessage));
@@ -1081,7 +1082,7 @@
                                      
GNUNET_TESTBED_PeerCreateSuccessEventMessage
                                      *) msg);
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT:
+  case GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT:
     GNUNET_assert (msize == sizeof (struct GNUNET_TESTBED_PeerEventMessage));
     status =
         handle_peer_event (c,
@@ -1089,7 +1090,7 @@
                            msg);
 
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG:
+  case GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION:
     GNUNET_assert (msize >=
                    sizeof (struct
                            
GNUNET_TESTBED_PeerConfigurationInformationMessage));
@@ -1099,7 +1100,7 @@
                              GNUNET_TESTBED_PeerConfigurationInformationMessage
                              *) msg);
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_PEERCONEVENT:
+  case GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT:
     GNUNET_assert (msize ==
                    sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
     status =
@@ -1107,7 +1108,7 @@
                               (const struct
                                GNUNET_TESTBED_ConnectionEventMessage *) msg);
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONFAILEVENT:
+  case GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT:
     GNUNET_assert (msize >=
                    sizeof (struct 
GNUNET_TESTBED_OperationFailureEventMessage));
     status =
@@ -1116,7 +1117,7 @@
                                GNUNET_TESTBED_OperationFailureEventMessage *)
                               msg);
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG:
+  case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION:
     GNUNET_assert (msize > sizeof (struct GNUNET_TESTBED_SlaveConfiguration));
     status =
         handle_slave_config (c,
@@ -1922,7 +1923,7 @@
       service_name_size;
   msg = GNUNET_malloc (msg_size);
   msg->header.size = htons (msg_size);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SERVICESHARE);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SHARE_SERVICE);
   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (controller->host));
   msg->num_peers = htonl (num_peers);
   memcpy (&msg[1], service_name, service_name_size);
@@ -2026,7 +2027,7 @@
   msg_size += strlen (hostname) + 1;
   msg = GNUNET_malloc (msg_size);
   msg->header.size = htons (msg_size);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST);
   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
   msg->ssh_port = htons (GNUNET_TESTBED_host_get_ssh_port_ (host));
   if (NULL != username)
@@ -2097,7 +2098,7 @@
 
   msg_size = sxcfg_size + sizeof (struct GNUNET_TESTBED_ControllerLinkMessage);
   msg = GNUNET_malloc (msg_size);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS);
   msg->header.size = htons (msg_size);
   msg->delegated_host_id = htonl (delegated_host_id);
   msg->slave_host_id = htonl (slave_host_id);
@@ -2492,7 +2493,7 @@
 
   switch (ntohs (msg->type))
   {
-  case GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG:
+  case GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION:
   {
     const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *imsg;
 
@@ -2505,7 +2506,7 @@
     xdata = (const Bytef *) &imsg[1];
   }
     break;
-  case GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG:
+  case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION:
   {
     const struct GNUNET_TESTBED_SlaveConfiguration *imsg;
 

Modified: gnunet/src/testbed/testbed_api_peers.c
===================================================================
--- gnunet/src/testbed/testbed_api_peers.c      2013-01-26 09:50:37 UTC (rev 
25919)
+++ gnunet/src/testbed/testbed_api_peers.c      2013-01-26 14:00:28 UTC (rev 
25920)
@@ -64,7 +64,7 @@
   msg = GNUNET_realloc (xconfig, msize);
   memmove (&msg[1], msg, xc_size);
   msg->header.size = htons (msize);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER);
   msg->operation_id = GNUNET_htonll (opc->id);
   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (data->peer->host));
   msg->peer_id = htonl (data->peer->unique_id);
@@ -118,7 +118,7 @@
   opc->state = OPC_STATE_STARTED;
   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerDestroyMessage));
   msg->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerDestroyMessage));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER);
   msg->peer_id = htonl (peer->unique_id);
   msg->operation_id = GNUNET_htonll (opc->id);
   GNUNET_CONTAINER_DLL_insert_tail (opc->c->ocq_head, opc->c->ocq_tail, opc);
@@ -164,7 +164,7 @@
   opc->state = OPC_STATE_STARTED;
   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerStartMessage));
   msg->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerStartMessage));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_STARTPEER);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_START_PEER);
   msg->peer_id = htonl (peer->unique_id);
   msg->operation_id = GNUNET_htonll (opc->id);
   GNUNET_CONTAINER_DLL_insert_tail (opc->c->ocq_head, opc->c->ocq_tail, opc);
@@ -211,7 +211,7 @@
   GNUNET_assert (PS_STARTED == peer->state);
   opc->state = OPC_STATE_STARTED;
   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerStopMessage));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_STOPPEER);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER);
   msg->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerStopMessage));
   msg->peer_id = htonl (peer->unique_id);
   msg->operation_id = GNUNET_htonll (opc->id);
@@ -258,7 +258,7 @@
                      (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
   msg->header.size =
       htons (sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG);
+  msg->header.type = htons 
(GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION);
   msg->peer_id = htonl (peer_id);
   msg->operation_id = GNUNET_htonll (operation_id);
   return msg;
@@ -345,7 +345,7 @@
   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_OverlayConnectMessage));
   msg->header.size =
       htons (sizeof (struct GNUNET_TESTBED_OverlayConnectMessage));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT);
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT);
   msg->peer1 = htonl (data->p1->unique_id);
   msg->peer2 = htonl (data->p2->unique_id);
   msg->operation_id = GNUNET_htonll (opc->id);

Modified: gnunet/src/testbed/testbed_api_services.c
===================================================================
--- gnunet/src/testbed/testbed_api_services.c   2013-01-26 09:50:37 UTC (rev 
25919)
+++ gnunet/src/testbed/testbed_api_services.c   2013-01-26 14:00:28 UTC (rev 
25920)
@@ -146,7 +146,7 @@
   info.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
   info.details.operation_finished.operation = data->operation;
   info.details.operation_finished.op_cls = data->op_cls;
-  if (GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONFAILEVENT == mtype)
+  if (GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT == mtype)
   {
     emsg =
         GNUNET_TESTBED_parse_error_string_ ((const struct




reply via email to

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