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