/**
* Process a share item tree, moving frequent keywords up and
* copying frequent metadata up.
*
* @param toplevel toplevel directory in the tree, returned by the scanner
*/
void
GNUNET_FS_share_tree_trim (struct GNUNET_FS_ShareTreeItem *toplevel)
{
struct TrimContext tc;
if (toplevel == NULL)
return;
tc.keywordcounter = GNUNET_CONTAINER_multihashmap_create (1024);
tc.metacounter = GNUNET_CONTAINER_multihashmap_create (1024);
share_tree_trim (&tc, toplevel);
GNUNET_CONTAINER_multihashmap_destroy (tc.keywordcounter);
GNUNET_CONTAINER_multihashmap_destroy (tc.metacounter);
}
/**
* Last task run during shutdown. Disconnects us from
* the transport and core.
*
* @param cls unused, NULL
* @param tc scheduler context
*/
static void
cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != peerinfo_notify)
{
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
peerinfo_notify = NULL;
}
GNUNET_TRANSPORT_disconnect (transport);
transport = NULL;
if (handle != NULL)
{
GNUNET_CORE_disconnect (handle);
handle = NULL;
}
whitelist_peers ();
if (GNUNET_SCHEDULER_NO_TASK != add_task)
{
GNUNET_SCHEDULER_cancel (add_task);
add_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_CONTAINER_multihashmap_iterate (peers, &free_peer, NULL);
GNUNET_CONTAINER_multihashmap_destroy (peers);
peers = NULL;
if (stats != NULL)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
}
/**
* Destroy a stream handle.
*
* @param sh stream to process
*/
static void
destroy_stream_handle (struct StreamHandle *sh)
{
struct GSF_StreamRequest *sr;
while (NULL != (sr = sh->pending_head))
{
sr->proc (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY,
GNUNET_TIME_UNIT_FOREVER_ABS,
0, NULL);
GSF_stream_query_cancel (sr);
}
GNUNET_CONTAINER_multihashmap_iterate (sh->waiting_map,
&free_waiting_entry,
sh);
if (NULL != sh->wh)
GNUNET_STREAM_io_write_cancel (sh->wh);
if (NULL != sh->rh)
GNUNET_STREAM_io_read_cancel (sh->rh);
if (GNUNET_SCHEDULER_NO_TASK != sh->timeout_task)
GNUNET_SCHEDULER_cancel (sh->timeout_task);
GNUNET_STREAM_close (sh->stream);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_remove (stream_map,
&sh->target.hashPubKey,
sh));
GNUNET_CONTAINER_multihashmap_destroy (sh->waiting_map);
GNUNET_free (sh);
}
/**
* Kill a #Slave object
*
* @param slave the #Slave object
*/
static void
kill_slave (struct Slave *slave)
{
struct HostRegistration *hr_entry;
while (NULL != (hr_entry = slave->hr_dll_head))
{
GNUNET_CONTAINER_DLL_remove (slave->hr_dll_head, slave->hr_dll_tail,
hr_entry);
GNUNET_free (hr_entry);
}
if (NULL != slave->rhandle)
GNUNET_TESTBED_cancel_registration (slave->rhandle);
GNUNET_assert (GNUNET_SYSERR !=
GNUNET_CONTAINER_multihashmap_iterate (slave->reghost_map,
reghost_free_iterator,
slave));
GNUNET_CONTAINER_multihashmap_destroy (slave->reghost_map);
if (NULL != slave->controller)
GNUNET_TESTBED_controller_disconnect (slave->controller);
if (NULL != slave->controller_proc)
{
LOG_DEBUG ("Stopping a slave\n");
GNUNET_TESTBED_controller_kill_ (slave->controller_proc);
}
}
void
do_shutdown (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
unsigned int ca;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n");
if (NULL != mlp)
{
GAS_mlp_done (mlp);
mlp = NULL;
}
if (NULL != a)
{
for (ca=0; ca < (peers * addresses); ca++)
{
GNUNET_free (a[ca].plugin);
GNUNET_free (a[ca].ats);
}
}
if (NULL != amap)
GNUNET_CONTAINER_multihashmap_destroy(amap);
GNUNET_free_non_null (a);
GNUNET_free_non_null (p);
}
/**
* Disconnect from the PEERSTORE service. Any pending ITERATE and WATCH requests
* will be canceled.
* Any pending STORE requests will depend on @e snyc_first flag.
*
* @param h handle to disconnect
* @param sync_first send any pending STORE requests before disconnecting
*/
void
GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h,
int sync_first)
{
struct GNUNET_PEERSTORE_IterateContext *ic;
struct GNUNET_PEERSTORE_StoreContext *sc;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting.\n");
if (NULL != h->watches)
{
GNUNET_CONTAINER_multihashmap_iterate (h->watches, &destroy_watch, NULL);
GNUNET_CONTAINER_multihashmap_destroy (h->watches);
h->watches = NULL;
}
while (NULL != (ic = h->iterate_head))
{
GNUNET_break (0);
GNUNET_PEERSTORE_iterate_cancel (ic);
}
if (NULL != h->store_head)
{
if (GNUNET_YES == sync_first)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Delaying disconnection due to pending store requests.\n");
h->disconnecting = GNUNET_YES;
return;
}
while (NULL != (sc = h->store_head))
GNUNET_PEERSTORE_store_cancel (sc);
}
do_disconnect (h);
}
/**
* Shutdown database connection and associate data
* structures.
* @param plugin the plugin context (state for this module)
*/
static void
database_shutdown (struct Plugin *plugin)
{
struct GNUNET_DISK_FileHandle *fh;
fh = GNUNET_DISK_file_open (plugin->fn,
GNUNET_DISK_OPEN_CREATE |
GNUNET_DISK_OPEN_TRUNCATE |
GNUNET_DISK_OPEN_READWRITE,
GNUNET_DISK_PERM_USER_WRITE |
GNUNET_DISK_PERM_USER_READ);
if (NULL == fh)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to initialize file: %s.\n"),
plugin->fn);
return;
}
GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
&store_and_free_entries,
fh);
GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
GNUNET_DISK_file_close (fh);
}
/**
* 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;
}
static int
testMap (int i)
{
struct GNUNET_CONTAINER_MultiHashMap *m;
GNUNET_HashCode k1;
GNUNET_HashCode k2;
const char *ret;
int j;
CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i)));
memset (&k1, 0, sizeof (k1));
memset (&k2, 1, sizeof (k2));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k1, NULL));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k2, NULL));
CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k1));
CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k2));
CHECK (0 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
CHECK (0 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
ret = GNUNET_CONTAINER_multihashmap_get (m, &k1);
GNUNET_assert (ret != NULL);
CHECK (0 == strcmp ("v1", ret));
CHECK (GNUNET_NO ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v1",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v3",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
CHECK (2 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
CHECK (0 == GNUNET_CONTAINER_multihashmap_get_multiple (m, &k2, NULL, NULL));
CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
for (j = 0; j < 1024; j++)
CHECK (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (m, &k1, "v2",
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
GNUNET_CONTAINER_multihashmap_destroy (m);
return 0;
}
/**
* Cancel an ongoing regex search in the DHT and free all resources.
*
* @param h the search context.
*/
void
REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h)
{
unsigned int i;
GNUNET_free (h->description);
GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_handles,
®ex_cancel_dht_get, NULL);
GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_results,
®ex_free_result, NULL);
GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_results);
GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_handles);
if (0 < h->n_contexts)
{
for (i = 0; i < h->n_contexts; i++)
GNUNET_free (h->contexts[i]);
GNUNET_free (h->contexts);
}
GNUNET_free (h);
}
/**
* Destroy the whole tree and free all used memory and Peer_Ids
*
* @param t Tree to be destroyed
*/
void
tree_destroy (struct MeshTunnelTree *t)
{
#if MESH_TREE_DEBUG
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "tree: Destroying tree\n");
#endif
tree_node_destroy (t->root);
GNUNET_CONTAINER_multihashmap_iterate (t->first_hops, &iterate_free, NULL);
GNUNET_CONTAINER_multihashmap_destroy (t->first_hops);
GNUNET_free (t);
}
/**
* Task run during shutdown.
*
* @param cls unused
*/
static void
shutdown_task (void *cls)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Shutting down, initiating cleanup.\n");
// FIXME: we have to cut our connections to CADET first!
if (NULL != my_cadet)
{
GNUNET_CADET_disconnect (my_cadet);
my_cadet = NULL;
}
if (NULL != edc)
{
GNUNET_CRYPTO_ecc_dlog_release (edc);
edc = NULL;
}
GNUNET_CONTAINER_multihashmap_destroy (client_sessions);
client_sessions = NULL;
GNUNET_CONTAINER_multihashmap_destroy (cadet_sessions);
cadet_sessions = NULL;
}
/**
* Shutdown routing subsystem.
*/
void
GDS_ROUTING_done ()
{
while (GNUNET_CONTAINER_heap_get_size (recent_heap) > 0)
expire_oldest_entry ();
GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (recent_heap));
GNUNET_CONTAINER_heap_destroy (recent_heap);
recent_heap = NULL;
GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (recent_map));
GNUNET_CONTAINER_multihashmap_destroy (recent_map);
recent_map = NULL;
}
/**
* 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_peer_get_active_addresses_cancel (pic);
pic = NULL;
}
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
th = NULL;
}
if (NULL != handle)
{
GNUNET_TRANSPORT_disconnect(handle);
handle = NULL;
}
if (NULL != peers)
{
GNUNET_CONTAINER_multihashmap_destroy (peers);
peers = NULL;
}
if (benchmark_send)
{
duration = GNUNET_TIME_absolute_get_duration (start_time);
FPRINTF (stdout, _("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
1000 * traffic_sent / (1 + duration.rel_value), 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"),
1000 * traffic_received / (1 + duration.rel_value),
traffic_received,
GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
}
}
/**
* Clean up our state. Called during shutdown.
*
* @param cls unused
* @param tc scheduler task context, unused
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_SERVER_notification_context_destroy (notify_list);
notify_list = NULL;
GNUNET_CONTAINER_multihashmap_iterate (hostmap, &free_host_entry, NULL);
GNUNET_CONTAINER_multihashmap_destroy (hostmap);
if (stats != NULL)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
}
/**
* Shutdown address subsystem.
*/
void
GAS_addresses_done ()
{
GAS_addresses_destroy_all ();
running = GNUNET_NO;
GNUNET_CONTAINER_multihashmap_destroy (addresses);
addresses = NULL;
#if HAVE_LIBGLPK
if (ats_mode == MLP)
{
GAS_mlp_done (mlp);
}
#endif
}
/**
* Exit point from the plugin.
* @param cls our "struct Plugin*"
* @return always NULL
*/
void *
libgnunet_plugin_datastore_heap_done (void *cls)
{
struct GNUNET_DATASTORE_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
&free_value,
plugin);
GNUNET_CONTAINER_multihashmap_destroy (plugin->keyvalue);
GNUNET_CONTAINER_heap_destroy (plugin->by_expiration);
GNUNET_CONTAINER_heap_destroy (plugin->by_replication);
GNUNET_free (plugin);
GNUNET_free (api);
return NULL;
}
/**
* Stop the validation subsystem.
*/
void
GST_validation_stop ()
{
struct CheckHelloValidatedContext *chvc;
GNUNET_CONTAINER_multihashmap_iterate (validation_map,
&cleanup_validation_entry, NULL);
GNUNET_CONTAINER_multihashmap_destroy (validation_map);
validation_map = NULL;
while (NULL != (chvc = chvc_head))
{
GNUNET_CONTAINER_DLL_remove (chvc_head, chvc_tail, chvc);
GNUNET_free (chvc);
}
GNUNET_PEERINFO_notify_cancel (pnc);
}
/**
* Shutdown subsystem for non-anonymous file-sharing.
*/
void
GSF_stream_stop ()
{
struct StreamClient *sc;
while (NULL != (sc = sc_head))
terminate_stream (sc);
if (NULL != listen_socket)
{
GNUNET_STREAM_listen_close (listen_socket);
listen_socket = NULL;
}
GNUNET_CONTAINER_multihashmap_iterate (stream_map,
&release_streams,
NULL);
GNUNET_CONTAINER_multihashmap_destroy (stream_map);
stream_map = NULL;
}
/**
* Shutdown connection with the DHT service.
*
* @param handle handle of the DHT connection to stop
*/
void
GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle)
{
struct PendingMessage *pm;
struct GNUNET_DHT_PutHandle *ph;
GNUNET_assert (NULL != handle);
GNUNET_assert (0 ==
GNUNET_CONTAINER_multihashmap_size (handle->active_requests));
if (NULL != handle->th)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
handle->th = NULL;
}
while (NULL != (pm = handle->pending_head))
{
GNUNET_assert (GNUNET_YES == pm->in_pending_queue);
GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,
pm);
pm->in_pending_queue = GNUNET_NO;
GNUNET_assert (GNUNET_YES == pm->free_on_send);
if (NULL != pm->cont)
pm->cont (pm->cont_cls, NULL);
GNUNET_free (pm);
}
while (NULL != (ph = handle->put_head))
{
GNUNET_break (NULL == ph->pending);
if (NULL != ph->cont)
ph->cont (ph->cont_cls, GNUNET_SYSERR);
GNUNET_DHT_put_cancel (ph);
}
if (NULL != handle->client)
{
GNUNET_CLIENT_disconnect (handle->client);
handle->client = NULL;
}
if (NULL != handle->reconnect_task)
GNUNET_SCHEDULER_cancel (handle->reconnect_task);
GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests);
GNUNET_free (handle);
}
/**
* Function called when we are done with removing UBlocks.
* Disconnect from datastore and notify FS service about
* the unindex event.
*
* @param uc our unindexing context
*/
static void
unindex_finish (struct GNUNET_FS_UnindexContext *uc)
{
char *emsg;
struct UnindexMessage req;
/* generate final progress message */
unindex_progress (uc, uc->file_size, NULL, 0, 0);
GNUNET_FS_tree_encoder_finish (uc->tc, &emsg);
uc->tc = NULL;
GNUNET_DISK_file_close (uc->fh);
uc->fh = NULL;
GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
uc->dsh = NULL;
GNUNET_CONTAINER_multihashmap_destroy (uc->seen_dh);
uc->seen_dh = NULL;
uc->state = UNINDEX_STATE_FS_NOTIFY;
GNUNET_FS_unindex_sync_ (uc);
uc->client = GNUNET_CLIENT_connect ("fs", uc->h->cfg);
if (uc->client == NULL)
{
uc->state = UNINDEX_STATE_ERROR;
uc->emsg =
GNUNET_strdup (_("Failed to connect to FS service for unindexing."));
GNUNET_FS_unindex_sync_ (uc);
signal_unindex_error (uc);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending UNINDEX message to FS service\n");
req.header.size = htons (sizeof (struct UnindexMessage));
req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX);
req.reserved = 0;
req.file_id = uc->file_id;
GNUNET_break (GNUNET_OK ==
GNUNET_CLIENT_transmit_and_get_response (uc->client,
&req.header,
GNUNET_CONSTANTS_SERVICE_TIMEOUT,
GNUNET_YES,
&process_fs_response,
uc));
}
/**
* 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);
}
}
/**
* Shutdown the module.
*/
void
GNUNET_FS_indexing_done ()
{
struct IndexInfo *pos;
while (NULL != (pos = indexed_files_head))
{
GNUNET_CONTAINER_DLL_remove (indexed_files_head,
indexed_files_tail,
pos);
if (pos->fhc != NULL)
GNUNET_CRYPTO_hash_file_cancel (pos->fhc);
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_remove (ifm,
&pos->file_id, pos));
GNUNET_free (pos);
}
GNUNET_CONTAINER_multihashmap_destroy (ifm);
ifm = NULL;
cfg = NULL;
}
/**
* Return all peers currently known to ATS
*
* @param p_it the iterator to call for every peer, callbach with id == NULL
* when done
* @param p_it_cls the closure for the iterator
*/
void
GAS_addresses_iterate_peers (GNUNET_ATS_Peer_Iterator p_it, void *p_it_cls)
{
struct PeerIteratorContext ip_ctx;
unsigned int size;
if (NULL == p_it)
return;
GNUNET_assert (NULL != addresses);
size = GNUNET_CONTAINER_multihashmap_size(addresses);
if (0 != size)
{
ip_ctx.it = p_it;
ip_ctx.it_cls = p_it_cls;
ip_ctx.peers_returned = GNUNET_CONTAINER_multihashmap_create (size, GNUNET_NO);
GNUNET_CONTAINER_multihashmap_iterate (addresses, &peer_it, &ip_ctx);
GNUNET_CONTAINER_multihashmap_destroy (ip_ctx.peers_returned);
}
p_it (p_it_cls, NULL);
}
/**
* Disconnect from identity service
*
* @param h handle to destroy
*/
void
GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h)
{
struct GNUNET_IDENTITY_Operation *op;
GNUNET_assert (NULL != h);
if (h->reconnect_task != NULL)
{
GNUNET_SCHEDULER_cancel (h->reconnect_task);
h->reconnect_task = NULL;
}
if (NULL != h->th)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
h->th = NULL;
}
if (NULL != h->egos)
{
GNUNET_CONTAINER_multihashmap_iterate (h->egos,
&free_ego,
h);
GNUNET_CONTAINER_multihashmap_destroy (h->egos);
h->egos = NULL;
}
while (NULL != (op = h->op_head))
{
GNUNET_break (NULL == op->cont);
GNUNET_CONTAINER_DLL_remove (h->op_head,
h->op_tail,
op);
GNUNET_free (op);
}
if (NULL != h->client)
{
GNUNET_CLIENT_disconnect (h->client);
h->client = NULL;
}
GNUNET_free (h);
}
/**
* 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;
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_multihashmap_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_multihashmap_destroy (handle->peers);
handle->peers = NULL;
GNUNET_break (handle->ready_peer_head == NULL);
GNUNET_free (handle);
}
/**
* Callback called when a client disconnected from the service
*
* @param cls closure for the service
* @param client the client that disconnected
* @param internal_cls should be equal to @a c
*/
static void
client_disconnect_cb (void *cls,
struct GNUNET_SERVICE_Client *client,
void *internal_cls)
{
struct CadetClient *c = internal_cls;
GNUNET_assert (c->client == client);
c->shutting_down = GNUNET_YES;
if (NULL != c->own_channels)
{
GNUNET_CONTAINER_multihashmap32_iterate (c->own_channels,
&own_channel_destroy_iterator,
c);
GNUNET_CONTAINER_multihashmap32_destroy (c->own_channels);
}
if (NULL != c->incoming_channels)
{
GNUNET_CONTAINER_multihashmap32_iterate (c->incoming_channels,
&incoming_channel_destroy_iterator,
c);
GNUNET_CONTAINER_multihashmap32_destroy (c->incoming_channels);
}
if (NULL != c->ports)
{
GNUNET_CONTAINER_multihashmap_iterate (c->ports,
&client_release_ports,
c);
GNUNET_CONTAINER_multihashmap_destroy (c->ports);
}
GNUNET_CONTAINER_DLL_remove (clients_head,
clients_tail,
c);
GNUNET_STATISTICS_update (stats,
"# clients",
-1,
GNUNET_NO);
GNUNET_free (c);
}
/**
* Shutdown client subsystem.
*/
void
GDS_CLIENTS_done ()
{
GNUNET_assert (client_head == NULL);
GNUNET_assert (client_tail == NULL);
if (GNUNET_SCHEDULER_NO_TASK != retry_task)
{
GNUNET_SCHEDULER_cancel (retry_task);
retry_task = GNUNET_SCHEDULER_NO_TASK;
}
if (NULL != retry_heap)
{
GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (retry_heap));
GNUNET_CONTAINER_heap_destroy (retry_heap);
retry_heap = NULL;
}
if (NULL != forward_map)
{
GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (forward_map));
GNUNET_CONTAINER_multihashmap_destroy (forward_map);
forward_map = NULL;
}
}
/**
* Shutdown plan subsystem.
*/
void
GSF_plan_done ()
{
GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (plans));
GNUNET_CONTAINER_multihashmap_destroy (plans);
}
static void
check (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
#if !HAVE_LIBGLPK
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed!");
ret = 1;
return;
#endif
struct ATS_Address addr[10];
struct ATS_PreferedAddress *res[10];
struct MLP_information *mlpi;
struct GAS_MLP_SolutionContext ctx;
stats = GNUNET_STATISTICS_create("ats", cfg);
addresses = GNUNET_CONTAINER_multihashmap_create (10);
mlp = GAS_mlp_init (cfg, NULL, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
mlp->auto_solve = GNUNET_NO;
struct GNUNET_PeerIdentity p[10];
/* Creating peer 1 */
GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &p[0].hashPubKey);
/* Creating peer 1 address 1 */
addr[0].peer.hashPubKey = p[0].hashPubKey;
struct GNUNET_ATS_Information a1_ats[3];
set_ats (&a1_ats[0], GNUNET_ATS_QUALITY_NET_DISTANCE, 1);
set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 0);
set_ats (&a1_ats[2], GNUNET_ATS_ARRAY_TERMINATOR, 0);
create_address (&addr[0], "dummy", 3, &a1_ats[0]);
addr[0].atsp_network_type = GNUNET_ATS_NET_LAN;
GNUNET_CONTAINER_multihashmap_put(addresses, &addr[0].peer.hashPubKey, &addr[0], GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
/* Add peer 1 address 1 */
GAS_mlp_address_update (mlp, addresses, &addr[0]);
mlpi = addr[0].mlp_information;
GNUNET_assert (mlp != NULL);
GNUNET_assert (mlp->addr_in_problem == 1);
/* Update an peer 1 address 1 */
set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 20);
GAS_mlp_address_update (mlp, addresses, &addr[0]);
GNUNET_assert (mlp->addr_in_problem == 1);
/* Update an peer 1 address 1 */
set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 10);
GAS_mlp_address_update (mlp, addresses, &addr[0]);
GNUNET_assert (mlp->addr_in_problem == 1);
/* Update an peer 1 address 1 */
set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 10);
GAS_mlp_address_update (mlp, addresses, &addr[0]);
GNUNET_assert (mlp->addr_in_problem == 1);
/* Update an peer 1 address 1 */
set_ats (&a1_ats[1], GNUNET_ATS_QUALITY_NET_DELAY, 30);
GAS_mlp_address_update (mlp, addresses, &addr[0]);
GNUNET_assert (mlp->addr_in_problem == 1);
GNUNET_assert (GNUNET_OK == GAS_mlp_solve_problem(mlp, &ctx));
GNUNET_assert (GNUNET_OK == ctx.lp_result);
GNUNET_assert (GNUNET_OK == ctx.mlp_result);
res[0] = GAS_mlp_get_preferred_address(mlp, addresses, &p[0]);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Preferred address `%s' outbound bandwidth: %u Bps\n",res[0]->address->plugin, res[0]->bandwidth_out);
GNUNET_free (res[0]);
/* Delete an address */
GNUNET_CONTAINER_multihashmap_remove (addresses, &addr[0].peer.hashPubKey, &addr[0]);
GAS_mlp_address_delete (mlp, addresses, &addr[0]);
GNUNET_assert (mlp->addr_in_problem == 0);
GAS_mlp_done (mlp);
GNUNET_free (addr[0].plugin);
GNUNET_CONTAINER_multihashmap_destroy (addresses);
GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
ret = 0;
return;
}
