add quiet flag (fix for test case)
[oweals/gnunet.git] / src / fs / gnunet-service-fs_indexing.c
1 /*
2      This file is part of GNUnet.
3      (C) 2009, 2010 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 2, 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/gnunet-service-fs_indexing.c
23  * @brief program that provides indexing functions of the file-sharing service
24  * @author Christian Grothoff
25  */
26 #include "platform.h"
27 #include <float.h>
28 #include "gnunet_core_service.h"
29 #include "gnunet_datastore_service.h"
30 #include "gnunet_peer_lib.h"
31 #include "gnunet_protocols.h"
32 #include "gnunet_signatures.h"
33 #include "gnunet_util_lib.h"
34 #include "gnunet-service-fs_drq.h"
35 #include "gnunet-service-fs_indexing.h"
36 #include "fs.h"
37
38 #define DEBUG_FS GNUNET_NO
39
40 /**
41  * In-memory information about indexed files (also available
42  * on-disk).
43  */
44 struct IndexInfo
45 {
46   
47   /**
48    * This is a linked list.
49    */
50   struct IndexInfo *next;
51
52   /**
53    * Name of the indexed file.  Memory allocated
54    * at the end of this struct (do not free).
55    */
56   const char *filename;
57
58   /**
59    * Context for transmitting confirmation to client,
60    * NULL if we've done this already.
61    */
62   struct GNUNET_SERVER_TransmitContext *tc;
63   
64   /**
65    * Hash of the contents of the file.
66    */
67   GNUNET_HashCode file_id;
68
69 };
70
71
72 /**
73  * Linked list of indexed files.
74  */
75 static struct IndexInfo *indexed_files;
76
77 /**
78  * Maps hash over content of indexed files to the respective filename.
79  * The filenames are pointers into the indexed_files linked list and
80  * do not need to be freed.
81  */
82 static struct GNUNET_CONTAINER_MultiHashMap *ifm;
83
84 /**
85  * Our scheduler.
86  */
87 static struct GNUNET_SCHEDULER_Handle *sched;
88
89 /**
90  * Our configuration.
91  */
92 static const struct GNUNET_CONFIGURATION_Handle *cfg;
93
94
95 /**
96  * Write the current index information list to disk.
97  */ 
98 static void
99 write_index_list ()
100 {
101   struct GNUNET_BIO_WriteHandle *wh;
102   char *fn;
103   struct IndexInfo *pos;  
104
105   if (GNUNET_OK !=
106       GNUNET_CONFIGURATION_get_value_filename (cfg,
107                                                "FS",
108                                                "INDEXDB",
109                                                &fn))
110     {
111       GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
112                   _("Configuration option `%s' in section `%s' missing.\n"),
113                   "INDEXDB",
114                   "FS");
115       return;
116     }
117   wh = GNUNET_BIO_write_open (fn);
118   if (NULL == wh)
119     {
120       GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
121                   _("Could not open `%s'.\n"),
122                   fn);
123       GNUNET_free (fn);
124       return;
125     }
126   pos = indexed_files;
127   while (pos != NULL)
128     {
129       if ( (GNUNET_OK !=
130             GNUNET_BIO_write (wh,
131                               &pos->file_id,
132                               sizeof (GNUNET_HashCode))) ||
133            (GNUNET_OK !=
134             GNUNET_BIO_write_string (wh,
135                                      pos->filename)) )
136         break;
137       pos = pos->next;
138     }
139   if (GNUNET_OK != 
140       GNUNET_BIO_write_close (wh))
141     {
142       GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
143                   _("Error writing `%s'.\n"),
144                   fn);
145       GNUNET_free (fn);
146       return;
147     }
148   GNUNET_free (fn);
149 }
150
151
152 /**
153  * Read index information from disk.
154  */
155 static void
156 read_index_list ()
157 {
158   struct GNUNET_BIO_ReadHandle *rh;
159   char *fn;
160   struct IndexInfo *pos;  
161   char *fname;
162   GNUNET_HashCode hc;
163   size_t slen;
164   char *emsg;
165
166   if (GNUNET_OK !=
167       GNUNET_CONFIGURATION_get_value_filename (cfg,
168                                                "FS",
169                                                "INDEXDB",
170                                                &fn))
171     {
172       GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
173                   _("Configuration option `%s' in section `%s' missing.\n"),
174                   "INDEXDB",
175                   "FS");
176       return;
177     }
178   if (GNUNET_NO == GNUNET_DISK_file_test (fn))
179     {
180       /* no index info yet */
181       GNUNET_free (fn);
182       return;
183     }
184   rh = GNUNET_BIO_read_open (fn);
185   if (NULL == rh)
186     {
187       GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
188                   _("Could not open `%s'.\n"),
189                   fn);
190       GNUNET_free (fn);
191       return;
192     }
193
194   while ( (GNUNET_OK ==
195            GNUNET_BIO_read (rh,
196                             "Hash of indexed file",
197                             &hc,
198                             sizeof (GNUNET_HashCode))) &&
199           (GNUNET_OK ==
200            GNUNET_BIO_read_string (rh, 
201                                    "Name of indexed file",
202                                    &fname,
203                                    1024 * 16)) )
204     {
205       slen = strlen (fname) + 1;
206       pos = GNUNET_malloc (sizeof (struct IndexInfo) + slen);
207       pos->file_id = hc;
208       pos->filename = (const char *) &pos[1];
209       memcpy (&pos[1], fname, slen);
210       if (GNUNET_SYSERR ==
211           GNUNET_CONTAINER_multihashmap_put (ifm,
212                                              &hc,
213                                              (void*) pos->filename,
214                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
215         {
216           GNUNET_free (pos);
217         }
218       else
219         {
220           pos->next = indexed_files;
221           indexed_files = pos;
222         }
223       GNUNET_free (fname);
224     }
225   if (GNUNET_OK != 
226       GNUNET_BIO_read_close (rh, &emsg))
227     GNUNET_free (emsg);
228   GNUNET_free (fn);
229 }
230
231
232 /**
233  * We've validated the hash of the file we're about to index.  Signal
234  * success to the client and update our internal data structures.
235  *
236  * @param ii the index info entry for the request
237  */
238 static void
239 signal_index_ok (struct IndexInfo *ii)
240 {
241   if (GNUNET_SYSERR ==
242       GNUNET_CONTAINER_multihashmap_put (ifm,
243                                          &ii->file_id,
244                                          (void*) ii->filename,
245                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
246     {
247       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
248                   _("Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
249                   ii->filename,
250                   (const char*) GNUNET_CONTAINER_multihashmap_get (ifm,
251                                                                    &ii->file_id));
252       GNUNET_SERVER_transmit_context_append_data (ii->tc,
253                                                   NULL, 0,
254                                                   GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
255       GNUNET_SERVER_transmit_context_run (ii->tc,
256                                           GNUNET_TIME_UNIT_MINUTES);
257       GNUNET_free (ii);
258       return;
259     }
260   ii->next = indexed_files;
261   indexed_files = ii;
262   write_index_list ();
263   GNUNET_SERVER_transmit_context_append_data (ii->tc,
264                                               NULL, 0,
265                                               GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
266   GNUNET_SERVER_transmit_context_run (ii->tc,
267                                       GNUNET_TIME_UNIT_MINUTES);
268   ii->tc = NULL;
269 }
270
271
272 /**
273  * Function called once the hash computation over an
274  * indexed file has completed.
275  *
276  * @param cls closure, our publishing context
277  * @param res resulting hash, NULL on error
278  */
279 static void 
280 hash_for_index_val (void *cls,
281                     const GNUNET_HashCode *
282                     res)
283 {
284   struct IndexInfo *ii = cls;
285   
286   if ( (res == NULL) ||
287        (0 != memcmp (res,
288                      &ii->file_id,
289                      sizeof(GNUNET_HashCode))) )
290     {
291       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
292                   _("Hash mismatch trying to index file `%s' which has hash `%s'\n"),
293                   ii->filename,
294                   GNUNET_h2s (res));
295 #if DEBUG_FS
296       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
297                   "Wanted `%s'\n",
298                   GNUNET_h2s (&ii->file_id));
299 #endif
300       GNUNET_SERVER_transmit_context_append_data (ii->tc,
301                                                   NULL, 0,
302                                                   GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
303       GNUNET_SERVER_transmit_context_run (ii->tc,
304                                           GNUNET_TIME_UNIT_MINUTES);
305       GNUNET_free (ii);
306       return;
307     }
308   signal_index_ok (ii);
309 }
310
311
312 /**
313  * Handle INDEX_START-message.
314  *
315  * @param cls closure
316  * @param client identification of the client
317  * @param message the actual message
318  */
319 void
320 GNUNET_FS_handle_index_start (void *cls,
321                               struct GNUNET_SERVER_Client *client,
322                               const struct GNUNET_MessageHeader *message)
323 {
324   const struct IndexStartMessage *ism;
325   const char *fn;
326   uint16_t msize;
327   struct IndexInfo *ii;
328   size_t slen;
329   uint32_t dev;
330   uint64_t ino;
331   uint32_t mydev;
332   uint64_t myino;
333
334   msize = ntohs(message->size);
335   if ( (msize <= sizeof (struct IndexStartMessage)) ||
336        ( ((const char *)message)[msize-1] != '\0') )
337     {
338       GNUNET_break (0);
339       GNUNET_SERVER_receive_done (client,
340                                   GNUNET_SYSERR);
341       return;
342     }
343   ism = (const struct IndexStartMessage*) message;
344   fn = (const char*) &ism[1];
345   dev = ntohl (ism->device);
346   ino = GNUNET_ntohll (ism->inode);
347   ism = (const struct IndexStartMessage*) message;
348   slen = strlen (fn) + 1;
349   ii = GNUNET_malloc (sizeof (struct IndexInfo) + slen);
350   ii->filename = (const char*) &ii[1];
351   memcpy (&ii[1], fn, slen);
352   ii->file_id = ism->file_id;  
353   ii->tc = GNUNET_SERVER_transmit_context_create (client);
354   mydev = 0;
355   myino = 0;
356   if ( ( (dev != 0) ||
357          (ino != 0) ) &&
358        (GNUNET_OK == GNUNET_DISK_file_get_identifiers (fn,
359                                                        &mydev,
360                                                        &myino)) &&
361        ( (dev == mydev) &&
362          (ino == myino) ) )
363     {      
364       /* fast validation OK! */
365       signal_index_ok (ii);
366       return;
367     }
368 #if DEBUG_FS
369   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
370               "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
371               (unsigned long long) ino,
372               (unsigned long long) myino,
373               (unsigned int) dev,
374               (unsigned int) mydev);
375 #endif
376   /* slow validation, need to hash full file (again) */
377   GNUNET_CRYPTO_hash_file (sched,
378                            GNUNET_SCHEDULER_PRIORITY_IDLE,
379                            fn,
380                            HASHING_BLOCKSIZE,
381                            &hash_for_index_val,
382                            ii);
383 }
384
385
386 /**
387  * Handle INDEX_LIST_GET-message.
388  *
389  * @param cls closure
390  * @param client identification of the client
391  * @param message the actual message
392  */
393 void
394 GNUNET_FS_handle_index_list_get (void *cls,
395                                  struct GNUNET_SERVER_Client *client,
396                                  const struct GNUNET_MessageHeader *message)
397 {
398   struct GNUNET_SERVER_TransmitContext *tc;
399   struct IndexInfoMessage *iim;
400   char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
401   size_t slen;
402   const char *fn;
403   struct IndexInfo *pos;
404
405   tc = GNUNET_SERVER_transmit_context_create (client);
406   iim = (struct IndexInfoMessage*) buf;
407   pos = indexed_files;
408   while (NULL != pos)
409     {
410       fn = pos->filename;
411       slen = strlen (fn) + 1;
412       if (slen + sizeof (struct IndexInfoMessage) > 
413           GNUNET_SERVER_MAX_MESSAGE_SIZE)
414         {
415           GNUNET_break (0);
416           break;
417         }
418       iim->header.type = htons (GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY);
419       iim->header.size = htons (slen + sizeof (struct IndexInfoMessage));
420       iim->reserved = 0;
421       iim->file_id = pos->file_id;
422       memcpy (&iim[1], fn, slen);
423       GNUNET_SERVER_transmit_context_append_message (tc,
424                                                      &iim->header);
425       pos = pos->next;
426     }
427   GNUNET_SERVER_transmit_context_append_data (tc,
428                                               NULL, 0,
429                                               GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END);
430   GNUNET_SERVER_transmit_context_run (tc,
431                                       GNUNET_TIME_UNIT_MINUTES);
432 }
433
434
435 /**
436  * Handle UNINDEX-message.
437  *
438  * @param cls closure
439  * @param client identification of the client
440  * @param message the actual message
441  */
442 void
443 GNUNET_FS_handle_unindex (void *cls,
444                           struct GNUNET_SERVER_Client *client,
445                           const struct GNUNET_MessageHeader *message)
446 {
447   const struct UnindexMessage *um;
448   struct IndexInfo *pos;
449   struct IndexInfo *prev;
450   struct IndexInfo *next;
451   struct GNUNET_SERVER_TransmitContext *tc;
452   int found;
453   
454   um = (const struct UnindexMessage*) message;
455   found = GNUNET_NO;
456   prev = NULL;
457   pos = indexed_files;
458   while (NULL != pos)
459     {
460       next = pos->next;
461       if (0 == memcmp (&pos->file_id,
462                        &um->file_id,
463                        sizeof (GNUNET_HashCode)))
464         {
465           if (prev == NULL)
466             indexed_files = next;
467           else
468             prev->next = next;
469           GNUNET_free (pos);
470           found = GNUNET_YES;
471         }
472       else
473         {
474           prev = pos;
475         }
476       pos = next;
477     }
478 #if DEBUG_FS
479   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
480               "Client requested unindexing of file `%s': %s\n",
481               GNUNET_h2s (&um->file_id),
482               found ? "found" : "not found");
483 #endif
484   if (GNUNET_YES == found)    
485     write_index_list ();
486   tc = GNUNET_SERVER_transmit_context_create (client);
487   GNUNET_SERVER_transmit_context_append_data (tc,
488                                               NULL, 0,
489                                               GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
490   GNUNET_SERVER_transmit_context_run (tc,
491                                       GNUNET_TIME_UNIT_MINUTES);
492 }
493
494
495
496
497 /**
498  * Continuation called from datastore's remove
499  * function.
500  *
501  * @param cls unused
502  * @param success did the deletion work?
503  * @param msg error message
504  */
505 static void
506 remove_cont (void *cls,
507              int success,
508              const char *msg)
509 {
510   if (GNUNET_OK != success)
511     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
512                 _("Failed to delete bogus block: %s\n"),
513                 msg);
514 }
515
516
517 /**
518  * We've received an on-demand encoded block from the datastore.
519  * Attempt to do on-demand encoding and (if successful), call the
520  * continuation with the resulting block.  On error, clean up and ask
521  * the datastore for more results.
522  *
523  * @param key key for the content
524  * @param size number of bytes in data
525  * @param data content stored
526  * @param type type of the content
527  * @param priority priority of the content
528  * @param anonymity anonymity-level for the content
529  * @param expiration expiration time for the content
530  * @param uid unique identifier for the datum;
531  *        maybe 0 if no unique identifier is available
532  * @param cont function to call with the actual block (at most once, on success)
533  * @param cont_cls closure for cont
534  * @return GNUNET_OK on success
535  */
536 int
537 GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key,
538                                   uint32_t size,
539                                   const void *data,
540                                   uint32_t type,
541                                   uint32_t priority,
542                                   uint32_t anonymity,
543                                   struct GNUNET_TIME_Absolute
544                                   expiration, uint64_t uid,
545                                   GNUNET_DATASTORE_Iterator cont,
546                                   void *cont_cls)
547 {
548   const struct OnDemandBlock *odb;
549   GNUNET_HashCode nkey;
550   struct GNUNET_CRYPTO_AesSessionKey skey;
551   struct GNUNET_CRYPTO_AesInitializationVector iv;
552   GNUNET_HashCode query;
553   ssize_t nsize;
554   char ndata[DBLOCK_SIZE];
555   char edata[DBLOCK_SIZE];
556   const char *fn;
557   struct GNUNET_DISK_FileHandle *fh;
558   uint64_t off;
559
560   if (size != sizeof (struct OnDemandBlock))
561     {
562       GNUNET_break (0);
563       GNUNET_FS_drq_remove (key,
564                             size,
565                             data,
566                             &remove_cont,
567                             NULL,
568                             GNUNET_TIME_UNIT_FOREVER_REL);
569       return GNUNET_SYSERR;
570     }
571   odb = (const struct OnDemandBlock*) data;
572   off = GNUNET_ntohll (odb->offset);
573   fn = (const char*) GNUNET_CONTAINER_multihashmap_get (ifm,
574                                                         &odb->file_id);
575   fh = NULL;
576   if ( (NULL == fn) ||
577        (NULL == (fh = GNUNET_DISK_file_open (fn, 
578                                              GNUNET_DISK_OPEN_READ,
579                                              GNUNET_DISK_PERM_NONE))) ||
580        (off !=
581         GNUNET_DISK_file_seek (fh,
582                                off,
583                                GNUNET_DISK_SEEK_SET)) ||
584        (-1 ==
585         (nsize = GNUNET_DISK_file_read (fh,
586                                         ndata,
587                                         sizeof (ndata)))) )
588     {
589       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
590                   _("Could not access indexed file `%s' at offset %llu: %s\n"),
591                   GNUNET_h2s (&odb->file_id),
592                   (unsigned long long) off,
593                   STRERROR (errno));
594       if (fh != NULL)
595         GNUNET_DISK_file_close (fh);
596       GNUNET_FS_drq_remove (key,
597                             size,
598                             data,
599                             &remove_cont,
600                             NULL,
601                             GNUNET_TIME_UNIT_FOREVER_REL);
602       return GNUNET_SYSERR;
603     }
604   GNUNET_DISK_file_close (fh);
605   GNUNET_CRYPTO_hash (ndata,
606                       nsize,
607                       &nkey);
608   GNUNET_CRYPTO_hash_to_aes_key (&nkey, &skey, &iv);
609   GNUNET_CRYPTO_aes_encrypt (ndata,
610                              nsize,
611                              &skey,
612                              &iv,
613                              edata);
614   GNUNET_CRYPTO_hash (edata,
615                       nsize,
616                       &query);
617   if (0 != memcmp (&query, 
618                    key,
619                    sizeof (GNUNET_HashCode)))
620     {
621       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
622                   _("Indexed file `%s' changed at offset %llu\n"),
623                   fn,
624                   (unsigned long long) off);
625       GNUNET_FS_drq_remove (key,
626                             size,
627                             data,
628                             &remove_cont,
629                             NULL,
630                             GNUNET_TIME_UNIT_FOREVER_REL);
631       return GNUNET_SYSERR;
632     }
633 #if DEBUG_FS
634       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
635                   "On-demand encoded block for query `%s'\n",
636                   GNUNET_h2s (key));
637 #endif  
638   cont (cont_cls,
639         key,
640         nsize,
641         edata,
642         GNUNET_DATASTORE_BLOCKTYPE_DBLOCK,
643         priority,
644         anonymity,
645         expiration,
646         uid);
647   return GNUNET_OK;
648 }
649
650
651 /**
652  * Task run during shutdown.
653  *
654  * @param cls unused
655  * @param tc unused
656  */
657 static void
658 shutdown_task (void *cls,
659                const struct GNUNET_SCHEDULER_TaskContext *tc)
660 {
661   struct IndexInfo *pos;  
662
663   GNUNET_CONTAINER_multihashmap_destroy (ifm);
664   ifm = NULL;
665   while (NULL != (pos = indexed_files))
666     {
667       indexed_files = pos->next;
668       GNUNET_free (pos);
669     }
670   sched = NULL;
671   cfg = NULL;
672 }
673
674
675 /**
676  * Initialize the indexing submodule.
677  *
678  * @param s scheduler to use
679  * @param c configuration to use
680  */
681 int
682 GNUNET_FS_indexing_init (struct GNUNET_SCHEDULER_Handle *s,
683                          const struct GNUNET_CONFIGURATION_Handle *c)
684 {
685   sched = s;
686   cfg = c;
687   ifm = GNUNET_CONTAINER_multihashmap_create (128);
688   GNUNET_SCHEDULER_add_delayed (sched,
689                                 GNUNET_TIME_UNIT_FOREVER_REL,
690                                 &shutdown_task,
691                                 NULL);
692   read_index_list ();
693   return GNUNET_OK;
694 }
695
696 /* end of gnunet-service-fs_indexing.c */