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 * The configuration of the slave. Cannot be NULL
191 struct GNUNET_CONFIGURATION_Handle *cfg;
194 * handle to lcc which is associated with this slave startup. Should be set to
195 * NULL when the slave has successfully started up
197 struct LinkControllersContext *lcc;
200 * Head of the host registration DLL
202 struct HostRegistration *hr_dll_head;
205 * Tail of the host registration DLL
207 struct HostRegistration *hr_dll_tail;
210 * The current host registration handle
212 struct GNUNET_TESTBED_HostRegistrationHandle *rhandle;
215 * Hashmap to hold Registered host contexts
217 struct GNUNET_CONTAINER_MultiHashMap *reghost_map;
220 * The id of the host this controller is running on
239 * The peer handle from testing API
241 struct GNUNET_TESTING_Peer *peer;
244 * The modified (by GNUNET_TESTING_peer_configure) configuration this
245 * peer is configured with
247 struct GNUNET_CONFIGURATION_Handle *cfg;
250 * Is the peer running
259 * The slave this peer is started through
264 * The id of the remote host this peer is running on
266 uint32_t remote_host_id;
273 * Is this peer locally created?
278 * Our local reference id for this peer
283 * References to peers are using in forwarded overlay contexts and remote
284 * overlay connect contexts. A peer can only be destroyed after all such
285 * contexts are destroyed. For this, we maintain a reference counter. When we
286 * use a peer in any such context, we increment this counter. We decrement it
287 * when we are destroying these contexts
289 uint32_t reference_cnt;
292 * While destroying a peer, due to the fact that there could be references to
293 * this peer, we delay the peer destroy to a further time. We do this by using
294 * this flag to destroy the peer while destroying a context in which this peer
295 * has been used. When the flag is set to 1 and reference_cnt = 0 we destroy
298 uint32_t destroy_flag;
304 * The main context information associated with the client which started us
309 * The client handle associated with this context
311 struct GNUNET_SERVER_Client *client;
314 * The network address of the master controller
319 * The TESTING system handle for starting peers locally
321 struct GNUNET_TESTING_System *system;
324 * Our host id according to this context
331 * The structure for identifying a shared service
336 * The name of the shared service
341 * Number of shared peers per instance of the shared service
346 * Number of peers currently sharing the service
348 uint32_t num_sharing;
353 * Context information to used during operations which forward the overlay
356 struct ForwardedOverlayConnectContext
359 * next ForwardedOverlayConnectContext in the DLL
361 struct ForwardedOverlayConnectContext *next;
364 * previous ForwardedOverlayConnectContext in the DLL
366 struct ForwardedOverlayConnectContext *prev;
369 * A copy of the original overlay connect message
371 struct GNUNET_MessageHeader *orig_msg;
374 * The id of the operation which created this context information
376 uint64_t operation_id;
389 * Id of the host where peer2 is running
391 uint32_t peer2_host_id;
396 * This context information will be created for each host that is registered at
397 * slave controllers during overlay connects.
399 struct RegisteredHostContext
402 * The host which is being registered
404 struct GNUNET_TESTBED_Host *reg_host;
407 * The host of the controller which has to connect to the above rhost
409 struct GNUNET_TESTBED_Host *host;
412 * The gateway to which this operation is forwarded to
414 struct Slave *gateway;
417 * The gateway through which peer2's controller can be reached
419 struct Slave *gateway2;
422 * Handle for sub-operations
424 struct GNUNET_TESTBED_Operation *sub_op;
427 * The client which initiated the link controller operation
429 struct GNUNET_SERVER_Client *client;
432 * Head of the ForwardedOverlayConnectContext DLL
434 struct ForwardedOverlayConnectContext *focc_dll_head;
437 * Tail of the ForwardedOverlayConnectContext DLL
439 struct ForwardedOverlayConnectContext *focc_dll_tail;
442 * Enumeration of states for this context
453 * State where we attempt to get peer2's controller configuration
458 * State where we attempt to link the controller of peer 1 to the controller
464 * State where we attempt to do the overlay connection again
473 * States of LCFContext
478 * The Context has been initialized; Nothing has been done on it
483 * Delegated host has been registered at the forwarding controller
485 DELEGATED_HOST_REGISTERED,
488 * The slave host has been registred at the forwarding controller
490 SLAVE_HOST_REGISTERED,
493 * The context has been finished (may have error)
500 * Link controllers request forwarding context
505 * The gateway which will pass the link message to delegated host
507 struct Slave *gateway;
510 * The controller link message that has to be forwarded to
512 struct GNUNET_TESTBED_ControllerLinkRequest *msg;
515 * The client which has asked to perform this operation
517 struct GNUNET_SERVER_Client *client;
520 * Handle for operations which are forwarded while linking controllers
522 struct ForwardedOperationContext *fopc;
525 * The id of the operation which created this context
527 uint64_t operation_id;
530 * The state of this context
532 enum LCFContextState state;
537 uint32_t delegated_host_id;
542 uint32_t slave_host_id;
548 * Structure of a queue entry in LCFContext request queue
550 struct LCFContextQueue
555 struct LCFContext *lcf;
560 struct LCFContextQueue *next;
565 struct LCFContextQueue *prev;
571 struct GNUNET_CONFIGURATION_Handle *our_config;
574 * The master context; generated with the first INIT message
576 extern struct Context *GST_context;
579 * DLL head for forwarded operation contexts
581 extern struct ForwardedOperationContext *fopcq_head;
584 * DLL tail for forwarded operation contexts
586 extern struct ForwardedOperationContext *fopcq_tail;
589 * A list of peers we know about
591 extern struct Peer **GST_peer_list;
596 extern struct GNUNET_TESTBED_Host **GST_host_list;
599 * A list of directly linked neighbours
601 extern struct Slave **GST_slave_list;
604 * Operation queue for open file descriptors
606 extern struct OperationQueue *GST_opq_openfds;
609 * Timeout for operations which may take some time
611 const extern struct GNUNET_TIME_Relative GST_timeout;
614 * The size of the peer list
616 extern unsigned int GST_peer_list_size;
619 * The size of the host list
621 extern unsigned int GST_host_list_size;
624 * The size of directly linked neighbours list
626 extern unsigned int GST_slave_list_size;
630 * Queues a message in send queue for sending to the service
632 * @param client the client to whom the queued message has to be sent
633 * @param msg the message to queue
636 GST_queue_message (struct GNUNET_SERVER_Client *client,
637 struct GNUNET_MessageHeader *msg);
641 * Function to destroy a peer
643 * @param peer the peer structure to destroy
646 GST_destroy_peer (struct Peer *peer);
650 * Finds the route with directly connected host as destination through which
651 * the destination host can be reached
653 * @param host_id the id of the destination host
654 * @return the route with directly connected destination host; NULL if no route
658 GST_find_dest_route (uint32_t host_id);
662 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT messages
665 * @param client identification of the client
666 * @param message the actual message
669 GST_handle_overlay_connect (void *cls, struct GNUNET_SERVER_Client *client,
670 const struct GNUNET_MessageHeader *message);
674 * Adds a host registration's request to a slave's registration queue
676 * @param slave the slave controller at which the given host has to be
678 * @param cb the host registration completion callback
679 * @param cb_cls the closure for the host registration completion callback
680 * @param host the host which has to be registered
683 GST_queue_host_registration (struct Slave *slave,
684 GNUNET_TESTBED_HostRegistrationCompletion cb,
685 void *cb_cls, struct GNUNET_TESTBED_Host *host);
689 * Callback to relay the reply msg of a forwarded operation back to the client
691 * @param cls ForwardedOperationContext
692 * @param msg the message to relay
695 GST_forwarded_operation_reply_relay (void *cls,
696 const struct GNUNET_MessageHeader *msg);
700 * Task to free resources when forwarded operation has been timedout
702 * @param cls the ForwardedOperationContext
703 * @param tc the task context from scheduler
706 GST_forwarded_operation_timeout (void *cls,
707 const struct GNUNET_SCHEDULER_TaskContext *tc);
711 * Send operation failure message to client
713 * @param client the client to which the failure message has to be sent to
714 * @param operation_id the id of the failed operation
715 * @param emsg the error message; can be NULL
718 GST_send_operation_fail_msg (struct GNUNET_SERVER_Client *client,
719 uint64_t operation_id, const char *emsg);
723 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages
726 * @param client identification of the client
727 * @param message the actual message
730 GST_handle_remote_overlay_connect (void *cls,
731 struct GNUNET_SERVER_Client *client,
732 const struct GNUNET_MessageHeader *message);
736 * Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext
738 * @param rhc the RegisteredHostContext
741 GST_process_next_focc (struct RegisteredHostContext *rhc);
745 * Cleans up ForwardedOverlayConnectContext
747 * @param focc the ForwardedOverlayConnectContext to cleanup
750 GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc);
754 * Clears all pending overlay connect contexts in queue
761 * Clears all pending remote overlay connect contexts in queue
768 * Initializes the cache
770 * @param size the size of the cache
773 GST_cache_init (unsigned int size);
784 * Looks up in the hello cache and returns the HELLO of the given peer
786 * @param peer_id the index of the peer whose HELLO has to be looked up
787 * @return the HELLO message; NULL if not found
789 const struct GNUNET_MessageHeader *
790 GST_cache_lookup_hello (const unsigned int peer_id);
794 * Caches the HELLO of the given peer. Updates the HELLO if it was already
797 * @param id the peer identity of the peer whose HELLO has to be cached
798 * @param hello the HELLO message
801 GST_cache_add_hello (const unsigned int peer_id,
802 const struct GNUNET_MessageHeader *hello);
806 * Functions of this type are called when the needed handle is available for
807 * usage. These functions are to be registered with either of the functions
808 * GST_cache_get_handle_transport() or GST_cache_get_handle_core(). The
809 * corresponding handles will be set and if they are not, then it signals an
810 * error while opening the handles.
812 * @param cls the closure passed to GST_cache_get_handle_transport() or
813 * GST_cache_get_handle_core()
814 * @param ch the handle to CORE. Can be NULL if it is not requested
815 * @param th the handle to TRANSPORT. Can be NULL if it is not requested
816 * @param peer_id the identity of the peer. Will be NULL if ch is NULL. In other
817 * cases, its value being NULL means that CORE connection has failed.
819 typedef void (*GST_cache_handle_ready_cb) (void *cls,
820 struct GNUNET_CORE_Handle * ch,
821 struct GNUNET_TRANSPORT_Handle * th,
822 const struct GNUNET_PeerIdentity *
827 * Callback to notify when the target peer given to
828 * GST_cache_get_handle_transport() is connected. Note that this callback may
829 * not be called if the target peer is already connected. Use
830 * GNUNET_TRANSPORT_check_neighbour_connected() to check if the target peer is
831 * already connected or not. This callback will be called only once or never (in
832 * case the target cannot be connected).
834 * @param cls the closure given to GST_cache_get_handle_done() for this callback
835 * @param target the peer identity of the target peer. The pointer should be
836 * valid until GST_cache_get_handle_done() is called.
838 typedef void (*GST_cache_peer_connect_notify) (void *cls,
839 const struct GNUNET_PeerIdentity
844 * Get a transport handle with the given configuration. If the handle is already
845 * cached before, it will be retured in the given callback; the peer_id is used to lookup in the
846 * cache. If not a new operation is started to open the transport handle and
847 * will be given in the callback when it is available.
849 * @param peer_id the index of the peer
850 * @param cfg the configuration with which the transport handle has to be
851 * created if it was not present in the cache
852 * @param cb the callback to notify when the transport handle is available
853 * @param cb_cls the closure for the above callback
854 * @param target the peer identify of the peer whose connection to our TRANSPORT
855 * subsystem will be notified through the connect_notify_cb. Can be NULL
856 * @param connect_notify_cb the callback to call when the given target peer is
857 * connected. This callback will only be called once or never again (in
858 * case the target peer cannot be connected). Can be NULL
859 * @param connect_notify_cb_cls the closure for the above callback
860 * @return the handle which can be used cancel or mark that the handle is no
863 struct GSTCacheGetHandle *
864 GST_cache_get_handle_transport (unsigned int peer_id,
865 const struct GNUNET_CONFIGURATION_Handle *cfg,
866 GST_cache_handle_ready_cb cb, void *cb_cls,
867 const struct GNUNET_PeerIdentity *target,
868 GST_cache_peer_connect_notify connect_notify_cb,
869 void *connect_notify_cb_cls);
873 * Get a CORE handle with the given configuration. If the handle is already
874 * cached before, it will be retured in the given callback; the peer_id is used
875 * to lookup in the cache. If the handle is not cached before, a new operation
876 * is started to open the CORE handle and will be given in the callback when it
877 * is available along with the peer identity
879 * @param peer_id the index of the peer
880 * @param cfg the configuration with which the transport handle has to be
881 * created if it was not present in the cache
882 * @param cb the callback to notify when the transport handle is available
883 * @param cb_cls the closure for the above callback
884 * @param target the peer identify of the peer whose connection to our CORE
885 * subsystem will be notified through the connect_notify_cb. Can be NULL
886 * @param connect_notify_cb the callback to call when the given target peer is
887 * connected. This callback will only be called once or never again (in
888 * case the target peer cannot be connected). Can be NULL
889 * @param connect_notify_cb_cls the closure for the above callback
890 * @return the handle which can be used cancel or mark that the handle is no
893 struct GSTCacheGetHandle *
894 GST_cache_get_handle_core (unsigned int peer_id,
895 const struct GNUNET_CONFIGURATION_Handle *cfg,
896 GST_cache_handle_ready_cb cb, void *cb_cls,
897 const struct GNUNET_PeerIdentity *target,
898 GST_cache_peer_connect_notify connect_notify_cb,
899 void *connect_notify_cb_cls);
903 * Mark the GetCacheHandle as being done if a handle has been provided already
904 * or as being cancelled if the callback for the handle hasn't been called.
906 * @param cgh the CacheGetHandle handle
909 GST_cache_get_handle_done (struct GSTCacheGetHandle *cgh);
911 /* End of gnunet-service-testbed.h */