src/gns/test_gns_ns_lookup.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file gns/test_gns_ns_lookup.c
  22  * @brief base testcase for testing a local GNS record lookup through NS
  23  *
  24  */
  25 #include "platform.h"
  26 #include "gnunet_testing_lib.h"
  27 #include "gnunet_core_service.h"
  28 #include "block_dns.h"
  29 #include "gnunet_signatures.h"
  30 #include "gnunet_namestore_service.h"
  31 #include "gnunet_resolver_service.h"
  32 #include "gnunet_dnsparser_lib.h"
  33 #include "gnunet_gns_service.h"
  34
  35 /* Timeout for entire testcase */
  36 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20)
  37
  38 /* If number of peers not in config file, use this number */
  39 #define DEFAULT_NUM_PEERS 2
  40
  41 /* test records to resolve */
  42 #define TEST_DOMAIN "www.homepage.gnunet"
  43 #define TEST_DOMAIN_ALT "homepage.gnunet"
  44 #define TEST_DOMAIN_ALT2 "uk.homepage.gnunet"
  45 #define TEST_IP_ALT2 "81.187.252.184"
  46 #define TEST_IP "131.159.74.67"
  47 #define TEST_IP_NS "216.69.185.1" //ns01.domaincontrol.com
  48 #define TEST_RECORD_NAME "homepage"
  49 #define TEST_RECORD_NS "gnunet.org"
  50
  51 /* Globals */
  52
  53 /**
  54  * Directory to store temp data in, defined in config file
  55  */
  56 static char *test_directory;
  57
  58 static struct GNUNET_TESTING_PeerGroup *pg;
  59
  60 /* Task handle to use to schedule test failure */
  61 GNUNET_SCHEDULER_TaskIdentifier die_task;
  62
  63 /* Global return value (0 for success, anything else for failure) */
  64 static int ok;
  65
  66 static int resolver_working;
  67
  68 static struct GNUNET_NAMESTORE_Handle *namestore_handle;
  69
  70 static struct GNUNET_GNS_Handle *gns_handle;
  71
  72 static struct GNUNET_RESOLVER_RequestHandle *resolver_handle;
  73
  74 const struct GNUNET_CONFIGURATION_Handle *cfg;
  75
  76 /**
  77  * Check whether peers successfully shut down.
  78  */
  79 void
  80 shutdown_callback (void *cls, const char *emsg)
  81 {
  82   if (emsg != NULL)
  83   {
  84     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error on shutdown! ret=%d\n", ok);
  85     if (ok == 0)
  86       ok = 2;
  87   }
  88
  89   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "done(ret=%d)!\n", ok);
  90 }
  91
  92 static void
  93 on_lookup_result_alt2 (void *cls, uint32_t rd_count,
  94                  const struct GNUNET_NAMESTORE_RecordData *rd)
  95 {
  96   struct in_addr a;
  97   int i;
  98   char* addr;
  99
 100   if (rd_count == 0)
 101   {
 102     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 103                 "Lookup failed\n");
 104     ok = 2;
 105   }
 106   else
 107   {
 108     ok = 1;
 109     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 110     for (i=0; i<rd_count; i++)
 111     {
 112       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 113       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 114       {
 115         memcpy(&a, rd[i].data, sizeof(a));
 116         addr = inet_ntoa(a);
 117         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 118         if (0 == strcmp(addr, TEST_IP_ALT2))
 119         {
 120           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 121                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 122           ok = 0;
 123         }
 124       }
 125       else
 126       {
 127         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 128       }
 129     }
 130   }
 131   GNUNET_GNS_disconnect(gns_handle);
 132   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n");
 133   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 134 }
 135
 136 static void
 137 on_lookup_result_alt (void *cls, uint32_t rd_count,
 138                  const struct GNUNET_NAMESTORE_RecordData *rd)
 139 {
 140   struct in_addr a;
 141   int i;
 142   char* addr;
 143
 144   if (rd_count == 0)
 145   {
 146     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 147                 "Lookup failed\n");
 148     ok = 2;
 149   }
 150   else
 151   {
 152     ok = 1;
 153     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 154     for (i=0; i<rd_count; i++)
 155     {
 156       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 157       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 158       {
 159         memcpy(&a, rd[i].data, sizeof(a));
 160         addr = inet_ntoa(a);
 161         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 162         if (0 == strcmp(addr, TEST_IP))
 163         {
 164           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 165                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 166           ok = 0;
 167         }
 168       }
 169       else
 170       {
 171         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 172       }
 173     }
 174   }
 175
 176   GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN_ALT2, GNUNET_GNS_RECORD_A,
 177                     GNUNET_YES,
 178                     NULL,
 179                     &on_lookup_result_alt2, TEST_DOMAIN_ALT2);
 180 }
 181
 182 static void
 183 on_lookup_result(void *cls, uint32_t rd_count,
 184                  const struct GNUNET_NAMESTORE_RecordData *rd)
 185 {
 186   struct in_addr a;
 187   int i;
 188   char* addr;
 189
 190   if (rd_count == 0)
 191   {
 192     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 193                 "Lookup failed\n");
 194     ok = 2;
 195   }
 196   else
 197   {
 198     ok = 1;
 199     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 200     for (i=0; i<rd_count; i++)
 201     {
 202       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 203       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 204       {
 205         memcpy(&a, rd[i].data, sizeof(a));
 206         addr = inet_ntoa(a);
 207         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 208         if (0 == strcmp(addr, TEST_IP))
 209         {
 210           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 211                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 212           ok = 0;
 213         }
 214       }
 215       else
 216       {
 217         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 218       }
 219     }
 220   }
 221
 222   GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN_ALT, GNUNET_GNS_RECORD_A,
 223                     GNUNET_YES,
 224                     NULL,
 225                     &on_lookup_result_alt, TEST_DOMAIN_ALT);
 226 }
 227
 228
 229 static void
 230 start_lookup (void)
 231 {
 232
 233
 234   GNUNET_NAMESTORE_disconnect (namestore_handle);
 235   gns_handle = GNUNET_GNS_connect (cfg);
 236
 237   if (NULL == gns_handle)
 238   {
 239     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 240                 "Failed to connect to GNS!\n");
 241     ok = 2;
 242   }
 243
 244   GNUNET_GNS_lookup (gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_A,
 245                      GNUNET_YES,
 246                      NULL,
 247                      &on_lookup_result, TEST_DOMAIN);
 248 }
 249
 250
 251 static void
 252 handle_dns_test (void *cls,
 253                  const struct sockaddr *addr,
 254                  socklen_t addrlen)
 255 {
 256   struct sockaddr_in* sai;
 257
 258   if (NULL == addr)
 259   {
 260     /* end of results */
 261     if (GNUNET_YES != resolver_working)
 262     {
 263       ok = 0;
 264       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 265                   "System resolver not working. Test inconclusive!\n");
 266       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n");
 267       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 268       return;
 269     }
 270     start_lookup ();
 271     return;
 272   }
 273
 274   if (addrlen == sizeof (struct sockaddr_in))
 275   {
 276     sai = (struct sockaddr_in*) addr;
 277     if (0 == strcmp (TEST_IP, inet_ntoa (sai->sin_addr)))
 278       resolver_working = GNUNET_YES;
 279   }
 280 }
 281
 282
 283
 284
 285 /**
 286  * Function scheduled to be run on the successful start of services
 287  * tries to look up the dns record for TEST_DOMAIN
 288  */
 289 static void
 290 commence_testing (void *cls, int32_t success, const char *emsg)
 291 {
 292
 293   resolver_working = GNUNET_NO;
 294
 295   GNUNET_RESOLVER_connect (cfg);
 296   resolver_handle = GNUNET_RESOLVER_ip_get (TEST_RECORD_NS,
 297                                             AF_INET,
 298                                             TIMEOUT,
 299                                             &handle_dns_test,
 300                                             NULL);
 301 }
 302
 303
 304 /**
 305  * Continuation for the GNUNET_DHT_get_stop call, so that we don't shut
 306  * down the peers without freeing memory associated with GET request.
 307  */
 308 static void
 309 end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 310 {
 311   if (resolver_handle != NULL)
 312     GNUNET_RESOLVER_request_cancel (resolver_handle);
 313   if (pg != NULL)
 314     GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 315   GNUNET_SCHEDULER_cancel (die_task);
 316 }
 317
 318 /**
 319  * Check if the get_handle is being used, if so stop the request.  Either
 320  * way, schedule the end_badly_cont function which actually shuts down the
 321  * test.
 322  */
 323 static void
 324 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 325 {
 326   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failing test with error: `%s'!\n",
 327               (char *) cls);
 328   GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
 329   ok = 1;
 330 }
 331
 332 static void
 333 do_lookup(void *cls, const struct GNUNET_PeerIdentity *id,
 334           const struct GNUNET_CONFIGURATION_Handle *_cfg,
 335           struct GNUNET_TESTING_Daemon *d, const char *emsg)
 336 {
 337   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
 338   struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
 339   char* alice_keyfile;
 340
 341   cfg = _cfg;
 342
 343   GNUNET_SCHEDULER_cancel (die_task);
 344
 345   /* put records into namestore */
 346   namestore_handle = GNUNET_NAMESTORE_connect(cfg);
 347   if (NULL == namestore_handle)
 348   {
 349     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
 350     ok = -1;
 351     return;
 352   }
 353
 354   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
 355                                                           "ZONEKEY",
 356                                                           &alice_keyfile))
 357   {
 358     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
 359     ok = -1;
 360     return;
 361   }
 362
 363   alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
 364
 365   GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
 366
 367   GNUNET_free(alice_keyfile);
 368
 369   struct GNUNET_NAMESTORE_RecordData rd;
 370   char* ip = TEST_IP_NS;
 371   struct in_addr *ns = GNUNET_malloc(sizeof(struct in_addr));
 372   rd.expiration_time = UINT64_MAX;
 373   GNUNET_assert(1 == inet_pton (AF_INET, ip, ns));
 374   rd.data_size = sizeof(struct in_addr);
 375   rd.data = ns;
 376   rd.record_type = GNUNET_DNSPARSER_TYPE_A;
 377   rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
 378
 379
 380   GNUNET_NAMESTORE_record_create (namestore_handle,
 381                                   alice_key,
 382                                   TEST_RECORD_NAME,
 383                                   &rd,
 384                                   NULL,
 385                                   NULL);
 386
 387   rd.data_size = strlen (TEST_RECORD_NS);
 388   rd.data = TEST_RECORD_NS;
 389   rd.record_type = GNUNET_GNS_RECORD_NS;
 390
 391   GNUNET_NAMESTORE_record_create (namestore_handle,
 392                                   alice_key,
 393                                   TEST_RECORD_NAME,
 394                                   &rd,
 395                                   &commence_testing,
 396                                   NULL);
 397   GNUNET_CRYPTO_rsa_key_free(alice_key);
 398   GNUNET_free(ns);
 399
 400 }
 401
 402 static void
 403 run (void *cls, char *const *args, const char *cfgfile,
 404      const struct GNUNET_CONFIGURATION_Handle *c)
 405 {
 406   cfg = c;
 407    /* Get path from configuration file */
 408   if (GNUNET_YES !=
 409       GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
 410                                              &test_directory))
 411   {
 412     ok = 404;
 413     return;
 414   }
 415
 416
 417   /* Set up a task to end testing if peer start fails */
 418   die_task =
 419       GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly,
 420                                     "didn't start all daemons in reasonable amount of time!!!");
 421
 422   /* Start alice */
 423   pg = GNUNET_TESTING_daemons_start(cfg, 1, 1, 1, TIMEOUT,
 424                                     NULL, NULL, &do_lookup, NULL,
 425                                     NULL, NULL, NULL);
 426 }
 427
 428 static int
 429 check ()
 430 {
 431   int ret;
 432
 433   /* Arguments for GNUNET_PROGRAM_run */
 434   char *const argv[] = { "test-gns-ns-lookup", /* Name to give running binary */
 435     "-c",
 436     "test_gns_simple_lookup.conf",       /* Config file to use */
 437     NULL
 438   };
 439   struct GNUNET_GETOPT_CommandLineOption options[] = {
 440     GNUNET_GETOPT_OPTION_END
 441   };
 442   /* Run the run function as a new program */
 443   ret =
 444       GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
 445                           "test-gns-ns-lookup", "nohelp", options, &run,
 446                           &ok);
 447   if (ret != GNUNET_OK)
 448   {
 449     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 450                 "`test-gns-simple-lookup': Failed with error code %d\n", ret);
 451   }
 452   return ok;
 453 }
 454
 455 int
 456 main (int argc, char *argv[])
 457 {
 458   int ret;
 459
 460   GNUNET_log_setup ("test-gns-simple-lookup",
 461                     "WARNING",
 462                     NULL);
 463   ret = check ();
 464   /**
 465    * Need to remove base directory, subdirectories taken care
 466    * of by the testing framework.
 467    */
 468   return ret;
 469 }
 470
 471 /* end of test_gns_twopeer.c */