/*
This file is part of GNUnet.
- (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
+ (C) 2009-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* - test test test
*/
#include "platform.h"
+#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
-#include "gnunet_bandwidth_lib.h"
-#include "gnunet_client_lib.h"
-#include "gnunet_constants.h"
-#include "gnunet_container_lib.h"
#include "gnunet_arm_service.h"
#include "gnunet_hello_lib.h"
#include "gnunet_protocols.h"
-#include "gnunet_server_lib.h"
-#include "gnunet_time_lib.h"
#include "gnunet_transport_service.h"
#include "transport.h"
* Hash map of the current connected neighbours of this peer.
* Maps peer identities to 'struct Neighbour' entries.
*/
- struct GNUNET_CONTAINER_MultiHashMap *neighbours;
+ struct GNUNET_CONTAINER_MultiPeerMap *neighbours;
/**
* Heap sorting peers with pending messages by the timestamps that
neighbour_find (struct GNUNET_TRANSPORT_Handle *h,
const struct GNUNET_PeerIdentity *peer)
{
- return GNUNET_CONTAINER_multihashmap_get (h->neighbours, &peer->hashPubKey);
+ return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
}
GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
MAX_BANDWIDTH_CARRY_S);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap_put (h->neighbours,
- &n->id.hashPubKey, n,
+ GNUNET_CONTAINER_multipeermap_put (h->neighbours,
+ &n->id, n,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
return n;
}
* GNUNET_NO if not.
*/
static int
-neighbour_delete (void *cls, const struct GNUNET_HashCode * key, void *value)
+neighbour_delete (void *cls,
+ const struct GNUNET_PeerIdentity *key, void *value)
{
struct GNUNET_TRANSPORT_Handle *handle = cls;
struct Neighbour *n = value;
GNUNET_assert (NULL == n->th);
GNUNET_assert (NULL == n->hn);
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_remove (handle->neighbours, key,
+ GNUNET_CONTAINER_multipeermap_remove (handle->neighbours, key,
n));
GNUNET_free (n);
return GNUNET_YES;
"CONNECT", GNUNET_i2s (&cim->id), ntohl (cim->quota_out.value__));
GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, cim->quota_out);
if (h->nc_cb != NULL)
- h->nc_cb (h->cls, &n->id, NULL, 0);
+ h->nc_cb (h->cls, &n->id);
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT:
if (size != sizeof (struct DisconnectInfoMessage))
GNUNET_break (0);
break;
}
- neighbour_delete (h, &dim->peer.hashPubKey, n);
+ neighbour_delete (h, &dim->peer, n);
break;
case GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK:
if (size != sizeof (struct SendOkMessage))
if (th->notify_size + sizeof (struct OutboundMessage) > size)
break; /* does not fit */
if (GNUNET_BANDWIDTH_tracker_get_delay
- (&n->out_tracker, th->notify_size).rel_value > 0)
+ (&n->out_tracker, th->notify_size).rel_value_us > 0)
break; /* too early */
GNUNET_assert (n == GNUNET_CONTAINER_heap_remove_root (h->ready_heap));
n->hn = NULL;
GNUNET_assert (NULL != h->client);
/* destroy all requests that have timed out */
while ((NULL != (n = GNUNET_CONTAINER_heap_peek (h->ready_heap))) &&
- (GNUNET_TIME_absolute_get_remaining (n->th->timeout).rel_value == 0))
+ (0 == GNUNET_TIME_absolute_get_remaining (n->th->timeout).rel_value_us))
{
/* notify client that the request could not be satisfied within
* the given time constraints */
else
return; /* no work to be done */
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Scheduling next transmission to service in %llu ms\n",
- (unsigned long long) delay.rel_value);
+ "Scheduling next transmission to service in %s\n",
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
h->quota_task =
GNUNET_SCHEDULER_add_delayed (delay, &schedule_transmission_task, h);
}
h->client = NULL;
}
/* Forget about all neighbours that we used to be connected to */
- GNUNET_CONTAINER_multihashmap_iterate (h->neighbours, &neighbour_delete, h);
+ GNUNET_CONTAINER_multipeermap_iterate (h->neighbours, &neighbour_delete, h);
if (h->quota_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (h->quota_task);
GNUNET_free (th);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Scheduling task to reconnect to transport service in %llu ms.\n",
- h->reconnect_delay.rel_value);
+ "Scheduling task to reconnect to transport service in %s.\n",
+ GNUNET_STRINGS_relative_time_to_string(h->reconnect_delay, GNUNET_YES));
h->reconnect_task =
GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
if (NULL != tch->cb)
tch->cb (tch->cb_cls, GNUNET_SYSERR);
GNUNET_CONTAINER_DLL_remove (tch->th->tc_head, tch->th->tc_tail, tch);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Discarding `%s' request to `%4s' due to error in transport service connection.\n", "REQUEST_CONNECT",
+ GNUNET_i2s (&tch->pid));
GNUNET_free (tch);
return 0;
}
int
GNUNET_TRANSPORT_check_neighbour_connected (struct GNUNET_TRANSPORT_Handle *handle,
- const struct GNUNET_PeerIdentity *peer)
+ const struct GNUNET_PeerIdentity *peer)
{
- GNUNET_assert (NULL != handle);
- GNUNET_assert (NULL != peer);
+ GNUNET_assert (NULL != handle);
+ GNUNET_assert (NULL != peer);
- if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(handle->neighbours, &peer->hashPubKey))
- return GNUNET_YES;
- else
- return GNUNET_NO;
+ if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (handle->neighbours, peer))
+ return GNUNET_YES;
+ else
+ return GNUNET_NO;
}
GNUNET_assert (NULL != ghh->handle->my_hello);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != ghh->notify_task);
ghh->notify_task = GNUNET_SCHEDULER_NO_TASK;
- ghh->rec (ghh->rec_cls,
+ ghh->rec (ghh->rec_cls,
(const struct GNUNET_MessageHeader *) ghh->handle->my_hello);
}
ret->nd_cb = nd;
ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
ret->neighbours =
- GNUNET_CONTAINER_multihashmap_create (STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
+ GNUNET_CONTAINER_multipeermap_create (STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
ret->ready_heap =
GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
GNUNET_SCHEDULER_cancel (handle->reconnect_task);
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_CONTAINER_multihashmap_destroy (handle->neighbours);
+ GNUNET_CONTAINER_multipeermap_destroy (handle->neighbours);
handle->neighbours = NULL;
if (handle->quota_task != GNUNET_SCHEDULER_NO_TASK)
{
/* calculate when our transmission should be ready */
delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, size + n->traffic_overhead);
n->traffic_overhead = 0;
- if (delay.rel_value > timeout.rel_value)
- delay.rel_value = 0; /* notify immediately (with failure) */
+ if (delay.rel_value_us > timeout.rel_value_us)
+ delay.rel_value_us = 0; /* notify immediately (with failure) */
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Bandwidth tracker allows next transmission to peer %s in %llu ms\n",
- GNUNET_i2s (target), (unsigned long long) delay.rel_value);
- n->hn = GNUNET_CONTAINER_heap_insert (handle->ready_heap, n, delay.rel_value);
+ "Bandwidth tracker allows next transmission to peer %s in %s\n",
+ GNUNET_i2s (target),
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
+ n->hn = GNUNET_CONTAINER_heap_insert (handle->ready_heap, n, delay.rel_value_us);
schedule_transmission (handle);
return th;
}
projects / oweals / gnunet.git / blobdiff