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 (NULL != signature)
 144   {
 145     GNUNET_break(0);
 146     failed = GNUNET_YES;
 147   }
 148   if (failed == GNUNET_YES)
 149   {
 150     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned invalid response\n");
 151     res = 1;
 152   }
 153   else
 154   {
 155    res = 0;
 156   }
 157   GNUNET_SCHEDULER_add_now(&end, NULL);
 158 }
 159
 160
 161 static void
 162 name_lookup_non_existing_record_type (void *cls,
 163                                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 164                                       struct GNUNET_TIME_Absolute expire,
 165                                       const char *n,
 166                                       unsigned int rd_count,
 167                                       const struct GNUNET_NAMESTORE_RecordData *rd,
 168                                       const struct GNUNET_CRYPTO_RsaSignature *signature)
 169 {
 170   int failed = GNUNET_NO;
 171   /* We expect zone key != NULL, name != NULL, rd_count 0, rd NULL, signature NULL */
 172   if (NULL == zone_key)
 173   {
 174     GNUNET_break(0);
 175     failed = GNUNET_YES;
 176   }
 177   if (NULL == n)
 178   {
 179     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name %s!\n", n);
 180     GNUNET_break(0);
 181     failed = GNUNET_YES;
 182   }
 183   if (0 != rd_count)
 184   {
 185     GNUNET_break(0);
 186     failed = GNUNET_YES;
 187   }
 188   if (NULL != rd)
 189   {
 190     GNUNET_break(0);
 191     failed = GNUNET_YES;
 192   }
 193   if (NULL != signature)
 194   {
 195     GNUNET_break(0);
 196     failed = GNUNET_YES;
 197   }
 198
 199   if ((rd_count == 1) && (rd != NULL))
 200   {
 201     if (GNUNET_NO == GNUNET_NAMESTORE_records_cmp(rd, &rd[RECORDS-1]))
 202     {
 203       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Records are not equal!\n");
 204       failed = GNUNET_YES;
 205     }
 206     else
 207     {
 208       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Records are equal!\n");
 209     }
 210   }
 211
 212   if (failed == GNUNET_YES)
 213   {
 214     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned invalid response\n");
 215     res = 1;
 216
 217   }
 218   else
 219   {
 220    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore returned valid response\n");
 221    GNUNET_NAMESTORE_lookup_record (nsh, &s_zone, s_name, TEST_RECORD_LOOKUP_TYPE_EXISTING, &name_lookup_existing_record_type, NULL);
 222    res = 0;
 223   }
 224 }
 225
 226
 227 static void
 228 put_cont (void *cls, int32_t success, const char *emsg)
 229 {
 230   char * name = cls;
 231
 232   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name store added record for `%s': %s\n", name, (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
 233   if (success == GNUNET_OK)
 234   {
 235     res = 0;
 236     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up non-existing record type %u for name `%s'\n", TEST_RECORD_LOOKUP_TYPE_NOT_EXISTING, name);
 237     GNUNET_NAMESTORE_lookup_record (nsh, &s_zone, name, TEST_RECORD_LOOKUP_TYPE_NOT_EXISTING, &name_lookup_non_existing_record_type, NULL);
 238   }
 239   else
 240   {
 241     res = 1;
 242     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to put records for name `%s'\n", name);
 243     GNUNET_SCHEDULER_add_now(&end, NULL);
 244   }
 245 }
 246
 247
 248 static struct GNUNET_NAMESTORE_RecordData *
 249 create_record (unsigned int count)
 250 {
 251   unsigned int c;
 252   struct GNUNET_NAMESTORE_RecordData * rd;
 253
 254   rd = GNUNET_malloc (count * sizeof (struct GNUNET_NAMESTORE_RecordData));
 255   for (c = 0; c < count-1; c++)
 256   {
 257     rd[c].expiration_time = 0;
 258     rd[c].record_type = 1;
 259     rd[c].data_size = TEST_RECORD_DATALEN;
 260     rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
 261     memset ((char *) rd[c].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
 262   }
 263   rd[c].expiration_time = GNUNET_TIME_absolute_get().abs_value;
 264   rd[c].record_type = TEST_RECORD_LOOKUP_TYPE_EXISTING;
 265   rd[c].data_size = TEST_RECORD_DATALEN;
 266   rd[c].data = GNUNET_malloc(TEST_RECORD_DATALEN);
 267   memset ((char *) rd[c].data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
 268
 269   return rd;
 270 }
 271
 272
 273 static void
 274 run (void *cls,
 275      const struct GNUNET_CONFIGURATION_Handle *cfg,
 276      struct GNUNET_TESTING_Peer *peer)
 277 {
 278   size_t rd_ser_len;
 279   char *hostkey_file;
 280   struct GNUNET_TIME_Absolute et;
 281
 282   endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
 283   /* load privat key */
 284   GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
 285       "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
 286   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
 287   privkey = GNUNET_CRYPTO_rsa_key_create_from_file(hostkey_file);
 288   GNUNET_free (hostkey_file);
 289   GNUNET_assert (privkey != NULL);
 290   /* get public key */
 291   GNUNET_CRYPTO_rsa_key_get_public(privkey, &pubkey);
 292
 293   /* create record */
 294   s_name = "dummy.dummy.gnunet";
 295   s_rd = create_record (RECORDS);
 296
 297   rd_ser_len = GNUNET_NAMESTORE_records_get_size(RECORDS, s_rd);
 298   {
 299     char rd_ser[rd_ser_len];
 300     GNUNET_NAMESTORE_records_serialize(RECORDS, s_rd, rd_ser_len, rd_ser);
 301
 302     /* sign */
 303     et.abs_value = s_rd[RECORDS - 1].expiration_time;
 304     s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, s_rd, RECORDS);
 305
 306     /* create random zone hash */
 307     GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &s_zone);
 308     nsh = GNUNET_NAMESTORE_connect (cfg);
 309     GNUNET_break (NULL != nsh);
 310     GNUNET_break (s_rd != NULL);
 311     GNUNET_break (s_name != NULL);
 312     GNUNET_NAMESTORE_record_put (nsh, &pubkey, s_name,
 313                                  GNUNET_TIME_UNIT_FOREVER_ABS,
 314                                  RECORDS, s_rd, s_signature, put_cont, s_name);
 315   }
 316 }
 317
 318
 319 int
 320 main (int argc, char *argv[])
 321 {
 322   res = 1;
 323   if (0 !=
 324       GNUNET_TESTING_service_run ("test-namestore-api-lookup-specific-type",
 325                                   "namestore",
 326                                   "test_namestore_api.conf",
 327                                   &run,
 328                                   NULL))
 329     return 1;
 330   GNUNET_free_non_null (s_signature);
 331   return res;
 332 }
 333
 334 /* end of test_namestore_api_lookup_specific_type.c */