src/nat/test_stun.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009, 2015 Christian Grothoff (and other contributing authors)
   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 /**
  22  * Testcase for STUN server resolution
  23  *
  24  * @file nat/test_stun.c
  25  * @brief Testcase for STUN library
  26  * @author Bruno Souza Cabral
  27
  28  *
  29  */
  30
  31
  32 #include "platform.h"
  33 #include "gnunet_util_lib.h"
  34 #include "gnunet_program_lib.h"
  35 #include "gnunet_scheduler_lib.h"
  36 #include "gnunet_nat_lib.h"
  37
  38
  39
  40 #define LOG(kind,...) GNUNET_log_from (kind, "test-stun", __VA_ARGS__)
  41
  42 /**
  43  * Time to wait before stopping NAT, in seconds
  44  */
  45 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  46
  47
  48 /**
  49  * The port the test service is running on (default 7895)
  50  */
  51 static unsigned long port = 7895;
  52 static int ret = 1;
  53
  54 static char *stun_server = "stun.ekiga.net";
  55 static int stun_port = 3478;
  56
  57 /**
  58  * The listen socket of the service for IPv4
  59  */
  60 static struct GNUNET_NETWORK_Handle *lsock4;
  61
  62
  63 /**
  64  * The listen task ID for IPv4
  65  */
  66 static struct GNUNET_SCHEDULER_Task * ltask4;
  67
  68
  69
  70
  71 static void
  72 print_answer(struct sockaddr_in* answer)
  73 {
  74     GNUNET_log (GNUNET_ERROR_TYPE_INFO,"External IP is: %s , with port %d\n", inet_ntoa(answer->sin_addr), ntohs(answer->sin_port));
  75 }
  76
  77
  78 /**
  79  * Activity on our incoming socket.  Read data from the
  80  * incoming connection.
  81  *
  82  * @param cls
  83  * @param tc scheduler context
  84  */
  85 static void
  86 do_udp_read (void *cls,
  87              const struct GNUNET_SCHEDULER_TaskContext *tc)
  88 {
  89     //struct GNUNET_NAT_Test *tst = cls;
  90         unsigned char reply_buf[1024];
  91         ssize_t rlen;
  92         struct sockaddr_in answer;
  93
  94     if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
  95       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
  96                                    lsock4)))
  97         {
  98                 rlen = GNUNET_NETWORK_socket_recv (lsock4, reply_buf, sizeof (reply_buf));
  99
 100
 101                 //Lets handle the packet
 102                 memset(&answer, 0, sizeof(struct sockaddr_in));
 103         GNUNET_NAT_stun_handle_packet(reply_buf,rlen, &answer);
 104
 105                 //Print the answer
 106                 ret = 0;
 107                 print_answer(&answer);
 108
 109         //Destroy the connection
 110         GNUNET_NETWORK_socket_close(lsock4);
 111
 112         }
 113
 114
 115 }
 116
 117
 118 /**
 119  * Create an IPv4 listen socket bound to our port.
 120  *
 121  * @return NULL on error
 122  */
 123 static struct GNUNET_NETWORK_Handle *
 124 bind_v4 ()
 125 {
 126     struct GNUNET_NETWORK_Handle *ls;
 127     struct sockaddr_in sa4;
 128     int eno;
 129
 130     memset (&sa4, 0, sizeof (sa4));
 131     sa4.sin_family = AF_INET;
 132     sa4.sin_port = htons (port);
 133 #if HAVE_SOCKADDR_IN_SIN_LEN
 134     sa4.sin_len = sizeof (sa4);
 135 #endif
 136     ls = GNUNET_NETWORK_socket_create (AF_INET,
 137                                        SOCK_DGRAM,
 138                                        0);
 139     if (NULL == ls)
 140         return NULL;
 141     if (GNUNET_OK !=
 142             GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
 143                                         sizeof (sa4)))
 144     {
 145         eno = errno;
 146         GNUNET_NETWORK_socket_close (ls);
 147         errno = eno;
 148         return NULL;
 149     }
 150     return ls;
 151 }
 152
 153 /**
 154  * Function that terminates the test.
 155  */
 156 static void
 157 stop ()
 158 {
 159     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n");
 160
 161     //Clean task
 162     if(NULL != ltask4)
 163         GNUNET_SCHEDULER_cancel (ltask4);
 164
 165     //Clean socket
 166     if(NULL != ltask4)
 167         GNUNET_NETWORK_socket_close (lsock4);
 168
 169 }
 170
 171
 172 static void request_callback(void *cls,
 173 enum GNUNET_NAT_StatusCode result)
 174 {
 175     ret = result;
 176     stop();
 177 };
 178
 179
 180 /**
 181  * Main function run with scheduler.
 182  */
 183 static void
 184 run (void *cls, char *const *args, const char *cfgfile,
 185      const struct GNUNET_CONFIGURATION_Handle *cfg)
 186 {
 187
 188
 189     //Lets create the socket
 190     lsock4 = bind_v4 ();
 191     if (NULL == lsock4)
 192     {
 193         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 194         GNUNET_SCHEDULER_shutdown ();
 195         return;
 196     }
 197     else
 198     {
 199         //Lets call our function now when it accepts
 200         ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 201                                                 lsock4, &do_udp_read, NULL);
 202         /* So you read once and what will happen if you get an irregular message? Repeat and add timeout */
 203
 204     }
 205
 206     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 207                 "Service listens on port %u\n",
 208                 port);
 209     GNUNET_NAT_stun_make_request(stun_server, stun_port, lsock4, &request_callback, NULL);
 210
 211     //GNUNET_SCHEDULER_add_delayed (TIMEOUT, &stop, NULL);
 212
 213 }
 214
 215
 216 int
 217 main (int argc, char *const argv[])
 218 {
 219     struct GNUNET_GETOPT_CommandLineOption options[] = {
 220         GNUNET_GETOPT_OPTION_END
 221     };
 222
 223     char *const argv_prog[] = {
 224         "test-stun",
 225         "-c",
 226         "test_stun.conf",
 227         NULL
 228     };
 229     GNUNET_log_setup ("test-stun",
 230                       "WARNING",
 231                       NULL);
 232
 233     /* Lets start resolver */
 234     char *fn;
 235     struct GNUNET_OS_Process *proc;
 236
 237     fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
 238     proc = GNUNET_OS_start_process (GNUNET_YES,
 239                                     GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
 240                                     NULL, NULL, NULL,
 241                                     fn,
 242                                     "gnunet-service-resolver",
 243                                     "-c", "test_stun.conf", NULL);
 244
 245     if (NULL != proc)
 246     {
 247       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "This test was unable to start gnunet-service-resolver, and it is required to run ...\n");
 248       exit(1);
 249     }
 250
 251     GNUNET_PROGRAM_run (3, argv_prog, "test-stun", "nohelp", options, &run, NULL);
 252
 253     /* Now kill the resolver */
 254     if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
 255     {
 256         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 257     }
 258     GNUNET_OS_process_wait (proc);
 259     GNUNET_OS_process_destroy (proc);
 260     proc = NULL;
 261     GNUNET_free (fn);
 262
 263
 264         return ret;
 265 }
 266
 267 /* end of test_stun.c */