GNUnet 0.21.1
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_SearchResultGNUNET_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_SearchContextsearch_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_SearchContextGNUNET_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
61 pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
62 pi->value.search.duration = (NULL != sc)
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}
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int ret
Final status code.
Definition: gnunet-arm.c:94
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
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
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
union GNUNET_FS_ProgressInfo::@21 value
Values that depend on the event type.
struct GNUNET_FS_ProgressInfo::@21::GNUNET_FS_SearchStatusEvent search
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1541
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
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1588
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1525
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1570
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_FS_ProgressInfo::fsh, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_ZERO, h, GNUNET_FS_SearchContext::psearch_result, ret, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchContext::start_time, GNUNET_FS_SearchContext::uri, and GNUNET_FS_ProgressInfo::value.

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_result_present()

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

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

Parameters
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
92 return GNUNET_SYSERR;
93 return GNUNET_OK;
94}
static char * value
Value of the record to add/remove.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
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_SYSERR
Information we store for each search result.
Definition: fs_api.h:499
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:524
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167

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

Referenced by process_ksk_result(), and process_sks_result().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_client_chk_result()

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

We've found a new CHK result.

Let the client know about it.

Parameters
scthe search context
srthe specific result

Definition at line 105 of file fs_search.c.

107{
108 struct GNUNET_FS_ProgressInfo pi;
109
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;
116}
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
This search has yielded a result.
Argument given to the progress callback with information about what is going on.
enum GNUNET_FS_Status status
Specific status code (determines the event type).
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1515
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:602
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, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by process_ksk_result(), and process_sks_result().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_client_chk_update()

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

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

Let the client know about it.

Parameters
scthe search context
srthe specific result

Definition at line 127 of file fs_search.c.

129{
130 struct GNUNET_FS_ProgressInfo pi;
131
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 =
138 pi.value.search.specifics.update.availability_certainty =
140 pi.value.search.specifics.update.applicability_rank = sr->optional_support;
141 pi.value.search.specifics.update.current_probe_time
144}
@ GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:613
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:607
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, GNUNET_FS_SearchResult::probe_active_time, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by process_ksk_result().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_result_present()

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

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

Parameters
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}
Context for "get_result_present".
Definition: fs_search.c:151
const struct GNUNET_FS_Uri * uri
The URI we're looking for.
Definition: fs_search.c:155
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
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
206 pi.value.search.specifics.update.availability_certainty
208 pi.value.search.specifics.update.applicability_rank = sr->optional_support;
209 pi.value.search.specifics.update.current_probe_time
211 sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc);
213}
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:431
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:503
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, GNUNET_FS_SearchResult::probe_active_time, GNUNET_FS_SearchResult::sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ probe_failure_handler()

static void probe_failure_handler ( void *  cls)
static

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

Parameters
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;
229 sr->probe_ctx = NULL;
233 "Probe #%u for search result %p failed\n",
235 sr);
237}
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
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
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
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:2253
#define GNUNET_log(kind,...)
@ GNUNET_YES
@ GNUNET_ERROR_TYPE_DEBUG
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
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;
254 sr->probe_ctx = NULL;
258 "Probe #%u for search result %p succeeded\n",
260 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 {
290 /* ignore */
291 break;
293 /* probes should never be resumed */
294 GNUNET_assert (0);
295 break;
297 /* probes should never be suspended */
298 GNUNET_break (0);
299 break;
301 /* ignore */
302 break;
304 if (NULL != sr->probe_cancel_task)
305 {
307 sr->probe_cancel_task = NULL;
308 }
312 break;
314 if (NULL != sr->probe_cancel_task)
315 {
317 sr->probe_cancel_task = NULL;
318 }
321 break;
323 if (NULL != sr->probe_cancel_task)
324 {
326 sr->probe_cancel_task = NULL;
327 }
328 sr = NULL;
329 break;
331 if (NULL == sr->probe_cancel_task)
332 {
337 }
338 break;
340 if (NULL != sr->probe_cancel_task)
341 {
343 sr->probe_cancel_task = NULL;
344 }
352 break;
353
354 default:
355 GNUNET_break (0);
356 return NULL;
357 }
358 return sr;
359}
static void probe_success_handler(void *cls)
Handle the case where we have gotten a response for our probe.
Definition: fs_search.c:246
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
#define info
@ GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
Notification that this download is no longer actively being pursued (back in the queue).
@ GNUNET_FS_STATUS_DOWNLOAD_ERROR
Notification that this download encountered an error.
@ GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
Notification that this download completed.
@ GNUNET_FS_STATUS_DOWNLOAD_RESUME
Notification that this download is being resumed.
@ GNUNET_FS_STATUS_DOWNLOAD_SUSPEND
Notification that this download was suspended.
@ GNUNET_FS_STATUS_DOWNLOAD_START
Notification that we have started this download.
@ GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
Notification about progress with this download.
@ GNUNET_FS_STATUS_DOWNLOAD_ACTIVE
Notification that this download is now actively being pursued (as opposed to waiting in the queue).
@ GNUNET_FS_STATUS_DOWNLOAD_STOPPED
Notification that this download was stopped (final event with respect to this action).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
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:1305
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:1278
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
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:584
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.

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)
377 h->probe_ping_task
380 h);
381}
static void probe_ping_task_cb(void *cls)
Task run periodically to remind clients that a probe is active.
Definition: fs_search.c:368
#define GNUNET_FS_PROBE_UPDATE_FREQUENCY
How often do we signal applications that a probe for a particular search result is running?...
Master context for most FS operations.
Definition: fs_api.h:1070

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

Referenced by probe_ping_task_cb(), and start_probe_ping_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ start_probe_ping_task()

static void start_probe_ping_task ( struct GNUNET_FS_SearchResult sr)
static

Start the ping task for this search result.

Parameters
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
400 h);
401}
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.

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}
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.

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;
443 return;
444 if ( (GNUNET_FS_URI_CHK != sr->uri->type) &&
445 (GNUNET_FS_URI_LOC != sr->uri->type) )
446 return;
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)
455 off *= DBLOCK_SIZE;
456 if (len - off < DBLOCK_SIZE)
457 len = len - off;
458 else
459 len = DBLOCK_SIZE;
461 "Starting probe #%u (at offset %llu) for search result %p\n",
462 sr->availability_trials + 1,
463 (unsigned long long) off,
464 sr);
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,
473 | GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
475}
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:41
@ GNUNET_FS_URI_LOC
Location (chk with identity of hosting peer).
Definition: fs_api.h:159
@ GNUNET_FS_URI_CHK
Content-hash-key (simple file).
Definition: fs_api.h:144
#define AVAILABILITY_TRIALS_MAX
Number of availability trials we perform per search result.
Definition: fs_search.c:37
static void start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
Start the ping task for this search result.
Definition: fs_search.c:390
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
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
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:2099
@ GNUNET_FS_FLAGS_DO_PROBES
Should we automatically trigger probes for search results to determine availability?...
@ GNUNET_FS_DOWNLOAD_IS_PROBE
Internal option used to flag this download as a 'probe' for a search result.
@ GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
Do not append temporary data to the target file (for the IBlocks).
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
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1162
struct GNUNET_TIME_Relative avg_block_latency
Average time we take for a single request to be satisfied.
Definition: fs_api.h:1147
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:546
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:589
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, 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 {
521 sr->probe_ctx = NULL;
523 }
524 if (NULL != sr->probe_cancel_task)
525 {
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 !=
580 &key))
581 {
582 GNUNET_break_op (0);
583 return;
584 }
585 if (GNUNET_SYSERR ==
587 &key,
589 (void *) uri))
590 return; /* duplicate result */
591 /* try to find search result in master map */
592 grc.sr = NULL;
593 grc.uri = uri;
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 {
602 sr->h = sc->h;
603 sr->sc = sc;
608 sr->key = key;
610 / 8); /* round up, count bits */
613 }
614 else
615 {
617 }
620 &sr->key,
621 sr,
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 */
630 {
631 if (ent->mandatory)
632 {
635 }
636 else
637 {
639 }
640 }
641 if (0 != sr->mandatory_missing)
642 {
643 GNUNET_break (NULL == sr->client_info);
644 return;
645 }
646 if (is_new)
648 else
652}
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
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
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
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
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_FS_MetaData * meta
Meta-data provided via command-line option.
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:987
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
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ 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...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
void GNUNET_FS_meta_data_merge(struct GNUNET_FS_MetaData *md, const struct GNUNET_FS_MetaData *in)
Extend metadata.
Definition: meta_data.c:356
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_duplicate(const struct GNUNET_FS_MetaData *md)
Duplicate a MetaData token.
Definition: meta_data.c:527
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
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1565
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1593
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:562
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:567
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
union GNUNET_FS_Uri::@49 data
struct GNUNET_FS_Uri::@49::@50 ksk
unsigned int keywordCount
Size of the keywords array.
Definition: fs_api.h:191
A 512-bit hashcode.
int mandatory
Is this keyword a mandatory keyword (started with '+')?
Definition: fs_api.h:1503
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::keywordCount, GNUNET_FS_Uri::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, meta, GNUNET_FS_SearchResult::meta, notify_client_chk_result(), notify_client_chk_update(), GNUNET_FS_SearchResult::optional_support, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchResult::sc, GetResultContext::sr, test_result_present(), uri, GNUNET_FS_SearchResult::uri, GNUNET_FS_SearchContext::uri, and GetResultContext::uri.

Referenced by process_kblock().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ search_start()

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

Start search for content, internal API.

Parameters
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{
1342 struct GNUNET_FS_ProgressInfo pi;
1343
1345 sc->h = h;
1346 sc->options = options;
1350 if (NULL != psearch)
1351 {
1352 sc->psearch_result = psearch;
1353 psearch->update_search = sc;
1354 }
1356 sc->client_info = cctx;
1358 {
1361 GNUNET_free (sc);
1362 return NULL;
1363 }
1367 return sc;
1368}
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
void GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
Synchronize this search struct with its mirror on disk.
Definition: fs_api.c:2248
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
static unsigned int anonymity
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
@ GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_NO
#define GNUNET_free(ptr)
Wrapper around free.
void * cctx
Client context pointer (set the last time by the client for this operation; initially NULL on START/R...
Handle for controlling a search.
Definition: fs_api.h:1511
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1598
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 anonymity, GNUNET_FS_SearchContext::anonymity, GNUNET_FS_ProgressInfo::cctx, GNUNET_FS_SearchContext::client_info, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_FS_search_make_status_(), GNUNET_FS_search_start_searching_(), GNUNET_FS_search_sync_(), GNUNET_FS_STATUS_SEARCH_START, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get(), h, GNUNET_FS_SearchContext::h, GNUNET_FS_SearchContext::master_result_map, options, GNUNET_FS_SearchContext::options, GNUNET_FS_SearchContext::psearch_result, sc, GNUNET_FS_SearchContext::start_time, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::update_search, uri, and GNUNET_FS_SearchContext::uri.

Referenced by GNUNET_FS_search_start(), and process_sks_result().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_sks_result()

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

We have received an SKS result.

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

Parameters
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 !=
699 &key))
700 {
701 GNUNET_break (0);
702 return;
703 }
705 &uri->data.chk.chk.query,
706 &key);
707 if (GNUNET_SYSERR ==
710 (void *) uri))
711 return; /* duplicate result */
713 sr->h = sc->h;
714 sr->sc = sc;
715 sr->anonymity = sc->anonymity;
716 sr->uri = GNUNET_FS_uri_dup (uri);
718 sr->key = key;
723 /* notify client */
724 if (0 == sr->mandatory_missing)
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
Signed key space (file in namespace).
Definition: fs_api.h:149
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
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
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_HashCode key
Hash of the original content, used for encryption.
Definition: fs.h:59
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:64
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
struct GNUNET_FS_Uri::@49::@51 sks
struct GNUNET_CRYPTO_EcdsaPublicKey ns
Identifier of the namespace.
Definition: fs_api.h:199
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, FileIdentifier::chk, GNUNET_FS_Uri::chk, GNUNET_FS_SearchResult::client_info, GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash_xor(), GNUNET_free, GNUNET_FS_meta_data_duplicate(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_start_probe_(), GNUNET_FS_uri_dup(), GNUNET_FS_URI_SKS, GNUNET_FS_uri_to_key(), GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchContext::h, GNUNET_FS_Uri::identifier, key, ContentHashKey::key, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, meta, GNUNET_FS_SearchResult::meta, notify_client_chk_result(), GNUNET_FS_Uri::ns, GNUNET_FS_SearchContext::options, ContentHashKey::query, sc, GNUNET_FS_SearchResult::sc, search_start(), GNUNET_FS_Uri::sks, test_result_present(), GNUNET_FS_Uri::type, uri, GNUNET_FS_SearchResult::uri, and GNUNET_FS_SearchContext::uri.

Referenced by process_sblock().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ decrypt_block_with_keyword()

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

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

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

Parameters
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 */
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}
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.
static char * data
The data to insert into the dht.
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:497
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
Private ECC key encoded for transmission.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to 'uquery'.
Definition: fs_api.h:1481
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1487

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

Referenced by process_kblock().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_kblock()

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

Process a keyword search result.

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

Parameters
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 */
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)
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 */
846 return;
847 }
849 &sc->requests[i],
850 uri,
851 meta);
852
853 /* clean up */
856}
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
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
#define GNUNET_FS_VERSION
Version number of the implementation.
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_ERROR_TYPE_ERROR
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_create(void)
Create a fresh meta data container.
Definition: meta_data.c:127
void GNUNET_FS_meta_data_destroy(struct GNUNET_FS_MetaData *md)
Free meta data.
Definition: meta_data.c:166
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
Definition: meta_data.c:885
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
Meta data to associate with a file, directory or namespace.
Definition: meta_data.c:92
universal block for keyword and namespace search results
Definition: block_fs.h:54
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,
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 {
901 _ ("Failed to parse URI `%s': %s\n"),
902 uris, emsg);
903 GNUNET_break_op (0); /* ublock malformed */
904 GNUNET_free (emsg);
906 return;
907 }
908 /* process */
910 /* clean up */
913}
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
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
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
char * identifier
Human-readable identifier chosen for this entry in the namespace.
Definition: fs_api.h:205

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

Referenced by handle_result().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ try_reconnect()

static void try_reconnect ( struct GNUNET_FS_SearchContext sc)
static

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

Parameters
scthe search to reconnec

Definition at line 1306 of file fs_search.c.

1307{
1308 if (NULL != sc->mq)
1309 {
1311 sc->mq = NULL;
1312 }
1314 sc->task =
1316 &do_reconnect,
1317 sc);
1318}
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1272
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
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
struct GNUNET_TIME_Relative reconnect_backoff
How long to wait before we try to reconnect to FS service?
Definition: fs_api.h:1575
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
957 cm->expiration)).rel_value_us > 0)
958 {
960 "Result received has already expired.\n");
961 return; /* result expired */
962 }
963 switch (type)
964 {
966 if (GNUNET_FS_URI_SKS == sc->uri->type)
968 (const struct UBlock *) &cm[1],
969 msize);
970 else
972 (const struct UBlock *) &cm[1],
973 msize);
974 break;
975
977 GNUNET_break (0);
978 break;
979
981 GNUNET_break (0);
982 break;
983
985 GNUNET_break (0);
986 break;
987
989 GNUNET_break (0);
990 break;
991
992 default:
994 _ ("Got result with unknown block type `%d', ignoring"),
995 type);
996 break;
997 }
998}
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
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
static uint32_t type
Type string converted to DNS type value.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_ERROR_TYPE_WARNING
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_FS_DBLOCK
Data block (leaf) in the CHK tree.
@ GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
@ GNUNET_BLOCK_TYPE_FS_IBLOCK
Inner block in the CHK tree.
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
@ GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
uint32_t type
Type of the block (in big endian).
Definition: fs.h:365
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:370
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
Definition: fs.h:360

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

Here is the call graph for this function:

◆ schedule_transmit_search_request()

static void schedule_transmit_search_request ( struct GNUNET_FS_SearchContext sc)
static

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

Parameters
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;
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! */
1138 &mbc);
1139 total_seen_results = mbc.put_cnt;
1140 }
1141 else
1142 {
1143 total_seen_results
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;
1157
1158 fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct
1160 todo = GNUNET_MIN (fit,
1161 left);
1163 sizeof(struct GNUNET_HashCode) * todo,
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
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;
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... */
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;
1204 &mbc);
1205 total_seen_results = mbc.put_cnt;
1206 }
1207 }
1208 }
1209 else
1210 {
1212
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;
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... */
1230 }
1231 else
1232 {
1233 sm->options = htonl (options);
1234 }
1235 }
1237 env);
1238 }
1239}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define SEARCH_MESSAGE_OPTION_NONE
No options.
Definition: fs.h:249
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:254
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:262
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
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
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
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.
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1324
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
Only search the local host, do not search remote systems (no P2P)
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
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_MIN(a, b)
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
#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
#define GNUNET_MESSAGE_TYPE_FS_START_SEARCH
Client asks FS service to start a (keyword) search.
The identity of the host (wraps the signing key of the peer).
Closure for build_result_set().
Definition: fs_search.c:1015
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search.
Definition: fs.h:270
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
uint32_t type
Type of the content that we're looking for.
Definition: fs.h:290
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
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:295
uint32_t options
Bitmask with options.
Definition: fs.h:285
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, GNUNET_FS_Uri::identifier, MessageBuilderContext::keyword_offset, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_Uri::ns, options, SearchMessage::options, GNUNET_FS_SearchContext::options, MessageBuilderContext::put_cnt, SearchMessage::query, GNUNET_FS_SearchContext::requests, sc, MessageBuilderContext::sc, SEARCH_MESSAGE_OPTION_CONTINUED, SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY, SEARCH_MESSAGE_OPTION_NONE, MessageBuilderContext::skip_cnt, GNUNET_FS_Uri::sks, SearchMessage::target, SearchMessage::type, SearchRequestEntry::uquery, GNUNET_FS_SearchContext::uri, and MessageBuilderContext::xoff.

Referenced by do_reconnect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ build_result_set()

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

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

Parameters
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}
unsigned int put_cnt
How many entries can we store to xoff.
Definition: fs_search.c:1019
struct GNUNET_HashCode * xoff
Where to store the keys.
Definition: fs_search.c:1029
unsigned int keyword_offset
Keyword offset the search result must match (0 for SKS)
Definition: fs_search.c:1039
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 {
1259 sc->mq = NULL;
1260 }
1261 try_reconnect (sc);
1262}
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;
1278 struct ClientPutMessage,
1279 sc),
1281 };
1282
1283 sc->task = NULL;
1285 "fs",
1286 handlers,
1288 sc);
1289 if (NULL == sc->mq)
1290 {
1291 try_reconnect (sc);
1292 return;
1293 }
1295}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
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
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
static int result
Global testing status.
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
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
Response from FS service with a result for a previous FS search.
Definition: fs.h:356
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1074
Message handler for a specific message type.

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))))
1393 &sr->key,
1394 sr,
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::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchContext::uri, and value.

Referenced by GNUNET_FS_search_start_searching_().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_start_searching_()

int GNUNET_FS_search_start_searching_ ( struct GNUNET_FS_SearchContext sc)

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

Parameters
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);
1412 {
1415 GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
1416 sc->requests
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);
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)
1436 }
1439 sc);
1440 }
1441 GNUNET_assert (NULL == sc->task);
1442 do_reconnect (sc);
1443 if (NULL == sc->mq)
1444 {
1446 sc->task = NULL;
1447 return GNUNET_SYSERR;
1448 }
1449 return GNUNET_OK;
1450}
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
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
char ** keywords
Keywords start with a '+' if they are mandatory (in which case the '+' is NOT part of the keyword) an...
Definition: fs_api.h:186
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::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchContext::task, update_sre_result_maps(), SearchRequestEntry::uquery, and GNUNET_FS_SearchContext::uri.

Referenced by deserialize_search(), and search_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ search_result_freeze_probes()

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

Freeze probes for the given search result.

Parameters
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 {
1471 sr->probe_ctx = NULL;
1473 }
1474 if (NULL != sr->probe_cancel_task)
1475 {
1477 sr->probe_cancel_task = NULL;
1478 }
1479 if (NULL != sr->update_search)
1481 return GNUNET_OK;
1482}
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
1501 if (NULL != sr->update_search)
1503 return GNUNET_OK;
1504}
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 {
1527 sr->download = NULL;
1528 }
1529 if (NULL != sr->update_search)
1530 {
1532 sr->update_search = NULL;
1533 }
1535 if (0 == sr->mandatory_missing)
1536 {
1537 /* client is aware of search result, notify about suspension event */
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;
1543 }
1544 GNUNET_break (NULL == sr->client_info);
1549 GNUNET_free (sr);
1550 return GNUNET_OK;
1551}
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:1952
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
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
Event generated for each search result when the respective search is suspended.
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, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchResult::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchResult::uri, value, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_signal_suspend_().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_signal_suspend_()

void GNUNET_FS_search_signal_suspend_ ( void *  cls)

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

Parameters
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
1566 GNUNET_break (NULL == sc->client_info);
1567 if (sc->task != NULL)
1568 {
1570 sc->task = NULL;
1571 }
1572 if (NULL != sc->mq)
1573 {
1575 sc->mq = NULL;
1576 }
1578 if (NULL != sc->requests)
1579 {
1581 for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1582 {
1585 }
1586 }
1588 GNUNET_free (sc->emsg);
1591 GNUNET_free (sc);
1592}
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:402
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
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1551
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1546
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::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, search_result_suspend(), GNUNET_FS_SearchContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchContext::task, GNUNET_FS_SearchContext::top, and GNUNET_FS_SearchContext::uri.

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ search_result_stop()

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

Signal stop for the given search result.

Parameters
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
1691 if (NULL != sr->download)
1692 {
1693 sr->download->search = NULL;
1694 sr->download->top
1697 sr->download);
1698 if (NULL != sr->download->serialization)
1699 {
1702 sr->download->serialization);
1704 sr->download->serialization = NULL;
1705 }
1708 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 }
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;
1724 return GNUNET_OK;
1725}
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:2036
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
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
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
#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
Event generated for each search result when the respective search is stopped.
@ GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT
Notification that this download is no longer part of a recursive download or search but now a 'stand-...
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none.
Definition: fs_api.h:1770
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1816
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1748
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, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_DownloadContext::top, GNUNET_FS_SearchResult::uri, value, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ search_result_free()

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

Free the given search result.

Parameters
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 {
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);
1755 GNUNET_free (sr);
1756 return GNUNET_OK;
1757}
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: