transport-testing-send.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2016 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
#include "transport-testing.h"
 
#define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 30)
 
 
static void
find_cr (void *cls,
         struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
{
  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 */