GNUnet  0.10.x
Data Structures | Macros | Functions
fs_search.c File Reference

Helper functions for searching. More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_fs_service.h"
#include "gnunet_protocols.h"
#include "fs_api.h"
#include "fs_publish_ublock.h"
Include dependency graph for fs_search.c:

Go to the source code of this file.

Data Structures

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

Macros

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

Functions

void * GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
 Fill in all of the generic fields for a search event and call the callback. More...
 
static int test_result_present (void *cls, const struct GNUNET_HashCode *key, void *value)
 Check if the given result is identical to the given URI. More...
 
static void notify_client_chk_result (struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
 We've found a new CHK result. More...
 
static void notify_client_chk_update (struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
 We've found new information about an existing CHK result. More...
 
static int get_result_present (void *cls, const struct GNUNET_HashCode *key, void *value)
 Check if the given result is identical to the given URI and if so return it. More...
 
static void signal_probe_result (struct GNUNET_FS_SearchResult *sr)
 Signal result of last probe to client and then schedule next probe. More...
 
static void probe_failure_handler (void *cls)
 Handle the case where we have failed to receive a response for our probe. More...
 
static void probe_success_handler (void *cls)
 Handle the case where we have gotten a response for our probe. More...
 
void * GNUNET_FS_search_probe_progress_ (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 Notification of FS that a search probe has made progress. More...
 
static void probe_ping_task_cb (void *cls)
 Task run periodically to remind clients that a probe is active. More...
 
static void start_probe_ping_task (struct GNUNET_FS_SearchResult *sr)
 Start the ping task for this search result. More...
 
void GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr)
 Stop the ping task for this search result. More...
 
void GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 Start download probes for the given search result. More...
 
struct GNUNET_FS_SearchResultGNUNET_FS_probe (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_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_CONTAINER_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_CONTAINER_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 36 of file fs_search.c.

Referenced by GNUNET_FS_search_start_probe_().

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 48 of file fs_search.c.

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, GNUNET_FS_SearchContext::psearch_result, ret, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchContext::start_time, GNUNET_FS_Handle::upcb, GNUNET_FS_Handle::upcb_cls, 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().

51 {
52  void *ret;
53 
54  pi->value.search.sc = sc;
55  pi->value.search.cctx = (NULL != sc) ? sc->client_info : NULL;
56  pi->value.search.pctx =
57  ((NULL == sc) || (NULL == sc->psearch_result))
58  ? NULL
60  pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
61  pi->value.search.duration = (NULL != sc)
64  pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
65  pi->fsh = h;
66  ret = h->upcb(h->upcb_cls, pi);
67  return ret;
68 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
struct GNUNET_FS_ProgressInfo::@28::@31 search
Values for all "GNUNET_FS_STATUS_SEARCH_*" events.
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:1512
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1551
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1506
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1569
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1070
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:373
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1075
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1522
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 82 of file fs_search.c.

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().

85 {
86  const struct GNUNET_FS_Uri *uri = cls;
87  struct GNUNET_FS_SearchResult *sr = value;
88 
89  if (GNUNET_FS_uri_test_equal(uri, sr->uri))
90  return GNUNET_SYSERR;
91  return GNUNET_OK;
92 }
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:1209
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:162
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 103 of file fs_search.c.

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, 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().

105 {
106  struct GNUNET_FS_ProgressInfo pi;
107 
109  pi.value.search.specifics.result.meta = sr->meta;
110  pi.value.search.specifics.result.uri = sr->uri;
111  pi.value.search.specifics.result.result = sr;
112  pi.value.search.specifics.result.applicability_rank = sr->optional_support;
114 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:587
This search has yielded a result.
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
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:48
Argument given to the progress callback with information about what is going on.
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 125 of file fs_search.c.

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, GNUNET_FS_ProgressInfo::search, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchResult::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by process_ksk_result().

127 {
128  struct GNUNET_FS_ProgressInfo pi;
129 
131  pi.value.search.specifics.update.cctx = sr->client_info;
132  pi.value.search.specifics.update.meta = sr->meta;
133  pi.value.search.specifics.update.uri = sr->uri;
134  pi.value.search.specifics.update.availability_rank =
136  pi.value.search.specifics.update.availability_certainty =
138  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
139  pi.value.search.specifics.update.current_probe_time
142 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:587
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:598
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:592
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
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:373
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:564
We have additional data about the quality or availability of a search result.
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:48
Argument given to the progress callback with information about what is going on.
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 173 of file fs_search.c.

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

Referenced by process_ksk_result().

176 {
177  struct GetResultContext *grc = cls;
178  struct GNUNET_FS_SearchResult *sr = value;
179 
180  if (GNUNET_FS_uri_test_equal(grc->uri, sr->uri))
181  grc->sr = sr;
182  return GNUNET_OK;
183 }
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
Context for "get_result_present".
Definition: fs_search.c:148
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:1209
struct GNUNET_FS_SearchResult * sr
Where to store a pointer to the search result struct if we found a match.
Definition: fs_search.c:158
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
const struct GNUNET_FS_Uri * uri
The URI we're looking for.
Definition: fs_search.c:152
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 193 of file fs_search.c.

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().

194 {
195  struct GNUNET_FS_ProgressInfo pi;
196 
198  pi.value.search.specifics.update.cctx = sr->client_info;
199  pi.value.search.specifics.update.meta = sr->meta;
200  pi.value.search.specifics.update.uri = sr->uri;
201  pi.value.search.specifics.update.availability_rank
203  pi.value.search.specifics.update.availability_certainty
204  = sr->availability_trials;
205  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
206  pi.value.search.specifics.update.current_probe_time
208  sr->client_info = GNUNET_FS_search_make_status_(&pi, sr->h, sr->sc);
210 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:587
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:504
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:598
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:592
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
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:373
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:564
We have additional data about the quality or availability of a search result.
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:48
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:435
Argument given to the progress callback with information about what is going on.
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 219 of file fs_search.c.

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, signal_probe_result(), and GetResultContext::sr.

Referenced by GNUNET_FS_search_probe_progress_().

220 {
221  struct GNUNET_FS_SearchResult *sr = cls;
222 
223  sr->probe_cancel_task = NULL;
224  sr->availability_trials++;
226  sr->probe_ctx = NULL;
230  "Probe #%u for search result %p failed\n",
232  sr);
234 }
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:193
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:525
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:598
Information we store for each search result.
Definition: fs_api.h:484
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:414
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2075
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:2332
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
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:559
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 243 of file fs_search.c.

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, signal_probe_result(), and GetResultContext::sr.

Referenced by GNUNET_FS_search_probe_progress_().

244 {
245  struct GNUNET_FS_SearchResult *sr = cls;
246 
247  sr->probe_cancel_task = NULL;
248  sr->availability_trials++;
249  sr->availability_success++;
251  sr->probe_ctx = NULL;
255  "Probe #%u for search result %p succeeded\n",
257  sr);
259 }
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:193
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:525
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:598
Information we store for each search result.
Definition: fs_api.h:484
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:592
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:414
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2075
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:2332
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
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:559
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 278 of file fs_search.c.

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

Referenced by GNUNET_FS_download_make_status_().

280 {
281  struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
282  struct GNUNET_TIME_Relative dur;
283 
284  switch (info->status)
285  {
287  /* ignore */
288  break;
289 
291  /* probes should never be resumed */
292  GNUNET_assert(0);
293  break;
294 
296  /* probes should never be suspended */
297  GNUNET_break(0);
298  break;
299 
301  /* ignore */
302  break;
303 
305  if (NULL != sr->probe_cancel_task)
306  {
308  sr->probe_cancel_task = NULL;
309  }
310  sr->probe_cancel_task =
312  &probe_failure_handler, sr);
313  break;
314 
316  if (NULL != sr->probe_cancel_task)
317  {
319  sr->probe_cancel_task = NULL;
320  }
321  sr->probe_cancel_task =
323  break;
324 
326  if (NULL != sr->probe_cancel_task)
327  {
329  sr->probe_cancel_task = NULL;
330  }
331  sr = NULL;
332  break;
333 
335  if (NULL == sr->probe_cancel_task)
336  {
338  sr->probe_cancel_task =
340  &probe_failure_handler, sr);
341  }
342  break;
343 
345  if (NULL != sr->probe_cancel_task)
346  {
348  sr->probe_cancel_task = NULL;
349  }
353  if (0 == sr->remaining_probe_time.rel_value_us)
354  sr->probe_cancel_task =
357  break;
358 
359  default:
360  GNUNET_break(0);
361  return NULL;
362  }
363  return sr;
364 }
Notification that we have started this download.
uint64_t rel_value_us
The actual value.
Notification that this download was suspended.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
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:219
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Notification that this download completed.
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:1237
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:569
Information we store for each search result.
Definition: fs_api.h:484
static void probe_success_handler(void *cls)
Handle the case where we have gotten a response for our probe.
Definition: fs_search.c:243
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:1264
enum GNUNET_FS_Status status
Specific status code (determines the event type).
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2075
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:602
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Notification that this download is no longer actively being pursued (back in the queue).
Notification about progress with this download.
Notification that this download is now actively being pursued (as opposed to waiting in the queue)...
Notification that this download is being resumed.
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:373
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:564
Notification that this download was stopped (final event with respect to this action).
Notification that this download encountered an error.
Time for relative time used by GNUnet, in microseconds.
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:559
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 373 of file fs_search.c.

References GNUNET_FS_PROBE_UPDATE_FREQUENCY, GNUNET_SCHEDULER_add_delayed(), h, GNUNET_FS_DownloadContext::mq, GNUNET_FS_SearchResult::next, GNUNET_FS_SearchResult::probe_ctx, GNUNET_FS_Handle::probe_ping_task, GNUNET_FS_Handle::probes_head, signal_probe_result(), and GetResultContext::sr.

Referenced by start_probe_ping_task().

374 {
375  struct GNUNET_FS_Handle *h = cls;
376  struct GNUNET_FS_SearchResult *sr;
377 
378  for (sr = h->probes_head; NULL != sr; sr = sr->next)
379  if (NULL != sr->probe_ctx->mq)
381  h->probe_ping_task
384  h);
385 }
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:193
Master context for most FS operations.
Definition: fs_api.h:1056
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:525
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
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:1237
Information we store for each search result.
Definition: fs_api.h:484
#define GNUNET_FS_PROBE_UPDATE_FREQUENCY
How often do we signal applications that a probe for a particular search result is running...
struct GNUNET_FS_SearchResult * next
Kept in a DLL while probing.
Definition: fs_api.h:493
struct GNUNET_SCHEDULER_Task * probe_ping_task
Task we use to report periodically to the application that certain search probes (from probes_head) a...
Definition: fs_api.h:1127
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1110
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1736
static void probe_ping_task_cb(void *cls)
Task run periodically to remind clients that a probe is active.
Definition: fs_search.c:373
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 394 of file fs_search.c.

References GNUNET_CONTAINER_DLL_insert, GNUNET_SCHEDULER_add_now(), h, GNUNET_FS_SearchResult::h, GNUNET_FS_Handle::probe_ping_task, probe_ping_task_cb(), GNUNET_FS_Handle::probes_head, and GNUNET_FS_Handle::probes_tail.

Referenced by GNUNET_FS_search_start_probe_().

395 {
396  struct GNUNET_FS_Handle *h = sr->h;
397 
399  h->probes_tail,
400  sr);
401  if (NULL == h->probe_ping_task)
402  h->probe_ping_task
404  h);
405 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Master context for most FS operations.
Definition: fs_api.h:1056
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
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:1264
struct GNUNET_SCHEDULER_Task * probe_ping_task
Task we use to report periodically to the application that certain search probes (from probes_head) a...
Definition: fs_api.h:1127
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1110
struct GNUNET_FS_SearchResult * probes_tail
Tail of active probes.
Definition: fs_api.h:1115
static void probe_ping_task_cb(void *cls)
Task run periodically to remind clients that a probe is active.
Definition: fs_search.c:373
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 414 of file fs_search.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_cancel(), h, GNUNET_FS_SearchResult::h, GNUNET_FS_Handle::probe_ping_task, GNUNET_FS_Handle::probes_head, and GNUNET_FS_Handle::probes_tail.

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

415 {
416  struct GNUNET_FS_Handle *h = sr->h;
417 
419  h->probes_tail,
420  sr);
421  if (NULL == h->probes_head)
422  {
424  h->probe_ping_task = NULL;
425  }
426 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Master context for most FS operations.
Definition: fs_api.h:1056
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
struct GNUNET_SCHEDULER_Task * probe_ping_task
Task we use to report periodically to the application that certain search probes (from probes_head) a...
Definition: fs_api.h:1127
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1110
struct GNUNET_FS_SearchResult * probes_tail
Tail of active probes.
Definition: fs_api.h:1115
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 435 of file fs_search.c.

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

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

436 {
437  uint64_t off;
438  uint64_t len;
439 
440  if (NULL != sr->probe_ctx)
441  return;
442  if (NULL != sr->download)
443  return;
444  if (0 == (sr->h->flags & GNUNET_FS_FLAGS_DO_PROBES))
445  return;
447  return;
448  if ((GNUNET_FS_URI_CHK != sr->uri->type) && (GNUNET_FS_URI_LOC != sr->uri->type))
449  return;
451  if (0 == len)
452  return;
453  if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
454  return;
455  off = len / DBLOCK_SIZE;
456  if (off > 0)
458  off *= DBLOCK_SIZE;
459  if (len - off < DBLOCK_SIZE)
460  len = len - off;
461  else
462  len = DBLOCK_SIZE;
464  "Starting probe #%u (at offset %llu) for search result %p\n",
465  sr->availability_trials + 1,
466  (unsigned long long)off,
467  sr);
470  2 * (1 + sr->availability_trials));
471  sr->probe_ctx =
472  GNUNET_FS_download_start(sr->h, sr->uri, sr->meta, NULL, NULL, off,
473  len, sr->anonymity,
475  GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
477 }
static void start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
Start the ping task for this search result.
Definition: fs_search.c:394
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:531
struct GNUNET_TIME_Relative avg_block_latency
Average time we take for a single request to be satisfied.
Definition: fs_api.h:1133
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results&#39; availability (NULL if we are not currently probin...
Definition: fs_api.h:525
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_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:2145
Do not append temporary data to the target file (for the IBlocks).
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:569
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:598
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
Should we automatically trigger probes for search results to determine availability? (will create GNUNET_FS_STATUS_SEARCH_UPDATE events).
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:592
Internal option used to flag this download as a &#39;probe&#39; for a search result.
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:574
#define AVAILABILITY_TRIALS_MAX
Number of availability trials we perform per search result.
Definition: fs_search.c:36
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
Content-hash-key (simple file).
Definition: fs_api.h:140
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:166
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:1368
#define GNUNET_log(kind,...)
Location (chk with identity of hosting peer).
Definition: fs_api.h:155
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:499
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1148
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 518 of file fs_search.c.

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().

519 {
520  if (NULL != sr->probe_ctx)
521  {
523  sr->probe_ctx = NULL;
525  }
526  if (NULL != sr->probe_cancel_task)
527  {
529  sr->probe_cancel_task = NULL;
530  }
531 }
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results&#39; availability (NULL if we are not currently probin...
Definition: fs_api.h:525
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:414
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:2332
#define GNUNET_YES
Definition: gnunet_common.h:77
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:559
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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_CONTAINER_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 567 of file fs_search.c.

References anonymity, 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_meta_data_duplicate(), GNUNET_CONTAINER_meta_data_merge(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, 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, h, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchContext::h, key, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::keyword_bitmap, GNUNET_FS_Uri::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchResult::meta, notify_client_chk_result(), notify_client_chk_update(), GNUNET_FS_SearchResult::optional_support, options, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, GNUNET_FS_SearchResult::sc, search_start(), GetResultContext::sr, test_result_present(), GetResultContext::uri, GNUNET_FS_SearchResult::uri, and GNUNET_FS_SearchContext::uri.

Referenced by process_kblock().

571 {
572  struct GNUNET_HashCode key;
573  struct GNUNET_FS_SearchResult *sr;
574  struct GetResultContext grc;
575  int is_new;
576  unsigned int koff;
577 
578  /* check if new */
579  GNUNET_assert(NULL != sc);
580  if (GNUNET_OK !=
582  &key))
583  {
584  GNUNET_break_op(0);
585  return;
586  }
587  if (GNUNET_SYSERR ==
589  &key,
591  (void *)uri))
592  return; /* duplicate result */
593  /* try to find search result in master map */
594  grc.sr = NULL;
595  grc.uri = uri;
597  &key,
598  &get_result_present, &grc);
599  sr = grc.sr;
600  is_new = (NULL == sr) || (sr->mandatory_missing > 0);
601  if (NULL == sr)
602  {
603  sr = GNUNET_new(struct GNUNET_FS_SearchResult);
604  sr->h = sc->h;
605  sr->sc = sc;
606  sr->anonymity = sc->anonymity;
607  sr->uri = GNUNET_FS_uri_dup(uri);
610  sr->key = key;
611  sr->keyword_bitmap = GNUNET_malloc((sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
614  }
615  else
616  {
618  }
621  &sr->key,
622  sr,
624 
625  koff = ent - sc->requests;
626  GNUNET_assert((ent >= sc->requests) &&
627  (koff < sc->uri->data.ksk.keywordCount));
628  sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8));
629  /* check if mandatory satisfied */
631  {
632  if (ent->mandatory)
633  {
635  sr->mandatory_missing--;
636  }
637  else
638  {
639  sr->optional_support++;
640  }
641  }
642  if (0 != sr->mandatory_missing)
643  {
644  GNUNET_break(NULL == sr->client_info);
645  return;
646  }
647  if (is_new)
648  notify_client_chk_result(sc, sr);
649  else
650  notify_client_chk_update(sc, sr);
653 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:587
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1574
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
static void notify_client_chk_result(struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
We&#39;ve found a new CHK result.
Definition: fs_search.c:103
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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:504
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:547
int mandatory
Is this keyword a mandatory keyword (started with &#39;+&#39;)?
Definition: fs_api.h:1485
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
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:82
Context for "get_result_present".
Definition: fs_search.c:148
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:173
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:995
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
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:103
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1569
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
struct GNUNET_FS_SearchResult * sr
Where to store a pointer to the search result struct if we found a match.
Definition: fs_search.c:158
void GNUNET_CONTAINER_meta_data_merge(struct GNUNET_CONTAINER_MetaData *md, const struct GNUNET_CONTAINER_MetaData *in)
Extend metadata.
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:1540
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Information we store for each search result.
Definition: fs_api.h:484
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2075
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:1479
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:574
A 512-bit hashcode.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
int 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.
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:552
Allow multiple values with the same key.
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:581
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
static void notify_client_chk_update(struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
We&#39;ve found new information about an existing CHK result.
Definition: fs_search.c:125
#define GNUNET_malloc(size)
Wrapper around malloc.
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:435
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData *md)
Duplicate a MetaData token.
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 1325 of file fs_search.c.

References anonymity, GNUNET_FS_ProgressInfo::cctx, 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::master_result_map, options, sc, GNUNET_FS_ProgressInfo::status, and GNUNET_FS_SearchResult::update_search.

Referenced by GNUNET_FS_search_start(), process_ksk_result(), and process_sks_result().

1331 {
1332  struct GNUNET_FS_SearchContext *sc;
1333  struct GNUNET_FS_ProgressInfo pi;
1334 
1335  sc = GNUNET_new(struct GNUNET_FS_SearchContext);
1336  sc->h = h;
1337  sc->options = options;
1338  sc->uri = GNUNET_FS_uri_dup(uri);
1339  sc->anonymity = anonymity;
1340  sc->start_time = GNUNET_TIME_absolute_get();
1341  if (NULL != psearch)
1342  {
1343  sc->psearch_result = psearch;
1344  psearch->update_search = sc;
1345  }
1347  sc->client_info = cctx;
1349  {
1350  GNUNET_FS_uri_destroy(sc->uri);
1351  GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map);
1352  GNUNET_free(sc);
1353  return NULL;
1354  }
1357  sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
1358  return sc;
1359 }
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:2166
First event generated when a client requests a search to begin or when a namespace result automatical...
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:995
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
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:537
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:1540
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
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:1400
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Handle for controlling a search.
Definition: fs_api.h:1492
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static unsigned int anonymity
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:48
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
void * cctx
Client context pointer (set the last time by the client for this operation; initially NULL on START/R...
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_CONTAINER_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 687 of file fs_search.c.

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

Referenced by process_sblock().

691 {
692  struct GNUNET_FS_Uri uu;
693  struct GNUNET_HashCode key;
694  struct GNUNET_FS_SearchResult *sr;
695 
696  /* check if new */
697  GNUNET_assert(NULL != sc);
698  if (GNUNET_OK !=
700  &key))
701  {
702  GNUNET_break(0);
703  return;
704  }
706  &uri->data.chk.chk.query,
707  &key);
708  if (GNUNET_SYSERR ==
711  (void *)uri))
712  return; /* duplicate result */
713  sr = GNUNET_new(struct GNUNET_FS_SearchResult);
714  sr->h = sc->h;
715  sr->sc = sc;
716  sr->anonymity = sc->anonymity;
717  sr->uri = GNUNET_FS_uri_dup(uri);
719  sr->key = key;
724  /* notify client */
725  if (0 == sr->mandatory_missing)
726  notify_client_chk_result(sc, sr);
727  else
728  GNUNET_break(NULL == sr->client_info);
729  /* search for updates */
730  if (0 == strlen(id_update))
731  return; /* no updates */
732  uu.type = GNUNET_FS_URI_SKS;
733  uu.data.sks.ns = sc->uri->data.sks.ns;
734  uu.data.sks.identifier = GNUNET_strdup(id_update);
735  (void)search_start(sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
736  GNUNET_free(uu.data.sks.identifier);
737 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:102
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:204
static void notify_client_chk_result(struct GNUNET_FS_SearchContext *sc, struct GNUNET_FS_SearchResult *sr)
We&#39;ve found a new CHK result.
Definition: fs_search.c:103
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1579
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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:504
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
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:82
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:995
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
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:103
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1569
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:1540
Information we store for each search result.
Definition: fs_api.h:484
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:62
union GNUNET_FS_Uri::@16 data
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2075
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:574
A 512-bit hashcode.
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
int 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.
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:552
Allow multiple values with the same key.
Signed key space (file in namespace).
Definition: fs_api.h:145
struct GNUNET_HashCode key
Hash of the original content, used for encryption.
Definition: fs.h:57
struct GNUNET_FS_Uri::@16::@18 sks
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:581
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:162
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
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:193
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:1325
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:435
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData *md)
Duplicate a MetaData token.
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 755 of file fs_search.c.

References 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::ksk, GNUNET_FS_SearchContext::requests, and GNUNET_FS_SearchContext::uri.

Referenced by process_kblock().

760 {
761  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
762  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
763  unsigned int i;
764 
765  /* find key */
766  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
767  if (0 == memcmp(dpub,
768  &sc->requests[i].dpub,
769  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
770  break;
771  if (i == sc->uri->data.ksk.keywordCount)
772  {
773  /* oops, does not match any of our keywords!? */
774  GNUNET_break(0);
775  return GNUNET_SYSERR;
776  }
777  /* decrypt */
779  GNUNET_CRYPTO_ecdsa_key_get_public(anon, &anon_pub);
780  GNUNET_FS_ublock_decrypt_(edata, edata_size,
781  &anon_pub,
782  sc->requests[i].keyword,
783  data);
784  return i;
785 }
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:814
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to &#39;uquery&#39;.
Definition: fs_api.h:1463
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.
Private ECC key encoded for transmission.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:241
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
uint32_t data
The data value.
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1469
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 798 of file fs_search.c.

References _, decrypt_block_with_keyword(), GNUNET_break_op, GNUNET_CONTAINER_meta_data_create(), GNUNET_CONTAINER_meta_data_deserialize(), GNUNET_CONTAINER_meta_data_destroy(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free_non_null, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_parse(), GNUNET_FS_VERSION, GNUNET_log, meta, process_ksk_result(), GNUNET_FS_SearchContext::requests, GetResultContext::uri, and UBlock::verification_key.

Referenced by handle_result().

801 {
802  size_t j;
803  char pt[size - sizeof(struct UBlock)];
804  const char *eos;
806  struct GNUNET_FS_Uri *uri;
807  char *emsg;
808  int i;
809 
810  if (-1 == (i = decrypt_block_with_keyword(sc,
811  &ub->verification_key,
812  &ub[1],
813  size - sizeof(struct UBlock),
814  pt)))
815  return;
816  /* parse; pt[0] is just '\0', so we skip over that */
817  eos = memchr(&pt[1], '\0', sizeof(pt) - 1);
818  if (NULL == eos)
819  {
820  GNUNET_break_op(0);
821  return;
822  }
823  if (NULL == (uri = GNUNET_FS_uri_parse(&pt[1], &emsg)))
824  {
825  if (GNUNET_FS_VERSION > 0x00090400)
826  {
827  /* we broke this in 0x00090300, so don't bitch
828  too loudly just one version up... */
829  GNUNET_break_op(0); /* ublock malformed */
831  _("Failed to parse URI `%s': %s\n"),
832  &pt[1],
833  emsg);
834  }
835  GNUNET_free_non_null(emsg);
836  return;
837  }
838  j = eos - pt + 1;
839  if (sizeof(pt) == j)
841  else
842  meta = GNUNET_CONTAINER_meta_data_deserialize(&pt[j], sizeof(pt) - j);
843  if (NULL == meta)
844  {
845  GNUNET_break_op(0); /* ublock malformed */
847  return;
848  }
850  &sc->requests[i],
851  uri,
852  meta);
853 
854  /* clean up */
857 }
#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:641
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
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 &#39;keyword&#39; as the passphrase.
Definition: fs_search.c:755
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Meta data to associate with a file, directory or namespace.
static void process_ksk_result(struct GNUNET_FS_SearchContext *sc, struct SearchRequestEntry *ent, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta)
We have received a KSK result.
Definition: fs_search.c:567
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_create(void)
Create a fresh meta data container.
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
static unsigned int size
Size of the "table".
Definition: peer.c:66
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:162
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:64
universal block for keyword and namespace search results
Definition: block_fs.h:50
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 870 of file fs_search.c.

References _, GNUNET_FS_Uri::data, GNUNET_break_op, GNUNET_CONTAINER_meta_data_deserialize(), GNUNET_CONTAINER_meta_data_destroy(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free_non_null, GNUNET_FS_ublock_decrypt_(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_parse(), GNUNET_log, GNUNET_STRINGS_buffer_tokenize(), id, len, meta, process_sks_result(), sc, GNUNET_FS_Uri::sks, try_reconnect(), GetResultContext::uri, and GNUNET_FS_SearchContext::uri.

Referenced by handle_result().

873 {
874  size_t len = size - sizeof(struct UBlock);
875  char pt[len];
876  struct GNUNET_FS_Uri *uri;
878  const char *id;
879  const char *uris;
880  size_t off;
881  char *emsg;
882 
883  GNUNET_FS_ublock_decrypt_(&ub[1], len,
884  &sc->uri->data.sks.ns,
885  sc->uri->data.sks.identifier,
886  pt);
887  /* parse */
888  if (0 == (off = GNUNET_STRINGS_buffer_tokenize(pt, len, 2, &id, &uris)))
889  {
890  GNUNET_break_op(0); /* ublock malformed */
891  return;
892  }
893  if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize(&pt[off], len - 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_non_null(emsg);
906  return;
907  }
908  /* process */
909  process_sks_result(sc, id, uri, meta);
910  /* clean up */
913 }
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:641
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.
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
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:135
Meta data to associate with a file, directory or namespace.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
union GNUNET_FS_Uri::@16 data
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
static void process_sks_result(struct GNUNET_FS_SearchContext *sc, const char *id_update, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta)
We have received an SKS result.
Definition: fs_search.c:687
static unsigned int size
Size of the "table".
Definition: peer.c:66
struct GNUNET_FS_Uri::@16::@18 sks
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:162
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
#define GNUNET_log(kind,...)
universal block for keyword and namespace search results
Definition: block_fs.h:50
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 1297 of file fs_search.c.

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

Referenced by do_reconnect(), process_sblock(), and search_mq_error_handler().

1298 {
1299  if (NULL != sc->mq)
1300  {
1301  GNUNET_MQ_destroy(sc->mq);
1302  sc->mq = NULL;
1303  }
1305  sc->task =
1307  &do_reconnect,
1308  sc);
1309 }
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:1564
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1263
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:1237
struct GNUNET_TIME_Relative reconnect_backoff
How long to wait before we try to reconnect to FS service?
Definition: fs_api.h:1556
#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_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1517
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
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
msgresult message received

Definition at line 934 of file fs_search.c.

References GNUNET_OK.

936 {
937  /* payload of any variable size is OK */
938  return GNUNET_OK;
939 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ handle_result()

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

We process a search result from the service.

Parameters
clsclosure
msgresult message received

Definition at line 949 of file fs_search.c.

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, schedule_transmit_search_request(), GNUNET_MessageHeader::size, GNUNET_FS_Uri::type, type, ClientPutMessage::type, and GNUNET_FS_SearchContext::uri.

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  {
959  "Result received has already expired.\n");
960  return; /* result expired */
961  }
962  switch (type)
963  {
965  if (GNUNET_FS_URI_SKS == sc->uri->type)
966  process_sblock(sc,
967  (const struct UBlock *)&cm[1],
968  msize);
969  else
970  process_kblock(sc,
971  (const struct UBlock *)&cm[1],
972  msize);
973  break;
974 
976  GNUNET_break(0);
977  break;
978 
980  GNUNET_break(0);
981  break;
982 
984  GNUNET_break(0);
985  break;
986 
988  GNUNET_break(0);
989  break;
990 
991  default:
993  _("Got result with unknown block type `%d', ignoring"),
994  type);
995  break;
996  }
997 }
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:671
uint64_t rel_value_us
The actual value.
Any type of block, used as a wildcard when searching.
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
Definition: fs.h:350
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
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:870
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
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:798
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Type of a block representing a block to be encoded on demand from disk.
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:360
Inner block in the CHK tree.
Type of a block representing any type of search result (universal).
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:166
uint32_t type
Type of the block (in big endian).
Definition: fs.h:355
Signed key space (file in namespace).
Definition: fs_api.h:145
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:373
Handle for controlling a search.
Definition: fs_api.h:1492
#define GNUNET_log(kind,...)
Data block (leaf) in the CHK tree.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
universal block for keyword and namespace search results
Definition: block_fs.h:50
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 1106 of file fs_search.c.

References GNUNET_FS_SearchContext::anonymity, SearchMessage::anonymity_level, build_result_set(), GNUNET_FS_Uri::data, env, find_result_set(), GNUNET_assert, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_hash(), GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY, GNUNET_FS_uri_test_ksk(), GNUNET_FS_uri_test_sks(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, GNUNET_MIN, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, MessageBuilderContext::keyword_offset, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, options, SearchMessage::options, GNUNET_FS_SearchContext::options, MessageBuilderContext::put_cnt, SearchMessage::query, GNUNET_FS_SearchContext::requests, 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(), and handle_result().

1107 {
1108  struct MessageBuilderContext mbc;
1109  struct GNUNET_MQ_Envelope *env;
1110  struct SearchMessage *sm;
1111  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
1112  unsigned int total_seen_results; /* total number of result hashes to send */
1113  uint32_t options;
1114  unsigned int left;
1115  unsigned int todo;
1116  unsigned int fit;
1117  unsigned int search_request_map_offset;
1118  unsigned int keyword_offset;
1119  int first_call;
1120 
1121  memset(&mbc, 0, sizeof(mbc));
1122  mbc.sc = sc;
1123  if (GNUNET_FS_uri_test_ksk(sc->uri))
1124  {
1125  /* This will calculate the result set size ONLY for
1126  "keyword_offset == 0", so we will have to recalculate
1127  it for the other keywords later! */
1129  &find_result_set,
1130  &mbc);
1131  total_seen_results = mbc.put_cnt;
1132  }
1133  else
1134  {
1135  total_seen_results
1137  }
1138  search_request_map_offset = 0;
1139  keyword_offset = 0;
1140  first_call = GNUNET_YES;
1141  while ((0 != (left =
1142  (total_seen_results - search_request_map_offset))) ||
1143  (GNUNET_YES == first_call))
1144  {
1145  first_call = GNUNET_NO;
1146  options = SEARCH_MESSAGE_OPTION_NONE;
1149 
1150  fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct GNUNET_HashCode);
1151  todo = GNUNET_MIN(fit,
1152  left);
1153  env = GNUNET_MQ_msg_extra(sm,
1154  sizeof(struct GNUNET_HashCode) * todo,
1156  mbc.skip_cnt = search_request_map_offset;
1157  mbc.xoff = (struct GNUNET_HashCode *)&sm[1];
1158  sm->type = htonl(GNUNET_BLOCK_TYPE_FS_UBLOCK);
1159  sm->anonymity_level = htonl(sc->anonymity);
1160  memset(&sm->target,
1161  0,
1162  sizeof(struct GNUNET_PeerIdentity));
1163 
1164  if (GNUNET_FS_uri_test_ksk(sc->uri))
1165  {
1166  mbc.keyword_offset = keyword_offset;
1167  /* calculate how many results we can send in this message */
1168  mbc.put_cnt = todo;
1169  /* now build message */
1170  sm->query = sc->requests[keyword_offset].uquery;
1173  &mbc);
1174  search_request_map_offset += todo;
1175  GNUNET_assert(0 == mbc.put_cnt);
1176  GNUNET_assert(total_seen_results >= search_request_map_offset);
1177  if (total_seen_results != search_request_map_offset)
1178  {
1179  /* more requesting to be done... */
1180  sm->options = htonl(options | SEARCH_MESSAGE_OPTION_CONTINUED);
1181  }
1182  else
1183  {
1184  sm->options = htonl(options);
1185  keyword_offset++;
1186  if (sc->uri->data.ksk.keywordCount != keyword_offset)
1187  {
1188  /* more keywords => more requesting to be done... */
1189  first_call = GNUNET_YES;
1190  search_request_map_offset = 0;
1191  mbc.put_cnt = 0;
1192  mbc.keyword_offset = keyword_offset;
1194  &find_result_set,
1195  &mbc);
1196  total_seen_results = mbc.put_cnt;
1197  }
1198  }
1199  }
1200  else
1201  {
1203 
1205  sc->uri->data.sks.identifier,
1206  "fs-ublock",
1207  &dpub);
1208  GNUNET_CRYPTO_hash(&dpub,
1209  sizeof(dpub),
1210  &sm->query);
1211  mbc.put_cnt = todo;
1212  mbc.keyword_offset = 0;
1215  &mbc);
1216  GNUNET_assert(total_seen_results >= search_request_map_offset);
1217  if (total_seen_results != search_request_map_offset)
1218  {
1219  /* more requesting to be done... */
1220  sm->options = htonl(options | SEARCH_MESSAGE_OPTION_CONTINUED);
1221  }
1222  else
1223  {
1224  sm->options = htonl(options);
1225  }
1226  }
1227  GNUNET_MQ_send(sc->mq,
1228  env);
1229  }
1230 }
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1332
Closure for build_result_set().
Definition: fs_search.c:1013
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc.c:1340
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_HashCode uquery
Hash of the public key, also known as the query.
Definition: fs_api.h:1458
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1579
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t options
Bitmask with options.
Definition: fs.h:277
#define GNUNET_NO
Definition: gnunet_common.h:78
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1279
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:1084
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:299
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1569
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS...
Definition: fs.h:305
#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:52
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:1540
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
uint32_t type
Type of the content that we&#39;re looking for.
Definition: fs.h:282
Type of a block representing any type of search result (universal).
A 512-bit hashcode.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
#define GNUNET_MESSAGE_TYPE_FS_START_SEARCH
Client asks FS service to start a (keyword) search.
struct GNUNET_FS_Uri::@16::@18 sks
The identity of the host (wraps the signing key of the peer).
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1517
Only search the local host, do not search remote systems (no P2P)
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:255
#define GNUNET_YES
Definition: gnunet_common.h:77
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:351
#define SEARCH_MESSAGE_OPTION_NONE
No options.
Definition: fs.h:242
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:247
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:1051
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search...
Definition: fs.h:262
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:287
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 1051 of file fs_search.c.

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

Referenced by schedule_transmit_search_request().

1054 {
1055  struct MessageBuilderContext *mbc = cls;
1056  struct GNUNET_FS_SearchResult *sr = value;
1057 
1058  if ((NULL != sr->keyword_bitmap) &&
1059  (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))))
1060  return GNUNET_OK; /* have no match for this keyword yet */
1061  if (mbc->skip_cnt > 0)
1062  {
1063  mbc->skip_cnt--;
1064  return GNUNET_OK;
1065  }
1066  if (0 == mbc->put_cnt)
1067  return GNUNET_SYSERR;
1068  mbc->xoff[--mbc->put_cnt] = *key;
1069 
1070  return GNUNET_OK;
1071 }
Closure for build_result_set().
Definition: fs_search.c:1013
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:547
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
unsigned int keyword_offset
Keyword offset the search result must match (0 for SKS)
Definition: fs_search.c:1037
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
unsigned int put_cnt
How many entries can we store to xoff.
Definition: fs_search.c:1017
struct GNUNET_HashCode * xoff
Where to store the keys.
Definition: fs_search.c:1027
unsigned int skip_cnt
How many entries should we skip.
Definition: fs_search.c:1022
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 1084 of file fs_search.c.

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

Referenced by schedule_transmit_search_request().

1087 {
1088  struct MessageBuilderContext *mbc = cls;
1089  struct GNUNET_FS_SearchResult *sr = value;
1090 
1091  if ((NULL != sr->keyword_bitmap) &&
1092  (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))))
1093  return GNUNET_OK; /* have no match for this keyword yet */
1094  mbc->put_cnt++;
1095  return GNUNET_OK;
1096 }
Closure for build_result_set().
Definition: fs_search.c:1013
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:547
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
unsigned int keyword_offset
Keyword offset the search result must match (0 for SKS)
Definition: fs_search.c:1037
unsigned int put_cnt
How many entries can we store to xoff.
Definition: fs_search.c:1017
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 1242 of file fs_search.c.

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

Referenced by do_reconnect().

1244 {
1245  struct GNUNET_FS_SearchContext *sc = cls;
1246 
1247  if (NULL != sc->mq)
1248  {
1249  GNUNET_MQ_destroy(sc->mq);
1250  sc->mq = NULL;
1251  }
1252  try_reconnect(sc);
1253 }
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Handle for controlling a search.
Definition: fs_api.h:1492
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1517
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
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:1297
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 1263 of file fs_search.c.

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, GNUNET_FS_SearchContext::mq, result, 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().

1264 {
1265  struct GNUNET_FS_SearchContext *sc = cls;
1266  struct GNUNET_MQ_MessageHandler handlers[] = {
1269  struct ClientPutMessage,
1270  sc),
1272  };
1273 
1274  sc->task = NULL;
1275  sc->mq = GNUNET_CLIENT_connect(sc->h->cfg,
1276  "fs",
1277  handlers,
1279  sc);
1280  if (NULL == sc->mq)
1281  {
1282  try_reconnect(sc);
1283  return;
1284  }
1286 }
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:1564
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:900
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:1106
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static int result
Global testing status.
Message handler for a specific message type.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Response from FS service with a result for a previous FS search.
Definition: fs.h:346
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:1242
Handle for controlling a search.
Definition: fs_api.h:1492
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1517
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
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:1297
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1060
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 1372 of file fs_search.c.

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

Referenced by GNUNET_FS_search_start_searching_().

1375 {
1376  struct GNUNET_FS_SearchContext *sc = cls;
1377  struct GNUNET_FS_SearchResult *sr = value;
1378  unsigned int i;
1379 
1380  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1381  if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8))))
1384  &sr->key,
1385  sr,
1387 
1388  return GNUNET_YES;
1389 }
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:547
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
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:1479
There must only be one value per key; storing a value should fail if a value under the same key alrea...
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
int 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.
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:552
Handle for controlling a search.
Definition: fs_api.h:1492
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1400 of file fs_search.c.

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

Referenced by deserialize_search(), and search_start().

1401 {
1402  unsigned int i;
1403  const char *keyword;
1404  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
1405  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
1406  struct SearchRequestEntry *sre;
1407 
1408  GNUNET_assert(NULL == sc->mq);
1409  if (GNUNET_FS_uri_test_ksk(sc->uri))
1410  {
1411  GNUNET_assert(0 != sc->uri->data.ksk.keywordCount);
1413  GNUNET_CRYPTO_ecdsa_key_get_public(anon, &anon_pub);
1414  sc->requests
1415  = GNUNET_new_array(sc->uri->data.ksk.keywordCount,
1416  struct SearchRequestEntry);
1417 
1418  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1419  {
1420  keyword = &sc->uri->data.ksk.keywords[i][1];
1421  sre = &sc->requests[i];
1422  sre->keyword = GNUNET_strdup(keyword);
1424  keyword,
1425  "fs-ublock",
1426  &sre->dpub);
1427  GNUNET_CRYPTO_hash(&sre->dpub,
1428  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
1429  &sre->uquery);
1430  sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
1431  if (sre->mandatory)
1432  sc->mandatory_count++;
1434  }
1437  sc);
1438  }
1439  GNUNET_assert(NULL == sc->task);
1440  do_reconnect(sc);
1441  if (NULL == sc->mq)
1442  {
1444  sc->task = NULL;
1445  return GNUNET_SYSERR;
1446  }
1447  return GNUNET_OK;
1448 }
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1332
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:814
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc.c:1340
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:1564
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1574
struct GNUNET_HashCode uquery
Hash of the public key, also known as the query.
Definition: fs_api.h:1458
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to &#39;uquery&#39;.
Definition: fs_api.h:1463
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int mandatory
Is this keyword a mandatory keyword (started with &#39;+&#39;)?
Definition: fs_api.h:1485
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Private ECC key encoded for transmission.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1263
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:1540
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
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:1479
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:241
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1517
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static int update_sre_result_maps(void *cls, const struct GNUNET_HashCode *key, void *value)
Update the &#39;results&#39; map for the individual keywords with the results from the &#39;global&#39; result set...
Definition: fs_search.c:1372
Information we keep for each keyword in a keyword search.
Definition: fs_api.h:1454
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1469
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 1460 of file fs_search.c.

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, GetResultContext::sr, GNUNET_FS_SearchResult::update_search, and value.

Referenced by GNUNET_FS_search_pause().

1463 {
1464  struct GNUNET_FS_SearchResult *sr = value;
1465 
1466  if (NULL != sr->probe_ctx)
1467  {
1469  sr->probe_ctx = NULL;
1471  }
1472  if (NULL != sr->probe_cancel_task)
1473  {
1475  sr->probe_cancel_task = NULL;
1476  }
1477  if (NULL != sr->update_search)
1479  return GNUNET_OK;
1480 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results&#39; availability (NULL if we are not currently probin...
Definition: fs_api.h:525
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:537
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:414
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:2332
void GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc)
Pause search.
Definition: fs_search.c:1631
#define GNUNET_YES
Definition: gnunet_common.h:77
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:559
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 1492 of file fs_search.c.

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

Referenced by GNUNET_FS_search_continue().

1495 {
1496  struct GNUNET_FS_SearchResult *sr = value;
1497 
1499  if (NULL != sr->update_search)
1501  return GNUNET_OK;
1502 }
void GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc)
Continue paused search.
Definition: fs_search.c:1662
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:537
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:435
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 1514 of file fs_search.c.

References GNUNET_FS_SearchResult::client_info, GNUNET_FS_SearchResult::download, GNUNET_break, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_free, GNUNET_free_non_null, GNUNET_FS_download_signal_suspend_(), 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, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchResult::serialization, GetResultContext::sr, 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_().

1517 {
1518  struct GNUNET_FS_SearchContext *sc = cls;
1519  struct GNUNET_FS_SearchResult *sr = value;
1520  struct GNUNET_FS_ProgressInfo pi;
1521 
1522  if (NULL != sr->download)
1523  {
1525  sr->download = NULL;
1526  }
1527  if (NULL != sr->update_search)
1528  {
1530  sr->update_search = NULL;
1531  }
1533  if (0 == sr->mandatory_missing)
1534  {
1535  /* client is aware of search result, notify about suspension event */
1537  pi.value.search.specifics.result_suspend.cctx = sr->client_info;
1538  pi.value.search.specifics.result_suspend.meta = sr->meta;
1539  pi.value.search.specifics.result_suspend.uri = sr->uri;
1540  sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
1541  }
1542  GNUNET_break(NULL == sr->client_info);
1547  GNUNET_free(sr);
1548  return GNUNET_OK;
1549 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:531
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:547
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:537
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:1968
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
static void GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
Stop probing activity associated with a search result.
Definition: fs_search.c:518
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
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:581
Event generated for each search result when the respective search is suspended.
Handle for controlling a search.
Definition: fs_api.h:1492
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
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:48
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:542
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:1559
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
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 1559 of file fs_search.c.

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_free_non_null, GNUNET_FS_end_top(), GNUNET_FS_search_make_status_(), GNUNET_FS_STATUS_SEARCH_SUSPEND, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_test_ksk(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_FS_SearchContext::h, SearchRequestEntry::keyword, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, 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().

1560 {
1561  struct GNUNET_FS_SearchContext *sc = cls;
1562  struct GNUNET_FS_ProgressInfo pi;
1563  unsigned int i;
1564 
1565  GNUNET_FS_end_top(sc->h, sc->top);
1567  &search_result_suspend, sc);
1569  sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
1570  GNUNET_break(NULL == sc->client_info);
1571  if (sc->task != NULL)
1572  {
1574  sc->task = NULL;
1575  }
1576  if (NULL != sc->mq)
1577  {
1578  GNUNET_MQ_destroy(sc->mq);
1579  sc->mq = NULL;
1580  }
1582  if (NULL != sc->requests)
1583  {
1585  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1586  {
1588  GNUNET_free(sc->requests[i].keyword);
1589  }
1590  }
1595  GNUNET_free(sc);
1596 }
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1332
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:1564
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1501
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1532
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1546
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1506
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1527
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:1540
struct GNUNET_FS_Uri::@16::@17 ksk
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:412
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
union GNUNET_FS_Uri::@16 data
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:1479
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Handle for controlling a search.
Definition: fs_api.h:1492
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:1514
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1517
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
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:48
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1522
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1469
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 1686 of file fs_search.c.

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, GNUNET_FS_ProgressInfo::search, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::serialization, GetResultContext::sr, GNUNET_FS_ProgressInfo::status, GNUNET_FS_DownloadContext::top, GNUNET_FS_SearchResult::uri, value, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_stop().

1689 {
1690  struct GNUNET_FS_SearchContext *sc = cls;
1691  struct GNUNET_FS_SearchResult *sr = value;
1692  struct GNUNET_FS_ProgressInfo pi;
1693 
1695  if (NULL != sr->download)
1696  {
1697  sr->download->search = NULL;
1698  sr->download->top
1699  = GNUNET_FS_make_top(sr->download->h,
1701  sr->download);
1702  if (NULL != sr->download->serialization)
1703  {
1706  sr->download->serialization);
1708  sr->download->serialization = NULL;
1709  }
1712  sr->download);
1714  sr->download = NULL;
1715  }
1716  if (0 != sr->mandatory_missing)
1717  {
1718  /* client is unaware of search result as
1719  it does not match required keywords */
1720  GNUNET_break(NULL == sr->client_info);
1721  return GNUNET_OK;
1722  }
1724  pi.value.search.specifics.result_stopped.cctx = sr->client_info;
1725  pi.value.search.specifics.result_stopped.meta = sr->meta;
1726  pi.value.search.specifics.result_stopped.uri = sr->uri;
1727  sr->client_info = GNUNET_FS_search_make_status_(&pi, sr->h, sc);
1728  return GNUNET_OK;
1729 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:531
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1726
#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:71
Event generated for each search result when the respective search is stopped.
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:1971
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:103
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:1968
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1794
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:488
static void GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
Stop probing activity associated with a search result.
Definition: fs_search.c:518
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1731
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none...
Definition: fs_api.h:1748
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
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:391
Notification that this download is no longer part of a recursive download or search but now a &#39;stand-...
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:581
Handle for controlling a search.
Definition: fs_api.h:1492
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1496
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:48
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:743
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
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 1741 of file fs_search.c.

References GNUNET_FS_SearchResult::client_info, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_free, GNUNET_free_non_null, 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, GetResultContext::sr, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchResult::uri, and value.

Referenced by GNUNET_FS_search_stop().

1744 {
1745  struct GNUNET_FS_SearchResult *sr = value;
1746 
1747  if (NULL != sr->update_search)
1748  {
1750  GNUNET_assert(NULL == sr->update_search);
1751  }
1752  GNUNET_break(NULL == sr->probe_ctx);
1753  GNUNET_break(NULL == sr->probe_cancel_task);
1754  GNUNET_break(NULL == sr->client_info);
1759  GNUNET_free(sr);
1760  return GNUNET_OK;
1761 }
void * client_info
Client info for this search result.
Definition: fs_api.h:519
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:547
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:509
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results&#39; availability (NULL if we are not currently probin...
Definition: fs_api.h:525
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:537
static char * value
Value of the record to add/remove.
Information we store for each search result.
Definition: fs_api.h:484
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:514
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:542
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1770
#define GNUNET_free(ptr)
Wrapper around free.
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:559
Here is the call graph for this function:
Here is the caller graph for this function: