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-new.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 /* Task handle to use to schedule test failure */
  55 GNUNET_SCHEDULER_TaskIdentifier die_task;
  56
  57 /* Global return value (0 for success, anything else for failure) */
  58 static int ok;
  59
  60 static int resolver_working;
  61
  62 static struct GNUNET_NAMESTORE_Handle *namestore_handle;
  63
  64 static struct GNUNET_GNS_Handle *gns_handle;
  65
  66 static struct GNUNET_RESOLVER_RequestHandle *resolver_handle;
  67
  68 const struct GNUNET_CONFIGURATION_Handle *cfg;
  69
  70 /**
  71  * Check if the get_handle is being used, if so stop the request.  Either
  72  * way, schedule the end_badly_cont function which actually shuts down the
  73  * test.
  74  */
  75 static void
  76 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  77 {
  78   die_task = GNUNET_SCHEDULER_NO_TASK;
  79
  80   if (NULL != resolver_handle)
  81   {
  82     GNUNET_RESOLVER_request_cancel (resolver_handle);
  83     resolver_handle = NULL;
  84   }
  85
  86   if (NULL != gns_handle)
  87   {
  88     GNUNET_GNS_disconnect(gns_handle);
  89     gns_handle = NULL;
  90   }
  91
  92   if (NULL != namestore_handle)
  93   {
  94     GNUNET_NAMESTORE_disconnect (namestore_handle);
  95     namestore_handle = NULL;
  96   }
  97   GNUNET_break (0);
  98   GNUNET_SCHEDULER_shutdown ();
  99   ok = 1;
 100 }
 101
 102 static void
 103 end_badly_now ()
 104 {
 105   GNUNET_SCHEDULER_cancel (die_task);
 106   die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 107 }
 108
 109 static void
 110 on_lookup_result_alt2 (void *cls, uint32_t rd_count,
 111                  const struct GNUNET_NAMESTORE_RecordData *rd)
 112 {
 113   struct in_addr a;
 114   int i;
 115   char* addr;
 116
 117   if (GNUNET_SCHEDULER_NO_TASK != die_task)
 118   {
 119       GNUNET_SCHEDULER_cancel (die_task);
 120       die_task = GNUNET_SCHEDULER_NO_TASK;
 121   }
 122
 123   if (rd_count == 0)
 124   {
 125     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 126                 "Lookup failed\n");
 127     ok = 2;
 128   }
 129   else
 130   {
 131     ok = 1;
 132     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 133     for (i=0; i<rd_count; i++)
 134     {
 135       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 136       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 137       {
 138         memcpy(&a, rd[i].data, sizeof(a));
 139         addr = inet_ntoa(a);
 140         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 141         if (0 == strcmp(addr, TEST_IP_ALT2))
 142         {
 143           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 144                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 145           ok = 0;
 146         }
 147       }
 148       else
 149       {
 150         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 151       }
 152     }
 153   }
 154   GNUNET_GNS_disconnect(gns_handle);
 155   gns_handle = NULL;
 156   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer!\n");
 157   GNUNET_SCHEDULER_shutdown ();
 158 }
 159
 160 static void
 161 on_lookup_result_alt (void *cls, uint32_t rd_count,
 162                  const struct GNUNET_NAMESTORE_RecordData *rd)
 163 {
 164   struct in_addr a;
 165   int i;
 166   char* addr;
 167
 168   if (rd_count == 0)
 169   {
 170     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 171                 "Lookup failed\n");
 172     ok = 2;
 173   }
 174   else
 175   {
 176     ok = 1;
 177     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 178     for (i=0; i<rd_count; i++)
 179     {
 180       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 181       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 182       {
 183         memcpy(&a, rd[i].data, sizeof(a));
 184         addr = inet_ntoa(a);
 185         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 186         if (0 == strcmp(addr, TEST_IP))
 187         {
 188           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 189                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 190           ok = 0;
 191         }
 192       }
 193       else
 194       {
 195         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 196       }
 197     }
 198   }
 199
 200   GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN_ALT2, GNUNET_GNS_RECORD_A,
 201                     GNUNET_YES,
 202                     NULL,
 203                     &on_lookup_result_alt2, TEST_DOMAIN_ALT2);
 204 }
 205
 206 static void
 207 on_lookup_result(void *cls, uint32_t rd_count,
 208                  const struct GNUNET_NAMESTORE_RecordData *rd)
 209 {
 210   struct in_addr a;
 211   int i;
 212   char* addr;
 213
 214   if (rd_count == 0)
 215   {
 216     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 217                 "Lookup failed\n");
 218     ok = 2;
 219   }
 220   else
 221   {
 222     ok = 1;
 223     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 224     for (i=0; i<rd_count; i++)
 225     {
 226       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 227       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 228       {
 229         memcpy(&a, rd[i].data, sizeof(a));
 230         addr = inet_ntoa(a);
 231         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 232         if (0 == strcmp(addr, TEST_IP))
 233         {
 234           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 235                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 236           ok = 0;
 237         }
 238       }
 239       else
 240       {
 241         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 242       }
 243     }
 244   }
 245
 246   GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN_ALT, GNUNET_GNS_RECORD_A,
 247                     GNUNET_YES,
 248                     NULL,
 249                     &on_lookup_result_alt, TEST_DOMAIN_ALT);
 250 }
 251
 252
 253 static void
 254 start_lookup (void)
 255 {
 256   GNUNET_NAMESTORE_disconnect (namestore_handle);
 257   namestore_handle = NULL;
 258
 259   gns_handle = GNUNET_GNS_connect(cfg);
 260   if (NULL == gns_handle)
 261   {
 262     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 263                 "Failed to connect to GNS!\n");
 264     end_badly_now ();
 265     return;
 266   }
 267
 268   GNUNET_GNS_lookup (gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_A,
 269                      GNUNET_YES,
 270                      NULL,
 271                      &on_lookup_result, TEST_DOMAIN);
 272 }
 273
 274
 275 static void
 276 handle_dns_test (void *cls,
 277                  const struct sockaddr *addr,
 278                  socklen_t addrlen)
 279 {
 280   struct sockaddr_in* sai;
 281
 282   resolver_handle = NULL;
 283   if (NULL == addr)
 284   {
 285     /* end of results */
 286     if (GNUNET_YES != resolver_working)
 287     {
 288       ok = 0;
 289       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 290                   "System resolver not working. Test inconclusive!\n");
 291       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n");
 292       GNUNET_SCHEDULER_shutdown();
 293       return;
 294     }
 295     start_lookup ();
 296     return;
 297   }
 298
 299   if (addrlen == sizeof (struct sockaddr_in))
 300   {
 301     sai = (struct sockaddr_in*) addr;
 302     if (0 == strcmp (TEST_IP, inet_ntoa (sai->sin_addr)))
 303       resolver_working = GNUNET_YES;
 304   }
 305 }
 306
 307
 308
 309
 310 /**
 311  * Function scheduled to be run on the successful start of services
 312  * tries to look up the dns record for TEST_DOMAIN
 313  */
 314 static void
 315 commence_testing (void *cls, int32_t success, const char *emsg)
 316 {
 317   resolver_working = GNUNET_NO;
 318
 319   GNUNET_RESOLVER_connect (cfg);
 320   resolver_handle = GNUNET_RESOLVER_ip_get (TEST_RECORD_NS,
 321                                             AF_INET,
 322                                             TIMEOUT,
 323                                             &handle_dns_test,
 324                                             NULL);
 325 }
 326
 327 static void
 328 do_check (void *cls,
 329           const struct GNUNET_CONFIGURATION_Handle *ccfg,
 330           struct GNUNET_TESTING_Peer *peer)
 331 {
 332   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
 333   struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
 334   char* alice_keyfile;
 335
 336   cfg = ccfg;
 337   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 338
 339   /* put records into namestore */
 340   namestore_handle = GNUNET_NAMESTORE_connect(cfg);
 341   if (NULL == namestore_handle)
 342   {
 343     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
 344     end_badly_now ();
 345     return;
 346   }
 347
 348   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
 349                                                           "ZONEKEY",
 350                                                           &alice_keyfile))
 351   {
 352     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
 353     end_badly_now ();
 354     return;
 355   }
 356
 357   alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
 358
 359   GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
 360
 361   GNUNET_free(alice_keyfile);
 362
 363   struct GNUNET_NAMESTORE_RecordData rd;
 364   char* ip = TEST_IP_NS;
 365   struct in_addr *ns = GNUNET_malloc(sizeof(struct in_addr));
 366   rd.expiration_time = UINT64_MAX;
 367   GNUNET_assert(1 == inet_pton (AF_INET, ip, ns));
 368   rd.data_size = sizeof(struct in_addr);
 369   rd.data = ns;
 370   rd.record_type = GNUNET_DNSPARSER_TYPE_A;
 371   rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
 372
 373
 374   GNUNET_NAMESTORE_record_create (namestore_handle,
 375                                   alice_key,
 376                                   TEST_RECORD_NAME,
 377                                   &rd,
 378                                   NULL,
 379                                   NULL);
 380
 381   rd.data_size = strlen (TEST_RECORD_NS);
 382   rd.data = TEST_RECORD_NS;
 383   rd.record_type = GNUNET_GNS_RECORD_NS;
 384
 385   GNUNET_NAMESTORE_record_create (namestore_handle,
 386                                   alice_key,
 387                                   TEST_RECORD_NAME,
 388                                   &rd,
 389                                   &commence_testing,
 390                                   NULL);
 391   GNUNET_CRYPTO_rsa_key_free(alice_key);
 392   GNUNET_free(ns);
 393
 394 }
 395
 396 int
 397 main (int argc, char *argv[])
 398 {
 399   ok = 1;
 400
 401   GNUNET_log_setup ("test-gns-simple-ns-lookup",
 402 #if VERBOSE
 403                     "DEBUG",
 404 #else
 405                     "WARNING",
 406 #endif
 407                     NULL);
 408   GNUNET_TESTING_peer_run ("test-gns-simple-ns-lookup", "test_gns_simple_lookup.conf", &do_check, NULL);
 409   return ok;
 410 }
 411
 412 /* end of test_gns_simple_ns_lookup.c */