2 This file is part of GNUnet.
3 (C) 2012 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 2, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file testbed/gnunet-service-testbed.h
23 * @brief data structures shared amongst components of TESTBED service
24 * @author Sree Harsha Totakura
28 #include "gnunet_util_lib.h"
29 #include "gnunet_testbed_service.h"
30 #include "gnunet_transport_service.h"
31 #include "gnunet_core_service.h"
34 #include "testbed_api.h"
35 #include "testbed_api_operations.h"
36 #include "testbed_api_hosts.h"
37 #include "gnunet_testing_lib.h"
43 #define LOG(kind,...) \
44 GNUNET_log (kind, __VA_ARGS__)
49 #define LOG_DEBUG(...) \
50 LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
53 * By how much should the arrays lists grow
55 #define LIST_GROW_STEP 10
69 * The destination host is reachable thru
76 * Context information for operations forwarded to subcontrollers
78 struct ForwardedOperationContext
81 * The next pointer for DLL
83 struct ForwardedOperationContext *next;
86 * The prev pointer for DLL
88 struct ForwardedOperationContext *prev;
91 * The generated operation context
93 struct OperationContext *opc;
96 * The client to which we have to reply
98 struct GNUNET_SERVER_Client *client;
106 * Task ID for the timeout task
108 GNUNET_SCHEDULER_TaskIdentifier timeout_task;
111 * The id of the operation that has been forwarded
113 uint64_t operation_id;
116 * The type of the operation which is forwarded
118 enum OperationType type;
124 * A DLL of host registrations to be made
126 struct HostRegistration
129 * next registration in the DLL
131 struct HostRegistration *next;
134 * previous registration in the DLL
136 struct HostRegistration *prev;
139 * The callback to call after this registration's status is available
141 GNUNET_TESTBED_HostRegistrationCompletion cb;
144 * The closure for the above callback
149 * The host that has to be registered
151 struct GNUNET_TESTBED_Host *host;
156 * Context information used while linking controllers
158 struct LinkControllersContext
161 * The client which initiated the link controller operation
163 struct GNUNET_SERVER_Client *client;
166 * The ID of the operation
168 uint64_t operation_id;
174 * Structure representing a connected(directly-linked) controller
179 * The controller process handle if we had started the controller
181 struct GNUNET_TESTBED_ControllerProc *controller_proc;
184 * The controller handle
186 struct GNUNET_TESTBED_Controller *controller;
189 * handle to lcc which is associated with this slave startup. Should be set to
190 * NULL when the slave has successfully started up
192 struct LinkControllersContext *lcc;
195 * Head of the host registration DLL
197 struct HostRegistration *hr_dll_head;
200 * Tail of the host registration DLL
202 struct HostRegistration *hr_dll_tail;
205 * The current host registration handle
207 struct GNUNET_TESTBED_HostRegistrationHandle *rhandle;
210 * Hashmap to hold Registered host contexts
212 struct GNUNET_CONTAINER_MultiHashMap *reghost_map;
215 * The id of the host this controller is running on
234 * The peer handle from testing API
236 struct GNUNET_TESTING_Peer *peer;
239 * The modified (by GNUNET_TESTING_peer_configure) configuration this
240 * peer is configured with
242 struct GNUNET_CONFIGURATION_Handle *cfg;
245 * Is the peer running
254 * The slave this peer is started through
259 * The id of the remote host this peer is running on
261 uint32_t remote_host_id;
268 * Is this peer locally created?
273 * Our local reference id for this peer
278 * References to peers are using in forwarded overlay contexts and remote
279 * overlay connect contexts. A peer can only be destroyed after all such
280 * contexts are destroyed. For this, we maintain a reference counter. When we
281 * use a peer in any such context, we increment this counter. We decrement it
282 * when we are destroying these contexts
284 uint32_t reference_cnt;
287 * While destroying a peer, due to the fact that there could be references to
288 * this peer, we delay the peer destroy to a further time. We do this by using
289 * this flag to destroy the peer while destroying a context in which this peer
290 * has been used. When the flag is set to 1 and reference_cnt = 0 we destroy
293 uint32_t destroy_flag;
299 * The main context information associated with the client which started us
304 * The client handle associated with this context
306 struct GNUNET_SERVER_Client *client;
309 * The network address of the master controller
314 * The TESTING system handle for starting peers locally
316 struct GNUNET_TESTING_System *system;
319 * Our host id according to this context
326 * The structure for identifying a shared service
331 * The name of the shared service
336 * Number of shared peers per instance of the shared service
341 * Number of peers currently sharing the service
343 uint32_t num_sharing;
348 * Context information to used during operations which forward the overlay
351 struct ForwardedOverlayConnectContext
354 * next ForwardedOverlayConnectContext in the DLL
356 struct ForwardedOverlayConnectContext *next;
359 * previous ForwardedOverlayConnectContext in the DLL
361 struct ForwardedOverlayConnectContext *prev;
364 * A copy of the original overlay connect message
366 struct GNUNET_MessageHeader *orig_msg;
369 * The id of the operation which created this context information
371 uint64_t operation_id;
384 * Id of the host where peer2 is running
386 uint32_t peer2_host_id;
391 * The type for data structures which commonly arrive at the slave_event_callback
396 * Type for RegisteredHostContext closures
398 CLOSURE_TYPE_RHC = 1,
401 * Type for LinkControllersForwardingContext closures
408 * This context information will be created for each host that is registered at
409 * slave controllers during overlay connects.
411 struct RegisteredHostContext
414 * The type of this data structure. Set this to CLOSURE_TYPE_RHC
416 enum ClosureType type;
419 * The host which is being registered
421 struct GNUNET_TESTBED_Host *reg_host;
424 * The host of the controller which has to connect to the above rhost
426 struct GNUNET_TESTBED_Host *host;
429 * The gateway to which this operation is forwarded to
431 struct Slave *gateway;
434 * The gateway through which peer2's controller can be reached
436 struct Slave *gateway2;
439 * Handle for sub-operations
441 struct GNUNET_TESTBED_Operation *sub_op;
444 * The client which initiated the link controller operation
446 struct GNUNET_SERVER_Client *client;
449 * Head of the ForwardedOverlayConnectContext DLL
451 struct ForwardedOverlayConnectContext *focc_dll_head;
454 * Tail of the ForwardedOverlayConnectContext DLL
456 struct ForwardedOverlayConnectContext *focc_dll_tail;
459 * Enumeration of states for this context
470 * State where we attempt to get peer2's controller configuration
475 * State where we attempt to link the controller of peer 1 to the controller
481 * State where we attempt to do the overlay connection again
490 * States of LCFContext
495 * The Context has been initialized; Nothing has been done on it
500 * Delegated host has been registered at the forwarding controller
502 DELEGATED_HOST_REGISTERED,
505 * The slave host has been registred at the forwarding controller
507 SLAVE_HOST_REGISTERED,
510 * The context has been finished (may have error)
517 * Link controllers request forwarding context
522 * The type of this data structure. Set this to CLOSURE_TYPE_LCF
524 enum ClosureType type;
527 * The gateway which will pass the link message to delegated host
529 struct Slave *gateway;
532 * The client which has asked to perform this operation
534 struct GNUNET_SERVER_Client *client;
537 * Handle for operations which are forwarded while linking controllers
539 struct GNUNET_TESTBED_Operation *op;
542 * The configuration which has to be either used as a template while starting
543 * the delegated controller or for connecting to the delegated controller
545 struct GNUNET_CONFIGURATION_Handle *cfg;
550 GNUNET_SCHEDULER_TaskIdentifier timeout_task;
553 * The id of the operation which created this context
555 uint64_t operation_id;
558 * should the slave controller start the delegated controller?
563 * The state of this context
565 enum LCFContextState state;
570 uint32_t delegated_host_id;
575 uint32_t slave_host_id;
581 * Structure of a queue entry in LCFContext request queue
583 struct LCFContextQueue
588 struct LCFContext *lcf;
593 struct LCFContextQueue *next;
598 struct LCFContextQueue *prev;
605 struct GNUNET_CONFIGURATION_Handle *our_config;
608 * The master context; generated with the first INIT message
610 extern struct Context *GST_context;
613 * DLL head for forwarded operation contexts
615 extern struct ForwardedOperationContext *fopcq_head;
618 * DLL tail for forwarded operation contexts
620 extern struct ForwardedOperationContext *fopcq_tail;
623 * A list of peers we know about
625 extern struct Peer **GST_peer_list;
630 extern struct GNUNET_TESTBED_Host **GST_host_list;
633 * A list of directly linked neighbours
635 extern struct Slave **GST_slave_list;
638 * Operation queue for open file descriptors
640 extern struct OperationQueue *GST_opq_openfds;
643 * Timeout for operations which may take some time
645 const extern struct GNUNET_TIME_Relative GST_timeout;
648 * The size of the peer list
650 extern unsigned int GST_peer_list_size;
653 * The size of the host list
655 extern unsigned int GST_host_list_size;
658 * The size of directly linked neighbours list
660 extern unsigned int GST_slave_list_size;
664 * Queues a message in send queue for sending to the service
666 * @param client the client to whom the queued message has to be sent
667 * @param msg the message to queue
670 GST_queue_message (struct GNUNET_SERVER_Client *client,
671 struct GNUNET_MessageHeader *msg);
675 * Function to destroy a peer
677 * @param peer the peer structure to destroy
680 GST_destroy_peer (struct Peer *peer);
684 * Finds the route with directly connected host as destination through which
685 * the destination host can be reached
687 * @param host_id the id of the destination host
688 * @return the route with directly connected destination host; NULL if no route
692 GST_find_dest_route (uint32_t host_id);
696 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT messages
699 * @param client identification of the client
700 * @param message the actual message
703 GST_handle_overlay_connect (void *cls, struct GNUNET_SERVER_Client *client,
704 const struct GNUNET_MessageHeader *message);
708 * Adds a host registration's request to a slave's registration queue
710 * @param slave the slave controller at which the given host has to be
712 * @param cb the host registration completion callback
713 * @param cb_cls the closure for the host registration completion callback
714 * @param host the host which has to be registered
717 GST_queue_host_registration (struct Slave *slave,
718 GNUNET_TESTBED_HostRegistrationCompletion cb,
719 void *cb_cls, struct GNUNET_TESTBED_Host *host);
723 * Callback to relay the reply msg of a forwarded operation back to the client
725 * @param cls ForwardedOperationContext
726 * @param msg the message to relay
729 GST_forwarded_operation_reply_relay (void *cls,
730 const struct GNUNET_MessageHeader *msg);
734 * Task to free resources when forwarded operation has been timedout
736 * @param cls the ForwardedOperationContext
737 * @param tc the task context from scheduler
740 GST_forwarded_operation_timeout (void *cls,
741 const struct GNUNET_SCHEDULER_TaskContext *tc);
745 * Send operation failure message to client
747 * @param client the client to which the failure message has to be sent to
748 * @param operation_id the id of the failed operation
749 * @param emsg the error message; can be NULL
752 GST_send_operation_fail_msg (struct GNUNET_SERVER_Client *client,
753 uint64_t operation_id, const char *emsg);
757 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages
760 * @param client identification of the client
761 * @param message the actual message
764 GST_handle_remote_overlay_connect (void *cls,
765 struct GNUNET_SERVER_Client *client,
766 const struct GNUNET_MessageHeader *message);
770 * Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext
772 * @param rhc the RegisteredHostContext
775 GST_process_next_focc (struct RegisteredHostContext *rhc);
779 * Cleans up ForwardedOverlayConnectContext
781 * @param focc the ForwardedOverlayConnectContext to cleanup
784 GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc);
788 * Clears all pending overlay connect contexts in queue
795 * Clears all pending remote overlay connect contexts in queue
802 * Initializes the cache
804 * @param size the size of the cache
807 GST_cache_init (unsigned int size);
818 * Looks up in the hello cache and returns the HELLO of the given peer
820 * @param peer_id the index of the peer whose HELLO has to be looked up
821 * @return the HELLO message; NULL if not found
823 const struct GNUNET_MessageHeader *
824 GST_cache_lookup_hello (const unsigned int peer_id);
828 * Caches the HELLO of the given peer. Updates the HELLO if it was already
831 * @param peer_id the peer identity of the peer whose HELLO has to be cached
832 * @param hello the HELLO message
835 GST_cache_add_hello (const unsigned int peer_id,
836 const struct GNUNET_MessageHeader *hello);
840 * Functions of this type are called when the needed handle is available for
841 * usage. These functions are to be registered with either of the functions
842 * GST_cache_get_handle_transport() or GST_cache_get_handle_core(). The
843 * corresponding handles will be set and if they are not, then it signals an
844 * error while opening the handles.
846 * @param cls the closure passed to GST_cache_get_handle_transport() or
847 * GST_cache_get_handle_core()
848 * @param ch the handle to CORE. Can be NULL if it is not requested
849 * @param th the handle to TRANSPORT. Can be NULL if it is not requested
850 * @param peer_id the identity of the peer. Will be NULL if ch is NULL. In other
851 * cases, its value being NULL means that CORE connection has failed.
853 typedef void (*GST_cache_handle_ready_cb) (void *cls,
854 struct GNUNET_CORE_Handle * ch,
855 struct GNUNET_TRANSPORT_Handle * th,
856 const struct GNUNET_PeerIdentity *
861 * Callback to notify when the target peer given to
862 * GST_cache_get_handle_transport() is connected. Note that this callback may
863 * not be called if the target peer is already connected. Use
864 * GNUNET_TRANSPORT_check_neighbour_connected() to check if the target peer is
865 * already connected or not. This callback will be called only once or never (in
866 * case the target cannot be connected).
868 * @param cls the closure given to GST_cache_get_handle_done() for this callback
869 * @param target the peer identity of the target peer. The pointer should be
870 * valid until GST_cache_get_handle_done() is called.
872 typedef void (*GST_cache_peer_connect_notify) (void *cls,
873 const struct GNUNET_PeerIdentity
878 * Get a transport handle with the given configuration. If the handle is already
879 * cached before, it will be retured in the given callback; the peer_id is used to lookup in the
880 * cache. If not a new operation is started to open the transport handle and
881 * will be given in the callback when it is available.
883 * @param peer_id the index of the peer
884 * @param cfg the configuration with which the transport handle has to be
885 * created if it was not present in the cache
886 * @param cb the callback to notify when the transport handle is available
887 * @param cb_cls the closure for the above callback
888 * @param target the peer identify of the peer whose connection to our TRANSPORT
889 * subsystem will be notified through the connect_notify_cb. Can be NULL
890 * @param connect_notify_cb the callback to call when the given target peer is
891 * connected. This callback will only be called once or never again (in
892 * case the target peer cannot be connected). Can be NULL
893 * @param connect_notify_cb_cls the closure for the above callback
894 * @return the handle which can be used cancel or mark that the handle is no
897 struct GSTCacheGetHandle *
898 GST_cache_get_handle_transport (unsigned int peer_id,
899 const struct GNUNET_CONFIGURATION_Handle *cfg,
900 GST_cache_handle_ready_cb cb, void *cb_cls,
901 const struct GNUNET_PeerIdentity *target,
902 GST_cache_peer_connect_notify connect_notify_cb,
903 void *connect_notify_cb_cls);
907 * Get a CORE handle with the given configuration. If the handle is already
908 * cached before, it will be retured in the given callback; the peer_id is used
909 * to lookup in the cache. If the handle is not cached before, a new operation
910 * is started to open the CORE handle and will be given in the callback when it
911 * is available along with the peer identity
913 * @param peer_id the index of the peer
914 * @param cfg the configuration with which the transport handle has to be
915 * created if it was not present in the cache
916 * @param cb the callback to notify when the transport handle is available
917 * @param cb_cls the closure for the above callback
918 * @param target the peer identify of the peer whose connection to our CORE
919 * subsystem will be notified through the connect_notify_cb. Can be NULL
920 * @param connect_notify_cb the callback to call when the given target peer is
921 * connected. This callback will only be called once or never again (in
922 * case the target peer cannot be connected). Can be NULL
923 * @param connect_notify_cb_cls the closure for the above callback
924 * @return the handle which can be used cancel or mark that the handle is no
927 struct GSTCacheGetHandle *
928 GST_cache_get_handle_core (unsigned int peer_id,
929 const struct GNUNET_CONFIGURATION_Handle *cfg,
930 GST_cache_handle_ready_cb cb, void *cb_cls,
931 const struct GNUNET_PeerIdentity *target,
932 GST_cache_peer_connect_notify connect_notify_cb,
933 void *connect_notify_cb_cls);
937 * Mark the GetCacheHandle as being done if a handle has been provided already
938 * or as being cancelled if the callback for the handle hasn't been called.
940 * @param cgh the CacheGetHandle handle
943 GST_cache_get_handle_done (struct GSTCacheGetHandle *cgh);
945 /* End of gnunet-service-testbed.h */