src/util/test_server.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009, 2010, 2014, 2016 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file util/test_server.c
  22  * @brief tests for server.c
  23  */
  24 #include "platform.h"
  25 #include "gnunet_util_lib.h"
  26
  27 /**
  28  * TCP port to use for the server.
  29  */
  30 #define PORT 12435
  31
  32 /**
  33  * Timeout to use for operations.
  34  */
  35 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
  36
  37 /**
  38  * Test message type.
  39  */
  40 #define MY_TYPE 128
  41
  42 /**
  43  * Test message type.
  44  */
  45 #define MY_TYPE2 129
  46
  47 /**
  48  * Handle for the server.
  49  */
  50 static struct GNUNET_SERVER_Handle *server;
  51
  52 /**
  53  * Handle for the client.
  54  */
  55 static struct GNUNET_MQ_Handle *mq;
  56
  57 /**
  58  * Handle of the server for the client.
  59  */
  60 static struct GNUNET_SERVER_Client *argclient;
  61
  62 /**
  63  * Our configuration.
  64  */
  65 static struct GNUNET_CONFIGURATION_Handle *cfg;
  66
  67 /**
  68  * Number indiciating in which phase of the test we are.
  69  */
  70 static int ok;
  71
  72
  73 /**
  74  * Final task invoked to clean up.
  75  *
  76  * @param cls NULL
  77  */
  78 static void
  79 finish_up (void *cls)
  80 {
  81   GNUNET_assert (7 == ok);
  82   ok = 0;
  83   GNUNET_SERVER_destroy (server);
  84   GNUNET_MQ_destroy (mq);
  85   GNUNET_CONFIGURATION_destroy (cfg);
  86 }
  87
  88
  89 /**
  90  * The server has received the second message, initiate clean up.
  91  *
  92  * @param cls NULL
  93  * @param client client we got the message from
  94  * @param message the message
  95  */
  96 static void
  97 recv_fin_cb (void *cls,
  98              struct GNUNET_SERVER_Client *client,
  99              const struct GNUNET_MessageHeader *message)
 100 {
 101   GNUNET_assert (6 == ok);
 102   ok = 7;
 103   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 104   GNUNET_SCHEDULER_add_now (&finish_up, NULL);
 105 }
 106
 107
 108 /**
 109  * We have received the reply from the server, check that we are at
 110  * the right stage and queue the next message to the server.  Cleans
 111  * up #argclient.
 112  *
 113  * @param cls NULL
 114  * @param msg message we got from the server
 115  */
 116 static void
 117 handle_reply (void *cls,
 118               const struct GNUNET_MessageHeader *msg)
 119 {
 120   struct GNUNET_MQ_Envelope *env;
 121   struct GNUNET_MessageHeader *m;
 122
 123   GNUNET_assert (4 == ok);
 124   ok = 6;
 125   env = GNUNET_MQ_msg (m,
 126                        MY_TYPE2);
 127   GNUNET_MQ_send (mq,
 128                   env);
 129 }
 130
 131
 132 /**
 133  * Send a reply of type #MY_TYPE from the server to the client.
 134  * Checks that we are in the right phase and transmits the
 135  * reply.  Cleans up #argclient state.
 136  *
 137  * @param cls NULL
 138  * @param size number of bytes we are allowed to send
 139  * @param buf where to copy the reply
 140  * @return number of bytes written to @a buf
 141  */
 142 static size_t
 143 reply_msg (void *cls,
 144            size_t size,
 145            void *buf)
 146 {
 147   struct GNUNET_MessageHeader msg;
 148
 149   GNUNET_assert (3 == ok);
 150   ok = 4;
 151   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
 152   msg.type = htons (MY_TYPE);
 153   msg.size = htons (sizeof (struct GNUNET_MessageHeader));
 154   GNUNET_memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader));
 155   GNUNET_assert (NULL != argclient);
 156   GNUNET_SERVER_receive_done (argclient, GNUNET_OK);
 157   GNUNET_SERVER_client_drop (argclient);
 158   argclient = NULL;
 159   return sizeof (struct GNUNET_MessageHeader);
 160 }
 161
 162
 163 /**
 164  * Function called whenever the server receives a message of
 165  * type #MY_TYPE.  Checks that we are at the stage where
 166  * we expect the first message, then sends a reply.  Stores
 167  * the handle to the client in #argclient.
 168  *
 169  * @param cls NULL
 170  * @param client client that sent the message
 171  * @param message the message we received
 172  */
 173 static void
 174 recv_cb (void *cls,
 175          struct GNUNET_SERVER_Client *client,
 176          const struct GNUNET_MessageHeader *message)
 177 {
 178   GNUNET_assert (2 == ok);
 179   ok = 3;
 180   argclient = client;
 181   GNUNET_SERVER_client_keep (argclient);
 182   GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size));
 183   GNUNET_assert (MY_TYPE == ntohs (message->type));
 184   GNUNET_assert (NULL !=
 185                  GNUNET_SERVER_notify_transmit_ready (client,
 186                                                       ntohs (message->size),
 187                                                       TIMEOUT,
 188                                                       &reply_msg,
 189                                                       NULL));
 190 }
 191
 192
 193 /**
 194  * Message handlers for the server.
 195  */
 196 static struct GNUNET_SERVER_MessageHandler handlers[] = {
 197   {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
 198   {&recv_fin_cb, NULL, MY_TYPE2, sizeof (struct GNUNET_MessageHeader)},
 199   {NULL, NULL, 0, 0}
 200 };
 201
 202
 203 /**
 204  * Generic error handler, called with the appropriate error code and
 205  * the same closure specified at the creation of the message queue.
 206  * Not every message queue implementation supports an error handler.
 207  *
 208  * @param cls closure with the `struct GNUNET_STATISTICS_Handle *`
 209  * @param error error code
 210  */
 211 static void
 212 mq_error_handler (void *cls,
 213                   enum GNUNET_MQ_Error error)
 214 {
 215   GNUNET_assert (0); /* should never happen */
 216 }
 217
 218
 219 /**
 220  * First task run by the scheduler.  Initializes the server and
 221  * a client and asks for a transmission from the client to the
 222  * server.
 223  *
 224  * @param cls NULL
 225  */
 226 static void
 227 task (void *cls)
 228 {
 229   struct sockaddr_in sa;
 230   struct sockaddr *sap[2];
 231   socklen_t slens[2];
 232   struct GNUNET_MQ_Envelope *env;
 233   struct GNUNET_MessageHeader *msg;
 234   struct GNUNET_MQ_MessageHandler chandlers[] = {
 235     GNUNET_MQ_hd_fixed_size (reply,
 236                              MY_TYPE,
 237                              struct GNUNET_MessageHeader,
 238                              cls),
 239     GNUNET_MQ_handler_end ()
 240   };
 241
 242   sap[0] = (struct sockaddr *) &sa;
 243   slens[0] = sizeof (sa);
 244   sap[1] = NULL;
 245   slens[1] = 0;
 246   memset (&sa, 0, sizeof (sa));
 247 #if HAVE_SOCKADDR_IN_SIN_LEN
 248   sa.sin_len = sizeof (sa);
 249 #endif
 250   sa.sin_family = AF_INET;
 251   sa.sin_port = htons (PORT);
 252   server = GNUNET_SERVER_create (NULL, NULL,
 253                                  sap, slens,
 254                                  TIMEOUT, GNUNET_NO);
 255   GNUNET_assert (server != NULL);
 256   GNUNET_SERVER_add_handlers (server, handlers);
 257   cfg = GNUNET_CONFIGURATION_create ();
 258   GNUNET_CONFIGURATION_set_value_number (cfg,
 259                                          "test-server",
 260                                          "PORT",
 261                                          PORT);
 262   GNUNET_CONFIGURATION_set_value_string (cfg,
 263                                          "test-server",
 264                                          "HOSTNAME",
 265                                          "localhost");
 266   GNUNET_CONFIGURATION_set_value_string (cfg,
 267                                          "resolver",
 268                                          "HOSTNAME",
 269                                          "localhost");
 270   mq = GNUNET_CLIENT_connect (cfg,
 271                               "test-server",
 272                               chandlers,
 273                               &mq_error_handler,
 274                               NULL);
 275   GNUNET_assert (NULL != mq);
 276   ok = 2;
 277   env = GNUNET_MQ_msg (msg,
 278                        MY_TYPE);
 279   GNUNET_MQ_send (mq,
 280                   env);
 281 }
 282
 283
 284 /**
 285  * Runs the test.
 286  *
 287  * @param argc length of @a argv
 288  * @param argv command line arguments (ignored)
 289  * @return 0 on success, otherwise phase of failure
 290  */
 291 int
 292 main (int argc, char *argv[])
 293 {
 294   GNUNET_log_setup ("test_server",
 295                     "WARNING",
 296                     NULL);
 297   ok = 1;
 298   GNUNET_SCHEDULER_run (&task, &ok);
 299   return ok;
 300 }
 301
 302 /* end of test_server.c */