src/gns/test_gns_ns_lookup.c

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