gnunet-service-testbed_links.h File Reference

TESTBED service components that deals with starting slave controllers and establishing lateral links between controllers. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Slave
	Structure representing a connected(directly-linked) controller. More...

Typedefs
typedef void(*	GST_NeighbourConnectNotifyCallback) (void *cls, struct GNUNET_TESTBED_Controller *controller)
	The notification callback to call when we are connect to neighbour. More...

Functions
void	GST_neighbour_list_clean (void)
	Cleans up the neighbour list. More...
struct Neighbour *	GST_get_neighbour (uint32_t id)
	Get a neighbour from the neighbour list. More...
void	GST_free_nccq (void)
	Function to cleanup the neighbour connect contexts. More...
struct NeighbourConnectNotification *	GST_neighbour_get_connection (struct Neighbour *n, GST_NeighbourConnectNotifyCallback cb, void *cb_cls)
	Try to open a connection to the given neighbour. More...
void	GST_neighbour_get_connection_cancel (struct NeighbourConnectNotification *h)
	Cancel the request for opening a connection to the neighbour. More...
void	GST_neighbour_release_connection (struct Neighbour *n)
	Release the connection to the neighbour. More...
struct Neighbour *	GST_create_neighbour (struct GNUNET_TESTBED_Host *host)
	Function to create a neighbour and add it into the neighbour list. More...
void	handle_link_controllers (void *cls, const struct GNUNET_TESTBED_ControllerLinkRequest *msg)
	Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS message. More...
void	GST_link_notify_disconnect (struct GNUNET_SERVICE_Client *client)
	Clean up client handle if we stored any via handle_link_controllers(), the given client disconnected. More...
void	GST_slave_list_clear (void)
	Cleans up the slave list. More...

Variables
struct Slave **	GST_slave_list
	A list of directly linked neighbours. More...
unsigned int	GST_slave_list_size
	The size of directly linked neighbours list. More...

Detailed Description

TESTBED service components that deals with starting slave controllers and establishing lateral links between controllers.

Author

Sree Harsha Totakura

Definition in file gnunet-service-testbed_links.h.

Typedef Documentation

GST_NeighbourConnectNotifyCallback

typedef void(* GST_NeighbourConnectNotifyCallback) (void *cls, struct GNUNET_TESTBED_Controller *controller)

The notification callback to call when we are connect to neighbour.

Parameters

cls	the closure given to GST_neighbour_get_connection()
controller	the controller handle to the neighbour

Definition at line 131 of file gnunet-service-testbed_links.h.

Function Documentation

GST_neighbour_list_clean()

void GST_neighbour_list_clean

(

void

)

Cleans up the neighbour list.

Definition at line 1094 of file gnunet-service-testbed_links.c.

{
  struct Neighbour *n;
  unsigned int id;
 
  for (id = 0; id < neighbour_list_size; id++)
  {
    if (NULL == (n = neighbour_list[id]))
      continue;
    if (NULL != n->conn_op)
      GNUNET_TESTBED_operation_release_ (n->conn_op);
    GNUNET_free (n);
    neighbour_list[id] = NULL;
  }
  GNUNET_free (neighbour_list);
}

References Neighbour::conn_op, GNUNET_free, GNUNET_TESTBED_operation_release_(), id, neighbour_list, and neighbour_list_size.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_get_neighbour()

struct Neighbour* GST_get_neighbour

(

uint32_t

id

)

Get a neighbour from the neighbour list.

Parameters

id	the index of the neighbour in the neighbour list

Returns

the Neighbour; NULL if the given index in invalid (index greater than the list size or neighbour at that index is NULL)

Definition at line 1120 of file gnunet-service-testbed_links.c.

{
  if (neighbour_list_size <= id)
    return NULL;
  return neighbour_list[id];
}

References id, neighbour_list, and neighbour_list_size.

Referenced by handle_overlay_connect().

Here is the caller graph for this function:

GST_free_nccq()

void GST_free_nccq

(

void

)

Function to cleanup the neighbour connect contexts.

Definition at line 1132 of file gnunet-service-testbed_links.c.

{
  while (NULL != ncc_head)
    cleanup_ncc (ncc_head);
}

References cleanup_ncc(), and ncc_head.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbour_get_connection()

struct NeighbourConnectNotification* GST_neighbour_get_connection	(	struct Neighbour *	n,
		GST_NeighbourConnectNotifyCallback	cb,
		void *	cb_cls
	)

Try to open a connection to the given neighbour.

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.

Parameters

n	the neighbour to open a connection to
cb	the notification callback to call when the connection is opened
cb_cls	the closure for the above callback

Definition at line 986 of file gnunet-service-testbed_links.c.

{
  struct NeighbourConnectNotification *h;
 
  GNUNET_assert (NULL != cb);
  LOG_DEBUG ("Attempting to get connection to controller on host %u\n",
             n->host_id);
  h = GNUNET_new (struct NeighbourConnectNotification);
  h->n = n;
  h->cb = cb;
  h->cb_cls = cb_cls;
  GNUNET_CONTAINER_DLL_insert_tail (n->nl_head, n->nl_tail, h);
  if (NULL == n->conn_op)
  {
    GNUNET_assert (NULL == n->controller);
    n->conn_op = GNUNET_TESTBED_operation_create_ (n, &opstart_neighbour_conn,
                                                   &oprelease_neighbour_conn);
    GNUNET_TESTBED_operation_queue_insert_ (GST_opq_openfds, n->conn_op);
    GNUNET_TESTBED_operation_begin_wait_ (n->conn_op);
    return h;
  }
  trigger_notifications (n);
  return h;
}

References NeighbourConnectNotification::cb, NeighbourConnectNotification::cb_cls, Neighbour::conn_op, Neighbour::controller, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_new, GNUNET_TESTBED_operation_begin_wait_(), GNUNET_TESTBED_operation_create_(), GNUNET_TESTBED_operation_queue_insert_(), GST_opq_openfds, h, Neighbour::host_id, LOG_DEBUG, NeighbourConnectNotification::n, Neighbour::nl_head, Neighbour::nl_tail, oprelease_neighbour_conn(), opstart_neighbour_conn(), and trigger_notifications().

Referenced by handle_link_controllers(), and handle_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbour_get_connection_cancel()

void GST_neighbour_get_connection_cancel

(

struct NeighbourConnectNotification *

h

)

Cancel the request for opening a connection to the neighbour.

Parameters

h	the notification handle

Definition at line 1020 of file gnunet-service-testbed_links.c.

{
  struct Neighbour *n;
  int cleanup_task;
 
  n = h->n;
  cleanup_task = (h == n->nl_head) ? GNUNET_YES : GNUNET_NO;
  GNUNET_CONTAINER_DLL_remove (n->nl_head, n->nl_tail, h);
  GNUNET_free (h);
  if (GNUNET_NO == cleanup_task)
    return;
  if (NULL == n->notify_task)
    return;
  GNUNET_assert (0 < n->reference_cnt);
  n->reference_cnt--;
  GNUNET_SCHEDULER_cancel (n->notify_task);
  n->notify_task = NULL;
  if (NULL == n->nl_head)
  {
    if ((0 == n->reference_cnt) && (0 == n->inactive))
    {
      n->inactive = 1;
      GNUNET_TESTBED_operation_inactivate_ (n->conn_op);
    }
    return;
  }
  trigger_notifications (n);
}

References cleanup_task, Neighbour::conn_op, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_operation_inactivate_(), GNUNET_YES, h, Neighbour::inactive, Neighbour::nl_head, Neighbour::nl_tail, Neighbour::notify_task, Neighbour::reference_cnt, and trigger_notifications().

Referenced by cleanup_ncc(), and cleanup_occ_rp2c().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_neighbour_release_connection()

void GST_neighbour_release_connection

(

struct Neighbour *

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).

Parameters

n	the neighbour whose connection can be closed

Definition at line 1058 of file gnunet-service-testbed_links.c.

{
  GNUNET_assert (0 == n->inactive);
  GNUNET_assert (0 < n->reference_cnt);
  n->reference_cnt--;
  if (0 == n->reference_cnt)
  {
    n->inactive = 1;
    GNUNET_TESTBED_operation_inactivate_ (n->conn_op);
  }
}

References Neighbour::conn_op, GNUNET_assert, GNUNET_TESTBED_operation_inactivate_(), Neighbour::inactive, and Neighbour::reference_cnt.

Referenced by cleanup_occ_rp2c(), and neighbour_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_create_neighbour()

struct Neighbour* GST_create_neighbour

(

struct GNUNET_TESTBED_Host *

host

)

Function to create a neighbour and add it into the neighbour list.

Parameters

host	the host of the neighbour

Definition at line 1188 of file gnunet-service-testbed_links.c.

{
  struct Neighbour *n;
 
  n = GNUNET_new (struct Neighbour);
  n->host_id = GNUNET_TESTBED_host_get_id_ (host);
  neighbour_list_add (n);    /* just add; connect on-demand */
  return n;
}

References GNUNET_new, GNUNET_TESTBED_host_get_id_(), Neighbour::host_id, and neighbour_list_add().

Referenced by handle_link_controllers(), and handle_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_link_controllers()

void handle_link_controllers	(	void *	cls,
		const struct GNUNET_TESTBED_ControllerLinkRequest *	msg
	)

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS message.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1206 of file gnunet-service-testbed_links.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct LCFContext *lcf;
  struct Route *route;
  struct Route *new_route;
  uint64_t op_id;
  uint32_t delegated_host_id;
  uint32_t slave_host_id;
 
  if (NULL == GST_context)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  delegated_host_id = ntohl (msg->delegated_host_id);
  if (delegated_host_id == GST_context->host_id)
  {
    GNUNET_break (0);
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Trying to link ourselves\n");
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if ((delegated_host_id >= GST_host_list_size) ||
      (NULL == GST_host_list[delegated_host_id]))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Delegated host %u not registered with us\n",
         delegated_host_id);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  slave_host_id = ntohl (msg->slave_host_id);
  if ((slave_host_id >= GST_host_list_size) ||
      (NULL == GST_host_list[slave_host_id]))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Slave host %u not registered with us\n",
         slave_host_id);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if (slave_host_id == delegated_host_id)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Slave and delegated host are same\n");
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  op_id = GNUNET_ntohll (msg->operation_id);
  if (slave_host_id == GST_context->host_id)    /* Link from us */
  {
    struct Slave *slave;
    struct LinkControllersContext *lcc;
 
    if (1 != msg->is_subordinate)
    {
      struct Neighbour *n;
      struct NeighbourConnectCtxt *ncc;
 
      if ((delegated_host_id < neighbour_list_size) &&
          (NULL != neighbour_list[delegated_host_id]))
      {
        GNUNET_break (0);
        GNUNET_SERVICE_client_drop (client);
        return;
      }
      LOG_DEBUG ("Received request to establish a link to host %u\n",
                 delegated_host_id);
      n = GST_create_neighbour (GST_host_list[delegated_host_id]);
      ncc = GNUNET_new (struct NeighbourConnectCtxt);
      ncc->n = n;
      ncc->op_id = op_id;
      ncc->client = client;
      ncc->nh = GST_neighbour_get_connection (n,
                                              &neighbour_connect_cb,
                                              ncc);
      ncc->timeout_task
        = GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                        &timeout_neighbour_connect,
                                        ncc);
      GNUNET_CONTAINER_DLL_insert_tail (ncc_head,
                                        ncc_tail,
                                        ncc);
      GNUNET_SERVICE_client_continue (client);
      return;
    }
    if ((delegated_host_id < GST_slave_list_size) &&
        (NULL != GST_slave_list[delegated_host_id]))
    {
      GNUNET_break (0);
      GNUNET_SERVICE_client_drop (client);
      return;
    }
    LOG_DEBUG ("Received request to start and establish a link to host %u\n",
               delegated_host_id);
    slave = GNUNET_new (struct Slave);
    slave->host_id = delegated_host_id;
    slave->reghost_map = GNUNET_CONTAINER_multihashmap_create (100,
                                                               GNUNET_NO);
    slave_list_add (slave);
    lcc = GNUNET_new (struct LinkControllersContext);
    lcc->operation_id = op_id;
    lcc->client = client;
    slave->lcc = lcc;
    slave->controller_proc
      = GNUNET_TESTBED_controller_start (GST_context->master_ip,
                                         GST_host_list[slave->host_id],
                                         &slave_status_cb,
                                         slave);
    new_route = GNUNET_new (struct Route);
    new_route->dest = delegated_host_id;
    new_route->thru = GST_context->host_id;
    route_list_add (new_route);
    return;
  }
 
  /* Route the request */
  if (slave_host_id >= route_list_size)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "No route towards slave host");
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  lcf = GNUNET_new (struct LCFContext);
  lcf->delegated_host_id = delegated_host_id;
  lcf->slave_host_id = slave_host_id;
  route = GST_find_dest_route (slave_host_id);
  GNUNET_assert (NULL != route);         /* because we add routes carefully */
  GNUNET_assert (route->dest < GST_slave_list_size);
  GNUNET_assert (NULL != GST_slave_list[route->dest]);
  lcf->is_subordinate = msg->is_subordinate;
  lcf->state = INIT;
  lcf->operation_id = op_id;
  lcf->gateway = GST_slave_list[route->dest];
  lcf->client = client;
  if (NULL == lcf_head)
  {
    GNUNET_assert (NULL == lcf_proc_task_id);
    GNUNET_CONTAINER_DLL_insert_tail (lcf_head,
                                      lcf_tail,
                                      lcf);
    lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
                                                 lcf);
  }
  else
  {
    GNUNET_CONTAINER_DLL_insert_tail (lcf_head,
                                      lcf_tail,
                                      lcf);
  }
  /* FIXME: Adding a new route should happen after the controllers are linked
   * successfully */
  if (1 != msg->is_subordinate)
  {
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if ((delegated_host_id < route_list_size) &&
      (NULL != route_list[delegated_host_id]))
  {
    GNUNET_break_op (0);        /* Are you trying to link delegated host twice
                                 * with is subordinate flag set to GNUNET_YES? */
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  new_route = GNUNET_new (struct Route);
  new_route->dest = delegated_host_id;
  new_route->thru = route->dest;
  route_list_add (new_route);
  GNUNET_SERVICE_client_continue (client);
}

References LinkControllersContext::client, LCFContext::client, NeighbourConnectCtxt::client, Slave::controller_proc, LCFContext::delegated_host_id, Route::dest, LCFContext::gateway, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_WARNING, GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TESTBED_controller_start(), GST_context, GST_create_neighbour(), GST_find_dest_route(), GST_host_list, GST_host_list_size, GST_neighbour_get_connection(), GST_slave_list, GST_slave_list_size, GST_timeout, Context::host_id, Slave::host_id, INIT, LCFContext::is_subordinate, Slave::lcc, lcf_head, lcf_proc_task(), lcf_proc_task_id, lcf_tail, LOG, LOG_DEBUG, Context::master_ip, msg, NeighbourConnectCtxt::n, ncc_head, ncc_tail, neighbour_connect_cb(), neighbour_list, neighbour_list_size, NeighbourConnectCtxt::nh, NeighbourConnectCtxt::op_id, LinkControllersContext::operation_id, LCFContext::operation_id, Slave::reghost_map, route_list, route_list_add(), route_list_size, LCFContext::slave_host_id, slave_list_add(), slave_status_cb(), LCFContext::state, Route::thru, timeout_neighbour_connect(), and NeighbourConnectCtxt::timeout_task.

Here is the call graph for this function:

GST_link_notify_disconnect()

void GST_link_notify_disconnect

(

struct GNUNET_SERVICE_Client *

client

)

Clean up client handle if we stored any via handle_link_controllers(), the given client disconnected.

Parameters

client

the client that is history

Definition at line 1391 of file gnunet-service-testbed_links.c.

{
  struct NeighbourConnectCtxt *ncc;
  struct NeighbourConnectCtxt *nccn;
  struct LCFContext *lcf;
  struct LCFContext *lcfn;
 
  for (ncc = ncc_head; NULL != ncc; ncc = nccn)
  {
    nccn = ncc->next;
    if (ncc->client == client)
      cleanup_ncc (ncc);
  }
  for (unsigned int i = 0; i < GST_slave_list_size; i++)
  {
    struct Slave *slave = GST_slave_list[i];
    struct LinkControllersContext *lcc;
 
    if (NULL == slave)
      continue;
    GNUNET_CONTAINER_multihashmap_iterate (slave->reghost_map,
                                           &drop_client_entries,
                                           client);
    lcc = slave->lcc;
    if (NULL == lcc)
      continue;
    if (lcc->client == client)
    {
      slave->lcc = NULL;
      GNUNET_free (lcc);
    }
  }
  for (lcf = lcf_head; NULL != lcf; lcf = lcfn)
  {
    lcfn = lcf->next;
    if ((NULL != lcf) &&
        (client == lcf->client))
    {
      if (NULL != lcf->op)
        GNUNET_TESTBED_operation_done (lcf->op);
      GNUNET_CONTAINER_DLL_remove (lcf_head,
                                   lcf_tail,
                                   lcf);
      GNUNET_free (lcf);
    }
  }
}

References cleanup_ncc(), LinkControllersContext::client, LCFContext::client, NeighbourConnectCtxt::client, drop_client_entries(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_TESTBED_operation_done(), GST_slave_list, GST_slave_list_size, Slave::lcc, lcf_head, lcf_tail, ncc_head, LCFContext::next, NeighbourConnectCtxt::next, LCFContext::op, and Slave::reghost_map.

Referenced by client_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_slave_list_clear()

void GST_slave_list_clear

(

void

)

Cleans up the slave list.

Definition at line 493 of file gnunet-service-testbed_links.c.

{
  struct Slave *slave;
  unsigned int id;
 
  for (id = 0; id < GST_slave_list_size; id++)
  {
    slave = GST_slave_list[id];
    if (NULL == slave)
      continue;
    kill_slave (slave);
  }
  for (id = 0; id < GST_slave_list_size; id++)
  {
    slave = GST_slave_list[id];
    if (NULL == slave)
      continue;
    destroy_slave (slave);
  }
  GNUNET_free (GST_slave_list);
  GST_slave_list = NULL;
}

References destroy_slave(), GNUNET_free, GST_slave_list, GST_slave_list_size, id, and kill_slave().

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

GST_slave_list

struct Slave** GST_slave_list

extern

A list of directly linked neighbours.

Definition at line 283 of file gnunet-service-testbed_links.c.

Referenced by destroy_slave(), GST_link_notify_disconnect(), GST_slave_list_clear(), handle_barrier_init(), handle_link_controllers(), handle_peer_create(), handle_shutdown_peers(), handle_slave_get_config(), and slave_list_add().

GST_slave_list_size

unsigned int GST_slave_list_size

extern

The size of directly linked neighbours list.

Definition at line 288 of file gnunet-service-testbed_links.c.

Referenced by GST_link_notify_disconnect(), GST_slave_list_clear(), handle_barrier_init(), handle_link_controllers(), handle_shutdown_peers(), handle_slave_get_config(), and slave_list_add().