GNUnet  0.20.0
Data Structures | Macros | Functions
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. More...
 

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. More...
 
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. More...
 
static void notify_client_chk_result (struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
 We've found a new CHK result. More...
 
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. More...
 
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. More...
 
static void signal_probe_result (struct GNUNET_FS_SearchResult *sr)
 Signal result of last probe to client and then schedule next probe. More...
 
static void probe_failure_handler (void *cls)
 Handle the case where we have failed to receive a response for our probe. More...
 
static void probe_success_handler (void *cls)
 Handle the case where we have gotten a response for our probe. More...
 
void * GNUNET_FS_search_probe_progress_ (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 Notification of FS that a search probe has made progress. More...
 
static void probe_ping_task_cb (void *cls)
 Task run periodically to remind clients that a probe is active. More...
 
static void start_probe_ping_task (struct GNUNET_FS_SearchResult *sr)
 Start the ping task for this search result. More...
 
void GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr)
 Stop the ping task for this search result. More...
 
void GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 Start download probes for the given search result. More...
 
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. More...
 
static void GNUNET_FS_search_stop_probe_ (struct GNUNET_FS_SearchResult *sr)
 Stop probing activity associated with a search result. More...
 
void * GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
 Stop probe activity. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
static void process_kblock (struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
 Process a keyword search result. More...
 
static void process_sblock (struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
 Process a namespace-search result. More...
 
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). More...
 
static int check_result (void *cls, const struct ClientPutMessage *cm)
 We check a result message from the service. More...
 
static void handle_result (void *cls, const struct ClientPutMessage *cm)
 We process a search result from the service. More...
 
static void schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
 Schedule the transmission of the (next) search request to the service. More...
 
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'. More...
 
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. More...
 
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. More...
 
static void do_reconnect (void *cls)
 Reconnect to the FS service and transmit our queries NOW. More...
 
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. More...
 
int GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
 Build the request and actually initiate the search using the GNUnet FS service. More...
 
static int search_result_freeze_probes (void *cls, const struct GNUNET_HashCode *key, void *value)
 Freeze probes for the given search result. More...
 
static int search_result_resume_probes (void *cls, const struct GNUNET_HashCode *key, void *value)
 Resume probes for the given search result. More...
 
static int search_result_suspend (void *cls, const struct GNUNET_HashCode *key, void *value)
 Signal suspend and free the given search result. More...
 
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). More...
 
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. More...
 
void GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
 Pause search. More...
 
void GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
 Continue paused search. More...
 
static int search_result_stop (void *cls, const struct GNUNET_HashCode *key, void *value)
 Signal stop for the given search result. More...
 
static int search_result_free (void *cls, const struct GNUNET_HashCode *key, void *value)
 Free the given search result. More...
 
void GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
 Stop search for content. More...
 

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
pistructure to fill in
hfile-sharing handle
scoverall search context
Returns
value returned by the callback

Definition at line 49 of file fs_search.c.

52 {
53  void *ret;
54 
55  pi->value.search.sc = sc;
56  pi->value.search.cctx = (NULL != sc) ? sc->client_info : NULL;
57  pi->value.search.pctx =
58  ((NULL == sc) || (NULL == sc->psearch_result))
59  ? NULL
60  : sc->psearch_result->client_info;
61  pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
62  pi->value.search.duration = (NULL != sc)
63  ? GNUNET_TIME_absolute_get_duration (
64  sc->start_time)
65  : GNUNET_TIME_UNIT_ZERO;
66  pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
67  pi->fsh = h;
68  ret = h->upcb (h->upcb_cls, pi);
69  return ret;
70 }
ret
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
h
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
GNUNET_TIME_absolute_get_duration
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
GNUNET_TIME_UNIT_ZERO
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
Definition: gnunet_time_lib.h:125
GNUNET_FS_SearchContext::client_info
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1541
GNUNET_FS_SearchContext::psearch_result
struct GNUNET_FS_SearchResult * psearch_result
For update-searches, link to the search result that triggered the update search; otherwise NULL.
Definition: fs_api.h:1531
GNUNET_FS_SearchContext::anonymity
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1525
GNUNET_FS_SearchContext::start_time
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1570
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:534

References GNUNET_FS_SearchContext::anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_FS_SearchContext::client_info, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_ZERO, h, pi, GNUNET_FS_SearchContext::psearch_result, ret, sc, GNUNET_FS_SearchContext::start_time, and GNUNET_FS_SearchContext::uri.

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
clspoints to the URI we check against
keynot used
valuea 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.

87 {
88  const struct GNUNET_FS_Uri *uri = cls;
89  struct GNUNET_FS_SearchResult *sr = value;
90 
91  if (GNUNET_FS_uri_test_equal (uri, sr->uri))
92  return GNUNET_SYSERR;
93  return GNUNET_OK;
94 }
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:265
uri
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Definition: gnunet-publish.c:84
GNUNET_FS_uri_test_equal
int GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
Test if two URIs are equal.
Definition: fs_uri.c:1201
GNUNET_OK
@ GNUNET_OK
Definition: gnunet_common.h:109
GNUNET_SYSERR
@ GNUNET_SYSERR
Definition: gnunet_common.h:107
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:499
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:524
GNUNET_FS_Uri
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167

References GNUNET_FS_uri_test_equal(), GNUNET_OK, GNUNET_SYSERR, GNUNET_FS_SearchResult::uri, 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
scthe search context
srthe specific result

Definition at line 105 of file fs_search.c.

107 {
108  struct GNUNET_FS_ProgressInfo pi;
109 
110  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT;
111  pi.value.search.specifics.result.meta = sr->meta;
112  pi.value.search.specifics.result.uri = sr->uri;
113  pi.value.search.specifics.result.result = sr;
114  pi.value.search.specifics.result.applicability_rank = sr->optional_support;
115  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
116 }
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.
Definition: fs_search.c:49
GNUNET_FS_STATUS_SEARCH_RESULT
@ GNUNET_FS_STATUS_SEARCH_RESULT
This search has yielded a result.
Definition: gnunet_fs_service.h:749
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:886
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1515
GNUNET_FS_SearchResult::optional_support
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:602
GNUNET_FS_SearchResult::meta
struct GNUNET_FS_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:529

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, pi, sc, and GNUNET_FS_SearchResult::uri.

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
scthe search context
srthe specific result

Definition at line 127 of file fs_search.c.

129 {
130  struct GNUNET_FS_ProgressInfo pi;
131 
132  pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
133  pi.value.search.specifics.update.cctx = sr->client_info;
134  pi.value.search.specifics.update.meta = sr->meta;
135  pi.value.search.specifics.update.uri = sr->uri;
136  pi.value.search.specifics.update.availability_rank =
137  2 * sr->availability_success - sr->availability_trials;
138  pi.value.search.specifics.update.availability_certainty =
139  sr->availability_trials;
140  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
141  pi.value.search.specifics.update.current_probe_time
142  = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
143  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
144 }
GNUNET_FS_STATUS_SEARCH_UPDATE
@ GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
Definition: gnunet_fs_service.h:760
GNUNET_FS_SearchResult::availability_trials
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:613
GNUNET_FS_SearchResult::availability_success
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:607
GNUNET_FS_SearchResult::probe_active_time
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:579

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, pi, GNUNET_FS_SearchResult::probe_active_time, sc, and GNUNET_FS_SearchResult::uri.

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
clsa struct GetResultContext
keynot used
valuea struct GNUNET_FS_SearchResult who's URI we should compare with
Returns
GNUNET_OK

Definition at line 176 of file fs_search.c.

179 {
180  struct GetResultContext *grc = cls;
181  struct GNUNET_FS_SearchResult *sr = value;
182 
183  if (GNUNET_FS_uri_test_equal (grc->uri, sr->uri))
184  grc->sr = sr;
185  return GNUNET_OK;
186 }
GetResultContext
Context for "get_result_present".
Definition: fs_search.c:151
GetResultContext::uri
const struct GNUNET_FS_Uri * uri
The URI we're looking for.
Definition: fs_search.c:155
GetResultContext::sr
struct GNUNET_FS_SearchResult * sr
Where to store a pointer to the search result struct if we found a match.
Definition: fs_search.c:161

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
srsearch result to signal for

Definition at line 196 of file fs_search.c.

197 {
198  struct GNUNET_FS_ProgressInfo pi;
199 
200  pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
201  pi.value.search.specifics.update.cctx = sr->client_info;
202  pi.value.search.specifics.update.meta = sr->meta;
203  pi.value.search.specifics.update.uri = sr->uri;
204  pi.value.search.specifics.update.availability_rank
205  = 2 * sr->availability_success - sr->availability_trials;
206  pi.value.search.specifics.update.availability_certainty
207  = sr->availability_trials;
208  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
209  pi.value.search.specifics.update.current_probe_time
210  = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
211  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc);
212  GNUNET_FS_search_start_probe_ (sr);
213 }
GNUNET_FS_search_start_probe_
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:431
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:503
GNUNET_FS_SearchResult::sc
struct GNUNET_FS_SearchContext * sc
Search context this result belongs to; can be NULL for probes that come from a directory result.
Definition: fs_api.h:519

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, pi, GNUNET_FS_SearchResult::probe_active_time, GNUNET_FS_SearchResult::sc, and GNUNET_FS_SearchResult::uri.

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
clsour struct GNUNET_FS_SearchResult *

Definition at line 222 of file fs_search.c.

223 {
224  struct GNUNET_FS_SearchResult *sr = cls;
225 
226  sr->probe_cancel_task = NULL;
227  sr->availability_trials++;
228  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
229  sr->probe_ctx = NULL;
230  GNUNET_FS_stop_probe_ping_task_ (sr);
231  GNUNET_FS_search_result_sync_ (sr);
232  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
233  "Probe #%u for search result %p failed\n",
234  sr->availability_trials,
235  sr);
236  signal_probe_result (sr);
237 }
GNUNET_FS_search_result_sync_
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2149
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.
Definition: fs_search.c:410
signal_probe_result
static void signal_probe_result(struct GNUNET_FS_SearchResult *sr)
Signal result of last probe to client and then schedule next probe.
Definition: fs_search.c:196
GNUNET_FS_download_stop
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2254
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:568
GNUNET_YES
@ GNUNET_YES
Definition: gnunet_common.h:111
GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_DEBUG
Definition: gnunet_common.h:444
GNUNET_FS_SearchResult::probe_ctx
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results' availability (NULL if we are not currently probin...
Definition: fs_api.h:540
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:574

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
clsour struct GNUNET_FS_SearchResult *

Definition at line 246 of file fs_search.c.

247 {
248  struct GNUNET_FS_SearchResult *sr = cls;
249 
250  sr->probe_cancel_task = NULL;
251  sr->availability_trials++;
252  sr->availability_success++;
253  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
254  sr->probe_ctx = NULL;
255  GNUNET_FS_stop_probe_ping_task_ (sr);
256  GNUNET_FS_search_result_sync_ (sr);
257  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
258  "Probe #%u for search result %p succeeded\n",
259  sr->availability_trials,
260  sr);
261  signal_probe_result (sr);
262 }

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
clsclosure, always NULL (!), actual closure is in the client-context of the info struct
infodetails 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.

283 {
284  struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
285  struct GNUNET_TIME_Relative dur;
286 
287  switch (info->status)
288  {
289  case GNUNET_FS_STATUS_DOWNLOAD_START:
290  /* ignore */
291  break;
292  case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
293  /* probes should never be resumed */
294  GNUNET_assert (0);
295  break;
296  case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
297  /* probes should never be suspended */
298  GNUNET_break (0);
299  break;
300  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
301  /* ignore */
302  break;
303  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
304  if (NULL != sr->probe_cancel_task)
305  {
306  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
307  sr->probe_cancel_task = NULL;
308  }
309  sr->probe_cancel_task =
310  GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
311  &probe_failure_handler, sr);
312  break;
313  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
314  if (NULL != sr->probe_cancel_task)
315  {
316  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
317  sr->probe_cancel_task = NULL;
318  }
319  sr->probe_cancel_task =
320  GNUNET_SCHEDULER_add_now (&probe_success_handler, sr);
321  break;
322  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
323  if (NULL != sr->probe_cancel_task)
324  {
325  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
326  sr->probe_cancel_task = NULL;
327  }
328  sr = NULL;
329  break;
330  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
331  if (NULL == sr->probe_cancel_task)
332  {
333  sr->probe_active_time = GNUNET_TIME_absolute_get ();
334  sr->probe_cancel_task =
335  GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
336  &probe_failure_handler, sr);
337  }
338  break;
339  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
340  if (NULL != sr->probe_cancel_task)
341  {
342  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
343  sr->probe_cancel_task = NULL;
344  }
345  dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
346  sr->remaining_probe_time =
347  GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
348  if (0 == sr->remaining_probe_time.rel_value_us)
349  sr->probe_cancel_task =
350  GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr);
351  GNUNET_FS_search_result_sync_ (sr);
352  break;
353 
354  default:
355  GNUNET_break (0);
356  return NULL;
357  }
358  return sr;
359 }
probe_success_handler
static void probe_success_handler(void *cls)
Handle the case where we have gotten a response for our probe.
Definition: fs_search.c:246
probe_failure_handler
static void probe_failure_handler(void *cls)
Handle the case where we have failed to receive a response for our probe.
Definition: fs_search.c:222
info
#define info
GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
@ GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
Notification that this download is no longer actively being pursued (back in the queue).
Definition: gnunet_fs_service.h:709
GNUNET_FS_STATUS_DOWNLOAD_ERROR
@ GNUNET_FS_STATUS_DOWNLOAD_ERROR
Notification that this download encountered an error.
Definition: gnunet_fs_service.h:684
GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
@ GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
Notification that this download completed.
Definition: gnunet_fs_service.h:691
GNUNET_FS_STATUS_DOWNLOAD_RESUME
@ GNUNET_FS_STATUS_DOWNLOAD_RESUME
Notification that this download is being resumed.
Definition: gnunet_fs_service.h:669
GNUNET_FS_STATUS_DOWNLOAD_SUSPEND
@ GNUNET_FS_STATUS_DOWNLOAD_SUSPEND
Notification that this download was suspended.
Definition: gnunet_fs_service.h:674
GNUNET_FS_STATUS_DOWNLOAD_START
@ GNUNET_FS_STATUS_DOWNLOAD_START
Notification that we have started this download.
Definition: gnunet_fs_service.h:664
GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
@ GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
Notification about progress with this download.
Definition: gnunet_fs_service.h:679
GNUNET_FS_STATUS_DOWNLOAD_ACTIVE
@ GNUNET_FS_STATUS_DOWNLOAD_ACTIVE
Notification that this download is now actively being pursued (as opposed to waiting in the queue).
Definition: gnunet_fs_service.h:703
GNUNET_FS_STATUS_DOWNLOAD_STOPPED
@ GNUNET_FS_STATUS_DOWNLOAD_STOPPED
Notification that this download was stopped (final event with respect to this action).
Definition: gnunet_fs_service.h:697
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:943
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
Definition: gnunet_common.h:1024
GNUNET_SCHEDULER_add_now
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
GNUNET_SCHEDULER_add_delayed
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
GNUNET_TIME_relative_subtract
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:603
GNUNET_TIME_absolute_get
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
GNUNET_FS_SearchResult::remaining_probe_time
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:584
GNUNET_TIME_Relative
Time for relative time used by GNUnet, in microseconds.
Definition: gnunet_time_lib.h:77
GNUNET_TIME_Relative::rel_value_us
uint64_t rel_value_us
The actual value.
Definition: gnunet_time_lib.h:81

References 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
clsthe struct GNUNET_FS_SearchResult that we are probing for

Definition at line 368 of file fs_search.c.

369 {
370  struct GNUNET_FS_Handle *h = cls;
371 
372  for (struct GNUNET_FS_SearchResult *sr = h->probes_head;
373  NULL != sr;
374  sr = sr->next)
375  if (NULL != sr->probe_ctx->mq)
376  signal_probe_result (sr);
377  h->probe_ping_task
378  = GNUNET_SCHEDULER_add_delayed (GNUNET_FS_PROBE_UPDATE_FREQUENCY,
379  &probe_ping_task_cb,
380  h);
381 }
probe_ping_task_cb
static void probe_ping_task_cb(void *cls)
Task run periodically to remind clients that a probe is active.
Definition: fs_search.c:368
GNUNET_FS_PROBE_UPDATE_FREQUENCY
#define GNUNET_FS_PROBE_UPDATE_FREQUENCY
How often do we signal applications that a probe for a particular search result is running?...
Definition: gnunet_fs_service.h:188
GNUNET_FS_Handle
Master context for most FS operations.
Definition: fs_api.h:1070

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

Referenced by 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
srresult to start pinging for.

Definition at line 390 of file fs_search.c.

391 {
392  struct GNUNET_FS_Handle *h = sr->h;
393 
394  GNUNET_CONTAINER_DLL_insert (h->probes_head,
395  h->probes_tail,
396  sr);
397  if (NULL == h->probe_ping_task)
398  h->probe_ping_task
399  = GNUNET_SCHEDULER_add_now (&probe_ping_task_cb,
400  h);
401 }
GNUNET_CONTAINER_DLL_insert
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Definition: gnunet_container_lib.h:1797

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
srresult to start pinging for.

Definition at line 410 of file fs_search.c.

411 {
412  struct GNUNET_FS_Handle *h = sr->h;
413 
414  GNUNET_CONTAINER_DLL_remove (h->probes_head,
415  h->probes_tail,
416  sr);
417  if (NULL == h->probes_head)
418  {
419  GNUNET_SCHEDULER_cancel (h->probe_ping_task);
420  h->probe_ping_task = NULL;
421  }
422 }
GNUNET_CONTAINER_DLL_remove
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Definition: gnunet_container_lib.h:1916

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
srthe search result

Definition at line 431 of file fs_search.c.

432 {
433  uint64_t off;
434  uint64_t len;
435 
436  if (NULL != sr->probe_ctx)
437  return;
438  if (NULL != sr->download)
439  return;
440  if (0 == (sr->h->flags & GNUNET_FS_FLAGS_DO_PROBES))
441  return;
442  if (sr->availability_trials > AVAILABILITY_TRIALS_MAX)
443  return;
444  if ( (GNUNET_FS_URI_CHK != sr->uri->type) &&
445  (GNUNET_FS_URI_LOC != sr->uri->type) )
446  return;
447  len = GNUNET_FS_uri_chk_get_file_size (sr->uri);
448  if (0 == len)
449  return;
450  if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
451  return;
452  off = len / DBLOCK_SIZE;
453  if (off > 0)
454  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, off);
455  off *= DBLOCK_SIZE;
456  if (len - off < DBLOCK_SIZE)
457  len = len - off;
458  else
459  len = DBLOCK_SIZE;
460  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
461  "Starting probe #%u (at offset %llu) for search result %p\n",
462  sr->availability_trials + 1,
463  (unsigned long long) off,
464  sr);
465  sr->remaining_probe_time =
466  GNUNET_TIME_relative_saturating_multiply (sr->h->avg_block_latency,
467  2 * (1
468  + sr->availability_trials));
469  sr->probe_ctx =
470  GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off,
471  len, sr->anonymity,
472  GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
473  | GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
474  start_probe_ping_task (sr);
475 }
DBLOCK_SIZE
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:41
GNUNET_FS_URI_LOC
@ GNUNET_FS_URI_LOC
Location (chk with identity of hosting peer).
Definition: fs_api.h:159
GNUNET_FS_URI_CHK
@ GNUNET_FS_URI_CHK
Content-hash-key (simple file).
Definition: fs_api.h:144
AVAILABILITY_TRIALS_MAX
#define AVAILABILITY_TRIALS_MAX
Number of availability trials we perform per search result.
Definition: fs_search.c:37
start_probe_ping_task
static void start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
Start the ping task for this search result.
Definition: fs_search.c:390
len
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Definition: gnunet-helper-transport-wlan.c:16
GNUNET_CRYPTO_random_u32
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
Definition: crypto_random.c:178
GNUNET_CRYPTO_QUALITY_WEAK
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Definition: gnunet_crypto_lib.h:91
GNUNET_FS_uri_chk_get_file_size
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1360
GNUNET_FS_download_start
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_MetaData *meta, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx, struct GNUNET_FS_DownloadContext *parent)
Download parts of a file.
Definition: fs_download.c:2100
GNUNET_FS_FLAGS_DO_PROBES
@ GNUNET_FS_FLAGS_DO_PROBES
Should we automatically trigger probes for search results to determine availability?...
Definition: gnunet_fs_service.h:1684
GNUNET_FS_DOWNLOAD_IS_PROBE
@ GNUNET_FS_DOWNLOAD_IS_PROBE
Internal option used to flag this download as a 'probe' for a search result.
Definition: gnunet_fs_service.h:2452
GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
@ GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
Do not append temporary data to the target file (for the IBlocks).
Definition: gnunet_fs_service.h:2443
GNUNET_TIME_relative_saturating_multiply
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:531
GNUNET_FS_Handle::flags
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1162
GNUNET_FS_Handle::avg_block_latency
struct GNUNET_TIME_Relative avg_block_latency
Average time we take for a single request to be satisfied.
Definition: fs_api.h:1147
GNUNET_FS_SearchResult::download
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:546
GNUNET_FS_SearchResult::anonymity
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:589
GNUNET_FS_Uri::type
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:171

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, len, 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
srsearch result

Definition at line 516 of file fs_search.c.

517 {
518  if (NULL != sr->probe_ctx)
519  {
520  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
521  sr->probe_ctx = NULL;
522  GNUNET_FS_stop_probe_ping_task_ (sr);
523  }
524  if (NULL != sr->probe_cancel_task)
525  {
526  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
527  sr->probe_cancel_task = NULL;
528  }
529 }

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
sccontext for the overall query
ententry for the specific keyword
urithe URI that was found
metametadata associated with the URI under the ent keyword

Definition at line 565 of file fs_search.c.

569 {
570  struct GNUNET_HashCode key;
571  struct GNUNET_FS_SearchResult *sr;
572  struct GetResultContext grc;
573  int is_new;
574  unsigned int koff;
575 
576  /* check if new */
577  GNUNET_assert (NULL != sc);
578  if (GNUNET_OK !=
579  GNUNET_FS_uri_to_key (uri,
580  &key))
581  {
582  GNUNET_break_op (0);
583  return;
584  }
585  if (GNUNET_SYSERR ==
586  GNUNET_CONTAINER_multihashmap_get_multiple (ent->results,
587  &key,
588  &test_result_present,
589  (void *) uri))
590  return; /* duplicate result */
591  /* try to find search result in master map */
592  grc.sr = NULL;
593  grc.uri = uri;
594  GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map,
595  &key,
596  &get_result_present, &grc);
597  sr = grc.sr;
598  is_new = (NULL == sr) || (sr->mandatory_missing > 0);
599  if (NULL == sr)
600  {
601  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
602  sr->h = sc->h;
603  sr->sc = sc;
604  sr->anonymity = sc->anonymity;
605  sr->uri = GNUNET_FS_uri_dup (uri);
606  sr->meta = GNUNET_FS_meta_data_duplicate (meta);
607  sr->mandatory_missing = sc->mandatory_count;
608  sr->key = key;
609  sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7)
610  / 8); /* round up, count bits */
611  GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
612  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
613  }
614  else
615  {
616  GNUNET_FS_meta_data_merge (sr->meta, meta);
617  }
618  GNUNET_break (GNUNET_OK ==
619  GNUNET_CONTAINER_multihashmap_put (ent->results,
620  &sr->key,
621  sr,
622  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
623 
624  koff = ent - sc->requests;
625  GNUNET_assert ((ent >= sc->requests) &&
626  (koff < sc->uri->data.ksk.keywordCount));
627  sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8));
628  /* check if mandatory satisfied */
629  if (1 <= GNUNET_CONTAINER_multihashmap_size (ent->results))
630  {
631  if (ent->mandatory)
632  {
633  GNUNET_break (sr->mandatory_missing > 0);
634  sr->mandatory_missing--;
635  }
636  else
637  {
638  sr->optional_support++;
639  }
640  }
641  if (0 != sr->mandatory_missing)
642  {
643  GNUNET_break (NULL == sr->client_info);
644  return;
645  }
646  if (is_new)
647  notify_client_chk_result (sc, sr);
648  else
649  notify_client_chk_update (sc, sr);
650  GNUNET_FS_search_result_sync_ (sr);
651  GNUNET_FS_search_start_probe_ (sr);
652 }
notify_client_chk_update
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.
Definition: fs_search.c:127
get_result_present
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.
Definition: fs_search.c:176
test_result_present
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.
Definition: fs_search.c:84
notify_client_chk_result
static void notify_client_chk_result(struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
We've found a new CHK result.
Definition: fs_search.c:105
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition: gnunet-dht-put.c:37
meta
static struct GNUNET_FS_MetaData * meta
Meta-data provided via command-line option.
Definition: gnunet-publish.c:61
GNUNET_FS_uri_dup
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:987
GNUNET_FS_uri_to_key
int GNUNET_FS_uri_to_key(const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *key)
Get a unique key from a URI.
Definition: fs_uri.c:96
GNUNET_CONTAINER_multihashmap_put
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
Definition: container_multihashmap.c:711
GNUNET_CONTAINER_multihashmap_size
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
Definition: container_multihashmap.c:274
GNUNET_CONTAINER_multihashmap_get_multiple
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
Definition: container_multihashmap.c:782
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
Definition: gnunet_container_lib.h:371
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Definition: gnunet_container_lib.h:378
GNUNET_break_op
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Definition: gnunet_common.h:1046
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition: gnunet_common.h:1214
GNUNET_malloc
#define GNUNET_malloc(size)
Wrapper around malloc.
Definition: gnunet_common.h:1352
GNUNET_FS_meta_data_merge
void GNUNET_FS_meta_data_merge(struct GNUNET_FS_MetaData *md, const struct GNUNET_FS_MetaData *in)
Extend metadata.
Definition: meta_data.c:361
GNUNET_FS_meta_data_duplicate
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_duplicate(const struct GNUNET_FS_MetaData *md)
Duplicate a struct GNUNET_FS_MetaData.
Definition: meta_data.c:532
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search.
Definition: fs_api.h:1559
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1565
GNUNET_FS_SearchContext::mandatory_count
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1593
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:562
GNUNET_FS_SearchResult::key
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:567
GNUNET_FS_SearchResult::mandatory_missing
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:596
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@13::@14 ksk
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@13 data
GNUNET_HashCode
A 512-bit hashcode.
Definition: gnunet_common.h:284
SearchRequestEntry::mandatory
int mandatory
Is this keyword a mandatory keyword (started with '+')?
Definition: fs_api.h:1503
SearchRequestEntry::results
struct GNUNET_CONTAINER_MultiHashMap * results
Map that contains a "struct GNUNET_FS_SearchResult" for each result that was found under this keyword...
Definition: fs_api.h:1497

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::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchResult::meta, meta, notify_client_chk_result(), notify_client_chk_update(), GNUNET_FS_SearchResult::optional_support, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, GNUNET_FS_SearchResult::sc, sc, GetResultContext::sr, test_result_present(), GNUNET_FS_SearchResult::uri, GNUNET_FS_SearchContext::uri, GetResultContext::uri, and 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
hhandle to the file sharing subsystem
urispecifies the search parameters; can be a KSK URI or an SKS URI.
anonymitydesired level of anonymity
optionsoptions for the search
cctxclient context
psearchparent search result (for namespace update searches)
Returns
context that can be used to control the search
Parameters
hhandle to the file sharing subsystem
urispecifies the search parameters; can be a KSK URI or an SKS URI.
anonymitydesired level of anonymity
optionsoptions for the search
cctxinitial value for the client context
psearchparent 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.

1340 {
1341  struct GNUNET_FS_SearchContext *sc;
1342  struct GNUNET_FS_ProgressInfo pi;
1343 
1344  sc = GNUNET_new (struct GNUNET_FS_SearchContext);
1345  sc->h = h;
1346  sc->options = options;
1347  sc->uri = GNUNET_FS_uri_dup (uri);
1348  sc->anonymity = anonymity;
1349  sc->start_time = GNUNET_TIME_absolute_get ();
1350  if (NULL != psearch)
1351  {
1352  sc->psearch_result = psearch;
1353  psearch->update_search = sc;
1354  }
1355  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
1356  sc->client_info = cctx;
1357  if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc))
1358  {
1359  GNUNET_FS_uri_destroy (sc->uri);
1360  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1361  GNUNET_free (sc);
1362  return NULL;
1363  }
1364  GNUNET_FS_search_sync_ (sc);
1365  pi.status = GNUNET_FS_STATUS_SEARCH_START;
1366  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1367  return sc;
1368 }
options
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
GNUNET_FS_search_sync_
void GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
Synchronize this search struct with its mirror on disk.
Definition: fs_api.c:2248
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.
Definition: fs_search.c:1402
anonymity
static unsigned int anonymity
Definition: gnunet-download.c:44
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
GNUNET_FS_STATUS_SEARCH_START
@ GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
Definition: gnunet_fs_service.h:724
GNUNET_CONTAINER_multihashmap_create
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
Definition: container_multihashmap.c:181
GNUNET_CONTAINER_multihashmap_destroy
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
Definition: container_multihashmap.c:216
GNUNET_NO
@ GNUNET_NO
Definition: gnunet_common.h:108
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1412
GNUNET_FS_ProgressInfo::cctx
void * cctx
Client context pointer (set the last time by the client for this operation; initially NULL on START/R...
Definition: gnunet_fs_service.h:911
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1511
GNUNET_FS_SearchContext::options
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1598
GNUNET_FS_SearchResult::update_search
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:552

References GNUNET_FS_SearchContext::anonymity, 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, pi, GNUNET_FS_SearchContext::psearch_result, sc, GNUNET_FS_SearchContext::start_time, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchContext::uri, and 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
sccontext for the overall query
id_updateidentifier for updates, NULL for none
urithe URI that was found
metametadata associated with the URI

Definition at line 686 of file fs_search.c.

690 {
691  struct GNUNET_FS_Uri uu;
692  struct GNUNET_HashCode key;
693  struct GNUNET_FS_SearchResult *sr;
694 
695  /* check if new */
696  GNUNET_assert (NULL != sc);
697  if (GNUNET_OK !=
698  GNUNET_FS_uri_to_key (uri,
699  &key))
700  {
701  GNUNET_break (0);
702  return;
703  }
704  GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key,
705  &uri->data.chk.chk.query,
706  &key);
707  if (GNUNET_SYSERR ==
708  GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, &key,
709  &test_result_present,
710  (void *) uri))
711  return; /* duplicate result */
712  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
713  sr->h = sc->h;
714  sr->sc = sc;
715  sr->anonymity = sc->anonymity;
716  sr->uri = GNUNET_FS_uri_dup (uri);
717  sr->meta = GNUNET_FS_meta_data_duplicate (meta);
718  sr->key = key;
719  GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
720  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
721  GNUNET_FS_search_result_sync_ (sr);
722  GNUNET_FS_search_start_probe_ (sr);
723  /* notify client */
724  if (0 == sr->mandatory_missing)
725  notify_client_chk_result (sc, sr);
726  else
727  GNUNET_break (NULL == sr->client_info);
728  /* search for updates */
729  if (0 == strlen (id_update))
730  return; /* no updates */
731  uu.type = GNUNET_FS_URI_SKS;
732  uu.data.sks.ns = sc->uri->data.sks.ns;
733  uu.data.sks.identifier = GNUNET_strdup (id_update);
734  (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
735  GNUNET_free (uu.data.sks.identifier);
736 }
GNUNET_FS_URI_SKS
@ GNUNET_FS_URI_SKS
Signed key space (file in namespace).
Definition: fs_api.h:149
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)
Start search for content, internal API.
Definition: fs_search.c:1334
GNUNET_CRYPTO_hash_xor
void GNUNET_CRYPTO_hash_xor(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
compute result = a ^ b
Definition: crypto_hash.c:135
GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition: gnunet_common.h:1426
ContentHashKey::key
struct GNUNET_HashCode key
Hash of the original content, used for encryption.
Definition: fs.h:59
ContentHashKey::query
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:64
FileIdentifier::chk
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
GNUNET_FS_Uri::sks
struct GNUNET_FS_Uri::@13::@15 sks
GNUNET_FS_Uri::chk
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:212

References GNUNET_FS_SearchResult::anonymity, GNUNET_FS_SearchContext::anonymity, GNUNET_FS_Uri::chk, FileIdentifier::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, key, ContentHashKey::key, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchResult::meta, meta, notify_client_chk_result(), GNUNET_FS_SearchContext::options, ContentHashKey::query, GNUNET_FS_SearchResult::sc, sc, search_start(), GNUNET_FS_Uri::sks, test_result_present(), GNUNET_FS_Uri::type, GNUNET_FS_SearchResult::uri, GNUNET_FS_SearchContext::uri, and 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
scsearch context with the keywords
dpubderived public key used for the search
edataencrypted data
edata_sizenumber of bytes in edata (and data)
datawhere 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.

759 {
760  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
761  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
762  unsigned int i;
763 
764  /* find key */
765  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
766  if (0 == memcmp (dpub,
767  &sc->requests[i].dpub,
768  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
769  break;
770  if (i == sc->uri->data.ksk.keywordCount)
771  {
772  /* oops, does not match any of our keywords!? */
773  GNUNET_break (0);
774  return GNUNET_SYSERR;
775  }
776  /* decrypt */
777  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
778  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
779  GNUNET_FS_ublock_decrypt_ (edata, edata_size,
780  &anon_pub,
781  sc->requests[i].keyword,
782  data);
783  return i;
784 }
GNUNET_FS_ublock_decrypt_
void GNUNET_FS_ublock_decrypt_(const void *input, size_t input_len, const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *label, void *output)
Decrypt the given UBlock, storing the result in output.
Definition: fs_publish_ublock.c:66
data
uint32_t data
The data value.
Definition: gnunet-helper-transport-wlan.c:21
GNUNET_CRYPTO_ecdsa_key_get_anonymous
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_key_get_anonymous(void)
Get the shared private key we use for anonymous users.
Definition: crypto_ecc.c:482
GNUNET_CRYPTO_ecdsa_key_get_public
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:187
GNUNET_CRYPTO_EcdsaPrivateKey
Private ECC key encoded for transmission.
Definition: gnunet_crypto_lib.h:266
GNUNET_CRYPTO_EcdsaPublicKey
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Definition: gnunet_crypto_lib.h:216
SearchRequestEntry::dpub
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to 'uquery'.
Definition: fs_api.h:1481
SearchRequestEntry::keyword
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1487

References GNUNET_FS_Uri::data, 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::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
scour search context
ubthe ublock with the keyword search result
sizesize of ub

Definition at line 797 of file fs_search.c.

800 {
801  size_t j;
802  char pt[size - sizeof(struct UBlock)];
803  const char *eos;
804  struct GNUNET_FS_MetaData *meta;
805  struct GNUNET_FS_Uri *uri;
806  char *emsg;
807  int i;
808 
809  if (-1 == (i = decrypt_block_with_keyword (sc,
810  &ub->verification_key,
811  &ub[1],
812  size - sizeof(struct UBlock),
813  pt)))
814  return;
815  /* parse; pt[0] is just '\0', so we skip over that */
816  eos = memchr (&pt[1], '\0', sizeof(pt) - 1);
817  if (NULL == eos)
818  {
819  GNUNET_break_op (0);
820  return;
821  }
822  if (NULL == (uri = GNUNET_FS_uri_parse (&pt[1], &emsg)))
823  {
824  if (GNUNET_FS_VERSION > 0x00090400)
825  {
826  /* we broke this in 0x00090300, so don't bitch
827  too loudly just one version up... */
828  GNUNET_break_op (0); /* ublock malformed */
829  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
830  _ ("Failed to parse URI `%s': %s\n"),
831  &pt[1],
832  emsg);
833  }
834  GNUNET_free (emsg);
835  return;
836  }
837  j = eos - pt + 1;
838  if (sizeof(pt) == j)
839  meta = GNUNET_FS_meta_data_create ();
840  else
841  meta = GNUNET_FS_meta_data_deserialize (&pt[j], sizeof(pt) - j);
842  if (NULL == meta)
843  {
844  GNUNET_break_op (0); /* ublock malformed */
845  GNUNET_FS_uri_destroy (uri);
846  return;
847  }
848  process_ksk_result (sc,
849  &sc->requests[i],
850  uri,
851  meta);
852 
853  /* clean up */
854  GNUNET_FS_meta_data_destroy (meta);
855  GNUNET_FS_uri_destroy (uri);
856 }
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)
Decrypt a ublock using a 'keyword' as the passphrase.
Definition: fs_search.c:754
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)
We have received a KSK result.
Definition: fs_search.c:565
GNUNET_FS_uri_parse
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:637
GNUNET_FS_VERSION
#define GNUNET_FS_VERSION
Version number of the implementation.
Definition: gnunet_fs_service.h:72
GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_ERROR
Definition: gnunet_common.h:437
GNUNET_FS_meta_data_create
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_create()
Create a fresh struct FS_MetaData token.
Definition: meta_data.c:132
GNUNET_FS_meta_data_destroy
void GNUNET_FS_meta_data_destroy(struct GNUNET_FS_MetaData *md)
Free meta data.
Definition: meta_data.c:171
GNUNET_FS_meta_data_deserialize
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
Definition: meta_data.c:890
size
static unsigned int size
Size of the "table".
Definition: peer.c:68
_
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
GNUNET_FS_MetaData
Meta data to associate with a file, directory or namespace.
Definition: meta_data.c:97
UBlock
universal block for keyword and namespace search results
Definition: block_fs.h:54
UBlock::verification_key
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:68

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
scour search context
ubthe ublock with a namespace result
sizesize of ub

Definition at line 869 of file fs_search.c.

872 {
873  size_t len = size - sizeof(struct UBlock);
874  char pt[len];
875  struct GNUNET_FS_Uri *uri;
876  struct GNUNET_FS_MetaData *meta;
877  const char *id;
878  const char *uris;
879  size_t off;
880  char *emsg;
881 
882  GNUNET_FS_ublock_decrypt_ (&ub[1], len,
883  &sc->uri->data.sks.ns,
884  sc->uri->data.sks.identifier,
885  pt);
886  /* parse */
887  if (0 == (off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris)))
888  {
889  GNUNET_break_op (0); /* ublock malformed */
890  return;
891  }
892  if (NULL == (meta = GNUNET_FS_meta_data_deserialize (&pt[off], len
893  - off)))
894  {
895  GNUNET_break_op (0); /* ublock malformed */
896  return;
897  }
898  if (NULL == (uri = GNUNET_FS_uri_parse (uris, &emsg)))
899  {
900  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
901  _ ("Failed to parse URI `%s': %s\n"),
902  uris, emsg);
903  GNUNET_break_op (0); /* ublock malformed */
904  GNUNET_free (emsg);
905  GNUNET_FS_meta_data_destroy (meta);
906  return;
907  }
908  /* process */
909  process_sks_result (sc, id, uri, meta);
910  /* clean up */
911  GNUNET_FS_uri_destroy (uri);
912  GNUNET_FS_meta_data_destroy (meta);
913 }
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)
We have received an SKS result.
Definition: fs_search.c:686
id
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
Definition: gnunet-conversation.c:187
GNUNET_STRINGS_buffer_tokenize
unsigned int GNUNET_STRINGS_buffer_tokenize(const char *buffer, size_t size, unsigned int count,...)
Given a buffer of a given size, find "count" 0-terminated strings in the buffer and assign the count ...
Definition: strings.c:72

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, len, meta, process_sks_result(), sc, size, GNUNET_FS_Uri::sks, GNUNET_FS_SearchContext::uri, and 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
scthe search to reconnec

Definition at line 1306 of file fs_search.c.

1307 {
1308  if (NULL != sc->mq)
1309  {
1310  GNUNET_MQ_destroy (sc->mq);
1311  sc->mq = NULL;
1312  }
1313  sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (sc->reconnect_backoff);
1314  sc->task =
1315  GNUNET_SCHEDULER_add_delayed (sc->reconnect_backoff,
1316  &do_reconnect,
1317  sc);
1318 }
do_reconnect
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1272
GNUNET_MQ_destroy
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
GNUNET_TIME_STD_BACKOFF
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Definition: gnunet_time_lib.h:221
GNUNET_FS_SearchContext::task
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1583
GNUNET_FS_SearchContext::reconnect_backoff
struct GNUNET_TIME_Relative reconnect_backoff
How long to wait before we try to reconnect to FS service?
Definition: fs_api.h:1575
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1536

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
clsclosure
cmresult message received

Definition at line 934 of file fs_search.c.

936 {
937  /* payload of any variable size is OK */
938  return GNUNET_OK;
939 }

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
clsclosure
cmresult message received

Definition at line 949 of file fs_search.c.

951 {
952  struct GNUNET_FS_SearchContext *sc = cls;
953  uint16_t msize = ntohs (cm->header.size) - sizeof(*cm);
954  enum GNUNET_BLOCK_Type type = ntohl (cm->type);
955 
956  if (GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (
957  cm->expiration)).rel_value_us > 0)
958  {
959  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
960  "Result received has already expired.\n");
961  return; /* result expired */
962  }
963  switch (type)
964  {
965  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
966  if (GNUNET_FS_URI_SKS == sc->uri->type)
967  process_sblock (sc,
968  (const struct UBlock *) &cm[1],
969  msize);
970  else
971  process_kblock (sc,
972  (const struct UBlock *) &cm[1],
973  msize);
974  break;
975 
976  case GNUNET_BLOCK_TYPE_ANY:
977  GNUNET_break (0);
978  break;
979 
980  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
981  GNUNET_break (0);
982  break;
983 
984  case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
985  GNUNET_break (0);
986  break;
987 
988  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
989  GNUNET_break (0);
990  break;
991 
992  default:
993  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
994  _ ("Got result with unknown block type `%d', ignoring"),
995  type);
996  break;
997  }
998 }
GNUNET_BLOCK_Type
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
Definition: gnunet_dht_block_types.h:43
GNUNET_BLOCK_TYPE_FS_UBLOCK
@ GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
Definition: gnunet_dht_block_types.h:85
GNUNET_BLOCK_TYPE_FS_IBLOCK
@ GNUNET_BLOCK_TYPE_FS_IBLOCK
Inner block in the CHK tree.
Definition: gnunet_dht_block_types.h:61
GNUNET_BLOCK_TYPE_ANY
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
Definition: gnunet_dht_block_types.h:49
GNUNET_BLOCK_TYPE_FS_ONDEMAND
@ GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
Definition: gnunet_dht_block_types.h:67
GNUNET_BLOCK_TYPE_FS_DBLOCK
@ GNUNET_BLOCK_TYPE_FS_DBLOCK
Data block (leaf) in the CHK tree.
Definition: gnunet_dht_block_types.h:55
process_kblock
static void process_kblock(struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
Process a keyword search result.
Definition: fs_search.c:797
process_sblock
static void process_sblock(struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
Process a namespace-search result.
Definition: fs_search.c:869
GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition: gnunet_common.h:438
GNUNET_TIME_absolute_ntoh
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
ClientPutMessage::type
uint32_t type
Type of the block (in big endian).
Definition: fs.h:365
ClientPutMessage::expiration
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:370
ClientPutMessage::header
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
Definition: fs.h:360
GNUNET_MessageHeader::size
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Definition: gnunet_common.h:325
type
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Definition: testbed_api_underlay.c:133

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, ClientPutMessage::type, GNUNET_FS_Uri::type, 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
sccontext for the search

Definition at line 1114 of file fs_search.c.

1115 {
1116  struct MessageBuilderContext mbc;
1117  struct GNUNET_MQ_Envelope *env;
1118  struct SearchMessage *sm;
1119  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
1120  unsigned int total_seen_results; /* total number of result hashes to send */
1121  uint32_t options;
1122  unsigned int left;
1123  unsigned int todo;
1124  unsigned int fit;
1125  unsigned int search_request_map_offset;
1126  unsigned int keyword_offset;
1127  int first_call;
1128 
1129  memset (&mbc, 0, sizeof(mbc));
1130  mbc.sc = sc;
1131  if (GNUNET_FS_uri_test_ksk (sc->uri))
1132  {
1133  /* This will calculate the result set size ONLY for
1134  "keyword_offset == 0", so we will have to recalculate
1135  it for the other keywords later! */
1136  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1137  &find_result_set,
1138  &mbc);
1139  total_seen_results = mbc.put_cnt;
1140  }
1141  else
1142  {
1143  total_seen_results
1144  = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
1145  }
1146  search_request_map_offset = 0;
1147  keyword_offset = 0;
1148  first_call = GNUNET_YES;
1149  while ((0 != (left =
1150  (total_seen_results - search_request_map_offset))) ||
1151  (GNUNET_YES == first_call))
1152  {
1153  first_call = GNUNET_NO;
1154  options = SEARCH_MESSAGE_OPTION_NONE;
1155  if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
1156  options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
1157 
1158  fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct
1159  GNUNET_HashCode);
1160  todo = GNUNET_MIN (fit,
1161  left);
1162  env = GNUNET_MQ_msg_extra (sm,
1163  sizeof(struct GNUNET_HashCode) * todo,
1164  GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
1165  mbc.skip_cnt = search_request_map_offset;
1166  mbc.xoff = (struct GNUNET_HashCode *) &sm[1];
1167  sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK);
1168  sm->anonymity_level = htonl (sc->anonymity);
1169  memset (&sm->target,
1170  0,
1171  sizeof(struct GNUNET_PeerIdentity));
1172 
1173  if (GNUNET_FS_uri_test_ksk (sc->uri))
1174  {
1175  mbc.keyword_offset = keyword_offset;
1176  /* calculate how many results we can send in this message */
1177  mbc.put_cnt = todo;
1178  /* now build message */
1179  sm->query = sc->requests[keyword_offset].uquery;
1180  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1181  &build_result_set,
1182  &mbc);
1183  search_request_map_offset += todo;
1184  GNUNET_assert (0 == mbc.put_cnt);
1185  GNUNET_assert (total_seen_results >= search_request_map_offset);
1186  if (total_seen_results != search_request_map_offset)
1187  {
1188  /* more requesting to be done... */
1189  sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
1190  }
1191  else
1192  {
1193  sm->options = htonl (options);
1194  keyword_offset++;
1195  if (sc->uri->data.ksk.keywordCount != keyword_offset)
1196  {
1197  /* more keywords => more requesting to be done... */
1198  first_call = GNUNET_YES;
1199  search_request_map_offset = 0;
1200  mbc.put_cnt = 0;
1201  mbc.keyword_offset = keyword_offset;
1202  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1203  &find_result_set,
1204  &mbc);
1205  total_seen_results = mbc.put_cnt;
1206  }
1207  }
1208  }
1209  else
1210  {
1211  GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
1212 
1213  GNUNET_CRYPTO_ecdsa_public_key_derive (&sc->uri->data.sks.ns,
1214  sc->uri->data.sks.identifier,
1215  "fs-ublock",
1216  &dpub);
1217  GNUNET_CRYPTO_hash (&dpub,
1218  sizeof(dpub),
1219  &sm->query);
1220  mbc.put_cnt = todo;
1221  mbc.keyword_offset = 0;
1222  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1223  &build_result_set,
1224  &mbc);
1225  GNUNET_assert (total_seen_results >= search_request_map_offset);
1226  if (total_seen_results != search_request_map_offset)
1227  {
1228  /* more requesting to be done... */
1229  sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
1230  }
1231  else
1232  {
1233  sm->options = htonl (options);
1234  }
1235  }
1236  GNUNET_MQ_send (sc->mq,
1237  env);
1238  }
1239 }
env
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
SEARCH_MESSAGE_OPTION_NONE
#define SEARCH_MESSAGE_OPTION_NONE
No options.
Definition: fs.h:249
SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:254
SEARCH_MESSAGE_OPTION_CONTINUED
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:262
build_result_set
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 ...
Definition: fs_search.c:1053
find_result_set
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...
Definition: fs_search.c:1089
GNUNET_MAX_MESSAGE_SIZE
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
Definition: gnunet_util_lib.h:52
GNUNET_CRYPTO_ecdsa_public_key_derive
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc_gnsrecord.c:241
GNUNET_FS_uri_test_ksk
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1324
GNUNET_FS_uri_test_sks
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1271
GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY
@ GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY
Only search the local host, do not search remote systems (no P2P)
Definition: gnunet_fs_service.h:2340
GNUNET_CRYPTO_hash
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
GNUNET_CONTAINER_multihashmap_iterate
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Definition: container_multihashmap.c:310
GNUNET_MIN
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:115
GNUNET_MQ_send
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
GNUNET_MQ_msg_extra
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
GNUNET_MESSAGE_TYPE_FS_START_SEARCH
#define GNUNET_MESSAGE_TYPE_FS_START_SEARCH
Client asks FS service to start a (keyword) search.
Definition: gnunet_protocols.h:563
GNUNET_MQ_Envelope
Definition: mq.c:34
GNUNET_PeerIdentity
The identity of the host (wraps the signing key of the peer).
Definition: gnunet_crypto_lib.h:229
MessageBuilderContext
Closure for build_result_set().
Definition: fs_search.c:1015
SearchMessage
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search.
Definition: fs.h:270
SearchMessage::target
struct GNUNET_PeerIdentity target
If the request is for a DBLOCK or IBLOCK, this is the identity of the peer that is known to have a re...
Definition: fs.h:307
SearchMessage::type
uint32_t type
Type of the content that we're looking for.
Definition: fs.h:290
SearchMessage::query
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS.
Definition: fs.h:313
SearchMessage::anonymity_level
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:295
SearchMessage::options
uint32_t options
Bitmask with options.
Definition: fs.h:285
SearchRequestEntry::uquery
struct GNUNET_HashCode uquery
Hash of the public key, also known as the query.
Definition: fs_api.h:1476

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, MessageBuilderContext::keyword_offset, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, options, SearchMessage::options, GNUNET_FS_SearchContext::options, MessageBuilderContext::put_cnt, SearchMessage::query, GNUNET_FS_SearchContext::requests, MessageBuilderContext::sc, 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
clsthe struct MessageBuilderContext
keykey for a result
valuethe search result
Returns
GNUNET_OK to continue iterating

Definition at line 1053 of file fs_search.c.

1056 {
1057  struct MessageBuilderContext *mbc = cls;
1058  struct GNUNET_FS_SearchResult *sr = value;
1059 
1060  if ((NULL != sr->keyword_bitmap) &&
1061  (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1
1062  << (mbc->
1063  keyword_offset
1064  % 8)))))
1065  return GNUNET_OK; /* have no match for this keyword yet */
1066  if (mbc->skip_cnt > 0)
1067  {
1068  mbc->skip_cnt--;
1069  return GNUNET_OK;
1070  }
1071  if (0 == mbc->put_cnt)
1072  return GNUNET_SYSERR;
1073  mbc->xoff[--mbc->put_cnt] = *key;
1074 
1075  return GNUNET_OK;
1076 }
MessageBuilderContext::put_cnt
unsigned int put_cnt
How many entries can we store to xoff.
Definition: fs_search.c:1019
MessageBuilderContext::xoff
struct GNUNET_HashCode * xoff
Where to store the keys.
Definition: fs_search.c:1029
MessageBuilderContext::keyword_offset
unsigned int keyword_offset
Keyword offset the search result must match (0 for SKS)
Definition: fs_search.c:1039
MessageBuilderContext::skip_cnt
unsigned int skip_cnt
How many entries should we skip.
Definition: fs_search.c:1024

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
clsthe struct MessageBuilderContext
keykey for a result
valuethe search result
Returns
GNUNET_OK to continue iterating

Definition at line 1089 of file fs_search.c.

1092 {
1093  struct MessageBuilderContext *mbc = cls;
1094  struct GNUNET_FS_SearchResult *sr = value;
1095 
1096  if ((NULL != sr->keyword_bitmap) &&
1097  (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1
1098  << (mbc->
1099  keyword_offset
1100  % 8)))))
1101  return GNUNET_OK; /* have no match for this keyword yet */
1102  mbc->put_cnt++;
1103  return GNUNET_OK;
1104 }

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
clsclosure with the struct GNUNET_FS_SearchContext *
errorerror code

Definition at line 1251 of file fs_search.c.

1253 {
1254  struct GNUNET_FS_SearchContext *sc = cls;
1255 
1256  if (NULL != sc->mq)
1257  {
1258  GNUNET_MQ_destroy (sc->mq);
1259  sc->mq = NULL;
1260  }
1261  try_reconnect (sc);
1262 }
try_reconnect
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-tran...
Definition: fs_search.c:1306

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
clsour search context

Definition at line 1272 of file fs_search.c.

1273 {
1274  struct GNUNET_FS_SearchContext *sc = cls;
1275  struct GNUNET_MQ_MessageHandler handlers[] = {
1276  GNUNET_MQ_hd_var_size (result,
1277  GNUNET_MESSAGE_TYPE_FS_PUT,
1278  struct ClientPutMessage,
1279  sc),
1280  GNUNET_MQ_handler_end ()
1281  };
1282 
1283  sc->task = NULL;
1284  sc->mq = GNUNET_CLIENT_connect (sc->h->cfg,
1285  "fs",
1286  handlers,
1287  &search_mq_error_handler,
1288  sc);
1289  if (NULL == sc->mq)
1290  {
1291  try_reconnect (sc);
1292  return;
1293  }
1294  schedule_transmit_search_request (sc);
1295 }
schedule_transmit_search_request
static void schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc)
Schedule the transmission of the (next) search request to the service.
Definition: fs_search.c:1114
search_mq_error_handler
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 c...
Definition: fs_search.c:1251
handlers
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
Definition: gnunet-cadet-profiler.c:800
result
static int result
Global testing status.
Definition: gnunet-regex-profiler.c:240
GNUNET_CLIENT_connect
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1057
GNUNET_MQ_handler_end
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Definition: gnunet_mq_lib.h:532
GNUNET_MQ_hd_var_size
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Definition: gnunet_mq_lib.h:618
GNUNET_MESSAGE_TYPE_FS_PUT
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
Definition: gnunet_protocols.h:575
ClientPutMessage
Response from FS service with a result for a previous FS search.
Definition: fs.h:356
GNUNET_FS_Handle::cfg
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1074
GNUNET_MQ_MessageHandler
Message handler for a specific message type.
Definition: gnunet_mq_lib.h:492

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
clsclosure, the struct GNUNET_FS_SearchContext *
keycurrent key code
valuevalue 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.

1384 {
1385  struct GNUNET_FS_SearchContext *sc = cls;
1386  struct GNUNET_FS_SearchResult *sr = value;
1387 
1388  for (unsigned int i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1389  {
1390  if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8))))
1391  GNUNET_break (GNUNET_OK ==
1392  GNUNET_CONTAINER_multihashmap_put (sc->requests[i].results,
1393  &sr->key,
1394  sr,
1395  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1396  }
1397  return GNUNET_YES;
1398 }

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::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
scsearch context
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1402 of file fs_search.c.

1403 {
1404  unsigned int i;
1405  const char *keyword;
1406  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
1407  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
1408  struct SearchRequestEntry *sre;
1409 
1410  GNUNET_assert (NULL == sc->mq);
1411  if (GNUNET_FS_uri_test_ksk (sc->uri))
1412  {
1413  GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
1414  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
1415  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
1416  sc->requests
1417  = GNUNET_new_array (sc->uri->data.ksk.keywordCount,
1418  struct SearchRequestEntry);
1419 
1420  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1421  {
1422  keyword = &sc->uri->data.ksk.keywords[i][1];
1423  sre = &sc->requests[i];
1424  sre->keyword = GNUNET_strdup (keyword);
1425  GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
1426  keyword,
1427  "fs-ublock",
1428  &sre->dpub);
1429  GNUNET_CRYPTO_hash (&sre->dpub,
1430  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
1431  &sre->uquery);
1432  sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
1433  if (sre->mandatory)
1434  sc->mandatory_count++;
1435  sre->results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
1436  }
1437  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1438  &update_sre_result_maps,
1439  sc);
1440  }
1441  GNUNET_assert (NULL == sc->task);
1442  do_reconnect (sc);
1443  if (NULL == sc->mq)
1444  {
1445  GNUNET_SCHEDULER_cancel (sc->task);
1446  sc->task = NULL;
1447  return GNUNET_SYSERR;
1448  }
1449  return GNUNET_OK;
1450 }
update_sre_result_maps
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.
Definition: fs_search.c:1381
GNUNET_new_array
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
Definition: gnunet_common.h:1313
SearchRequestEntry
Information we keep for each keyword in a keyword search.
Definition: fs_api.h:1472

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::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
clsthe global FS handle
keythe key for the search result (unused)
valuethe search result to free
Returns
GNUNET_OK

Definition at line 1462 of file fs_search.c.

1465 {
1466  struct GNUNET_FS_SearchResult *sr = value;
1467 
1468  if (NULL != sr->probe_ctx)
1469  {
1470  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
1471  sr->probe_ctx = NULL;
1472  GNUNET_FS_stop_probe_ping_task_ (sr);
1473  }
1474  if (NULL != sr->probe_cancel_task)
1475  {
1476  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
1477  sr->probe_cancel_task = NULL;
1478  }
1479  if (NULL != sr->update_search)
1480  GNUNET_FS_search_pause (sr->update_search);
1481  return GNUNET_OK;
1482 }
GNUNET_FS_search_pause
void GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc)
Pause search.
Definition: fs_search.c:1627

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
clsthe global FS handle
keythe key for the search result (unused)
valuethe search result to free
Returns
GNUNET_OK

Definition at line 1494 of file fs_search.c.

1497 {
1498  struct GNUNET_FS_SearchResult *sr = value;
1499 
1500  GNUNET_FS_search_start_probe_ (sr);
1501  if (NULL != sr->update_search)
1502  GNUNET_FS_search_continue (sr->update_search);
1503  return GNUNET_OK;
1504 }
GNUNET_FS_search_continue
void GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc)
Continue paused search.
Definition: fs_search.c:1658

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
clsthe global FS handle
keythe key for the search result (unused)
valuethe search result to free
Returns
GNUNET_OK

Definition at line 1516 of file fs_search.c.

1519 {
1520  struct GNUNET_FS_SearchContext *sc = cls;
1521  struct GNUNET_FS_SearchResult *sr = value;
1522  struct GNUNET_FS_ProgressInfo pi;
1523 
1524  if (NULL != sr->download)
1525  {
1526  GNUNET_FS_download_signal_suspend_ (sr->download);
1527  sr->download = NULL;
1528  }
1529  if (NULL != sr->update_search)
1530  {
1531  GNUNET_FS_search_signal_suspend_ (sr->update_search);
1532  sr->update_search = NULL;
1533  }
1534  GNUNET_FS_search_stop_probe_ (sr);
1535  if (0 == sr->mandatory_missing)
1536  {
1537  /* client is aware of search result, notify about suspension event */
1538  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND;
1539  pi.value.search.specifics.result_suspend.cctx = sr->client_info;
1540  pi.value.search.specifics.result_suspend.meta = sr->meta;
1541  pi.value.search.specifics.result_suspend.uri = sr->uri;
1542  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1543  }
1544  GNUNET_break (NULL == sr->client_info);
1545  GNUNET_free (sr->serialization);
1546  GNUNET_FS_uri_destroy (sr->uri);
1547  GNUNET_FS_meta_data_destroy (sr->meta);
1548  GNUNET_free (sr->keyword_bitmap);
1549  GNUNET_free (sr);
1550  return GNUNET_OK;
1551 }
GNUNET_FS_download_signal_suspend_
void GNUNET_FS_download_signal_suspend_(void *cls)
Create SUSPEND event for the given download operation and then clean up our state (without stop signa...
Definition: fs_download.c:1953
GNUNET_FS_search_stop_probe_
static void GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
Stop probing activity associated with a search result.
Definition: fs_search.c:516
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)...
Definition: fs_search.c:1555
GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND
@ GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND
Event generated for each search result when the respective search is suspended.
Definition: gnunet_fs_service.h:787
GNUNET_FS_SearchResult::serialization
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:557

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, pi, sc, GNUNET_FS_SearchResult::serialization, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchResult::uri, and 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
clsthe 'struct GNUNET_FS_SearchContext' to signal for

Definition at line 1555 of file fs_search.c.

1556 {
1557  struct GNUNET_FS_SearchContext *sc = cls;
1558  struct GNUNET_FS_ProgressInfo pi;
1559  unsigned int i;
1560 
1561  GNUNET_FS_end_top (sc->h, sc->top);
1562  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1563  &search_result_suspend, sc);
1564  pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND;
1565  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1566  GNUNET_break (NULL == sc->client_info);
1567  if (sc->task != NULL)
1568  {
1569  GNUNET_SCHEDULER_cancel (sc->task);
1570  sc->task = NULL;
1571  }
1572  if (NULL != sc->mq)
1573  {
1574  GNUNET_MQ_destroy (sc->mq);
1575  sc->mq = NULL;
1576  }
1577  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1578  if (NULL != sc->requests)
1579  {
1580  GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
1581  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1582  {
1583  GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
1584  GNUNET_free (sc->requests[i].keyword);
1585  }
1586  }
1587  GNUNET_free (sc->requests);
1588  GNUNET_free (sc->emsg);
1589  GNUNET_FS_uri_destroy (sc->uri);
1590  GNUNET_free (sc->serialization);
1591  GNUNET_free (sc);
1592 }
GNUNET_FS_end_top
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:402
search_result_suspend
static int search_result_suspend(void *cls, const struct GNUNET_HashCode *key, void *value)
Signal suspend and free the given search result.
Definition: fs_search.c:1516
GNUNET_FS_STATUS_SEARCH_SUSPEND
@ GNUNET_FS_STATUS_SEARCH_SUSPEND
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
Definition: gnunet_fs_service.h:744
GNUNET_FS_SearchContext::emsg
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1551
GNUNET_FS_SearchContext::serialization
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1546
GNUNET_FS_SearchContext::top
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1520

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::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, pi, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, search_result_suspend(), GNUNET_FS_SearchContext::serialization, 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
clsthe global FS handle
keythe key for the search result (unused)
valuethe search result to free
Returns
GNUNET_OK

Definition at line 1682 of file fs_search.c.

1685 {
1686  struct GNUNET_FS_SearchContext *sc = cls;
1687  struct GNUNET_FS_SearchResult *sr = value;
1688  struct GNUNET_FS_ProgressInfo pi;
1689 
1690  GNUNET_FS_search_stop_probe_ (sr);
1691  if (NULL != sr->download)
1692  {
1693  sr->download->search = NULL;
1694  sr->download->top
1695  = GNUNET_FS_make_top (sr->download->h,
1696  &GNUNET_FS_download_signal_suspend_,
1697  sr->download);
1698  if (NULL != sr->download->serialization)
1699  {
1700  GNUNET_FS_remove_sync_file_ (sc->h,
1701  GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
1702  sr->download->serialization);
1703  GNUNET_free (sr->download->serialization);
1704  sr->download->serialization = NULL;
1705  }
1706  pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT;
1707  GNUNET_FS_download_make_status_ (&pi,
1708  sr->download);
1709  GNUNET_FS_download_sync_ (sr->download);
1710  sr->download = NULL;
1711  }
1712  if (0 != sr->mandatory_missing)
1713  {
1714  /* client is unaware of search result as
1715  it does not match required keywords */
1716  GNUNET_break (NULL == sr->client_info);
1717  return GNUNET_OK;
1718  }
1719  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED;
1720  pi.value.search.specifics.result_stopped.cctx = sr->client_info;
1721  pi.value.search.specifics.result_stopped.meta = sr->meta;
1722  pi.value.search.specifics.result_stopped.uri = sr->uri;
1723  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sc);
1724  return GNUNET_OK;
1725 }
GNUNET_FS_make_top
struct TopLevelActivity * GNUNET_FS_make_top(struct GNUNET_FS_Handle *h, SuspendSignalFunction ssf, void *ssf_cls)
Create a top-level activity entry.
Definition: fs_api.c:381
GNUNET_FS_download_sync_
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:2036
GNUNET_FS_remove_sync_file_
void GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Remove serialization/deserialization file from disk.
Definition: fs_api.c:728
GNUNET_FS_download_make_status_
void GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_DownloadContext *dc)
Fill in all of the generic fields for a download event and call the callback.
Definition: fs_download.c:104
GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
#define GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
Name of the directory with downloads that are part of another download or a search.
Definition: fs_api.h:72
GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
@ GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
Event generated for each search result when the respective search is stopped.
Definition: gnunet_fs_service.h:781
GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT
@ GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT
Notification that this download is no longer part of a recursive download or search but now a 'stand-...
Definition: gnunet_fs_service.h:717
GNUNET_FS_DownloadContext::search
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none.
Definition: fs_api.h:1770
GNUNET_FS_DownloadContext::serialization
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1816
GNUNET_FS_DownloadContext::h
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1748
GNUNET_FS_DownloadContext::top
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1753

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, pi, sc, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_DownloadContext::top, 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:

◆ search_result_free()

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

Free the given search result.

Parameters
clsthe global FS handle
keythe key for the search result (unused)
valuethe search result to free
Returns
GNUNET_OK

Definition at line 1737 of file fs_search.c.

1740 {
1741  struct GNUNET_FS_SearchResult *sr = value;
1742 
1743  if (NULL != sr->update_search)
1744  {
1745  GNUNET_FS_search_stop (sr->update_search);
1746  GNUNET_assert (NULL == sr->update_search);
1747  }
1748  GNUNET_break (NULL == sr->probe_ctx);
1749  GNUNET_break (NULL == sr->probe_cancel_task);
1750  GNUNET_break (NULL == sr->client_info);
1751  GNUNET_free (sr->serialization);
1752  GNUNET_FS_uri_destroy (sr->uri);
1753  GNUNET_FS_meta_data_destroy (sr->meta);
1754  GNUNET_free (sr->keyword_bitmap);
1755  GNUNET_free (sr);
1756  return GNUNET_OK;
1757 }
GNUNET_FS_search_stop
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1766

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: