src/gns/test_gns_max_queries.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_max_queries.c
  22  * @brief base testcase for testing GNS background queries
  23  * in particular query replacement and clean shutdown
  24  */
  25 #include "platform.h"
  26 #include "gnunet_testing_lib.h"
  27 #include "gnunet_core_service.h"
  28 #include "block_dns.h"
  29 #include "gns.h"
  30 #include "gnunet_signatures.h"
  31 #include "gnunet_namestore_service.h"
  32 #include "gnunet_dnsparser_lib.h"
  33 #include "gnunet_gns_service.h"
  34
  35
  36 /* Timeout for entire testcase */
  37 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20)
  38
  39 /* test records to resolve */
  40 #define TEST_DOMAIN "www.gads"
  41 #define TEST_DOMAIN_NACK "doesnotexist.bob.gads"
  42 #define TEST_IP "127.0.0.1"
  43 #define TEST_RECORD_NAME "www"
  44 #define TEST_ADDITIONAL_LOOKUPS 5
  45 #define TEST_AUTHORITY_NAME "bob"
  46
  47 #define KEYFILE_BOB "../namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey"
  48
  49 /* Task handle to use to schedule test failure */
  50 static GNUNET_SCHEDULER_TaskIdentifier die_task;
  51
  52 /* Global return value (0 for success, anything else for failure) */
  53 static int ok;
  54
  55 static struct GNUNET_NAMESTORE_Handle *namestore_handle;
  56
  57 static struct GNUNET_GNS_Handle *gns_handle;
  58
  59 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  60
  61 static unsigned long long max_parallel_lookups;
  62
  63 static struct GNUNET_GNS_LookupRequest **requests;
  64
  65 static unsigned int num_requests;
  66
  67
  68 /**
  69  * Check if the get_handle is being used, if so stop the request.  Either
  70  * way, schedule the end_badly_cont function which actually shuts down the
  71  * test.
  72  */
  73 static void
  74 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  75 {
  76   unsigned int i;
  77
  78   for (i=0;i<num_requests;i++)
  79     if (NULL != requests[i])
  80       GNUNET_GNS_cancel_lookup_request (requests[i]);
  81   die_task = GNUNET_SCHEDULER_NO_TASK;
  82   if (NULL != gns_handle)
  83   {
  84     GNUNET_GNS_disconnect(gns_handle);
  85     gns_handle = NULL;
  86   }
  87   if (NULL != namestore_handle)
  88   {
  89     GNUNET_NAMESTORE_disconnect (namestore_handle);
  90     namestore_handle = NULL;
  91   }
  92   GNUNET_break (0);
  93   GNUNET_SCHEDULER_shutdown ();
  94   GNUNET_free (requests);
  95   ok = 1;
  96 }
  97
  98
  99 static void
 100 shutdown_task (void *cls,
 101                const struct GNUNET_SCHEDULER_TaskContext *tc)
 102 {
 103   unsigned int i;
 104
 105   if (GNUNET_SCHEDULER_NO_TASK != die_task)
 106   {
 107       GNUNET_SCHEDULER_cancel (die_task);
 108       die_task = GNUNET_SCHEDULER_NO_TASK;
 109   }
 110   for (i=0;i<num_requests;i++)
 111     if (NULL != requests[i])
 112       GNUNET_GNS_cancel_lookup_request (requests[i]);
 113   if (NULL != gns_handle)
 114   {
 115     GNUNET_GNS_disconnect (gns_handle);
 116     gns_handle = NULL;
 117   }
 118   if (NULL != namestore_handle)
 119   {
 120     GNUNET_NAMESTORE_disconnect (namestore_handle);
 121     namestore_handle = NULL;
 122   }
 123   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer!\n");
 124   GNUNET_SCHEDULER_shutdown ();
 125   GNUNET_free (requests);
 126 }
 127
 128
 129 static void
 130 on_lookup_result_dummy (void *cls, uint32_t rd_count,
 131                         const struct GNUNET_NAMESTORE_RecordData *rd)
 132 {
 133   struct GNUNET_GNS_LookupRequest **request = cls;
 134   static int replies = 0;
 135
 136   *request = NULL;
 137   if (GNUNET_SCHEDULER_NO_TASK != die_task)
 138   {
 139       GNUNET_SCHEDULER_cancel (die_task);
 140       die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 141   }
 142   if (rd_count != 0)
 143   {
 144     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 145                "Got %d results from dummy lookup! Wanted: 0\n",
 146                rd_count);
 147     ok = -1;
 148   }
 149   replies++;
 150   fprintf (stderr, ".");
 151 }
 152
 153
 154 static void
 155 on_lookup_result (void *cls, uint32_t rd_count,
 156                   const struct GNUNET_NAMESTORE_RecordData *rd)
 157 {
 158   struct in_addr a;
 159   int i;
 160   char* addr;
 161
 162   requests[max_parallel_lookups + TEST_ADDITIONAL_LOOKUPS] = NULL;
 163   if (GNUNET_SCHEDULER_NO_TASK != die_task)
 164   {
 165       GNUNET_SCHEDULER_cancel (die_task);
 166       die_task = GNUNET_SCHEDULER_NO_TASK;
 167   }
 168
 169   GNUNET_NAMESTORE_disconnect (namestore_handle);
 170   namestore_handle = NULL;
 171   fprintf (stderr, "\n");
 172   if (rd_count == 0)
 173   {
 174     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 175                 "Lookup failed, rp_filtering?\n");
 176     ok = 2;
 177   }
 178   else
 179   {
 180     ok = 1;
 181     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
 182     for (i=0; i<rd_count; i++)
 183     {
 184       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
 185       if (rd[i].record_type == GNUNET_GNS_RECORD_A)
 186       {
 187         memcpy(&a, rd[i].data, sizeof(a));
 188         addr = inet_ntoa(a);
 189         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "address: %s\n", addr);
 190         if (0 == strcmp(addr, TEST_IP))
 191         {
 192           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 193                     "%s correctly resolved to %s!\n", TEST_DOMAIN, addr);
 194           ok = 0;
 195         }
 196       }
 197       else
 198       {
 199         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No resolution!\n");
 200       }
 201     }
 202   }
 203   GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 204 }
 205
 206
 207 /**
 208  * Function scheduled to be run on the successful start of services
 209  * tries to look up the dns record for TEST_DOMAIN
 210  */
 211 static void
 212 commence_testing (void *cls, int32_t success, const char *emsg)
 213 {
 214   int i;
 215   char lookup_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
 216   struct GNUNET_GNS_LookupRequest *lr;
 217
 218   gns_handle = GNUNET_GNS_connect(cfg);
 219
 220   if (NULL == gns_handle)
 221   {
 222     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 223                 "Failed to connect to GNS!\n");
 224     ok = 2;
 225   }
 226
 227
 228   /* Now lookup some non existing records */
 229   for (i=0; i<max_parallel_lookups+TEST_ADDITIONAL_LOOKUPS; i++)
 230   {
 231     GNUNET_snprintf(lookup_name,
 232                     GNUNET_DNSPARSER_MAX_NAME_LENGTH,
 233                     "www.doesnotexist-%d.bob.gads", i);
 234     lr = GNUNET_GNS_lookup (gns_handle, lookup_name, GNUNET_GNS_RECORD_A,
 235                             GNUNET_NO,
 236                             NULL,
 237                             &on_lookup_result_dummy, &requests[num_requests]);
 238     requests[num_requests++] = lr;
 239   }
 240   lr = GNUNET_GNS_lookup (gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_A,
 241                           GNUNET_NO,
 242                           NULL,
 243                           &on_lookup_result, TEST_DOMAIN);
 244   requests[num_requests++] = lr;
 245   GNUNET_assert (num_requests == max_parallel_lookups + TEST_ADDITIONAL_LOOKUPS + 1);
 246 }
 247
 248
 249
 250 static void
 251 do_check (void *cls,
 252           const struct GNUNET_CONFIGURATION_Handle *ccfg,
 253           struct GNUNET_TESTING_Peer *peer)
 254 {
 255   struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded alice_pkey;
 256   struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded bob_pkey;
 257   struct GNUNET_CRYPTO_EccPrivateKey *alice_key;
 258   struct GNUNET_CRYPTO_EccPrivateKey *bob_key;
 259   char* alice_keyfile;
 260   struct GNUNET_CRYPTO_ShortHashCode bob_hash;
 261
 262   cfg = ccfg;
 263   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 264
 265
 266   /* put records into namestore */
 267   namestore_handle = GNUNET_NAMESTORE_connect(cfg);
 268   if (NULL == namestore_handle)
 269   {
 270     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
 271     GNUNET_SCHEDULER_shutdown ();
 272     return;
 273   }
 274
 275   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
 276                                                           "ZONEKEY",
 277                                                           &alice_keyfile))
 278   {
 279     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
 280     GNUNET_SCHEDULER_shutdown ();
 281     return;
 282   }
 283
 284   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "gns",
 285                                                           "MAX_PARALLEL_BACKGROUND_QUERIES",
 286                                                           &max_parallel_lookups))
 287   {
 288     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get max queries from cfg\n");
 289     GNUNET_SCHEDULER_shutdown ();
 290     GNUNET_free (alice_keyfile);
 291     return;
 292   }
 293   requests = GNUNET_malloc ((max_parallel_lookups + TEST_ADDITIONAL_LOOKUPS + 1) *
 294                             sizeof (struct GNUNET_GNS_LookupRequest *));
 295   alice_key = GNUNET_CRYPTO_ecc_key_create_from_file (alice_keyfile);
 296   bob_key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE_BOB);
 297
 298   GNUNET_CRYPTO_ecc_key_get_public (alice_key, &alice_pkey);
 299   GNUNET_CRYPTO_ecc_key_get_public (bob_key, &bob_pkey);
 300
 301   GNUNET_free(alice_keyfile);
 302
 303   struct GNUNET_NAMESTORE_RecordData rd;
 304   char* ip = TEST_IP;
 305   struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
 306   rd.expiration_time = UINT64_MAX;
 307   GNUNET_assert(1 == inet_pton (AF_INET, ip, web));
 308   rd.data_size = sizeof(struct in_addr);
 309   rd.data = web;
 310   rd.record_type = GNUNET_DNSPARSER_TYPE_A;
 311   rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
 312
 313   GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
 314                                             alice_key,
 315                                             TEST_RECORD_NAME,
 316                                             1, &rd,
 317                                             NULL,
 318                                             NULL);
 319
 320   GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
 321   rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
 322   rd.data = &bob_hash;
 323   rd.record_type = GNUNET_GNS_RECORD_PKEY;
 324
 325   GNUNET_NAMESTORE_record_put_by_authority (namestore_handle,
 326                                             alice_key,
 327                                             TEST_AUTHORITY_NAME,
 328                                             1, &rd,
 329                                             &commence_testing,
 330                                             NULL);
 331
 332   GNUNET_CRYPTO_ecc_key_free(alice_key);
 333   GNUNET_CRYPTO_ecc_key_free(bob_key);
 334   GNUNET_free(web);
 335
 336 }
 337
 338
 339 int
 340 main (int argc, char *argv[])
 341 {
 342   ok = 1;
 343
 344   GNUNET_log_setup ("test-gns-max-queries",
 345                     "WARNING",
 346                     NULL);
 347   GNUNET_TESTING_peer_run ("test-gns-max-queries", "test_gns_simple_lookup.conf", &do_check, NULL);
 348   return ok;
 349 }
 350
 351
 352 /* end of test_gns_simple_zkey_lookup.c */