#include "gnunet_program_lib.h"
#include "gnunet_scheduler_lib.h"
#include "gnunet_transport_service.h"
+#include <gauger.h>
#define VERBOSE GNUNET_NO
#define START_ARM GNUNET_YES
+/**
+ * Note that this value must not significantly exceed
+ * 'MAX_PENDING' in 'gnunet-service-transport.c', otherwise
+ * messages may be dropped even for a reliable transport.
+ */
+#define TOTAL_MSGS (600 * 10)
+
/**
* How long until we give up on transmitting the message?
*/
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 6000)
/**
* What delay do we request from the core service for transmission?
static struct GNUNET_TIME_Absolute start_time;
-/**
- * Note that this value must not significantly exceed
- * 'MAX_PENDING' in 'gnunet-service-transport.c', otherwise
- * messages may be dropped even for a reliable transport.
- */
-#define TOTAL_MSGS (600 * 2)
+static GNUNET_SCHEDULER_TaskIdentifier err_task;
+
struct PeerContext
{
struct GNUNET_MessageHeader *hello;
int connect_status;
#if START_ARM
- pid_t arm_pid;
+ struct GNUNET_OS_Process *arm_proc;
#endif
};
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
+static int32_t tr_n;
+
+
#if VERBOSE
#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
#else
p1.th = NULL;
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
- delta = GNUNET_TIME_absolute_get_duration (start_time).value;
+ delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
fprintf (stderr,
"\nThroughput was %llu kb/s\n",
total_bytes * 1000 / 1024 / delta);
+ GAUGER ("CORE", "Core throughput/s", total_bytes * 1000 / 1024 / delta, "kb/s");
ok = 0;
}
}
+static size_t
+transmit_ready (void *cls, size_t size, void *buf)
+{
+ char *cbuf = buf;
+ struct TestMessage hdr;
+ unsigned int s;
+ unsigned int ret;
+
+ GNUNET_assert (size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
+ if (buf == NULL)
+ {
+ if (p1.ch != NULL)
+ GNUNET_break (NULL !=
+ GNUNET_CORE_notify_transmit_ready (p1.ch,
+ GNUNET_NO,
+ 0,
+ FAST_TIMEOUT,
+ &p2.id,
+ get_size(tr_n),
+ &transmit_ready, &p1));
+ return 0;
+ }
+ GNUNET_assert (tr_n < TOTAL_MSGS);
+ ret = 0;
+ s = get_size (tr_n);
+ GNUNET_assert (size >= s);
+ GNUNET_assert (buf != NULL);
+ cbuf = buf;
+ do
+ {
+#if VERBOSE
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending message %u of size %u at offset %u\n",
+ tr_n,
+ s,
+ ret);
+#endif
+ hdr.header.size = htons (s);
+ hdr.header.type = htons (MTYPE);
+ hdr.num = htonl (tr_n);
+ memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+ ret += sizeof (struct TestMessage);
+ memset (&cbuf[ret], tr_n, s - sizeof (struct TestMessage));
+ ret += s - sizeof (struct TestMessage);
+ tr_n++;
+ s = get_size (tr_n);
+ if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+ break; /* sometimes pack buffer full, sometimes not */
+ }
+ while (size - ret >= s);
+ GNUNET_SCHEDULER_cancel (err_task);
+ err_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &terminate_task_error,
+ NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Returning total message block of size %u\n",
+ ret);
+ total_bytes += ret;
+ return ret;
+}
+
+
+
static void
connect_notify (void *cls,
const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance)
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi)
{
struct PeerContext *pc = cls;
+
+ if (0 == memcmp (&pc->id,
+ peer,
+ sizeof (struct GNUNET_PeerIdentity)))
+ return;
GNUNET_assert (pc->connect_status == 0);
pc->connect_status = 1;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Encrypted connection established to peer `%4s'\n",
- GNUNET_i2s (peer));
+ if (pc == &p1)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Encrypted connection established to peer `%4s'\n",
+ GNUNET_i2s (peer));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Asking core (1) for transmission to peer `%4s'\n",
+ GNUNET_i2s (&p2.id));
+ err_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &terminate_task_error,
+ NULL);
+ start_time = GNUNET_TIME_absolute_get ();
+ GNUNET_break (NULL !=
+ GNUNET_CORE_notify_transmit_ready (p1.ch,
+ GNUNET_NO,
+ 0,
+ TIMEOUT,
+ &p2.id,
+ get_size (0),
+ &transmit_ready, &p1));
+ }
}
const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *pc = cls;
+
+ if (0 == memcmp (&pc->id,
+ peer,
+ sizeof (struct GNUNET_PeerIdentity)))
+ return;
pc->connect_status = 0;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer));
inbound_notify (void *cls,
const struct GNUNET_PeerIdentity *other,
const struct GNUNET_MessageHeader *message,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance)
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi)
{
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
outbound_notify (void *cls,
const struct GNUNET_PeerIdentity *other,
const struct GNUNET_MessageHeader *message,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance)
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi)
{
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
}
-static GNUNET_SCHEDULER_TaskIdentifier err_task;
-
-
static size_t
transmit_ready (void *cls, size_t size, void *buf);
-static int tr_n;
-
-
static int
process_mtype (void *cls,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_MessageHeader *message,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance)
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi)
{
static int n;
unsigned int s;
n, s,
ntohs (message->size),
ntohl (hdr->num));
- GNUNET_SCHEDULER_cancel (sched, err_task);
- err_task = GNUNET_SCHEDULER_add_now (sched, &terminate_task_error, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
return GNUNET_SYSERR;
}
if (ntohl (hdr->num) != n)
n, s,
ntohs (message->size),
ntohl (hdr->num));
- GNUNET_SCHEDULER_cancel (sched, err_task);
- err_task = GNUNET_SCHEDULER_add_now (sched, &terminate_task_error, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
return GNUNET_SYSERR;
}
#if VERBOSE
fprintf (stderr, ".");
if (n == TOTAL_MSGS)
{
- GNUNET_SCHEDULER_cancel (sched, err_task);
- GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
}
else
{
if (n == tr_n)
GNUNET_break (NULL !=
GNUNET_CORE_notify_transmit_ready (p1.ch,
+ GNUNET_NO,
0,
FAST_TIMEOUT,
&p2.id,
};
-static size_t
-transmit_ready (void *cls, size_t size, void *buf)
-{
- char *cbuf = buf;
- struct TestMessage hdr;
- unsigned int s;
- unsigned int ret;
-
- GNUNET_assert (size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
- if (buf == NULL)
- {
- if (p1.ch != NULL)
- GNUNET_break (NULL !=
- GNUNET_CORE_notify_transmit_ready (p1.ch,
- 0,
- FAST_TIMEOUT,
- &p2.id,
- get_size(tr_n),
- &transmit_ready, &p1));
- return 0;
- }
- GNUNET_assert (tr_n < TOTAL_MSGS);
- ret = 0;
- s = get_size (tr_n);
- GNUNET_assert (size >= s);
- GNUNET_assert (buf != NULL);
- cbuf = buf;
- do
- {
-#if VERBOSE
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending message %u of size %u at offset %u\n",
- tr_n,
- s,
- ret);
-#endif
- hdr.header.size = htons (s);
- hdr.header.type = htons (MTYPE);
- hdr.num = htonl (tr_n);
- memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
- ret += sizeof (struct TestMessage);
- memset (&cbuf[ret], tr_n, s - sizeof (struct TestMessage));
- ret += s - sizeof (struct TestMessage);
- tr_n++;
- s = get_size (tr_n);
- if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
- break; /* sometimes pack buffer full, sometimes not */
- }
- while (size - ret >= s);
- GNUNET_SCHEDULER_cancel (sched, err_task);
- err_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
- &terminate_task_error,
- NULL);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Returning total message block of size %u\n",
- ret);
- total_bytes += ret;
- return ret;
-}
-
-
static void
init_notify (void *cls,
GNUNET_assert (ok == 2);
OKPP;
/* connect p2 */
- GNUNET_CORE_connect (sched,
- p2.cfg,
- TIMEOUT,
+ GNUNET_CORE_connect (p2.cfg, 1,
&p2,
&init_notify,
&connect_notify,
&disconnect_notify,
+ NULL,
&inbound_notify,
GNUNET_YES,
&outbound_notify, GNUNET_YES, handlers);
OKPP;
GNUNET_assert (cls == &p2);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Asking core (1) for transmission to peer `%4s'\n",
+ "Asking core (1) to connect to peer `%4s'\n",
GNUNET_i2s (&p2.id));
- err_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
- &terminate_task_error,
- NULL);
- start_time = GNUNET_TIME_absolute_get ();
- GNUNET_break (NULL !=
- GNUNET_CORE_notify_transmit_ready (p1.ch,
- 0,
- TIMEOUT,
- &p2.id,
- get_size (0),
- &transmit_ready, &p1));
+ GNUNET_CORE_peer_request_connect (p1.ch,
+ GNUNET_TIME_UNIT_SECONDS,
+ &p2.id,
+ NULL, NULL);
}
}
p->hello = GNUNET_malloc (ntohs (message->size));
memcpy (p->hello, message, ntohs (message->size));
if ((p == &p1) && (p2.th != NULL))
- GNUNET_TRANSPORT_offer_hello (p2.th, message);
+ GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
if ((p == &p2) && (p1.th != NULL))
- GNUNET_TRANSPORT_offer_hello (p1.th, message);
+ GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
if ((p == &p1) && (p2.hello != NULL))
- GNUNET_TRANSPORT_offer_hello (p1.th, p2.hello);
+ GNUNET_TRANSPORT_offer_hello (p1.th, p2.hello, NULL, NULL);
if ((p == &p2) && (p1.hello != NULL))
- GNUNET_TRANSPORT_offer_hello (p2.th, p1.hello);
+ GNUNET_TRANSPORT_offer_hello (p2.th, p1.hello, NULL, NULL);
}
{
p->cfg = GNUNET_CONFIGURATION_create ();
#if START_ARM
- p->arm_pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
+ p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE
"-L", "DEBUG",
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, p, NULL, NULL, NULL);
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
GNUNET_assert (p->th != NULL);
GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
setup_peer (&p1, "test_core_api_peer1.conf");
setup_peer (&p2, "test_core_api_peer2.conf");
- GNUNET_CORE_connect (sched,
- p1.cfg,
- TIMEOUT,
+ GNUNET_CORE_connect (p1.cfg, 1,
&p1,
&init_notify,
&connect_notify,
&disconnect_notify,
+ NULL,
&inbound_notify,
GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
}
stop_arm (struct PeerContext *p)
{
#if START_ARM
- if (0 != PLIBC_KILL (p->arm_pid, SIGTERM))
+ if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
- if (GNUNET_OS_process_wait(p->arm_pid) != GNUNET_OK)
+ if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ARM process %u stopped\n", p->arm_pid);
+ "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
+ GNUNET_OS_process_close (p->arm_proc);
+ p->arm_proc = NULL;
#endif
GNUNET_CONFIGURATION_destroy (p->cfg);
}