src/fs/fs_search.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001-2014 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  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
  17      Free Software Foundation, Inc., 59 Tem ple Place - Suite 330,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file fs/fs_search.c
  22  * @brief Helper functions for searching.
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_constants.h"
  27 #include "gnunet_fs_service.h"
  28 #include "gnunet_protocols.h"
  29 #include "fs_api.h"
  30 #include "fs_publish_ublock.h"
  31
  32
  33 /**
  34  * Number of availability trials we perform per search result.
  35  */
  36 #define AVAILABILITY_TRIALS_MAX 8
  37
  38 /**
  39  * Fill in all of the generic fields for a search event and
  40  * call the callback.
  41  *
  42  * @param pi structure to fill in
  43  * @param h file-sharing handle
  44  * @param sc overall search context
  45  * @return value returned by the callback
  46  */
  47 void *
  48 GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  49                                struct GNUNET_FS_Handle *h,
  50                                struct GNUNET_FS_SearchContext *sc)
  51 {
  52   void *ret;
  53
  54   pi->value.search.sc = sc;
  55   pi->value.search.cctx = (NULL != sc) ? sc->client_info : NULL;
  56   pi->value.search.pctx =
  57     ((NULL == sc) || (NULL == sc->psearch_result))
  58     ? NULL
  59     : sc->psearch_result->client_info;
  60   pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
  61   pi->value.search.duration = (NULL != sc)
  62     ? GNUNET_TIME_absolute_get_duration (sc->start_time)
  63     : GNUNET_TIME_UNIT_ZERO;
  64   pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
  65   pi->fsh = h;
  66   ret = h->upcb (h->upcb_cls, pi);
  67   return ret;
  68 }
  69
  70
  71 /**
  72  * Check if the given result is identical to the given URI.
  73  *
  74  * @param cls points to the URI we check against
  75  * @param key not used
  76  * @param value a `struct GNUNET_FS_SearchResult` who's URI we
  77  *        should compare with
  78  * @return #GNUNET_SYSERR if the result is present,
  79  *         #GNUNET_OK otherwise
  80  */
  81 static int
  82 test_result_present (void *cls,
  83                      const struct GNUNET_HashCode * key,
  84                      void *value)
  85 {
  86   const struct GNUNET_FS_Uri *uri = cls;
  87   struct GNUNET_FS_SearchResult *sr = value;
  88
  89   if (GNUNET_FS_uri_test_equal (uri, sr->uri))
  90     return GNUNET_SYSERR;
  91   return GNUNET_OK;
  92 }
  93
  94
  95 /**
  96  * We've found a new CHK result.  Let the client
  97  * know about it.
  98  *
  99  * @param sc the search context
 100  * @param sr the specific result
 101  */
 102 static void
 103 notify_client_chk_result (struct GNUNET_FS_SearchContext *sc,
 104                           struct GNUNET_FS_SearchResult *sr)
 105 {
 106   struct GNUNET_FS_ProgressInfo pi;
 107
 108   pi.status = GNUNET_FS_STATUS_SEARCH_RESULT;
 109   pi.value.search.specifics.result.meta = sr->meta;
 110   pi.value.search.specifics.result.uri = sr->uri;
 111   pi.value.search.specifics.result.result = sr;
 112   pi.value.search.specifics.result.applicability_rank = sr->optional_support;
 113   sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
 114 }
 115
 116
 117 /**
 118  * We've found new information about an existing CHK result.  Let the
 119  * client know about it.
 120  *
 121  * @param sc the search context
 122  * @param sr the specific result
 123  */
 124 static void
 125 notify_client_chk_update (struct GNUNET_FS_SearchContext *sc,
 126                           struct GNUNET_FS_SearchResult *sr)
 127 {
 128   struct GNUNET_FS_ProgressInfo pi;
 129
 130   pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
 131   pi.value.search.specifics.update.cctx = sr->client_info;
 132   pi.value.search.specifics.update.meta = sr->meta;
 133   pi.value.search.specifics.update.uri = sr->uri;
 134   pi.value.search.specifics.update.availability_rank =
 135       2 * sr->availability_success - sr->availability_trials;
 136   pi.value.search.specifics.update.availability_certainty =
 137       sr->availability_trials;
 138   pi.value.search.specifics.update.applicability_rank = sr->optional_support;
 139   pi.value.search.specifics.update.current_probe_time
 140     = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
 141   sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
 142 }
 143
 144
 145 /**
 146  * Context for "get_result_present".
 147  */
 148 struct GetResultContext
 149 {
 150   /**
 151    * The URI we're looking for.
 152    */
 153   const struct GNUNET_FS_Uri *uri;
 154
 155   /**
 156    * Where to store a pointer to the search
 157    * result struct if we found a match.
 158    */
 159   struct GNUNET_FS_SearchResult *sr;
 160 };
 161
 162
 163 /**
 164  * Check if the given result is identical to the given URI and if so
 165  * return it.
 166  *
 167  * @param cls a `struct GetResultContext`
 168  * @param key not used
 169  * @param value a `struct GNUNET_FS_SearchResult` who's URI we
 170  *        should compare with
 171  * @return #GNUNET_OK
 172  */
 173 static int
 174 get_result_present (void *cls,
 175                     const struct GNUNET_HashCode *key,
 176                     void *value)
 177 {
 178   struct GetResultContext *grc = cls;
 179   struct GNUNET_FS_SearchResult *sr = value;
 180
 181   if (GNUNET_FS_uri_test_equal (grc->uri, sr->uri))
 182     grc->sr = sr;
 183   return GNUNET_OK;
 184 }
 185
 186
 187 /**
 188  * Signal result of last probe to client and then schedule next
 189  * probe.
 190  *
 191  * @param sr search result to signal for
 192  */
 193 static void
 194 signal_probe_result (struct GNUNET_FS_SearchResult *sr)
 195 {
 196   struct GNUNET_FS_ProgressInfo pi;
 197
 198   pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
 199   pi.value.search.specifics.update.cctx = sr->client_info;
 200   pi.value.search.specifics.update.meta = sr->meta;
 201   pi.value.search.specifics.update.uri = sr->uri;
 202   pi.value.search.specifics.update.availability_rank
 203     = 2 * sr->availability_success - sr->availability_trials;
 204   pi.value.search.specifics.update.availability_certainty
 205     = sr->availability_trials;
 206   pi.value.search.specifics.update.applicability_rank = sr->optional_support;
 207   pi.value.search.specifics.update.current_probe_time
 208     = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
 209   sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc);
 210   GNUNET_FS_search_start_probe_ (sr);
 211 }
 212
 213
 214 /**
 215  * Handle the case where we have failed to receive a response for our probe.
 216  *
 217  * @param cls our `struct GNUNET_FS_SearchResult *`
 218  */
 219 static void
 220 probe_failure_handler (void *cls)
 221 {
 222   struct GNUNET_FS_SearchResult *sr = cls;
 223
 224   sr->probe_cancel_task = NULL;
 225   sr->availability_trials++;
 226   GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
 227   sr->probe_ctx = NULL;
 228   GNUNET_FS_stop_probe_ping_task_ (sr);
 229   GNUNET_FS_search_result_sync_ (sr);
 230   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 231               "Probe #%u for search result %p failed\n",
 232               sr->availability_trials,
 233               sr);
 234   signal_probe_result (sr);
 235 }
 236
 237
 238 /**
 239  * Handle the case where we have gotten a response for our probe.
 240  *
 241  * @param cls our `struct GNUNET_FS_SearchResult *`
 242  */
 243 static void
 244 probe_success_handler (void *cls)
 245 {
 246   struct GNUNET_FS_SearchResult *sr = cls;
 247
 248   sr->probe_cancel_task = NULL;
 249   sr->availability_trials++;
 250   sr->availability_success++;
 251   GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
 252   sr->probe_ctx = NULL;
 253   GNUNET_FS_stop_probe_ping_task_ (sr);
 254   GNUNET_FS_search_result_sync_ (sr);
 255   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 256               "Probe #%u for search result %p succeeded\n",
 257               sr->availability_trials,
 258               sr);
 259   signal_probe_result (sr);
 260 }
 261
 262
 263 /**
 264  * Notification of FS that a search probe has made progress.
 265  * This function is used INSTEAD of the client's event handler
 266  * for downloads where the #GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.
 267  *
 268  * @param cls closure, always NULL (!), actual closure
 269  *        is in the client-context of the info struct
 270  * @param info details about the event, specifying the event type
 271  *        and various bits about the event
 272  * @return client-context (for the next progress call
 273  *         for this operation; should be set to NULL for
 274  *         SUSPEND and STOPPED events).  The value returned
 275  *         will be passed to future callbacks in the respective
 276  *         field in the `struct GNUNET_FS_ProgressInfo`.
 277  */
 278 void *
 279 GNUNET_FS_search_probe_progress_ (void *cls,
 280                                   const struct GNUNET_FS_ProgressInfo *info)
 281 {
 282   struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
 283   struct GNUNET_TIME_Relative dur;
 284
 285   switch (info->status)
 286   {
 287   case GNUNET_FS_STATUS_DOWNLOAD_START:
 288     /* ignore */
 289     break;
 290   case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
 291     /* probes should never be resumed */
 292     GNUNET_assert (0);
 293     break;
 294   case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
 295     /* probes should never be suspended */
 296     GNUNET_break (0);
 297     break;
 298   case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
 299     /* ignore */
 300     break;
 301   case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
 302     if (NULL != sr->probe_cancel_task)
 303     {
 304       GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
 305       sr->probe_cancel_task = NULL;
 306     }
 307     sr->probe_cancel_task =
 308         GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
 309                                       &probe_failure_handler, sr);
 310     break;
 311   case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
 312     if (NULL != sr->probe_cancel_task)
 313     {
 314       GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
 315       sr->probe_cancel_task = NULL;
 316     }
 317     sr->probe_cancel_task =
 318         GNUNET_SCHEDULER_add_now (&probe_success_handler, sr);
 319     break;
 320   case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
 321     if (NULL != sr->probe_cancel_task)
 322     {
 323       GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
 324       sr->probe_cancel_task = NULL;
 325     }
 326     sr = NULL;
 327     break;
 328   case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
 329     if (NULL == sr->probe_cancel_task)
 330     {
 331       sr->probe_active_time = GNUNET_TIME_absolute_get ();
 332       sr->probe_cancel_task =
 333         GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
 334                                       &probe_failure_handler, sr);
 335     }
 336     break;
 337   case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
 338     if (NULL != sr->probe_cancel_task)
 339     {
 340       GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
 341       sr->probe_cancel_task = NULL;
 342     }
 343     dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
 344     sr->remaining_probe_time =
 345         GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
 346     if (0 == sr->remaining_probe_time.rel_value_us)
 347       sr->probe_cancel_task =
 348         GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr);
 349     GNUNET_FS_search_result_sync_ (sr);
 350     break;
 351   default:
 352     GNUNET_break (0);
 353     return NULL;
 354   }
 355   return sr;
 356 }
 357
 358
 359 /**
 360  * Task run periodically to remind clients that a probe is active.
 361  *
 362  * @param cls the `struct GNUNET_FS_SearchResult` that we are probing for
 363  */
 364 static void
 365 probe_ping_task_cb (void *cls)
 366 {
 367   struct GNUNET_FS_Handle *h = cls;
 368   struct GNUNET_FS_SearchResult *sr;
 369
 370   for (sr = h->probes_head; NULL != sr; sr = sr->next)
 371     if (NULL != sr->probe_ctx->client)
 372       signal_probe_result (sr);
 373   h->probe_ping_task
 374     = GNUNET_SCHEDULER_add_delayed (GNUNET_FS_PROBE_UPDATE_FREQUENCY,
 375                                     &probe_ping_task_cb,
 376                                     h);
 377 }
 378
 379
 380 /**
 381  * Start the ping task for this search result.
 382  *
 383  * @param sr result to start pinging for.
 384  */
 385 static void
 386 start_probe_ping_task (struct GNUNET_FS_SearchResult *sr)
 387 {
 388   struct GNUNET_FS_Handle *h = sr->h;
 389
 390   GNUNET_CONTAINER_DLL_insert (h->probes_head,
 391                                h->probes_tail,
 392                                sr);
 393   if (NULL == h->probe_ping_task)
 394     h->probe_ping_task
 395       = GNUNET_SCHEDULER_add_now (&probe_ping_task_cb,
 396                                   h);
 397 }
 398
 399
 400 /**
 401  * Stop the ping task for this search result.
 402  *
 403  * @param sr result to start pinging for.
 404  */
 405 void
 406 GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr)
 407 {
 408   struct GNUNET_FS_Handle *h = sr->h;
 409
 410   GNUNET_CONTAINER_DLL_remove (h->probes_head,
 411                                h->probes_tail,
 412                                sr);
 413   if (NULL == h->probes_head)
 414   {
 415     GNUNET_SCHEDULER_cancel (h->probe_ping_task);
 416     h->probe_ping_task = NULL;
 417   }
 418 }
 419
 420
 421 /**
 422  * Start download probes for the given search result.
 423  *
 424  * @param sr the search result
 425  */
 426 void
 427 GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 428 {
 429   uint64_t off;
 430   uint64_t len;
 431
 432   if (NULL != sr->probe_ctx)
 433     return;
 434   if (NULL != sr->download)
 435     return;
 436   if (0 == (sr->h->flags & GNUNET_FS_FLAGS_DO_PROBES))
 437     return;
 438   if (sr->availability_trials > AVAILABILITY_TRIALS_MAX)
 439     return;
 440   if ( (GNUNET_FS_URI_CHK != sr->uri->type) && (GNUNET_FS_URI_LOC != sr->uri->type))
 441     return;
 442   len = GNUNET_FS_uri_chk_get_file_size (sr->uri);
 443   if (0 == len)
 444     return;
 445   if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
 446     return;
 447   off = len / DBLOCK_SIZE;
 448   if (off > 0)
 449     off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, off);
 450   off *= DBLOCK_SIZE;
 451   if (len - off < DBLOCK_SIZE)
 452     len = len - off;
 453   else
 454     len = DBLOCK_SIZE;
 455   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 456               "Starting probe #%u (at offset %llu) for search result %p\n",
 457               sr->availability_trials + 1,
 458               (unsigned long long) off,
 459               sr);
 460   sr->remaining_probe_time =
 461       GNUNET_TIME_relative_multiply (sr->h->avg_block_latency,
 462                                      2 * (1 + sr->availability_trials));
 463   sr->probe_ctx =
 464       GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off,
 465                                 len, sr->anonymity,
 466                                 GNUNET_FS_DOWNLOAD_NO_TEMPORARIES |
 467                                 GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
 468   start_probe_ping_task (sr);
 469 }
 470
 471
 472 /**
 473  * Start download probes for the given search result.
 474  *
 475  * @param h file-sharing handle to use for the operation
 476  * @param uri URI to probe
 477  * @param meta meta data associated with the URI
 478  * @param client_info client info pointer to use for associated events
 479  * @param anonymity anonymity level to use for the probes
 480  * @return the search result handle to access the probe activity
 481  */
 482 struct GNUNET_FS_SearchResult *
 483 GNUNET_FS_probe (struct GNUNET_FS_Handle *h,
 484                  const struct GNUNET_FS_Uri *uri,
 485                  const struct GNUNET_CONTAINER_MetaData *meta,
 486                  void *client_info,
 487                  uint32_t anonymity)
 488 {
 489   struct GNUNET_FS_SearchResult *sr;
 490
 491   GNUNET_assert (NULL != h);
 492   sr = GNUNET_new (struct GNUNET_FS_SearchResult);
 493   sr->h = h;
 494   sr->uri = GNUNET_FS_uri_dup (uri);
 495   sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
 496   sr->client_info = client_info;
 497   sr->anonymity = anonymity;
 498   GNUNET_FS_search_start_probe_ (sr);
 499   return sr;
 500 }
 501
 502
 503 /**
 504  * Stop probing activity associated with a search result.
 505  *
 506  * @param sr search result
 507  */
 508 static void
 509 GNUNET_FS_search_stop_probe_ (struct GNUNET_FS_SearchResult *sr)
 510 {
 511   if (NULL != sr->probe_ctx)
 512   {
 513     GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
 514     sr->probe_ctx = NULL;
 515     GNUNET_FS_stop_probe_ping_task_ (sr);
 516   }
 517   if (NULL != sr->probe_cancel_task)
 518   {
 519     GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
 520     sr->probe_cancel_task = NULL;
 521   }
 522 }
 523
 524
 525 /**
 526  * Stop probe activity.  Must ONLY be used on values
 527  * returned from #GNUNET_FS_probe.
 528  *
 529  * @param sr search result to stop probing for (freed)
 530  * @return the value of the 'client_info' pointer
 531  */
 532 void *
 533 GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
 534 {
 535   void *client_info;
 536
 537   GNUNET_assert (NULL == sr->sc);
 538   GNUNET_FS_search_stop_probe_ (sr);
 539   GNUNET_FS_uri_destroy (sr->uri);
 540   GNUNET_CONTAINER_meta_data_destroy (sr->meta);
 541   client_info = sr->client_info;
 542   GNUNET_free (sr);
 543   return client_info;
 544 }
 545
 546
 547 /**
 548  * We have received a KSK result.  Check how it fits in with the
 549  * overall query and notify the client accordingly.
 550  *
 551  * @param sc context for the overall query
 552  * @param ent entry for the specific keyword
 553  * @param uri the URI that was found
 554  * @param meta metadata associated with the URI
 555  *        under the @a ent keyword
 556  */
 557 static void
 558 process_ksk_result (struct GNUNET_FS_SearchContext *sc,
 559                     struct SearchRequestEntry *ent,
 560                     const struct GNUNET_FS_Uri *uri,
 561                     const struct GNUNET_CONTAINER_MetaData *meta)
 562 {
 563   struct GNUNET_HashCode key;
 564   struct GNUNET_FS_SearchResult *sr;
 565   struct GetResultContext grc;
 566   int is_new;
 567   unsigned int koff;
 568
 569   /* check if new */
 570   GNUNET_assert (NULL != sc);
 571   GNUNET_FS_uri_to_key (uri, &key);
 572   if (GNUNET_SYSERR ==
 573       GNUNET_CONTAINER_multihashmap_get_multiple (ent->results,
 574                                                   &key,
 575                                                   &test_result_present,
 576                                                   (void *) uri))
 577     return;                     /* duplicate result */
 578   /* try to find search result in master map */
 579   grc.sr = NULL;
 580   grc.uri = uri;
 581   GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map,
 582                                               &key,
 583                                               &get_result_present, &grc);
 584   sr = grc.sr;
 585   is_new = (NULL == sr) || (sr->mandatory_missing > 0);
 586   if (NULL == sr)
 587   {
 588     sr = GNUNET_new (struct GNUNET_FS_SearchResult);
 589     sr->h = sc->h;
 590     sr->sc = sc;
 591     sr->anonymity = sc->anonymity;
 592     sr->uri = GNUNET_FS_uri_dup (uri);
 593     sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
 594     sr->mandatory_missing = sc->mandatory_count;
 595     sr->key = key;
 596     sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
 597     GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
 598                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 599   }
 600   else
 601   {
 602     GNUNET_CONTAINER_meta_data_merge (sr->meta, meta);
 603   }
 604   GNUNET_break (GNUNET_OK ==
 605                 GNUNET_CONTAINER_multihashmap_put (ent->results,
 606                                                    &sr->key,
 607                                                    sr,
 608                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 609
 610   koff = ent - sc->requests;
 611   GNUNET_assert ( (ent >= sc->requests) &&
 612                   (koff < sc->uri->data.ksk.keywordCount));
 613   sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8));
 614   /* check if mandatory satisfied */
 615   if (1 <= GNUNET_CONTAINER_multihashmap_size (ent->results))
 616   {
 617     if (ent->mandatory)
 618     {
 619       GNUNET_break (sr->mandatory_missing > 0);
 620       sr->mandatory_missing--;
 621     }
 622     else
 623     {
 624       sr->optional_support++;
 625     }
 626   }
 627   if (0 != sr->mandatory_missing)
 628   {
 629     GNUNET_break (NULL == sr->client_info);
 630     return;
 631   }
 632   if (is_new)
 633     notify_client_chk_result (sc, sr);
 634   else
 635     notify_client_chk_update (sc, sr);
 636   GNUNET_FS_search_result_sync_ (sr);
 637   GNUNET_FS_search_start_probe_ (sr);
 638 }
 639
 640
 641 /**
 642  * Start search for content, internal API.
 643  *
 644  * @param h handle to the file sharing subsystem
 645  * @param uri specifies the search parameters; can be
 646  *        a KSK URI or an SKS URI.
 647  * @param anonymity desired level of anonymity
 648  * @param options options for the search
 649  * @param cctx client context
 650  * @param psearch parent search result (for namespace update searches)
 651  * @return context that can be used to control the search
 652  */
 653 static struct GNUNET_FS_SearchContext *
 654 search_start (struct GNUNET_FS_Handle *h,
 655               const struct GNUNET_FS_Uri *uri,
 656               uint32_t anonymity,
 657               enum GNUNET_FS_SearchOptions options,
 658               void *cctx,
 659               struct GNUNET_FS_SearchResult *psearch);
 660
 661
 662 /**
 663  * We have received an SKS result.  Start searching for updates and
 664  * notify the client if it is a new result.
 665  *
 666  * @param sc context for the overall query
 667  * @param id_update identifier for updates, NULL for none
 668  * @param uri the URI that was found
 669  * @param meta metadata associated with the URI
 670   */
 671 static void
 672 process_sks_result (struct GNUNET_FS_SearchContext *sc,
 673                     const char *id_update,
 674                     const struct GNUNET_FS_Uri *uri,
 675                     const struct GNUNET_CONTAINER_MetaData *meta)
 676 {
 677   struct GNUNET_FS_Uri uu;
 678   struct GNUNET_HashCode key;
 679   struct GNUNET_FS_SearchResult *sr;
 680
 681   /* check if new */
 682   GNUNET_assert (NULL != sc);
 683   GNUNET_FS_uri_to_key (uri, &key);
 684   GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key, &uri->data.chk.chk.query,
 685                           &key);
 686   if (GNUNET_SYSERR ==
 687       GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, &key,
 688                                                   &test_result_present,
 689                                                   (void *) uri))
 690     return;                     /* duplicate result */
 691   sr = GNUNET_new (struct GNUNET_FS_SearchResult);
 692   sr->h = sc->h;
 693   sr->sc = sc;
 694   sr->anonymity = sc->anonymity;
 695   sr->uri = GNUNET_FS_uri_dup (uri);
 696   sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
 697   sr->key = key;
 698   GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
 699                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 700   GNUNET_FS_search_result_sync_ (sr);
 701   GNUNET_FS_search_start_probe_ (sr);
 702   /* notify client */
 703   if (0 == sr->mandatory_missing)
 704     notify_client_chk_result (sc, sr);
 705   else
 706     GNUNET_break (NULL == sr->client_info);
 707   /* search for updates */
 708   if (0 == strlen (id_update))
 709     return;                     /* no updates */
 710   uu.type = GNUNET_FS_URI_SKS;
 711   uu.data.sks.ns = sc->uri->data.sks.ns;
 712   uu.data.sks.identifier = GNUNET_strdup (id_update);
 713   (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
 714   GNUNET_free (uu.data.sks.identifier);
 715 }
 716
 717
 718 /**
 719  * Decrypt a ublock using a 'keyword' as the passphrase.  Given the
 720  * KSK public key derived from the keyword, this function looks up
 721  * the original keyword in the search context and decrypts the
 722  * given ciphertext block.
 723  *
 724  * @param sc search context with the keywords
 725  * @param dpub derived public key used for the search
 726  * @param edata encrypted data
 727  * @param edata_size number of bytes in @a edata (and @a data)
 728  * @param data where to store the plaintext
 729  * @return keyword index on success, #GNUNET_SYSERR on error (no such
 730  *         keyword, internal error)
 731  */
 732 static int
 733 decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc,
 734                             const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub,
 735                             const void *edata,
 736                             size_t edata_size,
 737                             char *data)
 738 {
 739   const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
 740   struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
 741   unsigned int i;
 742
 743   /* find key */
 744   for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
 745     if (0 == memcmp (dpub,
 746                      &sc->requests[i].dpub,
 747                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
 748       break;
 749   if (i == sc->uri->data.ksk.keywordCount)
 750   {
 751     /* oops, does not match any of our keywords!? */
 752     GNUNET_break (0);
 753     return GNUNET_SYSERR;
 754   }
 755   /* decrypt */
 756   anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
 757   GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
 758   GNUNET_FS_ublock_decrypt_ (edata, edata_size,
 759                              &anon_pub,
 760                              sc->requests[i].keyword,
 761                              data);
 762   return i;
 763 }
 764
 765
 766 /**
 767  * Process a keyword search result.  The actual type of block is
 768  * a UBlock; we know it is a keyword search result because that's
 769  * what we were searching for.
 770  *
 771  * @param sc our search context
 772  * @param ub the ublock with the keyword search result
 773  * @param size size of @a ub
 774  */
 775 static void
 776 process_kblock (struct GNUNET_FS_SearchContext *sc,
 777                 const struct UBlock *ub,
 778                 size_t size)
 779 {
 780   size_t j;
 781   char pt[size - sizeof (struct UBlock)];
 782   const char *eos;
 783   struct GNUNET_CONTAINER_MetaData *meta;
 784   struct GNUNET_FS_Uri *uri;
 785   char *emsg;
 786   int i;
 787
 788   if (-1 == (i = decrypt_block_with_keyword (sc,
 789                                              &ub->verification_key,
 790                                              &ub[1],
 791                                              size - sizeof (struct UBlock),
 792                                              pt)))
 793     return;
 794   /* parse; pt[0] is just '\0', so we skip over that */
 795   eos = memchr (&pt[1], '\0', sizeof (pt) - 1);
 796   if (NULL == eos)
 797   {
 798     GNUNET_break_op (0);
 799     return;
 800   }
 801   if (NULL == (uri = GNUNET_FS_uri_parse (&pt[1], &emsg)))
 802   {
 803     if (GNUNET_FS_VERSION > 0x00090400)
 804     {
 805       /* we broke this in 0x00090300, so don't bitch
 806          too loudly just one version up... */
 807       GNUNET_break_op (0);        /* ublock malformed */
 808       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 809                   _("Failed to parse URI `%s': %s\n"),
 810                   &pt[1],
 811                   emsg);
 812     }
 813     GNUNET_free_non_null (emsg);
 814     return;
 815   }
 816   j = eos - pt + 1;
 817   if (sizeof (pt) == j)
 818     meta = GNUNET_CONTAINER_meta_data_create ();
 819   else
 820     meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof (pt) - j);
 821   if (NULL == meta)
 822   {
 823     GNUNET_break_op (0);        /* ublock malformed */
 824     GNUNET_FS_uri_destroy (uri);
 825     return;
 826   }
 827   process_ksk_result (sc,
 828                       &sc->requests[i],
 829                       uri,
 830                       meta);
 831
 832   /* clean up */
 833   GNUNET_CONTAINER_meta_data_destroy (meta);
 834   GNUNET_FS_uri_destroy (uri);
 835 }
 836
 837
 838 /**
 839  * Process a namespace-search result.  The actual type of block is
 840  * a UBlock; we know it is a namespace search result because that's
 841  * what we were searching for.
 842  *
 843  * @param sc our search context
 844  * @param ub the ublock with a namespace result
 845  * @param size size of @a ub
 846  */
 847 static void
 848 process_sblock (struct GNUNET_FS_SearchContext *sc,
 849                 const struct UBlock *ub,
 850                 size_t size)
 851 {
 852   size_t len = size - sizeof (struct UBlock);
 853   char pt[len];
 854   struct GNUNET_FS_Uri *uri;
 855   struct GNUNET_CONTAINER_MetaData *meta;
 856   const char *id;
 857   const char *uris;
 858   size_t off;
 859   char *emsg;
 860
 861   GNUNET_FS_ublock_decrypt_ (&ub[1], len,
 862                              &sc->uri->data.sks.ns,
 863                              sc->uri->data.sks.identifier,
 864                              pt);
 865   /* parse */
 866   if (0 == (off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris)))
 867   {
 868     GNUNET_break_op (0);        /* ublock malformed */
 869     return;
 870   }
 871   if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], len - off)))
 872   {
 873     GNUNET_break_op (0);        /* ublock malformed */
 874     return;
 875   }
 876   if (NULL == (uri = GNUNET_FS_uri_parse (uris, &emsg)))
 877   {
 878     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 879                 _("Failed to parse URI `%s': %s\n"),
 880                 uris, emsg);
 881     GNUNET_break_op (0);        /* ublock malformed */
 882     GNUNET_free_non_null (emsg);
 883     GNUNET_CONTAINER_meta_data_destroy (meta);
 884     return;
 885   }
 886   /* process */
 887   process_sks_result (sc, id, uri, meta);
 888   /* clean up */
 889   GNUNET_FS_uri_destroy (uri);
 890   GNUNET_CONTAINER_meta_data_destroy (meta);
 891 }
 892
 893
 894 /**
 895  * Process a search result.
 896  *
 897  * @param sc our search context
 898  * @param type type of the result
 899  * @param expiration when it will expire
 900  * @param data the (encrypted) response
 901  * @param size size of @a data
 902  */
 903 static void
 904 process_result (struct GNUNET_FS_SearchContext *sc,
 905                 enum GNUNET_BLOCK_Type type,
 906                 struct GNUNET_TIME_Absolute expiration,
 907                 const void *data,
 908                 size_t size)
 909 {
 910   if (GNUNET_TIME_absolute_get_duration (expiration).rel_value_us > 0)
 911   {
 912     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 913                 "Result received has already expired.\n");
 914     return;                     /* result expired */
 915   }
 916   switch (type)
 917   {
 918   case GNUNET_BLOCK_TYPE_FS_UBLOCK:
 919     if (GNUNET_FS_URI_SKS == sc->uri->type)
 920       process_sblock (sc, data, size);
 921     else
 922       process_kblock (sc, data, size);
 923     break;
 924   case GNUNET_BLOCK_TYPE_ANY:
 925     GNUNET_break (0);
 926     break;
 927   case GNUNET_BLOCK_TYPE_FS_DBLOCK:
 928     GNUNET_break (0);
 929     break;
 930   case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
 931     GNUNET_break (0);
 932     break;
 933   case GNUNET_BLOCK_TYPE_FS_IBLOCK:
 934     GNUNET_break (0);
 935     break;
 936   default:
 937     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 938                 _("Got result with unknown block type `%d', ignoring"), type);
 939     break;
 940   }
 941 }
 942
 943
 944 /**
 945  * Shutdown any existing connection to the FS
 946  * service and try to establish a fresh one
 947  * (and then re-transmit our search request).
 948  *
 949  * @param sc the search to reconnec
 950  */
 951 static void
 952 try_reconnect (struct GNUNET_FS_SearchContext *sc);
 953
 954
 955 /**
 956  * Type of a function to call when we receive a message
 957  * from the service.
 958  *
 959  * @param cls closure
 960  * @param msg message received, NULL on timeout or fatal error
 961  */
 962 static void
 963 receive_results (void *cls,
 964                  const struct GNUNET_MessageHeader *msg)
 965 {
 966   struct GNUNET_FS_SearchContext *sc = cls;
 967   const struct ClientPutMessage *cm;
 968   uint16_t msize;
 969
 970   if ((NULL == msg) || (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_PUT) ||
 971       (ntohs (msg->size) <= sizeof (struct ClientPutMessage)))
 972   {
 973     try_reconnect (sc);
 974     return;
 975   }
 976   msize = ntohs (msg->size);
 977   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 978               "Receiving %u bytes of result from fs service\n",
 979               msize);
 980   cm = (const struct ClientPutMessage *) msg;
 981   process_result (sc, ntohl (cm->type),
 982                   GNUNET_TIME_absolute_ntoh (cm->expiration), &cm[1],
 983                   msize - sizeof (struct ClientPutMessage));
 984   /* continue receiving */
 985   GNUNET_CLIENT_receive (sc->client,
 986                          &receive_results,
 987                          sc,
 988                          GNUNET_TIME_UNIT_FOREVER_REL);
 989 }
 990
 991
 992 /**
 993  * Schedule the transmission of the (next) search request
 994  * to the service.
 995  *
 996  * @param sc context for the search
 997  */
 998 static void
 999 schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc);
1000
1001
1002 /**
1003  * Closure for #build_result_set().
1004  */
1005 struct MessageBuilderContext
1006 {
1007   /**
1008    * How many entries can we store to xoff.
1009    */
1010   unsigned int put_cnt;
1011
1012   /**
1013    * How many entries should we skip.
1014    */
1015   unsigned int skip_cnt;
1016
1017   /**
1018    * Where to store the keys.
1019    */
1020   struct GNUNET_HashCode *xoff;
1021
1022   /**
1023    * Search context we are iterating for.
1024    */
1025   struct GNUNET_FS_SearchContext *sc;
1026
1027   /**
1028    * Keyword offset the search result must match (0 for SKS)
1029    */
1030   unsigned int keyword_offset;
1031 };
1032
1033
1034 /**
1035  * Iterating over the known results, pick those matching the given
1036  * result range and store their keys at 'xoff'.
1037  *
1038  * @param cls the `struct MessageBuilderContext`
1039  * @param key key for a result
1040  * @param value the search result
1041  * @return #GNUNET_OK to continue iterating
1042  */
1043 static int
1044 build_result_set (void *cls,
1045                   const struct GNUNET_HashCode *key,
1046                   void *value)
1047 {
1048   struct MessageBuilderContext *mbc = cls;
1049   struct GNUNET_FS_SearchResult *sr = value;
1050
1051   if ( (NULL != sr->keyword_bitmap) &&
1052        (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) )
1053     return GNUNET_OK; /* have no match for this keyword yet */
1054   if (mbc->skip_cnt > 0)
1055   {
1056     mbc->skip_cnt--;
1057     return GNUNET_OK;
1058   }
1059   if (0 == mbc->put_cnt)
1060     return GNUNET_SYSERR;
1061   mbc->sc->search_request_map_offset++;
1062   mbc->xoff[--mbc->put_cnt] = *key;
1063
1064   return GNUNET_OK;
1065 }
1066
1067
1068 /**
1069  * Iterating over the known results, count those matching the given
1070  * result range and increment put count for each.
1071  *
1072  * @param cls the `struct MessageBuilderContext`
1073  * @param key key for a result
1074  * @param value the search result
1075  * @return #GNUNET_OK to continue iterating
1076  */
1077 static int
1078 find_result_set (void *cls,
1079                  const struct GNUNET_HashCode *key,
1080                  void *value)
1081 {
1082   struct MessageBuilderContext *mbc = cls;
1083   struct GNUNET_FS_SearchResult *sr = value;
1084
1085   if ( (NULL != sr->keyword_bitmap) &&
1086        (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) )
1087     return GNUNET_OK; /* have no match for this keyword yet */
1088   mbc->put_cnt++;
1089   return GNUNET_OK;
1090 }
1091
1092
1093 /**
1094  * We're ready to transmit the search request to the file-sharing
1095  * service.  Do it.  If the request is too large to fit into a single
1096  * message, transmit in increments.
1097  *
1098  * @param cls closure
1099  * @param size number of bytes available in @a buf
1100  * @param buf where the callee should write the message
1101  * @return number of bytes written to @a buf
1102  */
1103 static size_t
1104 transmit_search_request (void *cls,
1105                          size_t size,
1106                          void *buf)
1107 {
1108   struct GNUNET_FS_SearchContext *sc = cls;
1109   struct MessageBuilderContext mbc;
1110   size_t msize;
1111   struct SearchMessage *sm;
1112   struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
1113   unsigned int total_seen_results; /* total number of result hashes to send */
1114   unsigned int message_size_limit;
1115   uint32_t options;
1116
1117   if (NULL == buf)
1118   {
1119     try_reconnect (sc);
1120     return 0;
1121   }
1122   mbc.sc = sc;
1123   mbc.skip_cnt = sc->search_request_map_offset;
1124   sm = buf;
1125   sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
1126   mbc.xoff = (struct GNUNET_HashCode *) &sm[1];
1127   options = SEARCH_MESSAGE_OPTION_NONE;
1128   if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
1129     options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
1130   if (GNUNET_FS_uri_test_ksk (sc->uri))
1131   {
1132     msize = sizeof (struct SearchMessage);
1133     GNUNET_assert (size >= msize);
1134     mbc.keyword_offset = sc->keyword_offset;
1135     /* calculate total number of known results (in put_cnt => total_seen_results) */
1136     mbc.put_cnt = 0;
1137     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1138                                            &find_result_set, &mbc);
1139     total_seen_results = mbc.put_cnt;
1140     /* calculate how many results we can send in this message */
1141     message_size_limit = (size - msize) / sizeof (struct GNUNET_HashCode);
1142     mbc.put_cnt = GNUNET_MIN (message_size_limit,
1143                               total_seen_results - mbc.skip_cnt);
1144     if (sc->search_request_map_offset < total_seen_results)
1145       GNUNET_assert (mbc.put_cnt > 0);
1146
1147     /* now build message */
1148     msize += sizeof (struct GNUNET_HashCode) * mbc.put_cnt;
1149     sm->header.size = htons (msize);
1150     sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK);
1151     sm->anonymity_level = htonl (sc->anonymity);
1152     memset (&sm->target, 0, sizeof (struct GNUNET_PeerIdentity));
1153     sm->query = sc->requests[sc->keyword_offset].uquery;
1154     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1155                                            &build_result_set, &mbc);
1156     GNUNET_assert (0 == mbc.put_cnt);
1157     GNUNET_assert (total_seen_results >= sc->search_request_map_offset);
1158     if (total_seen_results != sc->search_request_map_offset)
1159     {
1160       /* more requesting to be done... */
1161       sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
1162       schedule_transmit_search_request (sc);
1163       return msize;
1164     }
1165     sm->options = htonl (options);
1166     sc->keyword_offset++;
1167     sc->search_request_map_offset = 0;
1168     if (sc->uri->data.ksk.keywordCount != sc->keyword_offset)
1169     {
1170       /* more requesting to be done... */
1171       schedule_transmit_search_request (sc);
1172       return msize;
1173     }
1174   }
1175   else
1176   {
1177     GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
1178     msize = sizeof (struct SearchMessage);
1179     GNUNET_assert (size >= msize);
1180     sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK);
1181     sm->anonymity_level = htonl (sc->anonymity);
1182     memset (&sm->target, 0, sizeof (struct GNUNET_PeerIdentity));
1183     GNUNET_CRYPTO_ecdsa_public_key_derive (&sc->uri->data.sks.ns,
1184                                          sc->uri->data.sks.identifier,
1185                                          "fs-ublock",
1186                                          &dpub);
1187     GNUNET_CRYPTO_hash (&dpub,
1188                         sizeof (dpub),
1189                         &sm->query);
1190     message_size_limit = (size - msize) / sizeof (struct GNUNET_HashCode);
1191     total_seen_results = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
1192     mbc.put_cnt = GNUNET_MIN (message_size_limit,
1193                               total_seen_results - mbc.skip_cnt);
1194     mbc.keyword_offset = 0;
1195     if (sc->search_request_map_offset < total_seen_results)
1196       GNUNET_assert (mbc.put_cnt > 0);
1197     msize += sizeof (struct GNUNET_HashCode) * mbc.put_cnt;
1198     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1199                                            &build_result_set, &mbc);
1200     sm->header.size = htons (msize);
1201     GNUNET_assert (total_seen_results >= sc->search_request_map_offset);
1202     if (total_seen_results != sc->search_request_map_offset)
1203     {
1204       /* more requesting to be done... */
1205       sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
1206       schedule_transmit_search_request (sc);
1207       return msize;
1208     }
1209     sm->options = htonl (options);
1210   }
1211   GNUNET_CLIENT_receive (sc->client,
1212                          &receive_results, sc,
1213                          GNUNET_TIME_UNIT_FOREVER_REL);
1214   return msize;
1215 }
1216
1217
1218 /**
1219  * Schedule the transmission of the (next) search request
1220  * to the service.
1221  *
1222  * @param sc context for the search
1223  */
1224 static void
1225 schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
1226 {
1227   size_t size;
1228   unsigned int left;
1229   unsigned int fit;
1230   unsigned int request;
1231
1232   size = sizeof (struct SearchMessage);
1233   left =
1234       GNUNET_CONTAINER_multihashmap_size (sc->master_result_map) -
1235       sc->search_request_map_offset;
1236   fit = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - size) / sizeof (struct GNUNET_HashCode);
1237   request = GNUNET_MIN (fit, left);
1238   size += sizeof (struct GNUNET_HashCode) * request;
1239   GNUNET_CLIENT_notify_transmit_ready (sc->client, size,
1240                                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
1241                                        GNUNET_NO,
1242                                        &transmit_search_request, sc);
1243 }
1244
1245
1246 /**
1247  * Reconnect to the FS service and transmit
1248  * our queries NOW.
1249  *
1250  * @param cls our search context
1251  */
1252 static void
1253 do_reconnect (void *cls)
1254 {
1255   struct GNUNET_FS_SearchContext *sc = cls;
1256   struct GNUNET_CLIENT_Connection *client;
1257
1258   sc->task = NULL;
1259   client = GNUNET_CLIENT_connect ("fs", sc->h->cfg);
1260   if (NULL == client)
1261   {
1262     try_reconnect (sc);
1263     return;
1264   }
1265   sc->client = client;
1266   sc->search_request_map_offset = 0;
1267   sc->keyword_offset = 0;
1268   schedule_transmit_search_request (sc);
1269 }
1270
1271
1272 /**
1273  * Shutdown any existing connection to the FS
1274  * service and try to establish a fresh one
1275  * (and then re-transmit our search request).
1276  *
1277  * @param sc the search to reconnec
1278  */
1279 static void
1280 try_reconnect (struct GNUNET_FS_SearchContext *sc)
1281 {
1282   if (NULL != sc->client)
1283   {
1284     GNUNET_CLIENT_disconnect (sc->client);
1285     sc->client = NULL;
1286   }
1287   sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (sc->reconnect_backoff);
1288   sc->task =
1289       GNUNET_SCHEDULER_add_delayed (sc->reconnect_backoff,
1290                                     &do_reconnect,
1291                                     sc);
1292 }
1293
1294
1295 /**
1296  * Start search for content, internal API.
1297  *
1298  * @param h handle to the file sharing subsystem
1299  * @param uri specifies the search parameters; can be
1300  *        a KSK URI or an SKS URI.
1301  * @param anonymity desired level of anonymity
1302  * @param options options for the search
1303  * @param cctx initial value for the client context
1304  * @param psearch parent search result (for namespace update searches)
1305  * @return context that can be used to control the search
1306  */
1307 static struct GNUNET_FS_SearchContext *
1308 search_start (struct GNUNET_FS_Handle *h,
1309               const struct GNUNET_FS_Uri *uri,
1310               uint32_t anonymity,
1311               enum GNUNET_FS_SearchOptions options,
1312               void *cctx,
1313               struct GNUNET_FS_SearchResult *psearch)
1314 {
1315   struct GNUNET_FS_SearchContext *sc;
1316   struct GNUNET_FS_ProgressInfo pi;
1317
1318   sc = GNUNET_new (struct GNUNET_FS_SearchContext);
1319   sc->h = h;
1320   sc->options = options;
1321   sc->uri = GNUNET_FS_uri_dup (uri);
1322   sc->anonymity = anonymity;
1323   sc->start_time = GNUNET_TIME_absolute_get ();
1324   if (NULL != psearch)
1325   {
1326     sc->psearch_result = psearch;
1327     psearch->update_search = sc;
1328   }
1329   sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
1330   sc->client_info = cctx;
1331   if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc))
1332   {
1333     GNUNET_FS_uri_destroy (sc->uri);
1334     GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1335     GNUNET_free (sc);
1336     return NULL;
1337   }
1338   GNUNET_FS_search_sync_ (sc);
1339   pi.status = GNUNET_FS_STATUS_SEARCH_START;
1340   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1341   return sc;
1342 }
1343
1344
1345 /**
1346  * Update the 'results' map for the individual keywords with the
1347  * results from the 'global' result set.
1348  *
1349  * @param cls closure, the `struct GNUNET_FS_SearchContext *`
1350  * @param key current key code
1351  * @param value value in the hash map, the `struct GNUNET_FS_SearchResult *`
1352  * @return #GNUNET_YES (we should continue to iterate)
1353  */
1354 static int
1355 update_sre_result_maps (void *cls,
1356                         const struct GNUNET_HashCode *key,
1357                         void *value)
1358 {
1359   struct GNUNET_FS_SearchContext *sc = cls;
1360   struct GNUNET_FS_SearchResult *sr = value;
1361   unsigned int i;
1362
1363   for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1364     if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8))))
1365       GNUNET_break (GNUNET_OK ==
1366                     GNUNET_CONTAINER_multihashmap_put (sc->requests[i].results,
1367                                                        &sr->key,
1368                                                        sr,
1369                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1370
1371   return GNUNET_YES;
1372 }
1373
1374
1375 /**
1376  * Build the request and actually initiate the search using the
1377  * GNUnet FS service.
1378  *
1379  * @param sc search context
1380  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1381  */
1382 int
1383 GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
1384 {
1385   unsigned int i;
1386   const char *keyword;
1387   const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
1388   struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
1389   struct SearchRequestEntry *sre;
1390
1391   GNUNET_assert (NULL == sc->client);
1392   if (GNUNET_FS_uri_test_ksk (sc->uri))
1393   {
1394     GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
1395     anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
1396     GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
1397     sc->requests =
1398         GNUNET_malloc (sizeof (struct SearchRequestEntry) *
1399                        sc->uri->data.ksk.keywordCount);
1400     for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1401     {
1402       keyword = &sc->uri->data.ksk.keywords[i][1];
1403       sre = &sc->requests[i];
1404       sre->keyword = GNUNET_strdup (keyword);
1405       GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
1406                                              keyword,
1407                                              "fs-ublock",
1408                                              &sre->dpub);
1409       GNUNET_CRYPTO_hash (&sre->dpub,
1410                           sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
1411                           &sre->uquery);
1412       sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
1413       if (sre->mandatory)
1414         sc->mandatory_count++;
1415       sre->results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
1416     }
1417     GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1418                                            &update_sre_result_maps,
1419                                            sc);
1420   }
1421   sc->client = GNUNET_CLIENT_connect ("fs", sc->h->cfg);
1422   if (NULL == sc->client)
1423     return GNUNET_SYSERR;
1424   sc->search_request_map_offset = 0;
1425   schedule_transmit_search_request (sc);
1426   return GNUNET_OK;
1427 }
1428
1429
1430 /**
1431  * Freeze probes for the given search result.
1432  *
1433  * @param cls the global FS handle
1434  * @param key the key for the search result (unused)
1435  * @param value the search result to free
1436  * @return #GNUNET_OK
1437  */
1438 static int
1439 search_result_freeze_probes (void *cls,
1440                              const struct GNUNET_HashCode *key,
1441                              void *value)
1442 {
1443   struct GNUNET_FS_SearchResult *sr = value;
1444
1445   if (NULL != sr->probe_ctx)
1446   {
1447     GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
1448     sr->probe_ctx = NULL;
1449     GNUNET_FS_stop_probe_ping_task_ (sr);
1450   }
1451   if (NULL != sr->probe_cancel_task)
1452   {
1453     GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
1454     sr->probe_cancel_task = NULL;
1455   }
1456   if (NULL != sr->update_search)
1457     GNUNET_FS_search_pause (sr->update_search);
1458   return GNUNET_OK;
1459 }
1460
1461
1462 /**
1463  * Resume probes for the given search result.
1464  *
1465  * @param cls the global FS handle
1466  * @param key the key for the search result (unused)
1467  * @param value the search result to free
1468  * @return #GNUNET_OK
1469  */
1470 static int
1471 search_result_resume_probes (void *cls,
1472                              const struct GNUNET_HashCode * key,
1473                              void *value)
1474 {
1475   struct GNUNET_FS_SearchResult *sr = value;
1476
1477   GNUNET_FS_search_start_probe_ (sr);
1478   if (NULL != sr->update_search)
1479     GNUNET_FS_search_continue (sr->update_search);
1480   return GNUNET_OK;
1481 }
1482
1483
1484 /**
1485  * Signal suspend and free the given search result.
1486  *
1487  * @param cls the global FS handle
1488  * @param key the key for the search result (unused)
1489  * @param value the search result to free
1490  * @return #GNUNET_OK
1491  */
1492 static int
1493 search_result_suspend (void *cls,
1494                        const struct GNUNET_HashCode *key,
1495                        void *value)
1496 {
1497   struct GNUNET_FS_SearchContext *sc = cls;
1498   struct GNUNET_FS_SearchResult *sr = value;
1499   struct GNUNET_FS_ProgressInfo pi;
1500
1501   if (NULL != sr->download)
1502   {
1503     GNUNET_FS_download_signal_suspend_ (sr->download);
1504     sr->download = NULL;
1505   }
1506   if (NULL != sr->update_search)
1507   {
1508     GNUNET_FS_search_signal_suspend_ (sr->update_search);
1509     sr->update_search = NULL;
1510   }
1511   GNUNET_FS_search_stop_probe_ (sr);
1512   if (0 == sr->mandatory_missing)
1513   {
1514     /* client is aware of search result, notify about suspension event */
1515     pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND;
1516     pi.value.search.specifics.result_suspend.cctx = sr->client_info;
1517     pi.value.search.specifics.result_suspend.meta = sr->meta;
1518     pi.value.search.specifics.result_suspend.uri = sr->uri;
1519     sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1520   }
1521   GNUNET_break (NULL == sr->client_info);
1522   GNUNET_free_non_null (sr->serialization);
1523   GNUNET_FS_uri_destroy (sr->uri);
1524   GNUNET_CONTAINER_meta_data_destroy (sr->meta);
1525   GNUNET_free_non_null (sr->keyword_bitmap);
1526   GNUNET_free (sr);
1527   return GNUNET_OK;
1528 }
1529
1530
1531 /**
1532  * Create SUSPEND event for the given search operation
1533  * and then clean up our state (without stop signal).
1534  *
1535  * @param cls the `struct GNUNET_FS_SearchContext` to signal for
1536  */
1537 void
1538 GNUNET_FS_search_signal_suspend_ (void *cls)
1539 {
1540   struct GNUNET_FS_SearchContext *sc = cls;
1541   struct GNUNET_FS_ProgressInfo pi;
1542   unsigned int i;
1543
1544   GNUNET_FS_end_top (sc->h, sc->top);
1545   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1546                                          &search_result_suspend, sc);
1547   pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND;
1548   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1549   GNUNET_break (NULL == sc->client_info);
1550   if (sc->task != NULL)
1551   {
1552     GNUNET_SCHEDULER_cancel (sc->task);
1553     sc->task = NULL;
1554   }
1555   if (NULL != sc->client)
1556   {
1557     GNUNET_CLIENT_disconnect (sc->client);
1558     sc->client = NULL;
1559   }
1560   GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1561   if (NULL != sc->requests)
1562   {
1563     GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
1564     for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1565     {
1566       GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
1567       GNUNET_free (sc->requests[i].keyword);
1568     }
1569   }
1570   GNUNET_free_non_null (sc->requests);
1571   GNUNET_free_non_null (sc->emsg);
1572   GNUNET_FS_uri_destroy (sc->uri);
1573   GNUNET_free_non_null (sc->serialization);
1574   GNUNET_free (sc);
1575 }
1576
1577
1578 /**
1579  * Start search for content.
1580  *
1581  * @param h handle to the file sharing subsystem
1582  * @param uri specifies the search parameters; can be
1583  *        a KSK URI or an SKS URI.
1584  * @param anonymity desired level of anonymity
1585  * @param options options for the search
1586  * @param cctx initial value for the client context
1587  * @return context that can be used to control the search
1588  */
1589 struct GNUNET_FS_SearchContext *
1590 GNUNET_FS_search_start (struct GNUNET_FS_Handle *h,
1591                         const struct GNUNET_FS_Uri *uri, uint32_t anonymity,
1592                         enum GNUNET_FS_SearchOptions options, void *cctx)
1593 {
1594   struct GNUNET_FS_SearchContext *ret;
1595
1596   ret = search_start (h, uri, anonymity, options, cctx, NULL);
1597   if (NULL == ret)
1598     return NULL;
1599   ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret);
1600   return ret;
1601 }
1602
1603
1604 /**
1605  * Pause search.
1606  *
1607  * @param sc context for the search that should be paused
1608  */
1609 void
1610 GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
1611 {
1612   struct GNUNET_FS_ProgressInfo pi;
1613
1614   if (NULL != sc->task)
1615   {
1616     GNUNET_SCHEDULER_cancel (sc->task);
1617     sc->task = NULL;
1618   }
1619   if (NULL != sc->client)
1620     GNUNET_CLIENT_disconnect (sc->client);
1621   sc->client = NULL;
1622   GNUNET_FS_search_sync_ (sc);
1623   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1624                                          &search_result_freeze_probes, sc);
1625   pi.status = GNUNET_FS_STATUS_SEARCH_PAUSED;
1626   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1627 }
1628
1629
1630 /**
1631  * Continue paused search.
1632  *
1633  * @param sc context for the search that should be resumed
1634  */
1635 void
1636 GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
1637 {
1638   struct GNUNET_FS_ProgressInfo pi;
1639
1640   GNUNET_assert (NULL == sc->client);
1641   GNUNET_assert (NULL == sc->task);
1642   do_reconnect (sc);
1643   GNUNET_FS_search_sync_ (sc);
1644   pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED;
1645   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1646   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1647                                          &search_result_resume_probes, sc);
1648 }
1649
1650
1651 /**
1652  * Signal stop for the given search result.
1653  *
1654  * @param cls the global FS handle
1655  * @param key the key for the search result (unused)
1656  * @param value the search result to free
1657  * @return #GNUNET_OK
1658  */
1659 static int
1660 search_result_stop (void *cls,
1661                     const struct GNUNET_HashCode *key,
1662                     void *value)
1663 {
1664   struct GNUNET_FS_SearchContext *sc = cls;
1665   struct GNUNET_FS_SearchResult *sr = value;
1666   struct GNUNET_FS_ProgressInfo pi;
1667
1668   GNUNET_FS_search_stop_probe_ (sr);
1669   if (NULL != sr->download)
1670   {
1671     sr->download->search = NULL;
1672     sr->download->top =
1673         GNUNET_FS_make_top (sr->download->h,
1674                             &GNUNET_FS_download_signal_suspend_,
1675                             sr->download);
1676     if (NULL != sr->download->serialization)
1677     {
1678       GNUNET_FS_remove_sync_file_ (sc->h,
1679                                    GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
1680                                    sr->download->serialization);
1681       GNUNET_free (sr->download->serialization);
1682       sr->download->serialization = NULL;
1683     }
1684     pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT;
1685     GNUNET_FS_download_make_status_ (&pi, sr->download);
1686     GNUNET_FS_download_sync_ (sr->download);
1687     sr->download = NULL;
1688   }
1689   if (0 != sr->mandatory_missing)
1690   {
1691     /* client is unaware of search result as
1692        it does not match required keywords */
1693     GNUNET_break (NULL == sr->client_info);
1694     return GNUNET_OK;
1695   }
1696   pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED;
1697   pi.value.search.specifics.result_stopped.cctx = sr->client_info;
1698   pi.value.search.specifics.result_stopped.meta = sr->meta;
1699   pi.value.search.specifics.result_stopped.uri = sr->uri;
1700   sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sc);
1701   return GNUNET_OK;
1702 }
1703
1704
1705 /**
1706  * Free the given search result.
1707  *
1708  * @param cls the global FS handle
1709  * @param key the key for the search result (unused)
1710  * @param value the search result to free
1711  * @return #GNUNET_OK
1712  */
1713 static int
1714 search_result_free (void *cls,
1715                     const struct GNUNET_HashCode *key,
1716                     void *value)
1717 {
1718   struct GNUNET_FS_SearchResult *sr = value;
1719
1720   if (NULL != sr->update_search)
1721   {
1722     GNUNET_FS_search_stop (sr->update_search);
1723     GNUNET_assert (NULL == sr->update_search);
1724   }
1725   GNUNET_break (NULL == sr->probe_ctx);
1726   GNUNET_break (NULL == sr->probe_cancel_task);
1727   GNUNET_break (NULL == sr->client_info);
1728   GNUNET_free_non_null (sr->serialization);
1729   GNUNET_FS_uri_destroy (sr->uri);
1730   GNUNET_CONTAINER_meta_data_destroy (sr->meta);
1731   GNUNET_free_non_null (sr->keyword_bitmap);
1732   GNUNET_free (sr);
1733   return GNUNET_OK;
1734 }
1735
1736
1737 /**
1738  * Stop search for content.
1739  *
1740  * @param sc context for the search that should be stopped
1741  */
1742 void
1743 GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
1744 {
1745   struct GNUNET_FS_ProgressInfo pi;
1746   unsigned int i;
1747
1748   if (NULL != sc->top)
1749     GNUNET_FS_end_top (sc->h, sc->top);
1750   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1751                                          &search_result_stop, sc);
1752   if (NULL != sc->psearch_result)
1753     sc->psearch_result->update_search = NULL;
1754   if (NULL != sc->serialization)
1755   {
1756     GNUNET_FS_remove_sync_file_ (sc->h,
1757                                  (sc->psearch_result !=
1758                                   NULL) ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH :
1759                                  GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
1760                                  sc->serialization);
1761     GNUNET_FS_remove_sync_dir_ (sc->h,
1762                                 (sc->psearch_result !=
1763                                  NULL) ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH :
1764                                 GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
1765                                 sc->serialization);
1766     GNUNET_free (sc->serialization);
1767   }
1768   pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED;
1769   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1770   GNUNET_break (NULL == sc->client_info);
1771   if (NULL != sc->task)
1772     GNUNET_SCHEDULER_cancel (sc->task);
1773   if (NULL != sc->client)
1774     GNUNET_CLIENT_disconnect (sc->client);
1775   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1776                                          &search_result_free, sc);
1777   GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1778   if (NULL != sc->requests)
1779   {
1780     GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
1781     for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1782       GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
1783   }
1784   GNUNET_free_non_null (sc->requests);
1785   GNUNET_free_non_null (sc->emsg);
1786   GNUNET_FS_uri_destroy (sc->uri);
1787   GNUNET_free (sc);
1788 }
1789
1790 /* end of fs_search.c */