void
GNUNET_ATS_TEST_traffic_handle_ping (struct BenchmarkPartner *p)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Slave [%u]: Received PING from [%u], sending PONG\n", p->me->no,
p->dest->no);
p->messages_received++;
p->bytes_received += TEST_MESSAGE_SIZE;
p->me->total_messages_received++;
p->me->total_bytes_received += TEST_MESSAGE_SIZE;
if (GNUNET_YES == top->test_core)
{
GNUNET_assert (NULL == p->cth);
p->cth
= GNUNET_CORE_notify_transmit_ready (p->me->ch, GNUNET_NO,
GNUNET_CORE_PRIO_BEST_EFFORT,
GNUNET_TIME_UNIT_MINUTES,
&p->dest->id, TEST_MESSAGE_SIZE,
&comm_send_pong_ready, p);
}
else
{
GNUNET_assert (NULL == p->tth);
p->tth = GNUNET_TRANSPORT_notify_transmit_ready (p->me->th, &p->dest->id,
TEST_MESSAGE_SIZE, GNUNET_TIME_UNIT_MINUTES, &comm_send_pong_ready,
p);
}
}
static void
sendtask (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
send_task = NULL;
if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
char *receiver_s = GNUNET_strdup (GNUNET_i2s (&p1->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending message from peer %u (`%4s') -> peer %u (`%s') !\n",
p2->no, GNUNET_i2s (&p2->id), p1->no, receiver_s);
GNUNET_free (receiver_s);
if (0 == messages_recv)
{
start_normal = GNUNET_TIME_absolute_get();
}
if (1 == messages_recv)
{
start_delayed = GNUNET_TIME_absolute_get();
}
s_sending = GNUNET_YES;
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th,
&p1->id,
TEST_MESSAGE_SIZE,
TIMEOUT_TRANSMIT,
¬ify_ready,
p1);
}
/**
* Function called to notify a client about the socket
* begin ready to queue more data. "buf" will be
* NULL and "size" zero if the socket was closed for
* writing in the meantime.
*
* @param cls closure
* @param size number of bytes available in buf
* @param buf where the callee should write the message
* @return number of bytes written to buf
*/
static size_t
transmit_data (void *cls, size_t size, void *buf)
{
struct GNUNET_MessageHeader *m = buf;
if ((NULL == buf) && (0 == size))
{
th = NULL;
return 0;
}
GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
m->size = ntohs (size);
m->type = ntohs (GNUNET_MESSAGE_TYPE_DUMMY);
memset (&m[1], 52, size - sizeof (struct GNUNET_MessageHeader));
traffic_sent += size;
th = GNUNET_TRANSPORT_notify_transmit_ready (handle, &pid, BLOCKSIZE * 1024, 0,
GNUNET_TIME_UNIT_FOREVER_REL,
&transmit_data, NULL);
if (verbosity > 0)
FPRINTF (stdout, _("Transmitting %u bytes to %s\n"), (unsigned int) size,
GNUNET_i2s (&pid));
return size;
}
static void
comm_schedule_send (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct BenchmarkPartner *p = cls;
p->tg->send_task = GNUNET_SCHEDULER_NO_TASK;
p->last_message_sent = GNUNET_TIME_absolute_get();
if (GNUNET_YES == top->test_core)
{
p->cth = GNUNET_CORE_notify_transmit_ready (p->me->ch, GNUNET_NO,
GNUNET_CORE_PRIO_BEST_EFFORT,
GNUNET_TIME_UNIT_MINUTES,
&p->dest->id,
TEST_MESSAGE_SIZE,
&send_ping_ready_cb, p);
}
else
{
p->tth = GNUNET_TRANSPORT_notify_transmit_ready (p->me->th,
&p->dest->id,
TEST_MESSAGE_SIZE,
GNUNET_TIME_UNIT_MINUTES,
&send_ping_ready_cb, p);
}
}
static void
sendtask ()
{
start_time = GNUNET_TIME_absolute_get ();
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, get_size (0), 0,
TIMEOUT_TRANSMIT, ¬ify_ready,
NULL);
}
static void
sendtask ()
{
start_time = GNUNET_TIME_absolute_get ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting to send %u messages\n",
TOTAL_MSGS);
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, get_size (0), 0,
TIMEOUT_TRANSMIT, ¬ify_ready,
NULL);
}
static void
sendtask (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
send_task = GNUNET_SCHEDULER_NO_TASK;
if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
th = GNUNET_TRANSPORT_notify_transmit_ready (p1->th, &p2->id, 256, 0, TIMEOUT,
¬ify_ready, &p1);
}
static void
sendtask (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
start_time = GNUNET_TIME_absolute_get ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting to send %u messages\n",
TOTAL_MSGS);
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, get_size (0),
TIMEOUT_TRANSMIT, ¬ify_ready,
NULL);
}
/**
* Function called to notify transport users that another
* peer connected to us.
*
* @param cls closure
* @param peer the peer that connected
*/
static void
notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
return;
ret = 0;
if (try_connect)
{
/* all done, terminate instantly */
FPRINTF (stdout, _("Successfully connected to `%s'\n"),
GNUNET_i2s_full (peer));
ret = 0;
if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
{
GNUNET_SCHEDULER_cancel (op_timeout);
op_timeout = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != end)
GNUNET_SCHEDULER_cancel (end);
end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL );
return;
}
if (benchmark_send)
{
if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
{
GNUNET_SCHEDULER_cancel (op_timeout);
op_timeout = GNUNET_SCHEDULER_NO_TASK;
}
if (verbosity > 0)
FPRINTF (stdout,
_("Successfully connected to `%s', starting to send benchmark data in %u Kb blocks\n"),
GNUNET_i2s (&pid), BLOCKSIZE);
start_time = GNUNET_TIME_absolute_get ();
if (NULL == th)
th = GNUNET_TRANSPORT_notify_transmit_ready (handle, peer,
BLOCKSIZE * 1024,
GNUNET_TIME_UNIT_FOREVER_REL,
&transmit_data,
NULL);
else
GNUNET_break(0);
return;
}
}
static void
sendtask (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
send_task = NULL;
if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
char *receiver_s = GNUNET_strdup (GNUNET_i2s (&p1->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending message from peer %u (`%4s') -> peer %u (`%s') !\n",
p2->no, GNUNET_i2s (&p2->id), p1->no, receiver_s);
GNUNET_free (receiver_s);
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, 256,
TIMEOUT_TRANSMIT, ¬ify_ready,
p1);
}
/**
* Check if we have messages for the specified neighbour pending, and
* if so, check with the transport about sending them out.
*
* @param n neighbour to check.
*/
static void
process_queue (struct Neighbour *n)
{
struct NeighbourMessageEntry *m;
if (NULL != n->th)
return; /* request already pending */
m = n->message_head;
if (NULL == m)
{
/* notify sessions that the queue is empty and more messages
* could thus be queued now */
GSC_SESSIONS_solicit (&n->peer);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Asking transport for transmission of %u bytes to `%s' in next %s\n",
(unsigned int) m->size,
GNUNET_i2s (&n->peer),
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (m->deadline),
GNUNET_NO));
m->submission_time = GNUNET_TIME_absolute_get ();
n->th
= GNUNET_TRANSPORT_notify_transmit_ready (transport,
&n->peer,
m->size,
GNUNET_TIME_absolute_get_remaining (m->deadline),
&transmit_ready,
n);
if (NULL != n->th)
return;
/* message request too large or duplicate request */
GNUNET_break (0);
/* discard encrypted message */
GNUNET_CONTAINER_DLL_remove (n->message_head,
n->message_tail,
m);
n->queue_size--;
GNUNET_free (m);
process_queue (n);
}
static void
sendtask (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_ATS_Information ats[1];
send_task = GNUNET_SCHEDULER_NO_TASK;
if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
char *receiver_s = GNUNET_strdup (GNUNET_i2s (&p1->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending message from peer %u (`%4s') -> peer %u (`%s') !\n",
p2->no, GNUNET_i2s (&p2->id), p1->no, receiver_s);
GNUNET_free (receiver_s);
if (0 == messages_recv)
{
start_normal = GNUNET_TIME_absolute_get();
}
if (1 == messages_recv)
{
ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
ats[0].value = htonl (1000);
GNUNET_TRANSPORT_set_traffic_metric (p2->th, &p1->id, TM_SEND, ats, 1);
ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
ats[0].value = htonl (10);
GNUNET_TRANSPORT_set_traffic_metric (p1->th, &p2->id, TM_BOTH, ats, 1);
start_delayed = GNUNET_TIME_absolute_get();
}
s_sending = GNUNET_YES;
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, TEST_MESSAGE_SIZE, 0,
TIMEOUT_TRANSMIT, ¬ify_ready,
p1);
}
static size_t
notify_ready (void *cls, size_t size, void *buf)
{
static int n;
char *cbuf = buf;
struct TestMessage hdr;
unsigned int s;
unsigned int ret;
th = NULL;
if (buf == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout occurred while waiting for transmit_ready for message %u of %u\n",
msg_scheduled, TOTAL_MSGS);
if (GNUNET_SCHEDULER_NO_TASK != die_task)
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
test_failed = 1;
return 0;
}
ret = 0;
s = get_size (n);
GNUNET_assert (size >= s);
GNUNET_assert (buf != NULL);
cbuf = buf;
do
{
hdr.header.size = htons (s);
hdr.header.type = htons (MTYPE);
hdr.num = htonl (n);
msg_sent = n;
memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
ret += sizeof (struct TestMessage);
memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
ret += s - sizeof (struct TestMessage);
#if VERBOSE
if (n % 5000 == 0)
{
char *receiver_s = GNUNET_strdup (GNUNET_i2s (&receiver->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending message of size %u from peer %u (`%4s') -> peer %u (`%s') !\n",
n, sender->no, GNUNET_i2s (&sender->id), receiver->no,
receiver_s);
GNUNET_free (receiver_s);
}
#endif
n++;
s = get_size (n);
if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
break; /* sometimes pack buffer full, sometimes not */
}
while (size - ret >= s);
if (n < TOTAL_MSGS)
{
if (th == NULL)
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, s, 0,
TIMEOUT_TRANSMIT,
¬ify_ready, NULL);
msg_scheduled = n;
}
if (n % 5000 == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Returning total message block of size %u\n", ret);
}
total_bytes_sent += ret;
if (n == TOTAL_MSGS)
{
FPRINTF (stderr, "%s", "\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All messages sent\n");
}
return ret;
}
static size_t
notify_ready (void *cls, size_t size, void *buf)
{
static int n;
char *cbuf = buf;
struct TestMessage hdr;
unsigned int s;
unsigned int ret;
th = NULL;
if (buf == NULL)
{
test_send_timeout = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout occurred while waiting for transmit_ready for msg %u of %u\n",
msg_scheduled, TOTAL_MSGS);
if (NULL != die_task)
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
ok = 42;
return 0;
}
ret = 0;
s = get_size (n);
GNUNET_assert (size >= s);
GNUNET_assert (buf != NULL);
GNUNET_assert (n < TOTAL_MSGS);
cbuf = buf;
do
{
GNUNET_assert (n < TOTAL_MSGS);
hdr.header.size = htons (s);
hdr.header.type = htons (MTYPE);
hdr.num = htonl (n);
msg_sent = n;
memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
ret += sizeof (struct TestMessage);
memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
ret += s - sizeof (struct TestMessage);
#if VERBOSE
if (n % 5000 == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending message %u of size %u\n",
n,
s);
}
#endif
n++;
s = get_size (n);
if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
break; /* sometimes pack buffer full, sometimes not */
}
while ((size - ret >= s) && (n < TOTAL_MSGS));
if (n < TOTAL_MSGS)
{
th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, s,
TIMEOUT_TRANSMIT,
¬ify_ready, NULL);
msg_scheduled = n;
}
else
{
FPRINTF (stderr, "%s", "\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"All messages scheduled to be sent\n");
if (NULL != die_task)
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
}
if (n % 5000 == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Returning total message block of size %u\n", ret);
}
total_bytes += ret;
return ret;
}
