projects / oweals / gnunet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(no commit message)
[oweals/gnunet.git] / src / fs / fs_search.c
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index af405bfc0a2a5744f337c6191bc6179baabcfa41..1ffd681aa90a133e79d88b35dd0c9efe16235b65 100644 (file)
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -4,7 +4,7 @@
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -107,6 +107,7 @@ notify_client_chk_result (struct GNUNET_FS_SearchContext *sc,
   pi.value.search.specifics.result.meta = sr->meta;
   pi.value.search.specifics.result.uri = sr->uri;
   pi.value.search.specifics.result.result = sr;
+  pi.value.search.specifics.result.applicability_rank = sr->optional_support;
   sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
 }
 
@@ -278,32 +279,27 @@ GNUNET_FS_search_probe_progress_ (void *cls,
     case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
       if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
        {
-         GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
-                                  sr->probe_cancel_task);
+         GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
        }     
-      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->sc->h->sched,
-                                                           sr->remaining_probe_time,
+      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
                                                            &probe_failure_handler,
                                                            sr);
       break;
     case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
       if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
        {
-         GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
-                                  sr->probe_cancel_task);
+         GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
        }     
-      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->sc->h->sched,
-                                                           sr->remaining_probe_time,
+      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
                                                            &probe_success_handler,
                                                            sr);
       break;
     case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
       if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
        {
-         GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
-                                  sr->probe_cancel_task);
+         GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
        }     
       sr = NULL;
@@ -311,16 +307,14 @@ GNUNET_FS_search_probe_progress_ (void *cls,
     case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
       GNUNET_assert (sr->probe_cancel_task == GNUNET_SCHEDULER_NO_TASK);
       sr->probe_active_time = GNUNET_TIME_absolute_get ();
-      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->sc->h->sched,
-                                                           sr->remaining_probe_time,
+      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
                                                            &probe_failure_handler,
                                                            sr);
       break;
     case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
       if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
        {
-         GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
-                                  sr->probe_cancel_task);
+         GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
        }
       dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
@@ -573,11 +567,15 @@ process_kblock (struct GNUNET_FS_SearchContext *sc,
     }
   /* decrypt */
   GNUNET_CRYPTO_hash_to_aes_key (&sc->requests[i].key, &skey, &iv);
-  GNUNET_CRYPTO_aes_decrypt (&kb[1],
-                            size - sizeof (struct KBlock),
-                            &skey,
-                            &iv,
-                            pt);
+  if (-1 == GNUNET_CRYPTO_aes_decrypt (&kb[1],
+                                      size - sizeof (struct KBlock),
+                                      &skey,
+                                      &iv,
+                                      pt))
+    {
+      GNUNET_break (0);
+      return;
+    }
   /* parse */
   eos = memchr (pt, 0, sizeof (pt));
   if (NULL == eos)
@@ -653,11 +651,15 @@ process_nblock (struct GNUNET_FS_SearchContext *sc,
     }
   /* decrypt */
   GNUNET_CRYPTO_hash_to_aes_key (&sc->requests[i].key, &skey, &iv);
-  GNUNET_CRYPTO_aes_decrypt (&nb[1],
-                            size - sizeof (struct NBlock),
-                            &skey,
-                            &iv,
-                            pt);
+  if (-1 == GNUNET_CRYPTO_aes_decrypt (&nb[1],
+                                      size - sizeof (struct NBlock),
+                                      &skey,
+                                      &iv,
+                                      pt))
+    {
+      GNUNET_break (0);
+      return;
+    }
   /* parse */
   eos = memchr (pt, 0, sizeof (pt));
   if (NULL == eos)
@@ -735,11 +737,15 @@ process_sblock (struct GNUNET_FS_SearchContext *sc,
                      strlen (identifier), 
                      &key);
   GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv);
-  GNUNET_CRYPTO_aes_decrypt (&sb[1],
-                            len,
-                            &skey,
-                            &iv,
-                            pt);
+  if (-1 == GNUNET_CRYPTO_aes_decrypt (&sb[1],
+                                      len,
+                                      &skey,
+                                      &iv,
+                                      pt))
+    {
+      GNUNET_break (0);
+      return;
+    }
   /* parse */
   off = GNUNET_STRINGS_buffer_tokenize (pt,
                                        len, 
@@ -793,7 +799,7 @@ process_result (struct GNUNET_FS_SearchContext *sc,
                const void *data,
                size_t size)
 {
-  if (GNUNET_TIME_absolute_get_duration (expiration).value > 0)
+  if (GNUNET_TIME_absolute_get_duration (expiration).rel_value > 0)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Result received has already expired.\n");
@@ -801,7 +807,7 @@ process_result (struct GNUNET_FS_SearchContext *sc,
     }
   switch (type)
     {
-    case GNUNET_BLOCK_TYPE_KBLOCK:
+    case GNUNET_BLOCK_TYPE_FS_KBLOCK:
       if (! GNUNET_FS_uri_test_ksk (sc->uri))
        {
          GNUNET_break (0);
@@ -814,7 +820,7 @@ process_result (struct GNUNET_FS_SearchContext *sc,
        }
       process_kblock (sc, data, size);
       break;
-    case GNUNET_BLOCK_TYPE_SBLOCK:
+    case GNUNET_BLOCK_TYPE_FS_SBLOCK:
       if (! GNUNET_FS_uri_test_sks (sc->uri))
        {
          GNUNET_break (0);
@@ -827,7 +833,7 @@ process_result (struct GNUNET_FS_SearchContext *sc,
        }
       process_sblock (sc, data, size);
       break;
-    case GNUNET_BLOCK_TYPE_NBLOCK:
+    case GNUNET_BLOCK_TYPE_FS_NBLOCK:
       if (! GNUNET_FS_uri_test_ksk (sc->uri))
        {
          GNUNET_break (0);
@@ -841,9 +847,9 @@ process_result (struct GNUNET_FS_SearchContext *sc,
       process_nblock (sc, data, size);
       break;
     case GNUNET_BLOCK_TYPE_ANY:
-    case GNUNET_BLOCK_TYPE_DBLOCK:
-    case GNUNET_BLOCK_TYPE_ONDEMAND:
-    case GNUNET_BLOCK_TYPE_IBLOCK:
+    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
+    case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
+    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
       GNUNET_break (0);
       break;
     default:
@@ -968,7 +974,7 @@ transmit_search_request (void *cls,
        sm->options = htonl (1);
       else
        sm->options = htonl (0);      
-      sm->type = htonl (GNUNET_BLOCK_TYPE_SBLOCK);
+      sm->type = htonl (GNUNET_BLOCK_TYPE_FS_SBLOCK);
       sm->anonymity_level = htonl (sc->anonymity);
       sm->target = sc->uri->data.sks.namespace;
       identifier = sc->uri->data.sks.identifier;
@@ -1009,8 +1015,7 @@ do_reconnect (void *cls,
   size_t size;
   
   sc->task = GNUNET_SCHEDULER_NO_TASK;
-  client = GNUNET_CLIENT_connect (sc->h->sched,
-                                 "fs",
+  client = GNUNET_CLIENT_connect ("fs",
                                  sc->h->cfg);
   if (NULL == client)
     {
@@ -1047,8 +1052,7 @@ try_reconnect (struct GNUNET_FS_SearchContext *sc)
       sc->client = NULL;
     }
   sc->task
-    = GNUNET_SCHEDULER_add_delayed (sc->h->sched,
-                                   GNUNET_TIME_UNIT_SECONDS,
+    = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                    &do_reconnect,
                                    sc);
 }
@@ -1148,6 +1152,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
          keyword = &sc->uri->data.ksk.keywords[i][1];
          GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc);
          pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc);
+         GNUNET_assert (pk != NULL);
          GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
          GNUNET_CRYPTO_rsa_key_free (pk);
          GNUNET_CRYPTO_hash (&pub,
@@ -1162,8 +1167,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
                              &sc->requests[i].key);
        }
     }
-  sc->client = GNUNET_CLIENT_connect (sc->h->sched,
-                                     "fs",
+  sc->client = GNUNET_CLIENT_connect ("fs",
                                      sc->h->cfg);
   if (NULL == sc->client)
     return GNUNET_SYSERR;
@@ -1190,8 +1194,6 @@ search_result_freeze_probes (void *cls,
                             const GNUNET_HashCode * key,
                             void *value)
 {
-  struct GNUNET_FS_SearchContext *sc = cls;
-  struct GNUNET_FS_Handle *h = sc->h;
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (sr->probe_ctx != NULL)
@@ -1201,8 +1203,7 @@ search_result_freeze_probes (void *cls,
     }
   if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (h->sched,
-                              sr->probe_cancel_task);  
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
       sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
     }
   if (sr->update_search != NULL)
@@ -1247,7 +1248,6 @@ search_result_suspend (void *cls,
                       void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
-  struct GNUNET_FS_Handle *h = sc->h;
   struct GNUNET_FS_SearchResult *sr = value;
   struct GNUNET_FS_ProgressInfo pi;
 
@@ -1267,8 +1267,7 @@ search_result_suspend (void *cls,
   if (sr->probe_ctx != NULL)
     GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);    
   if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (h->sched,
-                            sr->probe_cancel_task);    
+    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
   GNUNET_free (sr);
   return GNUNET_OK;
 }
@@ -1295,8 +1294,7 @@ GNUNET_FS_search_signal_suspend_ (void *cls)
   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
   GNUNET_break (NULL == sc->client_info);
   if (sc->task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sc->h->sched,
-                            sc->task);
+    GNUNET_SCHEDULER_cancel (sc->task);
   if (NULL != sc->client)
     GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
   GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
@@ -1334,6 +1332,8 @@ GNUNET_FS_search_start (struct GNUNET_FS_Handle *h,
 {
   struct GNUNET_FS_SearchContext *ret;
   ret = search_start (h, uri, anonymity, options, cctx, NULL);
+  if (ret == NULL)
+    return NULL;
   ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret);
   return ret;
 }
@@ -1350,8 +1350,7 @@ GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
   struct GNUNET_FS_ProgressInfo pi;
 
   if (sc->task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sc->h->sched,
-                            sc->task);
+    GNUNET_SCHEDULER_cancel (sc->task);
   sc->task = GNUNET_SCHEDULER_NO_TASK;
   if (NULL != sc->client)
     GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
@@ -1401,13 +1400,15 @@ search_result_free (void *cls,
                    void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
-  struct GNUNET_FS_Handle *h = sc->h;
   struct GNUNET_FS_SearchResult *sr = value;
   struct GNUNET_FS_ProgressInfo pi;
 
   if (NULL != sr->download)
     {
       sr->download->search = NULL;
+      sr->download->top = GNUNET_FS_make_top (sr->download->h,
+                                             &GNUNET_FS_download_signal_suspend_,
+                                             sr->download);
       if (NULL != sr->download->serialization)
        {
          GNUNET_FS_remove_sync_file_ (sc->h,
@@ -1439,8 +1440,7 @@ search_result_free (void *cls,
   if (sr->probe_ctx != NULL)
     GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);    
   if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (h->sched,
-                            sr->probe_cancel_task);    
+    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
   GNUNET_free (sr);
   return GNUNET_OK;
 }
@@ -1482,8 +1482,7 @@ GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
   GNUNET_break (NULL == sc->client_info);
   if (sc->task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sc->h->sched,
-                            sc->task);
+    GNUNET_SCHEDULER_cancel (sc->task);
   if (NULL != sc->client)
     GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
   GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
Unnamed repository; edit this file 'description' to name the repository.