fs_search.c File Reference

Helper functions for searching. More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_fs_service.h"
#include "gnunet_protocols.h"
#include "fs_api.h"
#include "fs_publish_ublock.h"

Include dependency graph for fs_search.c:

Go to the source code of this file.

Data Structures
struct	GetResultContext
	Context for "get_result_present". More...
struct	MessageBuilderContext
	Closure for build_result_set(). More...

Macros
#define	AVAILABILITY_TRIALS_MAX   8
	Number of availability trials we perform per search result.

Functions
void *	GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
	Fill in all of the generic fields for a search event and call the callback.
static int	test_result_present (void *cls, const struct GNUNET_HashCode *key, void *value)
	Check if the given result is identical to the given URI.
static void	notify_client_chk_result (struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
	We've found a new CHK result.
static void	notify_client_chk_update (struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
	We've found new information about an existing CHK result.
static int	get_result_present (void *cls, const struct GNUNET_HashCode *key, void *value)
	Check if the given result is identical to the given URI and if so return it.
static void	signal_probe_result (struct GNUNET_FS_SearchResult *sr)
	Signal result of last probe to client and then schedule next probe.
static void	probe_failure_handler (void *cls)
	Handle the case where we have failed to receive a response for our probe.
static void	probe_success_handler (void *cls)
	Handle the case where we have gotten a response for our probe.
void *	GNUNET_FS_search_probe_progress_ (void *cls, const struct GNUNET_FS_ProgressInfo *info)
	Notification of FS that a search probe has made progress.
static void	probe_ping_task_cb (void *cls)
	Task run periodically to remind clients that a probe is active.
static void	start_probe_ping_task (struct GNUNET_FS_SearchResult *sr)
	Start the ping task for this search result.
void	GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr)
	Stop the ping task for this search result.
void	GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
	Start download probes for the given search result.
struct GNUNET_FS_SearchResult *	GNUNET_FS_probe (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_MetaData *meta, void *client_info, uint32_t anonymity)
	Start download probes for the given search result.
static void	GNUNET_FS_search_stop_probe_ (struct GNUNET_FS_SearchResult *sr)
	Stop probing activity associated with a search result.
void *	GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
	Stop probe activity.
static void	process_ksk_result (struct GNUNET_FS_SearchContext *sc, struct SearchRequestEntry *ent, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_MetaData *meta)
	We have received a KSK result.
static struct GNUNET_FS_SearchContext *	search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx, struct GNUNET_FS_SearchResult *psearch)
	Start search for content, internal API.
static void	process_sks_result (struct GNUNET_FS_SearchContext *sc, const char *id_update, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_MetaData *meta)
	We have received an SKS result.
static int	decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc, const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub, const void *edata, size_t edata_size, char *data)
	Decrypt a ublock using a 'keyword' as the passphrase.
static void	process_kblock (struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
	Process a keyword search result.
static void	process_sblock (struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
	Process a namespace-search result.
static void	try_reconnect (struct GNUNET_FS_SearchContext *sc)
	Shutdown any existing connection to the FS service and try to establish a fresh one (and then re-transmit our search request).
static int	check_result (void *cls, const struct ClientPutMessage *cm)
	We check a result message from the service.
static void	handle_result (void *cls, const struct ClientPutMessage *cm)
	We process a search result from the service.
static void	schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
	Schedule the transmission of the (next) search request to the service.
static int	build_result_set (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterating over the known results, pick those matching the given result range and store their keys at 'xoff'.
static int	find_result_set (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterating over the known results, count those matching the given result range and increment put count for each.
static void	search_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
static void	do_reconnect (void *cls)
	Reconnect to the FS service and transmit our queries NOW.
static int	update_sre_result_maps (void *cls, const struct GNUNET_HashCode *key, void *value)
	Update the 'results' map for the individual keywords with the results from the 'global' result set.
int	GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
	Build the request and actually initiate the search using the GNUnet FS service.
static int	search_result_freeze_probes (void *cls, const struct GNUNET_HashCode *key, void *value)
	Freeze probes for the given search result.
static int	search_result_resume_probes (void *cls, const struct GNUNET_HashCode *key, void *value)
	Resume probes for the given search result.
static int	search_result_suspend (void *cls, const struct GNUNET_HashCode *key, void *value)
	Signal suspend and free the given search result.
void	GNUNET_FS_search_signal_suspend_ (void *cls)
	Create SUSPEND event for the given search operation and then clean up our state (without stop signal).
struct GNUNET_FS_SearchContext *	GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
	Start search for content.
void	GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
	Pause search.
void	GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
	Continue paused search.
static int	search_result_stop (void *cls, const struct GNUNET_HashCode *key, void *value)
	Signal stop for the given search result.
static int	search_result_free (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free the given search result.
void	GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
	Stop search for content.

Detailed Description

Helper functions for searching.

Author

Christian Grothoff

Definition in file fs_search.c.

Macro Definition Documentation

AVAILABILITY_TRIALS_MAX

#define AVAILABILITY_TRIALS_MAX   8

Number of availability trials we perform per search result.

Definition at line 37 of file fs_search.c.

Function Documentation

GNUNET_FS_search_make_status_()

void * GNUNET_FS_search_make_status_	(	struct GNUNET_FS_ProgressInfo *	pi,
		struct GNUNET_FS_Handle *	h,
		struct GNUNET_FS_SearchContext *	sc
	)

Fill in all of the generic fields for a search event and call the callback.

Parameters

pi	structure to fill in
h	file-sharing handle
sc	overall search context

Returns

value returned by the callback

Definition at line 49 of file fs_search.c.

{
  void *ret;
 
  pi->value.search.sc = sc;
  pi->value.search.cctx = (NULL != sc) ? sc->client_info : NULL;
  pi->value.search.pctx =
    ((NULL == sc) || (NULL == sc->psearch_result))
    ? NULL
    : sc->psearch_result->client_info;
  pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
  pi->value.search.duration = (NULL != sc)
                              ? GNUNET_TIME_absolute_get_duration (
    sc->start_time)
                              : GNUNET_TIME_UNIT_ZERO;
  pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
  pi->fsh = h;
  ret = h->upcb (h->upcb_cls, pi);
  return ret;
}

References GNUNET_FS_SearchContext::anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_FS_SearchContext::client_info, GNUNET_FS_ProgressInfo::fsh, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_ZERO, h, GNUNET_FS_SearchContext::psearch_result, ret, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchContext::start_time, GNUNET_FS_SearchContext::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_continue(), GNUNET_FS_search_pause(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_stop(), notify_client_chk_result(), notify_client_chk_update(), search_result_stop(), search_result_suspend(), search_start(), signal_probe_result(), signal_result_resume(), and signal_search_resume().

Here is the call graph for this function:

Here is the caller graph for this function:

test_result_present()

static int test_result_present ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Check if the given result is identical to the given URI.

Parameters

cls	points to the URI we check against
key	not used
value	a struct GNUNET_FS_SearchResult who's URI we should compare with

Returns

GNUNET_SYSERR if the result is present, GNUNET_OK otherwise

Definition at line 84 of file fs_search.c.

{
  const struct GNUNET_FS_Uri *uri = cls;
  struct GNUNET_FS_SearchResult *sr = value;
 
  if (GNUNET_FS_uri_test_equal (uri, sr->uri))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_FS_uri_test_equal(), GNUNET_OK, GNUNET_SYSERR, uri, GNUNET_FS_SearchResult::uri, and value.

Referenced by process_ksk_result(), and process_sks_result().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_client_chk_result()

static void notify_client_chk_result ( struct GNUNET_FS_SearchContext *  sc, struct GNUNET_FS_SearchResult *  sr  )

static

We've found a new CHK result.

Let the client know about it.

Parameters

sc	the search context
sr	the specific result

Definition at line 105 of file fs_search.c.

{
  struct GNUNET_FS_ProgressInfo pi;
 
  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT;
  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->h, sc);
}

References GNUNET_FS_SearchResult::client_info, GNUNET_FS_search_make_status_(), GNUNET_FS_STATUS_SEARCH_RESULT, GNUNET_FS_SearchContext::h, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::optional_support, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by process_ksk_result(), and process_sks_result().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_client_chk_update()

static void notify_client_chk_update ( struct GNUNET_FS_SearchContext *  sc, struct GNUNET_FS_SearchResult *  sr  )

static

We've found new information about an existing CHK result.

Let the client know about it.

Parameters

sc	the search context
sr	the specific result

Definition at line 127 of file fs_search.c.

{
  struct GNUNET_FS_ProgressInfo pi;
 
  pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
  pi.value.search.specifics.update.cctx = sr->client_info;
  pi.value.search.specifics.update.meta = sr->meta;
  pi.value.search.specifics.update.uri = sr->uri;
  pi.value.search.specifics.update.availability_rank =
    2 * sr->availability_success - sr->availability_trials;
  pi.value.search.specifics.update.availability_certainty =
    sr->availability_trials;
  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
  pi.value.search.specifics.update.current_probe_time
    = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
}

References GNUNET_FS_SearchResult::availability_success, GNUNET_FS_SearchResult::availability_trials, GNUNET_FS_SearchResult::client_info, GNUNET_FS_search_make_status_(), GNUNET_FS_STATUS_SEARCH_UPDATE, GNUNET_TIME_absolute_get_duration(), GNUNET_FS_SearchContext::h, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::optional_support, GNUNET_FS_SearchResult::probe_active_time, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by process_ksk_result().

Here is the call graph for this function:

Here is the caller graph for this function:

get_result_present()

static int get_result_present ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Check if the given result is identical to the given URI and if so return it.

Parameters

cls	a struct GetResultContext
key	not used
value	a struct GNUNET_FS_SearchResult who's URI we should compare with

Returns

GNUNET_OK

Definition at line 176 of file fs_search.c.

{
  struct GetResultContext *grc = cls;
  struct GNUNET_FS_SearchResult *sr = value;
 
  if (GNUNET_FS_uri_test_equal (grc->uri, sr->uri))
    grc->sr = sr;
  return GNUNET_OK;
}

References GNUNET_FS_uri_test_equal(), GNUNET_OK, GetResultContext::sr, GNUNET_FS_SearchResult::uri, GetResultContext::uri, and value.

Referenced by process_ksk_result().

Here is the call graph for this function:

Here is the caller graph for this function:

signal_probe_result()

static void signal_probe_result ( struct GNUNET_FS_SearchResult *  sr )

static

Signal result of last probe to client and then schedule next probe.

Parameters

sr	search result to signal for

Definition at line 196 of file fs_search.c.

{
  struct GNUNET_FS_ProgressInfo pi;
 
  pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
  pi.value.search.specifics.update.cctx = sr->client_info;
  pi.value.search.specifics.update.meta = sr->meta;
  pi.value.search.specifics.update.uri = sr->uri;
  pi.value.search.specifics.update.availability_rank
    = 2 * sr->availability_success - sr->availability_trials;
  pi.value.search.specifics.update.availability_certainty
    = sr->availability_trials;
  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
  pi.value.search.specifics.update.current_probe_time
    = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc);
  GNUNET_FS_search_start_probe_ (sr);
}

References GNUNET_FS_SearchResult::availability_success, GNUNET_FS_SearchResult::availability_trials, GNUNET_FS_SearchResult::client_info, GNUNET_FS_search_make_status_(), GNUNET_FS_search_start_probe_(), GNUNET_FS_STATUS_SEARCH_UPDATE, GNUNET_TIME_absolute_get_duration(), GNUNET_FS_SearchResult::h, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::optional_support, GNUNET_FS_SearchResult::probe_active_time, GNUNET_FS_SearchResult::sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by probe_failure_handler(), probe_ping_task_cb(), and probe_success_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

probe_failure_handler()

static void probe_failure_handler ( void *  cls )

static

Handle the case where we have failed to receive a response for our probe.

Parameters

cls	our struct GNUNET_FS_SearchResult *

Definition at line 222 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr = cls;
 
  sr->probe_cancel_task = NULL;
  sr->availability_trials++;
  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
  sr->probe_ctx = NULL;
  GNUNET_FS_stop_probe_ping_task_ (sr);
  GNUNET_FS_search_result_sync_ (sr);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Probe #%u for search result %p failed\n",
              sr->availability_trials,
              sr);
  signal_probe_result (sr);
}

References GNUNET_FS_SearchResult::availability_trials, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_download_stop(), GNUNET_FS_search_result_sync_(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_log, GNUNET_YES, GNUNET_FS_SearchResult::probe_cancel_task, GNUNET_FS_SearchResult::probe_ctx, and signal_probe_result().

Referenced by GNUNET_FS_search_probe_progress_().

Here is the call graph for this function:

Here is the caller graph for this function:

probe_success_handler()

static void probe_success_handler ( void *  cls )

static

Handle the case where we have gotten a response for our probe.

Parameters

cls	our struct GNUNET_FS_SearchResult *

Definition at line 246 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr = cls;
 
  sr->probe_cancel_task = NULL;
  sr->availability_trials++;
  sr->availability_success++;
  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
  sr->probe_ctx = NULL;
  GNUNET_FS_stop_probe_ping_task_ (sr);
  GNUNET_FS_search_result_sync_ (sr);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Probe #%u for search result %p succeeded\n",
              sr->availability_trials,
              sr);
  signal_probe_result (sr);
}

References GNUNET_FS_SearchResult::availability_success, GNUNET_FS_SearchResult::availability_trials, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_download_stop(), GNUNET_FS_search_result_sync_(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_log, GNUNET_YES, GNUNET_FS_SearchResult::probe_cancel_task, GNUNET_FS_SearchResult::probe_ctx, and signal_probe_result().

Referenced by GNUNET_FS_search_probe_progress_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_probe_progress_()

void * GNUNET_FS_search_probe_progress_	(	void *	cls,
		const struct GNUNET_FS_ProgressInfo *	info
	)

Notification of FS that a search probe has made progress.

This function is used INSTEAD of the client's event handler for downloads where the GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.

Parameters

cls	closure, always NULL (!), actual closure is in the client-context of the info struct
info	details about the event, specifying the event type and various bits about the event

Returns

client-context (for the next progress call for this operation; should be set to NULL for SUSPEND and STOPPED events). The value returned will be passed to future callbacks in the respective field in the struct GNUNET_FS_ProgressInfo.

Definition at line 281 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
  struct GNUNET_TIME_Relative dur;
 
  switch (info->status)
  {
  case GNUNET_FS_STATUS_DOWNLOAD_START:
    /* ignore */
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
    /* probes should never be resumed */
    GNUNET_assert (0);
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
    /* probes should never be suspended */
    GNUNET_break (0);
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
    /* ignore */
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
    if (NULL != sr->probe_cancel_task)
    {
      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
      sr->probe_cancel_task = NULL;
    }
    sr->probe_cancel_task =
      GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
                                    &probe_failure_handler, sr);
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
    if (NULL != sr->probe_cancel_task)
    {
      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
      sr->probe_cancel_task = NULL;
    }
    sr->probe_cancel_task =
      GNUNET_SCHEDULER_add_now (&probe_success_handler, sr);
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
    if (NULL != sr->probe_cancel_task)
    {
      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
      sr->probe_cancel_task = NULL;
    }
    sr = NULL;
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
    if (NULL == sr->probe_cancel_task)
    {
      sr->probe_active_time = GNUNET_TIME_absolute_get ();
      sr->probe_cancel_task =
        GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
                                      &probe_failure_handler, sr);
    }
    break;
  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
    if (NULL != sr->probe_cancel_task)
    {
      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
      sr->probe_cancel_task = NULL;
    }
    dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
    sr->remaining_probe_time =
      GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
    if (0 == sr->remaining_probe_time.rel_value_us)
      sr->probe_cancel_task =
        GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr);
    GNUNET_FS_search_result_sync_ (sr);
    break;
 
  default:
    GNUNET_break (0);
    return NULL;
  }
  return sr;
}

References GNUNET_FS_SearchResult::download, GNUNET_assert, GNUNET_break, GNUNET_FS_search_result_sync_(), GNUNET_FS_STATUS_DOWNLOAD_ACTIVE, GNUNET_FS_STATUS_DOWNLOAD_COMPLETED, GNUNET_FS_STATUS_DOWNLOAD_ERROR, GNUNET_FS_STATUS_DOWNLOAD_INACTIVE, GNUNET_FS_STATUS_DOWNLOAD_PROGRESS, GNUNET_FS_STATUS_DOWNLOAD_RESUME, GNUNET_FS_STATUS_DOWNLOAD_START, GNUNET_FS_STATUS_DOWNLOAD_STOPPED, GNUNET_FS_STATUS_DOWNLOAD_SUSPEND, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_subtract(), info, GNUNET_FS_SearchResult::probe_active_time, GNUNET_FS_SearchResult::probe_cancel_task, probe_failure_handler(), probe_success_handler(), GNUNET_TIME_Relative::rel_value_us, and GNUNET_FS_SearchResult::remaining_probe_time.

Referenced by GNUNET_FS_download_make_status_().

Here is the call graph for this function:

Here is the caller graph for this function:

probe_ping_task_cb()

static void probe_ping_task_cb ( void *  cls )

static

Task run periodically to remind clients that a probe is active.

Parameters

cls	the struct GNUNET_FS_SearchResult that we are probing for

Definition at line 368 of file fs_search.c.

{
  struct GNUNET_FS_Handle *h = cls;
 
  for (struct GNUNET_FS_SearchResult *sr = h->probes_head;
       NULL != sr;
       sr = sr->next)
    if (NULL != sr->probe_ctx->mq)
      signal_probe_result (sr);
  h->probe_ping_task
    = GNUNET_SCHEDULER_add_delayed (GNUNET_FS_PROBE_UPDATE_FREQUENCY,
                                    &probe_ping_task_cb,
                                    h);
}

References GNUNET_FS_PROBE_UPDATE_FREQUENCY, GNUNET_SCHEDULER_add_delayed(), h, probe_ping_task_cb(), and signal_probe_result().

Referenced by probe_ping_task_cb(), and start_probe_ping_task().

Here is the call graph for this function:

Here is the caller graph for this function:

start_probe_ping_task()

static void start_probe_ping_task ( struct GNUNET_FS_SearchResult *  sr )

static

Start the ping task for this search result.

Parameters

sr	result to start pinging for.

Definition at line 390 of file fs_search.c.

{
  struct GNUNET_FS_Handle *h = sr->h;
 
  GNUNET_CONTAINER_DLL_insert (h->probes_head,
                               h->probes_tail,
                               sr);
  if (NULL == h->probe_ping_task)
    h->probe_ping_task
      = GNUNET_SCHEDULER_add_now (&probe_ping_task_cb,
                                  h);
}

References GNUNET_CONTAINER_DLL_insert, GNUNET_SCHEDULER_add_now(), h, GNUNET_FS_SearchResult::h, and probe_ping_task_cb().

Referenced by GNUNET_FS_search_start_probe_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_stop_probe_ping_task_()

void GNUNET_FS_stop_probe_ping_task_

(

struct GNUNET_FS_SearchResult *

sr

)

Stop the ping task for this search result.

Parameters

sr	result to start pinging for.

Definition at line 410 of file fs_search.c.

{
  struct GNUNET_FS_Handle *h = sr->h;
 
  GNUNET_CONTAINER_DLL_remove (h->probes_head,
                               h->probes_tail,
                               sr);
  if (NULL == h->probes_head)
  {
    GNUNET_SCHEDULER_cancel (h->probe_ping_task);
    h->probe_ping_task = NULL;
  }
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_cancel(), h, and GNUNET_FS_SearchResult::h.

Referenced by GNUNET_FS_download_start_from_search(), GNUNET_FS_search_stop_probe_(), probe_failure_handler(), probe_success_handler(), and search_result_freeze_probes().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_start_probe_()

void GNUNET_FS_search_start_probe_

(

struct GNUNET_FS_SearchResult *

sr

)

Start download probes for the given search result.

Parameters

sr	the search result

Definition at line 431 of file fs_search.c.

{
  uint64_t off;
  uint64_t len;
 
  if (NULL != sr->probe_ctx)
    return;
  if (NULL != sr->download)
    return;
  if (0 == (sr->h->flags & GNUNET_FS_FLAGS_DO_PROBES))
    return;
  if (sr->availability_trials > AVAILABILITY_TRIALS_MAX)
    return;
  if ( (GNUNET_FS_URI_CHK != sr->uri->type) &&
       (GNUNET_FS_URI_LOC != sr->uri->type) )
    return;
  len = GNUNET_FS_uri_chk_get_file_size (sr->uri);
  if (0 == len)
    return;
  if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
    return;
  off = len / DBLOCK_SIZE;
  if (off > 0)
    off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, off);
  off *= DBLOCK_SIZE;
  if (len - off < DBLOCK_SIZE)
    len = len - off;
  else
    len = DBLOCK_SIZE;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting probe #%u (at offset %llu) for search result %p\n",
              sr->availability_trials + 1,
              (unsigned long long) off,
              sr);
  sr->remaining_probe_time =
    GNUNET_TIME_relative_saturating_multiply (sr->h->avg_block_latency,
                                              2 * (1
                                                   + sr->availability_trials));
  sr->probe_ctx =
    GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off,
                              len, sr->anonymity,
                              GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
                              | GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
  start_probe_ping_task (sr);
}

References GNUNET_FS_SearchResult::anonymity, GNUNET_FS_SearchResult::availability_success, GNUNET_FS_SearchResult::availability_trials, AVAILABILITY_TRIALS_MAX, GNUNET_FS_Handle::avg_block_latency, DBLOCK_SIZE, GNUNET_FS_SearchResult::download, GNUNET_FS_Handle::flags, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_DOWNLOAD_NO_TEMPORARIES, GNUNET_FS_download_start(), GNUNET_FS_FLAGS_DO_PROBES, GNUNET_FS_URI_CHK, GNUNET_FS_uri_chk_get_file_size(), GNUNET_FS_URI_LOC, GNUNET_log, GNUNET_TIME_relative_saturating_multiply(), GNUNET_FS_SearchResult::h, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::probe_ctx, GNUNET_FS_SearchResult::remaining_probe_time, start_probe_ping_task(), GNUNET_FS_Uri::type, and GNUNET_FS_SearchResult::uri.

Referenced by GNUNET_FS_probe(), process_ksk_result(), process_sks_result(), search_result_resume_probes(), signal_probe_result(), and signal_result_resume().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_stop_probe_()

static void GNUNET_FS_search_stop_probe_ ( struct GNUNET_FS_SearchResult *  sr )

static

Stop probing activity associated with a search result.

Parameters

sr	search result

Definition at line 516 of file fs_search.c.

{
  if (NULL != sr->probe_ctx)
  {
    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
    sr->probe_ctx = NULL;
    GNUNET_FS_stop_probe_ping_task_ (sr);
  }
  if (NULL != sr->probe_cancel_task)
  {
    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
    sr->probe_cancel_task = NULL;
  }
}

References GNUNET_FS_download_stop(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_FS_SearchResult::probe_cancel_task, and GNUNET_FS_SearchResult::probe_ctx.

Referenced by GNUNET_FS_probe_stop(), search_result_stop(), and search_result_suspend().

Here is the call graph for this function:

Here is the caller graph for this function:

process_ksk_result()

static void process_ksk_result ( struct GNUNET_FS_SearchContext *  sc, struct SearchRequestEntry *  ent, const struct GNUNET_FS_Uri *  uri, const struct GNUNET_FS_MetaData *  meta  )

static

We have received a KSK result.

Check how it fits in with the overall query and notify the client accordingly.

Parameters

sc	context for the overall query
ent	entry for the specific keyword
uri	the URI that was found
meta	metadata associated with the URI under the ent keyword

Definition at line 565 of file fs_search.c.

{
  struct GNUNET_HashCode key;
  struct GNUNET_FS_SearchResult *sr;
  struct GetResultContext grc;
  int is_new;
  unsigned int koff;
 
  /* check if new */
  GNUNET_assert (NULL != sc);
  if (GNUNET_OK !=
      GNUNET_FS_uri_to_key (uri,
                            &key))
  {
    GNUNET_break_op (0);
    return;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CONTAINER_multihashmap_get_multiple (ent->results,
                                                  &key,
                                                  &test_result_present,
                                                  (void *) uri))
    return;                     /* duplicate result */
  /* try to find search result in master map */
  grc.sr = NULL;
  grc.uri = uri;
  GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map,
                                              &key,
                                              &get_result_present, &grc);
  sr = grc.sr;
  is_new = (NULL == sr) || (sr->mandatory_missing > 0);
  if (NULL == sr)
  {
    sr = GNUNET_new (struct GNUNET_FS_SearchResult);
    sr->h = sc->h;
    sr->sc = sc;
    sr->anonymity = sc->anonymity;
    sr->uri = GNUNET_FS_uri_dup (uri);
    sr->meta = GNUNET_FS_meta_data_duplicate (meta);
    sr->mandatory_missing = sc->mandatory_count;
    sr->key = key;
    sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7)
                                        / 8);                                       /* round up, count bits */
    GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  }
  else
  {
    GNUNET_FS_meta_data_merge (sr->meta, meta);
  }
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multihashmap_put (ent->results,
                                                   &sr->key,
                                                   sr,
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
  koff = ent - sc->requests;
  GNUNET_assert ((ent >= sc->requests) &&
                 (koff < sc->uri->data.ksk.keywordCount));
  sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8));
  /* check if mandatory satisfied */
  if (1 <= GNUNET_CONTAINER_multihashmap_size (ent->results))
  {
    if (ent->mandatory)
    {
      GNUNET_break (sr->mandatory_missing > 0);
      sr->mandatory_missing--;
    }
    else
    {
      sr->optional_support++;
    }
  }
  if (0 != sr->mandatory_missing)
  {
    GNUNET_break (NULL == sr->client_info);
    return;
  }
  if (is_new)
    notify_client_chk_result (sc, sr);
  else
    notify_client_chk_update (sc, sr);
  GNUNET_FS_search_result_sync_ (sr);
  GNUNET_FS_search_start_probe_ (sr);
}

References GNUNET_FS_SearchResult::anonymity, GNUNET_FS_SearchContext::anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_FS_Uri::data, get_result_present(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_FS_meta_data_duplicate(), GNUNET_FS_meta_data_merge(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_start_probe_(), GNUNET_FS_uri_dup(), GNUNET_FS_uri_to_key(), GNUNET_malloc, GNUNET_new, GNUNET_OK, GNUNET_SYSERR, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchContext::h, key, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::keyword_bitmap, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, meta, GNUNET_FS_SearchResult::meta, notify_client_chk_result(), notify_client_chk_update(), GNUNET_FS_SearchResult::optional_support, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchResult::sc, GetResultContext::sr, test_result_present(), uri, GNUNET_FS_SearchResult::uri, GNUNET_FS_SearchContext::uri, and GetResultContext::uri.

Referenced by process_kblock().

Here is the call graph for this function:

Here is the caller graph for this function:

search_start()

static struct GNUNET_FS_SearchContext * search_start ( struct GNUNET_FS_Handle *  h, const struct GNUNET_FS_Uri *  uri, uint32_t  anonymity, enum GNUNET_FS_SearchOptions  options, void *  cctx, struct GNUNET_FS_SearchResult *  psearch  )

static

Start search for content, internal API.

Parameters

h	handle to the file sharing subsystem
uri	specifies the search parameters; can be a KSK URI or an SKS URI.
anonymity	desired level of anonymity
options	options for the search
cctx	client context
psearch	parent search result (for namespace update searches)

Returns

context that can be used to control the search

Parameters

h	handle to the file sharing subsystem
uri	specifies the search parameters; can be a KSK URI or an SKS URI.
anonymity	desired level of anonymity
options	options for the search
cctx	initial value for the client context
psearch	parent search result (for namespace update searches)

Returns

context that can be used to control the search

Definition at line 1334 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc;
  struct GNUNET_FS_ProgressInfo pi;
 
  sc = GNUNET_new (struct GNUNET_FS_SearchContext);
  sc->h = h;
  sc->options = options;
  sc->uri = GNUNET_FS_uri_dup (uri);
  sc->anonymity = anonymity;
  sc->start_time = GNUNET_TIME_absolute_get ();
  if (NULL != psearch)
  {
    sc->psearch_result = psearch;
    psearch->update_search = sc;
  }
  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
  sc->client_info = cctx;
  if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc))
  {
    GNUNET_FS_uri_destroy (sc->uri);
    GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
    GNUNET_free (sc);
    return NULL;
  }
  GNUNET_FS_search_sync_ (sc);
  pi.status = GNUNET_FS_STATUS_SEARCH_START;
  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
  return sc;
}

References anonymity, GNUNET_FS_SearchContext::anonymity, GNUNET_FS_ProgressInfo::cctx, GNUNET_FS_SearchContext::client_info, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_FS_search_make_status_(), GNUNET_FS_search_start_searching_(), GNUNET_FS_search_sync_(), GNUNET_FS_STATUS_SEARCH_START, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get(), h, GNUNET_FS_SearchContext::h, GNUNET_FS_SearchContext::master_result_map, options, GNUNET_FS_SearchContext::options, GNUNET_FS_SearchContext::psearch_result, sc, GNUNET_FS_SearchContext::start_time, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::update_search, uri, and GNUNET_FS_SearchContext::uri.

Referenced by GNUNET_FS_search_start(), and process_sks_result().

Here is the call graph for this function:

Here is the caller graph for this function:

process_sks_result()

static void process_sks_result ( struct GNUNET_FS_SearchContext *  sc, const char *  id_update, const struct GNUNET_FS_Uri *  uri, const struct GNUNET_FS_MetaData *  meta  )

static

We have received an SKS result.

Start searching for updates and notify the client if it is a new result.

Parameters

sc	context for the overall query
id_update	identifier for updates, NULL for none
uri	the URI that was found
meta	metadata associated with the URI

Definition at line 686 of file fs_search.c.

{
  struct GNUNET_FS_Uri uu;
  struct GNUNET_HashCode key;
  struct GNUNET_FS_SearchResult *sr;
 
  /* check if new */
  GNUNET_assert (NULL != sc);
  if (GNUNET_OK !=
      GNUNET_FS_uri_to_key (uri,
                            &key))
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key,
                          &uri->data.chk.chk.query,
                          &key);
  if (GNUNET_SYSERR ==
      GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, &key,
                                                  &test_result_present,
                                                  (void *) uri))
    return;                     /* duplicate result */
  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
  sr->h = sc->h;
  sr->sc = sc;
  sr->anonymity = sc->anonymity;
  sr->uri = GNUNET_FS_uri_dup (uri);
  sr->meta = GNUNET_FS_meta_data_duplicate (meta);
  sr->key = key;
  GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_FS_search_result_sync_ (sr);
  GNUNET_FS_search_start_probe_ (sr);
  /* notify client */
  if (0 == sr->mandatory_missing)
    notify_client_chk_result (sc, sr);
  else
    GNUNET_break (NULL == sr->client_info);
  /* search for updates */
  if (0 == strlen (id_update))
    return;                     /* no updates */
  uu.type = GNUNET_FS_URI_SKS;
  uu.data.sks.ns = sc->uri->data.sks.ns;
  uu.data.sks.identifier = GNUNET_strdup (id_update);
  (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
  GNUNET_free (uu.data.sks.identifier);
}

References GNUNET_FS_SearchResult::anonymity, GNUNET_FS_SearchContext::anonymity, FileIdentifier::chk, GNUNET_FS_Uri::chk, GNUNET_FS_SearchResult::client_info, GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash_xor(), GNUNET_free, GNUNET_FS_meta_data_duplicate(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_start_probe_(), GNUNET_FS_uri_dup(), GNUNET_FS_URI_SKS, GNUNET_FS_uri_to_key(), GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchContext::h, GNUNET_FS_Uri::identifier, key, ContentHashKey::key, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, meta, GNUNET_FS_SearchResult::meta, notify_client_chk_result(), GNUNET_FS_Uri::ns, GNUNET_FS_SearchContext::options, ContentHashKey::query, sc, GNUNET_FS_SearchResult::sc, search_start(), GNUNET_FS_Uri::sks, test_result_present(), GNUNET_FS_Uri::type, uri, GNUNET_FS_SearchResult::uri, and GNUNET_FS_SearchContext::uri.

Referenced by process_sblock().

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt_block_with_keyword()

static int decrypt_block_with_keyword ( const struct GNUNET_FS_SearchContext *  sc, const struct GNUNET_CRYPTO_EcdsaPublicKey *  dpub, const void *  edata, size_t  edata_size, char *  data  )

static

Decrypt a ublock using a 'keyword' as the passphrase.

Given the KSK public key derived from the keyword, this function looks up the original keyword in the search context and decrypts the given ciphertext block.

Parameters

sc	search context with the keywords
dpub	derived public key used for the search
edata	encrypted data
edata_size	number of bytes in edata (and data)
data	where to store the plaintext

Returns

keyword index on success, GNUNET_SYSERR on error (no such keyword, internal error)

Definition at line 754 of file fs_search.c.

{
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
  unsigned int i;
 
  /* find key */
  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
    if (0 == memcmp (dpub,
                     &sc->requests[i].dpub,
                     sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
      break;
  if (i == sc->uri->data.ksk.keywordCount)
  {
    /* oops, does not match any of our keywords!? */
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  /* decrypt */
  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
  GNUNET_FS_ublock_decrypt_ (edata, edata_size,
                             &anon_pub,
                             sc->requests[i].keyword,
                             data);
  return i;
}

References data, GNUNET_FS_Uri::data, SearchRequestEntry::dpub, GNUNET_break, GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_FS_ublock_decrypt_(), GNUNET_SYSERR, SearchRequestEntry::keyword, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::requests, sc, and GNUNET_FS_SearchContext::uri.

Referenced by process_kblock().

Here is the call graph for this function:

Here is the caller graph for this function:

process_kblock()

static void process_kblock ( struct GNUNET_FS_SearchContext *  sc, const struct UBlock *  ub, size_t  size  )

static

Process a keyword search result.

The actual type of block is a UBlock; we know it is a keyword search result because that's what we were searching for.

Parameters

sc	our search context
ub	the ublock with the keyword search result
size	size of ub

Definition at line 797 of file fs_search.c.

{
  size_t j;
  char pt[size - sizeof(struct UBlock)];
  const char *eos;
  struct GNUNET_FS_MetaData *meta;
  struct GNUNET_FS_Uri *uri;
  char *emsg;
  int i;
 
  if (-1 == (i = decrypt_block_with_keyword (sc,
                                             &ub->verification_key,
                                             &ub[1],
                                             size - sizeof(struct UBlock),
                                             pt)))
    return;
  /* parse; pt[0] is just '\0', so we skip over that */
  eos = memchr (&pt[1], '\0', sizeof(pt) - 1);
  if (NULL == eos)
  {
    GNUNET_break_op (0);
    return;
  }
  if (NULL == (uri = GNUNET_FS_uri_parse (&pt[1], &emsg)))
  {
    if (GNUNET_FS_VERSION > 0x00090400)
    {
      /* we broke this in 0x00090300, so don't bitch
         too loudly just one version up... */
      GNUNET_break_op (0);        /* ublock malformed */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to parse URI `%s': %s\n"),
                  &pt[1],
                  emsg);
    }
    GNUNET_free (emsg);
    return;
  }
  j = eos - pt + 1;
  if (sizeof(pt) == j)
    meta = GNUNET_FS_meta_data_create ();
  else
    meta = GNUNET_FS_meta_data_deserialize (&pt[j], sizeof(pt) - j);
  if (NULL == meta)
  {
    GNUNET_break_op (0);        /* ublock malformed */
    GNUNET_FS_uri_destroy (uri);
    return;
  }
  process_ksk_result (sc,
                      &sc->requests[i],
                      uri,
                      meta);
 
  /* clean up */
  GNUNET_FS_meta_data_destroy (meta);
  GNUNET_FS_uri_destroy (uri);
}

References _, decrypt_block_with_keyword(), GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_meta_data_create(), GNUNET_FS_meta_data_deserialize(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_parse(), GNUNET_FS_VERSION, GNUNET_log, meta, process_ksk_result(), GNUNET_FS_SearchContext::requests, sc, size, uri, and UBlock::verification_key.

Referenced by handle_result().

Here is the call graph for this function:

Here is the caller graph for this function:

process_sblock()

static void process_sblock ( struct GNUNET_FS_SearchContext *  sc, const struct UBlock *  ub, size_t  size  )

static

Process a namespace-search result.

The actual type of block is a UBlock; we know it is a namespace search result because that's what we were searching for.

Parameters

sc	our search context
ub	the ublock with a namespace result
size	size of ub

Definition at line 869 of file fs_search.c.

{
  size_t len = size - sizeof(struct UBlock);
  char pt[len];
  struct GNUNET_FS_Uri *uri;
  struct GNUNET_FS_MetaData *meta;
  const char *id;
  const char *uris;
  size_t off;
  char *emsg;
 
  GNUNET_FS_ublock_decrypt_ (&ub[1], len,
                             &sc->uri->data.sks.ns,
                             sc->uri->data.sks.identifier,
                             pt);
  /* parse */
  if (0 == (off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris)))
  {
    GNUNET_break_op (0);        /* ublock malformed */
    return;
  }
  if (NULL == (meta = GNUNET_FS_meta_data_deserialize (&pt[off], len
                                                       - off)))
  {
    GNUNET_break_op (0);        /* ublock malformed */
    return;
  }
  if (NULL == (uri = GNUNET_FS_uri_parse (uris, &emsg)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to parse URI `%s': %s\n"),
                uris, emsg);
    GNUNET_break_op (0);        /* ublock malformed */
    GNUNET_free (emsg);
    GNUNET_FS_meta_data_destroy (meta);
    return;
  }
  /* process */
  process_sks_result (sc, id, uri, meta);
  /* clean up */
  GNUNET_FS_uri_destroy (uri);
  GNUNET_FS_meta_data_destroy (meta);
}

References _, GNUNET_FS_Uri::data, GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_meta_data_deserialize(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_ublock_decrypt_(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_parse(), GNUNET_log, GNUNET_STRINGS_buffer_tokenize(), id, GNUNET_FS_Uri::identifier, meta, GNUNET_FS_Uri::ns, process_sks_result(), sc, size, GNUNET_FS_Uri::sks, uri, and GNUNET_FS_SearchContext::uri.

Referenced by handle_result().

Here is the call graph for this function:

Here is the caller graph for this function:

try_reconnect()

static void try_reconnect ( struct GNUNET_FS_SearchContext *  sc )

static

Shutdown any existing connection to the FS service and try to establish a fresh one (and then re-transmit our search request).

Parameters

sc	the search to reconnec

Definition at line 1306 of file fs_search.c.

{
  if (NULL != sc->mq)
  {
    GNUNET_MQ_destroy (sc->mq);
    sc->mq = NULL;
  }
  sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (sc->reconnect_backoff);
  sc->task =
    GNUNET_SCHEDULER_add_delayed (sc->reconnect_backoff,
                                  &do_reconnect,
                                  sc);
}

References do_reconnect(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::reconnect_backoff, sc, and GNUNET_FS_SearchContext::task.

Referenced by do_reconnect(), and search_mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

check_result()

static int check_result ( void *  cls, const struct ClientPutMessage *  cm  )

static

We check a result message from the service.

Parameters

cls	closure
cm	result message received

Definition at line 934 of file fs_search.c.

{
  /* payload of any variable size is OK */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_result()

static void handle_result ( void *  cls, const struct ClientPutMessage *  cm  )

static

We process a search result from the service.

Parameters

cls	closure
cm	result message received

Definition at line 949 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
  uint16_t msize = ntohs (cm->header.size) - sizeof(*cm);
  enum GNUNET_BLOCK_Type type = ntohl (cm->type);
 
  if (GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (
                                           cm->expiration)).rel_value_us > 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Result received has already expired.\n");
    return;                     /* result expired */
  }
  switch (type)
  {
  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
    if (GNUNET_FS_URI_SKS == sc->uri->type)
      process_sblock (sc,
                      (const struct UBlock *) &cm[1],
                      msize);
    else
      process_kblock (sc,
                      (const struct UBlock *) &cm[1],
                      msize);
    break;
 
  case GNUNET_BLOCK_TYPE_ANY:
    GNUNET_break (0);
    break;
 
  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
    GNUNET_break (0);
    break;
 
  case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
    GNUNET_break (0);
    break;
 
  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
    GNUNET_break (0);
    break;
 
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Got result with unknown block type `%d', ignoring"),
                type);
    break;
  }
}

References _, ClientPutMessage::expiration, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_BLOCK_TYPE_FS_ONDEMAND, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_FS_URI_SKS, GNUNET_log, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_ntoh(), ClientPutMessage::header, process_kblock(), process_sblock(), GNUNET_TIME_Relative::rel_value_us, sc, GNUNET_MessageHeader::size, type, ClientPutMessage::type, GNUNET_FS_Uri::type, and GNUNET_FS_SearchContext::uri.

Here is the call graph for this function:

schedule_transmit_search_request()

static void schedule_transmit_search_request ( struct GNUNET_FS_SearchContext *  sc )

static

Schedule the transmission of the (next) search request to the service.

Parameters

sc	context for the search

Definition at line 1114 of file fs_search.c.

{
  struct MessageBuilderContext mbc;
  struct GNUNET_MQ_Envelope *env;
  struct SearchMessage *sm;
  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
  unsigned int total_seen_results; /* total number of result hashes to send */
  uint32_t options;
  unsigned int left;
  unsigned int todo;
  unsigned int fit;
  unsigned int search_request_map_offset;
  unsigned int keyword_offset;
  int first_call;
 
  memset (&mbc, 0, sizeof(mbc));
  mbc.sc = sc;
  if (GNUNET_FS_uri_test_ksk (sc->uri))
  {
    /* This will calculate the result set size ONLY for
       "keyword_offset == 0", so we will have to recalculate
       it for the other keywords later! */
    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                           &find_result_set,
                                           &mbc);
    total_seen_results = mbc.put_cnt;
  }
  else
  {
    total_seen_results
      = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
  }
  search_request_map_offset = 0;
  keyword_offset = 0;
  first_call = GNUNET_YES;
  while ((0 != (left =
                  (total_seen_results - search_request_map_offset))) ||
         (GNUNET_YES == first_call))
  {
    first_call = GNUNET_NO;
    options = SEARCH_MESSAGE_OPTION_NONE;
    if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
      options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
 
    fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct
                                                               GNUNET_HashCode);
    todo = GNUNET_MIN (fit,
                       left);
    env = GNUNET_MQ_msg_extra (sm,
                               sizeof(struct GNUNET_HashCode) * todo,
                               GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
    mbc.skip_cnt = search_request_map_offset;
    mbc.xoff = (struct GNUNET_HashCode *) &sm[1];
    sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK);
    sm->anonymity_level = htonl (sc->anonymity);
    memset (&sm->target,
            0,
            sizeof(struct GNUNET_PeerIdentity));
 
    if (GNUNET_FS_uri_test_ksk (sc->uri))
    {
      mbc.keyword_offset = keyword_offset;
      /* calculate how many results we can send in this message */
      mbc.put_cnt = todo;
      /* now build message */
      sm->query = sc->requests[keyword_offset].uquery;
      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                             &build_result_set,
                                             &mbc);
      search_request_map_offset += todo;
      GNUNET_assert (0 == mbc.put_cnt);
      GNUNET_assert (total_seen_results >= search_request_map_offset);
      if (total_seen_results != search_request_map_offset)
      {
        /* more requesting to be done... */
        sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
      }
      else
      {
        sm->options = htonl (options);
        keyword_offset++;
        if (sc->uri->data.ksk.keywordCount != keyword_offset)
        {
          /* more keywords => more requesting to be done... */
          first_call = GNUNET_YES;
          search_request_map_offset = 0;
          mbc.put_cnt = 0;
          mbc.keyword_offset = keyword_offset;
          GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                                 &find_result_set,
                                                 &mbc);
          total_seen_results = mbc.put_cnt;
        }
      }
    }
    else
    {
      GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
 
      GNUNET_CRYPTO_ecdsa_public_key_derive (&sc->uri->data.sks.ns,
                                             sc->uri->data.sks.identifier,
                                             "fs-ublock",
                                             &dpub);
      GNUNET_CRYPTO_hash (&dpub,
                          sizeof(dpub),
                          &sm->query);
      mbc.put_cnt = todo;
      mbc.keyword_offset = 0;
      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                             &build_result_set,
                                             &mbc);
      GNUNET_assert (total_seen_results >= search_request_map_offset);
      if (total_seen_results != search_request_map_offset)
      {
        /* more requesting to be done... */
        sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
      }
      else
      {
        sm->options = htonl (options);
      }
    }
    GNUNET_MQ_send (sc->mq,
                    env);
  }
}

References GNUNET_FS_SearchContext::anonymity, SearchMessage::anonymity_level, build_result_set(), GNUNET_FS_Uri::data, env, find_result_set(), GNUNET_assert, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_hash(), GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY, GNUNET_FS_uri_test_ksk(), GNUNET_FS_uri_test_sks(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, GNUNET_MIN, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, GNUNET_FS_Uri::identifier, MessageBuilderContext::keyword_offset, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_Uri::ns, options, SearchMessage::options, GNUNET_FS_SearchContext::options, MessageBuilderContext::put_cnt, SearchMessage::query, GNUNET_FS_SearchContext::requests, sc, MessageBuilderContext::sc, SEARCH_MESSAGE_OPTION_CONTINUED, SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY, SEARCH_MESSAGE_OPTION_NONE, MessageBuilderContext::skip_cnt, GNUNET_FS_Uri::sks, SearchMessage::target, SearchMessage::type, SearchRequestEntry::uquery, GNUNET_FS_SearchContext::uri, and MessageBuilderContext::xoff.

Referenced by do_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

build_result_set()

static int build_result_set ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterating over the known results, pick those matching the given result range and store their keys at 'xoff'.

Parameters

cls	the struct MessageBuilderContext
key	key for a result
value	the search result

Returns

GNUNET_OK to continue iterating

Definition at line 1053 of file fs_search.c.

{
  struct MessageBuilderContext *mbc = cls;
  struct GNUNET_FS_SearchResult *sr = value;
 
  if ((NULL != sr->keyword_bitmap) &&
      (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1
                                                            << (mbc->
                                                                keyword_offset
                                                                % 8)))))
    return GNUNET_OK; /* have no match for this keyword yet */
  if (mbc->skip_cnt > 0)
  {
    mbc->skip_cnt--;
    return GNUNET_OK;
  }
  if (0 == mbc->put_cnt)
    return GNUNET_SYSERR;
  mbc->xoff[--mbc->put_cnt] = *key;
 
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SYSERR, key, GNUNET_FS_SearchResult::keyword_bitmap, MessageBuilderContext::keyword_offset, MessageBuilderContext::put_cnt, MessageBuilderContext::skip_cnt, value, and MessageBuilderContext::xoff.

Referenced by schedule_transmit_search_request().

Here is the caller graph for this function:

find_result_set()

static int find_result_set ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterating over the known results, count those matching the given result range and increment put count for each.

Parameters

cls	the struct MessageBuilderContext
key	key for a result
value	the search result

Returns

GNUNET_OK to continue iterating

Definition at line 1089 of file fs_search.c.

{
  struct MessageBuilderContext *mbc = cls;
  struct GNUNET_FS_SearchResult *sr = value;
 
  if ((NULL != sr->keyword_bitmap) &&
      (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1
                                                            << (mbc->
                                                                keyword_offset
                                                                % 8)))))
    return GNUNET_OK; /* have no match for this keyword yet */
  mbc->put_cnt++;
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_FS_SearchResult::keyword_bitmap, MessageBuilderContext::keyword_offset, MessageBuilderContext::put_cnt, and value.

Referenced by schedule_transmit_search_request().

Here is the caller graph for this function:

search_mq_error_handler()

static void search_mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure with the struct GNUNET_FS_SearchContext *
error	error code

Definition at line 1251 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
 
  if (NULL != sc->mq)
  {
    GNUNET_MQ_destroy (sc->mq);
    sc->mq = NULL;
  }
  try_reconnect (sc);
}

References GNUNET_MQ_destroy(), GNUNET_FS_SearchContext::mq, sc, and try_reconnect().

Referenced by do_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_reconnect()

static void do_reconnect ( void *  cls )

static

Reconnect to the FS service and transmit our queries NOW.

Parameters

cls	our search context

Definition at line 1272 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (result,
                           GNUNET_MESSAGE_TYPE_FS_PUT,
                           struct ClientPutMessage,
                           sc),
    GNUNET_MQ_handler_end ()
  };
 
  sc->task = NULL;
  sc->mq = GNUNET_CLIENT_connect (sc->h->cfg,
                                  "fs",
                                  handlers,
                                  &search_mq_error_handler,
                                  sc);
  if (NULL == sc->mq)
  {
    try_reconnect (sc);
    return;
  }
  schedule_transmit_search_request (sc);
}

References GNUNET_FS_Handle::cfg, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_FS_PUT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_FS_SearchContext::h, handlers, GNUNET_FS_SearchContext::mq, result, sc, schedule_transmit_search_request(), search_mq_error_handler(), GNUNET_FS_SearchContext::task, and try_reconnect().

Referenced by GNUNET_FS_search_continue(), GNUNET_FS_search_start_searching_(), and try_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

update_sre_result_maps()

static int update_sre_result_maps ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Update the 'results' map for the individual keywords with the results from the 'global' result set.

Parameters

cls	closure, the struct GNUNET_FS_SearchContext *
key	current key code
value	value in the hash map, the struct GNUNET_FS_SearchResult *

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 1381 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
  struct GNUNET_FS_SearchResult *sr = value;
 
  for (unsigned int i = 0; i < sc->uri->data.ksk.keywordCount; i++)
  {
    if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8))))
      GNUNET_break (GNUNET_OK ==
                    GNUNET_CONTAINER_multihashmap_put (sc->requests[i].results,
                                                       &sr->key,
                                                       sr,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  return GNUNET_YES;
}

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_OK, GNUNET_YES, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::keyword_bitmap, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchContext::uri, and value.

Referenced by GNUNET_FS_search_start_searching_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_start_searching_()

int GNUNET_FS_search_start_searching_

(

struct GNUNET_FS_SearchContext *

sc

)

Build the request and actually initiate the search using the GNUnet FS service.

Parameters

sc	search context

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1402 of file fs_search.c.

{
  unsigned int i;
  const char *keyword;
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
  struct SearchRequestEntry *sre;
 
  GNUNET_assert (NULL == sc->mq);
  if (GNUNET_FS_uri_test_ksk (sc->uri))
  {
    GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
    anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
    GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
    sc->requests
      = GNUNET_new_array (sc->uri->data.ksk.keywordCount,
                          struct SearchRequestEntry);
 
    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
    {
      keyword = &sc->uri->data.ksk.keywords[i][1];
      sre = &sc->requests[i];
      sre->keyword = GNUNET_strdup (keyword);
      GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
                                             keyword,
                                             "fs-ublock",
                                             &sre->dpub);
      GNUNET_CRYPTO_hash (&sre->dpub,
                          sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
                          &sre->uquery);
      sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
      if (sre->mandatory)
        sc->mandatory_count++;
      sre->results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
    }
    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                           &update_sre_result_maps,
                                           sc);
  }
  GNUNET_assert (NULL == sc->task);
  do_reconnect (sc);
  if (NULL == sc->mq)
  {
    GNUNET_SCHEDULER_cancel (sc->task);
    sc->task = NULL;
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_FS_Uri::data, do_reconnect(), SearchRequestEntry::dpub, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_hash(), GNUNET_FS_uri_test_ksk(), GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_strdup, GNUNET_SYSERR, SearchRequestEntry::keyword, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchContext::task, update_sre_result_maps(), SearchRequestEntry::uquery, and GNUNET_FS_SearchContext::uri.

Referenced by deserialize_search(), and search_start().

Here is the call graph for this function:

Here is the caller graph for this function:

search_result_freeze_probes()

static int search_result_freeze_probes ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Freeze probes for the given search result.

Parameters

cls	the global FS handle
key	the key for the search result (unused)
value	the search result to free

Returns

GNUNET_OK

Definition at line 1462 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr = value;
 
  if (NULL != sr->probe_ctx)
  {
    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
    sr->probe_ctx = NULL;
    GNUNET_FS_stop_probe_ping_task_ (sr);
  }
  if (NULL != sr->probe_cancel_task)
  {
    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
    sr->probe_cancel_task = NULL;
  }
  if (NULL != sr->update_search)
    GNUNET_FS_search_pause (sr->update_search);
  return GNUNET_OK;
}

References GNUNET_FS_download_stop(), GNUNET_FS_search_pause(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_FS_SearchResult::probe_cancel_task, GNUNET_FS_SearchResult::probe_ctx, GNUNET_FS_SearchResult::update_search, and value.

Referenced by GNUNET_FS_search_pause().

Here is the call graph for this function:

Here is the caller graph for this function:

search_result_resume_probes()

static int search_result_resume_probes ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Resume probes for the given search result.

Parameters

cls	the global FS handle
key	the key for the search result (unused)
value	the search result to free

Returns

GNUNET_OK

Definition at line 1494 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr = value;
 
  GNUNET_FS_search_start_probe_ (sr);
  if (NULL != sr->update_search)
    GNUNET_FS_search_continue (sr->update_search);
  return GNUNET_OK;
}

References GNUNET_FS_search_continue(), GNUNET_FS_search_start_probe_(), GNUNET_OK, GNUNET_FS_SearchResult::update_search, and value.

Referenced by GNUNET_FS_search_continue().

Here is the call graph for this function:

Here is the caller graph for this function:

search_result_suspend()

static int search_result_suspend ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Signal suspend and free the given search result.

Parameters

cls	the global FS handle
key	the key for the search result (unused)
value	the search result to free

Returns

GNUNET_OK

Definition at line 1516 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
  struct GNUNET_FS_SearchResult *sr = value;
  struct GNUNET_FS_ProgressInfo pi;
 
  if (NULL != sr->download)
  {
    GNUNET_FS_download_signal_suspend_ (sr->download);
    sr->download = NULL;
  }
  if (NULL != sr->update_search)
  {
    GNUNET_FS_search_signal_suspend_ (sr->update_search);
    sr->update_search = NULL;
  }
  GNUNET_FS_search_stop_probe_ (sr);
  if (0 == sr->mandatory_missing)
  {
    /* client is aware of search result, notify about suspension event */
    pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND;
    pi.value.search.specifics.result_suspend.cctx = sr->client_info;
    pi.value.search.specifics.result_suspend.meta = sr->meta;
    pi.value.search.specifics.result_suspend.uri = sr->uri;
    sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
  }
  GNUNET_break (NULL == sr->client_info);
  GNUNET_free (sr->serialization);
  GNUNET_FS_uri_destroy (sr->uri);
  GNUNET_FS_meta_data_destroy (sr->meta);
  GNUNET_free (sr->keyword_bitmap);
  GNUNET_free (sr);
  return GNUNET_OK;
}

References GNUNET_FS_SearchResult::client_info, GNUNET_FS_SearchResult::download, GNUNET_break, GNUNET_free, GNUNET_FS_download_signal_suspend_(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_search_make_status_(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_stop_probe_(), GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND, GNUNET_FS_uri_destroy(), GNUNET_OK, GNUNET_FS_SearchContext::h, GNUNET_FS_SearchResult::keyword_bitmap, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchResult::meta, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchResult::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchResult::uri, value, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_signal_suspend_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_signal_suspend_()

void GNUNET_FS_search_signal_suspend_

(

void *

cls

)

Create SUSPEND event for the given search operation and then clean up our state (without stop signal).

Parameters

cls	the 'struct GNUNET_FS_SearchContext' to signal for

Definition at line 1555 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
  struct GNUNET_FS_ProgressInfo pi;
  unsigned int i;
 
  GNUNET_FS_end_top (sc->h, sc->top);
  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                         &search_result_suspend, sc);
  pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND;
  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
  GNUNET_break (NULL == sc->client_info);
  if (sc->task != NULL)
  {
    GNUNET_SCHEDULER_cancel (sc->task);
    sc->task = NULL;
  }
  if (NULL != sc->mq)
  {
    GNUNET_MQ_destroy (sc->mq);
    sc->mq = NULL;
  }
  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
  if (NULL != sc->requests)
  {
    GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
    {
      GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
      GNUNET_free (sc->requests[i].keyword);
    }
  }
  GNUNET_free (sc->requests);
  GNUNET_free (sc->emsg);
  GNUNET_FS_uri_destroy (sc->uri);
  GNUNET_free (sc->serialization);
  GNUNET_free (sc);
}

References GNUNET_FS_SearchContext::client_info, GNUNET_FS_Uri::data, GNUNET_FS_SearchContext::emsg, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_FS_end_top(), GNUNET_FS_search_make_status_(), GNUNET_FS_STATUS_SEARCH_SUSPEND, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_test_ksk(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_FS_SearchContext::h, SearchRequestEntry::keyword, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, search_result_suspend(), GNUNET_FS_SearchContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchContext::task, GNUNET_FS_SearchContext::top, and GNUNET_FS_SearchContext::uri.

Referenced by deserialize_search_file(), GNUNET_FS_search_start(), and search_result_suspend().

Here is the call graph for this function:

Here is the caller graph for this function:

search_result_stop()

static int search_result_stop ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Signal stop for the given search result.

Parameters

cls	the global FS handle
key	the key for the search result (unused)
value	the search result to free

Returns

GNUNET_OK

Definition at line 1682 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *sc = cls;
  struct GNUNET_FS_SearchResult *sr = value;
  struct GNUNET_FS_ProgressInfo pi;
 
  GNUNET_FS_search_stop_probe_ (sr);
  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,
                                   GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
                                   sr->download->serialization);
      GNUNET_free (sr->download->serialization);
      sr->download->serialization = NULL;
    }
    pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT;
    GNUNET_FS_download_make_status_ (&pi,
                                     sr->download);
    GNUNET_FS_download_sync_ (sr->download);
    sr->download = NULL;
  }
  if (0 != sr->mandatory_missing)
  {
    /* client is unaware of search result as
       it does not match required keywords */
    GNUNET_break (NULL == sr->client_info);
    return GNUNET_OK;
  }
  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED;
  pi.value.search.specifics.result_stopped.cctx = sr->client_info;
  pi.value.search.specifics.result_stopped.meta = sr->meta;
  pi.value.search.specifics.result_stopped.uri = sr->uri;
  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sc);
  return GNUNET_OK;
}

References GNUNET_FS_SearchResult::client_info, GNUNET_FS_SearchResult::download, GNUNET_break, GNUNET_free, GNUNET_FS_download_make_status_(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_sync_(), GNUNET_FS_make_top(), GNUNET_FS_remove_sync_file_(), GNUNET_FS_search_make_status_(), GNUNET_FS_search_stop_probe_(), GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT, GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED, GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, GNUNET_OK, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchContext::h, GNUNET_FS_DownloadContext::h, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchResult::meta, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_DownloadContext::top, GNUNET_FS_SearchResult::uri, value, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

search_result_free()

static int search_result_free ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Free the given search result.

Parameters

cls	the global FS handle
key	the key for the search result (unused)
value	the search result to free

Returns

GNUNET_OK

Definition at line 1737 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr = value;
 
  if (NULL != sr->update_search)
  {
    GNUNET_FS_search_stop (sr->update_search);
    GNUNET_assert (NULL == sr->update_search);
  }
  GNUNET_break (NULL == sr->probe_ctx);
  GNUNET_break (NULL == sr->probe_cancel_task);
  GNUNET_break (NULL == sr->client_info);
  GNUNET_free (sr->serialization);
  GNUNET_FS_uri_destroy (sr->uri);
  GNUNET_FS_meta_data_destroy (sr->meta);
  GNUNET_free (sr->keyword_bitmap);
  GNUNET_free (sr);
  return GNUNET_OK;
}

References GNUNET_FS_SearchResult::client_info, GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_FS_meta_data_destroy(), GNUNET_FS_search_stop(), GNUNET_FS_uri_destroy(), GNUNET_OK, GNUNET_FS_SearchResult::keyword_bitmap, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::probe_cancel_task, GNUNET_FS_SearchResult::probe_ctx, GNUNET_FS_SearchResult::serialization, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchResult::uri, and value.

Referenced by GNUNET_FS_search_stop().

Here is the call graph for this function:

Here is the caller graph for this function: