GNUnet  0.19.5
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 RouteGST_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 NeighbourConnectNotificationGST_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 NeighbourGST_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 NeighbourGST_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 NeighbourConnectCtxtncc_head
 DLL head for the list of neighbour connect contexts. More...
 
struct NeighbourConnectCtxtncc_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 LCFContextlcf_head
 The LCF queue. More...
 
static struct LCFContextlcf_tail
 The tail for the LCF queue. More...
 
static struct GNUNET_SCHEDULER_Tasklcf_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

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.

50 {
54  INIT,
55 
60 
65 
69  FINISHED
70 };

Function Documentation

◆ slave_list_add()

static void slave_list_add ( struct Slave slave)
static

Adds a slave to the slave array.

Parameters
slavethe slave controller to add

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

323 {
324  if (slave->host_id >= GST_slave_list_size)
327  slave->host_id);
328  GNUNET_assert (NULL == GST_slave_list[slave->host_id]);
329  GST_slave_list[slave->host_id] = slave;
330 }
#define GST_array_grow_large_enough(ptr, size, accommodate_size)
Similar to GNUNET_array_grow(); however instead of calling GNUNET_array_grow() several times we call ...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t host_id
The id of the host this controller is running on.

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
clsa struct GNUNET_SERVICE_Client * to match
keyunused
valuethe struct RegisteredHostContext to search for cls
Returns
GNUNET_OK (continue iterating)

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

346 {
347  struct GNUNET_SERVICE_Client *client = cls;
348  struct RegisteredHostContext *rhc = value;
349  struct ForwardedOverlayConnectContext *focc;
350  struct ForwardedOverlayConnectContext *foccn;
351 
352  for (focc = rhc->focc_dll_head; NULL != focc; focc = foccn)
353  {
354  foccn = focc->next;
355  if (focc->client == client)
356  GST_cleanup_focc (focc);
357  }
358  return GNUNET_OK;
359 }
static char * value
Value of the record to add/remove.
void GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
Cleans up ForwardedOverlayConnectContext.
@ GNUNET_OK
Context information to used during operations which forward the overlay connect message.
struct RegisteredHostContext * rhc
Which host does this FOCC belong to?
struct ForwardedOverlayConnectContext * next
next ForwardedOverlayConnectContext in the DLL
struct GNUNET_SERVICE_Client * client
The client handle.
Handle to a client that is connected to a service.
Definition: service.c:252
This context information will be created for each host that is registered at slave controllers during...
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.

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
routethe route to add

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

369 {
370  if (route->dest >= route_list_size)
372  GNUNET_assert (NULL == route_list[route->dest]);
373  route_list[route->dest] = route;
374 }
uint32_t dest
destination host

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
nthe neighbour to add

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

385 {
386  if (n->host_id >= neighbour_list_size)
388  n->host_id);
389  GNUNET_assert (NULL == neighbour_list[n->host_id]);
390  neighbour_list[n->host_id] = n;
391 }
uint32_t host_id
The id of the host this controller is running on.

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.

399 {
400  unsigned int id;
401 
402  for (id = 0; id < route_list_size; id++)
403  if (NULL != route_list[id])
404  GNUNET_free (route_list[id]);
406  route_list = NULL;
407 }
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_free(ptr)
Wrapper around free.

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
clshandle to the slave
keycurrent key code
valuevalue 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.

423 {
424  struct Slave *slave = cls;
425  struct RegisteredHostContext *rhc = value;
426  struct ForwardedOverlayConnectContext *focc;
427 
430  value));
431  while (NULL != (focc = rhc->focc_dll_head))
432  GST_cleanup_focc (focc);
433  GNUNET_free (value);
434  return GNUNET_YES;
435 }
struct GNUNET_HashCode key
The key used in the DHT.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_YES
Structure representing a connected(directly-linked) controller.
struct GNUNET_CONTAINER_MultiHashMap * reghost_map
Hashmap to hold Registered host contexts.

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
slavethe Slave object

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

445 {
446  struct HostRegistration *hr_entry;
447 
448  while (NULL != (hr_entry = slave->hr_dll_head))
449  {
451  hr_entry);
452  GNUNET_free (hr_entry);
453  }
454  if (NULL != slave->rhandle)
459  slave));
461  if (NULL != slave->controller)
463  if (NULL != slave->controller_proc)
464  {
465  LOG_DEBUG ("Stopping a slave\n");
467  }
468 }
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
@ GNUNET_SYSERR
void GNUNET_TESTBED_cancel_registration(struct GNUNET_TESTBED_HostRegistrationHandle *handle)
Cancel the pending registration.
void GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c)
Stop the given controller (also will terminate all peers and controllers dependent on this controller...
Definition: testbed_api.c:1721
A DLL of host registrations to be made.
struct HostRegistration * hr_dll_tail
Tail of the host registration DLL.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
struct HostRegistration * hr_dll_head
Head of the host registration DLL.
struct GNUNET_TESTBED_HostRegistrationHandle * rhandle
The current host registration handle.
struct GNUNET_TESTBED_ControllerProc * controller_proc
The controller process handle if we had started the controller.
void GNUNET_TESTBED_controller_kill_(struct GNUNET_TESTBED_ControllerProc *cproc)
Sends termination signal to the controller's helper process.

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
slavethe Slave object

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

478 {
479  if (NULL != slave->controller_proc)
480  {
482  LOG_DEBUG ("Slave stopped\n");
483  }
484  GST_slave_list[slave->host_id] = NULL;
485  GNUNET_free (slave);
486 }
void GNUNET_TESTBED_controller_destroy_(struct GNUNET_TESTBED_ControllerProc *cproc)
Cleans-up the controller's helper process handle.

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.

494 {
495  struct Slave *slave;
496  unsigned int id;
497 
498  for (id = 0; id < GST_slave_list_size; id++)
499  {
500  slave = GST_slave_list[id];
501  if (NULL == slave)
502  continue;
503  kill_slave (slave);
504  }
505  for (id = 0; id < GST_slave_list_size; id++)
506  {
507  slave = GST_slave_list[id];
508  if (NULL == slave)
509  continue;
510  destroy_slave (slave);
511  }
513  GST_slave_list = NULL;
514 }

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

527 {
528  struct Route *route;
529 
530  if (route_list_size <= host_id)
531  return NULL;
532  while (NULL != (route = route_list[host_id]))
533  {
534  if (route->thru == GST_context->host_id)
535  break;
536  host_id = route->thru;
537  }
538  return route;
539 }
struct Context * GST_context
The master context; generated with the first INIT message.
uint32_t host_id
Our host id according to this context.
A routing entry.
uint32_t thru
The destination host is reachable thru.

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
clientthe client to send the message to
operation_idthe operation ID of the controller link request
cfgthe configuration with which the delegated controller is started. Can be NULL if the delegated controller is not started but just linked to.
emsgset 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.

559 {
560  struct GNUNET_MQ_Envelope *env;
562  char *xconfig;
563  size_t config_size;
564  size_t xconfig_size;
565  uint16_t msize;
566 
567  GNUNET_assert ((NULL == cfg) || (NULL == emsg));
568  xconfig = NULL;
569  xconfig_size = 0;
570  config_size = 0;
571  msize = 0;
572  if (NULL != cfg)
573  {
575  &config_size,
576  &xconfig_size);
577  msize += xconfig_size;
578  }
579  if (NULL != emsg)
580  msize += strlen (emsg);
582  msize,
584  if (NULL == emsg)
585  msg->success = htons (GNUNET_YES);
586  msg->operation_id = GNUNET_htonll (operation_id);
587  msg->config_size = htons ((uint16_t) config_size);
588  if (NULL != xconfig)
589  {
590  GNUNET_memcpy (&msg[1],
591  xconfig,
592  xconfig_size);
593  GNUNET_free (xconfig);
594  }
595  if (NULL != emsg)
596  GNUNET_memcpy (&msg[1],
597  emsg,
598  strlen (emsg));
600  env);
601 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT
Message to signal the result of GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS request.
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2443
Response message for ControllerLinkRequest message.
Definition: testbed.h:170
uint64_t operation_id
The id of the operation which created this message.
Definition: testbed.h:190
uint16_t config_size
The size of the compressed configuration.
Definition: testbed.h:180
char * GNUNET_TESTBED_compress_cfg_(const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size, size_t *xsize)
Function to serialize and compress using zlib a configuration through a configuration handle.
Definition: testbed_api.c:1785

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
clsthe LCFContext

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

697 {
698  struct LCFContext *lcf = cls;
699 
700  lcf_proc_task_id = NULL;
701  switch (lcf->state)
702  {
703  case INIT:
704  if (GNUNET_NO ==
706  [lcf->delegated_host_id],
707  lcf->gateway->controller))
708  {
711  }
712  else
713  {
716  }
717  break;
718 
720  if (GNUNET_NO ==
722  lcf->gateway->controller))
723  {
726  }
727  else
728  {
731  }
732  break;
733 
736  lcf->gateway->controller,
737  GST_host_list[lcf->
740  lcf->is_subordinate);
741  lcf->timeout_task =
744  lcf);
745  lcf->state = FINISHED;
746  break;
747 
748  case FINISHED:
749  if (NULL != lcf->op)
752  lcf_tail,
753  lcf);
754  GNUNET_free (lcf);
755  if (NULL != lcf_head)
757  lcf_head);
758  }
759 }
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
void GST_queue_host_registration(struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
Adds a host registration's request to a slave's registration queue.
@ GNUNET_NO
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2021
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_controller_link(void *op_cls, struct GNUNET_TESTBED_Controller *master, struct GNUNET_TESTBED_Host *delegated_host, struct GNUNET_TESTBED_Host *slave_host, int is_subordinate)
Create a link from slave controller to delegated controller.
Definition: testbed_api.c:1832
Link controllers request forwarding context.
enum LCFContextState state
The state of this context.
uint32_t delegated_host_id
The delegated host.
struct GNUNET_SCHEDULER_Task * timeout_task
The timeout task.
uint32_t slave_host_id
The slave host.
struct Slave * gateway
The gateway which will pass the link message to delegated host.
int is_subordinate
should the slave controller start the delegated controller?
struct GNUNET_TESTBED_Operation * op
Handle for operations which are forwarded while linking controllers.
int GNUNET_TESTBED_is_host_registered_(const struct GNUNET_TESTBED_Host *host, const struct GNUNET_TESTBED_Controller *const controller)
Checks whether a host has been registered.

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
clsthe LCFContext
emsgthe error message; NULL if host registration is successful

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

622 {
623  struct LCFContext *lcf = cls;
624 
626  switch (lcf->state)
627  {
628  case INIT:
629  if (NULL != emsg)
630  goto registration_error;
633  break;
634 
636  if (NULL != emsg)
637  goto registration_error;
640  break;
641 
642  default:
643  GNUNET_assert (0); /* Shouldn't reach here */
644  }
645  return;
646 
647 registration_error:
649  "Host registration failed with message: %s\n",
650  emsg);
651  lcf->state = FINISHED;
653  lcf);
654 }
@ GNUNET_ERROR_TYPE_WARNING

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
clsthe LCFContext

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

673 {
674  struct LCFContext *lcf = cls;
675 
676  lcf->timeout_task = NULL;
677  // GST_forwarded_operation_timeout (lcf->fopc, tc);
679  "A forwarded controller link operation has timed out\n");
681  lcf->operation_id,
682  NULL,
683  "A forwarded controller link operation has timed out\n");
686  lcf);
687 }
struct GNUNET_SERVICE_Client * client
The client which has asked to perform this operation.
uint64_t operation_id
The id of the operation which created this context.

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
clsNULL
eventinformation about the event

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

770 {
771  struct LCFContext *lcf;
772 
773  /* We currently only get here when working on LCFContexts */
775  lcf = event->op_cls;
776  GNUNET_assert (lcf->op == event->op);
778  lcf->op = NULL;
779  GNUNET_assert (FINISHED == lcf->state);
780  GNUNET_assert (NULL != lcf->timeout_task);
782  if (NULL == event->details.operation_finished.emsg)
786  NULL);
787  else
789  NULL,
790  event->details.operation_finished.emsg);
793  return;
794 }
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
@ GNUNET_TESTBED_ET_OPERATION_FINISHED
A requested testbed operation has been completed.
enum GNUNET_TESTBED_EventType type
Type of the event.
struct GNUNET_TESTBED_Operation * op
Handle for the corresponding operation that generated this event.
union GNUNET_TESTBED_EventInformation::@43 details
Details about the event.
struct GNUNET_TESTBED_EventInformation::@43::@48 operation_finished
Details about an operation finished event.
const struct GNUNET_CONFIGURATION_Handle * GNUNET_TESTBED_host_get_cfg_(const struct GNUNET_TESTBED_Host *host)
Obtain the host's configuration template.

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
clsthe handle to the slave whose status is to be found here
cfgthe configuration with which the controller has been started; NULL if status is not GNUNET_OK
statusGNUNET_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.

810 {
811  struct Slave *slave = cls;
812  struct LinkControllersContext *lcc;
813 
814  lcc = slave->lcc;
815  if (GNUNET_SYSERR == status)
816  {
817  slave->controller_proc = NULL;
818  /* Stop all link controller forwarding tasks since we shutdown here anyway
819  and as these tasks they depend on the operation queues which are created
820  through GNUNET_TESTBED_controller_connect() and in kill_slave() we call
821  the destructor function GNUNET_TESTBED_controller_disconnect() */
822  GST_free_lcf ();
823  kill_slave (slave);
824  destroy_slave (slave);
825  slave = NULL;
826  LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected slave shutdown\n");
827  GNUNET_SCHEDULER_shutdown (); /* We too shutdown */
828  goto clean_lcc;
829  }
830  slave->controller =
833  slave);
834  if (NULL != slave->controller)
835  {
837  }
838  else
839  {
841  "Could not connect to delegated controller");
842  kill_slave (slave);
843  destroy_slave (slave);
844  slave = NULL;
845  }
846 
847 clean_lcc:
848  if (NULL != lcc)
849  {
850  if (NULL != lcc->client)
851  {
853  lcc->client = NULL;
854  }
855  GNUNET_free (lcc);
856  }
857  if (NULL != slave)
858  slave->lcc = NULL;
859 }
uint16_t status
See PRISM_STATUS_*-constants.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
struct GNUNET_TESTBED_Controller * GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls)
Connect to a controller process.
Definition: testbed_api.c:1555
Context information used while linking controllers.
uint64_t operation_id
The ID of the operation.
struct GNUNET_SERVICE_Client * client
The client which initiated the link controller operation.
struct LinkControllersContext * lcc
handle to lcc which is associated with this slave startup.

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
nthe neighbour

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

907 {
908  GNUNET_assert (NULL != n->conn_op);
909  if (NULL == n->nl_head)
910  return;
911  if (NULL == n->controller)
912  return;
913  if (NULL != n->notify_task)
914  return;
915  if (1 == n->inactive)
916  {
917  GNUNET_assert (0 == n->reference_cnt);
919  n->inactive = 0;
920  }
921  n->reference_cnt++;
922  n->notify_task =
924 }
struct GNUNET_TESTBED_Operation * conn_op
Operation handle for opening a lateral connection to another controller.
unsigned int reference_cnt
How many references are present currently to this neighbour's connection.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
struct NeighbourConnectNotification * nl_head
DLL head for the list of notification requests.
unsigned int inactive
Is the conn_op inactivated?
struct GNUNET_SCHEDULER_Task * notify_task
Task id for the task to call notifications from the notification list.
void GNUNET_TESTBED_operation_activate_(struct GNUNET_TESTBED_Operation *op)
Marks and inactive operation as active.

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
clsthe neighbour

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

882 {
883  struct Neighbour *n = cls;
885 
886  GNUNET_assert (NULL != (h = n->nl_head));
887  GNUNET_assert (NULL != n->notify_task);
888  n->notify_task = NULL;
889  GNUNET_assert (NULL != n->controller);
892  h->cb (h->cb_cls, n->controller);
893  GNUNET_free (h);
894 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
Notification context to be used to notify when connection to the neighbour's controller is opened.
struct Neighbour * n
The neighbour.
A connected controller which is not our child.
struct NeighbourConnectNotification * nl_tail
DLL tail for the list of notification requests.

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
clsthe neighbour

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

936 {
937  struct Neighbour *n = cls;
938 
939  GNUNET_assert (NULL != n->conn_op);
940  GNUNET_assert (NULL == n->controller);
941  LOG_DEBUG ("Opening connection to controller on host %u\n", n->host_id);
943  EVENT_MASK,
945  NULL);
947 }

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
clsthe neighbour

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

957 {
958  struct Neighbour *n = cls;
959 
960  GNUNET_assert (0 == n->reference_cnt);
961  GNUNET_assert (NULL == n->notify_task);
962  GNUNET_assert (NULL == n->nl_head);
963  if (NULL != n->controller)
964  {
965  LOG_DEBUG ("Closing connection to controller on host %u\n", n->host_id);
967  n->controller = NULL;
968  }
969  n->conn_op = NULL;
970  n->inactive = 0;
971 }

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
nthe neighbour to open a connection to
cbthe notification callback to call when the connection is opened
cb_clsthe closure for the above callback

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

989 {
991 
992  GNUNET_assert (NULL != cb);
993  LOG_DEBUG ("Attempting to get connection to controller on host %u\n",
994  n->host_id);
996  h->n = n;
997  h->cb = cb;
998  h->cb_cls = cb_cls;
1000  if (NULL == n->conn_op)
1001  {
1002  GNUNET_assert (NULL == n->controller);
1007  return h;
1008  }
1010  return h;
1011 }
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
GST_NeighbourConnectNotifyCallback cb
The notification callback to call when we are connect to neighbour.
void * cb_cls
The closure for the above callback.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_operation_create_(void *cls, OperationStart start, OperationRelease release)
Create an 'operation' to be performed.
void GNUNET_TESTBED_operation_queue_insert_(struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
Add an operation to a queue.
void GNUNET_TESTBED_operation_begin_wait_(struct GNUNET_TESTBED_Operation *op)
Marks the given operation as waiting on the queues.

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
hthe notification handle

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

1021 {
1022  struct Neighbour *n;
1023  int cleanup_task;
1024 
1025  n = h->n;
1026  cleanup_task = (h == n->nl_head) ? GNUNET_YES : GNUNET_NO;
1028  GNUNET_free (h);
1029  if (GNUNET_NO == cleanup_task)
1030  return;
1031  if (NULL == n->notify_task)
1032  return;
1033  GNUNET_assert (0 < n->reference_cnt);
1034  n->reference_cnt--;
1036  n->notify_task = NULL;
1037  if (NULL == n->nl_head)
1038  {
1039  if ((0 == n->reference_cnt) && (0 == n->inactive))
1040  {
1041  n->inactive = 1;
1043  }
1044  return;
1045  }
1047 }
static struct GNUNET_SCHEDULER_Task * cleanup_task
Cleanup task.
void GNUNET_TESTBED_operation_inactivate_(struct GNUNET_TESTBED_Operation *op)
Marks an active operation as inactive - the operation will be kept in a ready-to-be-released state an...

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
nthe neighbour whose connection can be closed

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

1059 {
1060  GNUNET_assert (0 == n->inactive);
1061  GNUNET_assert (0 < n->reference_cnt);
1062  n->reference_cnt--;
1063  if (0 == n->reference_cnt)
1064  {
1065  n->inactive = 1;
1067  }
1068 }

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
nccthe neighbour connect context to cleanup

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

1078 {
1079  if (NULL != ncc->nh)
1081  if (NULL != ncc->timeout_task)
1084  ncc_tail,
1085  ncc);
1086  GNUNET_free (ncc);
1087 }
struct NeighbourConnectNotification * nh
The notification handle associated with the neighbour's connection request.
struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run upon timeout.

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.

1095 {
1096  struct Neighbour *n;
1097  unsigned int id;
1098 
1099  for (id = 0; id < neighbour_list_size; id++)
1100  {
1101  if (NULL == (n = neighbour_list[id]))
1102  continue;
1103  if (NULL != n->conn_op)
1105  GNUNET_free (n);
1106  neighbour_list[id] = NULL;
1107  }
1109 }
void GNUNET_TESTBED_operation_release_(struct GNUNET_TESTBED_Operation *op)
An operation is 'done' (was cancelled or finished); remove it from the queues and release associated ...

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

1121 {
1122  if (neighbour_list_size <= id)
1123  return NULL;
1124  return neighbour_list[id];
1125 }

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.

1133 {
1134  while (NULL != ncc_head)
1136 }

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
clsthe NeighbourConnectCtxt created in GST_handle_link_controllers()

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

1146 {
1147  struct NeighbourConnectCtxt *ncc = cls;
1148 
1149  ncc->timeout_task = NULL;
1151  ncc->op_id,
1152  NULL,
1153  "Could not connect to delegated controller");
1154  cleanup_ncc (ncc);
1155 }
Context information for establishing a link to neighbour (Used is GST_handle_link_controllers()
uint64_t op_id
The id of the link-controllers operation responsible for creating this context.
struct GNUNET_SERVICE_Client * client
The client requesting the connection.

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
clsthe NeighbourConnectCtxt created in GST_handle_link_controllers()
cthe handle the neighbour's controller

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

1167 {
1168  struct NeighbourConnectCtxt *ncc = cls;
1169 
1171  ncc->timeout_task = NULL;
1172  ncc->nh = NULL;
1175  ncc->op_id,
1176  NULL,
1177  NULL);
1178  cleanup_ncc (ncc);
1179 }
struct Neighbour * n
The neighbour to whom connection should be made.

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
hostthe host of the neighbour

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

1189 {
1190  struct Neighbour *n;
1191 
1192  n = GNUNET_new (struct Neighbour);
1194  neighbour_list_add (n); /* just add; connect on-demand */
1195  return n;
1196 }
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain a host's unique global ID.

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
clsidentification of the client
msgthe actual message

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

1208 {
1209  struct GNUNET_SERVICE_Client *client = cls;
1210  struct LCFContext *lcf;
1211  struct Route *route;
1212  struct Route *new_route;
1213  uint64_t op_id;
1214  uint32_t delegated_host_id;
1215  uint32_t slave_host_id;
1216 
1217  if (NULL == GST_context)
1218  {
1219  GNUNET_break (0);
1220  GNUNET_SERVICE_client_drop (client);
1221  return;
1222  }
1223  delegated_host_id = ntohl (msg->delegated_host_id);
1224  if (delegated_host_id == GST_context->host_id)
1225  {
1226  GNUNET_break (0);
1228  "Trying to link ourselves\n");
1229  GNUNET_SERVICE_client_drop (client);
1230  return;
1231  }
1232  if ((delegated_host_id >= GST_host_list_size) ||
1233  (NULL == GST_host_list[delegated_host_id]))
1234  {
1236  "Delegated host %u not registered with us\n",
1237  delegated_host_id);
1238  GNUNET_SERVICE_client_drop (client);
1239  return;
1240  }
1241  slave_host_id = ntohl (msg->slave_host_id);
1242  if ((slave_host_id >= GST_host_list_size) ||
1243  (NULL == GST_host_list[slave_host_id]))
1244  {
1246  "Slave host %u not registered with us\n",
1247  slave_host_id);
1248  GNUNET_SERVICE_client_drop (client);
1249  return;
1250  }
1251  if (slave_host_id == delegated_host_id)
1252  {
1254  "Slave and delegated host are same\n");
1255  GNUNET_SERVICE_client_drop (client);
1256  return;
1257  }
1258  op_id = GNUNET_ntohll (msg->operation_id);
1259  if (slave_host_id == GST_context->host_id) /* Link from us */
1260  {
1261  struct Slave *slave;
1262  struct LinkControllersContext *lcc;
1263 
1264  if (1 != msg->is_subordinate)
1265  {
1266  struct Neighbour *n;
1267  struct NeighbourConnectCtxt *ncc;
1268 
1269  if ((delegated_host_id < neighbour_list_size) &&
1270  (NULL != neighbour_list[delegated_host_id]))
1271  {
1272  GNUNET_break (0);
1274  return;
1275  }
1276  LOG_DEBUG ("Received request to establish a link to host %u\n",
1277  delegated_host_id);
1278  n = GST_create_neighbour (GST_host_list[delegated_host_id]);
1279  ncc = GNUNET_new (struct NeighbourConnectCtxt);
1280  ncc->n = n;
1281  ncc->op_id = op_id;
1282  ncc->client = client;
1285  ncc);
1286  ncc->timeout_task
1289  ncc);
1291  ncc_tail,
1292  ncc);
1294  return;
1295  }
1296  if ((delegated_host_id < GST_slave_list_size) &&
1297  (NULL != GST_slave_list[delegated_host_id]))
1298  {
1299  GNUNET_break (0);
1301  return;
1302  }
1303  LOG_DEBUG ("Received request to start and establish a link to host %u\n",
1304  delegated_host_id);
1305  slave = GNUNET_new (struct Slave);
1306  slave->host_id = delegated_host_id;
1308  GNUNET_NO);
1309  slave_list_add (slave);
1310  lcc = GNUNET_new (struct LinkControllersContext);
1311  lcc->operation_id = op_id;
1312  lcc->client = client;
1313  slave->lcc = lcc;
1314  slave->controller_proc
1316  GST_host_list[slave->host_id],
1317  &slave_status_cb,
1318  slave);
1319  new_route = GNUNET_new (struct Route);
1320  new_route->dest = delegated_host_id;
1321  new_route->thru = GST_context->host_id;
1322  route_list_add (new_route);
1323  return;
1324  }
1325 
1326  /* Route the request */
1327  if (slave_host_id >= route_list_size)
1328  {
1330  "No route towards slave host");
1332  return;
1333  }
1334  lcf = GNUNET_new (struct LCFContext);
1335  lcf->delegated_host_id = delegated_host_id;
1336  lcf->slave_host_id = slave_host_id;
1337  route = GST_find_dest_route (slave_host_id);
1338  GNUNET_assert (NULL != route); /* because we add routes carefully */
1340  GNUNET_assert (NULL != GST_slave_list[route->dest]);
1341  lcf->is_subordinate = msg->is_subordinate;
1342  lcf->state = INIT;
1343  lcf->operation_id = op_id;
1344  lcf->gateway = GST_slave_list[route->dest];
1345  lcf->client = client;
1346  if (NULL == lcf_head)
1347  {
1348  GNUNET_assert (NULL == lcf_proc_task_id);
1350  lcf_tail,
1351  lcf);
1353  lcf);
1354  }
1355  else
1356  {
1358  lcf_tail,
1359  lcf);
1360  }
1361  /* FIXME: Adding a new route should happen after the controllers are linked
1362  * successfully */
1363  if (1 != msg->is_subordinate)
1364  {
1366  return;
1367  }
1368  if ((delegated_host_id < route_list_size) &&
1369  (NULL != route_list[delegated_host_id]))
1370  {
1371  GNUNET_break_op (0); /* Are you trying to link delegated host twice
1372  * with is subordinate flag set to GNUNET_YES? */
1374  return;
1375  }
1376  new_route = GNUNET_new (struct Route);
1377  new_route->dest = delegated_host_id;
1378  new_route->thru = route->dest;
1379  route_list_add (new_route);
1381 }
unsigned int GST_host_list_size
The size of the host list.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
struct GNUNET_TESTBED_ControllerProc * GNUNET_TESTBED_controller_start(const char *trusted_ip, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_ControllerStatusCallback cb, void *cls)
Starts a controller process at the given host.
char * master_ip
The network address of the master controller.

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
clientthe client that is history

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

1392 {
1393  struct NeighbourConnectCtxt *ncc;
1394  struct NeighbourConnectCtxt *nccn;
1395  struct LCFContext *lcf;
1396  struct LCFContext *lcfn;
1397 
1398  for (ncc = ncc_head; NULL != ncc; ncc = nccn)
1399  {
1400  nccn = ncc->next;
1401  if (ncc->client == client)
1402  cleanup_ncc (ncc);
1403  }
1404  for (unsigned int i = 0; i < GST_slave_list_size; i++)
1405  {
1406  struct Slave *slave = GST_slave_list[i];
1407  struct LinkControllersContext *lcc;
1408 
1409  if (NULL == slave)
1410  continue;
1413  client);
1414  lcc = slave->lcc;
1415  if (NULL == lcc)
1416  continue;
1417  if (lcc->client == client)
1418  {
1419  slave->lcc = NULL;
1420  GNUNET_free (lcc);
1421  }
1422  }
1423  for (lcf = lcf_head; NULL != lcf; lcf = lcfn)
1424  {
1425  lcfn = lcf->next;
1426  if ((NULL != lcf) &&
1427  (client == lcf->client))
1428  {
1429  if (NULL != lcf->op)
1432  lcf_tail,
1433  lcf);
1434  GNUNET_free (lcf);
1435  }
1436  }
1437 }
struct LCFContext * next
The LCFContext.
struct NeighbourConnectCtxt * next
DLL next for inclusion in the corresponding context list.

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.

1445 {
1446  struct LCFContext *lcf;
1447 
1448  if (NULL != lcf_head)
1449  {
1450  if (NULL != lcf_proc_task_id)
1451  {
1453  lcf_proc_task_id = NULL;
1454  }
1455  }
1456  GNUNET_assert (NULL == lcf_proc_task_id);
1457  for (lcf = lcf_head; NULL != lcf; lcf = lcf_head)
1458  {
1459  if (NULL != lcf->op)
1461  if (NULL != lcf->timeout_task)
1464  lcf_tail,
1465  lcf);
1466  GNUNET_free (lcf);
1467  }
1468 }

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

◆ 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

◆ GST_slave_list_size

unsigned int GST_slave_list_size

◆ route_list

struct Route** route_list
static

◆ lcf_head

struct LCFContext* lcf_head
static

◆ 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

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