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