src/testbed/test_testbed_underlay.c

   1 /*
   2       This file is part of GNUnet
   3       Copyright (C) 2008--2013 GNUnet e.V.
   4
   5       GNUnet is free software: you can redistribute it and/or modify it
   6       under the terms of the GNU Affero General Public License as published
   7       by the Free Software Foundation, either version 3 of the License,
   8       or (at your option) any later version.
   9
  10       GNUnet is distributed in the hope that it will be useful, but
  11       WITHOUT ANY WARRANTY; without even the implied warranty of
  12       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13       Affero General Public License for more details.
  14
  15       You should have received a copy of the GNU Affero General Public License
  16       along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file testbed/test_testbed_underlay.c
  23  * @brief testcase binary for testing testbed underlay restrictions
  24  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_testbed_service.h"
  30
  31
  32 /**
  33  * Number of peers we start in this test case
  34  */
  35 #define NUM_PEERS 3
  36
  37 /**
  38  * Result of this test case
  39  */
  40 static int result;
  41
  42 static struct GNUNET_TESTBED_Operation *op;
  43
  44
  45 /**
  46  * Shutdown testcase
  47  *
  48  * @param cls NULL
  49  * @param tc scheduler task context
  50  */
  51 static void
  52 do_shutdown (void *cls)
  53 {
  54   if (NULL != op)
  55     GNUNET_TESTBED_operation_done (op);
  56   op = NULL;
  57 }
  58
  59
  60 /**
  61  * Callback to be called when an operation is completed
  62  *
  63  * @param cls the callback closure from functions generating an operation
  64  * @param op the operation that has been finished
  65  * @param emsg error message in case the operation has failed; will be NULL if
  66  *          operation has executed successfully.
  67  */
  68 static void
  69 overlay_connect_status (void *cls,
  70                         struct GNUNET_TESTBED_Operation *op_,
  71                         const char *emsg)
  72 {
  73   GNUNET_assert (op_ == op);
  74   GNUNET_TESTBED_operation_done (op);
  75   op = NULL;
  76   if (NULL == emsg)
  77     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
  78                 "Peers 0 and 2 should not get connected\n");
  79   else
  80   {
  81     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  82                 "Peers 0 and 2 not connected: %s.  Success!\n", emsg);
  83     result = GNUNET_OK;
  84   }
  85   GNUNET_SCHEDULER_shutdown ();
  86 }
  87
  88
  89
  90 /**
  91  * Signature of a main function for a testcase.
  92  *
  93  * @param cls closure
  94  * @param h the run handle
  95  * @param num_peers number of peers in 'peers'
  96  * @param peers_ handle to peers run in the testbed
  97  * @param links_succeeded the number of overlay link connection attempts that
  98  *          succeeded
  99  * @param links_failed the number of overlay link connection attempts that
 100  *          failed
 101  */
 102 static void
 103 test_master (void *cls,
 104              struct GNUNET_TESTBED_RunHandle *h,
 105              unsigned int num_peers,
 106              struct GNUNET_TESTBED_Peer **peers_,
 107              unsigned int links_succeeded,
 108              unsigned int links_failed)
 109 {
 110   GNUNET_assert (NULL == cls);
 111   if (NULL == peers_)
 112   {
 113     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failing test due to timeout\n");
 114     GNUNET_SCHEDULER_shutdown ();
 115     return;
 116   }
 117   GNUNET_assert (NUM_PEERS == num_peers);
 118   op = GNUNET_TESTBED_overlay_connect (NULL,
 119                                        &overlay_connect_status,
 120                                        NULL,
 121                                        peers_[0],
 122                                        peers_[2]);
 123   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
 124                                   GNUNET_TIME_UNIT_SECONDS,
 125                                   60),
 126                                 &do_shutdown, NULL);
 127 }
 128
 129
 130 #ifndef PATH_MAX
 131 /**
 132  * Assumed maximum path length (for the log file name).
 133  */
 134 #define PATH_MAX 4096
 135 #endif
 136
 137
 138 /**
 139  * Main function
 140  */
 141 int
 142 main (int argc, char **argv)
 143 {
 144   struct GNUNET_CONFIGURATION_Handle *cfg;
 145   char pwd[PATH_MAX];
 146   char *dbfile;
 147   uint64_t event_mask;
 148
 149   result = GNUNET_SYSERR;
 150   event_mask = 0;
 151   cfg = GNUNET_CONFIGURATION_create ();
 152   GNUNET_assert (GNUNET_YES ==
 153                  GNUNET_CONFIGURATION_parse (cfg,
 154                                              "test_testbed_underlay.conf.in"));
 155   if (NULL == getcwd (pwd, PATH_MAX))
 156     return 1;
 157   GNUNET_assert (0 < GNUNET_asprintf (&dbfile, "%s/%s", pwd,
 158                                       "test-underlay.sqlite"));
 159   GNUNET_CONFIGURATION_set_value_string (cfg, "TESTBED-UNDERLAY", "DBFILE",
 160                                          dbfile);
 161   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write
 162                    (cfg, "test_testbed_underlay.conf"));
 163   GNUNET_CONFIGURATION_destroy (cfg);
 164   cfg = NULL;
 165   GNUNET_free (dbfile);
 166   dbfile = NULL;
 167   (void) GNUNET_TESTBED_test_run ("test_testbed_underlay",
 168                                   "test_testbed_underlay.conf", NUM_PEERS,
 169                                   event_mask, NULL, NULL,
 170                                   &test_master, NULL);
 171   (void) unlink ("test_testbed_underlay.conf");
 172   if (GNUNET_OK != result)
 173     return 1;
 174   return 0;
 175 }