/**
* Call MESH's monitor API, get info of one connection.
*
* @param cls Closure (unused).
* @param tc TaskContext
*/
static void
create_channel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_PeerIdentity pid;
enum GNUNET_MESH_ChannelOption opt;
GNUNET_assert (NULL == ch);
if (GNUNET_OK !=
GNUNET_CRYPTO_eddsa_public_key_from_string (target_id,
strlen (target_id),
&pid.public_key))
{
FPRINTF (stderr,
_("Invalid target `%s'\n"),
target_id);
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to `%s'\n", target_id);
opt = GNUNET_MESH_OPTION_DEFAULT | GNUNET_MESH_OPTION_RELIABLE;
ch = GNUNET_MESH_channel_create (mh, NULL, &pid, target_port, opt);
if (GNUNET_NO == echo)
listen_stdio ();
else
GNUNET_SCHEDULER_add_now (send_echo, NULL);
}
/**
* Function called to notify a client about the connection
* begin ready to queue more data. "buf" will be
* NULL and "size" zero if the connection was closed for
* writing in the meantime.
*
* FIXME
*
* @param cls closure
* @param size number of bytes available in buf
* @param buf where the callee should write the message
* @return number of bytes written to buf
*/
size_t
data_ready (void *cls, size_t size, void *buf)
{
struct GNUNET_MessageHeader *msg;
size_t total_size;
if (NULL == buf || 0 == size)
{
GNUNET_SCHEDULER_shutdown();
return 0;
}
total_size = data_size + sizeof (struct GNUNET_MessageHeader);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "sending %u bytes\n", data_size);
GNUNET_assert (size >= total_size);
msg = buf;
msg->size = htons (total_size);
msg->type = htons (GNUNET_MESSAGE_TYPE_MESH_CLI);
memcpy (&msg[1], cls, data_size);
if (GNUNET_NO == echo)
{
listen_stdio ();
}
else
{
echo_time = GNUNET_TIME_absolute_get ();
}
return total_size;
}
/**
* Method called to retrieve information about a specific tunnel the mesh peer
* has established, o`r is trying to establish.
*
* @param cls Closure.
* @param peer Peer towards whom the tunnel is directed.
* @param n_channels Number of channels.
* @param n_connections Number of connections.
* @param channels Channels.
* @param connections Connections.
* @param estate Encryption status.
* @param cstate Connectivity status.
*/
void
tunnel_callback (void *cls,
const struct GNUNET_PeerIdentity *peer,
unsigned int n_channels,
unsigned int n_connections,
uint32_t *channels,
struct GNUNET_HashCode *connections,
unsigned int estate,
unsigned int cstate)
{
unsigned int i;
if (NULL != peer)
{
FPRINTF (stdout, "Tunnel %s\n", GNUNET_i2s_full (peer));
FPRINTF (stdout, "- %u channels\n", n_channels);
for (i = 0; i < n_channels; i++)
FPRINTF (stdout, " %u\n", channels[i]);
FPRINTF (stdout, "- %u connections\n", n_connections);
for (i = 0; i < n_connections; i++)
FPRINTF (stdout, " %s\n", GNUNET_h2s_full (&connections[i]));
FPRINTF (stdout, "- enc state: %u\n", estate);
FPRINTF (stdout, "- con state: %u\n", cstate);
}
if (GNUNET_YES != monitor_connections)
{
GNUNET_SCHEDULER_shutdown();
}
return;
}
static void
topology_completed (void *cls,
unsigned int nsuccess,
unsigned int nfailures)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Links successful %u / %u failed\n",
nsuccess,
nfailures);
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
if (nfailures > 0)
{
fprintf (stderr,
"Error: links successful %u but %u failed\n",
nsuccess,
nfailures);
ok = 1;
}
else
ok = 0;
GNUNET_SCHEDULER_shutdown ();
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct DLLOperation *dll_op;
unsigned int nhost;
shutdown_task = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
GNUNET_SCHEDULER_cancel (register_hosts_task);
if (NULL != reg_handle)
GNUNET_TESTBED_cancel_registration (reg_handle);
if (NULL != topology_op)
GNUNET_TESTBED_operation_done (topology_op);
for (nhost = 0; nhost < num_hosts; nhost++)
if (NULL != hosts[nhost])
GNUNET_TESTBED_host_destroy (hosts[nhost]);
GNUNET_free_non_null (hosts);
while (NULL != (dll_op = dll_op_head))
{
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
}
if (NULL != mc)
GNUNET_TESTBED_controller_disconnect (mc);
if (NULL != mc_proc)
GNUNET_TESTBED_controller_stop (mc_proc);
if (NULL != cfg)
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
}
/**
* Callback invoked from the VPN service once a redirection is
* available. Provides the IP address that can now be used to
* reach the requested destination.
*
* @param cls closure
* @param af address family, AF_INET or AF_INET6; AF_UNSPEC on error;
* will match 'result_af' from the request
* @param address IP address (struct in_addr or struct in_addr6, depending on 'af')
* that the VPN allocated for the redirection;
* traffic to this IP will now be redirected to the
* specified target peer; NULL on error
*/
static void
allocation_cb (void *cls,
int af,
const void *address)
{
char buf[INET6_ADDRSTRLEN];
request = NULL;
switch (af)
{
case AF_INET6:
case AF_INET:
FPRINTF (stdout,
"%s\n",
inet_ntop (af, address, buf, sizeof (buf)));
break;
case AF_UNSPEC:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Error creating tunnel\n"));
ret = 1;
break;
default:
break;
}
GNUNET_SCHEDULER_shutdown ();
}
/**
* Functions of this signature are called when a peer has been successfully
* created
*
* @param cls the closure from GNUNET_TESTBED_peer_create()
* @param peer the handle for the created peer; NULL on any error during
* creation
* @param emsg NULL if peer is not NULL; else MAY contain the error description
*/
static void
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
struct RunContextOperation *rcop = cls;
struct GNUNET_TESTBED_RunHandle *rc;
GNUNET_assert (NULL != rcop);
GNUNET_assert (NULL != (rc = rcop->rc));
remove_rcop (rc, rcop);
GNUNET_TESTBED_operation_done (rcop->op);
GNUNET_free (rcop);
if (NULL == peer)
{
if (NULL != emsg)
LOG (GNUNET_ERROR_TYPE_ERROR, "Error while creating a peer: %s\n",
emsg);
GNUNET_SCHEDULER_shutdown ();
return;
}
rc->peers[rc->peer_count] = peer;
rc->peer_count++;
if (rc->peer_count < rc->num_peers)
return;
DEBUG ("%u peers created in %s\n", rc->num_peers, prof_time (rc));
rc->state = RC_PEERS_CREATED;
GNUNET_SCHEDULER_add_now (&start_peers_task, rc);
}
static void
do_download (void *cls,
const char *emsg)
{
struct DownloadContext *dc = cls;
struct GNUNET_FS_Uri *uri = dc->uri;
GNUNET_TESTBED_operation_done (op);
op = NULL;
if (NULL != dc->fn)
{
GNUNET_DISK_directory_remove (dc->fn);
GNUNET_free (dc->fn);
}
GNUNET_free (dc);
if (NULL != emsg)
{
GNUNET_SCHEDULER_shutdown ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to stop source daemon: %s\n",
emsg);
GNUNET_FS_uri_destroy (uri);
ok = 1;
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
(unsigned long long) FILESIZE);
start_time = GNUNET_TIME_absolute_get ();
GNUNET_FS_TEST_download (daemons[0], TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop,
NULL);
GNUNET_FS_uri_destroy (uri);
}
/**
* Task run during shutdown.
*
* @param cls unused
* @param tc unused
*/
static void
cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ClientPeerContext *cp;
cp = cp_head;
while (NULL != cp)
{
GNUNET_CONTAINER_DLL_remove (cp_head, cp_tail, cp);
destroy_clientpeer (cp);
cp = cp_head;
}
if (NULL != cadet)
{
GNUNET_CADET_disconnect (cadet);
cadet = NULL;
}
if (NULL != peerstore)
{
GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_YES);
peerstore = NULL;
}
GNUNET_SENSOR_destroy_sensors (sensors);
if (NULL != sensor_dir)
{
GNUNET_free (sensor_dir);
sensor_dir = NULL;
}
GNUNET_SCHEDULER_shutdown ();
}
/**
* Handler for SHUTDOWN message.
*
* @param cls closure (refers to service)
* @param client identification of the client
* @param message the actual message
*/
static void
handle_shutdown (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
GNUNET_SCHEDULER_shutdown ();
GNUNET_SERVER_client_persist_ (client);
}
static void
clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (p1.th != NULL)
{
if (p1.ghh != NULL)
{
GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
p1.ghh = NULL;
}
GNUNET_TRANSPORT_disconnect (p1.th);
p1.th = NULL;
}
if (p2.th != NULL)
{
if (p2.ghh != NULL)
{
GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
p2.ghh = NULL;
}
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
}
GNUNET_SCHEDULER_shutdown ();
}
/**
* Callback to be called when a service connect operation is completed.
*
* @param cls The callback closure from functions generating an operation.
* @param op The operation that has been finished.
* @param ca_result The service handle returned from
* GNUNET_TESTBED_ConnectAdapter() (mesh handle).
* @param emsg Error message in case the operation has failed.
* NULL if operation has executed successfully.
*/
static void
mesh_connect_cb (void *cls,
struct GNUNET_TESTBED_Operation *op,
void *ca_result,
const char *emsg)
{
struct GNUNET_MESH_TEST_Context *ctx = cls;
unsigned int i;
if (NULL != emsg)
{
fprintf (stderr, "Failed to connect to MESH service: %s\n",
emsg);
GNUNET_SCHEDULER_shutdown ();
return;
}
for (i = 0; i < ctx->num_peers; i++)
if (op == ctx->ops[i])
ctx->meshes[i] = ca_result;
for (i = 0; i < ctx->num_peers; i++)
if (NULL == ctx->meshes[i])
return; /* still some MESH connections missing */
/* all MESH connections ready! */
ctx->app_main (ctx->app_main_cls,
ctx,
ctx->num_peers,
ctx->peers,
ctx->meshes);
}
/**
* Callback invoked from identity service with ego information.
* An @a ego of NULL means the ego was not found.
*
* @param cls closure with the configuration
* @param ego an ego known to identity service, or NULL
*/
static void
identity_cb (void *cls,
const struct GNUNET_IDENTITY_Ego *ego)
{
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
el = NULL;
if (NULL == ego)
{
if (NULL != ego_name)
{
fprintf (stderr,
_("Ego `%s' not known to identity service\n"),
ego_name);
}
GNUNET_SCHEDULER_shutdown ();
ret = -1;
return;
}
zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
GNUNET_free_non_null (ego_name);
ego_name = NULL;
GNUNET_CLIENT_service_test ("namestore", cfg,
GNUNET_TIME_UNIT_SECONDS,
&testservice_task,
(void *) cfg);
}
static void
testservice_id_task (void *cls, int result)
{
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
if (result != GNUNET_YES)
{
fprintf (stderr,
_("Identity service is not running\n"));
GNUNET_SCHEDULER_shutdown ();
ret = -1;
return;
}
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&do_shutdown, (void *) cfg);
if (NULL == ego_name)
{
idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
if (NULL == idh)
fprintf (stderr, _("Cannot connect to identity service\n"));
ret = -1;
return;
}
el = GNUNET_IDENTITY_ego_lookup (cfg,
ego_name,
&identity_cb,
(void *) cfg);
}
/**
* Initialize the DHT subsystem.
*
* @param c Configuration.
*/
void
GCD_init (const struct GNUNET_CONFIGURATION_Handle *c)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (c, "CADET",
"DHT_REPLICATION_LEVEL",
&dht_replication_level))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, "CADET",
"DHT_REPLICATION_LEVEL", "USING DEFAULT");
dht_replication_level = 3;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c, "CADET", "ID_ANNOUNCE_TIME",
&id_announce_time))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, "CADET",
"ID_ANNOUNCE_TIME", "MISSING");
GNUNET_SCHEDULER_shutdown ();
return;
}
dht_handle = GNUNET_DHT_connect (c, 64);
if (NULL == dht_handle)
{
GNUNET_break (0);
}
announce_delay = GNUNET_TIME_UNIT_SECONDS;
announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, NULL);
get_requests = GNUNET_CONTAINER_multihashmap32_create (32);
}
/**
* Called when a decryption has succeeded.
*
* @param cls Plaintext
* @param plaintext Plaintext
*/
static void decrypt_cb (void *cls,
const struct GNUNET_SECRETSHARING_Plaintext *plaintext)
{
struct GNUNET_SECRETSHARING_DecryptionHandle **dhp = cls;
unsigned int n = dhp - decrypt_handles;
num_decrypted++;
*dhp = NULL;
if (NULL == plaintext)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "decrypt failed for peer %u\n", n);
return;
}
else if (0 == memcmp (&reference_plaintext, plaintext, sizeof (struct GNUNET_SECRETSHARING_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;
}
static void
call_event_handler (void *cls,
enum GNUNET_CONVERSATION_CallEventCode code)
{
static enum GNUNET_CONVERSATION_CallEventCode expect
= GNUNET_CONVERSATION_EC_CALL_RINGING;
GNUNET_break (code == expect);
switch (code)
{
case GNUNET_CONVERSATION_EC_CALL_RINGING:
expect = GNUNET_CONVERSATION_EC_CALL_HUNG_UP;
break;
case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
call = NULL;
ok = 0;
GNUNET_SCHEDULER_shutdown ();
expect = -1;
break;
case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
case GNUNET_CONVERSATION_EC_CALL_RESUMED:
fprintf (stderr, "Unexpected call code: %d\n", code);
break;
case GNUNET_CONVERSATION_EC_CALL_ERROR:
fprintf (stderr, "Unexpected call code: %d\n", code);
call = NULL;
break;
}
}
/**
* Shutdown nicely
*
* @param cls NULL
*/
static void
do_shutdown (void *cls)
{
if (NULL != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
}
/**
* Main function run with scheduler.
*/
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
//Lets create the socket
lsock4 = bind_v4 ();
if (NULL == lsock4)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
"bind");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Service listens on port %u\n",
(unsigned int) port);
rh = GNUNET_NAT_stun_make_request (stun_server,
stun_port,
lsock4,
&request_callback, NULL);
GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&stop, NULL);
}
static void
do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_TIME_Relative del;
char *fancy;
GNUNET_SCHEDULER_shutdown ();
if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
{
del = GNUNET_TIME_absolute_get_duration (start_time);
if (del.rel_value_us == 0)
del.rel_value_us = 1;
fancy =
GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
1000000LL / del.rel_value_us);
FPRINTF (stdout, "Download speed was %s/s\n", fancy);
GNUNET_free (fancy);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n",
(unsigned long long) FILESIZE);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during download, shutting down with error\n");
ok = 1;
}
}
static void shutdown_task (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_GNS_disconnect(gns_handle);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer!\n");
GNUNET_SCHEDULER_shutdown ();
}
static void
do_wait (void *cls,
const struct GNUNET_FS_Uri *uri,
const char *fn)
{
struct DownloadContext *dc;
if (NULL == uri)
{
GNUNET_SCHEDULER_shutdown ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during upload attempt, shutting down with error\n");
ok = 1;
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Waiting to allow content to migrate\n");
dc = GNUNET_new (struct DownloadContext);
dc->uri = GNUNET_FS_uri_dup (uri);
if (NULL != fn)
dc->fn = GNUNET_strdup (fn);
(void) GNUNET_SCHEDULER_add_delayed (MIGRATION_DELAY,
&stop_source_peer,
dc);
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
}
static void
do_stop (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *fn = cls;
if (0 ==
GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
TIMEOUT)).rel_value_us)
{
GNUNET_break (0);
ret = 1;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Finished download, shutting down\n",
(unsigned long long) FILESIZE);
}
if (NULL != fn)
{
GNUNET_DISK_directory_remove (fn);
GNUNET_free (fn);
}
GNUNET_SCHEDULER_shutdown ();
}
/**
* Function called from #GNUNET_ATS_performance_list_addresses when
* we process a #CMD_LIST_ADDRESSES command.
*
* @param cls the `struct Command` that caused the call
* @param address the address, NULL if ATS service was disconnected
* @param address_active #GNUNET_YES if this address is actively used
* to maintain a connection to a peer;
* #GNUNET_NO if the address is not actively used;
* #GNUNET_SYSERR if this address is no longer available for ATS
* @param bandwidth_out assigned outbound bandwidth for the connection
* @param bandwidth_in assigned inbound bandwidth for the connection
* @param prop performance data for the address
*/
static void
info_cb (void *cls,
const struct GNUNET_HELLO_Address *address,
int address_active,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
const struct GNUNET_ATS_Properties *prop)
{
struct Command *c = cls;
struct CommandListAddresses *cmd = &c->details.list_addresses;
if (NULL == address)
{
cmd->alh = NULL;
/* we are done with the iteration, continue to execute */
if ( (cmd->calls < cmd->min_calls) &&
(cmd->active_calls < cmd->min_active_calls) )
{
GNUNET_SCHEDULER_shutdown ();
return;
}
off++;
run_interpreter ();
return;
}
switch (address_active)
{
case GNUNET_YES:
cmd->active_calls++;
cmd->calls++;
break;
case GNUNET_NO:
cmd->calls++;
break;
case GNUNET_SYSERR:
return;
}
if ( (cmd->calls > cmd->max_calls) &&
(cmd->active_calls < cmd->max_active_calls) )
{
GNUNET_break (0);
GNUNET_ATS_performance_list_addresses_cancel (cmd->alh);
cmd->alh = NULL;
GNUNET_SCHEDULER_shutdown ();
return;
}
}
/**
* Method called to inform about the egos of this peer.
*
* When used with #GNUNET_IDENTITY_connect, this function is
* initially called for all egos and then again whenever a
* ego's name changes or if it is deleted. At the end of
* the initial pass over all egos, the function is once called
* with 'NULL' for @a ego. That does NOT mean that the callback won't
* be invoked in the future or that there was an error.
*
* When used with #GNUNET_IDENTITY_create or #GNUNET_IDENTITY_get,
* this function is only called ONCE, and 'NULL' being passed in
* @a ego does indicate an error (i.e. name is taken or no default
* value is known). If @a ego is non-NULL and if '*ctx'
* is set in those callbacks, the value WILL be passed to a subsequent
* call to the identity callback of #GNUNET_IDENTITY_connect (if
* that one was not NULL).
*
* When an identity is renamed, this function is called with the
* (known) @a ego but the NEW @a name.
*
* When an identity is deleted, this function is called with the
* (known) ego and "NULL" for the @a name. In this case,
* the @a ego is henceforth invalid (and the @a ctx should also be
* cleaned up).
*
* @param cls closure
* @param ego ego handle
* @param ctx context for application to store data for this ego
* (during the lifetime of this process, initially NULL)
* @param name name assigned by the user for this ego,
* NULL if the user just deleted the ego and it
* must thus no longer be used
*/
static void
identity_cb (void *cls,
struct GNUNET_IDENTITY_Ego *ego,
void **ctx,
const char *name)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key;
struct GNUNET_GNSRECORD_Data rd;
char *rd_string;
char *peername;
if (NULL == name)
return;
if (NULL == ego)
{
if (NULL == qe)
{
fprintf (stderr,
"Failed to find master-zone ego\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_IDENTITY_disconnect (identity);
identity = NULL;
return;
}
GNUNET_assert (NULL != name);
if (0 != strcmp (name,
"master-zone"))
{
fprintf (stderr,
"Unexpected name %s\n",
name);
return;
}
zone_key = GNUNET_IDENTITY_ego_get_private_key (ego);
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
peername = GNUNET_strdup (GNUNET_i2s_full (&id));
GNUNET_asprintf (&rd_string,
"6 %s %s",
peername,
"www");
GNUNET_free (peername);
GNUNET_assert (GNUNET_OK ==
GNUNET_GNSRECORD_string_to_value (GNUNET_GNSRECORD_TYPE_VPN,
rd_string,
(void**) &rd.data,
&rd.data_size));
rd.record_type = GNUNET_GNSRECORD_TYPE_VPN;
qe = GNUNET_NAMESTORE_records_store (namestore,
zone_key,
"www",
1, &rd,
&commence_testing,
NULL);
GNUNET_free ((void**)rd.data);
GNUNET_free (rd_string);
}
/**
* Function run on timeout.
*
* @param cls closure
*/
static void
end_test (void *cls)
{
timeout_task = NULL;
fprintf (stderr,
"Timeout!\n");
GNUNET_SCHEDULER_shutdown ();
}
static void
terminate_task_error (void *cls)
{
err_task = NULL;
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
ok = 42;
}
static void
result_cb_set1 (void *cls,
const struct GNUNET_SET_Element *element,
enum GNUNET_SET_Status status)
{
switch (status)
{
case GNUNET_SET_STATUS_ADD_LOCAL:
count_set1++;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"set 1: got element\n");
break;
case GNUNET_SET_STATUS_FAILURE:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"set 1: failure\n");
oh1 = NULL;
ret = 1;
if (NULL != timeout_task)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = NULL;
}
GNUNET_SCHEDULER_shutdown ();
break;
case GNUNET_SET_STATUS_DONE:
oh1 = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"set 1: done\n");
GNUNET_SET_destroy (set1);
set1 = NULL;
if (NULL == set2)
{
if (NULL != timeout_task)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = NULL;
}
GNUNET_SCHEDULER_shutdown ();
}
break;
case GNUNET_SET_STATUS_ADD_REMOTE:
break;
default:
GNUNET_assert (0);
}
}
/**
* Timeout, give up.
*/
static void
timeout_error (void *cls)
{
timeout_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout trying to connect peers, test failed.\n");
GNUNET_SCHEDULER_shutdown ();
}
