* @author Matthias Wachs
*/
#include "platform.h"
-#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
#include "gnunet_core_service.h"
-#include "gnunet_util_lib.h"
#include "gnunet_transport_service.h"
#include "gnunet_statistics_service.h"
static int stat_check_running;
-static struct GNUNET_CONTAINER_MultiHashMap *peers;
+static struct GNUNET_CONTAINER_MultiPeerMap *peers;
struct PeerContainer
{
static struct TransportPlugin *ptail;
-static int
+static int
map_check_it (void *cls,
- const struct GNUNET_HashCode * key,
+ const struct GNUNET_PeerIdentity * key,
void *value)
{
int *fail = cls;
}
-static int
+static int
map_cleanup_it (void *cls,
- const struct GNUNET_HashCode * key,
+ const struct GNUNET_PeerIdentity * key,
void *value)
{
struct PeerContainer *pc = value;
- GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove(peers, key, value));
+ GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove(peers, key, value));
if (NULL != pc->th_ping)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel(pc->th_ping);
static void
map_cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_CONTAINER_multihashmap_iterate (peers, &map_cleanup_it, NULL);
- GNUNET_CONTAINER_multihashmap_destroy(peers);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &map_cleanup_it, NULL);
+ GNUNET_CONTAINER_multipeermap_destroy(peers);
}
static void
{
int fail = 0;
check_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_CONTAINER_multihashmap_iterate (peers, &map_check_it, &fail);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &map_check_it, &fail);
if (0 > fail)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Inconsistent peers after connection consistency check: %u\n", fail);
char line[1024];
int count = -1;
- switch (protocol)
+ switch (protocol)
{
case tcp:
#ifdef MINGW
return cur;
}
-static int
+static int
stats_check_cb (void *cls, const char *subsystem,
const char *name, uint64_t value,
int is_persistent)
GNUNET_NETWORK_STRUCT_END
-static size_t
+static size_t
send_transport_ping_cb (void *cls, size_t size, void *buf)
{
struct PeerContainer * pc = cls;
struct PING ping;
size_t mlen = sizeof (struct PING);
-
+
if (size < mlen)
{
GNUNET_break (0);
return 0;
}
-
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending transport ping to `%s'\n", GNUNET_i2s (&pc->id));
ping.header.size = htons (mlen);
ping.header.type = htons (1234);
ping.src = htons (0);
-
+
pc->th_ping = NULL;
-
+
memcpy (buf, &ping, mlen);
return mlen;
}
-static size_t
+static size_t
send_core_ping_cb (void *cls, size_t size, void *buf)
{
struct PeerContainer * pc = cls;
GNUNET_break (0);
return 0;
}
-
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending core ping to `%s'\n", GNUNET_i2s (&pc->id));
ping.header.size = htons (mlen);
ping.header.type = htons (1234);
ping.src = htons (1);
-
+
pc->ch_ping = NULL;
-
+
memcpy (buf, &ping, mlen);
return mlen;
}
-static int
+static int
map_ping_it (void *cls,
- const struct GNUNET_HashCode * key,
+ const struct GNUNET_PeerIdentity * key,
void *value)
{
struct PeerContainer *pc = value;
statistics_task = GNUNET_SCHEDULER_add_delayed(STATS_DELAY, &stats_check, NULL);
}
- GNUNET_CONTAINER_multihashmap_iterate (peers, &map_ping_it, NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &map_ping_it, NULL);
stat_check_running = GNUNET_YES;
}
-static size_t
+static size_t
send_transport_pong_cb (void *cls, size_t size, void *buf)
{
struct PeerContainer * pc = cls;
}
-static size_t
+static size_t
send_core_pong_cb (void *cls, size_t size, void *buf)
{
struct PeerContainer * pc = cls;
struct PING ping;
size_t mlen = sizeof (struct PING);
-
+
if (size < mlen)
{
GNUNET_break (0);
return 0;
}
-
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending core pong to `%s'\n", GNUNET_i2s (&pc->id));
ping.header.size = htons (mlen);
ping.header.type = htons (4321);
ping.src = htons (1);
-
+
pc->ch_pong = NULL;
-
+
memcpy (buf, &ping, mlen);
return mlen;
}
map_connect (const struct GNUNET_PeerIdentity *peer, void * source)
{
struct PeerContainer * pc;
- if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(peers, &peer->hashPubKey))
+ if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(peers, peer))
{
pc = GNUNET_malloc (sizeof (struct PeerContainer));
pc->id = *peer;
pc->core_connected = GNUNET_NO;
pc->transport_connected = GNUNET_NO;
- GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(peers, &peer->hashPubKey, pc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put(peers, peer, pc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
}
- pc = GNUNET_CONTAINER_multihashmap_get(peers, &peer->hashPubKey);
+ pc = GNUNET_CONTAINER_multipeermap_get(peers, peer);
GNUNET_assert (NULL != pc);
if (source == th)
{
struct PeerContainer * pc;
- if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(peers, &peer->hashPubKey))
+ if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains(peers, peer))
{
if (source == th)
{
}
}
- pc = GNUNET_CONTAINER_multihashmap_get(peers, &peer->hashPubKey);
+ pc = GNUNET_CONTAINER_multipeermap_get(peers, peer);
GNUNET_assert (NULL != pc);
if (source == th)
if ((GNUNET_NO == pc->core_connected) && (GNUNET_NO == pc->transport_connected))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing peer `%s'\n", GNUNET_i2s (&pc->id));
- GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (peers, &peer->hashPubKey, pc));
+ GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (peers, peer, pc));
GNUNET_free (pc);
if (NULL != ch)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Disconnecting from core service\n");
GNUNET_CORE_disconnect (ch);
ch = NULL;
const struct GNUNET_PeerIdentity *peer)
{
GNUNET_assert (transport_connections > 0);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"TRANSPORT disconnect for peer `%s' (%u total)\n",
- GNUNET_i2s (peer),
+ GNUNET_i2s (peer),
transport_connections);
map_disconnect (peer, th);
transport_connections --;
{
struct PeerContainer *pc;
- pc = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
+ pc = GNUNET_CONTAINER_multipeermap_get (peers, peer);
if (NULL == pc)
{
GNUNET_break (0);
if ((message->size == ntohs (sizeof (struct PING))) &&
(message->type == ntohs (1234)))
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Received %s %s from peer `%s'\n",
"TRANSPORT",
"PING",
}
}
-static int
+static int
core_notify_receive_cb (void *cls,
const struct GNUNET_PeerIdentity * peer,
const struct GNUNET_MessageHeader * message)
{
struct PeerContainer *pc = NULL;
- pc = GNUNET_CONTAINER_multihashmap_get(peers, &peer->hashPubKey);
+ pc = GNUNET_CONTAINER_multipeermap_get(peers, peer);
if (NULL == pc)
{
static void
-core_init_cb (void *cls,
+core_init_cb (void *cls,
const struct GNUNET_PeerIdentity *my_identity)
{
my_peer_id = *my_identity;
init();
stats = GNUNET_STATISTICS_create ("watchdog", cfg);
- peers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+ peers = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_NO);
th = GNUNET_TRANSPORT_connect(cfg, NULL, NULL,
&transport_notify_receive_cb,