/**
* Task run to terminate the testcase.
*
* @param cls NULL
* @param tc unused
*/
static void
end (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (0 != ret)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Test failed at stage %u %s\n",
off,
(NULL != test_commands[off].label)
? test_commands[off].label
: "");
if (NULL != interpreter_task)
{
GNUNET_SCHEDULER_cancel (interpreter_task);
interpreter_task = NULL;
}
if (NULL != sched_ats)
{
GNUNET_ATS_scheduling_done (sched_ats);
sched_ats = NULL;
}
if (NULL != con_ats)
{
GNUNET_ATS_connectivity_done (con_ats);
con_ats = NULL;
}
if (NULL != perf_ats)
{
GNUNET_ATS_performance_done (perf_ats);
perf_ats = NULL;
}
if (NULL != p2asd)
{
GNUNET_CONTAINER_multipeermap_iterate (p2asd,
&free_asd,
NULL);
GNUNET_CONTAINER_multipeermap_destroy (p2asd);
p2asd = NULL;
}
if (NULL != p2aid)
{
GNUNET_CONTAINER_multipeermap_iterate (p2aid,
&free_aid,
NULL);
GNUNET_CONTAINER_multipeermap_destroy (p2aid);
p2aid = NULL;
}
}
/**
* Change length of view
*
* If size is decreased, peers with higher indices are removed.
*
* @param len the (maximum) length for the view
*/
void
View_change_len (uint32_t len)
{
uint32_t i;
uint32_t *index;
if (GNUNET_CONTAINER_multipeermap_size (mpm) < len)
{ /* Simply shrink */
/* We might simply clear and free the left over space */
GNUNET_array_grow (array, length, len);
}
else /* We have to remove elements */
{
/* TODO find a way to preserve indices */
for (i = 0; i < len; i++)
{
index = GNUNET_CONTAINER_multipeermap_get (mpm, &array[i]);
GNUNET_assert (NULL != index);
GNUNET_free (index);
}
GNUNET_array_grow (array, length, len);
GNUNET_CONTAINER_multipeermap_destroy (mpm);
mpm = GNUNET_CONTAINER_multipeermap_create (len, GNUNET_NO);
for (i = 0; i < len; i++)
{
index = GNUNET_new (uint32_t);
*index = i;
GNUNET_CONTAINER_multipeermap_put (mpm, &array[i], index,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
}
}
GNUNET_assert (length == len);
}
/**
* @brief Delete storage of peers that was created with #Peers_initialise ()
*/
void
Peers_terminate ()
{
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multipeermap_iterate (peer_map,
peermap_clear_iterator,
NULL))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"Iteration destroying peers was aborted.\n");
}
GNUNET_CONTAINER_multipeermap_destroy (peer_map);
store_valid_peers ();
GNUNET_free (filename_valid_peers);
GNUNET_CONTAINER_multipeermap_destroy (valid_peers);
}
/**
* Disconnect from DV service.
*
* @param sh service handle
*/
void
GNUNET_DV_service_disconnect (struct GNUNET_DV_ServiceHandle *sh)
{
struct GNUNET_DV_TransmitHandle *pos;
if (NULL == sh)
return;
if (NULL != sh->th)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (sh->th);
sh->th = NULL;
}
while (NULL != (pos = sh->th_head))
{
GNUNET_CONTAINER_DLL_remove (sh->th_head,
sh->th_tail,
pos);
GNUNET_free (pos);
}
if (NULL != sh->client)
{
GNUNET_CLIENT_disconnect (sh->client);
sh->client = NULL;
}
GNUNET_CONTAINER_multipeermap_iterate (sh->peers,
&cleanup_send_cb,
sh);
GNUNET_CONTAINER_multipeermap_destroy (sh->peers);
GNUNET_free (sh);
}
/**
* Release precalculated values.
*
* @param edc dlog context
*/
void
GNUNET_CRYPTO_ecc_dlog_release (struct GNUNET_CRYPTO_EccDlogContext *edc)
{
gcry_ctx_release (edc->ctx);
GNUNET_CONTAINER_multipeermap_destroy (edc->map);
GNUNET_free (edc);
}
/**
* Destroy peermap.
*
* @param c_peer_map the map to destroy
*/
void
View_destroy ()
{
View_clear ();
GNUNET_free (array);
GNUNET_CONTAINER_multipeermap_destroy (mpm);
}
/**
* Task run in monitor mode when the user presses CTRL-C to abort.
* Stops monitoring activity.
*
* @param cls the 'struct GNUNET_TRANSPORT_PeerIterateContext *'
* @param tc scheduler context
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_TIME_Relative duration;
end = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
{
GNUNET_SCHEDULER_cancel (op_timeout);
op_timeout = GNUNET_SCHEDULER_NO_TASK;
}
if (NULL != tc_handle)
{
GNUNET_TRANSPORT_try_connect_cancel (tc_handle);
tc_handle = NULL;
}
if (NULL != pic)
{
GNUNET_TRANSPORT_monitor_peers_cancel (pic);
pic = NULL;
}
if (NULL != vic)
{
GNUNET_TRANSPORT_monitor_validation_entries_cancel (vic);
vic = NULL;
}
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
if (NULL != handle)
{
GNUNET_TRANSPORT_disconnect (handle);
handle = NULL;
}
if (benchmark_send)
{
duration = GNUNET_TIME_absolute_get_duration (start_time);
FPRINTF (stdout, _("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
1000LL * 1000LL * traffic_sent / (1 + duration.rel_value_us),
traffic_sent,
GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
}
if (benchmark_receive)
{
duration = GNUNET_TIME_absolute_get_duration (start_time);
FPRINTF (stdout, _("Received %llu bytes/s (%llu bytes in %s)\n"),
1000LL * 1000LL * traffic_received / (1 + duration.rel_value_us),
traffic_received,
GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
}
if (NULL != monitored_peers)
{
GNUNET_CONTAINER_multipeermap_iterate (monitored_peers, &destroy_it, NULL);
GNUNET_CONTAINER_multipeermap_destroy (monitored_peers);
monitored_peers = NULL;
}
}
/**
* Task run during shutdown.
*
* @param cls unused
*/
static void
shutdown_task (void *cls)
{
if (NULL != flood_task)
{
GNUNET_SCHEDULER_cancel (flood_task);
flood_task = NULL;
}
if (NULL != proof_task)
{
GNUNET_SCHEDULER_cancel (proof_task);
proof_task = NULL;
write_proof (); /* remember progress */
}
if (NULL != nc)
{
GNUNET_notification_context_destroy (nc);
nc = NULL;
}
if (NULL != core_api)
{
GNUNET_CORE_disconnect (core_api);
core_api = NULL;
}
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
if (NULL != peers)
{
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
}
if (NULL != my_private_key)
{
GNUNET_free (my_private_key);
my_private_key = NULL;
}
#if ENABLE_NSE_HISTOGRAM
if (NULL != logger_test)
{
GNUNET_CLIENT_service_test_cancel (logger_test);
logger_test = NULL;
}
if (NULL != lh)
{
GNUNET_TESTBED_LOGGER_flush (lh,
&flush_comp_cb,
NULL);
}
if (NULL != histogram)
{
GNUNET_BIO_write_close (histogram);
histogram = NULL;
}
#endif
}
/**
* This path is no longer needed, free resources.
*
* @param path path resources to free
*/
static void
path_destroy (struct CadetPeerPath *path)
{
GNUNET_assert (0 ==
GNUNET_CONTAINER_multipeermap_size (path->connections));
GNUNET_CONTAINER_multipeermap_destroy (path->connections);
GNUNET_free (path->entries);
GNUNET_free (path);
}
/**
* Shutdown connectivity subsystem.
*/
void
GAS_connectivity_done ()
{
GNUNET_CONTAINER_multipeermap_iterate (connection_requests,
&free_request,
NULL);
GNUNET_CONTAINER_multipeermap_destroy (connection_requests);
connection_requests = NULL;
}
/**
* Shutdown ATS subsystem.
*/
void
GST_ats_done ()
{
GNUNET_CONTAINER_multipeermap_iterate (p2a,
&destroy_ai_cb,
NULL);
publish_p2a_stat_update ();
GNUNET_CONTAINER_multipeermap_destroy (p2a);
p2a = NULL;
}
/**
* Shutdown sessions subsystem.
*/
void
GSC_SESSIONS_done ()
{
if (NULL != sessions)
{
GNUNET_CONTAINER_multipeermap_iterate (sessions,
&free_session_helper, NULL);
GNUNET_CONTAINER_multipeermap_destroy (sessions);
sessions = NULL;
}
}
/**
* Cleaup and destroy the map
*/
static void
cleanup_map ()
{
if (NULL != map)
{
GNUNET_assert (GNUNET_SYSERR != GNUNET_CONTAINER_multipeermap_iterate (map,
&iterator,
NULL));
GNUNET_CONTAINER_multipeermap_destroy (map);
map = NULL;
}
}
/**
* Stop the nodes management
*/
void
GED_nodes_stop ()
{
if (NULL != ch)
{
GNUNET_CORE_disconnect (ch);
ch = NULL;
}
if (NULL != nodes_requested)
{
GNUNET_CONTAINER_multipeermap_iterate (nodes_requested,
&cleanup_node,
nodes_requested);
update_stats (nodes_requested);
GNUNET_CONTAINER_multipeermap_destroy (nodes_requested);
nodes_requested = NULL;
}
if (NULL != nodes_active)
{
GNUNET_CONTAINER_multipeermap_iterate (nodes_active,
&cleanup_node,
nodes_active);
update_stats (nodes_active);
GNUNET_CONTAINER_multipeermap_destroy (nodes_active);
nodes_active = NULL;
}
if (NULL != nodes_inactive)
{
GNUNET_CONTAINER_multipeermap_iterate (nodes_inactive,
&cleanup_node,
nodes_inactive);
update_stats (nodes_inactive);
GNUNET_CONTAINER_multipeermap_destroy (nodes_inactive);
nodes_inactive = NULL;
}
}
/**
* Shutdown neighbours subsystem.
*/
void
GSC_NEIGHBOURS_done ()
{
if (NULL != transport)
{
GNUNET_TRANSPORT_disconnect (transport);
transport = NULL;
}
if (NULL != neighbours)
{
GNUNET_CONTAINER_multipeermap_iterate (neighbours,
&free_neighbour_helper,
NULL);
GNUNET_CONTAINER_multipeermap_destroy (neighbours);
neighbours = NULL;
}
}
/**
* Task run during shutdown.
*
* @param cls unused
*/
static void
shutdown_task (void *cls)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"shutting down\n");
shutting_down = GNUNET_YES;
GCO_shutdown ();
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats,
GNUNET_NO);
stats = NULL;
}
if (NULL != open_ports)
{
GNUNET_CONTAINER_multihashmap_destroy (open_ports);
open_ports = NULL;
}
if (NULL != loose_channels)
{
GNUNET_CONTAINER_multihashmap_destroy (loose_channels);
loose_channels = NULL;
}
/* All channels, connections and CORE must be down before this point. */
GCP_destroy_all_peers ();
if (NULL != peers)
{
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
}
if (NULL != connections)
{
GNUNET_CONTAINER_multishortmap_destroy (connections);
connections = NULL;
}
if (NULL != ats_ch)
{
GNUNET_ATS_connectivity_done (ats_ch);
ats_ch = NULL;
}
GCD_shutdown ();
GCH_shutdown ();
GNUNET_free_non_null (my_private_key);
my_private_key = NULL;
}
/**
* Disconnect from the core service. This function can only
* be called *after* all pending #GNUNET_CORE_notify_transmit_ready()
* requests have been explicitly canceled.
*
* @param handle connection to core to disconnect
*/
void
GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
{
struct ControlMessage *cm;
GNUNET_assert (NULL != handle);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from CORE service\n");
if (NULL != handle->cth)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (handle->cth);
handle->cth = NULL;
}
while (NULL != (cm = handle->control_pending_head))
{
GNUNET_CONTAINER_DLL_remove (handle->control_pending_head,
handle->control_pending_tail, cm);
if (NULL != cm->th)
cm->th->cm = NULL;
if (NULL != cm->cont)
cm->cont (cm->cont_cls, GNUNET_SYSERR);
GNUNET_free (cm);
}
if (NULL != handle->client)
{
GNUNET_CLIENT_disconnect (handle->client);
handle->client = NULL;
}
GNUNET_CONTAINER_multipeermap_iterate (handle->peers,
&disconnect_and_free_peer_entry,
handle);
if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (handle->reconnect_task);
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_CONTAINER_multipeermap_destroy (handle->peers);
handle->peers = NULL;
GNUNET_break (handle->ready_peer_head == NULL);
GNUNET_free (handle);
}
/**
* Shutdown
*
* @param cls NULL
* @param tc task context from scheduler
* @return
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
shutdown_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_ATS_performance_done (ats);
ats = NULL;
if (NULL != stmt_insert)
{
sqlite3_finalize (stmt_insert);
stmt_insert = NULL;
}
GNUNET_break (SQLITE_OK == sqlite3_close (db));
db = NULL;
if (NULL != map)
{
GNUNET_assert (GNUNET_SYSERR !=
GNUNET_CONTAINER_multipeermap_iterate (map, free_iterator, NULL));
GNUNET_CONTAINER_multipeermap_destroy (map);
map = NULL;
}
}
/**
* Initialize neighbours subsystem.
*/
int
GSC_NEIGHBOURS_init ()
{
neighbours = GNUNET_CONTAINER_multipeermap_create (128,
GNUNET_YES);
transport =
GNUNET_TRANSPORT_connect2 (GSC_cfg,
&GSC_my_identity,
NULL,
&handle_transport_receive,
&handle_transport_notify_connect,
&handle_transport_notify_disconnect,
&handle_transport_notify_excess_bw);
if (NULL == transport)
{
GNUNET_CONTAINER_multipeermap_destroy (neighbours);
neighbours = NULL;
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
/**
* Free the provided RegexSearchContext struct.
*
* This function stops the regex search associated with the given
* context and deletes the corresponding PUBLISH message (if it has been
* successfully delivered). Finally, it frees the provided
* RegexSearchContext struct.
*
* @param context pointer to a RegexSearchContext struct
*/
static void
regex_search_context_free (struct RegexSearchContext *context)
{
if (GNUNET_YES == context->message_delivered)
{
char *filepath = context->file_path;
if (GNUNET_SCHEDULER_NO_TASK != context->free_task)
GNUNET_SCHEDULER_cancel (context->free_task);
if (0 != UNLINK (filepath))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"unlink",
filepath);
}
GNUNET_CONTAINER_multipeermap_destroy (context->subscribers);
GNUNET_REGEX_search_cancel (context->regex_search_handle);
GNUNET_free (context->publish_msg);
GNUNET_free (context->file_path);
GNUNET_free (context);
}
/**
* Last task run during shutdown. Disconnects us from
* the transport and core.
*
* @param cls unused, NULL
*/
static void
cleaning_task (void *cls)
{
if (NULL != peerinfo_notify)
{
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
peerinfo_notify = NULL;
}
if (NULL != handle)
{
GNUNET_CORE_disconnect (handle);
handle = NULL;
}
whitelist_peers ();
if (NULL != add_task)
{
GNUNET_SCHEDULER_cancel (add_task);
add_task = NULL;
}
if (NULL != oh)
{
GNUNET_TRANSPORT_offer_hello_cancel (oh);
oh = NULL;
}
GNUNET_CONTAINER_multipeermap_iterate (peers,
&free_peer,
NULL);
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
if (NULL != ats)
{
GNUNET_ATS_connectivity_done (ats);
ats = NULL;
}
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
}
/**
* Shutdown routing subsystem.
*/
void
GDS_ROUTING_done ()
{
GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (routing_table));
GNUNET_CONTAINER_multipeermap_destroy (routing_table);
}
static int
testMap (int i)
{
struct GNUNET_CONTAINER_MultiPeerMap *m;
struct GNUNET_PeerIdentity k1;
struct GNUNET_PeerIdentity k2;
struct GNUNET_CONTAINER_MultiPeerMapIterator *iter;
struct GNUNET_PeerIdentity key_ret;
const char *ret;
int j;
CHECK (NULL != (m = GNUNET_CONTAINER_multipeermap_create (i, GNUNET_NO)));
memset (&k1, 0, sizeof (k1));
memset (&k2, 1, sizeof (k2));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k1));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k2));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove (m, &k1, NULL));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove (m, &k2, NULL));
CHECK (NULL == GNUNET_CONTAINER_multipeermap_get (m, &k1));
CHECK (NULL == GNUNET_CONTAINER_multipeermap_get (m, &k2));
CHECK (0 == GNUNET_CONTAINER_multipeermap_remove_all (m, &k1));
CHECK (0 == GNUNET_CONTAINER_multipeermap_size (m));
CHECK (0 == GNUNET_CONTAINER_multipeermap_iterate (m, NULL, NULL));
CHECK (0 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k1, NULL, NULL));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (m, &k1, "v1",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
CHECK (1 == GNUNET_CONTAINER_multipeermap_size (m));
ret = GNUNET_CONTAINER_multipeermap_get (m, &k1);
GNUNET_assert (ret != NULL);
CHECK (0 == strcmp ("v1", ret));
CHECK (GNUNET_NO ==
GNUNET_CONTAINER_multipeermap_put (m, &k1, "v1",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
CHECK (1 == GNUNET_CONTAINER_multipeermap_size (m));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (m, &k1, "v2",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (m, &k1, "v3",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
CHECK (3 == GNUNET_CONTAINER_multipeermap_size (m));
CHECK (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (m, &k1, "v3"));
CHECK (2 == GNUNET_CONTAINER_multipeermap_size (m));
CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (m, &k1));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k2));
CHECK (2 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k1, NULL, NULL));
CHECK (0 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k2, NULL, NULL));
CHECK (2 == GNUNET_CONTAINER_multipeermap_iterate (m, NULL, NULL));
iter = GNUNET_CONTAINER_multipeermap_iterator_create (m);
CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter, &key_ret, (const void **)&ret));
CHECK (0 == memcmp (&key_ret, &k1, sizeof (key_ret)));
CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter, &key_ret, (const void **)&ret));
CHECK (0 == memcmp (&key_ret, &k1, sizeof (key_ret)));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
GNUNET_free (iter);
CHECK (2 == GNUNET_CONTAINER_multipeermap_remove_all (m, &k1));
for (j = 0; j < 1024; j++)
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (m, &k1, "v2",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
iter = GNUNET_CONTAINER_multipeermap_iterator_create (m);
for (j = 0; j < GNUNET_CONTAINER_multipeermap_size (m); j++)
CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
GNUNET_free (iter);
GNUNET_CONTAINER_multipeermap_destroy (m);
return 0;
}
/**
* Stop server offering our hostlist.
*/
void
GNUNET_HOSTLIST_server_stop ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Hostlist server shutdown\n");
if (NULL != hostlist_task_v6)
{
GNUNET_SCHEDULER_cancel (hostlist_task_v6);
hostlist_task_v6 = NULL;
}
if (NULL != hostlist_task_v4)
{
GNUNET_SCHEDULER_cancel (hostlist_task_v4);
hostlist_task_v4 = NULL;
}
if (NULL != daemon_handle_v4)
{
MHD_stop_daemon (daemon_handle_v4);
daemon_handle_v4 = NULL;
}
if (NULL != daemon_handle_v6)
{
MHD_stop_daemon (daemon_handle_v6);
daemon_handle_v6 = NULL;
}
if (NULL != response)
{
MHD_destroy_response (response);
response = NULL;
}
if (NULL != notify)
{
GNUNET_PEERINFO_notify_cancel (notify);
notify = NULL;
}
if (NULL != builder)
{
if (NULL != builder->pitr)
{
GNUNET_PEERINFO_iterate_cancel (builder->pitr);
builder->pitr = NULL;
}
GNUNET_free_non_null (builder->data);
GNUNET_free (builder);
builder = NULL;
}
if (NULL != peerinfo)
{
GNUNET_PEERINFO_disconnect (peerinfo);
peerinfo = NULL;
}
if (NULL != advertisements)
{
GNUNET_break (0 ==
GNUNET_CONTAINER_multipeermap_size (advertisements));
GNUNET_CONTAINER_multipeermap_destroy (advertisements);
advertisements = NULL;
}
cfg = NULL;
stats = NULL;
core = NULL;
}
