profiling tool for distributed key generation and decryption More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_secretsharing_service.h"
#include "gnunet_testbed_service.h"

Include dependency graph for gnunet-secretsharing-profiler.c:

Functions
static void	controller_cb (void cls, const struct GNUNET_TESTBED_EventInformation event)
	Signature of the event handler function called by the respective event controller. More...

static void	session_connect_complete (void cls, struct GNUNET_TESTBED_Operation op, void ca_result, const char emsg)
	Callback to be called when a service connect operation is completed. More...

static void	decrypt_connect_complete (void cls, struct GNUNET_TESTBED_Operation op, void ca_result, const char emsg)
	Callback to be called when a service connect operation is completed. More...

static void	decrypt_cb (void cls, const struct GNUNET_SECRETSHARING_Plaintext plaintext)
	Called when a decryption has succeeded. More...

static void *	decrypt_connect_adapter (void cls, const struct GNUNET_CONFIGURATION_Handle cfg)
	Adapter function called to establish a connection to a service. More...

static void	decrypt_disconnect_adapter (void cls, void op_result)
	Adapter function called to destroy a connection to a service. More...

static void	secret_ready_cb (void cls, struct GNUNET_SECRETSHARING_Share my_share, struct GNUNET_SECRETSHARING_PublicKey public_key, unsigned int num_ready_peers, const struct GNUNET_PeerIdentity ready_peers)

static void *	session_connect_adapter (void cls, const struct GNUNET_CONFIGURATION_Handle cfg)
	Adapter function called to establish a connection to a service. More...

static void	session_disconnect_adapter (void cls, void op_result)
	Adapter function called to destroy a connection to a service. More...

static void	peer_info_cb (void cb_cls, struct GNUNET_TESTBED_Operation op, const struct GNUNET_TESTBED_PeerInformation pinfo, const char emsg)
	Callback to be called when the requested peer information is available. More...

static void	handle_shutdown (void *cls)
	Signature of the main function of a task. More...

static void	test_master (void cls, struct GNUNET_TESTBED_RunHandle h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **started_peers, unsigned int links_succeeded, unsigned int links_failed)
	Signature of a main function for a testcase. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)

int	main (int argc, char **argv)

Variables
static unsigned int	num_peers = 3
	How many peers should participate in the key generation? More...

static unsigned int	threshold = 2
	What should the threshold for then key be? More...

static int	decrypt = GNUNET_NO
	Should we try to decrypt a value after the key generation? More...

static struct GNUNET_TIME_Relative	timeout
	When would we like to see the operation finished? More...

static struct GNUNET_TIME_Relative	delay
	When should dkg communication start? More...

static struct GNUNET_SECRETSHARING_Session **	session_handles
	Handles for secretsharing sessions. More...

static struct GNUNET_SECRETSHARING_DecryptionHandle **	decrypt_handles

static struct GNUNET_SECRETSHARING_Share **	shares
	Shares we got from the distributed key generation. More...

static struct GNUNET_SECRETSHARING_PublicKey	common_pubkey

static unsigned int	num_connected_sessions

static unsigned int	num_connected_decrypt

static struct GNUNET_TESTBED_Peer **	peers
	Handles to the running peers. More...

static struct GNUNET_PeerIdentity *	peer_ids

static unsigned int	num_retrieved_peer_ids

static unsigned int	num_generated

static unsigned int	num_decrypted

static struct GNUNET_HashCode	session_id

static unsigned int	verbose

static struct GNUNET_SECRETSHARING_Plaintext	reference_plaintext

static struct GNUNET_SECRETSHARING_Ciphertext	ciphertext

static struct GNUNET_TIME_Absolute	dkg_start

static struct GNUNET_TIME_Absolute	dkg_deadline

static struct GNUNET_TIME_Absolute	decrypt_start

static struct GNUNET_TIME_Absolute	decrypt_deadline

static struct GNUNET_TESTBED_Operation **	connect_ops
	Connect operations, one for every peer. More...

static int	in_shutdown
	Are we performing a shutdown right now? More...

Detailed Description

profiling tool for distributed key generation and decryption

Author: Florian Dold

Definition in file gnunet-secretsharing-profiler.c.

Function Documentation

◆ controller_cb()

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

static

Signature of the event handler function called by the respective event controller.

Parameters

cls	closure
event	information about the event

Definition at line 125 of file gnunet-secretsharing-profiler.c.

References GNUNET_assert.

Referenced by run().

 {
   GNUNET_assert (0);
 }

Here is the caller graph for this function:

◆ session_connect_complete()

static void session_connect_complete	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		void *	ca_result,
		const char *	emsg
	)

static

Callback to be called when a service connect operation is completed.

Parameters

cls	the callback closure from functions generating an operation
op	the operation that has been finished
ca_result	the service handle returned from GNUNET_TESTBED_ConnectAdapter()
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 142 of file gnunet-secretsharing-profiler.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, num_connected_sessions, and num_peers.

Referenced by peer_info_cb().

 {
   if (NULL != emsg)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "testbed connect emsg: %s\n",
                 emsg);
     GNUNET_assert (0);
   }
 
   num_connected_sessions++;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "dkg: session connect complete\n");
 
   if (num_connected_sessions == num_peers)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "dkg: all peers connected\n");
   }
 }

Here is the caller graph for this function:

◆ decrypt_connect_complete()

static void decrypt_connect_complete	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		void *	ca_result,
		const char *	emsg
	)

static

Callback to be called when a service connect operation is completed.

Parameters

cls	the callback closure from functions generating an operation
op	the operation that has been finished
ca_result	the service handle returned from GNUNET_TESTBED_ConnectAdapter()
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 178 of file gnunet-secretsharing-profiler.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, num_connected_decrypt, and num_peers.

Referenced by session_disconnect_adapter().

 {
   if (NULL != emsg)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "testbed connect emsg: %s\n",
                 emsg);
     GNUNET_assert (0);
   }
 
   num_connected_decrypt++;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "decrypt: session connect complete\n");
 
   if (num_connected_decrypt == num_peers)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "decrypt: all peers connected\n");
   }
 }

Here is the caller graph for this function:

◆ decrypt_cb()

static void decrypt_cb	(	void *	cls,
		const struct GNUNET_SECRETSHARING_Plaintext *	plaintext
	)

static

Called when a decryption has succeeded.

Parameters

cls	Plaintext
plaintext	Plaintext

Definition at line 211 of file gnunet-secretsharing-profiler.c.

References decrypt_handles, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_memcmp, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), num_decrypted, num_peers, and reference_plaintext.

Referenced by decrypt_connect_adapter(), and GNUNET_SECRETSHARING_decrypt().

 {
   struct GNUNET_SECRETSHARING_DecryptionHandle **dhp = cls;
   unsigned int n = dhp - decrypt_handles;
 
   num_decrypted++;
 
   *dhp = NULL;
 
   // we should still be connected if this is called
   GNUNET_assert (NULL != connect_ops[n]);
 
   GNUNET_TESTBED_operation_done (connect_ops[n]);
 
   if (NULL == plaintext)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "decrypt failed for peer %u\n", n);
     return;
   }
   else if (0 == GNUNET_memcmp (&reference_plaintext, plaintext))
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "decrypt got correct result for peer %u\n", n);
   else
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "decrypt got wrong result for peer %u\n", n);
 
   if (num_decrypted == num_peers)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "every peer decrypted\n");
     GNUNET_SCHEDULER_shutdown ();
   }
 
   *dhp = NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decrypt_connect_adapter()

static void* decrypt_connect_adapter	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Adapter function called to establish a connection to a service.

Parameters

cls	closure
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns: service handle to return in 'op_result', NULL on error

Definition at line 259 of file gnunet-secretsharing-profiler.c.

References ciphertext, decrypt_cb(), decrypt_deadline, decrypt_handles, decrypt_start, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SECRETSHARING_decrypt(), and num_peers.

Referenced by session_disconnect_adapter().

 {
   struct GNUNET_SECRETSHARING_DecryptionHandle **hp = cls;
   unsigned int n = hp - decrypt_handles;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "decrypt connect adapter, %d peers\n",
               num_peers);
   *hp = GNUNET_SECRETSHARING_decrypt (cfg, shares[n], &ciphertext,
                                       decrypt_start, decrypt_deadline,
                                       decrypt_cb,
                                       hp);
 
   return *hp;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decrypt_disconnect_adapter()

static void decrypt_disconnect_adapter	(	void *	cls,
		void *	op_result
	)

static

Adapter function called to destroy a connection to a service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter

Definition at line 285 of file gnunet-secretsharing-profiler.c.

References decrypt_handles, GNUNET_assert, and GNUNET_SECRETSHARING_decrypt_cancel().

Referenced by session_disconnect_adapter().

 {
   struct GNUNET_SECRETSHARING_DecryptionHandle **dh = cls;
   unsigned int n = dh - decrypt_handles;
 
   GNUNET_assert (*dh == decrypt_handles[n]);
 
   if (NULL != *dh)
   {
     GNUNET_SECRETSHARING_decrypt_cancel (*dh);
     *dh = NULL;
   }
 
   GNUNET_assert (NULL != connect_ops[n]);
   connect_ops[n] = NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ secret_ready_cb()

static void secret_ready_cb	(	void *	cls,
		struct GNUNET_SECRETSHARING_Share *	my_share,
		struct GNUNET_SECRETSHARING_PublicKey *	public_key,
		unsigned int	num_ready_peers,
		const struct GNUNET_PeerIdentity *	ready_peers
	)

static

Definition at line 304 of file gnunet-secretsharing-profiler.c.

References common_pubkey, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_memcmp, GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_data_to_string(), GNUNET_TESTBED_operation_done(), num_generated, ret, and session_handles.

Referenced by session_connect_adapter().

 {
   struct GNUNET_SECRETSHARING_Session **sp = cls;
   unsigned int n = sp - session_handles;
   char pubkey_str[1024];
   char *ret;
 
   num_generated++;
   *sp = NULL;
   shares[n] = my_share;
   if (NULL == my_share)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation failed for peer #%u\n",
                 n);
   }
   else
   {
     ret = GNUNET_STRINGS_data_to_string (public_key, sizeof *public_key,
                                          pubkey_str, 1024);
     GNUNET_assert (NULL != ret);
     *ret = '\0';
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "key generation successful for peer #%u, pubkey %s\n", n,
                 pubkey_str);
 
     /* we're the first to get the key -> store it */
     if (num_generated == 1)
     {
       common_pubkey = *public_key;
     }
     else if (0 != GNUNET_memcmp (public_key, &common_pubkey))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "generated public keys do not match\n");
       GNUNET_SCHEDULER_shutdown ();
       return;
     }
   }
 
   // we should still be connected
   GNUNET_assert (NULL != connect_ops[n]);
 
   // disconnect from the service, will call the disconnect callback
   GNUNET_TESTBED_operation_done (connect_ops[n]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ session_connect_adapter()

static void* session_connect_adapter	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Adapter function called to establish a connection to a service.

Parameters

cls	closure
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns: service handle to return in 'op_result', NULL on error

Definition at line 366 of file gnunet-secretsharing-profiler.c.

References dkg_deadline, dkg_start, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SECRETSHARING_create_session(), num_peers, secret_ready_cb(), session_id, and threshold.

Referenced by peer_info_cb().

 {
   struct GNUNET_SECRETSHARING_Session **sp = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "connect adapter, %d peers\n",
               num_peers);
   *sp = GNUNET_SECRETSHARING_create_session (cfg,
                                              num_peers,
                                              peer_ids,
                                              &session_id,
                                              dkg_start,
                                              dkg_deadline,
                                              threshold,
                                              &secret_ready_cb, sp);
   return *sp;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ session_disconnect_adapter()

static void session_disconnect_adapter	(	void *	cls,
		void *	op_result
	)

static

Adapter function called to destroy a connection to a service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter

Definition at line 394 of file gnunet-secretsharing-profiler.c.

References ciphertext, common_pubkey, decrypt, decrypt_connect_adapter(), decrypt_connect_complete(), decrypt_deadline, decrypt_disconnect_adapter(), decrypt_start, delay, GNUNET_assert, GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_SECRETSHARING_encrypt(), GNUNET_SECRETSHARING_plaintext_generate_i(), GNUNET_SECRETSHARING_session_destroy(), GNUNET_TESTBED_service_connect(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_YES, in_shutdown, num_generated, num_peers, reference_plaintext, session_handles, and timeout.

Referenced by peer_info_cb().

 {
   struct GNUNET_SECRETSHARING_Session **sp = cls;
   unsigned int n = (sp - session_handles);
 
   GNUNET_assert (*sp == session_handles[n]);
 
   if (NULL != *sp)
   {
     GNUNET_SECRETSHARING_session_destroy (*sp);
     *sp = NULL;
   }
 
   GNUNET_assert (NULL != connect_ops[n]);
   connect_ops[n] = NULL;
 
   if (GNUNET_YES == in_shutdown)
     return;
 
   // all peers received their secret
   if (num_generated == num_peers)
   {
     int i;
 
     // only do decryption if requested by the user
     if (GNUNET_NO == decrypt)
     {
       GNUNET_SCHEDULER_shutdown ();
       return;
     }
 
     decrypt_start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
                                               delay);
     decrypt_deadline = GNUNET_TIME_absolute_add (decrypt_start, timeout);
 
     // compute g^42 as the plaintext which we will decrypt and then
     // cooperatively decrypt
     GNUNET_SECRETSHARING_plaintext_generate_i (&reference_plaintext, 42);
     GNUNET_SECRETSHARING_encrypt (&common_pubkey, &reference_plaintext,
                                   &ciphertext);
 
     for (i = 0; i < num_peers; i++)
       connect_ops[i] =
         GNUNET_TESTBED_service_connect (NULL, peers[i], "secretsharing",
                                         &decrypt_connect_complete, NULL,
                                         &decrypt_connect_adapter,
                                         &decrypt_disconnect_adapter,
                                         &decrypt_handles[i]);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peer_info_cb()

static void peer_info_cb	(	void *	cb_cls,
		struct GNUNET_TESTBED_Operation *	op,
		const struct GNUNET_TESTBED_PeerInformation *	pinfo,
		const char *	emsg
	)

static

Callback to be called when the requested peer information is available.

Parameters

cb_cls	the closure from GNUNET_TETSBED_peer_get_information()
op	the operation this callback corresponds to
pinfo	the result; will be NULL if the operation has failed
emsg	error message if the operation has failed; will be NULL if the operation is successfull

Definition at line 456 of file gnunet-secretsharing-profiler.c.

References GNUNET_assert, GNUNET_TESTBED_operation_done(), GNUNET_TESTBED_PIT_IDENTITY, GNUNET_TESTBED_service_connect(), GNUNET_TESTBED_PeerInformation::id, num_peers, num_retrieved_peer_ids, p, GNUNET_TESTBED_PeerInformation::pit, GNUNET_TESTBED_PeerInformation::result, session_connect_adapter(), session_connect_complete(), and session_disconnect_adapter().

Referenced by test_master().

 {
   struct GNUNET_PeerIdentity *p;
   int i;
 
   GNUNET_assert (NULL == emsg);
 
   p = (struct GNUNET_PeerIdentity *) cb_cls;
 
   if (pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY)
   {
     *p = *pinfo->result.id;
     num_retrieved_peer_ids++;
     if (num_retrieved_peer_ids == num_peers)
       for (i = 0; i < num_peers; i++)
         connect_ops[i] =
           GNUNET_TESTBED_service_connect (NULL, peers[i], "secretsharing",
                                           session_connect_complete, NULL,
                                           session_connect_adapter,
                                           session_disconnect_adapter,
                                           &session_handles[i]);
   }
   else
   {
     GNUNET_assert (0);
   }
 
   GNUNET_TESTBED_operation_done (op);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_shutdown()

static void handle_shutdown ( void * cls )

static

Signature of the main function of a task.

Parameters

cls closure

Definition at line 496 of file gnunet-secretsharing-profiler.c.

References GNUNET_free, GNUNET_TESTBED_operation_done(), GNUNET_YES, in_shutdown, and num_peers.

Referenced by test_master().

 {
   in_shutdown = GNUNET_YES;
 
   if (NULL != connect_ops)
   {
     unsigned int i;
     for (i = 0; i < num_peers; i++)
       if (NULL != connect_ops[i])
       {
         // the disconnect callback will set the op to NULL
         GNUNET_TESTBED_operation_done (connect_ops[i]);
       }
     GNUNET_free (connect_ops);
   }
 
   // killing the testbed operation will take care of remaining
   // service handles in the disconnect callback
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ test_master()

static void test_master	(	void *	cls,
		struct GNUNET_TESTBED_RunHandle *	h,
		unsigned int	num_peers,
		struct GNUNET_TESTBED_Peer **	started_peers,
		unsigned int	links_succeeded,
		unsigned int	links_failed
	)

static

Signature of a main function for a testcase.

Parameters

cls	closure
h	the run handle
num_peers	number of peers in 'peers'
started_peers	handle to peers run in the testbed. NULL upon timeout (see GNUNET_TESTBED_test_run()).
links_succeeded	the number of overlay link connection attempts that succeeded
links_failed	the number of overlay link connection attempts that failed

Definition at line 531 of file gnunet-secretsharing-profiler.c.

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_log_setup(), GNUNET_malloc, GNUNET_new_array, GNUNET_SCHEDULER_add_shutdown(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_PIT_IDENTITY, handle_shutdown(), num_peers, and peer_info_cb().

Referenced by run().

 {
   int i;
 
   GNUNET_log_setup ("gnunet-secretsharing-profiler", "INFO", NULL);
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "test master\n");
 
   GNUNET_SCHEDULER_add_shutdown (&handle_shutdown, NULL);
 
   peers = started_peers;
 
   peer_ids = GNUNET_malloc (num_peers * sizeof(struct GNUNET_PeerIdentity));
 
   session_handles = GNUNET_new_array (num_peers, struct
                                       GNUNET_SECRETSHARING_Session *);
   decrypt_handles = GNUNET_new_array (num_peers, struct
                                       GNUNET_SECRETSHARING_DecryptionHandle *);
   connect_ops = GNUNET_new_array (num_peers, struct GNUNET_TESTBED_Operation *);
   shares = GNUNET_new_array (num_peers, struct GNUNET_SECRETSHARING_Share *);
 
   for (i = 0; i < num_peers; i++)
   {
     // we do not store the returned operation, as peer_info_cb
     // will receive it as a parameter and call GNUNET_TESTBED_operation_done.
     GNUNET_TESTBED_peer_get_information (peers[i],
                                          GNUNET_TESTBED_PIT_IDENTITY,
                                          peer_info_cb,
                                          &peer_ids[i]);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Definition at line 570 of file gnunet-secretsharing-profiler.c.

References controller_cb(), delay, dkg_deadline, dkg_start, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_TESTBED_test_run(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), num_peers, session_id, test_master(), timeout, and topology.

Referenced by main().

 {
   static char *session_str = "gnunet-secretsharing/test";
   char *topology;
   int topology_cmp_result;
 
   dkg_start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
   dkg_deadline = GNUNET_TIME_absolute_add (dkg_start, timeout);
 
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "testbed",
                                                           "OVERLAY_TOPOLOGY",
                                                           &topology))
   {
     fprintf (stderr,
              "'OVERLAY_TOPOLOGY' not found in 'testbed' config section, "
              "seems like you passed the wrong configuration file\n");
     return;
   }
 
   topology_cmp_result = strcasecmp (topology, "NONE");
   GNUNET_free (topology);
 
   if (0 == topology_cmp_result)
   {
     fprintf (stderr,
              "'OVERLAY_TOPOLOGY' set to 'NONE', "
              "seems like you passed the wrong configuration file\n");
     return;
   }
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "running gnunet-secretsharing-profiler\n");
 
   GNUNET_CRYPTO_hash (session_str, strlen (session_str), &session_id);
 
   (void) GNUNET_TESTBED_test_run ("gnunet-secretsharing-profiler",
                                   cfgfile,
                                   num_peers,
                                   0,
                                   controller_cb,
                                   NULL,
                                   test_master,
                                   NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 618 of file gnunet-secretsharing-profiler.c.

References decrypt, delay, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_uint(), GNUNET_GETOPT_option_verbose(), GNUNET_PROGRAM_run2(), GNUNET_TIME_UNIT_MINUTES, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, num_peers, run(), threshold, timeout, and verbose.

 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_option_uint ('n',
                                "num-peers",
                                NULL,
                                gettext_noop ("number of peers in consensus"),
                                &num_peers),
 
     GNUNET_GETOPT_option_relative_time ('D',
                                         "delay",
                                         NULL,
                                         gettext_noop ("dkg start delay"),
                                         &delay),
 
     GNUNET_GETOPT_option_relative_time ('t',
                                         "timeout",
                                         NULL,
                                         gettext_noop ("dkg timeout"),
                                         &timeout),
 
     GNUNET_GETOPT_option_uint ('k',
                                "threshold",
                                NULL,
                                gettext_noop ("threshold"),
                                &threshold),
 
     GNUNET_GETOPT_option_flag ('d',
                                "descrypt",
                                gettext_noop ("also profile decryption"),
                                &decrypt),
 
 
     GNUNET_GETOPT_option_verbose (&verbose),
 
     GNUNET_GETOPT_OPTION_END
   };
 
   delay = GNUNET_TIME_UNIT_ZERO;
   timeout = GNUNET_TIME_UNIT_MINUTES;
   GNUNET_PROGRAM_run2 (argc, argv, "gnunet-secretsharing-profiler",
                        "help",
                        options, &run, NULL, GNUNET_YES);
   return 0;
 }