/** * 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; }