/*
This file is part of GNUnet.
- (C) 2009, 2010 Christian Grothoff (and other contributing authors)
+ (C) 2009, 2010, 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
* @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_getopt_lib.h"
-#include "gnunet_os_lib.h"
-#include "gnunet_program_lib.h"
-#include "gnunet_scheduler_lib.h"
#include "gnunet_transport_service.h"
#include "gnunet_statistics_service.h"
-#define CHECK_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
-#define STATS_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define CHECK_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+#define STATS_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
#define REPEATED_STATS_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
#define STATS_VALUES 4
* Final status code.
*/
static int ret;
+static int ping;
static int have_tcp;
static int have_udp;
static uint64_t statistics_core_neighbour_entries;
static uint64_t statistics_core_entries_session_map;
-int stat_check_running;
+static int stat_check_running;
-static struct GNUNET_CONTAINER_MultiHashMap *peers;
+static struct GNUNET_CONTAINER_MultiPeerMap *peers;
struct PeerContainer
{
int protocol;
};
-struct TransportPlugin *phead;
-struct TransportPlugin *ptail;
-int map_check_it (void *cls,
- const GNUNET_HashCode * key,
- void *value)
+static struct TransportPlugin *phead;
+static struct TransportPlugin *ptail;
+
+
+static int
+map_check_it (void *cls,
+ const struct GNUNET_PeerIdentity * key,
+ void *value)
{
int *fail = cls;
struct PeerContainer *pc = value;
}
-int map_cleanup_it (void *cls,
- const GNUNET_HashCode * key,
- void *value)
+static int
+map_cleanup_it (void *cls,
+ const struct GNUNET_PeerIdentity * key,
+ void *value)
{
struct PeerContainer *pc = value;
- 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);
static void
stats_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
static int
check_lowlevel_connections (int port, int protocol)
{
+#ifdef MINGW
+ #define DEVNULL "NUL"
+#else
+ #define DEVNULL "/dev/null"
+#endif
+
FILE *f;
char * cmdline;
char * proto;
char line[1024];
int count = -1;
-#ifdef MINGW
- /* not supported */
- return count;
-#else
- switch (protocol) {
+ switch (protocol)
+ {
case tcp:
+#ifdef MINGW
+ proto = "-p TCP";
+#else
proto = "-t";
+#endif
break;
case udp:
+#ifdef MINGW
+ proto = "-p UDP";
+#else
proto = "-u";
+#endif
break;
case unixdomain:
+#ifdef MINGW
+ proto = "-p UNIX";
+#else
proto = "-x";
+#endif
break;
default:
proto = "";
break;
}
+ /* Use netstat to get a numeric list of all connections on port 'port' in state 'ESTABLISHED' */
+ GNUNET_asprintf(&cmdline, "netstat -n %s | grep %u | grep ESTABLISHED", proto, port);
- GNUNET_asprintf(&cmdline, "netstat -n %s | grep %u", proto, port);
-
- if (system ("netstat -n > /dev/null 2> /dev/null"))
- if (system ("netstat -n > /dev/null 2> /dev/null") == 0)
+ if (system ("netstat -n > " DEVNULL " 2> " DEVNULL))
+ if (system ("netstat -n > " DEVNULL " 2> "DEVNULL) == 0)
f = popen (cmdline, "r");
else
f = NULL;
{
/* read */
//printf ("%s", line);
- count ++;
+ count++;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%i TCP connections established with port %u\n",
- count, port);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "%i TCP connections established with port %u\n",
+ count, port);
pclose (f);
GNUNET_free (cmdline);
return count;
-#endif
}
{
struct TransportPlugin *cur = NULL;
- for (cur = phead; cur != NULL; cur = phead)
+ for (cur = phead; cur != NULL; cur = cur->next)
{
if (0 == strcmp(name, cur->short_name))
return cur;
return cur;
}
-int stats_check_cb (void *cls, const char *subsystem,
- const char *name, uint64_t value,
- int is_persistent)
+static int
+stats_check_cb (void *cls, const char *subsystem,
+ const char *name, uint64_t value,
+ int is_persistent)
{
static int counter;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"%u transport tcp sessions <-> %i established tcp connections\n",
statistics_transport_tcp_connections, low_level_connections_tcp);
- fail = GNUNET_YES;
}
else if (low_level_connections_tcp != -1)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"%u transport notifications <-> %u in statistics (statistics_transport_tcp_connections)\n",
transport_connections, statistics_transport_tcp_connections);
- fail = GNUNET_YES;
}
else
{
return GNUNET_OK;
}
-
-static void
-stats_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- statistics_task = GNUNET_SCHEDULER_NO_TASK;
-
- if (GNUNET_YES == stat_check_running)
- {
- statistics_task = GNUNET_SCHEDULER_add_delayed(STATS_DELAY, &stats_check, NULL);
- }
-
- stat_check_running = GNUNET_YES;
-
- statistics_transport_connections = 0 ;
- statistics_core_entries_session_map = 0;
- statistics_core_neighbour_entries = 0;
-
- GNUNET_STATISTICS_get (stats, "transport", "# peers connected", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_transport_connections);
- GNUNET_STATISTICS_get (stats, "core", "# neighbour entries allocated", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_core_neighbour_entries);
- GNUNET_STATISTICS_get (stats, "core", "# entries in session map", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_core_entries_session_map);
-
- /* TCP plugin specific checks */
- if (GNUNET_YES == have_tcp)
- GNUNET_STATISTICS_get (stats, "transport", "# TCP sessions active", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_transport_tcp_connections);
-
-
-}
-
GNUNET_NETWORK_STRUCT_BEGIN
struct PING
GNUNET_NETWORK_STRUCT_END
- size_t send_transport_ping_cb (void *cls, size_t size, void *buf)
+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_break (0);
+ return 0;
+ }
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending transport ping to `%s'\n", GNUNET_i2s (&pc->id));
+ "Sending transport ping to `%s'\n", GNUNET_i2s (&pc->id));
ping.header.size = htons (mlen);
ping.header.type = htons (1234);
ping.src = htons (0);
return mlen;
}
-size_t send_core_ping_cb (void *cls, size_t size, void *buf)
+
+static size_t
+send_core_ping_cb (void *cls, size_t size, void *buf)
{
- struct PeerContainer * pc = cls;
- struct PING ping;
- size_t mlen = sizeof (struct PING);
+ struct PeerContainer * pc = cls;
+ struct PING ping;
+ size_t mlen = sizeof (struct PING);
- if (size < mlen)
- {
- GNUNET_break (0);
- return 0;
- }
+ if (size < mlen)
+ {
+ 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);
+ 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;
+ pc->ch_ping = NULL;
- memcpy (buf, &ping, mlen);
- return mlen;
+ memcpy (buf, &ping, mlen);
+ return mlen;
+}
+
+
+static int
+map_ping_it (void *cls,
+ const struct GNUNET_PeerIdentity * key,
+ void *value)
+{
+ struct PeerContainer *pc = value;
+
+ if (ping == GNUNET_YES)
+ {
+ if ((GNUNET_YES == pc->transport_connected) && (NULL == pc->th_ping))
+ pc->th_ping = GNUNET_TRANSPORT_notify_transmit_ready(th, &pc->id,
+ sizeof (struct PING), UINT_MAX,
+ GNUNET_TIME_UNIT_FOREVER_REL, &send_transport_ping_cb, pc);
+ else
+ GNUNET_break(0);
+
+ if ((GNUNET_YES == pc->core_connected) && (NULL == pc->ch_ping))
+ pc->ch_ping = GNUNET_CORE_notify_transmit_ready(ch,
+ GNUNET_NO, UINT_MAX,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &pc->id,
+ sizeof (struct PING),
+ send_core_ping_cb, pc);
+ else
+ GNUNET_break (0);
+ }
+ return GNUNET_OK;
}
-size_t send_transport_pong_cb (void *cls, size_t size, void *buf)
+static void
+stats_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ statistics_task = GNUNET_SCHEDULER_NO_TASK;
+
+ if (GNUNET_YES == stat_check_running)
+ {
+ statistics_task = GNUNET_SCHEDULER_add_delayed(STATS_DELAY, &stats_check, NULL);
+ }
+
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &map_ping_it, NULL);
+
+ stat_check_running = GNUNET_YES;
+
+ statistics_transport_connections = 0 ;
+ statistics_core_entries_session_map = 0;
+ statistics_core_neighbour_entries = 0;
+
+ GNUNET_STATISTICS_get (stats, "transport", "# peers connected", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_transport_connections);
+ GNUNET_STATISTICS_get (stats, "core", "# neighbour entries allocated", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_core_neighbour_entries);
+ GNUNET_STATISTICS_get (stats, "core", "# peers connected", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_core_entries_session_map);
+
+ /* TCP plugin specific checks */
+ if (GNUNET_YES == have_tcp)
+ GNUNET_STATISTICS_get (stats, "transport", "# TCP sessions active", GNUNET_TIME_UNIT_MINUTES, NULL, &stats_check_cb, &statistics_transport_tcp_connections);
+}
+
+
+static size_t
+send_transport_pong_cb (void *cls, size_t size, void *buf)
{
struct PeerContainer * pc = cls;
struct PING ping;
return mlen;
}
-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)
+static size_t
+send_core_pong_cb (void *cls, size_t size, void *buf)
{
- GNUNET_break (0);
- return 0;
-}
+ struct PeerContainer * pc = cls;
+ struct PING ping;
+ size_t mlen = sizeof (struct PING);
-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);
+ if (size < mlen)
+ {
+ GNUNET_break (0);
+ return 0;
+ }
-pc->ch_pong = NULL;
+ 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;
+ 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)
{
if (GNUNET_NO == pc->transport_connected)
{
pc->transport_connected = GNUNET_YES;
- if (NULL == pc->th_ping)
- pc->th_ping = GNUNET_TRANSPORT_notify_transmit_ready(th, peer, sizeof (struct PING), UINT_MAX, GNUNET_TIME_relative_get_forever(), &send_transport_ping_cb, pc);
- else
- GNUNET_break(0);
+ if (GNUNET_YES == ping)
+ {
+ if (NULL == pc->th_ping)
+ pc->th_ping = GNUNET_TRANSPORT_notify_transmit_ready(th, peer, sizeof (struct PING), UINT_MAX, GNUNET_TIME_UNIT_FOREVER_REL, &send_transport_ping_cb, pc);
+ else
+ GNUNET_break(0);
+ }
}
else
{
if (GNUNET_NO == pc->core_connected)
{
pc->core_connected = GNUNET_YES;
- if (NULL == pc->ch_ping)
- pc->ch_ping = GNUNET_CORE_notify_transmit_ready(ch,
+ if (GNUNET_YES == ping)
+ {
+ if (NULL == pc->ch_ping)
+ pc->ch_ping = GNUNET_CORE_notify_transmit_ready(ch,
GNUNET_NO, UINT_MAX,
- GNUNET_TIME_relative_get_forever(),
+ GNUNET_TIME_UNIT_FOREVER_REL,
peer,
sizeof (struct PING),
send_core_ping_cb, pc);
- else
- GNUNET_break (0);
+ else
+ GNUNET_break (0);
+ }
}
else
{
{
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 (NULL != pc->th_ping)
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);
static void
cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct TransportPlugin * cur = phead;
+ struct TransportPlugin *cur;
if (NULL != th)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Disconnecting from transport service\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Disconnecting from transport service\n");
GNUNET_TRANSPORT_disconnect (th);
th = NULL;
}
if (NULL != ch)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Disconnecting from core service\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Disconnecting from core service\n");
GNUNET_CORE_disconnect (ch);
ch = NULL;
}
check_task = GNUNET_SCHEDULER_NO_TASK;
}
- for (cur = phead; cur != NULL; cur = phead)
+ for (cur = phead; NULL != cur; cur = phead)
{
GNUNET_CONTAINER_DLL_remove(phead, ptail, cur);
GNUNET_free (cur->short_name);
check_task = GNUNET_SCHEDULER_add_now (&map_check, &map_cleanup);
}
-void
+
+static void
transport_notify_connect_cb (void *cls,
- const struct GNUNET_PeerIdentity
- * peer,
- const struct
- GNUNET_ATS_Information * ats,
- uint32_t ats_count)
+ const struct GNUNET_PeerIdentity* peer)
{
transport_connections ++;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "TRANSPORT connect for peer `%s' (%u total)\n",
- GNUNET_i2s (peer), transport_connections);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "TRANSPORT connect for peer `%s' (%u total)\n",
+ GNUNET_i2s (peer),
+ transport_connections);
map_connect (peer, th);
}
+
/**
* Function called to notify transport users that another
* peer disconnected from us.
* @param cls closure
* @param peer the peer that disconnected
*/
-void
+static void
transport_notify_disconnect_cb (void *cls,
- const struct
- GNUNET_PeerIdentity * peer)
+ const struct GNUNET_PeerIdentity *peer)
{
GNUNET_assert (transport_connections > 0);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "TRANSPORT disconnect for peer `%s' (%u total)\n",
- GNUNET_i2s (peer), transport_connections) ;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "TRANSPORT disconnect for peer `%s' (%u total)\n",
+ GNUNET_i2s (peer),
+ transport_connections);
map_disconnect (peer, th);
transport_connections --;
-
}
+
static void
transport_notify_receive_cb (void *cls,
const struct
GNUNET_PeerIdentity * peer,
const struct
GNUNET_MessageHeader *
- message,
- const struct
- GNUNET_ATS_Information * ats,
- uint32_t ats_count)
+ message)
{
+ struct PeerContainer *pc;
-
- struct PeerContainer *pc = NULL;
-
- pc = GNUNET_CONTAINER_multihashmap_get(peers, &peer->hashPubKey);
-
+ pc = GNUNET_CONTAINER_multipeermap_get (peers, peer);
if (NULL == pc)
{
GNUNET_break (0);
return;
}
- if ((message->size == ntohs (sizeof (struct PING))) && (message->type == ntohs (1234)))
+ if ((message->size == ntohs (sizeof (struct PING))) &&
+ (message->type == ntohs (1234)))
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received %s %s from peer `%s'\n",
- "TRANSPORT",
- "PING",
- GNUNET_i2s (peer)) ;
- if (NULL == pc->th_pong)
- pc->th_pong = GNUNET_TRANSPORT_notify_transmit_ready(th,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Received %s %s from peer `%s'\n",
+ "TRANSPORT",
+ "PING",
+ GNUNET_i2s (peer)) ;
+ if (GNUNET_YES == ping)
+ {
+ if (NULL == pc->th_pong)
+ pc->th_pong = GNUNET_TRANSPORT_notify_transmit_ready(th,
peer, sizeof (struct PONG),
- UINT_MAX, GNUNET_TIME_relative_get_forever(),
+ UINT_MAX, GNUNET_TIME_UNIT_FOREVER_REL,
&send_transport_pong_cb, pc);
- else
- GNUNET_break (0);
+ else
+ GNUNET_break (0);
+ }
}
if ((message->size == ntohs (sizeof (struct PONG))) && (message->type == ntohs (4321)))
}
}
-int core_notify_receive_cb (void *cls,
- const struct GNUNET_PeerIdentity * peer,
- const struct GNUNET_MessageHeader * message,
- const struct GNUNET_ATS_Information* atsi,
- unsigned int atsi_count)
+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)
{
+ if (0 == memcmp (peer, &my_peer_id, sizeof (my_peer_id)))
+ return GNUNET_OK;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Received unexpected message type %u from unknown peer `%s'\n",
+ ntohs (message->type),
+ GNUNET_i2s (peer));
+
GNUNET_break (0);
return GNUNET_OK;
}
"CORE",
"PING",
GNUNET_i2s (peer));
- if (NULL == pc->ch_pong)
- pc->ch_pong = GNUNET_CORE_notify_transmit_ready(ch,
+ if (GNUNET_YES == ping)
+ {
+ if (NULL == pc->ch_pong)
+ pc->ch_pong = GNUNET_CORE_notify_transmit_ready(ch,
GNUNET_NO, UINT_MAX,
- GNUNET_TIME_relative_get_forever(),
+ GNUNET_TIME_UNIT_FOREVER_REL,
peer,
sizeof (struct PONG),
send_core_pong_cb, pc);
- else
- GNUNET_break (0);
+ else
+ GNUNET_break (0);
+ }
}
if ((message->size == ntohs (sizeof (struct PONG))) && (message->type == ntohs (4321)))
}
static void
-core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer)
{
if (0 != memcmp (peer, &my_peer_id, sizeof (struct GNUNET_PeerIdentity)))
{
{
if (0 != memcmp (peer, &my_peer_id, sizeof (struct GNUNET_PeerIdentity)))
{
- GNUNET_assert (core_connections >= 0);
+ GNUNET_assert (core_connections > 0);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "CORE disconnect for peer `%s' (%u total)\n",
GNUNET_i2s (peer), core_connections);
map_disconnect (peer, ch);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "CORE disconnect for myself `%s' (%u total)\n",
GNUNET_i2s (peer), core_connections);
}
-
}
+
static void
-core_init_cb (void *cls, struct GNUNET_CORE_Handle *server,
- const struct GNUNET_PeerIdentity *my_identity)
+core_init_cb (void *cls,
+ const struct GNUNET_PeerIdentity *my_identity)
{
my_peer_id = *my_identity;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connected to core service\n");
char *pos;
char *secname;
int counter;
- long long unsigned int port;
+ unsigned long long port;
have_tcp = GNUNET_NO;
have_udp = GNUNET_NO;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport plugin: `%s' port %llu\n"), pos, port);
cur = GNUNET_malloc(sizeof (struct TransportPlugin));
- cur->short_name = strdup (pos);
+ cur->short_name = GNUNET_strdup (pos);
cur->port = port;
if (0 == strcmp("tcp", pos))
{
GNUNET_free (plugs);
}
+
/**
* Main function that will be run by the scheduler.
*
init();
stats = GNUNET_STATISTICS_create ("watchdog", cfg);
- peers = GNUNET_CONTAINER_multihashmap_create (20);
+ peers = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_NO);
th = GNUNET_TRANSPORT_connect(cfg, NULL, NULL,
&transport_notify_receive_cb,
&transport_notify_disconnect_cb);
GNUNET_assert (th != NULL);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connected to transport service\n");
- ch = GNUNET_CORE_connect (cfg, 1, NULL,
+ ch = GNUNET_CORE_connect (cfg, NULL,
&core_init_cb,
&core_connect_cb,
&core_disconnect_cb,
int
main (int argc, char *const *argv)
{
+ ping = GNUNET_NO;
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
- /* FIMXE: add options here */
+ {'p', "ping", NULL, gettext_noop ("Send ping messages to test connectivity (default == NO)"),
+ GNUNET_NO, &GNUNET_GETOPT_set_one, &ping},
GNUNET_GETOPT_OPTION_END
};
- return (GNUNET_OK ==
- GNUNET_PROGRAM_run (argc, argv, "cn",
- gettext_noop ("help text"), options, &run,
- NULL)) ? ret : 1;
+
+ if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+ return 2;
+ ret = (GNUNET_OK ==
+ GNUNET_PROGRAM_run (argc, argv, "cn",
+ gettext_noop ("help text"), options, &run,
+ NULL)) ? ret : 1;
+ GNUNET_free ((void*) argv);
+ return ret;
}
/* end of connection_watchdog.c */
projects / oweals / gnunet.git / blobdiff