transport-testing-send2.c File Reference

#include "platform.h"
#include "transport-testing2.h"

Include dependency graph for transport-testing-send2.c:

Go to the source code of this file.

Macros
#define	TIMEOUT_TRANSMIT
	Acceptable transmission delay.

Functions
static void	find_cr (void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
	Return cx in cls.
int	GNUNET_TRANSPORT_TESTING_send (struct GNUNET_TRANSPORT_TESTING_PeerContext *sender, struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, uint16_t mtype, uint16_t msize, uint32_t num, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
	Send a test message of type mtype and size msize from peer sender to peer receiver.
static void	do_send (struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc, uint16_t size, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
	Task that sends a test message from the first peer to the second peer.
void	GNUNET_TRANSPORT_TESTING_simple_send (void *cls)
	Task that sends a minimalistic test message from the first peer to the second peer.
void	GNUNET_TRANSPORT_TESTING_large_send (void *cls)
	Task that sends a large test message from the first peer to the second peer.

Macro Definition Documentation

TIMEOUT_TRANSMIT

#define TIMEOUT_TRANSMIT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 30)

Acceptable transmission delay.

Definition at line 31 of file transport-testing-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest **cr = cls;
 
  if (GNUNET_NO == cx->connected)
    return;
  *cr = cx;
}
 
 
int
GNUNET_TRANSPORT_TESTING_send (struct
                               GNUNET_TRANSPORT_TESTING_PeerContext *sender,
                               struct GNUNET_TRANSPORT_TESTING_PeerContext *
                               receiver,
                               uint16_t mtype,
                               uint16_t msize,
                               uint32_t num,
                               GNUNET_SCHEDULER_TaskCallback cont,
                               void *cont_cls)
{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cr;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_TESTING_TestMessage *test;
 
  if (msize < sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  cr = NULL;
  GNUNET_TRANSPORT_TESTING_find_connecting_context (sender,
                                                    receiver,
                                                    &find_cr,
                                                    &cr);
  if (NULL == cr)
    GNUNET_TRANSPORT_TESTING_find_connecting_context (receiver,
                                                      sender,
                                                      &find_cr,
                                                      &cr);
  if (NULL == cr)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  if (NULL == cr->mq)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  {
    char *receiver_s = GNUNET_strdup (GNUNET_i2s (&receiver->id));
 
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Sending message from peer %u (`%s') -> peer %u (`%s') !\n",
                sender->no,
                GNUNET_i2s (&sender->id),
                receiver->no,
                receiver_s);
    GNUNET_free (receiver_s);
  }
  env = GNUNET_MQ_msg_extra (test,
                             msize - sizeof(*test),
                             mtype);
  test->num = htonl (num);
  memset (&test[1],
          num,
          msize - sizeof(*test));
  GNUNET_MQ_notify_sent (env,
                         cont,
                         cont_cls);
  GNUNET_MQ_send (cr->mq,
                  env);
  return GNUNET_OK;
}
 
 
static void
do_send (struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc,
         uint16_t size,
         GNUNET_SCHEDULER_TaskCallback cont,
         void *cont_cls)
{
  int ret;
 
  ccc->global_ret = GNUNET_SYSERR;
  ret = GNUNET_TRANSPORT_TESTING_send (ccc->p[0],
                                       ccc->p[1],
                                       GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
                                       size,
                                       ccc->send_num_gen++,
                                       cont,
                                       cont_cls);
  GNUNET_assert (GNUNET_SYSERR != ret);
  if (GNUNET_NO == ret)
  {
    GNUNET_break (0);
    ccc->global_ret = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
  }
}
 
 
void
GNUNET_TRANSPORT_TESTING_simple_send (void *cls)
{
  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
  int done;
  size_t msize;
 
  if (0 < sc->num_messages)
  {
    sc->num_messages--;
    done = (0 == sc->num_messages);
  }
  else
  {
    done = 0;   /* infinite loop */
  }
  msize = sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage);
  if (NULL != sc->get_size_cb)
    msize = sc->get_size_cb (sc->num_messages);
  /* if this was the last message, call the continuation,
     otherwise call this function again */
  do_send (sc->ccc,
           msize,
           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_simple_send,
           done ? sc->cont_cls : sc);
}
 
 
void
GNUNET_TRANSPORT_TESTING_large_send (void *cls)
{
  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
  int done;
  size_t msize;
 
  if (0 < sc->num_messages)
  {
    sc->num_messages--;
    done = (0 == sc->num_messages);
  }
  else
  {
    done = 0;   /* infinite loop */
  }
  msize = 2600;
  if (NULL != sc->get_size_cb)
    msize = sc->get_size_cb (sc->num_messages);
  /* if this was the last message, call the continuation,
     otherwise call this function again */
  do_send (sc->ccc,
           msize,
           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_large_send,
           done ? sc->cont_cls : sc);
}
 
 
/* end of transport-testing-send.c */

Function Documentation

find_cr()

static void find_cr ( void *  cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *  cx  )

static

Return cx in cls.

Definition at line 39 of file transport-testing-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest **cr = cls;
 
  if (GNUNET_NO == cx->connected)
    return;
  *cr = cx;
}

References GNUNET_TRANSPORT_TESTING_ConnectRequest::connected, and GNUNET_NO.

Referenced by GNUNET_TRANSPORT_TESTING_send().

Here is the caller graph for this function:

GNUNET_TRANSPORT_TESTING_send()

int GNUNET_TRANSPORT_TESTING_send	(	struct GNUNET_TRANSPORT_TESTING_PeerContext *	sender,
		struct GNUNET_TRANSPORT_TESTING_PeerContext *	receiver,
		uint16_t	mtype,
		uint16_t	msize,
		uint32_t	num,
		GNUNET_SCHEDULER_TaskCallback	cont,
		void *	cont_cls
	)

Send a test message of type mtype and size msize from peer sender to peer receiver.

The peers should be connected when this function is called.

Parameters

sender	the sending peer
receiver	the receiving peer
mtype	message type to use
msize	size of the message, at least sizeof (struct GNUNET_TRANSPORT_TESTING_TestMessage)
num	unique message number
cont	continuation to call after transmission
cont_cls	closure for cont

Returns

GNUNET_OK if message was queued, GNUNET_NO if peers are not connected GNUNET_SYSERR if msize is illegal

Definition at line 67 of file transport-testing-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cr;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_TESTING_TestMessage *test;
 
  if (msize < sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  cr = NULL;
  GNUNET_TRANSPORT_TESTING_find_connecting_context (sender,
                                                    receiver,
                                                    &find_cr,
                                                    &cr);
  if (NULL == cr)
    GNUNET_TRANSPORT_TESTING_find_connecting_context (receiver,
                                                      sender,
                                                      &find_cr,
                                                      &cr);
  if (NULL == cr)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  if (NULL == cr->mq)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  {
    char *receiver_s = GNUNET_strdup (GNUNET_i2s (&receiver->id));
 
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Sending message from peer %u (`%s') -> peer %u (`%s') !\n",
                sender->no,
                GNUNET_i2s (&sender->id),
                receiver->no,
                receiver_s);
    GNUNET_free (receiver_s);
  }
  env = GNUNET_MQ_msg_extra (test,
                             msize - sizeof(*test),
                             mtype);
  test->num = htonl (num);
  memset (&test[1],
          num,
          msize - sizeof(*test));
  GNUNET_MQ_notify_sent (env,
                         cont,
                         cont_cls);
  GNUNET_MQ_send (cr->mq,
                  env);
  return GNUNET_OK;
}

References env, find_cr(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_TRANSPORT_TESTING_find_connecting_context(), GNUNET_TRANSPORT_TESTING_PeerContext::id, GNUNET_TRANSPORT_TESTING_ConnectRequest::mq, GNUNET_TRANSPORT_TESTING_PeerContext::no, GNUNET_TRANSPORT_TESTING_TestMessage::num, and receiver().

Referenced by do_send().

Here is the call graph for this function:

Here is the caller graph for this function:

do_send()

static void do_send ( struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *  ccc, uint16_t  size, GNUNET_SCHEDULER_TaskCallback  cont, void *  cont_cls  )

static

Task that sends a test message from the first peer to the second peer.

Parameters

ccc	context which should contain at least two peers, the first two of which should be currently connected
size	desired message size
cont	continuation to call after transmission
cont_cls	closure for cont

Definition at line 144 of file transport-testing-send2.c.

{
  int ret;
 
  ccc->global_ret = GNUNET_SYSERR;
  ret = GNUNET_TRANSPORT_TESTING_send (ccc->p[0],
                                       ccc->p[1],
                                       GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
                                       size,
                                       ccc->send_num_gen++,
                                       cont,
                                       cont_cls);
  GNUNET_assert (GNUNET_SYSERR != ret);
  if (GNUNET_NO == ret)
  {
    GNUNET_break (0);
    ccc->global_ret = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
  }
}

References GNUNET_TRANSPORT_TESTING_ConnectCheckContext::global_ret, GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TRANSPORT_TESTING_send(), GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::p, ret, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::send_num_gen, and size.

Referenced by GNUNET_TRANSPORT_TESTING_large_send(), and GNUNET_TRANSPORT_TESTING_simple_send().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_TESTING_simple_send()

void GNUNET_TRANSPORT_TESTING_simple_send

(

void *

cls

)

Task that sends a minimalistic test message from the first peer to the second peer.

Parameters

cls	the struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext which should contain at least two peers, the first two of which should be currently connected

Definition at line 178 of file transport-testing-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
  int done;
  size_t msize;
 
  if (0 < sc->num_messages)
  {
    sc->num_messages--;
    done = (0 == sc->num_messages);
  }
  else
  {
    done = 0;   /* infinite loop */
  }
  msize = sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage);
  if (NULL != sc->get_size_cb)
    msize = sc->get_size_cb (sc->num_messages);
  /* if this was the last message, call the continuation,
     otherwise call this function again */
  do_send (sc->ccc,
           msize,
           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_simple_send,
           done ? sc->cont_cls : sc);
}

References do_send(), GNUNET_TRANSPORT_TESTING_simple_send(), and sc.

Referenced by GNUNET_TRANSPORT_TESTING_simple_send().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TRANSPORT_TESTING_large_send()

void GNUNET_TRANSPORT_TESTING_large_send

(

void *

cls

)

Task that sends a large test message from the first peer to the second peer.

Parameters

cls	the struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext which should contain at least two peers, the first two of which should be currently connected

Definition at line 214 of file transport-testing-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
  int done;
  size_t msize;
 
  if (0 < sc->num_messages)
  {
    sc->num_messages--;
    done = (0 == sc->num_messages);
  }
  else
  {
    done = 0;   /* infinite loop */
  }
  msize = 2600;
  if (NULL != sc->get_size_cb)
    msize = sc->get_size_cb (sc->num_messages);
  /* if this was the last message, call the continuation,
     otherwise call this function again */
  do_send (sc->ccc,
           msize,
           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_large_send,
           done ? sc->cont_cls : sc);
}

References do_send(), GNUNET_TRANSPORT_TESTING_large_send(), and sc.

Referenced by GNUNET_TRANSPORT_TESTING_large_send().

Here is the call graph for this function:

Here is the caller graph for this function: