- htons => htonl

[oweals/gnunet.git] / src / fs / gnunet-service-fs_pr.c

diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index ee71019bbf6b1d43fb150afec09e2d7fcb2e0def..0af19d5379f66bc4e5112f2eb2c0ab3429b615cc 100644 (file)
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -504,7 +504,7 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
 {
   char lbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
   struct GetMessage *gm;
-  struct GNUNET_HashCode *ext;
+  struct GNUNET_PeerIdentity *ext;
   size_t msize;
   unsigned int k;
   uint32_t bm;
@@ -537,7 +537,7 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
     k++;
   }
   bf_size = GNUNET_CONTAINER_bloomfilter_get_size (pr->bf);
-  msize = sizeof (struct GetMessage) + bf_size + k * sizeof (struct GNUNET_HashCode);
+  msize = sizeof (struct GetMessage) + bf_size + k * sizeof (struct GNUNET_PeerIdentity);
   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   if (buf_size < msize)
     return msize;
@@ -561,16 +561,14 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
   gm->filter_mutator = htonl (pr->mingle);
   gm->hash_bitmap = htonl (bm);
   gm->query = pr->public_data.query;
-  ext = (struct GNUNET_HashCode *) & gm[1];
+  ext = (struct GNUNET_PeerIdentity *) &gm[1];
   k = 0;
   if (!do_route)
     GNUNET_PEER_resolve (pr->sender_pid,
-                         (struct GNUNET_PeerIdentity *) &ext[k++]);
+                         &ext[k++]);
   if (NULL != pr->public_data.target)
-    memcpy (&ext[k++],
-           pr->public_data.target,
-           sizeof (struct GNUNET_PeerIdentity));
-  if (pr->bf != NULL)
+    ext[k++] = *pr->public_data.target;
+  if (NULL != pr->bf)
     GNUNET_assert (GNUNET_SYSERR !=
                    GNUNET_CONTAINER_bloomfilter_get_raw_data (pr->bf,
                                                               (char *) &ext[k],
@@ -589,13 +587,20 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-clean_request (void *cls, const struct GNUNET_HashCode * key, void *value)
+clean_request (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GSF_PendingRequest *pr = value;
   GSF_LocalLookupContinuation cont;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Cleaning up pending request for `%s'.\n", GNUNET_h2s (key));
+              "Cleaning up pending request for `%s'.\n",
+             GNUNET_h2s (key));
+  if (NULL != pr->mesh_request)
+  {
+    pr->mesh_retry_count = MESH_RETRY_MAX;
+    GSF_mesh_query_cancel (pr->mesh_request);
+    pr->mesh_request = NULL;
+  }
   if (NULL != (cont = pr->llc_cont))
   {
     pr->llc_cont = NULL;
@@ -627,11 +632,6 @@ clean_request (void *cls, const struct GNUNET_HashCode * key, void *value)
     GNUNET_DHT_get_stop (pr->gh);
     pr->gh = NULL;
   }
-  if (NULL != pr->mesh_request)
-  {
-    GSF_mesh_query_cancel (pr->mesh_request);
-    pr->mesh_request = NULL;
-  }
   if (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
   {
     GNUNET_SCHEDULER_cancel (pr->warn_task);
@@ -668,6 +668,12 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup)
      * but do NOT remove from our data-structures, we still need it there
      * to prevent the request from looping */
     pr->rh = NULL;
+    if (NULL != pr->mesh_request)
+    {
+      pr->mesh_retry_count = MESH_RETRY_MAX;
+      GSF_mesh_query_cancel (pr->mesh_request);
+      pr->mesh_request = NULL;
+    }
     if (NULL != (cont = pr->llc_cont))
     {
       pr->llc_cont = NULL;
@@ -684,11 +690,6 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup)
       GNUNET_DHT_get_stop (pr->gh);
       pr->gh = NULL;
     }
-    if (NULL != pr->mesh_request)
-    {
-      GSF_mesh_query_cancel (pr->mesh_request);
-      pr->mesh_request = NULL;
-    }
     if (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
     {
       GNUNET_SCHEDULER_cancel (pr->warn_task);
@@ -716,10 +717,8 @@ GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls)
 }
 
 
-
-
 /**
- * Closure for "process_reply" function.
+ * Closure for process_reply() function.
  */
 struct ProcessReplyClosure
 {
@@ -797,7 +796,9 @@ update_request_performance_data (struct ProcessReplyClosure *prq,
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-process_reply (void *cls, const struct GNUNET_HashCode * key, void *value)
+process_reply (void *cls,
+               const struct GNUNET_HashCode *key,
+               void *value)
 {
   struct ProcessReplyClosure *prq = cls;
   struct GSF_PendingRequest *pr = value;
@@ -1077,7 +1078,7 @@ handle_dht_reply (void *cls, struct GNUNET_TIME_Absolute exp,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Replicating result for query `%s' with priority %u\n",
                 GNUNET_h2s (key), prq.priority);
-    pmc = GNUNET_malloc (sizeof (struct PutMigrationContext));
+    pmc = GNUNET_new (struct PutMigrationContext);
     pmc->start = GNUNET_TIME_absolute_get ();
     pmc->requested = GNUNET_YES;
     if (NULL ==
@@ -1143,15 +1144,15 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
  * @param cls the pending request struct
  * @param type type of the block, ANY on error
  * @param expiration expiration time for the block
- * @param data_size number of bytes in 'data', 0 on error
+ * @param data_size number of bytes in @a data, 0 on error
  * @param data reply block data, NULL on error
  */
 static void
 mesh_reply_proc (void *cls,
-                  enum GNUNET_BLOCK_Type type,
-                  struct GNUNET_TIME_Absolute expiration,
-                  size_t data_size,
-                  const void *data)
+                 enum GNUNET_BLOCK_Type type,
+                 struct GNUNET_TIME_Absolute expiration,
+                 size_t data_size,
+                 const void *data)
 {
   struct GSF_PendingRequest *pr = cls;
   struct ProcessReplyClosure prq;
@@ -1162,18 +1163,18 @@ mesh_reply_proc (void *cls,
   {
     GNUNET_break (NULL == data);
     GNUNET_break (0 == data_size);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-               "Error retrieiving block via mesh\n");
     pr->mesh_retry_count++;
     if (pr->mesh_retry_count >= MESH_RETRY_MAX)
       return; /* give up on mesh */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Error retrieiving block via mesh\n");
     /* retry -- without delay, as this is non-anonymous
        and mesh/mesh connect will take some time anyway */
     pr->mesh_request = GSF_mesh_query (pr->public_data.target,
-                                          &pr->public_data.query,
-                                          pr->public_data.type,
-                                          &mesh_reply_proc,
-                                          pr);
+                                       &pr->public_data.query,
+                                       pr->public_data.type,
+                                       &mesh_reply_proc,
+                                       pr);
     return;
   }
   if (GNUNET_YES !=
@@ -1674,7 +1675,7 @@ GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Replicating result for query `%s' with priority %u\n",
                 GNUNET_h2s (&query), prq.priority);
-    pmc = GNUNET_malloc (sizeof (struct PutMigrationContext));
+    pmc = GNUNET_new (struct PutMigrationContext);
     pmc->start = GNUNET_TIME_absolute_get ();
     pmc->requested = prq.request_found;
     GNUNET_assert (0 != GSF_get_peer_performance_data_ (cp)->pid);