/**
* Function scheduled to be run on the successful start of services
* tries to look up the dns record for TEST_DOMAIN
*/
static void
commence_testing (void *cls, int32_t success, const char *emsg)
{
char name[MAX_DNS_NAME_LENGTH];
char* pos;
struct GNUNET_CRYPTO_ShortHashAsciiEncoded hash_str;
GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES);
gns_handle = GNUNET_GNS_connect(cfg);
if (NULL == gns_handle)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to GNS!\n");
}
pos = name;
strcpy(pos, TEST_RECORD_NAME);
pos += strlen(TEST_RECORD_NAME);
strcpy(pos, ".");
pos++;
GNUNET_CRYPTO_short_hash_to_enc(&bob_hash, &hash_str);
strcpy(pos, (char*)&hash_str);
pos += strlen((char*)&hash_str);
strcpy(pos, ".");
pos++;
strcpy(pos, GNUNET_GNS_TLD_ZKEY);
GNUNET_GNS_lookup(gns_handle, name, GNUNET_GNS_RECORD_TYPE_A,
&on_lookup_result, NULL);
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
}
int c;
for (c = 0; c < RECORDS; c++)
GNUNET_free_non_null((void *) s_rd[c].data);
GNUNET_free (s_rd);
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh, GNUNET_YES);
nsh = NULL;
if (NULL != arm)
stop_arm();
}
/**
* Check if the get_handle is being used, if so stop the request. Either
* way, schedule the end_badly_cont function which actually shuts down the
* test.
*/
static void
end_badly (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != nsqe)
{
GNUNET_NAMESTORE_cancel (nsqe);
nsqe = NULL;
}
if (NULL != lr)
{
GNUNET_GNS_cancel_lookup_request (lr);
lr = NULL;
}
if (NULL != gns_handle)
{
GNUNET_GNS_disconnect (gns_handle);
gns_handle = NULL;
}
if (NULL != namestore_handle)
{
GNUNET_NAMESTORE_disconnect (namestore_handle);
namestore_handle = NULL;
}
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
ok = 1;
}
static void
disconnect_ns (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_NAMESTORE_disconnect (cls);
if (cls == nh[0])
nh[0] = NULL;
if (cls == nh[1])
nh[1] = NULL;
if (cls == nh[2])
nh[2] = NULL;
}
/**
* Check if the get_handle is being used, if so stop the request. Either
* way, schedule the end_badly_cont function which actually shuts down the
* test.
*/
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
int c;
if (GNUNET_SCHEDULER_NO_TASK != wait_task)
{
GNUNET_SCHEDULER_cancel (wait_task);
wait_task = GNUNET_SCHEDULER_NO_TASK;
}
for (c = 0; c < 3; c++)
{
if (NULL != nh[c])
{
GNUNET_NAMESTORE_disconnect(nh[c]);
nh[c] = NULL;
}
if (NULL != get_cfg_ops[c])
{
GNUNET_TESTBED_operation_done(get_cfg_ops[c]);
get_cfg_ops[c] = NULL;
}
if (NULL != cfg_handles[c])
{
GNUNET_CONFIGURATION_destroy (cfg_handles[c]);
cfg_handles[c] = NULL;
}
}
if (NULL != topology_op)
{
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
}
if (NULL != lookup_handle)
{
GNUNET_GNS_cancel_lookup_request (lookup_handle);
lookup_handle = NULL;
}
if (NULL != gh)
{
GNUNET_GNS_disconnect(gh);
gh = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Test failed \n");
GNUNET_SCHEDULER_shutdown ();
ok = 1;
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (stopiteration_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (stopiteration_task);
stopiteration_task = GNUNET_SCHEDULER_NO_TASK;
}
if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
}
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (privkey2 != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey2);
privkey2 = NULL;
GNUNET_free (sig_1);
GNUNET_free (sig_2);
GNUNET_free (sig_3);
GNUNET_free (s_name_1);
GNUNET_free (s_name_2);
GNUNET_free (s_name_3);
if (s_rd_1 != NULL)
{
GNUNET_free ((void *)s_rd_1->data);
GNUNET_free (s_rd_1);
}
if (s_rd_2 != NULL)
{
GNUNET_free ((void *)s_rd_2->data);
GNUNET_free (s_rd_2);
}
if (s_rd_3 != NULL)
{
GNUNET_free ((void *)s_rd_3->data);
GNUNET_free (s_rd_3);
}
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
if (returned_records == 1)
res = 0;
else
res = 1;
}
/**
* Function called on result for a GNS lookup
*
* @param cls closure, unused
* @param rd_count number of records
* @param rd the records in reply
*/
static void
on_lookup_result(void *cls, uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct in_addr a;
uint32_t i;
char* addr;
lr = NULL;
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_NAMESTORE_disconnect (namestore_handle);
namestore_handle = NULL;
if (rd_count == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Lookup failed, rp_filtering?\n");
ok = 2;
}
else
{
ok = 1;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
for (i=0; i<rd_count; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
if (rd[i].record_type == GNUNET_GNS_RECORD_A)
{
memcpy (&a, rd[i].data, sizeof(a));
addr = inet_ntoa(a);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
if (0 == strcmp (addr, TEST_IP))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"%s correctly resolved to %s!\n",
TEST_DOMAIN, addr);
ok = 0;
}
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"No resolution!\n");
}
}
}
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
static void
on_lookup_result(void *cls, uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
int i;
uint16_t *srv_data;
char* srv;
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_NAMESTORE_disconnect (namestore_handle);
if (rd_count == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Lookup failed, rp_filtering?\n");
ok = 2;
}
else
{
ok = 1;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
for (i=0; i<rd_count; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
if (rd[i].record_type == GNUNET_GNS_RECORD_SRV)
{
srv_data = (uint16_t*)rd[i].data;
srv = (char*)&srv_data[3];
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Got SRV %s with p=%d,w=%d,port=%d\n",
srv, srv_data, &srv_data[1], &srv_data[2]);
if (0 == strcmp(srv, TEST_EXPECTED_SRV))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"%s correctly resolved to %s!\n", TEST_DOMAIN,
TEST_EXPECTED_SRV);
ok = 0;
}
}
}
}
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
static void
cleanup ()
{
if (NULL != nsh)
{
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
}
if (NULL != privkey)
{
GNUNET_free (privkey);
privkey = NULL;
}
GNUNET_SCHEDULER_shutdown ();
}
static void
on_lookup_result(void *cls, uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
int i;
uint16_t mx_preference;
char* mx;
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_NAMESTORE_disconnect (namestore_handle);
if (rd_count == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Lookup failed, rp_filtering?\n");
ok = 2;
}
else
{
ok = 1;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
for (i=0; i<rd_count; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
if (rd[i].record_type == GNUNET_GNS_RECORD_MX)
{
mx = (char*)rd[i].data+sizeof(uint16_t);
mx_preference = *(uint16_t*)rd[i].data;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Got MX %s with preference %d\n", mx, mx_preference);
if (0 == strcmp(mx, TEST_EXPECTED_MX))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"%s correctly resolved to %s!\n", TEST_DOMAIN,
TEST_EXPECTED_MX);
ok = 0;
}
}
}
}
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
/**
* Function scheduled to be run on the successful start of services
* tries to look up the dns record for TEST_DOMAIN
*/
static void
commence_testing (void *cls, int32_t success, const char *emsg)
{
GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES);
gns_handle = GNUNET_GNS_connect(cfg);
if (NULL == gns_handle)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to GNS!\n");
}
GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_MX,
&on_lookup_result, TEST_DOMAIN);
}
/**
* Re-establish the connection to the service.
*
* @param cls handle to use to re-connect.
* @param tc scheduler context
*/
static void
endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh, GNUNET_YES);
nsh = NULL;
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (NULL != arm)
stop_arm();
res = 1;
}
static void
on_lookup_result (void *cls, uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
const char *name = cls;
uint32_t i;
const char* addr;
struct in_addr a;
GNUNET_NAMESTORE_disconnect (namestore_handle);
namestore_handle = NULL;
if (0 == rd_count)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Lookup failed!\n");
ok = 2;
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
ok = 1;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"name: %s\n",
name);
for (i=0; i<rd_count; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
if (rd[i].record_type != GNUNET_GNS_RECORD_A)
continue;
memcpy (&a, rd[i].data, sizeof (a));
addr = inet_ntoa (a);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"address: %s\n", addr);
if (0 != strcmp (addr, TEST_IP))
continue;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
ok = 0;
}
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
static void
on_lookup_result_cname (void *cls,
uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
uint32_t i;
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_NAMESTORE_disconnect (namestore_handle);
namestore_handle = NULL;
if (rd_count == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Lookup failed, rp_filtering?\n");
ok = 2;
}
else
{
ok = 1;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
for (i=0; i<rd_count; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
if (rd[i].record_type == GNUNET_GNS_RECORD_CNAME)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "CNAME: %s\n", rd[i].data);
if (0 == strcmp(rd[i].data, TEST_RECORD_CNAME_SERVER))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"%s correctly resolved to %s!\n", TEST_DOMAIN_PLUS, rd[i].data);
ok = 0;
}
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
}
}
}
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != zi)
{
GNUNET_NAMESTORE_zone_iteration_stop (zi);
zi = NULL;
}
if (endbadly_task != NULL)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = NULL;
}
if (privkey != NULL)
GNUNET_free (privkey);
privkey = NULL;
if (privkey2 != NULL)
GNUNET_free (privkey2);
privkey2 = NULL;
GNUNET_free (s_name_1);
GNUNET_free (s_name_2);
GNUNET_free (s_name_3);
if (s_rd_1 != NULL)
{
GNUNET_free ((void *)s_rd_1->data);
GNUNET_free (s_rd_1);
}
if (s_rd_2 != NULL)
{
GNUNET_free ((void *)s_rd_2->data);
GNUNET_free (s_rd_2);
}
if (s_rd_3 != NULL)
{
GNUNET_free ((void *)s_rd_3->data);
GNUNET_free (s_rd_3);
}
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
}
/**
* Function run on shutdown.
*
* @param cls closure
*/
static void
do_shutdown (void *cls)
{
if (NULL != timeout_task)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = NULL;
}
if (NULL != op)
{
GNUNET_IDENTITY_cancel (op);
op = NULL;
}
if (NULL != call1)
{
GNUNET_CONVERSATION_call_stop (call1);
call1 = NULL;
}
if (NULL != call2)
{
GNUNET_CONVERSATION_call_stop (call2);
call2 = NULL;
}
if (NULL != phone)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
GNUNET_CONVERSATION_phone_destroy (phone);
phone = NULL;
}
if (NULL != id)
{
GNUNET_IDENTITY_disconnect (id);
id = NULL;
}
if (NULL != qe)
{
GNUNET_NAMESTORE_cancel (qe);
qe = NULL;
}
if (NULL != ns)
{
GNUNET_NAMESTORE_disconnect (ns);
ns = NULL;
}
}
/**
* Check if the get_handle is being used, if so stop the request. Either
* way, schedule the end_badly_cont function which actually shuts down the
* test.
*/
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
if (NULL != gns_handle)
{
GNUNET_GNS_disconnect (gns_handle);
gns_handle = NULL;
}
if (NULL != namestore_handle)
{
GNUNET_NAMESTORE_disconnect (namestore_handle);
namestore_handle = NULL;
}
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
ok = 1;
}
/**
* Re-establish the connection to the service.
*
* @param cls handle to use to re-connect.
* @param tc scheduler context
*/
static void
endbadly (void *cls)
{
if (NULL != zi)
{
GNUNET_NAMESTORE_zone_iteration_stop (zi);
zi = NULL;
}
if (nsh != NULL)
{
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
}
GNUNET_free_non_null(s_name_1);
GNUNET_free_non_null(s_name_2);
GNUNET_free_non_null(s_name_3);
if (s_rd_1 != NULL)
{
GNUNET_free ((void *)s_rd_1->data);
GNUNET_free (s_rd_1);
}
if (s_rd_2 != NULL)
{
GNUNET_free ((void *)s_rd_2->data);
GNUNET_free (s_rd_2);
}
if (s_rd_3 != NULL)
{
GNUNET_free ((void *)s_rd_3->data);
GNUNET_free (s_rd_3);
}
if (privkey != NULL)
GNUNET_free (privkey);
privkey = NULL;
if (privkey2 != NULL)
GNUNET_free (privkey2);
privkey2 = NULL;
res = 1;
}
/**
* Called when gns_get_authority finishes
*/
static void
process_auth_result(void* cls, const char* aname)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Disconnecting from namestore\n");
GNUNET_NAMESTORE_disconnect (namestore_handle);
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
if (aname == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"get_authority test failed!\n");
ok = 1;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"%s authority is %s\n", (char*)cls, aname);
if (0 != strcmp(aname, TEST_EXPECTED_RESULT))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"get_authority test failed! (wanted: %s got: %s\n",
TEST_EXPECTED_RESULT, aname);
ok = 1;
}
else
{
ok = 0;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "get_authority test finished!\n");
}
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
/**
* Cleanup task
*/
static void
cleanup()
{
struct EgoEntry *ego_entry;
struct EgoEntry *ego_tmp;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Cleaning up\n");
if (NULL != timeout_task)
GNUNET_SCHEDULER_cancel (timeout_task);
if (NULL != update_task)
GNUNET_SCHEDULER_cancel (update_task);
if (NULL != identity_handle)
GNUNET_IDENTITY_disconnect (identity_handle);
if (NULL != ns_it)
GNUNET_NAMESTORE_zone_iteration_stop (ns_it);
if (NULL != ns_qe)
GNUNET_NAMESTORE_cancel (ns_qe);
if (NULL != ns_handle)
GNUNET_NAMESTORE_disconnect (ns_handle);
if (NULL != token)
GNUNET_free (token);
if (NULL != label)
GNUNET_free (label);
for (ego_entry = ego_head;
NULL != ego_entry;)
{
ego_tmp = ego_entry;
if (0 != GNUNET_CONTAINER_multihashmap_size (ego_tmp->attr_map))
{
GNUNET_CONTAINER_multihashmap_iterate (ego_tmp->attr_map,
&clear_ego_attrs,
ego_tmp);
}
GNUNET_CONTAINER_multihashmap_destroy (ego_tmp->attr_map);
ego_entry = ego_entry->next;
GNUNET_free (ego_tmp);
}
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
}
if (privkey != NULL)
GNUNET_CRYPTO_rsa_key_free (privkey);
privkey = NULL;
if (nsh != NULL)
GNUNET_NAMESTORE_disconnect (nsh, GNUNET_YES);
nsh = NULL;
if (NULL != arm)
stop_arm();
res = 0;
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Finished\n");
int c;
if (GNUNET_SCHEDULER_NO_TASK != die_task)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
for (c = 0; c < 3; c++)
{
if (NULL != nh[c])
{
GNUNET_NAMESTORE_disconnect(nh[c]);
nh[c] = NULL;
}
if (NULL != cfg_handles[c])
{
GNUNET_CONFIGURATION_destroy (cfg_handles[c]);
cfg_handles[c] = NULL;
}
}
if (NULL != gh)
{
GNUNET_GNS_disconnect(gh);
gh = NULL;
}
if (0 == ok)
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Test ended successful\n");
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Test failed\n");
GNUNET_SCHEDULER_shutdown ();
}
/**
* Signature of the main function of a task.
*
* @param cls closure
* @param tc context information (why was this task triggered now)
*/
static void
end_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_SCHEDULER_shutdown ();
if (NULL != op)
{
GNUNET_IDENTITY_cancel (op);
op = NULL;
}
if (NULL != call)
{
GNUNET_CONVERSATION_call_stop (call);
call = NULL;
}
if (NULL != phone)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
GNUNET_CONVERSATION_phone_destroy (phone);
phone = NULL;
}
if (NULL != id)
{
GNUNET_IDENTITY_disconnect (id);
id = NULL;
}
if (NULL != qe)
{
GNUNET_NAMESTORE_cancel (qe);
qe = NULL;
}
if (NULL != ns)
{
GNUNET_NAMESTORE_disconnect (ns);
ns = NULL;
}
}
static void
do_shutdown ()
{
if (NULL != zm)
{
GNUNET_NAMESTORE_zone_monitor_stop (zm);
zm = NULL;
}
if (NULL != ns_ops[0])
{
GNUNET_NAMESTORE_cancel(ns_ops[0]);
ns_ops[0] = NULL;
}
if (NULL != ns_ops[1])
{
GNUNET_NAMESTORE_cancel(ns_ops[1]);
ns_ops[1] = NULL;
}
if (NULL != ns_ops[2])
{
GNUNET_NAMESTORE_cancel(ns_ops[2]);
ns_ops[2] = NULL;
}
if (NULL != nsh)
{
GNUNET_NAMESTORE_disconnect (nsh);
nsh = NULL;
}
GNUNET_free_non_null(s_name_1);
GNUNET_free_non_null(s_name_2);
GNUNET_free_non_null(s_name_3);
if (s_rd_1 != NULL)
{
GNUNET_free ((void *)s_rd_1->data);
GNUNET_free (s_rd_1);
}
if (s_rd_2 != NULL)
{
GNUNET_free ((void *)s_rd_2->data);
GNUNET_free (s_rd_2);
}
if (s_rd_3 != NULL)
{
GNUNET_free ((void *)s_rd_3->data);
GNUNET_free (s_rd_3);
}
if (NULL != privkey)
{
GNUNET_free (privkey);
privkey = NULL;
}
if (NULL != privkey2)
{
GNUNET_free (privkey2);
privkey2 = NULL;
}
}
/**
* Continue shutdown
*/
static void
on_resolver_cleanup(void)
{
GNUNET_NAMESTORE_disconnect(namestore_handle, 1);
GNUNET_DHT_disconnect(dht_handle);
}
static void
disco_ns (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_NAMESTORE_disconnect (namestore);
}
/**
* Task run on shutdown. Cleans up everything.
*
* @param cls unused
* @param tc scheduler context
*/
static void
do_shutdown (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != get_default)
{
GNUNET_IDENTITY_cancel (get_default);
get_default = NULL;
}
if (NULL != idh)
{
GNUNET_IDENTITY_disconnect (idh);
idh = NULL;
}
if (NULL != el)
{
GNUNET_IDENTITY_ego_lookup_cancel (el);
el = NULL;
}
if (NULL != list_it)
{
GNUNET_NAMESTORE_zone_iteration_stop (list_it);
list_it = NULL;
}
if (NULL != add_qe)
{
GNUNET_NAMESTORE_cancel (add_qe);
add_qe = NULL;
}
if (NULL != add_qe_uri)
{
GNUNET_NAMESTORE_cancel (add_qe_uri);
add_qe_uri = NULL;
}
if (NULL != del_qe)
{
GNUNET_NAMESTORE_cancel (del_qe);
del_qe = NULL;
}
if (NULL != ns)
{
GNUNET_NAMESTORE_disconnect (ns);
ns = NULL;
}
memset (&zone_pkey, 0, sizeof (zone_pkey));
if (NULL != uri)
{
GNUNET_free (uri);
uri = NULL;
}
if (NULL != zm)
{
GNUNET_NAMESTORE_zone_monitor_stop (zm);
zm = NULL;
}
if (NULL != data)
{
GNUNET_free (data);
data = NULL;
}
}
