src/namestore/test_namestore_api_lookup_specific_type.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 namestore/test_namestore_api_lookup_sepecific_type.c
  22  * @brief testcase for namestore_api.c
  23  */
  24 #include "platform.h"
  25 #include "gnunet_common.h"
  26 #include "gnunet_namestore_service.h"
  27 #include "gnunet_testing_lib-new.h"
  28 #include "namestore.h"
  29 #include "gnunet_signatures.h"
  30
  31
  32 #define RECORDS 5
  33
  34 #define TEST_RECORD_TYPE 1234
  35
  36 #define TEST_RECORD_DATALEN 123
  37
  38 #define TEST_RECORD_DATA 'a'
  39
  40 #define TEST_RECORD_LOOKUP_TYPE_NOT_EXISTING 11111
  41
  42 #define TEST_RECORD_LOOKUP_TYPE_EXISTING 22222
  43
  44 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
  45
  46
  47 static struct GNUNET_NAMESTORE_Handle * nsh;
  48
  49 static GNUNET_SCHEDULER_TaskIdentifier endbadly_task;
  50
  51 static struct GNUNET_CRYPTO_RsaPrivateKey * privkey;
  52
  53 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pubkey;
  54
  55 static struct GNUNET_CRYPTO_RsaSignature *s_signature;
  56
  57 static struct GNUNET_CRYPTO_ShortHashCode s_zone;
  58
  59 static struct GNUNET_NAMESTORE_RecordData *s_rd;
  60
  61 static char *s_name;
  62
  63 static int res;
  64
  65
  66 /**
  67  * Re-establish the connection to the service.
  68  *
  69  * @param cls handle to use to re-connect.
  70  * @param tc scheduler context
  71  */
  72 static void
  73 endbadly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  74 {
  75   if (nsh != NULL)
  76     GNUNET_NAMESTORE_disconnect (nsh);
  77   nsh = NULL;
  78   if (privkey != NULL)
  79     GNUNET_CRYPTO_rsa_key_free (privkey);
  80   privkey = NULL;
  81   res = 1;
  82 }
  83
  84
  85 static void
  86 end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  87 {
  88   int c;
  89
  90   if (endbadly_task != GNUNET_SCHEDULER_NO_TASK)
  91   {
  92     GNUNET_SCHEDULER_cancel (endbadly_task);
  93     endbadly_task = GNUNET_SCHEDULER_NO_TASK;
  94   }
  95   for (c = 0; c < RECORDS; c++)
  96   {
  97     GNUNET_free_non_null((void *) s_rd[c].data);
  98   }
  99   GNUNET_free (s_rd);
 100
 101   if (privkey != NULL)
 102     GNUNET_CRYPTO_rsa_key_free (privkey);
 103   privkey = NULL;
 104   if (nsh != NULL)
 105     GNUNET_NAMESTORE_disconnect (nsh);
 106   nsh = NULL;
 107 }
 108
 109
 110 static void
 111 name_lookup_existing_record_type (void *cls,
 112                                   const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 113                                   struct GNUNET_TIME_Absolute expire,
 114                                   const char *n,
 115                                   unsigned int rd_count,
 116                                   const struct GNUNET_NAMESTORE_RecordData *rd,
 117                                   const struct GNUNET_CRYPTO_RsaSignature *signature)
 118 {
 119   int failed = GNUNET_NO;
 120
 121   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned %u records\n", rd_count);
 122
 123   if ((NULL == n) || (0 != memcmp(zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))))
 124   {
 125     GNUNET_break(0);
 126     failed = GNUNET_YES;
 127   }
 128   if ((NULL == n) || (0 != strcmp(n, s_name)))
 129   {
 130     GNUNET_break(0);
 131     failed = GNUNET_YES;
 132   }
 133   if (1 != rd_count)
 134   {
 135     GNUNET_break(0);
 136     failed = GNUNET_YES;
 137   }
 138   if (NULL == rd)
 139   {
 140     GNUNET_break(0);
 141     failed = GNUNET_YES;
 142   }
 143   if (failed == GNUNET_YES)
 144   {
 145     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned invalid response\n");
 146     res = 1;
 147   }
 148   else
 149   {
 150    res = 0;
 151   }
 152   GNUNET_SCHEDULER_add_now(&end, NULL);
 153 }
 154
 155
 156 static void
 157 name_lookup_non_existing_record_type (void *cls,
 158                                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 159                                       struct GNUNET_TIME_Absolute expire,
 160                                       const char *n,
 161                                       unsigned int rd_count,
 162                                       const struct GNUNET_NAMESTORE_RecordData *rd,
 163                                       const struct GNUNET_CRYPTO_RsaSignature *signature)
 164 {
 165   int failed = GNUNET_NO;
 166   /* We expect zone key != NULL, name != NULL, rd_count 0, rd NULL, signature NULL */
 167   if (NULL == zone_key)
 168   {
 169     GNUNET_break(0);
 170     failed = GNUNET_YES;
 171   }
 172   if (NULL == n)
 173   {
 174     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name %s!\n", n);
 175     GNUNET_break(0);
 176     failed = GNUNET_YES;
 177   }
 178   if (0 != rd_count)
 179   {
 180     GNUNET_break(0);
 181     failed = GNUNET_YES;
 182   }
 183   if (NULL != rd)
 184   {
 185     GNUNET_break(0);
 186     failed = GNUNET_YES;
 187   }
 188   if (NULL != signature)
 189   {
 190     GNUNET_break(0);
 191     failed = GNUNET_YES;
 192   }
 193
 194   if ((rd_count == 1) && (rd != NULL))
 195   {
 196     if (GNUNET_NO == GNUNET_NAMESTORE_records_cmp(rd, &rd[RECORDS-1]))
 197     {
 198       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Records are not equal!\n");
 199       failed = GNUNET_YES;
 200     }
 201     else
 202     {
 203       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Records are equal!\n");
 204     }
 205   }
 206
 207   if (failed == GNUNET_YES)
 208   {
 209     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned invalid response\n");
 210     res = 1;
 211
 212   }
 213   else
 214   {
 215    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned valid response\n");
 216    GNUNET_NAMESTORE_lookup_record (nsh, &s_zone, s_name, TEST_RECORD_LOOKUP_TYPE_EXISTING, &name_lookup_existing_record_type, NULL);
 217    res = 0;
 218   }
 219 }
 220
 221
 222 static void
 223 put_cont (void *cls, int32_t success, const char *emsg)
 224 {
 225   char * name = cls;
 226
 227   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name store added record for `%s': %s\n", name, (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 228   if (success == GNUNET_OK)
 229   {
 230     res = 0;
 231     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up non-existing record type %u for name `%s'\n", TEST_RECORD_LOOKUP_TYPE_NOT_EXISTING, name);
 232     GNUNET_NAMESTORE_lookup_record (nsh, &s_zone, name, TEST_RECORD_LOOKUP_TYPE_NOT_EXISTING, &name_lookup_non_existing_record_type, NULL);
 233   }
 234   else
 235   {
 236     res = 1;
 237     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to put records for name `%s'\n", name);
 238     GNUNET_SCHEDULER_add_now(&end, NULL);
 239   }
 240 }
 241
 242
 243 static struct GNUNET_NAMESTORE_RecordData *
 244 create_record (unsigned int count)
 245 {
 246   unsigned int c;
 247   struct GNUNET_NAMESTORE_RecordData * rd;
 248
 249   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
 250   for (c = 0; c < count-1; c++)
 251   {
 252     rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
 253     rd[c].record_type = 1;
 254     rd[c].data_size = TEST_RECORD_DATALEN;
 255     rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
 256     memset ((char *) rd[c].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
 257   }
 258   rd[c].expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS).abs_value;
 259   rd[c].record_type = TEST_RECORD_LOOKUP_TYPE_EXISTING;
 260   rd[c].data_size = TEST_RECORD_DATALEN;
 261   rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
 262   memset ((char *) rd[c].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
 263
 264   return rd;
 265 }
 266
 267
 268 static void
 269 run (void *cls,
 270      const struct GNUNET_CONFIGURATION_Handle *cfg,
 271      struct GNUNET_TESTING_Peer *peer)
 272 {
 273   size_t rd_ser_len;
 274   char *hostkey_file;
 275   struct GNUNET_TIME_Absolute et;
 276
 277   endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
 278   /* load privat key */
 279   GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
 280       "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
 281   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
 282   privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
 283   GNUNET_free (hostkey_file);
 284   GNUNET_assert (privkey != NULL);
 285   /* get public key */
 286   GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
 287
 288   /* create record */
 289   s_name = "dummy.dummy.gnunet";
 290   s_rd = create_record (RECORDS);
 291
 292   rd_ser_len = GNUNET_NAMESTORE_records_get_size(RECORDS, s_rd);
 293   {
 294     char rd_ser[rd_ser_len];
 295     GNUNET_NAMESTORE_records_serialize(RECORDS, s_rd, rd_ser_len, rd_ser);
 296
 297     /* sign */
 298     et.abs_value = s_rd[RECORDS - 1].expiration_time;
 299     s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_rd, RECORDS);
 300
 301     /* create random zone hash */
 302     GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
 303     nsh = GNUNET_NAMESTORE_connect (cfg);
 304     GNUNET_break (NULL != nsh);
 305     GNUNET_break (s_rd != NULL);
 306     GNUNET_break (s_name != NULL);
 307     GNUNET_NAMESTORE_record_put (nsh, &pubkey, s_name,
 308                                  GNUNET_TIME_UNIT_FOREVER_ABS,
 309                                  RECORDS, s_rd, s_signature, put_cont, s_name);
 310   }
 311 }
 312
 313
 314 int
 315 main (int argc, char *argv[])
 316 {
 317   res = 1;
 318   if (0 !=
 319       GNUNET_TESTING_service_run ("test-namestore-api-lookup-specific-type",
 320                                   "namestore",
 321                                   "test_namestore_api.conf",
 322                                   &run,
 323                                   NULL))
 324     return 1;
 325   GNUNET_free_non_null (s_signature);
 326   return res;
 327 }
 328
 329 /* end of test_namestore_api_lookup_specific_type.c */