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 210 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 257 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 283 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 302 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 360 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 389 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 446 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 483 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 518 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 555 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 601 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;
 }