gnunet-service-testbed_links.c File Reference

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

#include "platform.h"
#include "gnunet-service-testbed.h"

Include dependency graph for gnunet-service-testbed_links.c:

Go to the source code of this file.

Data Structures
struct	LCFContext
	Link controllers request forwarding context. More...
struct	NeighbourConnectNotification
	Notification context to be used to notify when connection to the neighbour's controller is opened. More...
struct	Neighbour
	A connected controller which is not our child. More...
struct	NeighbourConnectCtxt
	Context information for establishing a link to neighbour (Used is GST_handle_link_controllers() More...

Macros
#define	LOG(kind, ...)    GNUNET_log_from (kind, "testbed-links", __VA_ARGS__)
	Redefine LOG with a changed log component string. More...
#define	EVENT_MASK   (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED)
	The event mask for the events we listen from sub-controllers. More...

Enumerations
enum	LCFContextState { INIT , DELEGATED_HOST_REGISTERED , SLAVE_HOST_REGISTERED , FINISHED }
	States of LCFContext. More...

Functions
static void	slave_list_add (struct Slave *slave)
	Adds a slave to the slave array. More...
static int	drop_client_entries (void *cls, const struct GNUNET_HashCode *key, void *value)
	Clean up all forwarded operation overlay context matching the client given in cls. More...
static void	route_list_add (struct Route *route)
	Adds a route to the route list. More...
static void	neighbour_list_add (struct Neighbour *n)
	Add a neighbour to the neighbour list. More...
void	GST_route_list_clear ()
	Cleans up the route list. More...
static int	reghost_free_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator for freeing hash map entries in a slave's reghost_map. More...
static void	kill_slave (struct Slave *slave)
	Kill a Slave object. More...
static void	destroy_slave (struct Slave *slave)
	Destroy a Slave object. More...
void	GST_slave_list_clear ()
	Cleans up the slave list. More...
struct Route *	GST_find_dest_route (uint32_t host_id)
	Finds the route with directly connected host as destination through which the destination host can be reached. More...
static void	send_controller_link_response (struct GNUNET_SERVICE_Client *client, uint64_t operation_id, const struct GNUNET_CONFIGURATION_Handle *cfg, const char *emsg)
	Function to send a failure response for controller link operation. More...
static void	lcf_proc_task (void *cls)
	The Link Controller forwarding task. More...
static void	lcf_proc_cc (void *cls, const char *emsg)
	Completion callback for host registrations while forwarding Link Controller messages. More...
static void	lcf_forwarded_operation_timeout (void *cls)
	Task to free resources when forwarded link controllers has been timedout. More...
static void	slave_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
	Callback for event from slave controllers. More...
static void	slave_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, int status)
	Callback to signal successful startup of the controller process. More...
static void	trigger_notifications (struct Neighbour *n)
	Trigger notification task if there are notification requests currently waiting in the given neighbour. More...
static void	neighbour_connect_notify_task (void *cls)
	Task to call the notification queued in the notifications list of the given neighbour. More...
static void	opstart_neighbour_conn (void *cls)
	Callback to be called when the neighbour connect operation is started. More...
static void	oprelease_neighbour_conn (void *cls)
	Callback to be called when the neighbour connect operation is released. 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...
static void	cleanup_ncc (struct NeighbourConnectCtxt *ncc)
	Cleanup neighbour connect contexts. More...
void	GST_neighbour_list_clean ()
	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 ()
	Function to cleanup the neighbour connect contexts. More...
static void	timeout_neighbour_connect (void *cls)
	Task to be run upon timeout while attempting to connect to the neighbour. More...
static void	neighbour_connect_cb (void *cls, struct GNUNET_TESTBED_Controller *c)
	Callback called when a connection to the neighbour is made. 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_free_lcf ()
	Cleans up the queue used for forwarding link controllers requests. More...

Variables
static struct Neighbour **	neighbour_list
	The neighbour list. More...
static unsigned int	neighbour_list_size
	The size of the neighbour list. More...
struct NeighbourConnectCtxt *	ncc_head
	DLL head for the list of neighbour connect contexts. More...
struct NeighbourConnectCtxt *	ncc_tail
	DLL tail for the list of neighbour connect contexts. More...
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...
static struct Route **	route_list
	A list of routes. More...
static struct LCFContext *	lcf_head
	The LCF queue. More...
static struct LCFContext *	lcf_tail
	The tail for the LCF queue. More...
static struct GNUNET_SCHEDULER_Task *	lcf_proc_task_id
	The lcf_task handle. More...
static unsigned int	route_list_size
	The size of the route 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.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "testbed-links", __VA_ARGS__)

Redefine LOG with a changed log component string.

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

EVENT_MASK

#define EVENT_MASK   (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED)

The event mask for the events we listen from sub-controllers.

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

Enumeration Type Documentation

LCFContextState

enum LCFContextState

States of LCFContext.

Enumerator
INIT	The Context has been initialized; Nothing has been done on it.
DELEGATED_HOST_REGISTERED	Delegated host has been registered at the forwarding controller.
SLAVE_HOST_REGISTERED	The slave host has been registered at the forwarding controller.
FINISHED	The context has been finished (may have error)

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

{
  INIT,
 
  DELEGATED_HOST_REGISTERED,
 
  SLAVE_HOST_REGISTERED,
 
  FINISHED
};

Function Documentation

slave_list_add()

static void slave_list_add ( struct Slave *  slave )

static

Adds a slave to the slave array.

Parameters

slave

the slave controller to add

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

{
  if (slave->host_id >= GST_slave_list_size)
    GST_array_grow_large_enough (GST_slave_list,
                                 GST_slave_list_size,
                                 slave->host_id);
  GNUNET_assert (NULL == GST_slave_list[slave->host_id]);
  GST_slave_list[slave->host_id] = slave;
}

References GNUNET_assert, GST_array_grow_large_enough, GST_slave_list, GST_slave_list_size, and Slave::host_id.

Referenced by handle_link_controllers().

Here is the caller graph for this function:

drop_client_entries()

static int drop_client_entries ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Clean up all forwarded operation overlay context matching the client given in cls.

Parameters

cls	a struct GNUNET_SERVICE_Client * to match
key	unused
value	the struct RegisteredHostContext to search for cls

Returns

GNUNET_OK (continue iterating)

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

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct RegisteredHostContext *rhc = value;
  struct ForwardedOverlayConnectContext *focc;
  struct ForwardedOverlayConnectContext *foccn;
 
  for (focc = rhc->focc_dll_head; NULL != focc; focc = foccn)
  {
    foccn = focc->next;
    if (focc->client == client)
      GST_cleanup_focc (focc);
  }
  return GNUNET_OK;
}

References ForwardedOverlayConnectContext::client, RegisteredHostContext::focc_dll_head, GNUNET_OK, GST_cleanup_focc(), ForwardedOverlayConnectContext::next, ForwardedOverlayConnectContext::rhc, and value.

Referenced by GST_link_notify_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

route_list_add()

static void route_list_add ( struct Route *  route )

static

Adds a route to the route list.

Parameters

route

the route to add

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

{
  if (route->dest >= route_list_size)
    GST_array_grow_large_enough (route_list, route_list_size, route->dest);
  GNUNET_assert (NULL == route_list[route->dest]);
  route_list[route->dest] = route;
}

References Route::dest, GNUNET_assert, GST_array_grow_large_enough, route_list, and route_list_size.

Referenced by handle_link_controllers().

Here is the caller graph for this function:

neighbour_list_add()

static void neighbour_list_add ( struct Neighbour *  n )

static

Add a neighbour to the neighbour list.

Grows the neighbour list automatically.

Parameters

n	the neighbour to add

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

{
  if (n->host_id >= neighbour_list_size)
    GST_array_grow_large_enough (neighbour_list, neighbour_list_size,
                                 n->host_id);
  GNUNET_assert (NULL == neighbour_list[n->host_id]);
  neighbour_list[n->host_id] = n;
}

References GNUNET_assert, GST_array_grow_large_enough, Neighbour::host_id, neighbour_list, and neighbour_list_size.

Referenced by GST_create_neighbour().

Here is the caller graph for this function:

GST_route_list_clear()

void GST_route_list_clear

(

void

)

Cleans up the route list.

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

{
  unsigned int id;
 
  for (id = 0; id < route_list_size; id++)
    if (NULL != route_list[id])
      GNUNET_free (route_list[id]);
  GNUNET_free (route_list);
  route_list = NULL;
}

References GNUNET_free, id, route_list, and route_list_size.

Referenced by shutdown_task().

Here is the caller graph for this function:

reghost_free_iterator()

static int reghost_free_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator for freeing hash map entries in a slave's reghost_map.

Parameters

cls	handle to the slave
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

{
  struct Slave *slave = cls;
  struct RegisteredHostContext *rhc = value;
  struct ForwardedOverlayConnectContext *focc;
 
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (slave->reghost_map, key,
                                                       value));
  while (NULL != (focc = rhc->focc_dll_head))
    GST_cleanup_focc (focc);
  GNUNET_free (value);
  return GNUNET_YES;
}

References RegisteredHostContext::focc_dll_head, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_YES, GST_cleanup_focc(), key, Slave::reghost_map, ForwardedOverlayConnectContext::rhc, and value.

Referenced by kill_slave().

Here is the call graph for this function:

Here is the caller graph for this function:

kill_slave()

static void kill_slave ( struct Slave *  slave )

static

Kill a Slave object.

Parameters

slave

the Slave object

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

{
  struct HostRegistration *hr_entry;
 
  while (NULL != (hr_entry = slave->hr_dll_head))
  {
    GNUNET_CONTAINER_DLL_remove (slave->hr_dll_head, slave->hr_dll_tail,
                                 hr_entry);
    GNUNET_free (hr_entry);
  }
  if (NULL != slave->rhandle)
    GNUNET_TESTBED_cancel_registration (slave->rhandle);
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_CONTAINER_multihashmap_iterate (slave->reghost_map,
                                                        reghost_free_iterator,
                                                        slave));
  GNUNET_CONTAINER_multihashmap_destroy (slave->reghost_map);
  if (NULL != slave->controller)
    GNUNET_TESTBED_controller_disconnect (slave->controller);
  if (NULL != slave->controller_proc)
  {
    LOG_DEBUG ("Stopping a slave\n");
    GNUNET_TESTBED_controller_kill_ (slave->controller_proc);
  }
}

References Slave::controller, Slave::controller_proc, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SYSERR, GNUNET_TESTBED_cancel_registration(), GNUNET_TESTBED_controller_disconnect(), GNUNET_TESTBED_controller_kill_(), Slave::hr_dll_head, Slave::hr_dll_tail, LOG_DEBUG, reghost_free_iterator(), Slave::reghost_map, and Slave::rhandle.

Referenced by GST_slave_list_clear(), and slave_status_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_slave()

static void destroy_slave ( struct Slave *  slave )

static

Destroy a Slave object.

Parameters

slave

the Slave object

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

{
  if (NULL != slave->controller_proc)
  {
    GNUNET_TESTBED_controller_destroy_ (slave->controller_proc);
    LOG_DEBUG ("Slave stopped\n");
  }
  GST_slave_list[slave->host_id] = NULL;
  GNUNET_free (slave);
}

References Slave::controller_proc, GNUNET_free, GNUNET_TESTBED_controller_destroy_(), GST_slave_list, Slave::host_id, and LOG_DEBUG.

Referenced by GST_slave_list_clear(), and slave_status_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:

GST_find_dest_route()

struct Route* GST_find_dest_route

(

uint32_t

host_id

)

Finds the route with directly connected host as destination through which the destination host can be reached.

Parameters

host_id

the id of the destination host

Returns

the route with directly connected destination host; NULL if no route is found

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

{
  struct Route *route;
 
  if (route_list_size <= host_id)
    return NULL;
  while (NULL != (route = route_list[host_id]))
  {
    if (route->thru == GST_context->host_id)
      break;
    host_id = route->thru;
  }
  return route;
}

References GST_context, Context::host_id, route_list, route_list_size, and Route::thru.

Referenced by forward_overlay_connect(), handle_link_controllers(), and handle_peer_create().

Here is the caller graph for this function:

send_controller_link_response()

static void send_controller_link_response ( struct GNUNET_SERVICE_Client *  client, uint64_t  operation_id, const struct GNUNET_CONFIGURATION_Handle *  cfg, const char *  emsg  )

static

Function to send a failure response for controller link operation.

Parameters

client	the client to send the message to
operation_id	the operation ID of the controller link request
cfg	the configuration with which the delegated controller is started. Can be NULL if the delegated controller is not started but just linked to.
emsg	set to an error message explaining why the controller link failed. Setting this to NULL signifies success. !This should be NULL if cfg is set!

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_ControllerLinkResponse *msg;
  char *xconfig;
  size_t config_size;
  size_t xconfig_size;
  uint16_t msize;
 
  GNUNET_assert ((NULL == cfg) || (NULL == emsg));
  xconfig = NULL;
  xconfig_size = 0;
  config_size = 0;
  msize = 0;
  if (NULL != cfg)
  {
    xconfig = GNUNET_TESTBED_compress_cfg_ (cfg,
                                            &config_size,
                                            &xconfig_size);
    msize += xconfig_size;
  }
  if (NULL != emsg)
    msize += strlen (emsg);
  env = GNUNET_MQ_msg_extra (msg,
                             msize,
                             GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT);
  if (NULL == emsg)
    msg->success = htons (GNUNET_YES);
  msg->operation_id = GNUNET_htonll (operation_id);
  msg->config_size = htons ((uint16_t) config_size);
  if (NULL != xconfig)
  {
    GNUNET_memcpy (&msg[1],
                   xconfig,
                   xconfig_size);
    GNUNET_free (xconfig);
  }
  if (NULL != emsg)
    GNUNET_memcpy (&msg[1],
                   emsg,
                   strlen (emsg));
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
}

References cfg, GNUNET_TESTBED_ControllerLinkResponse::config_size, env, GNUNET_assert, GNUNET_free, GNUNET_htonll(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_compress_cfg_(), GNUNET_YES, msg, and GNUNET_TESTBED_ControllerLinkResponse::operation_id.

Referenced by lcf_forwarded_operation_timeout(), neighbour_connect_cb(), slave_event_cb(), slave_status_cb(), and timeout_neighbour_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

lcf_proc_task()

static void lcf_proc_task ( void *  cls )

static

The Link Controller forwarding task.

Parameters

cls	the LCFContext

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

{
  struct LCFContext *lcf = cls;
 
  lcf_proc_task_id = NULL;
  switch (lcf->state)
  {
  case INIT:
    if (GNUNET_NO ==
        GNUNET_TESTBED_is_host_registered_ (GST_host_list
                                            [lcf->delegated_host_id],
                                            lcf->gateway->controller))
    {
      GST_queue_host_registration (lcf->gateway, lcf_proc_cc, lcf,
                                   GST_host_list[lcf->delegated_host_id]);
    }
    else
    {
      lcf->state = DELEGATED_HOST_REGISTERED;
      lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
    }
    break;
 
  case DELEGATED_HOST_REGISTERED:
    if (GNUNET_NO ==
        GNUNET_TESTBED_is_host_registered_ (GST_host_list[lcf->slave_host_id],
                                            lcf->gateway->controller))
    {
      GST_queue_host_registration (lcf->gateway, lcf_proc_cc, lcf,
                                   GST_host_list[lcf->slave_host_id]);
    }
    else
    {
      lcf->state = SLAVE_HOST_REGISTERED;
      lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
    }
    break;
 
  case SLAVE_HOST_REGISTERED:
    lcf->op = GNUNET_TESTBED_controller_link (lcf,
                                              lcf->gateway->controller,
                                              GST_host_list[lcf->
                                                            delegated_host_id],
                                              GST_host_list[lcf->slave_host_id],
                                              lcf->is_subordinate);
    lcf->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &lcf_forwarded_operation_timeout,
                                    lcf);
    lcf->state = FINISHED;
    break;
 
  case FINISHED:
    if (NULL != lcf->op)
      GNUNET_TESTBED_operation_done (lcf->op);
    GNUNET_CONTAINER_DLL_remove (lcf_head,
                                 lcf_tail,
                                 lcf);
    GNUNET_free (lcf);
    if (NULL != lcf_head)
      lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
                                                   lcf_head);
  }
}

References Slave::controller, LCFContext::delegated_host_id, DELEGATED_HOST_REGISTERED, FINISHED, LCFContext::gateway, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_is_host_registered_(), GNUNET_TESTBED_operation_done(), GST_host_list, GST_queue_host_registration(), GST_timeout, INIT, LCFContext::is_subordinate, lcf_forwarded_operation_timeout(), lcf_head, lcf_proc_cc(), lcf_proc_task_id, lcf_tail, LCFContext::op, LCFContext::slave_host_id, SLAVE_HOST_REGISTERED, LCFContext::state, and LCFContext::timeout_task.

Referenced by handle_link_controllers(), lcf_forwarded_operation_timeout(), lcf_proc_cc(), and slave_event_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

lcf_proc_cc()

static void lcf_proc_cc ( void *  cls, const char *  emsg  )

static

Completion callback for host registrations while forwarding Link Controller messages.

Parameters

cls	the LCFContext
emsg	the error message; NULL if host registration is successful

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

{
  struct LCFContext *lcf = cls;
 
  GNUNET_assert (NULL == lcf_proc_task_id);
  switch (lcf->state)
  {
  case INIT:
    if (NULL != emsg)
      goto registration_error;
    lcf->state = DELEGATED_HOST_REGISTERED;
    lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
    break;
 
  case DELEGATED_HOST_REGISTERED:
    if (NULL != emsg)
      goto registration_error;
    lcf->state = SLAVE_HOST_REGISTERED;
    lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
    break;
 
  default:
    GNUNET_assert (0);          /* Shouldn't reach here */
  }
  return;
 
registration_error:
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "Host registration failed with message: %s\n",
       emsg);
  lcf->state = FINISHED;
  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
                                               lcf);
}

References DELEGATED_HOST_REGISTERED, FINISHED, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_now(), INIT, lcf_proc_task(), lcf_proc_task_id, LOG, SLAVE_HOST_REGISTERED, and LCFContext::state.

Referenced by lcf_proc_task().

Here is the call graph for this function:

Here is the caller graph for this function:

lcf_forwarded_operation_timeout()

static void lcf_forwarded_operation_timeout ( void *  cls )

static

Task to free resources when forwarded link controllers has been timedout.

Parameters

cls	the LCFContext

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

{
  struct LCFContext *lcf = cls;
 
  lcf->timeout_task = NULL;
  //  GST_forwarded_operation_timeout (lcf->fopc, tc);
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "A forwarded controller link operation has timed out\n");
  send_controller_link_response (lcf->client,
                                 lcf->operation_id,
                                 NULL,
                                 "A forwarded controller link operation has timed out\n");
  GNUNET_assert (NULL == lcf_proc_task_id);
  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task,
                                               lcf);
}

References LCFContext::client, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_now(), lcf_proc_task(), lcf_proc_task_id, LOG, LCFContext::operation_id, send_controller_link_response(), and LCFContext::timeout_task.

Referenced by lcf_proc_task().

Here is the call graph for this function:

Here is the caller graph for this function:

slave_event_cb()

static void slave_event_cb ( void *  cls, const struct GNUNET_TESTBED_EventInformation *  event  )

static

Callback for event from slave controllers.

Parameters

cls	NULL
event	information about the event

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

{
  struct LCFContext *lcf;
 
  /* We currently only get here when working on LCFContexts */
  GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
  lcf = event->op_cls;
  GNUNET_assert (lcf->op == event->op);
  GNUNET_TESTBED_operation_done (lcf->op);
  lcf->op = NULL;
  GNUNET_assert (FINISHED == lcf->state);
  GNUNET_assert (NULL != 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 (NULL == lcf_proc_task_id);
  lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
  return;
}

References LCFContext::client, LCFContext::delegated_host_id, GNUNET_TESTBED_EventInformation::details, FINISHED, GNUNET_assert, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_host_get_cfg_(), GNUNET_TESTBED_operation_done(), GST_host_list, lcf_proc_task(), lcf_proc_task_id, GNUNET_TESTBED_EventInformation::op, LCFContext::op, GNUNET_TESTBED_EventInformation::operation_finished, LCFContext::operation_id, send_controller_link_response(), LCFContext::state, LCFContext::timeout_task, and GNUNET_TESTBED_EventInformation::type.

Referenced by opstart_neighbour_conn(), and slave_status_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

slave_status_cb()

static void slave_status_cb ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg, int  status  )

static

Callback to signal successful startup of the controller process.

Parameters

cls	the handle to the slave whose status is to be found here
cfg	the configuration with which the controller has been started; NULL if status is not GNUNET_OK
status	GNUNET_OK if the startup is successful; GNUNET_SYSERR if not, GNUNET_TESTBED_controller_stop() shouldn't be called in this case

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

{
  struct Slave *slave = cls;
  struct LinkControllersContext *lcc;
 
  lcc = slave->lcc;
  if (GNUNET_SYSERR == status)
  {
    slave->controller_proc = NULL;
    /* Stop all link controller forwarding tasks since we shutdown here anyway
       and as these tasks they depend on the operation queues which are created
       through GNUNET_TESTBED_controller_connect() and in kill_slave() we call
       the destructor function GNUNET_TESTBED_controller_disconnect() */
    GST_free_lcf ();
    kill_slave (slave);
    destroy_slave (slave);
    slave = NULL;
    LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected slave shutdown\n");
    GNUNET_SCHEDULER_shutdown ();       /* We too shutdown */
    goto clean_lcc;
  }
  slave->controller =
    GNUNET_TESTBED_controller_connect (GST_host_list[slave->host_id],
                                       EVENT_MASK, &slave_event_cb,
                                       slave);
  if (NULL != slave->controller)
  {
    send_controller_link_response (lcc->client, lcc->operation_id, cfg, NULL);
  }
  else
  {
    send_controller_link_response (lcc->client, lcc->operation_id, NULL,
                                   "Could not connect to delegated controller");
    kill_slave (slave);
    destroy_slave (slave);
    slave = NULL;
  }
 
clean_lcc:
  if (NULL != lcc)
  {
    if (NULL != lcc->client)
    {
      GNUNET_SERVICE_client_continue (lcc->client);
      lcc->client = NULL;
    }
    GNUNET_free (lcc);
  }
  if (NULL != slave)
    slave->lcc = NULL;
}

References cfg, LinkControllersContext::client, Slave::controller, Slave::controller_proc, destroy_slave(), EVENT_MASK, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_client_continue(), GNUNET_SYSERR, GNUNET_TESTBED_controller_connect(), GST_free_lcf(), GST_host_list, Slave::host_id, kill_slave(), Slave::lcc, LOG, LinkControllersContext::operation_id, send_controller_link_response(), slave_event_cb(), and status.

Referenced by handle_link_controllers().

Here is the call graph for this function:

Here is the caller graph for this function:

trigger_notifications()

static void trigger_notifications ( struct Neighbour *  n )

static

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

Parameters

n	the neighbour

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

{
  GNUNET_assert (NULL != n->conn_op);
  if (NULL == n->nl_head)
    return;
  if (NULL == n->controller)
    return;
  if (NULL != n->notify_task)
    return;
  if (1 == n->inactive)
  {
    GNUNET_assert (0 == n->reference_cnt);
    GNUNET_TESTBED_operation_activate_ (n->conn_op);
    n->inactive = 0;
  }
  n->reference_cnt++;
  n->notify_task =
    GNUNET_SCHEDULER_add_now (&neighbour_connect_notify_task, n);
}

References Neighbour::conn_op, Neighbour::controller, GNUNET_assert, GNUNET_SCHEDULER_add_now(), GNUNET_TESTBED_operation_activate_(), Neighbour::inactive, NeighbourConnectNotification::n, neighbour_connect_notify_task(), Neighbour::nl_head, Neighbour::notify_task, and Neighbour::reference_cnt.

Referenced by GST_neighbour_get_connection(), GST_neighbour_get_connection_cancel(), neighbour_connect_notify_task(), and opstart_neighbour_conn().

Here is the call graph for this function:

Here is the caller graph for this function:

neighbour_connect_notify_task()

static void neighbour_connect_notify_task ( void *  cls )

static

Task to call the notification queued in the notifications list of the given neighbour.

Parameters

cls	the neighbour

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

{
  struct Neighbour *n = cls;
  struct NeighbourConnectNotification *h;
 
  GNUNET_assert (NULL != (h = n->nl_head));
  GNUNET_assert (NULL != n->notify_task);
  n->notify_task = NULL;
  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);
}

References Neighbour::controller, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, h, NeighbourConnectNotification::n, Neighbour::nl_head, Neighbour::nl_tail, Neighbour::notify_task, and trigger_notifications().

Referenced by trigger_notifications().

Here is the call graph for this function:

Here is the caller graph for this function:

opstart_neighbour_conn()

static void opstart_neighbour_conn ( void *  cls )

static

Callback to be called when the neighbour connect operation is started.

The connection to the neighbour is opened here and any pending notifications are trigger.

Parameters

cls	the neighbour

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

{
  struct Neighbour *n = cls;
 
  GNUNET_assert (NULL != n->conn_op);
  GNUNET_assert (NULL == n->controller);
  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_cb,
                                                     NULL);
  trigger_notifications (n);
}

References Neighbour::conn_op, Neighbour::controller, EVENT_MASK, GNUNET_assert, GNUNET_TESTBED_controller_connect(), GST_host_list, Neighbour::host_id, LOG_DEBUG, slave_event_cb(), and trigger_notifications().

Referenced by GST_neighbour_get_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_neighbour_conn()

static void oprelease_neighbour_conn ( void *  cls )

static

Callback to be called when the neighbour connect operation is released.

Parameters

cls	the neighbour

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

{
  struct Neighbour *n = cls;
 
  GNUNET_assert (0 == n->reference_cnt);
  GNUNET_assert (NULL == n->notify_task);
  GNUNET_assert (NULL == n->nl_head);
  if (NULL != n->controller)
  {
    LOG_DEBUG ("Closing connection to controller on host %u\n", n->host_id);
    GNUNET_TESTBED_controller_disconnect (n->controller);
    n->controller = NULL;
  }
  n->conn_op = NULL;
  n->inactive = 0;
}

References Neighbour::conn_op, Neighbour::controller, GNUNET_assert, GNUNET_TESTBED_controller_disconnect(), Neighbour::host_id, Neighbour::inactive, LOG_DEBUG, Neighbour::nl_head, Neighbour::notify_task, and Neighbour::reference_cnt.

Referenced by GST_neighbour_get_connection().

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:

cleanup_ncc()

static void cleanup_ncc ( struct NeighbourConnectCtxt *  ncc )

static

Cleanup neighbour connect contexts.

Parameters

ncc	the neighbour connect context to cleanup

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

{
  if (NULL != ncc->nh)
    GST_neighbour_get_connection_cancel (ncc->nh);
  if (NULL != ncc->timeout_task)
    GNUNET_SCHEDULER_cancel (ncc->timeout_task);
  GNUNET_CONTAINER_DLL_remove (ncc_head,
                               ncc_tail,
                               ncc);
  GNUNET_free (ncc);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GST_neighbour_get_connection_cancel(), ncc_head, ncc_tail, NeighbourConnectCtxt::nh, and NeighbourConnectCtxt::timeout_task.

Referenced by GST_free_nccq(), GST_link_notify_disconnect(), neighbour_connect_cb(), and timeout_neighbour_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

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:

timeout_neighbour_connect()

static void timeout_neighbour_connect ( void *  cls )

static

Task to be run upon timeout while attempting to connect to the neighbour.

Parameters

cls	the NeighbourConnectCtxt created in GST_handle_link_controllers()

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

{
  struct NeighbourConnectCtxt *ncc = cls;
 
  ncc->timeout_task = NULL;
  send_controller_link_response (ncc->client,
                                 ncc->op_id,
                                 NULL,
                                 "Could not connect to delegated controller");
  cleanup_ncc (ncc);
}

References cleanup_ncc(), NeighbourConnectCtxt::client, NeighbourConnectCtxt::op_id, send_controller_link_response(), and NeighbourConnectCtxt::timeout_task.

Referenced by handle_link_controllers().

Here is the call graph for this function:

Here is the caller graph for this function:

neighbour_connect_cb()

static void neighbour_connect_cb ( void *  cls, struct GNUNET_TESTBED_Controller *  c  )

static

Callback called when a connection to the neighbour is made.

Parameters

cls	the NeighbourConnectCtxt created in GST_handle_link_controllers()
c	the handle the neighbour's controller

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

{
  struct NeighbourConnectCtxt *ncc = cls;
 
  GNUNET_SCHEDULER_cancel (ncc->timeout_task);
  ncc->timeout_task = NULL;
  ncc->nh = NULL;
  GST_neighbour_release_connection (ncc->n);
  send_controller_link_response (ncc->client,
                                 ncc->op_id,
                                 NULL,
                                 NULL);
  cleanup_ncc (ncc);
}

References cleanup_ncc(), NeighbourConnectCtxt::client, GNUNET_SCHEDULER_cancel(), GST_neighbour_release_connection(), NeighbourConnectCtxt::n, NeighbourConnectCtxt::nh, NeighbourConnectCtxt::op_id, send_controller_link_response(), and NeighbourConnectCtxt::timeout_task.

Referenced by handle_link_controllers().

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_free_lcf()

void GST_free_lcf

(

void

)

Cleans up the queue used for forwarding link controllers requests.

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

{
  struct LCFContext *lcf;
 
  if (NULL != lcf_head)
  {
    if (NULL != lcf_proc_task_id)
    {
      GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
      lcf_proc_task_id = NULL;
    }
  }
  GNUNET_assert (NULL == lcf_proc_task_id);
  for (lcf = lcf_head; NULL != lcf; lcf = lcf_head)
  {
    if (NULL != lcf->op)
      GNUNET_TESTBED_operation_done (lcf->op);
    if (NULL != lcf->timeout_task)
      GNUNET_SCHEDULER_cancel (lcf->timeout_task);
    GNUNET_CONTAINER_DLL_remove (lcf_head,
                                 lcf_tail,
                                 lcf);
    GNUNET_free (lcf);
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_operation_done(), lcf_head, lcf_proc_task_id, lcf_tail, LCFContext::op, and LCFContext::timeout_task.

Referenced by shutdown_task(), and slave_status_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

neighbour_list

struct Neighbour** neighbour_list

static

The neighbour list.

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

Referenced by GST_get_neighbour(), GST_neighbour_list_clean(), handle_link_controllers(), and neighbour_list_add().

neighbour_list_size

unsigned int neighbour_list_size

static

The size of the neighbour list.

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

Referenced by GST_get_neighbour(), GST_neighbour_list_clean(), handle_link_controllers(), and neighbour_list_add().

ncc_head

struct NeighbourConnectCtxt* ncc_head

DLL head for the list of neighbour connect contexts.

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

Referenced by cleanup_ncc(), GST_free_nccq(), GST_link_notify_disconnect(), and handle_link_controllers().

ncc_tail

struct NeighbourConnectCtxt* ncc_tail

DLL tail for the list of neighbour connect contexts.

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

Referenced by cleanup_ncc(), and handle_link_controllers().

GST_slave_list

struct Slave** GST_slave_list

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

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

route_list

struct Route** route_list

static

A list of routes.

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

Referenced by GST_find_dest_route(), GST_route_list_clear(), handle_link_controllers(), and route_list_add().

lcf_head

struct LCFContext* lcf_head

static

The LCF queue.

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

Referenced by GST_free_lcf(), GST_link_notify_disconnect(), handle_link_controllers(), and lcf_proc_task().

lcf_tail

struct LCFContext* lcf_tail

static

The tail for the LCF queue.

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

Referenced by GST_free_lcf(), GST_link_notify_disconnect(), handle_link_controllers(), and lcf_proc_task().

lcf_proc_task_id

struct GNUNET_SCHEDULER_Task* lcf_proc_task_id

static

The lcf_task handle.

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

Referenced by GST_free_lcf(), handle_link_controllers(), lcf_forwarded_operation_timeout(), lcf_proc_cc(), lcf_proc_task(), and slave_event_cb().

route_list_size

unsigned int route_list_size

static

The size of the route list.

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

Referenced by GST_find_dest_route(), GST_route_list_clear(), handle_link_controllers(), and route_list_add().