fix

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

diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 6364dac0ad158ce5fd5d2cc01be25c3cf4bf4ed8..4d93579bd227bd16b8ecf008ec958971626ea5e3 100644 (file)
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -109,18 +109,26 @@ GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
 /**
  * Cleanup the publish context, we're done with it.
  *
- * @param pc struct to clean up after
+ * @param cls struct to clean up after
+ * @param tc scheduler context
  */
 static void
-publish_cleanup (struct GNUNET_FS_PublishContext *pc)
+publish_cleanup (void *cls,
+                const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
+  struct GNUNET_FS_PublishContext *pc = cls;
+
   GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
   if (pc->namespace != NULL)
     GNUNET_FS_namespace_delete (pc->namespace, GNUNET_NO);
   GNUNET_free_non_null (pc->nid);  
   GNUNET_free_non_null (pc->nuid);
   GNUNET_free_non_null (pc->serialization);
-  GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
+  if (pc->dsh != NULL)
+    {
+      GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
+      pc->dsh = NULL;
+    }
   if (pc->client != NULL)
     GNUNET_CLIENT_disconnect (pc->client, GNUNET_NO);
   GNUNET_free (pc);
@@ -145,9 +153,12 @@ ds_put_cont (void *cls,
 
   if (GNUNET_SYSERR == pcc->sc->in_network_wait)
     {
-      /* we were aborted in the meantime,
-        finish shutdown! */
-      publish_cleanup (pcc->sc);
+      /* we were aborted in the meantime, finish shutdown! */
+      GNUNET_SCHEDULER_add_continuation (pcc->sc->h->sched,                                     
+                                        &publish_cleanup,
+                                        pcc->sc,
+                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+      GNUNET_free (pcc);
       return;
     }
   GNUNET_assert (GNUNET_YES == pcc->sc->in_network_wait);
@@ -481,6 +492,7 @@ block_proc (void *cls,
                            p->priority,
                            p->anonymity,
                            p->expirationTime,
+                           -2, 1,
                            GNUNET_CONSTANTS_SERVICE_TIMEOUT,
                            &ds_put_cont,
                            dpc_cls);     
@@ -502,6 +514,7 @@ block_proc (void *cls,
                        p->priority,
                        p->anonymity,
                        p->expirationTime,
+                       -2, 1,
                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
                        &ds_put_cont,
                        dpc_cls);
@@ -797,19 +810,19 @@ void
 GNUNET_FS_publish_main_ (void *cls,
                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct GNUNET_FS_PublishContext *sc = cls;
+  struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_FS_FileInformation *p;
   char *fn;
 
-  sc->upload_task = GNUNET_SCHEDULER_NO_TASK;  
-  p = sc->fi_pos;
+  pc->upload_task = GNUNET_SCHEDULER_NO_TASK;  
+  p = pc->fi_pos;
   if (NULL == p)
     {
       /* upload of entire hierarchy complete,
         publish namespace entries */
-      GNUNET_FS_publish_sync_ (sc);
-      publish_sblock (sc);
+      GNUNET_FS_publish_sync_ (pc);
+      publish_sblock (pc);
       return;
     }
   /* find starting position */
@@ -819,8 +832,8 @@ GNUNET_FS_publish_main_ (void *cls,
          (NULL == p->data.dir.entries->chk_uri) )
     {
       p = p->data.dir.entries;
-      sc->fi_pos = p;
-      GNUNET_FS_publish_sync_ (sc);
+      pc->fi_pos = p;
+      GNUNET_FS_publish_sync_ (pc);
     }
   /* abort on error */
   if (NULL != p->emsg)
@@ -849,33 +862,33 @@ GNUNET_FS_publish_main_ (void *cls,
          pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
          pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
          pi.value.publish.specifics.error.message = p->emsg;
-         p->client_info = GNUNET_FS_publish_make_status_ (&pi, sc, p, 0);
+         p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
        }
-      sc->all_done = GNUNET_YES;
-      GNUNET_FS_publish_sync_ (sc);
+      pc->all_done = GNUNET_YES;
+      GNUNET_FS_publish_sync_ (pc);
       return;
     }
   /* handle completion */
   if (NULL != p->chk_uri)
     {
-      GNUNET_FS_publish_sync_ (sc);
+      GNUNET_FS_publish_sync_ (pc);
       /* upload of "p" complete, publish KBlocks! */
       if (p->keywords != NULL)
        {
-         GNUNET_FS_publish_ksk (sc->h,
+         GNUNET_FS_publish_ksk (pc->h,
                                 p->keywords,
                                 p->meta,
                                 p->chk_uri,
                                 p->expirationTime,
                                 p->anonymity,
                                 p->priority,
-                                sc->options,
+                                pc->options,
                                 &publish_kblocks_cont,
-                                sc);
+                                pc);
        }
       else
        {
-         publish_kblocks_cont (sc,
+         publish_kblocks_cont (pc,
                                p->chk_uri,
                                NULL);
        }
@@ -892,27 +905,27 @@ GNUNET_FS_publish_main_ (void *cls,
                      "<no-name>",
                      _("needs to be an actual file"));
          GNUNET_FS_file_information_sync_ (p);
-         publish_content (sc);
+         publish_content (pc);
          return;
        }      
       if (p->data.file.have_hash)
        {
-         hash_for_index_cb (sc,
+         hash_for_index_cb (pc,
                             &p->data.file.file_id);
        }
       else
        {
          p->start_time = GNUNET_TIME_absolute_get ();
-         GNUNET_CRYPTO_hash_file (sc->h->sched,
+         GNUNET_CRYPTO_hash_file (pc->h->sched,
                                   GNUNET_SCHEDULER_PRIORITY_IDLE,
                                   p->filename,
                                   HASHING_BLOCKSIZE,
                                   &hash_for_index_cb,
-                                  sc);
+                                  pc);
        }
       return;
     }
-  publish_content (sc);
+  publish_content (pc);
 }
 
 
@@ -988,6 +1001,11 @@ fip_signal_suspend(void *cls,
   pi.status = GNUNET_FS_STATUS_PUBLISH_SUSPEND;
   GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, sc, fi, off));
   *client_info = NULL;
+  if (NULL != sc->dsh)
+    {
+      GNUNET_DATASTORE_disconnect (sc->dsh, GNUNET_NO);
+      sc->dsh = NULL;
+    }
   return GNUNET_OK;
 }
 
@@ -998,8 +1016,8 @@ fip_signal_suspend(void *cls,
  *
  * @param cls the 'struct GNUNET_FS_PublishContext' to signal for
  */
-static void
-publish_signal_suspend (void *cls)
+void
+GNUNET_FS_publish_signal_suspend_ (void *cls)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
@@ -1012,9 +1030,10 @@ publish_signal_suspend (void *cls)
                                      &fip_signal_suspend,
                                      pc);
   GNUNET_FS_end_top (pc->h, pc->top);
-  publish_cleanup (pc);
+  publish_cleanup (pc, NULL);
 }
 
+
 /**
  * Publish a file or directory.
  *
@@ -1068,7 +1087,7 @@ GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h,
                                      &fip_signal_start,
                                      ret);
   ret->fi_pos = ret->fi;
-  ret->top = GNUNET_FS_make_top (h, &publish_signal_suspend, ret);
+  ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_publish_signal_suspend_, ret);
   GNUNET_FS_publish_sync_ (ret);
   // FIXME: calculate space needed for "fi"
   // and reserve as first task (then trigger
@@ -1114,12 +1133,9 @@ fip_signal_stop(void *cls,
 
   if (fi->serialization != NULL) 
     {
-      if (0 != UNLINK (fi->serialization))
-       {
-         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
-                                   "unlink",
-                                   fi->serialization); 
-       }
+      GNUNET_FS_remove_sync_file_ (sc->h,
+                                  GNUNET_FS_SYNC_PATH_FILE_INFO,
+                                  fi->serialization);
       GNUNET_free (fi->serialization);
       fi->serialization = NULL;
     }
@@ -1143,6 +1159,11 @@ void
 GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc)
 {
   GNUNET_FS_end_top (pc->h, pc->top);
+  if (NULL != pc->dsh)
+    {
+      GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
+      pc->dsh = NULL;
+    }
   if (GNUNET_SCHEDULER_NO_TASK != pc->upload_task)
     {
       GNUNET_SCHEDULER_cancel (pc->h->sched, pc->upload_task);
@@ -1162,7 +1183,7 @@ GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc)
       pc->in_network_wait = GNUNET_SYSERR;
       return;
     }
-  publish_cleanup (pc);
+  publish_cleanup (pc, NULL);
 }
 
 
@@ -1273,7 +1294,11 @@ kb_put_cont (void *cls,
 
   if (GNUNET_OK != success)
     {
-      GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+      if (NULL != pkc->dsh)
+       {
+         GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+         pkc->dsh = NULL;
+       }
       GNUNET_free (pkc->cpy);
       GNUNET_free (pkc->kb);
       pkc->cont (pkc->cont_cls,
@@ -1314,7 +1339,10 @@ publish_ksk_cont (void *cls,
        (NULL == pkc->dsh) )
     {
       if (NULL != pkc->dsh)
-       GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+       {
+         GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+         pkc->dsh = NULL;
+       }
       GNUNET_free (pkc->cpy);
       GNUNET_free (pkc->kb);
       pkc->cont (pkc->cont_cls,
@@ -1355,6 +1383,7 @@ publish_ksk_cont (void *cls,
                        pkc->priority,
                        pkc->anonymity,
                        pkc->expirationTime,
+                       -2, 1,
                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
                        &kb_put_cont,
                        pkc);
@@ -1439,7 +1468,10 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
       GNUNET_break (0);
       GNUNET_free (pkc->kb);
       if (pkc->dsh != NULL)
-       GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+       {
+         GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+         pkc->dsh = NULL;
+       }
       cont (cont_cls, NULL, _("Internal error."));
       GNUNET_free (pkc);
       return;
@@ -1505,7 +1537,10 @@ sb_put_cont (void *cls,
   struct PublishSksContext *psc = cls;
 
   if (NULL != psc->dsh)
-    GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
+    {
+      GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
+      psc->dsh = NULL;
+    }
   if (GNUNET_OK != success)
     psc->cont (psc->cont_cls,
               NULL,
@@ -1589,6 +1624,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   memcpy (dest, update, nidlen);
   dest += nidlen;
   memcpy (dest, uris, slen);
+  GNUNET_free (uris);
   dest += slen;
   mdsize = GNUNET_CONTAINER_meta_data_serialize (mmeta,
                                                 &dest,
@@ -1598,7 +1634,6 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   if (mdsize == -1)
     {
       GNUNET_break (0);
-      GNUNET_free (uris);
       GNUNET_free (sb);
       cont (cont_cls,
            NULL,
@@ -1668,10 +1703,10 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
                        priority,
                        anonymity,
                        expirationTime,
+                       -2, 1,
                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
                        &sb_put_cont,
                        psc);
-
   GNUNET_free (sb);
   GNUNET_free (sb_enc);
 }