src/fs/fs_unindex.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2003--2013 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/fs_unindex.c
  23  * @author Krista Grothoff
  24  * @author Christian Grothoff
  25  * @brief Unindex file.
  26  */
  27 #include "platform.h"
  28 #include "gnunet_constants.h"
  29 #include "gnunet_fs_service.h"
  30 #include "gnunet_protocols.h"
  31 #include "fs_api.h"
  32 #include "fs_tree.h"
  33 #include "block_fs.h"
  34
  35
  36 /**
  37  * Function called by the tree encoder to obtain
  38  * a block of plaintext data (for the lowest level
  39  * of the tree).
  40  *
  41  * @param cls our publishing context
  42  * @param offset identifies which block to get
  43  * @param max (maximum) number of bytes to get; returning
  44  *        fewer will also cause errors
  45  * @param buf where to copy the plaintext buffer
  46  * @param emsg location to store an error message (on error)
  47  * @return number of bytes copied to buf, 0 on error
  48  */
  49 static size_t
  50 unindex_reader (void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
  51 {
  52   struct GNUNET_FS_UnindexContext *uc = cls;
  53   size_t pt_size;
  54
  55   pt_size = GNUNET_MIN (max, uc->file_size - offset);
  56   if (offset != GNUNET_DISK_file_seek (uc->fh, offset, GNUNET_DISK_SEEK_SET))
  57   {
  58     *emsg = GNUNET_strdup (_("Failed to find given position in file"));
  59     return 0;
  60   }
  61   if (pt_size != GNUNET_DISK_file_read (uc->fh, buf, pt_size))
  62   {
  63     *emsg = GNUNET_strdup (_("Failed to read file"));
  64     return 0;
  65   }
  66   return pt_size;
  67 }
  68
  69
  70 /**
  71  * Fill in all of the generic fields for
  72  * an unindex event and call the callback.
  73  *
  74  * @param pi structure to fill in
  75  * @param uc overall unindex context
  76  * @param offset where we are in the file (for progress)
  77  */
  78 void
  79 GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  80                                 struct GNUNET_FS_UnindexContext *uc,
  81                                 uint64_t offset)
  82 {
  83   pi->value.unindex.uc = uc;
  84   pi->value.unindex.cctx = uc->client_info;
  85   pi->value.unindex.filename = uc->filename;
  86   pi->value.unindex.size = uc->file_size;
  87   pi->value.unindex.eta =
  88       GNUNET_TIME_calculate_eta (uc->start_time, offset, uc->file_size);
  89   pi->value.unindex.duration =
  90       GNUNET_TIME_absolute_get_duration (uc->start_time);
  91   pi->value.unindex.completed = offset;
  92   pi->fsh = uc->h;
  93   uc->client_info = uc->h->upcb (uc->h->upcb_cls, pi);
  94 }
  95
  96
  97 /**
  98  * Function called with information about our
  99  * progress in computing the tree encoding.
 100  *
 101  * @param cls closure
 102  * @param offset where are we in the file
 103  * @param pt_block plaintext of the currently processed block
 104  * @param pt_size size of pt_block
 105  * @param depth depth of the block in the tree, 0 for DBLOCK
 106  */
 107 static void
 108 unindex_progress (void *cls, uint64_t offset, const void *pt_block,
 109                   size_t pt_size, unsigned int depth)
 110 {
 111   struct GNUNET_FS_UnindexContext *uc = cls;
 112   struct GNUNET_FS_ProgressInfo pi;
 113
 114   pi.status = GNUNET_FS_STATUS_UNINDEX_PROGRESS;
 115   pi.value.unindex.specifics.progress.data = pt_block;
 116   pi.value.unindex.specifics.progress.offset = offset;
 117   pi.value.unindex.specifics.progress.data_len = pt_size;
 118   pi.value.unindex.specifics.progress.depth = depth;
 119   GNUNET_FS_unindex_make_status_ (&pi, uc, offset);
 120 }
 121
 122
 123 /**
 124  * We've encountered an error during
 125  * unindexing.  Signal the client.
 126  *
 127  * @param uc context for the failed unindexing operation
 128  */
 129 static void
 130 signal_unindex_error (struct GNUNET_FS_UnindexContext *uc)
 131 {
 132   struct GNUNET_FS_ProgressInfo pi;
 133
 134   pi.status = GNUNET_FS_STATUS_UNINDEX_ERROR;
 135   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
 136   pi.value.unindex.specifics.error.message = uc->emsg;
 137   GNUNET_FS_unindex_make_status_ (&pi, uc, 0);
 138 }
 139
 140
 141 /**
 142  * Continuation called to notify client about result of the
 143  * datastore removal operation.
 144  *
 145  * @param cls closure
 146  * @param success GNUNET_SYSERR on failure
 147  * @param min_expiration minimum expiration time required for content to be stored
 148  * @param msg NULL on success, otherwise an error message
 149  */
 150 static void
 151 process_cont (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
 152 {
 153   struct GNUNET_FS_UnindexContext *uc = cls;
 154
 155   if (success == GNUNET_SYSERR)
 156   {
 157     uc->emsg = GNUNET_strdup (msg);
 158     signal_unindex_error (uc);
 159     return;
 160   }
 161   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 162               "Datastore REMOVE operation succeeded\n");
 163   GNUNET_FS_tree_encoder_next (uc->tc);
 164 }
 165
 166
 167 /**
 168  * Function called asking for the current (encoded)
 169  * block to be processed.  After processing the
 170  * client should either call "GNUNET_FS_tree_encode_next"
 171  * or (on error) "GNUNET_FS_tree_encode_finish".
 172  *
 173  * @param cls closure
 174  * @param chk content hash key for the block (key for lookup in the datastore)
 175  * @param offset offset of the block
 176  * @param depth depth of the block, 0 for DBLOCK
 177  * @param type type of the block (IBLOCK or DBLOCK)
 178  * @param block the (encrypted) block
 179  * @param block_size size of block (in bytes)
 180  */
 181 static void
 182 unindex_process (void *cls, const struct ContentHashKey *chk, uint64_t offset,
 183                  unsigned int depth, enum GNUNET_BLOCK_Type type,
 184                  const void *block, uint16_t block_size)
 185 {
 186   struct GNUNET_FS_UnindexContext *uc = cls;
 187   uint32_t size;
 188   const void *data;
 189   struct OnDemandBlock odb;
 190
 191   if (type != GNUNET_BLOCK_TYPE_FS_DBLOCK)
 192   {
 193     size = block_size;
 194     data = block;
 195   }
 196   else                          /* on-demand encoded DBLOCK */
 197   {
 198     size = sizeof (struct OnDemandBlock);
 199     odb.offset = GNUNET_htonll (offset);
 200     odb.file_id = uc->file_id;
 201     data = &odb;
 202   }
 203   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 204               "Sending REMOVE request to DATASTORE service\n");
 205   GNUNET_DATASTORE_remove (uc->dsh, &chk->query, size, data, -2, 1,
 206                            GNUNET_CONSTANTS_SERVICE_TIMEOUT, &process_cont, uc);
 207   uc->chk = *chk;
 208 }
 209
 210
 211 /**
 212  * Function called with the response from the
 213  * FS service to our unindexing request.
 214  *
 215  * @param cls closure, unindex context
 216  * @param msg NULL on timeout, otherwise the response
 217  */
 218 static void
 219 process_fs_response (void *cls, const struct GNUNET_MessageHeader *msg)
 220 {
 221   struct GNUNET_FS_UnindexContext *uc = cls;
 222   struct GNUNET_FS_ProgressInfo pi;
 223
 224   if (uc->client != NULL)
 225   {
 226     GNUNET_CLIENT_disconnect (uc->client);
 227     uc->client = NULL;
 228   }
 229   if (uc->state != UNINDEX_STATE_FS_NOTIFY)
 230   {
 231     uc->state = UNINDEX_STATE_ERROR;
 232     uc->emsg =
 233         GNUNET_strdup (_("Unexpected time for a response from `fs' service."));
 234     GNUNET_FS_unindex_sync_ (uc);
 235     signal_unindex_error (uc);
 236     return;
 237   }
 238   if (NULL == msg)
 239   {
 240     uc->state = UNINDEX_STATE_ERROR;
 241     uc->emsg = GNUNET_strdup (_("Timeout waiting for `fs' service."));
 242     GNUNET_FS_unindex_sync_ (uc);
 243     signal_unindex_error (uc);
 244     return;
 245   }
 246   if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK)
 247   {
 248     uc->state = UNINDEX_STATE_ERROR;
 249     uc->emsg = GNUNET_strdup (_("Invalid response from `fs' service."));
 250     GNUNET_FS_unindex_sync_ (uc);
 251     signal_unindex_error (uc);
 252     return;
 253   }
 254   uc->state = UNINDEX_STATE_COMPLETE;
 255   pi.status = GNUNET_FS_STATUS_UNINDEX_COMPLETED;
 256   pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
 257   GNUNET_FS_unindex_sync_ (uc);
 258   GNUNET_FS_unindex_make_status_ (&pi, uc, uc->file_size);
 259 }
 260
 261
 262 /**
 263  * Function called when we are done with removing UBlocks.
 264  * Disconnect from datastore and notify FS service about
 265  * the unindex event.
 266  *
 267  * @param uc our unindexing context
 268  */
 269 static void
 270 unindex_finish (struct GNUNET_FS_UnindexContext *uc)
 271 {
 272   char *emsg;
 273   struct GNUNET_FS_Uri *uri;
 274   struct UnindexMessage req;
 275
 276   /* generate final progress message */
 277   unindex_progress (uc, uc->file_size, NULL, 0, 0);
 278   GNUNET_FS_tree_encoder_finish (uc->tc, &uri, &emsg);
 279   uc->tc = NULL;
 280   if (uri != NULL)
 281     GNUNET_FS_uri_destroy (uri);
 282   GNUNET_DISK_file_close (uc->fh);
 283   uc->fh = NULL;
 284   GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
 285   uc->dsh = NULL;
 286   uc->state = UNINDEX_STATE_FS_NOTIFY;
 287   GNUNET_FS_unindex_sync_ (uc);
 288   uc->client = GNUNET_CLIENT_connect ("fs", uc->h->cfg);
 289   if (uc->client == NULL)
 290   {
 291     uc->state = UNINDEX_STATE_ERROR;
 292     uc->emsg =
 293         GNUNET_strdup (_("Failed to connect to FS service for unindexing."));
 294     GNUNET_FS_unindex_sync_ (uc);
 295     signal_unindex_error (uc);
 296     return;
 297   }
 298   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 299               "Sending UNINDEX message to FS service\n");
 300   req.header.size = htons (sizeof (struct UnindexMessage));
 301   req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX);
 302   req.reserved = 0;
 303   req.file_id = uc->file_id;
 304   GNUNET_break (GNUNET_OK ==
 305                 GNUNET_CLIENT_transmit_and_get_response (uc->client,
 306                                                          &req.header,
 307                                                          GNUNET_CONSTANTS_SERVICE_TIMEOUT,
 308                                                          GNUNET_YES,
 309                                                          &process_fs_response,
 310                                                          uc));
 311 }
 312
 313
 314
 315 /**
 316  * Function called by the directory scanner as we extract keywords
 317  * that we will need to remove UBlocks.
 318  *
 319  * @param cls the 'struct GNUNET_FS_UnindexContext *'
 320  * @param filename which file we are making progress on
 321  * @param is_directory GNUNET_YES if this is a directory,
 322  *                     GNUNET_NO if this is a file
 323  *                     GNUNET_SYSERR if it is neither (or unknown)
 324  * @param reason kind of progress we are making
 325  */
 326 static void
 327 unindex_directory_scan_cb (void *cls,
 328                            const char *filename,
 329                            int is_directory,
 330                            enum GNUNET_FS_DirScannerProgressUpdateReason reason)
 331 {
 332   struct GNUNET_FS_UnindexContext *uc = cls;
 333   static struct GNUNET_FS_ShareTreeItem * directory_scan_result;
 334
 335   switch (reason)
 336   {
 337   case GNUNET_FS_DIRSCANNER_FINISHED:
 338     directory_scan_result = GNUNET_FS_directory_scan_get_result (uc->dscan);
 339     uc->dscan = NULL;
 340     if (NULL != directory_scan_result->ksk_uri)
 341     {
 342       uc->ksk_uri = GNUNET_FS_uri_dup (directory_scan_result->ksk_uri);
 343       uc->state = UNINDEX_STATE_DS_REMOVE_KBLOCKS;
 344       GNUNET_FS_unindex_sync_ (uc);
 345       GNUNET_FS_unindex_do_remove_kblocks_ (uc);
 346     }
 347     else
 348     {
 349       uc->emsg = GNUNET_strdup (_("Failed to get KSKs from directory scan."));
 350       GNUNET_FS_unindex_sync_ (uc);
 351       unindex_finish (uc);
 352     }
 353     GNUNET_FS_share_tree_free (directory_scan_result);
 354     break;
 355   case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
 356     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 357                 _("Internal error scanning `%s'.\n"),
 358                 uc->filename);
 359     GNUNET_FS_directory_scan_abort (uc->dscan);
 360     uc->dscan = NULL;
 361     uc->emsg = GNUNET_strdup (_("Failed to get KSKs from directory scan."));
 362     GNUNET_FS_unindex_sync_ (uc);
 363     unindex_finish (uc);
 364     break;
 365   default:
 366     break;
 367   }
 368 }
 369
 370
 371 /**
 372  * If necessary, connect to the datastore and remove the UBlocks.
 373  *
 374  * @param uc context for the unindex operation.
 375  */
 376 void
 377 GNUNET_FS_unindex_do_extract_keywords_ (struct GNUNET_FS_UnindexContext *uc)
 378 {
 379   char *ex;
 380
 381   if (GNUNET_OK !=
 382       GNUNET_CONFIGURATION_get_value_string (uc->h->cfg, "FS", "EXTRACTORS", &ex))
 383     ex = NULL;
 384   uc->dscan = GNUNET_FS_directory_scan_start (uc->filename,
 385                                               GNUNET_NO, ex,
 386                                               &unindex_directory_scan_cb,
 387                                               uc);
 388   GNUNET_free_non_null (ex);
 389 }
 390
 391
 392 /**
 393  * Continuation called to notify client about result of the remove
 394  * operation for the UBlock.
 395  *
 396  * @param cls the 'struct GNUNET_FS_UnindexContext *'
 397  * @param success GNUNET_SYSERR on failure (including timeout/queue drop)
 398  *                GNUNET_NO if content was already there
 399  *                GNUNET_YES (or other positive value) on success
 400  * @param min_expiration minimum expiration time required for 0-priority content to be stored
 401  *                by the datacache at this time, zero for unknown, forever if we have no
 402  *                space for 0-priority content
 403  * @param msg NULL on success, otherwise an error message
 404  */
 405 static void
 406 continue_after_remove (void *cls,
 407                        int32_t success,
 408                        struct GNUNET_TIME_Absolute min_expiration,
 409                        const char *msg)
 410 {
 411   struct GNUNET_FS_UnindexContext *uc = cls;
 412
 413   uc->dqe = NULL;
 414   if (success != GNUNET_YES)
 415     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 416                 _("Failed to remove UBlock: %s\n"),
 417                 msg);
 418   uc->ksk_offset++;
 419   GNUNET_FS_unindex_do_remove_kblocks_ (uc);
 420 }
 421
 422
 423 /**
 424  * Function called from datastore with result from us looking for
 425  * a UBlock.  There are four cases:
 426  * 1) no result, means we move on to the next keyword
 427  * 2) UID is the same as the first UID, means we move on to next keyword
 428  * 3) UBlock for a different CHK, means we keep looking for more
 429  * 4) UBlock is for our CHK, means we remove the block and then move
 430  *           on to the next keyword
 431  *
 432  * @param cls the 'struct GNUNET_FS_UnindexContext *'
 433  * @param key key for the content
 434  * @param size number of bytes in data
 435  * @param data content stored
 436  * @param type type of the content
 437  * @param priority priority of the content
 438  * @param anonymity anonymity-level for the content
 439  * @param expiration expiration time for the content
 440  * @param uid unique identifier for the datum;
 441  *        maybe 0 if no unique identifier is available
 442  */
 443 static void
 444 process_kblock_for_unindex (void *cls,
 445                             const struct GNUNET_HashCode *key,
 446                             size_t size, const void *data,
 447                             enum GNUNET_BLOCK_Type type,
 448                             uint32_t priority,
 449                             uint32_t anonymity,
 450                             struct GNUNET_TIME_Absolute
 451                             expiration, uint64_t uid)
 452 {
 453   struct GNUNET_FS_UnindexContext *uc = cls;
 454   const struct UBlock *ub;
 455   struct GNUNET_FS_Uri *chk_uri;
 456   struct GNUNET_HashCode query;
 457
 458   uc->dqe = NULL;
 459   if (NULL == data)
 460   {
 461     /* no result */
 462     uc->ksk_offset++;
 463     GNUNET_FS_unindex_do_remove_kblocks_ (uc);
 464     return;
 465   }
 466   if (0 == uc->first_uid)
 467   {
 468     /* remember UID of first result to detect cycles */
 469     uc->first_uid = uid;
 470   }
 471   else if (uid == uc->first_uid)
 472   {
 473     /* no more additional results */
 474     uc->ksk_offset++;
 475     GNUNET_FS_unindex_do_remove_kblocks_ (uc);
 476     return;
 477   }
 478   GNUNET_assert (GNUNET_BLOCK_TYPE_FS_UBLOCK == type);
 479   if (size < sizeof (struct UBlock))
 480   {
 481     GNUNET_break (0);
 482     goto get_next;
 483   }
 484   ub = data;
 485   GNUNET_CRYPTO_hash (&ub->verification_key,
 486                       sizeof (ub->verification_key),
 487                       &query);
 488   if (0 != memcmp (&query, key, sizeof (struct GNUNET_HashCode)))
 489   {
 490     /* result does not match our keyword, skip */
 491     goto get_next;
 492   }
 493   {
 494     char pt[size - sizeof (struct UBlock)];
 495     struct GNUNET_CRYPTO_AesSessionKey skey;
 496     struct GNUNET_CRYPTO_AesInitializationVector iv;
 497
 498     GNUNET_CRYPTO_hash_to_aes_key (&uc->ukey, &skey, &iv);
 499     if (-1 ==
 500         GNUNET_CRYPTO_aes_decrypt (&ub[1], size - sizeof (struct UBlock), &skey,
 501                                    &iv, pt))
 502     {
 503       GNUNET_break (0);
 504       goto get_next;
 505     }
 506     if (NULL == memchr (&pt[1], 0, sizeof (pt) - 1))
 507     {
 508       GNUNET_break_op (0); /* malformed UBlock */
 509       goto get_next;
 510     }
 511     chk_uri = GNUNET_FS_uri_parse (&pt[1], NULL);
 512     if (NULL == chk_uri)
 513     {
 514       GNUNET_break_op (0); /* malformed UBlock */
 515       goto get_next;
 516     }
 517   }
 518   if (0 != memcmp (&uc->chk,
 519                    &chk_uri->data.chk.chk,
 520                    sizeof (struct ContentHashKey)))
 521   {
 522     /* different CHK, ignore */
 523     GNUNET_FS_uri_destroy (chk_uri);
 524     goto get_next;
 525   }
 526   GNUNET_FS_uri_destroy (chk_uri);
 527   /* matches! */
 528   uc->dqe = GNUNET_DATASTORE_remove (uc->dsh,
 529                                      key, size, data,
 530                                      0 /* priority */, 1 /* queue size */,
 531                                      GNUNET_TIME_UNIT_FOREVER_REL,
 532                                      &continue_after_remove,
 533                                      uc);
 534   return;
 535  get_next:
 536   uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
 537                                       uc->roff++,
 538                                       &uc->uquery,
 539                                       GNUNET_BLOCK_TYPE_FS_UBLOCK,
 540                                       0 /* priority */, 1 /* queue size */,
 541                                       GNUNET_TIME_UNIT_FOREVER_REL,
 542                                       &process_kblock_for_unindex,
 543                                       uc);
 544 }
 545
 546
 547 /**
 548  * If necessary, connect to the datastore and remove the KBlocks.
 549  *
 550  * @param uc context for the unindex operation.
 551  */
 552 void
 553 GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
 554 {
 555   const char *keyword;
 556   const struct GNUNET_CRYPTO_EccPrivateKey *anon;
 557   struct GNUNET_CRYPTO_EccPublicKey anon_pub;
 558   struct GNUNET_CRYPTO_EccPublicKey dpub;
 559
 560   if (NULL == uc->dsh)
 561     uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
 562   if (NULL == uc->dsh)
 563   {
 564     uc->state = UNINDEX_STATE_ERROR;
 565     uc->emsg = GNUNET_strdup (_("Failed to connect to `datastore' service."));
 566     GNUNET_FS_unindex_sync_ (uc);
 567     signal_unindex_error (uc);
 568     return;
 569   }
 570   if ( (NULL == uc->ksk_uri) ||
 571        (uc->ksk_offset >= uc->ksk_uri->data.ksk.keywordCount) )
 572   {
 573     unindex_finish (uc);
 574     return;
 575   }
 576   anon = GNUNET_CRYPTO_ecc_key_get_anonymous ();
 577   GNUNET_CRYPTO_ecc_key_get_public (anon, &anon_pub);
 578   keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
 579   GNUNET_CRYPTO_ecc_public_key_derive (&anon_pub,
 580                                        keyword,
 581                                        &dpub);
 582   GNUNET_CRYPTO_hash (&dpub,
 583                       sizeof (dpub),
 584                       &uc->uquery);
 585   uc->first_uid = 0;
 586   uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
 587                                       uc->roff++,
 588                                       &uc->uquery,
 589                                       GNUNET_BLOCK_TYPE_FS_UBLOCK,
 590                                       0 /* priority */, 1 /* queue size */,
 591                                       GNUNET_TIME_UNIT_FOREVER_REL,
 592                                       &process_kblock_for_unindex,
 593                                       uc);
 594 }
 595
 596
 597 /**
 598  * Function called when the tree encoder has
 599  * processed all blocks.  Clean up.
 600  *
 601  * @param cls our unindexing context
 602  * @param tc not used
 603  */
 604 static void
 605 unindex_extract_keywords (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 606 {
 607   struct GNUNET_FS_UnindexContext *uc = cls;
 608
 609   uc->state = UNINDEX_STATE_EXTRACT_KEYWORDS;
 610   GNUNET_FS_unindex_sync_ (uc);
 611   GNUNET_FS_unindex_do_extract_keywords_ (uc);
 612 }
 613
 614
 615 /**
 616  * Connect to the datastore and remove the blocks.
 617  *
 618  * @param uc context for the unindex operation.
 619  */
 620 void
 621 GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
 622 {
 623   if (NULL == uc->dsh)
 624     uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
 625   if (NULL == uc->dsh)
 626   {
 627     uc->state = UNINDEX_STATE_ERROR;
 628     uc->emsg = GNUNET_strdup (_("Failed to connect to `datastore' service."));
 629     GNUNET_FS_unindex_sync_ (uc);
 630     signal_unindex_error (uc);
 631     return;
 632   }
 633   uc->fh =
 634       GNUNET_DISK_file_open (uc->filename, GNUNET_DISK_OPEN_READ,
 635                              GNUNET_DISK_PERM_NONE);
 636   if (NULL == uc->fh)
 637   {
 638     GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
 639     uc->dsh = NULL;
 640     uc->state = UNINDEX_STATE_ERROR;
 641     uc->emsg = GNUNET_strdup (_("Failed to open file for unindexing."));
 642     GNUNET_FS_unindex_sync_ (uc);
 643     signal_unindex_error (uc);
 644     return;
 645   }
 646   uc->tc =
 647       GNUNET_FS_tree_encoder_create (uc->h, uc->file_size, uc, &unindex_reader,
 648                                      &unindex_process, &unindex_progress,
 649                                      &unindex_extract_keywords);
 650   GNUNET_FS_tree_encoder_next (uc->tc);
 651 }
 652
 653
 654 /**
 655  * Function called once the hash of the file
 656  * that is being unindexed has been computed.
 657  *
 658  * @param cls closure, unindex context
 659  * @param file_id computed hash, NULL on error
 660  */
 661 void
 662 GNUNET_FS_unindex_process_hash_ (void *cls, const struct GNUNET_HashCode * file_id)
 663 {
 664   struct GNUNET_FS_UnindexContext *uc = cls;
 665
 666   uc->fhc = NULL;
 667   if (uc->state != UNINDEX_STATE_HASHING)
 668   {
 669     GNUNET_FS_unindex_stop (uc);
 670     return;
 671   }
 672   if (file_id == NULL)
 673   {
 674     uc->state = UNINDEX_STATE_ERROR;
 675     uc->emsg = GNUNET_strdup (_("Failed to compute hash of file."));
 676     GNUNET_FS_unindex_sync_ (uc);
 677     signal_unindex_error (uc);
 678     return;
 679   }
 680   uc->file_id = *file_id;
 681   uc->state = UNINDEX_STATE_DS_REMOVE;
 682   GNUNET_FS_unindex_sync_ (uc);
 683   GNUNET_FS_unindex_do_remove_ (uc);
 684 }
 685
 686
 687 /**
 688  * Create SUSPEND event for the given unindex operation
 689  * and then clean up our state (without stop signal).
 690  *
 691  * @param cls the 'struct GNUNET_FS_UnindexContext' to signal for
 692  */
 693 void
 694 GNUNET_FS_unindex_signal_suspend_ (void *cls)
 695 {
 696   struct GNUNET_FS_UnindexContext *uc = cls;
 697   struct GNUNET_FS_ProgressInfo pi;
 698
 699   /* FIXME: lots of duplication with unindex_stop here! */
 700   if (uc->dscan != NULL)
 701   {
 702     GNUNET_FS_directory_scan_abort (uc->dscan);
 703     uc->dscan = NULL;
 704   }
 705   if (NULL != uc->dqe)
 706   {
 707     GNUNET_DATASTORE_cancel (uc->dqe);
 708     uc->dqe = NULL;
 709   }
 710   if (uc->fhc != NULL)
 711   {
 712     GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
 713     uc->fhc = NULL;
 714   }
 715   if (NULL != uc->ksk_uri)
 716   {
 717     GNUNET_FS_uri_destroy (uc->ksk_uri);
 718     uc->ksk_uri = NULL;
 719   }
 720   if (uc->client != NULL)
 721   {
 722     GNUNET_CLIENT_disconnect (uc->client);
 723     uc->client = NULL;
 724   }
 725   if (NULL != uc->dsh)
 726   {
 727     GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
 728     uc->dsh = NULL;
 729   }
 730   if (NULL != uc->tc)
 731   {
 732     GNUNET_FS_tree_encoder_finish (uc->tc, NULL, NULL);
 733     uc->tc = NULL;
 734   }
 735   if (uc->fh != NULL)
 736   {
 737     GNUNET_DISK_file_close (uc->fh);
 738     uc->fh = NULL;
 739   }
 740   GNUNET_FS_end_top (uc->h, uc->top);
 741   pi.status = GNUNET_FS_STATUS_UNINDEX_SUSPEND;
 742   GNUNET_FS_unindex_make_status_ (&pi, uc,
 743                                   (uc->state ==
 744                                    UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
 745   GNUNET_break (NULL == uc->client_info);
 746   GNUNET_free (uc->filename);
 747   GNUNET_free_non_null (uc->serialization);
 748   GNUNET_free_non_null (uc->emsg);
 749   GNUNET_free (uc);
 750 }
 751
 752
 753 /**
 754  * Unindex a file.
 755  *
 756  * @param h handle to the file sharing subsystem
 757  * @param filename file to unindex
 758  * @param cctx initial value for the client context
 759  * @return NULL on error, otherwise handle
 760  */
 761 struct GNUNET_FS_UnindexContext *
 762 GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h, const char *filename,
 763                          void *cctx)
 764 {
 765   struct GNUNET_FS_UnindexContext *ret;
 766   struct GNUNET_FS_ProgressInfo pi;
 767   uint64_t size;
 768
 769   if (GNUNET_OK != GNUNET_DISK_file_size (filename, &size, GNUNET_YES, GNUNET_YES))
 770     return NULL;
 771   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_UnindexContext));
 772   ret->h = h;
 773   ret->filename = GNUNET_strdup (filename);
 774   ret->start_time = GNUNET_TIME_absolute_get ();
 775   ret->file_size = size;
 776   ret->client_info = cctx;
 777   GNUNET_FS_unindex_sync_ (ret);
 778   pi.status = GNUNET_FS_STATUS_UNINDEX_START;
 779   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
 780   GNUNET_FS_unindex_make_status_ (&pi, ret, 0);
 781   ret->fhc =
 782       GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE, filename,
 783                                HASHING_BLOCKSIZE,
 784                                &GNUNET_FS_unindex_process_hash_, ret);
 785   ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_unindex_signal_suspend_, ret);
 786   return ret;
 787 }
 788
 789
 790 /**
 791  * Clean up after completion of an unindex operation.
 792  *
 793  * @param uc handle
 794  */
 795 void
 796 GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
 797 {
 798   struct GNUNET_FS_ProgressInfo pi;
 799
 800   if (uc->dscan != NULL)
 801   {
 802     GNUNET_FS_directory_scan_abort (uc->dscan);
 803     uc->dscan = NULL;
 804   }
 805   if (NULL != uc->dqe)
 806   {
 807     GNUNET_DATASTORE_cancel (uc->dqe);
 808     uc->dqe = NULL;
 809   }
 810   if (uc->fhc != NULL)
 811   {
 812     GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
 813     uc->fhc = NULL;
 814   }
 815   if (uc->client != NULL)
 816   {
 817     GNUNET_CLIENT_disconnect (uc->client);
 818     uc->client = NULL;
 819   }
 820   if (NULL != uc->dsh)
 821   {
 822     GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
 823     uc->dsh = NULL;
 824   }
 825   if (NULL != uc->ksk_uri)
 826   {
 827     GNUNET_FS_uri_destroy (uc->ksk_uri);
 828     uc->ksk_uri = NULL;
 829   }
 830   if (NULL != uc->tc)
 831   {
 832     GNUNET_FS_tree_encoder_finish (uc->tc, NULL, NULL);
 833     uc->tc = NULL;
 834   }
 835   if (uc->fh != NULL)
 836   {
 837     GNUNET_DISK_file_close (uc->fh);
 838     uc->fh = NULL;
 839   }
 840   GNUNET_FS_end_top (uc->h, uc->top);
 841   if (uc->serialization != NULL)
 842   {
 843     GNUNET_FS_remove_sync_file_ (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
 844                                  uc->serialization);
 845     GNUNET_free (uc->serialization);
 846     uc->serialization = NULL;
 847   }
 848   pi.status = GNUNET_FS_STATUS_UNINDEX_STOPPED;
 849   pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
 850   GNUNET_FS_unindex_make_status_ (&pi, uc,
 851                                   (uc->state ==
 852                                    UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
 853   GNUNET_break (NULL == uc->client_info);
 854   GNUNET_free_non_null (uc->emsg);
 855   GNUNET_free (uc->filename);
 856   GNUNET_free (uc);
 857 }
 858
 859 /* end of fs_unindex.c */