src/util/test_socks.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2015, 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_socks.c
  22  * @brief tests for socks.c
  23  */
  24 #include "platform.h"
  25 #include "gnunet_util_lib.h"
  26
  27
  28 #define PORT 35124
  29
  30 #define MYNAME "test_sockst"
  31
  32 static struct GNUNET_MQ_Handle *mq;
  33
  34 static struct GNUNET_SERVER_Handle *server;
  35
  36 static struct GNUNET_CONFIGURATION_Handle *cfg;
  37
  38 #define MY_TYPE 130
  39
  40 struct CopyContext
  41 {
  42   struct GNUNET_SERVER_Client *client;
  43   struct GNUNET_MessageHeader *cpy;
  44 };
  45
  46 static size_t
  47 copy_msg (void *cls, size_t size, void *buf)
  48 {
  49   struct CopyContext *ctx = cls;
  50   struct GNUNET_MessageHeader *cpy = ctx->cpy;
  51
  52   GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size));
  53   GNUNET_assert (size >= ntohs (cpy->size));
  54   GNUNET_memcpy (buf, cpy, ntohs (cpy->size));
  55   GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK);
  56   GNUNET_free (cpy);
  57   GNUNET_free (ctx);
  58   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message bounced back to client\n");
  59   return sizeof (struct GNUNET_MessageHeader);
  60 }
  61
  62
  63 /**
  64  * Callback that just bounces the message back to the sender.
  65  */
  66 static void
  67 echo_cb (void *cls, struct GNUNET_SERVER_Client *client,
  68          const struct GNUNET_MessageHeader *message)
  69 {
  70   struct CopyContext *cc;
  71   struct GNUNET_MessageHeader *cpy;
  72
  73   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  74               "Receiving message from client, bouncing back\n");
  75   GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size));
  76   cc = GNUNET_new (struct CopyContext);
  77   cc->client = client;
  78   cpy = GNUNET_malloc (ntohs (message->size));
  79   GNUNET_memcpy (cpy, message, ntohs (message->size));
  80   cc->cpy = cpy;
  81   GNUNET_assert (NULL !=
  82                  GNUNET_SERVER_notify_transmit_ready (client,
  83                                                       ntohs (message->size),
  84                                                       GNUNET_TIME_UNIT_SECONDS,
  85                                                       &copy_msg, cc));
  86 }
  87
  88
  89 static struct GNUNET_SERVER_MessageHandler handlers[] = {
  90   {&echo_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
  91   {NULL, NULL, 0, 0}
  92 };
  93
  94
  95 static void
  96 handle_bounce (void *cls,
  97                const struct GNUNET_MessageHeader *got)
  98 {
  99   int *ok = cls;
 100
 101   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 102               "Receiving bounce, checking content\n");
 103   GNUNET_assert (NULL != got);
 104   GNUNET_MQ_destroy (mq);
 105   mq = NULL;
 106   GNUNET_SERVER_destroy (server);
 107   server = NULL;
 108   *ok = 0;
 109 }
 110
 111
 112 /**
 113  * Generic error handler, called with the appropriate error code and
 114  * the same closure specified at the creation of the message queue.
 115  * Not every message queue implementation supports an error handler.
 116  *
 117  * @param cls closure with the `struct GNUNET_STATISTICS_Handle *`
 118  * @param error error code
 119  */
 120 static void
 121 mq_error_handler (void *cls,
 122                   enum GNUNET_MQ_Error error)
 123 {
 124   GNUNET_assert (0); /* should never happen */
 125 }
 126
 127
 128 static void
 129 task (void *cls)
 130 {
 131   struct sockaddr_in sa;
 132   struct sockaddr *sap[2];
 133   socklen_t slens[2];
 134   struct GNUNET_MQ_Envelope *env;
 135   struct GNUNET_MessageHeader *msg;
 136   struct GNUNET_MQ_MessageHandler chandlers[] = {
 137     GNUNET_MQ_hd_fixed_size (bounce,
 138                              MY_TYPE,
 139                              struct GNUNET_MessageHeader,
 140                              cls),
 141     GNUNET_MQ_handler_end ()
 142   };
 143
 144   /* test IPC between client and server */
 145   sap[0] = (struct sockaddr *) &sa;
 146   slens[0] = sizeof (sa);
 147   sap[1] = NULL;
 148   slens[1] = 0;
 149   memset (&sa, 0, sizeof (sa));
 150 #if HAVE_SOCKADDR_IN_SIN_LEN
 151   sa.sin_len = sizeof (sa);
 152 #endif
 153   sa.sin_family = AF_INET;
 154   sa.sin_port = htons (PORT);
 155   server =
 156       GNUNET_SERVER_create (NULL, NULL, sap, slens,
 157                             GNUNET_TIME_relative_multiply
 158                             (GNUNET_TIME_UNIT_MILLISECONDS, 10000), GNUNET_NO);
 159   GNUNET_assert (server != NULL);
 160   handlers[0].callback_cls = cls;
 161   handlers[1].callback_cls = cls;
 162   GNUNET_SERVER_add_handlers (server, handlers);
 163   mq = GNUNET_CLIENT_connect (cfg,
 164                               MYNAME,
 165                               chandlers,
 166                               &mq_error_handler,
 167                               NULL);
 168   GNUNET_assert (NULL != mq);
 169   env = GNUNET_MQ_msg (msg,
 170                        MY_TYPE);
 171   GNUNET_MQ_send (mq,
 172                   env);
 173 }
 174
 175
 176 int
 177 main (int argc, char *argv[])
 178 {
 179   int ok;
 180   int status;
 181   const char *socksport = "1081";
 182
 183   GNUNET_log_setup ("test_client",
 184                     "WARNING",
 185                     NULL);
 186
 187   pid_t pid = fork();
 188   GNUNET_assert (pid >= 0);
 189   if (pid == 0)
 190   {
 191     execlp ("ssh",
 192             "ssh","-D",socksport,
 193             "-o","BatchMode yes",
 194             "-o","UserKnownHostsFile /tmp/gnunet_test_socks_ssh_garbage",
 195             "-o","StrictHostKeyChecking no",
 196             "127.0.0.1","-N",(char*)NULL);
 197     perror ("execlp (\"ssh\",\"ssh\",...,\"-D\",\"1081\",\"127.0.0.1\",\"-N\") ");
 198     printf (""
 199 "Please ensure you have ssh installed and have sshd installed and running :\n"
 200 "\tsudo apt-get install openssh-client openssh-server\n"
 201 "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
 202 "to localhost.  Please either run  make check  from an unproxied user, or else\n"
 203 "add these lines to the beginning of your ~/.ssh/config file :"
 204 "\tHost 127.0.0.1 localhost\n"
 205 "\t  CheckHostIP no\n"
 206 "\t  Protocol 2\n"
 207 "\t  ProxyCommand nc 127.0.0.1 22\n");
 208     kill (getppid(), SIGALRM);
 209     return 1;
 210   }
 211   if (0 != sleep (1))
 212   {
 213     /* sleep interrupted, likely SIGALRM, failure to
 214        launch child, terminate */
 215     printf (""
 216 "Please ensure you have ssh installed and have sshd installed and running :\n"
 217 "\tsudo apt-get install openssh-client openssh-server\n"
 218 "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
 219 "to localhost.  Please either run  make check  from an unproxied user, or else\n"
 220 "add these lines to the beginning of your ~/.ssh/config file :"
 221 "\tHost 127.0.0.1 localhost\n"
 222 "\t  CheckHostIP no\n"
 223 "\t  Protocol 2\n"
 224 "\t  ProxyCommand nc 127.0.0.1 22\n");
 225     return 77;
 226   }
 227   /* check if child exec()ed but died */
 228   if (0 != waitpid (pid, &status, WNOHANG))
 229   {
 230     printf (""
 231 "If you run Tor as a network proxy then Tor might prevent ssh from connecting\n"
 232 "to localhost.  Please either run  make check  from an unproxied user, or else\n"
 233 "add these lines to the beginning of your ~/.ssh/config file :"
 234 "\tHost 127.0.0.1 localhost\n"
 235 "\t  CheckHostIP no\n"
 236 "\t  Protocol 2\n"
 237 "\t  ProxyCommand nc 127.0.0.1 22\n");
 238     return 77;
 239   }
 240
 241   cfg = GNUNET_CONFIGURATION_create ();
 242   GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "SOCKSHOST", "127.0.0.1");
 243   GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "SOCKSPORT", socksport);
 244   GNUNET_CONFIGURATION_set_value_number (cfg, MYNAME, "PORT", PORT);
 245   GNUNET_CONFIGURATION_set_value_string (cfg, MYNAME, "HOSTNAME", "127.0.0.1");
 246   ok = 1;
 247   GNUNET_SCHEDULER_run (&task, &ok);
 248   GNUNET_CONFIGURATION_destroy (cfg);
 249
 250   GNUNET_break (0 == kill (pid, SIGTERM));
 251   GNUNET_break (pid == waitpid (pid, &status, 0));
 252   return ok;
 253 }
 254
 255 /* end of test_socks.c */