Make 2nd and 3rd arguments of GNUNET_FS_namespace_rename constant pointers
[oweals/gnunet.git] / src / fs / test_fs_namespace.c
1 /*
2      This file is part of GNUnet.
3      (C) 2005, 2006, 2008, 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 /**
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_HashCode 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 GNUNET_SCHEDULER_TaskIdentifier kill_task;
45
46 static GNUNET_SCHEDULER_TaskIdentifier kill_ncc_task;
47
48 struct GNUNET_FS_NamespaceCreationContext *ncc;
49
50 static int update_started;
51
52 static int err;
53
54 static int phase;
55
56 const struct GNUNET_CONFIGURATION_Handle *config;
57
58 static void ns_created (void *cls, struct GNUNET_FS_Namespace *ns, const char *emsg);
59
60 static void do_ncc_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
61
62
63 static void
64 next_phase ()
65 {
66   switch (phase)
67   {
68   case 0:
69     phase += 1;
70     FPRINTF (stderr, "%s",  "Testing asynchronous namespace creation\n");
71     ncc = GNUNET_FS_namespace_create_start (fs, "testNamespace", ns_created, NULL);
72     if (NULL == ncc)
73     {
74       FPRINTF (stderr, "%s",  "Failed to start asynchronous namespace creation\n");
75       err = 1;
76       next_phase ();
77       return;
78     }
79     kill_ncc_task =
80       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_ncc_timeout,
81                                     NULL);
82     break;
83   case 1:
84     FPRINTF (stderr, "%s",  "Shutting down FS\n");
85     GNUNET_FS_stop (fs);
86     if (GNUNET_SCHEDULER_NO_TASK != kill_task)
87       GNUNET_SCHEDULER_cancel (kill_task);
88     kill_task = GNUNET_SCHEDULER_NO_TASK;
89   }
90 }
91
92 static void
93 abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
94 {
95   if (NULL == ksk_search)
96     return;
97   FPRINTF (stderr, "%s",  "Stopping KSK search\n");
98   GNUNET_FS_search_stop (ksk_search);
99   ksk_search = NULL;
100   if (sks_search == NULL)
101     next_phase ();
102 }
103
104
105 static void
106 abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
107 {
108   struct GNUNET_FS_Namespace *ns;
109
110   if (sks_search == NULL)
111     return;
112   FPRINTF (stderr, "%s",  "Stopping SKS search\n");
113   GNUNET_FS_search_stop (sks_search);
114   sks_search = NULL;
115   ns = GNUNET_FS_namespace_create (fs, "testNamespace");
116   GNUNET_assert (NULL != ns);
117   GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES));
118   if (ksk_search == NULL)
119     next_phase ();
120 }
121
122
123 static void
124 do_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
125 {
126   FPRINTF (stderr, "%s",  "Operation timed out\n");
127   kill_task = GNUNET_SCHEDULER_NO_TASK;
128   abort_sks_search_task (NULL, tc);
129   abort_ksk_search_task (NULL, tc);
130 }
131
132
133 static void *
134 progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
135 {
136   char *got;
137   switch (event->status)
138   {
139   case GNUNET_FS_STATUS_SEARCH_RESULT:
140     got = GNUNET_FS_uri_to_string (event->value.search.specifics.result.uri);
141     FPRINTF (stderr, "Got a search result `%s'\n", got);
142     if (sks_search == event->value.search.sc)
143     {
144       if (!GNUNET_FS_uri_test_equal
145           (sks_expect_uri, event->value.search.specifics.result.uri))
146       {
147         char *expected;
148         expected = GNUNET_FS_uri_to_string (sks_expect_uri);
149         FPRINTF (stderr, "Wrong result for sks search! Expected:\n%s\nGot:\n%s\n", expected, got);
150         GNUNET_free (expected);
151         err = 1;
152       }
153       /* give system 1ms to initiate update search! */
154       FPRINTF (stderr, "scheduling `%s'\n", "abort_sks_search_task");
155       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
156                                     &abort_sks_search_task, NULL);
157     }
158     else if (ksk_search == event->value.search.sc)
159     {
160       if (!GNUNET_FS_uri_test_equal
161           (ksk_expect_uri, event->value.search.specifics.result.uri))
162       {
163         char *expected;
164         expected = GNUNET_FS_uri_to_string (ksk_expect_uri);
165         FPRINTF (stderr, "Wrong result for ksk search! Expected:\n%s\nGot:\n%s\n", expected, got);
166         GNUNET_free (expected);
167         err = 1;
168       }
169       FPRINTF (stderr, "scheduling `%s'\n", "abort_ksk_search_task");
170       GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, NULL,
171                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
172     }
173     else
174     {
175       FPRINTF (stderr, "Unexpected search result `%s' received!\n", got);
176       GNUNET_break (0);
177     }
178     GNUNET_free (got);
179     break;
180   case GNUNET_FS_STATUS_SEARCH_ERROR:
181     FPRINTF (stderr, "Error searching file: %s\n",
182              event->value.search.specifics.error.message);
183     if (sks_search == event->value.search.sc)
184       GNUNET_SCHEDULER_add_continuation (&abort_sks_search_task, NULL,
185                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
186     else if (ksk_search == event->value.search.sc)
187       GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, NULL,
188                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
189     else
190       GNUNET_break (0);
191     break;
192   case GNUNET_FS_STATUS_SEARCH_START:
193     FPRINTF (stderr, "Search %s started\n", event->value.search.pctx);
194     GNUNET_assert ((NULL == event->value.search.cctx) ||
195                    (0 == strcmp ("sks_search", event->value.search.cctx)) ||
196                    (0 == strcmp ("ksk_search", event->value.search.cctx)));
197     if (NULL == event->value.search.cctx)
198     {
199       GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx));
200       update_started = GNUNET_YES;
201     }
202     GNUNET_assert (1 == event->value.search.anonymity);
203     break;
204   case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
205     FPRINTF (stderr, "%s",  "Search result stopped\n");
206     return NULL;
207   case GNUNET_FS_STATUS_SEARCH_STOPPED:
208     FPRINTF (stderr, "%s",  "Search stopped\n");
209     return NULL;
210   default:
211     FPRINTF (stderr, "Unexpected event: %d\n", event->status);
212     break;
213   }
214   return event->value.search.cctx;
215 }
216
217
218 static void
219 publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
220 {
221   char *msg;
222   struct GNUNET_FS_Uri *sks_uri;
223   char sbuf[1024];
224   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
225
226   if (NULL != emsg)
227   {
228     FPRINTF (stderr, "Error publishing ksk: %s\n", emsg);
229     err = 1;
230     GNUNET_FS_stop (fs);
231     return;
232   }
233   FPRINTF (stderr, "%s",  "Published ksk\n");
234   GNUNET_CRYPTO_hash_to_enc (&nsid, &enc);
235   GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", &enc);
236   sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
237   if (NULL == sks_uri)
238   {
239     FPRINTF (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
240     err = 1;
241     GNUNET_FS_stop (fs);
242     GNUNET_free_non_null (msg);
243     return;
244   }
245   FPRINTF (stderr, "%s",  "Starting searches\n");
246   ksk_search =
247       GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
248                               "ksk_search");
249   sks_search =
250       GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
251                               "sks_search");
252   GNUNET_FS_uri_destroy (sks_uri);
253 }
254
255
256 static void
257 sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
258 {
259   struct GNUNET_CONTAINER_MetaData *meta;
260   struct GNUNET_FS_Uri *ksk_uri;
261   char *msg;
262   struct GNUNET_FS_BlockOptions bo;
263   char *suri;
264
265   if (NULL == uri)
266   {
267     fprintf (stderr, "Error publishing sks: %s\n", emsg);
268     err = 1;
269     GNUNET_FS_stop (fs);
270     return;
271   }
272   FPRINTF (stderr, "%s",  "Published sks\n");
273   meta = GNUNET_CONTAINER_meta_data_create ();
274   msg = NULL;
275   GNUNET_asprintf (&suri, "gnunet://fs/ksk/ns-search%d", phase);
276   ksk_uri = GNUNET_FS_uri_parse (suri, &msg);
277   GNUNET_free (suri);
278   GNUNET_assert (NULL == msg);
279   ksk_expect_uri = GNUNET_FS_uri_dup (uri);
280   bo.content_priority = 1;
281   bo.anonymity_level = 1;
282   bo.replication_level = 0;
283   bo.expiration_time =
284       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
285   GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
286                          GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
287   GNUNET_FS_uri_destroy (ksk_uri);
288   GNUNET_CONTAINER_meta_data_destroy (meta);
289 }
290
291
292 static void
293 adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
294 {
295   struct GNUNET_CONTAINER_MetaData *meta;
296   struct GNUNET_FS_Namespace *ns;
297   struct GNUNET_FS_BlockOptions bo;
298
299   if (NULL != emsg)
300   {
301     FPRINTF (stderr, "Error advertising: %s\n", emsg);
302     err = 1;
303     GNUNET_FS_stop (fs);
304     return;
305   }
306   FPRINTF (stderr, "%s",  "Created an advertising\n");
307   ns = GNUNET_FS_namespace_create (fs, "testNamespace");
308   GNUNET_assert (NULL != ns);
309   meta = GNUNET_CONTAINER_meta_data_create ();
310   GNUNET_assert (NULL == emsg);
311   sks_expect_uri = GNUNET_FS_uri_dup (uri);
312   bo.content_priority = 1;
313   bo.anonymity_level = 1;
314   bo.replication_level = 0;
315   bo.expiration_time =
316       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
317   GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,     /* FIXME: this is non-sense (use CHK URI!?) */
318                          &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
319   GNUNET_CONTAINER_meta_data_destroy (meta);
320   GNUNET_FS_namespace_delete (ns, GNUNET_NO);
321 }
322
323
324 static void
325 ns_iterator (void *cls, const char *name, const struct GNUNET_HashCode * id)
326 {
327   int *ok = cls;
328
329   FPRINTF (stderr, "Namespace in the list: %s\n", name);
330   if (0 != strcmp (name, "testNamespace"))
331     return;
332   *ok = GNUNET_YES;
333   nsid = *id;
334 }
335
336 static void
337 testCreatedNamespace (struct GNUNET_FS_Namespace *ns)
338 {
339   struct GNUNET_FS_BlockOptions bo;
340   struct GNUNET_CONTAINER_MetaData *meta;
341   struct GNUNET_FS_Uri *ksk_uri;
342   int ok;
343   char *uri;
344
345   FPRINTF (stderr, "%s",  "Listing namespaces\n");
346   ok = GNUNET_NO;
347   GNUNET_FS_namespace_list (fs, &ns_iterator, &ok);
348   if (GNUNET_NO == ok)
349   {
350     FPRINTF (stderr, "%s",  "namespace_list failed to find namespace!\n");
351     GNUNET_FS_namespace_delete (ns, GNUNET_YES);
352     GNUNET_FS_stop (fs);
353     err = 1;
354     return;
355   }
356   FPRINTF (stderr, "%s",  "Creating an advertising\n");
357   meta = GNUNET_CONTAINER_meta_data_create ();
358   GNUNET_asprintf (&uri, "gnunet://fs/ksk/testnsa%d", phase);
359   ksk_uri = GNUNET_FS_uri_parse (uri, NULL);
360   GNUNET_free (uri);
361   bo.content_priority = 1;
362   bo.anonymity_level = 1;
363   bo.replication_level = 0;
364   bo.expiration_time =
365       GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
366   GNUNET_FS_namespace_advertise (fs, ksk_uri, ns, meta, &bo, "root", &adv_cont,
367                                  NULL);
368   GNUNET_FS_uri_destroy (ksk_uri);
369   GNUNET_FS_namespace_delete (ns, GNUNET_NO);
370   GNUNET_CONTAINER_meta_data_destroy (meta);
371 }
372
373 static void
374 do_ncc_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
375 {
376   FPRINTF (stderr, "%s",  "Asynchronous NS creation timed out\n");
377   kill_ncc_task = GNUNET_SCHEDULER_NO_TASK;
378   if (NULL == ncc)
379     return;
380   GNUNET_FS_namespace_create_stop (ncc);
381   ncc = NULL;
382   err = 1;
383 }
384
385 static void
386 ns_created (void *cls, struct GNUNET_FS_Namespace *ns, const char *emsg)
387 {
388   if (GNUNET_SCHEDULER_NO_TASK != kill_ncc_task)
389     GNUNET_SCHEDULER_cancel (kill_ncc_task);
390   kill_ncc_task = GNUNET_SCHEDULER_NO_TASK;
391   if (NULL == ns)
392   {
393     FPRINTF (stderr, "Asynchronous NS creation failed: %s\n", emsg);
394     err = 1;
395     return;
396   }
397
398   FPRINTF (stderr, "%s",  "Namespace created asynchronously\n");
399   testCreatedNamespace (ns);
400 }
401
402 static void
403 testNamespace ()
404 {
405   struct GNUNET_FS_Namespace *ns;
406
407   FPRINTF (stderr, "%s",  "Testing synchronous namespace creation\n");
408   ns = GNUNET_FS_namespace_create (fs, "testNamespace");
409   GNUNET_assert (NULL != ns);
410   testCreatedNamespace (ns);
411
412   kill_task =
413       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
414                                     NULL);
415 }
416
417
418 static void
419 run (void *cls, 
420      const struct GNUNET_CONFIGURATION_Handle *cfg,
421      struct GNUNET_TESTING_Peer *peer)
422 {
423   config = cfg;
424   fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL,
425                         GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
426   phase = 0;
427   testNamespace ();
428 }
429
430
431 int
432 main (int argc, char *argv[])
433 {
434   if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace",
435                                     "test_fs_namespace_data.conf",
436                                     &run, NULL))
437     return 1;
438   return err;
439 }
440
441
442 /* end of test_fs_namespace.c */