diff options
author | Christian Grothoff <christian@grothoff.org> | 2012-05-17 15:48:17 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2012-05-17 15:48:17 +0000 |
commit | 04630c5e40fc4de16393894d0b5ff2ca9055f4e2 (patch) | |
tree | 5661edbbe2cd21be222968dbdd1e469b6d8dda06 | |
parent | 31ef7d36f5c003767aeedee385411f87ad1a9791 (diff) | |
download | gnunet-04630c5e40fc4de16393894d0b5ff2ca9055f4e2.tar.gz gnunet-04630c5e40fc4de16393894d0b5ff2ca9055f4e2.zip |
-fixing 2352
-rw-r--r-- | src/fs/fs_search.c | 101 |
1 files changed, 56 insertions, 45 deletions
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c index de1a698e5..3eacbe9cb 100644 --- a/src/fs/fs_search.c +++ b/src/fs/fs_search.c | |||
@@ -14,10 +14,9 @@ | |||
14 | 14 | ||
15 | You should have received a copy of the GNU General Public License | 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 | 16 | along with GNUnet; see the file COPYING. If not, write to the |
17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, | 17 | Free Software Foundation, Inc., 59 Tem ple Place - Suite 330, |
18 | Boston, MA 02111-1307, USA. | 18 | Boston, MA 02111-1307, USA. |
19 | */ | 19 | */ |
20 | |||
21 | /** | 20 | /** |
22 | * @file fs/fs_search.c | 21 | * @file fs/fs_search.c |
23 | * @brief Helper functions for searching. | 22 | * @brief Helper functions for searching. |
@@ -53,7 +52,7 @@ GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi, | |||
53 | pi->value.search.sc = sc; | 52 | pi->value.search.sc = sc; |
54 | pi->value.search.cctx = sc->client_info; | 53 | pi->value.search.cctx = sc->client_info; |
55 | pi->value.search.pctx = | 54 | pi->value.search.pctx = |
56 | (sc->psearch_result == NULL) ? NULL : sc->psearch_result->client_info; | 55 | (NULL == sc->psearch_result) ? NULL : sc->psearch_result->client_info; |
57 | pi->value.search.query = sc->uri; | 56 | pi->value.search.query = sc->uri; |
58 | pi->value.search.duration = | 57 | pi->value.search.duration = |
59 | GNUNET_TIME_absolute_get_duration (sc->start_time); | 58 | GNUNET_TIME_absolute_get_duration (sc->start_time); |
@@ -276,7 +275,7 @@ GNUNET_FS_search_probe_progress_ (void *cls, | |||
276 | /* ignore */ | 275 | /* ignore */ |
277 | break; | 276 | break; |
278 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: | 277 | case GNUNET_FS_STATUS_DOWNLOAD_ERROR: |
279 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | 278 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
280 | { | 279 | { |
281 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 280 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
282 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; | 281 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; |
@@ -286,7 +285,7 @@ GNUNET_FS_search_probe_progress_ (void *cls, | |||
286 | &probe_failure_handler, sr); | 285 | &probe_failure_handler, sr); |
287 | break; | 286 | break; |
288 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: | 287 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: |
289 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | 288 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
290 | { | 289 | { |
291 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 290 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
292 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; | 291 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; |
@@ -295,7 +294,7 @@ GNUNET_FS_search_probe_progress_ (void *cls, | |||
295 | GNUNET_SCHEDULER_add_now (&probe_success_handler, sr); | 294 | GNUNET_SCHEDULER_add_now (&probe_success_handler, sr); |
296 | break; | 295 | break; |
297 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: | 296 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: |
298 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | 297 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
299 | { | 298 | { |
300 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 299 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
301 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; | 300 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; |
@@ -303,14 +302,14 @@ GNUNET_FS_search_probe_progress_ (void *cls, | |||
303 | sr = NULL; | 302 | sr = NULL; |
304 | break; | 303 | break; |
305 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: | 304 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: |
306 | GNUNET_assert (sr->probe_cancel_task == GNUNET_SCHEDULER_NO_TASK); | 305 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sr->probe_cancel_task); |
307 | sr->probe_active_time = GNUNET_TIME_absolute_get (); | 306 | sr->probe_active_time = GNUNET_TIME_absolute_get (); |
308 | sr->probe_cancel_task = | 307 | sr->probe_cancel_task = |
309 | GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time, | 308 | GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time, |
310 | &probe_failure_handler, sr); | 309 | &probe_failure_handler, sr); |
311 | break; | 310 | break; |
312 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: | 311 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: |
313 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | 312 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
314 | { | 313 | { |
315 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 314 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
316 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; | 315 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; |
@@ -339,18 +338,18 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr) | |||
339 | uint64_t off; | 338 | uint64_t off; |
340 | uint64_t len; | 339 | uint64_t len; |
341 | 340 | ||
342 | if (sr->probe_ctx != NULL) | 341 | if (NULL != sr->probe_ctx) |
343 | return; | 342 | return; |
344 | if (sr->download != NULL) | 343 | if (NULL != sr->download) |
345 | return; | 344 | return; |
346 | if (0 == (sr->sc->h->flags & GNUNET_FS_FLAGS_DO_PROBES)) | 345 | if (0 == (sr->sc->h->flags & GNUNET_FS_FLAGS_DO_PROBES)) |
347 | return; | 346 | return; |
348 | if (sr->availability_trials > AVAILABILITY_TRIALS_MAX) | 347 | if (sr->availability_trials > AVAILABILITY_TRIALS_MAX) |
349 | return; | 348 | return; |
350 | if ( (sr->uri->type != chk) && (sr->uri->type != loc)) | 349 | if ( (chk != sr->uri->type) && (loc != sr->uri->type)) |
351 | return; | 350 | return; |
352 | len = GNUNET_FS_uri_chk_get_file_size (sr->uri); | 351 | len = GNUNET_FS_uri_chk_get_file_size (sr->uri); |
353 | if (len == 0) | 352 | if (0 == len) |
354 | return; | 353 | return; |
355 | if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0)) | 354 | if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0)) |
356 | return; | 355 | return; |
@@ -503,7 +502,7 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc, const char *id_update, | |||
503 | /* notify client */ | 502 | /* notify client */ |
504 | notify_client_chk_result (sc, sr); | 503 | notify_client_chk_result (sc, sr); |
505 | /* search for updates */ | 504 | /* search for updates */ |
506 | if (strlen (id_update) == 0) | 505 | if (0 == strlen (id_update)) |
507 | return; /* no updates */ | 506 | return; /* no updates */ |
508 | uu.type = sks; | 507 | uu.type = sks; |
509 | uu.data.sks.namespace = sc->uri->data.sks.namespace; | 508 | uu.data.sks.namespace = sc->uri->data.sks.namespace; |
@@ -602,13 +601,13 @@ process_kblock (struct GNUNET_FS_SearchContext *sc, const struct KBlock *kb, | |||
602 | meta = GNUNET_CONTAINER_meta_data_create (); | 601 | meta = GNUNET_CONTAINER_meta_data_create (); |
603 | else | 602 | else |
604 | meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof (pt) - j); | 603 | meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof (pt) - j); |
605 | if (meta == NULL) | 604 | if (NULL == meta) |
606 | { | 605 | { |
607 | GNUNET_break_op (0); /* kblock malformed */ | 606 | GNUNET_break_op (0); /* kblock malformed */ |
608 | return; | 607 | return; |
609 | } | 608 | } |
610 | uri = GNUNET_FS_uri_parse (pt, &emsg); | 609 | uri = GNUNET_FS_uri_parse (pt, &emsg); |
611 | if (uri == NULL) | 610 | if (NULL == uri) |
612 | { | 611 | { |
613 | GNUNET_break_op (0); /* kblock malformed */ | 612 | GNUNET_break_op (0); /* kblock malformed */ |
614 | GNUNET_free_non_null (emsg); | 613 | GNUNET_free_non_null (emsg); |
@@ -661,7 +660,7 @@ process_nblock (struct GNUNET_FS_SearchContext *sc, const struct NBlock *nb, | |||
661 | meta = GNUNET_CONTAINER_meta_data_create (); | 660 | meta = GNUNET_CONTAINER_meta_data_create (); |
662 | else | 661 | else |
663 | meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof (pt) - j); | 662 | meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof (pt) - j); |
664 | if (meta == NULL) | 663 | if (NULL == meta) |
665 | { | 664 | { |
666 | GNUNET_break_op (0); /* nblock malformed */ | 665 | GNUNET_break_op (0); /* nblock malformed */ |
667 | return; | 666 | return; |
@@ -723,7 +722,7 @@ process_sblock (struct GNUNET_FS_SearchContext *sc, const struct SBlock *sb, | |||
723 | } | 722 | } |
724 | /* parse */ | 723 | /* parse */ |
725 | off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris); | 724 | off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris); |
726 | if (off == 0) | 725 | if (0 == off) |
727 | { | 726 | { |
728 | GNUNET_break_op (0); /* sblock malformed */ | 727 | GNUNET_break_op (0); /* sblock malformed */ |
729 | return; | 728 | return; |
@@ -735,7 +734,7 @@ process_sblock (struct GNUNET_FS_SearchContext *sc, const struct SBlock *sb, | |||
735 | return; | 734 | return; |
736 | } | 735 | } |
737 | uri = GNUNET_FS_uri_parse (uris, &emsg); | 736 | uri = GNUNET_FS_uri_parse (uris, &emsg); |
738 | if (uri == NULL) | 737 | if (NULL == uri) |
739 | { | 738 | { |
740 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to parse URI `%s': %s\n", uris, | 739 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to parse URI `%s': %s\n", uris, |
741 | emsg); | 740 | emsg); |
@@ -934,7 +933,7 @@ build_result_set (void *cls, const GNUNET_HashCode * key, void *value) | |||
934 | struct MessageBuilderContext *mbc = cls; | 933 | struct MessageBuilderContext *mbc = cls; |
935 | struct GNUNET_FS_SearchResult *sr = value; | 934 | struct GNUNET_FS_SearchResult *sr = value; |
936 | 935 | ||
937 | if ( (sr->keyword_bitmap != NULL) && | 936 | if ( (NULL != sr->keyword_bitmap) && |
938 | (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) ) | 937 | (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) ) |
939 | return GNUNET_OK; /* have no match for this keyword yet */ | 938 | return GNUNET_OK; /* have no match for this keyword yet */ |
940 | if (mbc->skip_cnt > 0) | 939 | if (mbc->skip_cnt > 0) |
@@ -942,7 +941,7 @@ build_result_set (void *cls, const GNUNET_HashCode * key, void *value) | |||
942 | mbc->skip_cnt--; | 941 | mbc->skip_cnt--; |
943 | return GNUNET_OK; | 942 | return GNUNET_OK; |
944 | } | 943 | } |
945 | if (mbc->put_cnt == 0) | 944 | if (0 == mbc->put_cnt) |
946 | return GNUNET_SYSERR; | 945 | return GNUNET_SYSERR; |
947 | mbc->sc->search_request_map_offset++; | 946 | mbc->sc->search_request_map_offset++; |
948 | mbc->xoff[--mbc->put_cnt] = *key; | 947 | mbc->xoff[--mbc->put_cnt] = *key; |
@@ -966,7 +965,7 @@ find_result_set (void *cls, const GNUNET_HashCode * key, void *value) | |||
966 | struct MessageBuilderContext *mbc = cls; | 965 | struct MessageBuilderContext *mbc = cls; |
967 | struct GNUNET_FS_SearchResult *sr = value; | 966 | struct GNUNET_FS_SearchResult *sr = value; |
968 | 967 | ||
969 | if ( (sr->keyword_bitmap != NULL) && | 968 | if ( (NULL != sr->keyword_bitmap) && |
970 | (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) ) | 969 | (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) ) |
971 | return GNUNET_OK; /* have no match for this keyword yet */ | 970 | return GNUNET_OK; /* have no match for this keyword yet */ |
972 | mbc->put_cnt++; | 971 | mbc->put_cnt++; |
@@ -1188,7 +1187,7 @@ search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, | |||
1188 | sc->uri = GNUNET_FS_uri_dup (uri); | 1187 | sc->uri = GNUNET_FS_uri_dup (uri); |
1189 | sc->anonymity = anonymity; | 1188 | sc->anonymity = anonymity; |
1190 | sc->start_time = GNUNET_TIME_absolute_get (); | 1189 | sc->start_time = GNUNET_TIME_absolute_get (); |
1191 | if (psearch != NULL) | 1190 | if (NULL != psearch) |
1192 | { | 1191 | { |
1193 | sc->psearch_result = psearch; | 1192 | sc->psearch_result = psearch; |
1194 | psearch->update_search = sc; | 1193 | psearch->update_search = sc; |
@@ -1237,7 +1236,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc) | |||
1237 | keyword = &sc->uri->data.ksk.keywords[i][1]; | 1236 | keyword = &sc->uri->data.ksk.keywords[i][1]; |
1238 | GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc); | 1237 | GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc); |
1239 | pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc); | 1238 | pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc); |
1240 | GNUNET_assert (pk != NULL); | 1239 | GNUNET_assert (NULL != pk); |
1241 | GNUNET_CRYPTO_rsa_key_get_public (pk, &pub); | 1240 | GNUNET_CRYPTO_rsa_key_get_public (pk, &pub); |
1242 | GNUNET_CRYPTO_rsa_key_free (pk); | 1241 | GNUNET_CRYPTO_rsa_key_free (pk); |
1243 | GNUNET_CRYPTO_hash (&pub, | 1242 | GNUNET_CRYPTO_hash (&pub, |
@@ -1273,17 +1272,17 @@ search_result_freeze_probes (void *cls, const GNUNET_HashCode * key, | |||
1273 | { | 1272 | { |
1274 | struct GNUNET_FS_SearchResult *sr = value; | 1273 | struct GNUNET_FS_SearchResult *sr = value; |
1275 | 1274 | ||
1276 | if (sr->probe_ctx != NULL) | 1275 | if (NULL != sr->probe_ctx) |
1277 | { | 1276 | { |
1278 | GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); | 1277 | GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); |
1279 | sr->probe_ctx = NULL; | 1278 | sr->probe_ctx = NULL; |
1280 | } | 1279 | } |
1281 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | 1280 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
1282 | { | 1281 | { |
1283 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 1282 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
1284 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; | 1283 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; |
1285 | } | 1284 | } |
1286 | if (sr->update_search != NULL) | 1285 | if (NULL != sr->update_search) |
1287 | GNUNET_FS_search_pause (sr->update_search); | 1286 | GNUNET_FS_search_pause (sr->update_search); |
1288 | return GNUNET_OK; | 1287 | return GNUNET_OK; |
1289 | } | 1288 | } |
@@ -1304,7 +1303,7 @@ search_result_resume_probes (void *cls, const GNUNET_HashCode * key, | |||
1304 | struct GNUNET_FS_SearchResult *sr = value; | 1303 | struct GNUNET_FS_SearchResult *sr = value; |
1305 | 1304 | ||
1306 | GNUNET_FS_search_start_probe_ (sr); | 1305 | GNUNET_FS_search_start_probe_ (sr); |
1307 | if (sr->update_search != NULL) | 1306 | if (NULL != sr->update_search) |
1308 | GNUNET_FS_search_continue (sr->update_search); | 1307 | GNUNET_FS_search_continue (sr->update_search); |
1309 | return GNUNET_OK; | 1308 | return GNUNET_OK; |
1310 | } | 1309 | } |
@@ -1325,10 +1324,21 @@ search_result_suspend (void *cls, const GNUNET_HashCode * key, void *value) | |||
1325 | struct GNUNET_FS_SearchResult *sr = value; | 1324 | struct GNUNET_FS_SearchResult *sr = value; |
1326 | struct GNUNET_FS_ProgressInfo pi; | 1325 | struct GNUNET_FS_ProgressInfo pi; |
1327 | 1326 | ||
1328 | if (sr->download != NULL) | 1327 | if (NULL != sr->download) |
1328 | { | ||
1329 | GNUNET_FS_download_signal_suspend_ (sr->download); | 1329 | GNUNET_FS_download_signal_suspend_ (sr->download); |
1330 | if (sr->update_search != NULL) | 1330 | sr->download = NULL; |
1331 | } | ||
1332 | if (NULL != sr->probe_ctx) | ||
1333 | { | ||
1334 | GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); | ||
1335 | sr->probe_ctx = NULL; | ||
1336 | } | ||
1337 | if (NULL != sr->update_search) | ||
1338 | { | ||
1331 | GNUNET_FS_search_signal_suspend_ (sr->update_search); | 1339 | GNUNET_FS_search_signal_suspend_ (sr->update_search); |
1340 | sr->update_search = NULL; | ||
1341 | } | ||
1332 | pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND; | 1342 | pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND; |
1333 | pi.value.search.specifics.result_suspend.cctx = sr->client_info; | 1343 | pi.value.search.specifics.result_suspend.cctx = sr->client_info; |
1334 | pi.value.search.specifics.result_suspend.meta = sr->meta; | 1344 | pi.value.search.specifics.result_suspend.meta = sr->meta; |
@@ -1338,10 +1348,11 @@ search_result_suspend (void *cls, const GNUNET_HashCode * key, void *value) | |||
1338 | GNUNET_free_non_null (sr->serialization); | 1348 | GNUNET_free_non_null (sr->serialization); |
1339 | GNUNET_FS_uri_destroy (sr->uri); | 1349 | GNUNET_FS_uri_destroy (sr->uri); |
1340 | GNUNET_CONTAINER_meta_data_destroy (sr->meta); | 1350 | GNUNET_CONTAINER_meta_data_destroy (sr->meta); |
1341 | if (sr->probe_ctx != NULL) | 1351 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
1342 | GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); | 1352 | { |
1343 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | ||
1344 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 1353 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
1354 | sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK; | ||
1355 | } | ||
1345 | GNUNET_free_non_null (sr->keyword_bitmap); | 1356 | GNUNET_free_non_null (sr->keyword_bitmap); |
1346 | GNUNET_free (sr); | 1357 | GNUNET_free (sr); |
1347 | return GNUNET_OK; | 1358 | return GNUNET_OK; |
@@ -1372,7 +1383,7 @@ GNUNET_FS_search_signal_suspend_ (void *cls) | |||
1372 | if (NULL != sc->client) | 1383 | if (NULL != sc->client) |
1373 | GNUNET_CLIENT_disconnect (sc->client); | 1384 | GNUNET_CLIENT_disconnect (sc->client); |
1374 | GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); | 1385 | GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); |
1375 | if (sc->requests != NULL) | 1386 | if (NULL != sc->requests) |
1376 | { | 1387 | { |
1377 | GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri)); | 1388 | GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri)); |
1378 | for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) | 1389 | for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) |
@@ -1405,7 +1416,7 @@ GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, | |||
1405 | struct GNUNET_FS_SearchContext *ret; | 1416 | struct GNUNET_FS_SearchContext *ret; |
1406 | 1417 | ||
1407 | ret = search_start (h, uri, anonymity, options, cctx, NULL); | 1418 | ret = search_start (h, uri, anonymity, options, cctx, NULL); |
1408 | if (ret == NULL) | 1419 | if (NULL == ret) |
1409 | return NULL; | 1420 | return NULL; |
1410 | ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret); | 1421 | ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret); |
1411 | return ret; | 1422 | return ret; |
@@ -1422,7 +1433,7 @@ GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc) | |||
1422 | { | 1433 | { |
1423 | struct GNUNET_FS_ProgressInfo pi; | 1434 | struct GNUNET_FS_ProgressInfo pi; |
1424 | 1435 | ||
1425 | if (sc->task != GNUNET_SCHEDULER_NO_TASK) | 1436 | if (GNUNET_SCHEDULER_NO_TASK != sc->task) |
1426 | GNUNET_SCHEDULER_cancel (sc->task); | 1437 | GNUNET_SCHEDULER_cancel (sc->task); |
1427 | sc->task = GNUNET_SCHEDULER_NO_TASK; | 1438 | sc->task = GNUNET_SCHEDULER_NO_TASK; |
1428 | if (NULL != sc->client) | 1439 | if (NULL != sc->client) |
@@ -1446,8 +1457,8 @@ GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc) | |||
1446 | { | 1457 | { |
1447 | struct GNUNET_FS_ProgressInfo pi; | 1458 | struct GNUNET_FS_ProgressInfo pi; |
1448 | 1459 | ||
1449 | GNUNET_assert (sc->client == NULL); | 1460 | GNUNET_assert (NULL == sc->client); |
1450 | GNUNET_assert (sc->task == GNUNET_SCHEDULER_NO_TASK); | 1461 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sc->task); |
1451 | do_reconnect (sc, NULL); | 1462 | do_reconnect (sc, NULL); |
1452 | GNUNET_FS_search_sync_ (sc); | 1463 | GNUNET_FS_search_sync_ (sc); |
1453 | pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED; | 1464 | pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED; |
@@ -1515,15 +1526,15 @@ search_result_free (void *cls, const GNUNET_HashCode * key, void *value) | |||
1515 | if (NULL != sr->update_search) | 1526 | if (NULL != sr->update_search) |
1516 | { | 1527 | { |
1517 | GNUNET_FS_search_stop (sr->update_search); | 1528 | GNUNET_FS_search_stop (sr->update_search); |
1518 | GNUNET_assert (sr->update_search == NULL); | 1529 | GNUNET_assert (NULL == sr->update_search); |
1519 | } | 1530 | } |
1520 | GNUNET_break (NULL == sr->client_info); | 1531 | GNUNET_break (NULL == sr->client_info); |
1521 | GNUNET_free_non_null (sr->serialization); | 1532 | GNUNET_free_non_null (sr->serialization); |
1522 | GNUNET_FS_uri_destroy (sr->uri); | 1533 | GNUNET_FS_uri_destroy (sr->uri); |
1523 | GNUNET_CONTAINER_meta_data_destroy (sr->meta); | 1534 | GNUNET_CONTAINER_meta_data_destroy (sr->meta); |
1524 | if (sr->probe_ctx != NULL) | 1535 | if (NULL != sr->probe_ctx) |
1525 | GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); | 1536 | GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES); |
1526 | if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK) | 1537 | if (GNUNET_SCHEDULER_NO_TASK != sr->probe_cancel_task) |
1527 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); | 1538 | GNUNET_SCHEDULER_cancel (sr->probe_cancel_task); |
1528 | GNUNET_free_non_null (sr->keyword_bitmap); | 1539 | GNUNET_free_non_null (sr->keyword_bitmap); |
1529 | GNUNET_free (sr); | 1540 | GNUNET_free (sr); |
@@ -1542,13 +1553,13 @@ GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc) | |||
1542 | struct GNUNET_FS_ProgressInfo pi; | 1553 | struct GNUNET_FS_ProgressInfo pi; |
1543 | unsigned int i; | 1554 | unsigned int i; |
1544 | 1555 | ||
1545 | if (sc->top != NULL) | 1556 | if (NULL != sc->top) |
1546 | GNUNET_FS_end_top (sc->h, sc->top); | 1557 | GNUNET_FS_end_top (sc->h, sc->top); |
1547 | GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, | 1558 | GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, |
1548 | &search_result_stop, sc); | 1559 | &search_result_stop, sc); |
1549 | if (sc->psearch_result != NULL) | 1560 | if (NULL != sc->psearch_result) |
1550 | sc->psearch_result->update_search = NULL; | 1561 | sc->psearch_result->update_search = NULL; |
1551 | if (sc->serialization != NULL) | 1562 | if (NULL != sc->serialization) |
1552 | { | 1563 | { |
1553 | GNUNET_FS_remove_sync_file_ (sc->h, | 1564 | GNUNET_FS_remove_sync_file_ (sc->h, |
1554 | (sc->psearch_result != | 1565 | (sc->psearch_result != |
@@ -1565,14 +1576,14 @@ GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc) | |||
1565 | pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED; | 1576 | pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED; |
1566 | sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc); | 1577 | sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc); |
1567 | GNUNET_break (NULL == sc->client_info); | 1578 | GNUNET_break (NULL == sc->client_info); |
1568 | if (sc->task != GNUNET_SCHEDULER_NO_TASK) | 1579 | if (GNUNET_SCHEDULER_NO_TASK != sc->task) |
1569 | GNUNET_SCHEDULER_cancel (sc->task); | 1580 | GNUNET_SCHEDULER_cancel (sc->task); |
1570 | if (NULL != sc->client) | 1581 | if (NULL != sc->client) |
1571 | GNUNET_CLIENT_disconnect (sc->client); | 1582 | GNUNET_CLIENT_disconnect (sc->client); |
1572 | GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, | 1583 | GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map, |
1573 | &search_result_free, sc); | 1584 | &search_result_free, sc); |
1574 | GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); | 1585 | GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map); |
1575 | if (sc->requests != NULL) | 1586 | if (NULL == sc->requests) |
1576 | { | 1587 | { |
1577 | GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri)); | 1588 | GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri)); |
1578 | for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) | 1589 | for (i = 0; i < sc->uri->data.ksk.keywordCount; i++) |