fix

[oweals/gnunet.git] / src / fs / fs_unindex.c

diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index d53683dac64883a877e03d05f7022e026717f7b2..474e791d99a26be602b9ecc24c87585bf2405f82 100644 (file)
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -139,7 +139,6 @@ unindex_progress (void *cls,
  * unindexing.  Signal the client.
  *
  * @param uc context for the failed unindexing operation
- * @param emsg the error message
  */
 static void
 signal_unindex_error (struct GNUNET_FS_UnindexContext *uc)
@@ -219,49 +218,10 @@ unindex_process (void *cls,
                           query,
                           size,
                           data,
+                          -2, 1,
+                          GNUNET_CONSTANTS_SERVICE_TIMEOUT,
                           &process_cont,
-                          uc,
-                          GNUNET_CONSTANTS_SERVICE_TIMEOUT);
-}
-
-
-/**
- * Function called when the tree encoder has
- * processed all blocks.  Clean up.
- *
- * @param cls our unindexing context
- * @param tc not used
- */
-static void
-unindex_finish (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct GNUNET_FS_UnindexContext *uc = cls;
-  char *emsg;
-  struct GNUNET_FS_Uri *uri;
-  struct GNUNET_FS_ProgressInfo pi;
-
-  GNUNET_FS_tree_encoder_finish (uc->tc,
-                                &uri,
-                                &emsg);
-  if (uri != NULL)
-    GNUNET_FS_uri_destroy (uri);
-  GNUNET_DISK_file_close (uc->fh);
-  uc->fh = NULL;
-  GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
-  uc->dsh = NULL;
-  if (emsg != NULL)
-    {
-      uc->emsg = emsg;
-      signal_unindex_error (uc);
-    }
-  else
-    {   
-      pi.status = GNUNET_FS_STATUS_UNINDEX_COMPLETED;
-      pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
-      GNUNET_FS_unindex_make_status_ (&pi, uc, uc->file_size);
-    }
-  GNUNET_FS_unindex_sync_ (uc);
+                          uc);
 }
 
 
@@ -277,6 +237,7 @@ process_fs_response (void *cls,
                     const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
+  struct GNUNET_FS_ProgressInfo pi;
 
   if (uc->client != NULL)
     {
@@ -285,7 +246,10 @@ process_fs_response (void *cls,
     }
   if (uc->state != UNINDEX_STATE_FS_NOTIFY) 
     {
-      GNUNET_FS_unindex_stop (uc);
+      uc->state = UNINDEX_STATE_ERROR;
+      uc->emsg = GNUNET_strdup (_("Unexpected time for a response from `fs' service."));
+      GNUNET_FS_unindex_sync_ (uc);
+      signal_unindex_error (uc);
       return;
     }
   if (NULL == msg)
@@ -304,9 +268,64 @@ process_fs_response (void *cls,
       signal_unindex_error (uc);                           
       return;      
     }
-  uc->state = UNINDEX_STATE_DS_REMOVE;
+  uc->state = UNINDEX_STATE_COMPLETE;
+  pi.status = GNUNET_FS_STATUS_UNINDEX_COMPLETED;
+  pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
   GNUNET_FS_unindex_sync_ (uc);
-  GNUNET_FS_unindex_do_remove_ (uc);
+  GNUNET_FS_unindex_make_status_ (&pi, uc, uc->file_size);
+}
+
+
+/**
+ * Function called when the tree encoder has
+ * processed all blocks.  Clean up.
+ *
+ * @param cls our unindexing context
+ * @param tc not used
+ */
+static void
+unindex_finish (void *cls,
+               const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_FS_UnindexContext *uc = cls;
+  char *emsg;
+  struct GNUNET_FS_Uri *uri;
+  struct UnindexMessage req;
+
+  GNUNET_FS_tree_encoder_finish (uc->tc,
+                                &uri,
+                                &emsg);
+  uc->tc = NULL;
+  if (uri != NULL)
+    GNUNET_FS_uri_destroy (uri);
+  GNUNET_DISK_file_close (uc->fh);
+  uc->fh = NULL;
+  GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+  uc->dsh = NULL;
+  uc->state = UNINDEX_STATE_FS_NOTIFY;
+  GNUNET_FS_unindex_sync_ (uc);
+  uc->client = GNUNET_CLIENT_connect (uc->h->sched,
+                                     "fs",
+                                     uc->h->cfg);
+  if (uc->client == NULL)
+    {
+      uc->state = UNINDEX_STATE_ERROR;
+      uc->emsg = GNUNET_strdup (_("Failed to connect to FS service for unindexing."));
+      GNUNET_FS_unindex_sync_ (uc);
+      signal_unindex_error (uc);
+      return;
+    }
+  req.header.size = htons (sizeof (struct UnindexMessage));
+  req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX);
+  req.reserved = 0;
+  req.file_id = uc->file_id;
+  GNUNET_break (GNUNET_OK == 
+               GNUNET_CLIENT_transmit_and_get_response (uc->client,
+                                                        &req.header,
+                                                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                        GNUNET_YES,
+                                                        &process_fs_response,
+                                                        uc));
 }
 
 
@@ -364,8 +383,8 @@ GNUNET_FS_unindex_process_hash_ (void *cls,
                                 const GNUNET_HashCode *file_id)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
-  struct UnindexMessage req;
 
+  uc->fhc = NULL;
   if (uc->state != UNINDEX_STATE_HASHING) 
     {
       GNUNET_FS_unindex_stop (uc);
@@ -380,22 +399,9 @@ GNUNET_FS_unindex_process_hash_ (void *cls,
       return;
     }
   uc->file_id = *file_id;
-  uc->state = UNINDEX_STATE_FS_NOTIFY;
+  uc->state = UNINDEX_STATE_DS_REMOVE;
   GNUNET_FS_unindex_sync_ (uc);
-  uc->client = GNUNET_CLIENT_connect (uc->h->sched,
-                                     "fs",
-                                     uc->h->cfg);
-  req.header.size = htons (sizeof (struct UnindexMessage));
-  req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX);
-  req.reserved = 0;
-  req.file_id = *file_id;
-  GNUNET_break (GNUNET_OK == 
-               GNUNET_CLIENT_transmit_and_get_response (uc->client,
-                                                        &req.header,
-                                                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                        GNUNET_YES,
-                                                        &process_fs_response,
-                                                        uc));
+  GNUNET_FS_unindex_do_remove_ (uc);
 }
 
 
@@ -405,12 +411,39 @@ GNUNET_FS_unindex_process_hash_ (void *cls,
  *
  * @param cls the 'struct GNUNET_FS_UnindexContext' to signal for
  */
-static void
-unindex_signal_suspend (void *cls)
+void
+GNUNET_FS_unindex_signal_suspend_ (void *cls)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
+  if (uc->fhc != NULL)
+    {
+      GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
+      uc->fhc = NULL;
+    }
+  if (uc->client != NULL)
+    {
+      GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
+      uc->client = NULL;
+    }
+  if (NULL != uc->dsh)
+    {
+      GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+      uc->dsh = NULL;
+    }
+  if (NULL != uc->tc)
+    {
+      GNUNET_FS_tree_encoder_finish (uc->tc,
+                                    NULL, 
+                                    NULL);
+      uc->tc = NULL;
+    }
+  if (uc->fh != NULL)
+    {
+      GNUNET_DISK_file_close (uc->fh);
+      uc->fh = NULL;
+    }
   GNUNET_FS_end_top (uc->h, uc->top);
   pi.status = GNUNET_FS_STATUS_UNINDEX_SUSPEND;
   GNUNET_FS_unindex_make_status_ (&pi, uc, 
@@ -455,14 +488,14 @@ GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
   pi.status = GNUNET_FS_STATUS_UNINDEX_START;
   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
   GNUNET_FS_unindex_make_status_ (&pi, ret, 0);
-  GNUNET_CRYPTO_hash_file (h->sched,
-                          GNUNET_SCHEDULER_PRIORITY_IDLE,
-                          filename,
-                          HASHING_BLOCKSIZE,
-                          &GNUNET_FS_unindex_process_hash_,
-                          ret);
+  ret->fhc = GNUNET_CRYPTO_hash_file (h->sched,
+                                     GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                     filename,
+                                     HASHING_BLOCKSIZE,
+                                     &GNUNET_FS_unindex_process_hash_,
+                                     ret);
   ret->top = GNUNET_FS_make_top (h,
-                                &unindex_signal_suspend,
+                                &GNUNET_FS_unindex_signal_suspend_,
                                 ret);
   return ret;
 }
@@ -477,14 +510,35 @@ void
 GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
 {  
   struct GNUNET_FS_ProgressInfo pi;
-
-  GNUNET_FS_end_top (uc->h, uc->top);
-  if ( (uc->state != UNINDEX_STATE_COMPLETE) &&
-       (uc->state != UNINDEX_STATE_ERROR) )
+  
+  if (uc->fhc != NULL)
     {
-      uc->state = UNINDEX_STATE_ABORTED;
-      return;
+      GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
+      uc->fhc = NULL;
     }
+  if (uc->client != NULL)
+    {
+      GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
+      uc->client = NULL;
+    }
+  if (NULL != uc->dsh)
+    {
+      GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+      uc->dsh = NULL;
+    }
+  if (NULL != uc->tc)
+    {
+      GNUNET_FS_tree_encoder_finish (uc->tc,
+                                    NULL, 
+                                    NULL);
+      uc->tc = NULL;
+    }
+  if (uc->fh != NULL)
+    {
+      GNUNET_DISK_file_close (uc->fh);
+      uc->fh = NULL;
+    }
+  GNUNET_FS_end_top (uc->h, uc->top);
   if (uc->serialization != NULL)
     {
       GNUNET_FS_remove_sync_file_ (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX, uc->serialization);