src/fs/test_fs_namespace.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2005-2013 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20
  21 /**
  22  * @file fs/test_fs_namespace.c
  23  * @brief Test for fs_namespace.c
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_testing_lib.h"
  29 #include "gnunet_fs_service.h"
  30
  31
  32 static struct GNUNET_CRYPTO_EcdsaPublicKey nsid;
  33
  34 static struct GNUNET_FS_Uri *sks_expect_uri;
  35
  36 static struct GNUNET_FS_Uri *ksk_expect_uri;
  37
  38 static struct GNUNET_FS_Handle *fs;
  39
  40 static struct GNUNET_FS_SearchContext *sks_search;
  41
  42 static struct GNUNET_FS_SearchContext *ksk_search;
  43
  44 static struct GNUNET_SCHEDULER_Task * kill_task;
  45
  46 static int update_started;
  47
  48 static int err;
  49
  50
  51 static void
  52 abort_ksk_search_task (void *cls)
  53 {
  54   if (ksk_search != NULL)
  55   {
  56     GNUNET_FS_search_stop (ksk_search);
  57     ksk_search = NULL;
  58     if (sks_search == NULL)
  59     {
  60       GNUNET_FS_stop (fs);
  61       if (NULL != kill_task)
  62         GNUNET_SCHEDULER_cancel (kill_task);
  63     }
  64   }
  65 }
  66
  67
  68 static void
  69 abort_sks_search_task (void *cls)
  70 {
  71   if (sks_search == NULL)
  72     return;
  73   GNUNET_FS_search_stop (sks_search);
  74   sks_search = NULL;
  75   if (ksk_search == NULL)
  76   {
  77     GNUNET_FS_stop (fs);
  78     if (NULL != kill_task)
  79       GNUNET_SCHEDULER_cancel (kill_task);
  80   }
  81 }
  82
  83
  84 static void
  85 do_timeout (void *cls)
  86 {
  87   err = 1;
  88   FPRINTF (stderr, "%s",  "Operation timed out\n");
  89   kill_task = NULL;
  90   abort_sks_search_task (NULL);
  91   abort_ksk_search_task (NULL);
  92 }
  93
  94
  95 static void *
  96 progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
  97 {
  98   switch (event->status)
  99   {
 100   case GNUNET_FS_STATUS_SEARCH_RESULT:
 101     if (sks_search == event->value.search.sc)
 102     {
 103       if (!GNUNET_FS_uri_test_equal
 104           (sks_expect_uri, event->value.search.specifics.result.uri))
 105       {
 106         FPRINTF (stderr, "%s",  "Wrong result for sks search!\n");
 107         err = 1;
 108       }
 109       /* give system 1ms to initiate update search! */
 110       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
 111                                     &abort_sks_search_task, NULL);
 112     }
 113     else if (ksk_search == event->value.search.sc)
 114     {
 115       if (!GNUNET_FS_uri_test_equal
 116           (ksk_expect_uri, event->value.search.specifics.result.uri))
 117       {
 118         FPRINTF (stderr, "%s",  "Wrong result for ksk search!\n");
 119         err = 1;
 120       }
 121       GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
 122     }
 123     else
 124     {
 125       FPRINTF (stderr, "%s",  "Unexpected search result received!\n");
 126       GNUNET_break (0);
 127     }
 128     break;
 129   case GNUNET_FS_STATUS_SEARCH_ERROR:
 130     FPRINTF (stderr, "Error searching file: %s\n",
 131              event->value.search.specifics.error.message);
 132     if (sks_search == event->value.search.sc)
 133       GNUNET_SCHEDULER_add_now (&abort_sks_search_task, NULL);
 134     else if (ksk_search == event->value.search.sc)
 135       GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
 136     else
 137       GNUNET_break (0);
 138     break;
 139   case GNUNET_FS_STATUS_SEARCH_START:
 140     GNUNET_assert ((NULL == event->value.search.cctx) ||
 141                    (0 == strcmp ("sks_search", event->value.search.cctx)) ||
 142                    (0 == strcmp ("ksk_search", event->value.search.cctx)));
 143     if (NULL == event->value.search.cctx)
 144     {
 145       GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx));
 146       update_started = GNUNET_YES;
 147     }
 148     GNUNET_assert (1 == event->value.search.anonymity);
 149     break;
 150   case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
 151     return NULL;
 152   case GNUNET_FS_STATUS_SEARCH_STOPPED:
 153     return NULL;
 154   default:
 155     FPRINTF (stderr, "Unexpected event: %d\n", event->status);
 156     break;
 157   }
 158   return event->value.search.cctx;
 159 }
 160
 161
 162 static void
 163 publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
 164 {
 165   char *msg;
 166   struct GNUNET_FS_Uri *sks_uri;
 167   char sbuf[1024];
 168   char buf[1024];
 169   char *ret;
 170
 171   if (NULL != emsg)
 172   {
 173     FPRINTF (stderr, "Error publishing: %s\n", emsg);
 174     err = 1;
 175     GNUNET_FS_stop (fs);
 176     return;
 177   }
 178   ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof (nsid), buf, sizeof (buf));
 179   GNUNET_assert (NULL != ret);
 180   ret[0] = '\0';
 181   GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf);
 182   sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
 183   if (NULL == sks_uri)
 184   {
 185     FPRINTF (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
 186     err = 1;
 187     GNUNET_FS_stop (fs);
 188     GNUNET_free_non_null (msg);
 189     return;
 190   }
 191   ksk_search =
 192       GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
 193                               "ksk_search");
 194   sks_search =
 195       GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
 196                               "sks_search");
 197   GNUNET_FS_uri_destroy (sks_uri);
 198 }
 199
 200
 201 static void
 202 sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 203 {
 204   struct GNUNET_CONTAINER_MetaData *meta;
 205   struct GNUNET_FS_Uri *ksk_uri;
 206   char *msg;
 207   struct GNUNET_FS_BlockOptions bo;
 208
 209   if (NULL == uri)
 210   {
 211     fprintf (stderr, "Error publishing: %s\n", emsg);
 212     err = 1;
 213     GNUNET_FS_stop (fs);
 214     return;
 215   }
 216   meta = GNUNET_CONTAINER_meta_data_create ();
 217   msg = NULL;
 218   ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg);
 219   GNUNET_assert (NULL == msg);
 220   ksk_expect_uri = GNUNET_FS_uri_dup (uri);
 221   bo.content_priority = 1;
 222   bo.anonymity_level = 1;
 223   bo.replication_level = 0;
 224   bo.expiration_time =
 225       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
 226   GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
 227                          GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
 228   GNUNET_FS_uri_destroy (ksk_uri);
 229   GNUNET_CONTAINER_meta_data_destroy (meta);
 230 }
 231
 232
 233 static void
 234 adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 235 {
 236   struct GNUNET_CONTAINER_MetaData *meta;
 237   struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
 238   struct GNUNET_FS_BlockOptions bo;
 239
 240   if (NULL != emsg)
 241   {
 242     FPRINTF (stderr, "Error publishing: %s\n", emsg);
 243     err = 1;
 244     GNUNET_FS_stop (fs);
 245     return;
 246   }
 247   ns = GNUNET_CRYPTO_ecdsa_key_create ();
 248   meta = GNUNET_CONTAINER_meta_data_create ();
 249   sks_expect_uri = GNUNET_FS_uri_dup (uri);
 250   bo.content_priority = 1;
 251   bo.anonymity_level = 1;
 252   bo.replication_level = 0;
 253   bo.expiration_time =
 254       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
 255   GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid);
 256   GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,
 257                          &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
 258   GNUNET_CONTAINER_meta_data_destroy (meta);
 259   GNUNET_free (ns);
 260 }
 261
 262
 263 static void
 264 testNamespace ()
 265 {
 266   struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
 267   struct GNUNET_FS_BlockOptions bo;
 268   struct GNUNET_CONTAINER_MetaData *meta;
 269   struct GNUNET_FS_Uri *ksk_uri;
 270   struct GNUNET_FS_Uri *sks_uri;
 271
 272   ns = GNUNET_CRYPTO_ecdsa_key_create ();
 273   meta = GNUNET_CONTAINER_meta_data_create ();
 274   ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);
 275   bo.content_priority = 1;
 276   bo.anonymity_level = 1;
 277   bo.replication_level = 0;
 278   bo.expiration_time =
 279       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
 280   sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root");
 281   GNUNET_FS_publish_ksk (fs,
 282                          ksk_uri, meta, sks_uri,
 283                          &bo, GNUNET_FS_PUBLISH_OPTION_NONE,
 284                          &adv_cont, NULL);
 285   GNUNET_FS_uri_destroy (sks_uri);
 286   kill_task =
 287       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
 288                                     NULL);
 289   GNUNET_FS_uri_destroy (ksk_uri);
 290   GNUNET_CONTAINER_meta_data_destroy (meta);
 291   GNUNET_free (ns);
 292 }
 293
 294
 295 static void
 296 run (void *cls,
 297      const struct GNUNET_CONFIGURATION_Handle *cfg,
 298      struct GNUNET_TESTING_Peer *peer)
 299 {
 300   fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL,
 301                         GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
 302   testNamespace ();
 303 }
 304
 305
 306 int
 307 main (int argc, char *argv[])
 308 {
 309   if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace",
 310                                     "test_fs_namespace_data.conf",
 311                                     &run, NULL))
 312     return 1;
 313   return err;
 314 }
 315
 316
 317 /* end of test_fs_namespace.c */