/**
* Handler for port close requests.
*
* @param cls Identification of the client.
* @param pmsg The actual message.
*/
static void
handle_port_close (void *cls,
const struct GNUNET_CADET_PortMessage *pmsg)
{
struct CadetClient *c = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Open port %s requested by client %u\n",
GNUNET_h2s (&pmsg->port),
c->id);
if (GNUNET_YES !=
GNUNET_CONTAINER_multihashmap_remove (c->ports,
&pmsg->port,
c))
{
GNUNET_break (0);
GNUNET_SERVICE_client_drop (c->client);
return;
}
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (open_ports,
&pmsg->port,
c));
GNUNET_SERVICE_client_continue (c->client);
}
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;
}
/**
* Destroy the given address.
*
* @param addr address to destroy
* @return GNUNET_YES if bandwidth allocations should be recalcualted
*/
static int
destroy_address (struct ATS_Address *addr)
{
int ret;
ret = GNUNET_NO;
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (addresses,
&addr->peer.hashPubKey,
addr));
#if HAVE_LIBGLPK
if (ats_mode == MLP)
GAS_mlp_address_delete (mlp, addresses, addr);
#endif
if (GNUNET_YES == addr->active)
{
active_addr_count--;
addr->active = GNUNET_NO;
ret = GNUNET_YES;
}
free_address (addr);
return ret;
}
/**
* Set the amount of bandwidth the other peer could currently transmit
* to us (as far as we know) to the given value.
*
* @param peer identity of the peer
* @param bandwidth_in currently available bandwidth from that peer to
* this peer (estimate)
*/
void
GAS_reservations_set_bandwidth (const struct GNUNET_PeerIdentity *peer,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
{
struct GNUNET_BANDWIDTH_Tracker *tracker;
tracker = GNUNET_CONTAINER_multihashmap_get (trackers, &peer->hashPubKey);
if (0 == ntohl (bandwidth_in.value__))
{
if (NULL == tracker)
return;
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (trackers,
&peer->hashPubKey,
tracker));
GNUNET_free (tracker);
return;
}
if (NULL == tracker)
{
tracker = GNUNET_malloc (sizeof (struct GNUNET_BANDWIDTH_Tracker));
GNUNET_BANDWIDTH_tracker_init (tracker, bandwidth_in,
MAX_BANDWIDTH_CARRY_S);
GNUNET_CONTAINER_multihashmap_put (trackers, &peer->hashPubKey, tracker,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
return;
}
GNUNET_BANDWIDTH_tracker_update_quota (tracker, bandwidth_in);
}
/**
* Destroy incoming CADET session state, we are done with it.
*
* @param in the session to free elements from
*/
static void
destroy_cadet_session (struct CadetIncomingSession *in)
{
struct BobServiceSession *s;
if (GNUNET_YES == in->in_destroy)
return;
in->in_destroy = GNUNET_YES;
if (NULL != (s = in->s))
{
in->s = NULL;
destroy_service_session (s);
}
if (GNUNET_YES == in->in_map)
{
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (cadet_sessions,
&in->session_id,
in));
in->in_map = GNUNET_NO;
}
if (NULL != in->cadet_mq)
{
GNUNET_MQ_destroy (in->cadet_mq);
in->cadet_mq = NULL;
}
if (NULL != in->channel)
{
GNUNET_CADET_channel_destroy (in->channel);
in->channel = NULL;
}
GNUNET_free (in);
}
/**
* Delete the given value, removing it from the plugin's data
* structures.
*
* @param plugin the plugin
* @param value value to delete
*/
static void
delete_value (struct Plugin *plugin,
struct Value *value)
{
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (plugin->keyvalue,
&value->key,
value));
GNUNET_assert (value == GNUNET_CONTAINER_heap_remove_node (value->expire_heap));
GNUNET_assert (value == GNUNET_CONTAINER_heap_remove_node (value->replication_heap));
if (0 == value->anonymity)
{
struct ZeroAnonByType *zabt;
for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
if (zabt->type == value->type)
break;
GNUNET_assert (NULL != zabt);
zabt->array[value->zero_anon_offset] = zabt->array[--zabt->array_pos];
zabt->array[value->zero_anon_offset]->zero_anon_offset = value->zero_anon_offset;
if (0 == zabt->array_pos)
{
GNUNET_array_grow (zabt->array,
zabt->array_size,
0);
GNUNET_CONTAINER_DLL_remove (plugin->zero_head,
plugin->zero_tail,
zabt);
GNUNET_free (zabt);
}
}
plugin->size -= value->size;
GNUNET_free (value);
}
/**
* Notify the plan about a request being done; destroy all entries
* associated with this request.
*
* @param pr request that is done
*/
void
GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
{
struct GSF_RequestPlan *rp;
struct GSF_PendingRequestData *prd;
struct GSF_PendingRequestPlanBijection *bi;
prd = GSF_pending_request_get_data_ (pr);
while (NULL != (bi = prd->pr_head))
{
rp = bi->rp;
GNUNET_CONTAINER_MDLL_remove (PR, prd->pr_head, prd->pr_tail, bi);
GNUNET_CONTAINER_MDLL_remove (PE, rp->pe_head, rp->pe_tail, bi);
if (NULL == rp->pe_head)
{
GNUNET_CONTAINER_heap_remove_node (rp->hn);
plan_count--;
GNUNET_break (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (rp->pp->plan_map,
&GSF_pending_request_get_data_
(bi->pr)->query,
rp));
GNUNET_free (rp);
}
GNUNET_free (bi);
}
GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# query plan entries"),
plan_count, GNUNET_NO);
}
/**
* 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);
}
/**
* Iterate over validation entries and free them.
*
* @param cls (unused)
* @param key peer identity (unused)
* @param value a 'struct ValidationEntry' to clean up
* @return GNUNET_YES (continue to iterate)
*/
static int
cleanup_validation_entry (void *cls, const GNUNET_HashCode * key, void *value)
{
struct ValidationEntry *ve = value;
if (NULL != ve->bc)
{
GST_blacklist_test_cancel (ve->bc);
ve->bc = NULL;
}
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_remove (validation_map,
&ve->pid.hashPubKey, ve));
GNUNET_HELLO_address_free (ve->address);
if (GNUNET_SCHEDULER_NO_TASK != ve->timeout_task)
{
GNUNET_SCHEDULER_cancel (ve->timeout_task);
ve->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != ve->revalidation_task)
{
GNUNET_SCHEDULER_cancel (ve->revalidation_task);
ve->revalidation_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_free (ve);
return GNUNET_OK;
}
/**
* Remove client's ports from the global hashmap on disconnect.
*
* @param cls Closure (unused).
* @param key Port.
* @param value the `struct CadetClient` to remove
* @return #GNUNET_OK, keep iterating.
*/
static int
client_release_ports (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct CadetClient *c = value;
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (open_ports,
key,
value));
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (c->ports,
key,
value));
return GNUNET_OK;
}
static int
remove_iterator (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls;
/* if remove fails, there just was a collision with another key */
(void) GNUNET_CONTAINER_multihashmap_remove (hashmap, value, NULL);
return GNUNET_YES;
}
/**
* Stop async DHT-get.
*
* @param get_handle handle to the GET operation to stop
*/
void
GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
{
struct GNUNET_DHT_Handle *handle;
const struct GNUNET_DHT_ClientGetMessage *get_msg;
struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
struct PendingMessage *pending;
handle = get_handle->message->handle;
get_msg =
(const struct GNUNET_DHT_ClientGetMessage *) get_handle->message->msg;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Sending STOP for %s to DHT via %p\n",
GNUNET_h2s (&get_msg->key), handle);
/* generate STOP */
pending =
GNUNET_malloc (sizeof (struct PendingMessage) +
sizeof (struct GNUNET_DHT_ClientGetStopMessage));
stop_msg = (struct GNUNET_DHT_ClientGetStopMessage *) &pending[1];
pending->msg = &stop_msg->header;
pending->handle = handle;
pending->free_on_send = GNUNET_YES;
stop_msg->header.size =
htons (sizeof (struct GNUNET_DHT_ClientGetStopMessage));
stop_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);
stop_msg->reserved = htonl (0);
stop_msg->unique_id = get_msg->unique_id;
stop_msg->key = get_msg->key;
GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
/* remove 'GET' from active status */
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (handle->active_requests,
&get_handle->key,
get_handle));
if (GNUNET_YES == get_handle->message->in_pending_queue)
{
GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,
get_handle->message);
get_handle->message->in_pending_queue = GNUNET_NO;
}
GNUNET_free (get_handle->message);
GNUNET_array_grow (get_handle->seen_results,
get_handle->seen_results_end,
0);
GNUNET_free (get_handle);
process_pending_messages (handle);
}
static int
expire_entries (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct Plugin *plugin = cls;
struct GNUNET_PEERSTORE_Record *entry = value;
if (entry->expiry->abs_value_us < plugin->iter_now.abs_value_us)
{
GNUNET_CONTAINER_multihashmap_remove (plugin->hm, key, value);
plugin->exp_changes++;
}
return GNUNET_YES;
}
/**
* Iterate over routing table and remove entries with value as part of any trail.
*
* @param cls closure
* @param key current public key
* @param value value in the hash map
* @return #GNUNET_YES if we should continue to iterate,
* #GNUNET_NO if not.
*/
static int
remove_matching_trails (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct RoutingTrail *remove_trail = value;
struct GNUNET_PeerIdentity *disconnected_peer = cls;
struct GNUNET_HashCode trail_id = *key;
struct GNUNET_PeerIdentity my_identity;
/* If disconnected_peer is next_hop, then send a trail teardown message through
* prev_hop in direction from destination to source. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&remove_trail->next_hop,
disconnected_peer))
{
my_identity = *GDS_NEIGHBOURS_get_id ();
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
&remove_trail->prev_hop))
{
GDS_NEIGHBOURS_send_trail_teardown (&trail_id,
GDS_ROUTING_DEST_TO_SRC,
&remove_trail->prev_hop);
}
}
/* If disconnected_peer is prev_hop, then send a trail teardown through
* next_hop in direction from Source to Destination. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&remove_trail->prev_hop,
disconnected_peer))
{
my_identity = *GDS_NEIGHBOURS_get_id ();
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
&remove_trail->next_hop))
{
GDS_NEIGHBOURS_send_trail_teardown (&trail_id,
GDS_ROUTING_SRC_TO_DEST,
&remove_trail->next_hop);
}
}
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (routing_table,
&trail_id,
remove_trail));
GNUNET_free (remove_trail);
return GNUNET_YES;
}
/**
* We had a remote connection @a value to port @a port before
* client @a cls opened port @a port. Bind them now.
*
* @param cls the `struct CadetClient`
* @param port the port
* @param value the `struct CadetChannel`
* @return #GNUNET_YES (iterate over all such channels)
*/
static int
bind_loose_channel (void *cls,
const struct GNUNET_HashCode *port,
void *value)
{
struct CadetClient *c = cls;
struct CadetChannel *ch = value;
GCCH_bind (ch,
c);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (loose_channels,
port,
value));
return GNUNET_YES;
}
/**
* Cancel a watch request
*
* @param wc handle to the watch request
*/
void
GNUNET_PEERSTORE_watch_cancel (struct GNUNET_PEERSTORE_WatchContext *wc)
{
struct GNUNET_PEERSTORE_Handle *h = wc->h;
struct GNUNET_MQ_Envelope *ev;
struct StoreKeyHashMessage *hm;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Canceling watch.\n");
ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL);
hm->keyhash = wc->keyhash;
GNUNET_MQ_send (h->mq, ev);
GNUNET_CONTAINER_multihashmap_remove (h->watches,
&wc->keyhash,
wc);
GNUNET_free (wc);
}
/**
* Iterator for freeing hash map entries in a slave's reghost_map
*
* @param cls handle to the slave
* @param key current key code
* @param value value in the hash map
* @return #GNUNET_YES if we should continue to iterate,
* #GNUNET_NO if not.
*/
static int
reghost_free_iterator (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct Slave *slave = cls;
struct RegisteredHostContext *rhc = value;
struct ForwardedOverlayConnectContext *focc;
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (slave->reghost_map, key,
value));
while (NULL != (focc = rhc->focc_dll_head))
GST_cleanup_focc (focc);
GNUNET_free (value);
return GNUNET_YES;
}
static int
delete_entries (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct Plugin *plugin = cls;
struct GNUNET_PEERSTORE_Record *entry = value;
if (0 != strcmp (plugin->iter_key, entry->key))
return GNUNET_YES;
if (0 != memcmp (plugin->iter_peer, entry->peer, sizeof (struct GNUNET_PeerIdentity)))
return GNUNET_YES;
if (0 != strcmp (plugin->iter_sub_system, entry->sub_system))
return GNUNET_YES;
GNUNET_CONTAINER_multihashmap_remove (plugin->hm, key, value);
plugin->deleted_entries++;
return GNUNET_YES;
}
/**
* Iterator called on each entry in a waiting map to
* move it back to the pending list.
*
* @param cls the 'struct StreamHandle'
* @param key the key of the entry in the map (the query)
* @param value the 'struct GSF_StreamRequest' to move to pending
* @return GNUNET_YES (continue to iterate)
*/
static int
move_to_pending (void *cls,
const struct GNUNET_HashCode *key,
void *value)
{
struct StreamHandle *sh = cls;
struct GSF_StreamRequest *sr = value;
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (sh->waiting_map,
key,
value));
GNUNET_CONTAINER_DLL_insert (sh->pending_head,
sh->pending_tail,
sr);
sr->was_transmitted = GNUNET_NO;
return GNUNET_YES;
}
/**
* Remove the oldest entry from the DHT routing table. Must only
* be called if it is known that there is at least one entry
* in the heap and hashmap.
*/
static void
expire_oldest_entry ()
{
struct RecentRequest *recent_req;
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Entries removed from routing table"), 1,
GNUNET_NO);
recent_req = GNUNET_CONTAINER_heap_peek (recent_heap);
GNUNET_assert (recent_req != NULL);
GNUNET_CONTAINER_heap_remove_node (recent_req->heap_node);
GNUNET_CONTAINER_bloomfilter_free (recent_req->reply_bf);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (recent_map,
&recent_req->key,
recent_req));
GNUNET_free (recent_req);
}
/**
* Handle UNINDEX-message.
*
* @param cls closure
* @param client identification of the client
* @param message the actual message
*/
void
GNUNET_FS_handle_unindex (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct UnindexMessage *um;
struct IndexInfo *pos;
struct GNUNET_SERVER_TransmitContext *tc;
int found;
um = (const struct UnindexMessage *) message;
if (0 != um->reserved)
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
found = GNUNET_NO;
for (pos = indexed_files_head; NULL != pos; pos = pos->next)
{
if (0 == memcmp (&pos->file_id, &um->file_id, sizeof (struct GNUNET_HashCode)))
{
GNUNET_CONTAINER_DLL_remove (indexed_files_head,
indexed_files_tail,
pos);
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_remove (ifm, &pos->file_id,
pos));
GNUNET_free (pos);
found = GNUNET_YES;
break;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client requested unindexing of file `%s': %s\n",
GNUNET_h2s (&um->file_id), found ? "found" : "not found");
if (GNUNET_YES == found)
write_index_list ();
tc = GNUNET_SERVER_transmit_context_create (client);
GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_MINUTES);
}
/**
* Iterator over hash map entries that frees all entries
* associated with the given client.
*
* @param cls client to search for in source routes
* @param key current key code (ignored)
* @param value value in the hash map, a ClientQueryRecord
* @return #GNUNET_YES (we should continue to iterate)
*/
static int
remove_client_records (void *cls, const struct GNUNET_HashCode * key, void *value)
{
struct ClientList *client = cls;
struct ClientQueryRecord *record = value;
if (record->client != client)
return GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Removing client %p's record for key %s\n", client,
GNUNET_h2s (key));
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (forward_map, key,
record));
if (NULL != record->hnode)
GNUNET_CONTAINER_heap_remove_node (record->hnode);
GNUNET_array_grow (record->seen_replies, record->seen_replies_count, 0);
GNUNET_free (record);
return GNUNET_YES;
}
/**
* Move "frequent" keywords over to the target ksk uri, free the
* counters.
*
* @param cls the 'struct TrimContext'
* @param key key of the entry
* @param value the 'struct KeywordCounter'
* @return GNUNET_YES (always)
*/
static int
migrate_and_drop_keywords (void *cls, const GNUNET_HashCode * key, void *value)
{
struct TrimContext *tc = cls;
struct KeywordCounter *counter = value;
if (counter->count >= tc->move_threshold)
{
if (NULL == tc->pos->ksk_uri)
tc->pos->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &counter->value);
else
GNUNET_FS_uri_ksk_add_keyword (tc->pos->ksk_uri, counter->value, GNUNET_NO);
}
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (tc->keywordcounter,
key,
counter));
GNUNET_free (counter);
return GNUNET_YES;
}
/**
* Cancel an active request; must not be called after 'proc'
* was calld.
*
* @param sr request to cancel
*/
void
GSF_stream_query_cancel (struct GSF_StreamRequest *sr)
{
struct StreamHandle *sh = sr->sh;
if (GNUNET_YES == sr->was_transmitted)
GNUNET_CONTAINER_multihashmap_remove (sh->waiting_map,
&sr->query,
sr);
else
GNUNET_CONTAINER_DLL_remove (sh->pending_head,
sh->pending_tail,
sr);
GNUNET_free (sr);
if ( (0 == GNUNET_CONTAINER_multihashmap_size (sh->waiting_map)) &&
(NULL == sh->pending_head) )
sh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&stream_timeout,
sh);
}
/**
* Remove trail with trail_id
* @param trail_id Trail id to be removed
* @return #GNUNET_YES success
* #GNUNET_NO if entry not found.
*/
int
GDS_ROUTING_remove_trail (const struct GNUNET_HashCode *remove_trail_id)
{
struct RoutingTrail *remove_entry;
remove_entry = GNUNET_CONTAINER_multihashmap_get (routing_table,
remove_trail_id);
if (NULL == remove_entry)
return GNUNET_NO;
if (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (routing_table,
remove_trail_id,
remove_entry))
{
GNUNET_free (remove_entry);
return GNUNET_YES;
}
return GNUNET_NO;
}
/**
* 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;
}
/**
* Notify clients about disconnect and free
* the entry for connected peer.
*
* @param cls the 'struct GNUNET_CORE_Handle*'
* @param key the peer identity (not used)
* @param value the 'struct PeerRecord' to free.
* @return GNUNET_YES (continue)
*/
static int
disconnect_and_free_peer_entry (void *cls, const struct GNUNET_HashCode * key,
void *value)
{
struct GNUNET_CORE_Handle *h = cls;
struct GNUNET_CORE_TransmitHandle *th;
struct PeerRecord *pr = value;
if (GNUNET_SCHEDULER_NO_TASK != pr->timeout_task)
{
GNUNET_SCHEDULER_cancel (pr->timeout_task);
pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
{
GNUNET_SCHEDULER_cancel (pr->ntr_task);
pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
}
if ((NULL != pr->prev) || (NULL != pr->next) || (h->ready_peer_head == pr))
GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
if (NULL != h->disconnects)
h->disconnects (h->cls, &pr->peer);
/* all requests should have been cancelled, clean up anyway, just in case */
th = &pr->th;
if (NULL != th->peer)
{
GNUNET_break (0);
th->peer = NULL;
if (NULL != th->cm)
th->cm->th = NULL;
}
/* done with 'voluntary' cleanups, now on to normal freeing */
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (h->peers, key, pr));
GNUNET_assert (pr->ch == h);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->timeout_task);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->ntr_task);
GNUNET_free (pr);
return GNUNET_YES;
}
/**
* Free all resources associated with the given peer.
*
* @param cls closure (not used)
* @param pid identity of the peer
* @param value peer to free
* @return GNUNET_YES (always: continue to iterate)
*/
static int
free_peer (void *cls, const struct GNUNET_HashCode * pid, void *value)
{
struct Peer *pos = value;
GNUNET_break (GNUNET_NO == pos->is_connected);
GNUNET_break (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_remove (peers, pid, pos));
if (pos->hello_req != NULL)
GNUNET_CORE_notify_transmit_ready_cancel (pos->hello_req);
if (pos->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (pos->hello_delay_task);
if (pos->attempt_connect_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (pos->attempt_connect_task);
if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (pos->greylist_clean_task);
GNUNET_free_non_null (pos->hello);
if (pos->filter != NULL)
GNUNET_CONTAINER_bloomfilter_free (pos->filter);
GNUNET_free (pos);
return GNUNET_YES;
}
/**
* Copy "frequent" metadata items over to the
* target metadata container, free the counters.
*
* @param cls the 'struct TrimContext'
* @param key key of the entry
* @param value the 'struct KeywordCounter'
* @return GNUNET_YES (always)
*/
static int
migrate_and_drop_metadata (void *cls, const GNUNET_HashCode * key, void *value)
{
struct TrimContext *tc = cls;
struct MetaCounter *counter = value;
if (counter->count >= tc->move_threshold)
{
if (NULL == tc->pos->meta)
tc->pos->meta = GNUNET_CONTAINER_meta_data_create ();
GNUNET_CONTAINER_meta_data_insert (tc->pos->meta,
counter->plugin_name,
counter->type,
counter->format,
counter->data_mime_type, counter->data,
counter->data_size);
}
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (tc->metacounter,
key,
counter));
GNUNET_free (counter);
return GNUNET_YES;
}
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;
}