[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r27044 - gnunet/src/testbed
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r27044 - gnunet/src/testbed |
|
Date: |
Mon, 6 May 2013 18:06:08 +0200 |
Author: harsha
Date: 2013-05-06 18:06:08 +0200 (Mon, 06 May 2013)
New Revision: 27044
Modified:
gnunet/src/testbed/gnunet-service-testbed.h
gnunet/src/testbed/gnunet-service-testbed_links.c
gnunet/src/testbed/gnunet-service-testbed_links.h
gnunet/src/testbed/gnunet-service-testbed_oc.c
Log:
- doc
Modified: gnunet/src/testbed/gnunet-service-testbed.h
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed.h 2013-05-06 15:09:47 UTC (rev
27043)
+++ gnunet/src/testbed/gnunet-service-testbed.h 2013-05-06 16:06:08 UTC (rev
27044)
@@ -345,23 +345,6 @@
/**
- * The type for data structures which commonly arrive at the
slave_event_callback
- */
-enum ClosureType
-{
- /**
- * Type for RegisteredHostContext closures
- */
- CLOSURE_TYPE_RHC = 1,
-
- /**
- * Type for LinkControllersForwardingContext closures
- */
- CLOSURE_TYPE_LCF
-};
-
-
-/**
* This context information will be created for each host that is registered at
* slave controllers during overlay connects.
*/
@@ -482,16 +465,16 @@
extern char *GST_stats_dir;
/**
- * Condition to check if host id is invalid
+ * Condition to check if host id is valid
*/
-#define INVALID_HOST_ID(id) \
- ( ((id) >= GST_host_list_size) || (NULL == GST_host_list[id]) )
+#define VALID_HOST_ID(id) \
+ ( ((id) < GST_host_list_size) && (NULL != GST_host_list[id]) )
/**
- * Condition to check if peer id is invalid
+ * Condition to check if peer id is valid
*/
-#define INVALID_PEER_ID(id) \
- ( ((id) >= GST_peer_list_size) || (NULL == GST_peer_list[id]) )
+#define VALID_PEER_ID(id) \
+ ( ((id) < GST_peer_list_size) && (NULL != GST_peer_list[id]) )
/**
Modified: gnunet/src/testbed/gnunet-service-testbed_links.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_links.c 2013-05-06 15:09:47 UTC
(rev 27043)
+++ gnunet/src/testbed/gnunet-service-testbed_links.c 2013-05-06 16:06:08 UTC
(rev 27044)
@@ -75,11 +75,6 @@
struct LCFContext
{
/**
- * The type of this data structure. Set this to CLOSURE_TYPE_LCF
- */
- enum ClosureType type;
-
- /**
* The gateway which will pass the link message to delegated host
*/
struct Slave *gateway;
@@ -148,15 +143,40 @@
struct LCFContextQueue *prev;
};
+
+/**
+ * Notification context to be used to notify when connection to the neighbour's
+ * controller is opened
+ */
struct NeighbourConnectNotification
{
+ /**
+ * DLL next for inclusion in neighbour's list of notification requests
+ */
struct NeighbourConnectNotification *next;
+
+ /**
+ * DLL prev
+ */
struct NeighbourConnectNotification *prev;
+
+ /**
+ * The neighbour
+ */
struct Neighbour *n;
+
+ /**
+ * The notification callback to call when we are connect to neighbour
+ */
GST_NeigbourConnectNotifyCallback cb;
+
+ /**
+ * The closure for the above callback
+ */
void *cb_cls;
};
-
+
+
/**
* A connected controller which is not our child
*/
@@ -173,39 +193,100 @@
*/
struct GNUNET_TESTBED_Operation *conn_op;
+ /**
+ * DLL head for the list of notification requests
+ */
struct NeighbourConnectNotification *nl_head;
+ /**
+ * DLL tail for the list of notification requests
+ */
struct NeighbourConnectNotification *nl_tail;
+ /**
+ * Task id for the task to call notifications from the notification list
+ */
GNUNET_SCHEDULER_TaskIdentifier notify_task;
+ /**
+ * How many references are present currently to this neighbour's connection
+ */
unsigned int reference_cnt;
+ /**
+ * Is the conn_op inactivated?
+ */
unsigned int inactive;
-
/**
* The id of the host this controller is running on
*/
- uint32_t host_id;
-
+ uint32_t host_id;
};
+
+/**
+ * The neighbour list
+ */
static struct Neighbour **neighbour_list;
+
+/**
+ * The size of the neighbour list
+ */
static unsigned int neighbour_list_size;
+
+/**
+ * Context information for establishing a link to neighbour (Used is
+ * GST_handle_link_controllers()
+ */
struct NeighbourConnectCtxt
{
+ /**
+ * DLL next for inclusion in the corresponding context list
+ */
struct NeighbourConnectCtxt *next;
+
+ /**
+ * DLL tail
+ */
struct NeighbourConnectCtxt *prev;
+
+ /**
+ * The neighbour to whom connection should be made
+ */
struct Neighbour *n;
+
+ /**
+ * The client requesting the connection
+ */
struct GNUNET_SERVER_Client *client;
+
+ /**
+ * Task to be run upon timeout
+ */
GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+ /**
+ * The notification handle associated with the neighbour's connection request
+ */
struct NeighbourConnectNotification *nh;
+
+ /**
+ * The id of the link-controllers operation responsible for creating this
+ * context
+ */
uint64_t op_id;
};
+/**
+ * DLL head for the list of neighbour connect contexts
+ */
struct NeighbourConnectCtxt *ncc_head;
+
+/**
+ * DLL tail for the list of neighbour connect contexts
+ */
struct NeighbourConnectCtxt *ncc_tail;
/**
@@ -274,6 +355,13 @@
route_list[route->dest] = route;
}
+
+/**
+ * Add a neighbour to the neighbour list. Grows the neighbour list
+ * automatically.
+ *
+ * @param n the neighbour to add
+ */
static void
neighbour_list_add (struct Neighbour *n)
{
@@ -611,8 +699,7 @@
* @param event information about the event
*/
static void
-slave_event_callback (void *cls,
- const struct GNUNET_TESTBED_EventInformation *event)
+slave_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
{
struct LCFContext *lcf;
@@ -620,31 +707,24 @@
LCFContexts */
GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
lcf = event->op_cls;
- if (CLOSURE_TYPE_LCF == lcf->type)
- {
- GNUNET_assert (lcf->op == event->op);
- GNUNET_assert (FINISHED == lcf->state);
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != lcf->timeout_task);
- GNUNET_SCHEDULER_cancel (lcf->timeout_task);
- if (NULL == event->details.operation_finished.emsg)
- send_controller_link_response (lcf->client, lcf->operation_id,
- GNUNET_TESTBED_host_get_cfg_
- (GST_host_list[lcf->delegated_host_id]),
- NULL);
- else
- send_controller_link_response (lcf->client, lcf->operation_id,
- NULL,
- event->details.operation_finished.emsg);
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
- lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
- return;
- }
- GNUNET_assert (0);
+ GNUNET_assert (lcf->op == event->op);
+ GNUNET_assert (FINISHED == lcf->state);
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != lcf->timeout_task);
+ GNUNET_SCHEDULER_cancel (lcf->timeout_task);
+ if (NULL == event->details.operation_finished.emsg)
+ send_controller_link_response (lcf->client, lcf->operation_id,
+ GNUNET_TESTBED_host_get_cfg_
+ (GST_host_list[lcf->delegated_host_id]),
+ NULL);
+ else
+ send_controller_link_response (lcf->client, lcf->operation_id,
+ NULL,
+ event->details.operation_finished.emsg);
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+ return;
}
-static void
-slave_status_callback (void *cls, const struct GNUNET_CONFIGURATION_Handle
*cfg,
- int status);
/**
* Callback to signal successfull startup of the controller process
@@ -656,8 +736,8 @@
* GNUNET_TESTBED_controller_stop() shouldn't be called in this case
*/
static void
-slave_status_callback (void *cls, const struct GNUNET_CONFIGURATION_Handle
*cfg,
- int status)
+slave_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
+ int status)
{
struct Slave *slave = cls;
struct LinkControllersContext *lcc;
@@ -675,7 +755,7 @@
}
slave->controller =
GNUNET_TESTBED_controller_connect (GST_host_list[slave->host_id],
- EVENT_MASK, &slave_event_callback,
+ EVENT_MASK, &slave_event_cb,
slave);
if (NULL != slave->controller)
{
@@ -706,10 +786,52 @@
slave->lcc = NULL;
}
+
+/**
+ * Trigger notification task if there are notification requests currently
+ * waiting in the given neighbour. Also activates the neighbour connect
operation
+ * if it was previously inactivated so that the connection to the neighbour can
+ * be re-used
+ *
+ * @param n the neighbour
+ */
static void
+trigger_notifications (struct Neighbour *n);
+
+
+/**
+ * Task to call the notification queued in the notifications list of the given
+ * neighbour
+ *
+ * @param cls the neighbour
+ * @param tc scheduler task context
+ */
+static void
neighbour_connect_notify_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct Neighbour *n = cls;
+ struct NeighbourConnectNotification *h;
+ GNUNET_assert (NULL != (h = n->nl_head));
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != n->notify_task);
+ n->notify_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_assert (NULL != n->controller);
+ GNUNET_CONTAINER_DLL_remove (n->nl_head, n->nl_tail, h);
+ trigger_notifications (n);
+ h->cb (h->cb_cls, n->controller);
+ GNUNET_free (h);
+}
+
+
+/**
+ * Trigger notification task if there are notification requests currently
+ * waiting in the given neighbour. Also activates the neighbour connect
operation
+ * if it was previously inactivated so that the connection to the neighbour can
+ * be re-used
+ *
+ * @param n the neighbour
+ */
static void
trigger_notifications (struct Neighbour *n)
{
@@ -731,23 +853,14 @@
GNUNET_SCHEDULER_add_now (&neighbour_connect_notify_task, n);
}
-static void
-neighbour_connect_notify_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct Neighbour *n = cls;
- struct NeighbourConnectNotification *h;
- GNUNET_assert (NULL != (h = n->nl_head));
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != n->notify_task);
- n->notify_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_assert (NULL != n->controller);
- GNUNET_CONTAINER_DLL_remove (n->nl_head, n->nl_tail, h);
- trigger_notifications (n);
- h->cb (h->cb_cls, n->controller);
- GNUNET_free (h);
-}
-
+/**
+ * Callback to be called when the neighbour connect operation is started. The
+ * connection to the neigbour is opened here and any pending notifications are
+ * trigger.
+ *
+ * @param cls the neighbour
+ */
static void
opstart_neighbour_conn (void *cls)
{
@@ -758,11 +871,17 @@
LOG_DEBUG ("Opening connection to controller on host %u\n", n->host_id);
n->controller = GNUNET_TESTBED_controller_connect (GST_host_list[n->host_id],
EVENT_MASK,
- &slave_event_callback,
+ &slave_event_cb,
NULL);
trigger_notifications (n);
}
+
+/**
+ * Callback to be called when the neighbour connect operation is released
+ *
+ * @param cls the neighbour
+ */
static void
oprelease_neighbour_conn (void *cls)
{
@@ -781,6 +900,18 @@
n->inactive = 0;
}
+
+/**
+ * Try to open a connection to the given neigbour. If the connection is open
+ * already, then it is re-used. If not, the request is queued in the operation
+ * queues responsible for bounding the total number of file descriptors. The
+ * actual connection will happen when the operation queue marks the
+ * corresponding operation as active.
+ *
+ * @param n the neighbour to open a connection to
+ * @param cb the notification callback to call when the connection is opened
+ * @param cb_cls the closure for the above callback
+ */
struct NeighbourConnectNotification *
GST_neighbour_get_connection (struct Neighbour *n,
GST_NeigbourConnectNotifyCallback cb,
@@ -809,6 +940,12 @@
return h;
}
+
+/**
+ * Cancel the request for opening a connection to the neighbour
+ *
+ * @param h the notification handle
+ */
void
GST_neighbour_get_connection_cancel (struct NeighbourConnectNotification *h)
{
@@ -839,6 +976,14 @@
trigger_notifications (n);
}
+
+/**
+ * Release the connection to the neighbour. The actual connection will be
+ * closed if connections to other neighbour are waiting (to maintain a bound on
+ * the total number of connections that are open).
+ *
+ * @param n the neighbour whose connection can be closed
+ */
void
GST_neighbour_release_connection (struct Neighbour *n)
{
@@ -852,6 +997,12 @@
}
}
+
+/**
+ * Cleanup neighbour connect contexts
+ *
+ * @param ncc the neighbour connect context to cleanup
+ */
static void
cleanup_ncc (struct NeighbourConnectCtxt *ncc)
{
@@ -864,6 +1015,10 @@
GNUNET_free (ncc);
}
+
+/**
+ * Cleans up the neighbour list
+ */
void
GST_neighbour_list_clean()
{
@@ -882,6 +1037,14 @@
GNUNET_free_non_null (neighbour_list);
}
+
+/**
+ * Get a neighbour from the neighbour list
+ *
+ * @param id the index of the neighbour in the neighbour list
+ * @return the Neighbour; NULL if the given index in invalid (index greater
than
+ * the list size or neighbour at that index is NULL)
+ */
struct Neighbour *
GST_get_neighbour (uint32_t id)
{
@@ -891,6 +1054,10 @@
return neighbour_list[id];
}
+
+/**
+ * Function to cleanup the neighbour connect contexts
+ */
void
GST_free_nccq ()
{
@@ -898,6 +1065,13 @@
cleanup_ncc (ncc_head);
}
+
+/**
+ * Task to be run upon timeout while attempting to connect to the neighbour
+ *
+ * @param cls the NeighbourConnectCtxt created in GST_handle_link_controllers()
+ * @param tc the scheduler task context
+ */
static void
timeout_neighbour_connect (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
@@ -910,6 +1084,13 @@
cleanup_ncc (ncc);
}
+
+/**
+ * Callback called when a connection to the neighbour is made
+ *
+ * @param cls the NeighbourConnectCtxt created in GST_handle_link_controllers()
+ * @param c the handle the neighbour's controller
+ */
static void
neighbour_connect_cb (void *cls, struct GNUNET_TESTBED_Controller *c)
{
@@ -923,6 +1104,12 @@
cleanup_ncc (ncc);
}
+
+/**
+ * Function to create a neigbour and add it into the neighbour list
+ *
+ * @param host the host of the neighbour
+ */
struct Neighbour *
GST_create_neighbour (struct GNUNET_TESTBED_Host *host)
{
@@ -1048,7 +1235,7 @@
slave->controller_proc =
GNUNET_TESTBED_controller_start (GST_context->master_ip,
GST_host_list[slave->host_id],
- &slave_status_callback, slave);
+ &slave_status_cb, slave);
new_route = GNUNET_malloc (sizeof (struct Route));
new_route->dest = delegated_host_id;
new_route->thru = GST_context->host_id;
@@ -1065,7 +1252,6 @@
}
lcfq = GNUNET_malloc (sizeof (struct LCFContextQueue));
lcfq->lcf = GNUNET_malloc (sizeof (struct LCFContext));
- lcfq->lcf->type = CLOSURE_TYPE_LCF;
lcfq->lcf->delegated_host_id = delegated_host_id;
lcfq->lcf->slave_host_id = slave_host_id;
route = GST_find_dest_route (slave_host_id);
Modified: gnunet/src/testbed/gnunet-service-testbed_links.h
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_links.h 2013-05-06 15:09:47 UTC
(rev 27043)
+++ gnunet/src/testbed/gnunet-service-testbed_links.h 2013-05-06 16:06:08 UTC
(rev 27044)
@@ -25,6 +25,10 @@
* @author Sree Harsha Totakura
*/
+
+/**
+ * A connected controller which is not our child
+ */
struct Neighbour;
@@ -92,36 +96,97 @@
*/
extern unsigned int GST_slave_list_size;
+
+/**
+ * Cleans up the neighbour list
+ */
void
GST_neighbour_list_clean();
+
+/**
+ * Get a neighbour from the neighbour list
+ *
+ * @param id the index of the neighbour in the neighbour list
+ * @return the Neighbour; NULL if the given index in invalid (index greater
than
+ * the list size or neighbour at that index is NULL)
+ */
struct Neighbour *
GST_get_neighbour (uint32_t id);
+
+/**
+ * Function to cleanup the neighbour connect contexts
+ */
void
GST_free_nccq ();
+
+/**
+ * Notification context to be used to notify when connection to the neighbour's
+ * controller is opened
+ */
struct NeighbourConnectNotification;
+
+/**
+ * The notification callback to call when we are connect to neighbour
+ *
+ * @param cls the closure given to GST_neighbour_get_connection()
+ * @param controller the controller handle to the neighbour
+ */
typedef void (*GST_NeigbourConnectNotifyCallback) (void *cls,
struct
GNUNET_TESTBED_Controller
*controller);
+
+/**
+ * Try to open a connection to the given neigbour. If the connection is open
+ * already, then it is re-used. If not, the request is queued in the operation
+ * queues responsible for bounding the total number of file descriptors. The
+ * actual connection will happen when the operation queue marks the
+ * corresponding operation as active.
+ *
+ * @param n the neighbour to open a connection to
+ * @param cb the notification callback to call when the connection is opened
+ * @param cb_cls the closure for the above callback
+ */
struct NeighbourConnectNotification *
GST_neighbour_get_connection (struct Neighbour *n,
GST_NeigbourConnectNotifyCallback cb,
void *cb_cls);
+
+/**
+ * Cancel the request for opening a connection to the neighbour
+ *
+ * @param h the notification handle
+ */
void
GST_neighbour_get_connection_cancel (struct NeighbourConnectNotification *h);
+
+/**
+ * Release the connection to the neighbour. The actual connection will be
+ * closed if connections to other neighbour are waiting (to maintain a bound on
+ * the total number of connections that are open).
+ *
+ * @param n the neighbour whose connection can be closed
+ */
void
GST_neighbour_release_connection (struct Neighbour *n);
+
+/**
+ * Function to create a neigbour and add it into the neighbour list
+ *
+ * @param host the host of the neighbour
+ */
struct Neighbour *
GST_create_neighbour (struct GNUNET_TESTBED_Host *host);
+
/**
* Message handler for GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS message
*
Modified: gnunet/src/testbed/gnunet-service-testbed_oc.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_oc.c 2013-05-06 15:09:47 UTC
(rev 27043)
+++ gnunet/src/testbed/gnunet-service-testbed_oc.c 2013-05-06 16:06:08 UTC
(rev 27044)
@@ -439,7 +439,7 @@
focc = rhc->focc_dll_head;
GNUNET_assert (NULL != focc);
GNUNET_assert (RHC_DONE == rhc->state);
- GNUNET_assert (!INVALID_PEER_ID (focc->peer1));
+ GNUNET_assert (VALID_PEER_ID (focc->peer1));
peer = GST_peer_list[focc->peer1];
GNUNET_assert (GNUNET_YES == peer->is_remote);
GNUNET_assert (NULL != (slave = peer->details.remote.slave));
@@ -1199,14 +1199,27 @@
}
+/**
+ * Checks if the given host is registered at the given slave.
+ *
+ * @param slave the slave where registration has to be checked. The check is
+ * actually done through a locally maintained hashmap. No
+ * communication with the slave is involved.
+ * @param host the host to register
+ * @return If the given host is not registered already or the registration is
+ * pending, it returns the registration context. Any overlay
connects
+ * to be forwarded should be queued in the context so that they can
be
+ * executed when the registration is completed. If the given host is
+ * already registered, NULL is returned.
+ */
static struct RegisteredHostContext *
-register_p2_host (struct Slave *slave, uint32_t peer2_host_id)
+register_host (struct Slave *slave, struct GNUNET_TESTBED_Host *host)
{
struct GNUNET_HashCode hash;
struct RegisteredHostContext *rhc;
rhc = GNUNET_malloc (sizeof (struct RegisteredHostContext));
- rhc->reg_host = GST_host_list[peer2_host_id];
+ rhc->reg_host = host;
rhc->host = GST_host_list[slave->host_id];
GNUNET_assert (NULL != rhc->reg_host);
GNUNET_assert (NULL != rhc->host);
@@ -1268,8 +1281,8 @@
p2 = ntohl (msg->peer2);
op_id = GNUNET_ntohll (msg->operation_id);
peer2_host_id = ntohl (msg->peer2_host_id);
- GNUNET_assert (! INVALID_PEER_ID (p1));
- GNUNET_assert (! INVALID_HOST_ID (peer2_host_id));
+ GNUNET_assert (VALID_PEER_ID (p1));
+ GNUNET_assert (VALID_HOST_ID (peer2_host_id));
peer = GST_peer_list[p1];
GNUNET_assert (GNUNET_YES == peer->is_remote);
LOG_DEBUG ("0x%llx: Forwarding overlay connect\n", op_id);
@@ -1282,10 +1295,10 @@
goto forward;
/* Peer2 is either with us OR peer1 and peer2 can be reached through
different subtrees OR peer2 is on a subtree unknown to us */
- if (NULL != (rhc = register_p2_host (peer->details.remote.slave,
- peer2_host_id)))
+ if (NULL != (rhc = register_host (peer->details.remote.slave,
+ GST_host_list[peer2_host_id])))
{
- LOG_DEBUG ("Forwarding with FOCC for connecting peers %u and %u\n", p1,
p2);
+ LOG_DEBUG ("Queueing forwarding FOCC for connecting peers %u and %u\n",
p1, p2);
focc = GNUNET_malloc (sizeof (struct ForwardedOverlayConnectContext));
focc->peer1 = p1;
focc->peer2 = p2;
@@ -1386,7 +1399,7 @@
msg = (const struct GNUNET_TESTBED_OverlayConnectMessage *) message;
p1 = ntohl (msg->peer1);
p2 = ntohl (msg->peer2);
- if INVALID_PEER_ID (p1)
+ if (!VALID_PEER_ID (p1))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -1400,7 +1413,7 @@
peer2_host_id = ntohl (msg->peer2_host_id);
if (GNUNET_YES == peer->is_remote)
{
- if INVALID_HOST_ID (peer2_host_id)
+ if (!VALID_HOST_ID (peer2_host_id))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -1413,11 +1426,11 @@
p2n = NULL;
occ = GNUNET_malloc (sizeof (struct OverlayConnectContext));
occ->type = OCC_TYPE_LOCAL;
- if INVALID_PEER_ID (p2) /* May be peer2 is on a another controller */
+ if (!VALID_PEER_ID (p2)) /* May be peer2 is on a another controller */
{
if (NULL == (p2n = GST_get_neighbour (peer2_host_id)))
{
- if (INVALID_HOST_ID (peer2_host_id))
+ if (!VALID_HOST_ID (peer2_host_id))
{
GNUNET_break (0);
LOG (GNUNET_ERROR_TYPE_WARNING,
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r27044 - gnunet/src/testbed,
gnunet <=