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_SearchResult * GNUNET_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_SearchContext * search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx, struct GNUNET_FS_SearchResult *psearch)
 Start search for content, internal API. More...
 
static void process_sks_result (struct GNUNET_FS_SearchContext *sc, const char *id_update, const struct GNUNET_FS_Uri *uri, const struct GNUNET_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_SearchContext * GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
 Start search for content. More...
 
void GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
 Pause search. More...
 
void GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
 Continue paused search. More...
 
static int search_result_stop (void *cls, const struct GNUNET_HashCode *key, void *value)
 Signal stop for the given search result. More...
 
static int search_result_free (void *cls, const struct GNUNET_HashCode *key, void *value)
 Free the given search result. More...
 
void GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
 Stop search for content. More...
 

Detailed Description

Helper functions for searching.

Author
Christian Grothoff

Definition in file fs_search.c.

Macro Definition Documentation

◆ AVAILABILITY_TRIALS_MAX

#define AVAILABILITY_TRIALS_MAX   8

Number of availability trials we perform per search result.

Definition at line 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
59  : sc->psearch_result->client_info;
60  pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
61  pi->value.search.duration = (NULL != sc)
62  ? GNUNET_TIME_absolute_get_duration (sc->start_time)
63  : GNUNET_TIME_UNIT_ZERO;
64  pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
65  pi->fsh = h;
66  ret = h->upcb (h->upcb_cls, pi);
67  return ret;
68 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_ProgressInfo::search
struct GNUNET_FS_ProgressInfo::@28::@31 search
Values for all "GNUNET_FS_STATUS_SEARCH_*" events.
GNUNET_FS_SearchContext::psearch_result
struct GNUNET_FS_SearchResult * psearch_result
For update-searches, link to the search result that triggered the update search; otherwise NULL...
Definition: fs_api.h:1554
GNUNET_FS_SearchContext::start_time
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1593
ret
static int ret
Final status code.
Definition: gnunet-arm.c:89
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1548
GNUNET_FS_SearchContext::anonymity
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1611
GNUNET_FS_ProgressInfo::value
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_TIME_UNIT_ZERO
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
Definition: gnunet_time_lib.h:97
GNUNET_FS_ProgressInfo::fsh
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
Definition: gnunet_fs_service.h:1588
GNUNET_FS_Handle::upcb
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1102
GNUNET_TIME_absolute_get_duration
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
GNUNET_FS_Handle::upcb_cls
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1107
GNUNET_FS_SearchContext::client_info
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1564
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 }
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_FS_uri_test_equal
int GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
Test if two URIs are equal.
Definition: fs_uri.c:1204
uri
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Definition: gnunet-publish.c:83
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_SYSERR
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
GNUNET_FS_Uri
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
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 
108  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT;
109  pi.value.search.specifics.result.meta = sr->meta;
110  pi.value.search.specifics.result.uri = sr->uri;
111  pi.value.search.specifics.result.result = sr;
112  pi.value.search.specifics.result.applicability_rank = sr->optional_support;
113  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
114 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_SearchResult::optional_support
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:616
GNUNET_FS_STATUS_SEARCH_RESULT
This search has yielded a result.
Definition: gnunet_fs_service.h:638
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
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 
130  pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
131  pi.value.search.specifics.update.cctx = sr->client_info;
132  pi.value.search.specifics.update.meta = sr->meta;
133  pi.value.search.specifics.update.uri = sr->uri;
134  pi.value.search.specifics.update.availability_rank =
135  2 * sr->availability_success - sr->availability_trials;
136  pi.value.search.specifics.update.availability_certainty =
137  sr->availability_trials;
138  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
139  pi.value.search.specifics.update.current_probe_time
140  = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
141  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
142 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_SearchResult::optional_support
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:616
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_FS_SearchResult::availability_trials
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
GNUNET_FS_SearchResult::availability_success
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:621
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_TIME_absolute_get_duration
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
GNUNET_FS_SearchResult::probe_active_time
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:593
GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
Definition: gnunet_fs_service.h:649
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
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 174 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().

177 {
178  struct GetResultContext *grc = cls;
179  struct GNUNET_FS_SearchResult *sr = value;
180 
181  if (GNUNET_FS_uri_test_equal (grc->uri, sr->uri))
182  grc->sr = sr;
183  return GNUNET_OK;
184 }
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
GetResultContext
Context for "get_result_present".
Definition: fs_search.c:148
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_FS_uri_test_equal
int GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
Test if two URIs are equal.
Definition: fs_uri.c:1204
GetResultContext::sr
struct GNUNET_FS_SearchResult * sr
Where to store a pointer to the search result struct if we found a match.
Definition: fs_search.c:159
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GetResultContext::uri
const struct GNUNET_FS_Uri * uri
The URI we're looking for.
Definition: fs_search.c:153
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 194 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().

195 {
196  struct GNUNET_FS_ProgressInfo pi;
197 
198  pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
199  pi.value.search.specifics.update.cctx = sr->client_info;
200  pi.value.search.specifics.update.meta = sr->meta;
201  pi.value.search.specifics.update.uri = sr->uri;
202  pi.value.search.specifics.update.availability_rank
203  = 2 * sr->availability_success - sr->availability_trials;
204  pi.value.search.specifics.update.availability_certainty
205  = sr->availability_trials;
206  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
207  pi.value.search.specifics.update.current_probe_time
208  = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
209  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc);
210  GNUNET_FS_search_start_probe_ (sr);
211 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_SearchResult::optional_support
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:616
GNUNET_FS_SearchResult::sc
struct GNUNET_FS_SearchContext * sc
Search context this result belongs to; can be NULL for probes that come from a directory result...
Definition: fs_api.h:533
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_FS_SearchResult::availability_trials
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
GNUNET_FS_SearchResult::availability_success
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:621
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_TIME_absolute_get_duration
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
GNUNET_FS_SearchResult::probe_active_time
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:593
GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
Definition: gnunet_fs_service.h:649
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_FS_search_start_probe_
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:427
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
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 220 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_().

221 {
222  struct GNUNET_FS_SearchResult *sr = cls;
223 
224  sr->probe_cancel_task = NULL;
225  sr->availability_trials++;
226  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
227  sr->probe_ctx = NULL;
228  GNUNET_FS_stop_probe_ping_task_ (sr);
229  GNUNET_FS_search_result_sync_ (sr);
230  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
231  "Probe #%u for search result %p failed\n",
232  sr->availability_trials,
233  sr);
234  signal_probe_result (sr);
235 }
signal_probe_result
static void signal_probe_result(struct GNUNET_FS_SearchResult *sr)
Signal result of last probe to client and then schedule next probe.
Definition: fs_search.c:194
GNUNET_FS_SearchResult::probe_ctx
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results' availability (NULL if we are not currently probin...
Definition: fs_api.h:554
GNUNET_FS_SearchResult::availability_trials
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_stop_probe_ping_task_
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:406
GNUNET_FS_search_result_sync_
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
GNUNET_FS_download_stop
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2313
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:533
GNUNET_ERROR_TYPE_DEBUG
Definition: gnunet_common.h:412
GNUNET_YES
#define GNUNET_YES
Definition: gnunet_common.h:80
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
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 244 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_().

245 {
246  struct GNUNET_FS_SearchResult *sr = cls;
247 
248  sr->probe_cancel_task = NULL;
249  sr->availability_trials++;
250  sr->availability_success++;
251  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
252  sr->probe_ctx = NULL;
253  GNUNET_FS_stop_probe_ping_task_ (sr);
254  GNUNET_FS_search_result_sync_ (sr);
255  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
256  "Probe #%u for search result %p succeeded\n",
257  sr->availability_trials,
258  sr);
259  signal_probe_result (sr);
260 }
signal_probe_result
static void signal_probe_result(struct GNUNET_FS_SearchResult *sr)
Signal result of last probe to client and then schedule next probe.
Definition: fs_search.c:194
GNUNET_FS_SearchResult::probe_ctx
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results' availability (NULL if we are not currently probin...
Definition: fs_api.h:554
GNUNET_FS_SearchResult::availability_trials
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_SearchResult::availability_success
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:621
GNUNET_FS_stop_probe_ping_task_
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:406
GNUNET_FS_search_result_sync_
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
GNUNET_FS_download_stop
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2313
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:533
GNUNET_ERROR_TYPE_DEBUG
Definition: gnunet_common.h:412
GNUNET_YES
#define GNUNET_YES
Definition: gnunet_common.h:80
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
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 279 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_().

281 {
282  struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
283  struct GNUNET_TIME_Relative dur;
284 
285  switch (info->status)
286  {
287  case GNUNET_FS_STATUS_DOWNLOAD_START:
288  /* ignore */
289  break;
290  case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
291  /* probes should never be resumed */
292  GNUNET_assert (0);
293  break;
294  case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
295  /* probes should never be suspended */
296  GNUNET_break (0);
297  break;
298  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
299  /* ignore */
300  break;
301  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
302  if (NULL != sr->probe_cancel_task)
303  {
304  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
305  sr->probe_cancel_task = NULL;
306  }
307  sr->probe_cancel_task =
308  GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
309  &probe_failure_handler, sr);
310  break;
311  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
312  if (NULL != sr->probe_cancel_task)
313  {
314  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
315  sr->probe_cancel_task = NULL;
316  }
317  sr->probe_cancel_task =
318  GNUNET_SCHEDULER_add_now (&probe_success_handler, sr);
319  break;
320  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
321  if (NULL != sr->probe_cancel_task)
322  {
323  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
324  sr->probe_cancel_task = NULL;
325  }
326  sr = NULL;
327  break;
328  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
329  if (NULL == sr->probe_cancel_task)
330  {
331  sr->probe_active_time = GNUNET_TIME_absolute_get ();
332  sr->probe_cancel_task =
333  GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
334  &probe_failure_handler, sr);
335  }
336  break;
337  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
338  if (NULL != sr->probe_cancel_task)
339  {
340  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
341  sr->probe_cancel_task = NULL;
342  }
343  dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
344  sr->remaining_probe_time =
345  GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
346  if (0 == sr->remaining_probe_time.rel_value_us)
347  sr->probe_cancel_task =
348  GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr);
349  GNUNET_FS_search_result_sync_ (sr);
350  break;
351  default:
352  GNUNET_break (0);
353  return NULL;
354  }
355  return sr;
356 }
GNUNET_FS_STATUS_DOWNLOAD_START
Notification that we have started this download.
Definition: gnunet_fs_service.h:553
GNUNET_TIME_Relative::rel_value_us
uint64_t rel_value_us
The actual value.
Definition: gnunet_time_lib.h:65
GNUNET_FS_STATUS_DOWNLOAD_SUSPEND
Notification that this download was suspended.
Definition: gnunet_fs_service.h:563
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
GNUNET_FS_ProgressInfo::download
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
probe_failure_handler
static void probe_failure_handler(void *cls)
Handle the case where we have failed to receive a response for our probe.
Definition: fs_search.c:220
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
Notification that this download completed.
Definition: gnunet_fs_service.h:580
GNUNET_SCHEDULER_add_delayed
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
GNUNET_FS_ProgressInfo::value
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
GNUNET_FS_SearchResult::remaining_probe_time
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:598
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
probe_success_handler
static void probe_success_handler(void *cls)
Handle the case where we have gotten a response for our probe.
Definition: fs_search.c:244
GNUNET_SCHEDULER_add_now
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
GNUNET_FS_ProgressInfo::status
enum GNUNET_FS_Status status
Specific status code (determines the event type).
Definition: gnunet_fs_service.h:1583
GNUNET_FS_search_result_sync_
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
GNUNET_TIME_relative_subtract
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:601
GNUNET_TIME_absolute_get
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
Notification that this download is no longer actively being pursued (back in the queue).
Definition: gnunet_fs_service.h:598
GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
Notification about progress with this download.
Definition: gnunet_fs_service.h:568
GNUNET_FS_STATUS_DOWNLOAD_ACTIVE
Notification that this download is now actively being pursued (as opposed to waiting in the queue)...
Definition: gnunet_fs_service.h:592
GNUNET_FS_STATUS_DOWNLOAD_RESUME
Notification that this download is being resumed.
Definition: gnunet_fs_service.h:558
GNUNET_TIME_absolute_get_duration
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
GNUNET_FS_SearchResult::probe_active_time
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:593
GNUNET_FS_STATUS_DOWNLOAD_STOPPED
Notification that this download was stopped (final event with respect to this action).
Definition: gnunet_fs_service.h:586
GNUNET_FS_STATUS_DOWNLOAD_ERROR
Notification that this download encountered an error.
Definition: gnunet_fs_service.h:573
GNUNET_TIME_Relative
Time for relative time used by GNUnet, in microseconds.
Definition: gnunet_time_lib.h:60
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 365 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().

366 {
367  struct GNUNET_FS_Handle *h = cls;
368  struct GNUNET_FS_SearchResult *sr;
369 
370  for (sr = h->probes_head; NULL != sr; sr = sr->next)
371  if (NULL != sr->probe_ctx->mq)
372  signal_probe_result (sr);
373  h->probe_ping_task
374  = GNUNET_SCHEDULER_add_delayed (GNUNET_FS_PROBE_UPDATE_FREQUENCY,
375  &probe_ping_task_cb,
376  h);
377 }
signal_probe_result
static void signal_probe_result(struct GNUNET_FS_SearchResult *sr)
Signal result of last probe to client and then schedule next probe.
Definition: fs_search.c:194
GNUNET_FS_Handle
Master context for most FS operations.
Definition: fs_api.h:1087
GNUNET_FS_SearchResult::probe_ctx
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results' availability (NULL if we are not currently probin...
Definition: fs_api.h:554
h
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_SCHEDULER_add_delayed
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_PROBE_UPDATE_FREQUENCY
#define GNUNET_FS_PROBE_UPDATE_FREQUENCY
How often do we signal applications that a probe for a particular search result is running...
Definition: gnunet_fs_service.h:83
GNUNET_FS_SearchResult::next
struct GNUNET_FS_SearchResult * next
Kept in a DLL while probing.
Definition: fs_api.h:522
GNUNET_FS_Handle::probe_ping_task
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:1159
GNUNET_FS_Handle::probes_head
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1142
GNUNET_FS_DownloadContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1784
probe_ping_task_cb
static void probe_ping_task_cb(void *cls)
Task run periodically to remind clients that a probe is active.
Definition: fs_search.c:365
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 386 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_().

387 {
388  struct GNUNET_FS_Handle *h = sr->h;
389 
390  GNUNET_CONTAINER_DLL_insert (h->probes_head,
391  h->probes_tail,
392  sr);
393  if (NULL == h->probe_ping_task)
394  h->probe_ping_task
395  = GNUNET_SCHEDULER_add_now (&probe_ping_task_cb,
396  h);
397 }
GNUNET_CONTAINER_DLL_insert
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Definition: gnunet_container_lib.h:2154
GNUNET_FS_Handle
Master context for most FS operations.
Definition: fs_api.h:1087
h
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
GNUNET_SCHEDULER_add_now
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
GNUNET_FS_Handle::probe_ping_task
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:1159
GNUNET_FS_Handle::probes_head
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1142
GNUNET_FS_Handle::probes_tail
struct GNUNET_FS_SearchResult * probes_tail
Tail of active probes.
Definition: fs_api.h:1147
probe_ping_task_cb
static void probe_ping_task_cb(void *cls)
Task run periodically to remind clients that a probe is active.
Definition: fs_search.c:365
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 406 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().

407 {
408  struct GNUNET_FS_Handle *h = sr->h;
409 
410  GNUNET_CONTAINER_DLL_remove (h->probes_head,
411  h->probes_tail,
412  sr);
413  if (NULL == h->probes_head)
414  {
415  GNUNET_SCHEDULER_cancel (h->probe_ping_task);
416  h->probe_ping_task = NULL;
417  }
418 }
GNUNET_CONTAINER_DLL_remove
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Definition: gnunet_container_lib.h:2273
GNUNET_FS_Handle
Master context for most FS operations.
Definition: fs_api.h:1087
h
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
GNUNET_FS_Handle::probe_ping_task
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:1159
GNUNET_FS_Handle::probes_head
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1142
GNUNET_FS_Handle::probes_tail
struct GNUNET_FS_SearchResult * probes_tail
Tail of active probes.
Definition: fs_api.h:1147
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 427 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().

428 {
429  uint64_t off;
430  uint64_t len;
431 
432  if (NULL != sr->probe_ctx)
433  return;
434  if (NULL != sr->download)
435  return;
436  if (0 == (sr->h->flags & GNUNET_FS_FLAGS_DO_PROBES))
437  return;
438  if (sr->availability_trials > AVAILABILITY_TRIALS_MAX)
439  return;
440  if ( (GNUNET_FS_URI_CHK != sr->uri->type) && (GNUNET_FS_URI_LOC != sr->uri->type))
441  return;
442  len = GNUNET_FS_uri_chk_get_file_size (sr->uri);
443  if (0 == len)
444  return;
445  if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
446  return;
447  off = len / DBLOCK_SIZE;
448  if (off > 0)
449  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, off);
450  off *= DBLOCK_SIZE;
451  if (len - off < DBLOCK_SIZE)
452  len = len - off;
453  else
454  len = DBLOCK_SIZE;
455  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
456  "Starting probe #%u (at offset %llu) for search result %p\n",
457  sr->availability_trials + 1,
458  (unsigned long long) off,
459  sr);
460  sr->remaining_probe_time =
461  GNUNET_TIME_relative_saturating_multiply (sr->h->avg_block_latency,
462  2 * (1 + sr->availability_trials));
463  sr->probe_ctx =
464  GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off,
465  len, sr->anonymity,
466  GNUNET_FS_DOWNLOAD_NO_TEMPORARIES |
467  GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
468  start_probe_ping_task (sr);
469 }
start_probe_ping_task
static void start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
Start the ping task for this search result.
Definition: fs_search.c:386
GNUNET_FS_SearchResult::download
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:560
GNUNET_FS_Handle::avg_block_latency
struct GNUNET_TIME_Relative avg_block_latency
Average time we take for a single request to be satisfied.
Definition: fs_api.h:1165
GNUNET_CRYPTO_random_u32
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
Definition: crypto_random.c:174
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
GNUNET_FS_SearchResult::probe_ctx
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:554
GNUNET_FS_download_start
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_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:2126
GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
Do not append temporary data to the target file (for the IBlocks).
Definition: gnunet_fs_service.h:2384
GNUNET_FS_SearchResult::remaining_probe_time
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:598
GNUNET_FS_SearchResult::availability_trials
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
GNUNET_FS_FLAGS_DO_PROBES
Should we automatically trigger probes for search results to determine availability? (will create GNUNET_FS_STATUS_SEARCH_UPDATE events).
Definition: gnunet_fs_service.h:1633
GNUNET_FS_SearchResult::availability_success
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:621
GNUNET_FS_DOWNLOAD_IS_PROBE
Internal option used to flag this download as a &#39;probe&#39; for a search result.
Definition: gnunet_fs_service.h:2393
GNUNET_FS_SearchResult::anonymity
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:603
AVAILABILITY_TRIALS_MAX
#define AVAILABILITY_TRIALS_MAX
Number of availability trials we perform per search result.
Definition: fs_search.c:36
DBLOCK_SIZE
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
GNUNET_FS_URI_CHK
Content-hash-key (simple file).
Definition: fs_api.h:146
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_FS_Uri::type
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
GNUNET_FS_uri_chk_get_file_size
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1359
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:533
GNUNET_ERROR_TYPE_DEBUG
Definition: gnunet_common.h:412
GNUNET_FS_URI_LOC
Location (chk with identity of hosting peer).
Definition: fs_api.h:161
GNUNET_TIME_relative_saturating_multiply
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:499
GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Definition: gnunet_crypto_lib.h:81
len
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Definition: gnunet-helper-transport-wlan.c:86
GNUNET_FS_Handle::flags
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1180
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 509 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().

510 {
511  if (NULL != sr->probe_ctx)
512  {
513  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
514  sr->probe_ctx = NULL;
515  GNUNET_FS_stop_probe_ping_task_ (sr);
516  }
517  if (NULL != sr->probe_cancel_task)
518  {
519  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
520  sr->probe_cancel_task = NULL;
521  }
522 }
GNUNET_FS_SearchResult::probe_ctx
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:554
GNUNET_FS_stop_probe_ping_task_
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:406
GNUNET_FS_download_stop
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2313
GNUNET_YES
#define GNUNET_YES
Definition: gnunet_common.h:80
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 558 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().

562 {
563  struct GNUNET_HashCode key;
564  struct GNUNET_FS_SearchResult *sr;
565  struct GetResultContext grc;
566  int is_new;
567  unsigned int koff;
568 
569  /* check if new */
570  GNUNET_assert (NULL != sc);
571  if (GNUNET_OK !=
572  GNUNET_FS_uri_to_key (uri,
573  &key))
574  {
575  GNUNET_break_op (0);
576  return;
577  }
578  if (GNUNET_SYSERR ==
579  GNUNET_CONTAINER_multihashmap_get_multiple (ent->results,
580  &key,
581  &test_result_present,
582  (void *) uri))
583  return; /* duplicate result */
584  /* try to find search result in master map */
585  grc.sr = NULL;
586  grc.uri = uri;
587  GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map,
588  &key,
589  &get_result_present, &grc);
590  sr = grc.sr;
591  is_new = (NULL == sr) || (sr->mandatory_missing > 0);
592  if (NULL == sr)
593  {
594  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
595  sr->h = sc->h;
596  sr->sc = sc;
597  sr->anonymity = sc->anonymity;
598  sr->uri = GNUNET_FS_uri_dup (uri);
599  sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
600  sr->mandatory_missing = sc->mandatory_count;
601  sr->key = key;
602  sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
603  GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
604  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
605  }
606  else
607  {
608  GNUNET_CONTAINER_meta_data_merge (sr->meta, meta);
609  }
610  GNUNET_break (GNUNET_OK ==
611  GNUNET_CONTAINER_multihashmap_put (ent->results,
612  &sr->key,
613  sr,
614  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
615 
616  koff = ent - sc->requests;
617  GNUNET_assert ( (ent >= sc->requests) &&
618  (koff < sc->uri->data.ksk.keywordCount));
619  sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8));
620  /* check if mandatory satisfied */
621  if (1 <= GNUNET_CONTAINER_multihashmap_size (ent->results))
622  {
623  if (ent->mandatory)
624  {
625  GNUNET_break (sr->mandatory_missing > 0);
626  sr->mandatory_missing--;
627  }
628  else
629  {
630  sr->optional_support++;
631  }
632  }
633  if (0 != sr->mandatory_missing)
634  {
635  GNUNET_break (NULL == sr->client_info);
636  return;
637  }
638  if (is_new)
639  notify_client_chk_result (sc, sr);
640  else
641  notify_client_chk_update (sc, sr);
642  GNUNET_FS_search_result_sync_ (sr);
643  GNUNET_FS_search_start_probe_ (sr);
644 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_SearchResult::optional_support
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:616
GNUNET_FS_SearchContext::mandatory_count
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1616
GNUNET_CONTAINER_multihashmap_size
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
Definition: container_multihashmap.c:301
notify_client_chk_result
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
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
GNUNET_FS_SearchResult::sc
struct GNUNET_FS_SearchContext * sc
Search context this result belongs to; can be NULL for probes that come from a directory result...
Definition: fs_api.h:533
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
SearchRequestEntry::mandatory
int mandatory
Is this keyword a mandatory keyword (started with &#39;+&#39;)?
Definition: fs_api.h:1525
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
test_result_present
static int test_result_present(void *cls, const struct GNUNET_HashCode *key, void *value)
Check if the given result is identical to the given URI.
Definition: fs_search.c:82
GetResultContext
Context for "get_result_present".
Definition: fs_search.c:148
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
get_result_present
static int get_result_present(void *cls, const struct GNUNET_HashCode *key, void *value)
Check if the given result is identical to the given URI and if so return it.
Definition: fs_search.c:174
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition: gnunet_common.h:1094
GNUNET_FS_uri_dup
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:988
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
GNUNET_FS_uri_to_key
int GNUNET_FS_uri_to_key(const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *key)
Get a unique key from a URI.
Definition: fs_uri.c:104
GNUNET_FS_SearchContext::anonymity
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1611
uri
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Definition: gnunet-publish.c:83
GetResultContext::sr
struct GNUNET_FS_SearchResult * sr
Where to store a pointer to the search result struct if we found a match.
Definition: fs_search.c:159
GNUNET_CONTAINER_meta_data_merge
void GNUNET_CONTAINER_meta_data_merge(struct GNUNET_CONTAINER_MetaData *md, const struct GNUNET_CONTAINER_MetaData *in)
Extend metadata.
Definition: container_meta_data.c:464
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search...
Definition: fs_api.h:1582
GNUNET_break_op
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Definition: gnunet_common.h:940
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@16::@17 ksk
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
GNUNET_FS_search_result_sync_
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
SearchRequestEntry::results
struct GNUNET_CONTAINER_MultiHashMap * results
Map that contains a "struct GNUNET_FS_SearchResult" for each result that was found under this keyword...
Definition: fs_api.h:1519
GNUNET_FS_SearchResult::anonymity
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:603
GNUNET_HashCode
A 512-bit hashcode.
Definition: gnunet_common.h:259
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Definition: gnunet_container_lib.h:745
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition: gnunet-dht-put.c:37
GNUNET_SYSERR
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_CONTAINER_multihashmap_put
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.
Definition: container_multihashmap.c:795
GNUNET_FS_SearchResult::key
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:581
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
Definition: gnunet_container_lib.h:738
GNUNET_FS_SearchResult::mandatory_missing
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:610
GNUNET_CONTAINER_multihashmap_get_multiple
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.
Definition: container_multihashmap.c:876
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
notify_client_chk_update
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
GNUNET_malloc
#define GNUNET_malloc(size)
Wrapper around malloc.
Definition: gnunet_common.h:1186
GNUNET_FS_search_start_probe_
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:427
GNUNET_CONTAINER_meta_data_duplicate
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData *md)
Duplicate a MetaData token.
Definition: container_meta_data.c:671
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 1312 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(), and process_ksk_result().

1318 {
1319  struct GNUNET_FS_SearchContext *sc;
1320  struct GNUNET_FS_ProgressInfo pi;
1321 
1322  sc = GNUNET_new (struct GNUNET_FS_SearchContext);
1323  sc->h = h;
1324  sc->options = options;
1325  sc->uri = GNUNET_FS_uri_dup (uri);
1326  sc->anonymity = anonymity;
1327  sc->start_time = GNUNET_TIME_absolute_get ();
1328  if (NULL != psearch)
1329  {
1330  sc->psearch_result = psearch;
1331  psearch->update_search = sc;
1332  }
1333  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
1334  sc->client_info = cctx;
1335  if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc))
1336  {
1337  GNUNET_FS_uri_destroy (sc->uri);
1338  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1339  GNUNET_free (sc);
1340  return NULL;
1341  }
1342  GNUNET_FS_search_sync_ (sc);
1343  pi.status = GNUNET_FS_STATUS_SEARCH_START;
1344  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1345  return sc;
1346 }
options
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
GNUNET_FS_search_sync_
void GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
Synchronize this search struct with its mirror on disk.
Definition: fs_api.c:2135
GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
Definition: gnunet_fs_service.h:613
GNUNET_NO
#define GNUNET_NO
Definition: gnunet_common.h:81
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition: gnunet_common.h:1094
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_FS_uri_dup
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:988
h
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_FS_SearchResult::update_search
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:566
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search...
Definition: fs_api.h:1582
GNUNET_CONTAINER_multihashmap_destroy
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
Definition: container_multihashmap.c:237
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
GNUNET_TIME_absolute_get
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
GNUNET_FS_search_start_searching_
int GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc)
Build the request and actually initiate the search using the GNUnet FS service.
Definition: fs_search.c:1387
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_CONTAINER_multihashmap_create
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
Definition: container_multihashmap.c:196
anonymity
static unsigned int anonymity
Definition: gnunet-download.c:43
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1230
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
GNUNET_FS_ProgressInfo::cctx
void * cctx
Client context pointer (set the last time by the client for this operation; initially NULL on START/R...
Definition: gnunet_fs_service.h:804
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 678 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, 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().

682 {
683  struct GNUNET_FS_Uri uu;
684  struct GNUNET_HashCode key;
685  struct GNUNET_FS_SearchResult *sr;
686 
687  /* check if new */
688  GNUNET_assert (NULL != sc);
689  if (GNUNET_OK !=
690  GNUNET_FS_uri_to_key (uri,
691  &key))
692  {
693  GNUNET_break (0);
694  return;
695  }
696  GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key,
697  &uri->data.chk.chk.query,
698  &key);
699  if (GNUNET_SYSERR ==
700  GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, &key,
701  &test_result_present,
702  (void *) uri))
703  return; /* duplicate result */
704  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
705  sr->h = sc->h;
706  sr->sc = sc;
707  sr->anonymity = sc->anonymity;
708  sr->uri = GNUNET_FS_uri_dup (uri);
709  sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
710  sr->key = key;
711  GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
712  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
713  GNUNET_FS_search_result_sync_ (sr);
714  GNUNET_FS_search_start_probe_ (sr);
715  /* notify client */
716  if (0 == sr->mandatory_missing)
717  notify_client_chk_result (sc, sr);
718  else
719  GNUNET_break (NULL == sr->client_info);
720  /* search for updates */
721  if (0 == strlen (id_update))
722  return; /* no updates */
723  uu.type = GNUNET_FS_URI_SKS;
724  uu.data.sks.ns = sc->uri->data.sks.ns;
725  uu.data.sks.identifier = GNUNET_strdup (id_update);
726  (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
727  GNUNET_free (uu.data.sks.identifier);
728 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
FileIdentifier::chk
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
GNUNET_FS_Uri::chk
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:215
notify_client_chk_result
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
GNUNET_FS_SearchContext::options
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1621
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
GNUNET_FS_SearchResult::sc
struct GNUNET_FS_SearchContext * sc
Search context this result belongs to; can be NULL for probes that come from a directory result...
Definition: fs_api.h:533
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
test_result_present
static int test_result_present(void *cls, const struct GNUNET_HashCode *key, void *value)
Check if the given result is identical to the given URI.
Definition: fs_search.c:82
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition: gnunet_common.h:1094
GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition: gnunet_common.h:1257
GNUNET_FS_uri_dup
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:988
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
GNUNET_FS_uri_to_key
int GNUNET_FS_uri_to_key(const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *key)
Get a unique key from a URI.
Definition: fs_uri.c:104
GNUNET_FS_SearchContext::anonymity
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1611
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search...
Definition: fs_api.h:1582
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
ContentHashKey::query
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:63
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
GNUNET_FS_search_result_sync_
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
GNUNET_FS_SearchResult::anonymity
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:603
GNUNET_HashCode
A 512-bit hashcode.
Definition: gnunet_common.h:259
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition: gnunet-dht-put.c:37
GNUNET_SYSERR
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_CONTAINER_multihashmap_put
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.
Definition: container_multihashmap.c:795
GNUNET_FS_SearchResult::key
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:581
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
Definition: gnunet_container_lib.h:738
GNUNET_FS_URI_SKS
Signed key space (file in namespace).
Definition: fs_api.h:151
ContentHashKey::key
struct GNUNET_HashCode key
Hash of the original content, used for encryption.
Definition: fs.h:58
GNUNET_FS_Uri::sks
struct GNUNET_FS_Uri::@16::@18 sks
GNUNET_FS_SearchResult::mandatory_missing
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:610
GNUNET_CONTAINER_multihashmap_get_multiple
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.
Definition: container_multihashmap.c:876
GNUNET_FS_Uri
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
GNUNET_CRYPTO_hash_xor
void GNUNET_CRYPTO_hash_xor(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
compute result = a ^ b
Definition: crypto_hash.c:193
search_start
static struct GNUNET_FS_SearchContext * search_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx, struct GNUNET_FS_SearchResult *psearch)
Start search for content, internal API.
Definition: fs_search.c:1312
GNUNET_FS_search_start_probe_
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:427
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1230
GNUNET_CONTAINER_meta_data_duplicate
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData *md)
Duplicate a MetaData token.
Definition: container_meta_data.c:671
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 746 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().

751 {
752  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
753  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
754  unsigned int i;
755 
756  /* find key */
757  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
758  if (0 == memcmp (dpub,
759  &sc->requests[i].dpub,
760  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
761  break;
762  if (i == sc->uri->data.ksk.keywordCount)
763  {
764  /* oops, does not match any of our keywords!? */
765  GNUNET_break (0);
766  return GNUNET_SYSERR;
767  }
768  /* decrypt */
769  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
770  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
771  GNUNET_FS_ublock_decrypt_ (edata, edata_size,
772  &anon_pub,
773  sc->requests[i].keyword,
774  data);
775  return i;
776 }
GNUNET_CRYPTO_ecdsa_key_get_anonymous
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_key_get_anonymous(void)
Get the shared private key we use for anonymous users.
Definition: crypto_ecc.c:814
SearchRequestEntry::dpub
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to &#39;uquery&#39;.
Definition: fs_api.h:1503
GNUNET_FS_ublock_decrypt_
void GNUNET_FS_ublock_decrypt_(const void *input, size_t input_len, const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *label, void *output)
Decrypt the given UBlock, storing the result in output.
Definition: fs_publish_ublock.c:74
GNUNET_CRYPTO_EcdsaPrivateKey
Private ECC key encoded for transmission.
Definition: gnunet_crypto_lib.h:255
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@16::@17 ksk
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
GNUNET_SYSERR
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
GNUNET_CRYPTO_ecdsa_key_get_public
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:241
GNUNET_CRYPTO_EcdsaPublicKey
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Definition: gnunet_crypto_lib.h:205
data
uint32_t data
The data value.
Definition: gnunet-helper-transport-wlan.c:91
SearchRequestEntry::keyword
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1509
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 789 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().

792 {
793  size_t j;
794  char pt[size - sizeof (struct UBlock)];
795  const char *eos;
796  struct GNUNET_CONTAINER_MetaData *meta;
797  struct GNUNET_FS_Uri *uri;
798  char *emsg;
799  int i;
800 
801  if (-1 == (i = decrypt_block_with_keyword (sc,
802  &ub->verification_key,
803  &ub[1],
804  size - sizeof (struct UBlock),
805  pt)))
806  return;
807  /* parse; pt[0] is just '\0', so we skip over that */
808  eos = memchr (&pt[1], '\0', sizeof (pt) - 1);
809  if (NULL == eos)
810  {
811  GNUNET_break_op (0);
812  return;
813  }
814  if (NULL == (uri = GNUNET_FS_uri_parse (&pt[1], &emsg)))
815  {
816  if (GNUNET_FS_VERSION > 0x00090400)
817  {
818  /* we broke this in 0x00090300, so don't bitch
819  too loudly just one version up... */
820  GNUNET_break_op (0); /* ublock malformed */
821  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
822  _("Failed to parse URI `%s': %s\n"),
823  &pt[1],
824  emsg);
825  }
826  GNUNET_free_non_null (emsg);
827  return;
828  }
829  j = eos - pt + 1;
830  if (sizeof (pt) == j)
831  meta = GNUNET_CONTAINER_meta_data_create ();
832  else
833  meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof (pt) - j);
834  if (NULL == meta)
835  {
836  GNUNET_break_op (0); /* ublock malformed */
837  GNUNET_FS_uri_destroy (uri);
838  return;
839  }
840  process_ksk_result (sc,
841  &sc->requests[i],
842  uri,
843  meta);
844 
845  /* clean up */
846  GNUNET_CONTAINER_meta_data_destroy (meta);
847  GNUNET_FS_uri_destroy (uri);
848 }
GNUNET_FS_VERSION
#define GNUNET_FS_VERSION
Version number of the implementation.
Definition: gnunet_fs_service.h:67
GNUNET_FS_uri_parse
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:635
GNUNET_CONTAINER_meta_data_deserialize
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
Definition: container_meta_data.c:1033
GNUNET_free_non_null
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition: gnunet_common.h:1239
decrypt_block_with_keyword
static int decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc, const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub, const void *edata, size_t edata_size, char *data)
Decrypt a ublock using a &#39;keyword&#39; as the passphrase.
Definition: fs_search.c:746
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
_
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
uri
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Definition: gnunet-publish.c:83
GNUNET_CONTAINER_MetaData
Meta data to associate with a file, directory or namespace.
Definition: container_meta_data.c:171
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)
We have received a KSK result.
Definition: fs_search.c:558
GNUNET_break_op
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Definition: gnunet_common.h:940
GNUNET_CONTAINER_meta_data_create
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_create(void)
Create a fresh meta data container.
Definition: container_meta_data.c:208
GNUNET_CONTAINER_meta_data_destroy
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
Definition: container_meta_data.c:252
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
size
static unsigned int size
Size of the "table".
Definition: peer.c:67
GNUNET_FS_Uri
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
meta
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
Definition: gnunet-publish.c:60
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:533
GNUNET_ERROR_TYPE_ERROR
Definition: gnunet_common.h:405
UBlock::verification_key
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:66
UBlock
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 861 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().

864 {
865  size_t len = size - sizeof (struct UBlock);
866  char pt[len];
867  struct GNUNET_FS_Uri *uri;
868  struct GNUNET_CONTAINER_MetaData *meta;
869  const char *id;
870  const char *uris;
871  size_t off;
872  char *emsg;
873 
874  GNUNET_FS_ublock_decrypt_ (&ub[1], len,
875  &sc->uri->data.sks.ns,
876  sc->uri->data.sks.identifier,
877  pt);
878  /* parse */
879  if (0 == (off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris)))
880  {
881  GNUNET_break_op (0); /* ublock malformed */
882  return;
883  }
884  if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], len - off)))
885  {
886  GNUNET_break_op (0); /* ublock malformed */
887  return;
888  }
889  if (NULL == (uri = GNUNET_FS_uri_parse (uris, &emsg)))
890  {
891  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
892  _("Failed to parse URI `%s': %s\n"),
893  uris, emsg);
894  GNUNET_break_op (0); /* ublock malformed */
895  GNUNET_free_non_null (emsg);
896  GNUNET_CONTAINER_meta_data_destroy (meta);
897  return;
898  }
899  /* process */
900  process_sks_result (sc, id, uri, meta);
901  /* clean up */
902  GNUNET_FS_uri_destroy (uri);
903  GNUNET_CONTAINER_meta_data_destroy (meta);
904 }
GNUNET_FS_uri_parse
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:635
GNUNET_FS_ublock_decrypt_
void GNUNET_FS_ublock_decrypt_(const void *input, size_t input_len, const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *label, void *output)
Decrypt the given UBlock, storing the result in output.
Definition: fs_publish_ublock.c:74
GNUNET_CONTAINER_meta_data_deserialize
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
Definition: container_meta_data.c:1033
id
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
Definition: gnunet-conversation.c:201
GNUNET_free_non_null
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition: gnunet_common.h:1239
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
_
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
uri
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
Definition: gnunet-publish.c:83
GNUNET_STRINGS_buffer_tokenize
unsigned int GNUNET_STRINGS_buffer_tokenize(const char *buffer, size_t size, unsigned int count,...)
Given a buffer of a given size, find "count" 0-terminated strings in the buffer and assign the count ...
Definition: strings.c:136
GNUNET_CONTAINER_MetaData
Meta data to associate with a file, directory or namespace.
Definition: container_meta_data.c:171
GNUNET_break_op
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Definition: gnunet_common.h:940
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
GNUNET_CONTAINER_meta_data_destroy
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
Definition: container_meta_data.c:252
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
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)
We have received an SKS result.
Definition: fs_search.c:678
size
static unsigned int size
Size of the "table".
Definition: peer.c:67
GNUNET_FS_Uri::sks
struct GNUNET_FS_Uri::@16::@18 sks
GNUNET_FS_Uri
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
meta
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
Definition: gnunet-publish.c:60
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:533
GNUNET_ERROR_TYPE_ERROR
Definition: gnunet_common.h:405
UBlock
universal block for keyword and namespace search results
Definition: block_fs.h:50
len
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Definition: gnunet-helper-transport-wlan.c:86
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 1284 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().

1285 {
1286  if (NULL != sc->mq)
1287  {
1288  GNUNET_MQ_destroy (sc->mq);
1289  sc->mq = NULL;
1290  }
1291  sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (sc->reconnect_backoff);
1292  sc->task =
1293  GNUNET_SCHEDULER_add_delayed (sc->reconnect_backoff,
1294  &do_reconnect,
1295  sc);
1296 }
GNUNET_FS_SearchContext::task
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1606
do_reconnect
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1250
GNUNET_SCHEDULER_add_delayed
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
GNUNET_FS_SearchContext::reconnect_backoff
struct GNUNET_TIME_Relative reconnect_backoff
How long to wait before we try to reconnect to FS service?
Definition: fs_api.h:1598
GNUNET_TIME_STD_BACKOFF
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Definition: gnunet_time_lib.h:175
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
GNUNET_MQ_destroy
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
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 925 of file fs_search.c.

References GNUNET_OK.

927 {
928  /* payload of any variable size is OK */
929  return GNUNET_OK;
930 }
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78

◆ 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 940 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.

942 {
943  struct GNUNET_FS_SearchContext *sc = cls;
944  uint16_t msize = ntohs (cm->header.size) - sizeof (*cm);
945  enum GNUNET_BLOCK_Type type = ntohl (cm->type);
946 
947  if (GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (cm->expiration)).rel_value_us > 0)
948  {
949  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
950  "Result received has already expired.\n");
951  return; /* result expired */
952  }
953  switch (type)
954  {
955  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
956  if (GNUNET_FS_URI_SKS == sc->uri->type)
957  process_sblock (sc,
958  (const struct UBlock *) &cm[1],
959  msize);
960  else
961  process_kblock (sc,
962  (const struct UBlock *) &cm[1],
963  msize);
964  break;
965  case GNUNET_BLOCK_TYPE_ANY:
966  GNUNET_break (0);
967  break;
968  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
969  GNUNET_break (0);
970  break;
971  case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
972  GNUNET_break (0);
973  break;
974  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
975  GNUNET_break (0);
976  break;
977  default:
978  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
979  _("Got result with unknown block type `%d', ignoring"),
980  type);
981  break;
982  }
983 }
GNUNET_TIME_absolute_ntoh
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:670
GNUNET_TIME_Relative::rel_value_us
uint64_t rel_value_us
The actual value.
Definition: gnunet_time_lib.h:65
GNUNET_BLOCK_TYPE_ANY
Any type of block, used as a wildcard when searching.
Definition: gnunet_block_lib.h:53
ClientPutMessage::header
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
Definition: fs.h:370
GNUNET_BLOCK_Type
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
Definition: gnunet_block_lib.h:47
process_sblock
static void process_sblock(struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
Process a namespace-search result.
Definition: fs_search.c:861
GNUNET_MessageHeader::size
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
Definition: gnunet_common.h:297
process_kblock
static void process_kblock(struct GNUNET_FS_SearchContext *sc, const struct UBlock *ub, size_t size)
Process a keyword search result.
Definition: fs_search.c:789
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
Definition: gnunet_block_lib.h:84
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
_
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
ClientPutMessage::expiration
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:380
GNUNET_BLOCK_TYPE_FS_IBLOCK
Inner block in the CHK tree.
Definition: gnunet_block_lib.h:63
GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
Definition: gnunet_block_lib.h:102
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_Uri::type
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
ClientPutMessage::type
uint32_t type
Type of the block (in big endian).
Definition: fs.h:375
GNUNET_FS_URI_SKS
Signed key space (file in namespace).
Definition: fs_api.h:151
GNUNET_ERROR_TYPE_WARNING
Definition: gnunet_common.h:406
GNUNET_TIME_absolute_get_duration
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_log
#define GNUNET_log(kind,...)
Definition: gnunet_common.h:533
GNUNET_ERROR_TYPE_DEBUG
Definition: gnunet_common.h:412
GNUNET_BLOCK_TYPE_FS_DBLOCK
Data block (leaf) in the CHK tree.
Definition: gnunet_block_lib.h:58
type
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Definition: testbed_api_underlay.c:126
UBlock
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 1093 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().

1094 {
1095  struct MessageBuilderContext mbc;
1096  struct GNUNET_MQ_Envelope *env;
1097  struct SearchMessage *sm;
1098  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
1099  unsigned int total_seen_results; /* total number of result hashes to send */
1100  uint32_t options;
1101  unsigned int left;
1102  unsigned int todo;
1103  unsigned int fit;
1104  unsigned int search_request_map_offset;
1105  unsigned int keyword_offset;
1106  int first_call;
1107 
1108  memset (&mbc, 0, sizeof (mbc));
1109  mbc.sc = sc;
1110  if (GNUNET_FS_uri_test_ksk (sc->uri))
1111  {
1112  /* This will calculate the result set size ONLY for
1113  "keyword_offset == 0", so we will have to recalculate
1114  it for the other keywords later! */
1115  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1116  &find_result_set,
1117  &mbc);
1118  total_seen_results = mbc.put_cnt;
1119  }
1120  else
1121  {
1122  total_seen_results
1123  = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
1124  }
1125  search_request_map_offset = 0;
1126  keyword_offset = 0;
1127  first_call = GNUNET_YES;
1128  while ( (0 != (left =
1129  (total_seen_results - search_request_map_offset))) ||
1130  (GNUNET_YES == first_call) )
1131  {
1132  first_call = GNUNET_NO;
1133  options = SEARCH_MESSAGE_OPTION_NONE;
1134  if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
1135  options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
1136 
1137  fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof (*sm)) / sizeof (struct GNUNET_HashCode);
1138  todo = GNUNET_MIN (fit,
1139  left);
1140  env = GNUNET_MQ_msg_extra (sm,
1141  sizeof (struct GNUNET_HashCode) * todo,
1142  GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
1143  mbc.skip_cnt = search_request_map_offset;
1144  mbc.xoff = (struct GNUNET_HashCode *) &sm[1];
1145  sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK);
1146  sm->anonymity_level = htonl (sc->anonymity);
1147  memset (&sm->target,
1148  0,
1149  sizeof (struct GNUNET_PeerIdentity));
1150 
1151  if (GNUNET_FS_uri_test_ksk (sc->uri))
1152  {
1153  mbc.keyword_offset = keyword_offset;
1154  /* calculate how many results we can send in this message */
1155  mbc.put_cnt = todo;
1156  /* now build message */
1157  sm->query = sc->requests[keyword_offset].uquery;
1158  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1159  &build_result_set,
1160  &mbc);
1161  search_request_map_offset += todo;
1162  GNUNET_assert (0 == mbc.put_cnt);
1163  GNUNET_assert (total_seen_results >= search_request_map_offset);
1164  if (total_seen_results != search_request_map_offset)
1165  {
1166  /* more requesting to be done... */
1167  sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
1168  }
1169  else
1170  {
1171  sm->options = htonl (options);
1172  keyword_offset++;
1173  if (sc->uri->data.ksk.keywordCount != keyword_offset)
1174  {
1175  /* more keywords => more requesting to be done... */
1176  first_call = GNUNET_YES;
1177  search_request_map_offset = 0;
1178  mbc.put_cnt = 0;
1179  mbc.keyword_offset = keyword_offset;
1180  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1181  &find_result_set,
1182  &mbc);
1183  total_seen_results = mbc.put_cnt;
1184  }
1185  }
1186  }
1187  else
1188  {
1189  GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
1190 
1191  GNUNET_CRYPTO_ecdsa_public_key_derive (&sc->uri->data.sks.ns,
1192  sc->uri->data.sks.identifier,
1193  "fs-ublock",
1194  &dpub);
1195  GNUNET_CRYPTO_hash (&dpub,
1196  sizeof (dpub),
1197  &sm->query);
1198  mbc.put_cnt = todo;
1199  mbc.keyword_offset = 0;
1200  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1201  &build_result_set,
1202  &mbc);
1203  GNUNET_assert (total_seen_results >= search_request_map_offset);
1204  if (total_seen_results != search_request_map_offset)
1205  {
1206  /* more requesting to be done... */
1207  sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
1208  }
1209  else
1210  {
1211  sm->options = htonl (options);
1212  }
1213  }
1214  GNUNET_MQ_send (sc->mq,
1215  env);
1216  }
1217 }
GNUNET_FS_uri_test_ksk
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
MessageBuilderContext
Closure for build_result_set().
Definition: fs_search.c:999
GNUNET_CRYPTO_ecdsa_public_key_derive
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc.c:1339
GNUNET_CONTAINER_multihashmap_size
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
Definition: container_multihashmap.c:301
SearchRequestEntry::uquery
struct GNUNET_HashCode uquery
Hash of the public key, also known as the query.
Definition: fs_api.h:1498
options
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
GNUNET_FS_SearchContext::options
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1621
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
SearchMessage::options
uint32_t options
Bitmask with options.
Definition: fs.h:292
GNUNET_NO
#define GNUNET_NO
Definition: gnunet_common.h:81
GNUNET_FS_uri_test_sks
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1270
find_result_set
static int find_result_set(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterating over the known results, count those matching the given result range and increment put count...
Definition: fs_search.c:1071
SearchMessage::target
struct GNUNET_PeerIdentity target
If the request is for a DBLOCK or IBLOCK, this is the identity of the peer that is known to have a re...
Definition: fs.h:314
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
GNUNET_FS_SearchContext::anonymity
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1611
SearchMessage::query
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS...
Definition: fs.h:320
GNUNET_MQ_msg_extra
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search...
Definition: fs_api.h:1582
GNUNET_CRYPTO_hash
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@16::@17 ksk
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
GNUNET_MIN
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
SearchMessage::type
uint32_t type
Type of the content that we&#39;re looking for.
Definition: fs.h:297
GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
Definition: gnunet_block_lib.h:102
GNUNET_HashCode
A 512-bit hashcode.
Definition: gnunet_common.h:259
GNUNET_MQ_Envelope
Definition: mq.c:32
env
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_MAX_MESSAGE_SIZE
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
Definition: gnunet_util_lib.h:48
GNUNET_MESSAGE_TYPE_FS_START_SEARCH
#define GNUNET_MESSAGE_TYPE_FS_START_SEARCH
Client asks FS service to start a (keyword) search.
Definition: gnunet_protocols.h:554
GNUNET_FS_Uri::sks
struct GNUNET_FS_Uri::@16::@18 sks
GNUNET_PeerIdentity
The identity of the host (wraps the signing key of the peer).
Definition: gnunet_crypto_lib.h:218
GNUNET_CRYPTO_EcdsaPublicKey
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Definition: gnunet_crypto_lib.h:205
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY
Only search the local host, do not search remote systems (no P2P)
Definition: gnunet_fs_service.h:2281
SEARCH_MESSAGE_OPTION_CONTINUED
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:268
GNUNET_YES
#define GNUNET_YES
Definition: gnunet_common.h:80
GNUNET_MQ_send
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
SEARCH_MESSAGE_OPTION_NONE
#define SEARCH_MESSAGE_OPTION_NONE
No options.
Definition: fs.h:255
SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:260
build_result_set
static int build_result_set(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterating over the known results, pick those matching the given result range and store their keys at ...
Definition: fs_search.c:1038
GNUNET_CONTAINER_multihashmap_iterate
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Definition: container_multihashmap.c:356
SearchMessage
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search...
Definition: fs.h:275
SearchMessage::anonymity_level
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:302
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 1038 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().

1041 {
1042  struct MessageBuilderContext *mbc = cls;
1043  struct GNUNET_FS_SearchResult *sr = value;
1044 
1045  if ( (NULL != sr->keyword_bitmap) &&
1046  (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) )
1047  return GNUNET_OK; /* have no match for this keyword yet */
1048  if (mbc->skip_cnt > 0)
1049  {
1050  mbc->skip_cnt--;
1051  return GNUNET_OK;
1052  }
1053  if (0 == mbc->put_cnt)
1054  return GNUNET_SYSERR;
1055  mbc->xoff[--mbc->put_cnt] = *key;
1056 
1057  return GNUNET_OK;
1058 }
MessageBuilderContext
Closure for build_result_set().
Definition: fs_search.c:999
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
MessageBuilderContext::keyword_offset
unsigned int keyword_offset
Keyword offset the search result must match (0 for SKS)
Definition: fs_search.c:1024
key
struct GNUNET_HashCode key
The key used in the DHT.
Definition: gnunet-dht-put.c:37
GNUNET_SYSERR
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
MessageBuilderContext::put_cnt
unsigned int put_cnt
How many entries can we store to xoff.
Definition: fs_search.c:1004
MessageBuilderContext::xoff
struct GNUNET_HashCode * xoff
Where to store the keys.
Definition: fs_search.c:1014
MessageBuilderContext::skip_cnt
unsigned int skip_cnt
How many entries should we skip.
Definition: fs_search.c:1009
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 1071 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().

1074 {
1075  struct MessageBuilderContext *mbc = cls;
1076  struct GNUNET_FS_SearchResult *sr = value;
1077 
1078  if ( (NULL != sr->keyword_bitmap) &&
1079  (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))) )
1080  return GNUNET_OK; /* have no match for this keyword yet */
1081  mbc->put_cnt++;
1082  return GNUNET_OK;
1083 }
MessageBuilderContext
Closure for build_result_set().
Definition: fs_search.c:999
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
MessageBuilderContext::keyword_offset
unsigned int keyword_offset
Keyword offset the search result must match (0 for SKS)
Definition: fs_search.c:1024
MessageBuilderContext::put_cnt
unsigned int put_cnt
How many entries can we store to xoff.
Definition: fs_search.c:1004
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 1229 of file fs_search.c.

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

Referenced by do_reconnect().

1231 {
1232  struct GNUNET_FS_SearchContext *sc = cls;
1233 
1234  if (NULL != sc->mq)
1235  {
1236  GNUNET_MQ_destroy (sc->mq);
1237  sc->mq = NULL;
1238  }
1239  try_reconnect (sc);
1240 }
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
GNUNET_MQ_destroy
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
try_reconnect
static void try_reconnect(struct GNUNET_FS_SearchContext *sc)
Shutdown any existing connection to the FS service and try to establish a fresh one (and then re-tran...
Definition: fs_search.c:1284
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 1250 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().

1251 {
1252  struct GNUNET_FS_SearchContext *sc = cls;
1253  struct GNUNET_MQ_MessageHandler handlers[] = {
1254  GNUNET_MQ_hd_var_size (result,
1255  GNUNET_MESSAGE_TYPE_FS_PUT,
1256  struct ClientPutMessage,
1257  sc),
1258  GNUNET_MQ_handler_end ()
1259  };
1260 
1261  sc->task = NULL;
1262  sc->mq = GNUNET_CLIENT_connect (sc->h->cfg,
1263  "fs",
1264  handlers,
1265  &search_mq_error_handler,
1266  sc);
1267  if (NULL == sc->mq)
1268  {
1269  try_reconnect (sc);
1270  return;
1271  }
1272  schedule_transmit_search_request (sc);
1273 }
GNUNET_FS_SearchContext::task
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1606
GNUNET_CLIENT_connect
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:901
schedule_transmit_search_request
static void schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc)
Schedule the transmission of the (next) search request to the service.
Definition: fs_search.c:1093
handlers
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
Definition: gnunet-cadet-profiler.c:799
GNUNET_MQ_hd_var_size
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Definition: gnunet_mq_lib.h:601
result
static int result
Global testing status.
Definition: gnunet-regex-profiler.c:244
GNUNET_MQ_MessageHandler
Message handler for a specific message type.
Definition: gnunet_mq_lib.h:475
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
ClientPutMessage
Response from FS service with a result for a previous FS search.
Definition: fs.h:364
search_mq_error_handler
static void search_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: fs_search.c:1229
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
try_reconnect
static void try_reconnect(struct GNUNET_FS_SearchContext *sc)
Shutdown any existing connection to the FS service and try to establish a fresh one (and then re-tran...
Definition: fs_search.c:1284
GNUNET_MESSAGE_TYPE_FS_PUT
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
Definition: gnunet_protocols.h:566
GNUNET_MQ_handler_end
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Definition: gnunet_mq_lib.h:516
GNUNET_FS_Handle::cfg
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1092
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 1359 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_().

1362 {
1363  struct GNUNET_FS_SearchContext *sc = cls;
1364  struct GNUNET_FS_SearchResult *sr = value;
1365  unsigned int i;
1366 
1367  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1368  if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8))))
1369  GNUNET_break (GNUNET_OK ==
1370  GNUNET_CONTAINER_multihashmap_put (sc->requests[i].results,
1371  &sr->key,
1372  sr,
1373  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1374 
1375  return GNUNET_YES;
1376 }
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@16::@17 ksk
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
SearchRequestEntry::results
struct GNUNET_CONTAINER_MultiHashMap * results
Map that contains a "struct GNUNET_FS_SearchResult" for each result that was found under this keyword...
Definition: fs_api.h:1519
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Definition: gnunet_container_lib.h:745
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_CONTAINER_multihashmap_put
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.
Definition: container_multihashmap.c:795
GNUNET_FS_SearchResult::key
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:581
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_YES
#define GNUNET_YES
Definition: gnunet_common.h:80
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 1387 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().

1388 {
1389  unsigned int i;
1390  const char *keyword;
1391  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
1392  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
1393  struct SearchRequestEntry *sre;
1394 
1395  GNUNET_assert (NULL == sc->mq);
1396  if (GNUNET_FS_uri_test_ksk (sc->uri))
1397  {
1398  GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
1399  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
1400  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
1401  sc->requests
1402  = GNUNET_new_array (sc->uri->data.ksk.keywordCount,
1403  struct SearchRequestEntry);
1404 
1405  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1406  {
1407  keyword = &sc->uri->data.ksk.keywords[i][1];
1408  sre = &sc->requests[i];
1409  sre->keyword = GNUNET_strdup (keyword);
1410  GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
1411  keyword,
1412  "fs-ublock",
1413  &sre->dpub);
1414  GNUNET_CRYPTO_hash (&sre->dpub,
1415  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
1416  &sre->uquery);
1417  sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
1418  if (sre->mandatory)
1419  sc->mandatory_count++;
1420  sre->results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
1421  }
1422  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1423  &update_sre_result_maps,
1424  sc);
1425  }
1426  GNUNET_assert (NULL == sc->task);
1427  do_reconnect (sc);
1428  if (NULL == sc->mq)
1429  {
1430  GNUNET_SCHEDULER_cancel (sc->task);
1431  sc->task = NULL;
1432  return GNUNET_SYSERR;
1433  }
1434  return GNUNET_OK;
1435 }
GNUNET_FS_uri_test_ksk
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
GNUNET_CRYPTO_ecdsa_key_get_anonymous
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_key_get_anonymous(void)
Get the shared private key we use for anonymous users.
Definition: crypto_ecc.c:814
GNUNET_CRYPTO_ecdsa_public_key_derive
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc.c:1339
GNUNET_FS_SearchContext::task
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1606
GNUNET_FS_SearchContext::mandatory_count
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1616
SearchRequestEntry::uquery
struct GNUNET_HashCode uquery
Hash of the public key, also known as the query.
Definition: fs_api.h:1498
SearchRequestEntry::dpub
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to &#39;uquery&#39;.
Definition: fs_api.h:1503
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
SearchRequestEntry::mandatory
int mandatory
Is this keyword a mandatory keyword (started with &#39;+&#39;)?
Definition: fs_api.h:1525
GNUNET_NO
#define GNUNET_NO
Definition: gnunet_common.h:81
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_CRYPTO_EcdsaPrivateKey
Private ECC key encoded for transmission.
Definition: gnunet_crypto_lib.h:255
GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition: gnunet_common.h:1257
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
do_reconnect
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1250
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search...
Definition: fs_api.h:1582
GNUNET_CRYPTO_hash
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@16::@17 ksk
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
GNUNET_new_array
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
Definition: gnunet_common.h:1150
SearchRequestEntry::results
struct GNUNET_CONTAINER_MultiHashMap * results
Map that contains a "struct GNUNET_FS_SearchResult" for each result that was found under this keyword...
Definition: fs_api.h:1519
GNUNET_SYSERR
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
GNUNET_CRYPTO_ecdsa_key_get_public
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:241
GNUNET_CRYPTO_EcdsaPublicKey
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Definition: gnunet_crypto_lib.h:205
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
GNUNET_CONTAINER_multihashmap_create
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
Definition: container_multihashmap.c:196
update_sre_result_maps
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:1359
SearchRequestEntry
Information we keep for each keyword in a keyword search.
Definition: fs_api.h:1492
GNUNET_CONTAINER_multihashmap_iterate
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Definition: container_multihashmap.c:356
SearchRequestEntry::keyword
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1509
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 1447 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().

1450 {
1451  struct GNUNET_FS_SearchResult *sr = value;
1452 
1453  if (NULL != sr->probe_ctx)
1454  {
1455  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
1456  sr->probe_ctx = NULL;
1457  GNUNET_FS_stop_probe_ping_task_ (sr);
1458  }
1459  if (NULL != sr->probe_cancel_task)
1460  {
1461  GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
1462  sr->probe_cancel_task = NULL;
1463  }
1464  if (NULL != sr->update_search)
1465  GNUNET_FS_search_pause (sr->update_search);
1466  return GNUNET_OK;
1467 }
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_FS_SearchResult::probe_ctx
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:554
GNUNET_FS_SearchResult::update_search
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:566
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_stop_probe_ping_task_
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:406
GNUNET_FS_download_stop
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2313
GNUNET_FS_search_pause
void GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc)
Pause search.
Definition: fs_search.c:1618
GNUNET_YES
#define GNUNET_YES
Definition: gnunet_common.h:80
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 1479 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().

1482 {
1483  struct GNUNET_FS_SearchResult *sr = value;
1484 
1485  GNUNET_FS_search_start_probe_ (sr);
1486  if (NULL != sr->update_search)
1487  GNUNET_FS_search_continue (sr->update_search);
1488  return GNUNET_OK;
1489 }
GNUNET_FS_search_continue
void GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc)
Continue paused search.
Definition: fs_search.c:1649
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_FS_SearchResult::update_search
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:566
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_search_start_probe_
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:427
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 1501 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_().

1504 {
1505  struct GNUNET_FS_SearchContext *sc = cls;
1506  struct GNUNET_FS_SearchResult *sr = value;
1507  struct GNUNET_FS_ProgressInfo pi;
1508 
1509  if (NULL != sr->download)
1510  {
1511  GNUNET_FS_download_signal_suspend_ (sr->download);
1512  sr->download = NULL;
1513  }
1514  if (NULL != sr->update_search)
1515  {
1516  GNUNET_FS_search_signal_suspend_ (sr->update_search);
1517  sr->update_search = NULL;
1518  }
1519  GNUNET_FS_search_stop_probe_ (sr);
1520  if (0 == sr->mandatory_missing)
1521  {
1522  /* client is aware of search result, notify about suspension event */
1523  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND;
1524  pi.value.search.specifics.result_suspend.cctx = sr->client_info;
1525  pi.value.search.specifics.result_suspend.meta = sr->meta;
1526  pi.value.search.specifics.result_suspend.uri = sr->uri;
1527  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1528  }
1529  GNUNET_break (NULL == sr->client_info);
1530  GNUNET_free_non_null (sr->serialization);
1531  GNUNET_FS_uri_destroy (sr->uri);
1532  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
1533  GNUNET_free_non_null (sr->keyword_bitmap);
1534  GNUNET_free (sr);
1535  return GNUNET_OK;
1536 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_SearchResult::download
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:560
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_free_non_null
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition: gnunet_common.h:1239
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchResult::update_search
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:566
GNUNET_FS_download_signal_suspend_
void GNUNET_FS_download_signal_suspend_(void *cls)
Create SUSPEND event for the given download operation and then clean up our state (without stop signa...
Definition: fs_download.c:1953
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_CONTAINER_meta_data_destroy
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
Definition: container_meta_data.c:252
GNUNET_FS_search_stop_probe_
static void GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
Stop probing activity associated with a search result.
Definition: fs_search.c:509
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_FS_SearchResult::mandatory_missing
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:610
GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND
Event generated for each search result when the respective search is suspended.
Definition: gnunet_fs_service.h:676
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_FS_SearchResult::serialization
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:571
GNUNET_FS_search_signal_suspend_
void GNUNET_FS_search_signal_suspend_(void *cls)
Create SUSPEND event for the given search operation and then clean up our state (without stop signal)...
Definition: fs_search.c:1546
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1230
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
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 1546 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().

1547 {
1548  struct GNUNET_FS_SearchContext *sc = cls;
1549  struct GNUNET_FS_ProgressInfo pi;
1550  unsigned int i;
1551 
1552  GNUNET_FS_end_top (sc->h, sc->top);
1553  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
1554  &search_result_suspend, sc);
1555  pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND;
1556  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1557  GNUNET_break (NULL == sc->client_info);
1558  if (sc->task != NULL)
1559  {
1560  GNUNET_SCHEDULER_cancel (sc->task);
1561  sc->task = NULL;
1562  }
1563  if (NULL != sc->mq)
1564  {
1565  GNUNET_MQ_destroy (sc->mq);
1566  sc->mq = NULL;
1567  }
1568  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
1569  if (NULL != sc->requests)
1570  {
1571  GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
1572  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1573  {
1574  GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
1575  GNUNET_free (sc->requests[i].keyword);
1576  }
1577  }
1578  GNUNET_free_non_null (sc->requests);
1579  GNUNET_free_non_null (sc->emsg);
1580  GNUNET_FS_uri_destroy (sc->uri);
1581  GNUNET_free_non_null (sc->serialization);
1582  GNUNET_free (sc);
1583 }
GNUNET_FS_uri_test_ksk
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
GNUNET_FS_SearchContext::task
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1606
GNUNET_FS_SearchContext::top
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1543
GNUNET_FS_SearchContext::emsg
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1574
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
GNUNET_free_non_null
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition: gnunet_common.h:1239
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchContext::requests
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
GNUNET_FS_SearchContext::uri
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
GNUNET_FS_SearchContext::serialization
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1569
GNUNET_FS_SearchContext::master_result_map
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search...
Definition: fs_api.h:1582
GNUNET_FS_Uri::ksk
struct GNUNET_FS_Uri::@16::@17 ksk
GNUNET_FS_end_top
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:416
GNUNET_CONTAINER_multihashmap_destroy
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
Definition: container_multihashmap.c:237
GNUNET_FS_Uri::data
union GNUNET_FS_Uri::@16 data
SearchRequestEntry::results
struct GNUNET_CONTAINER_MultiHashMap * results
Map that contains a "struct GNUNET_FS_SearchResult" for each result that was found under this keyword...
Definition: fs_api.h:1519
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
GNUNET_FS_STATUS_SEARCH_SUSPEND
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
Definition: gnunet_fs_service.h:633
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
search_result_suspend
static int search_result_suspend(void *cls, const struct GNUNET_HashCode *key, void *value)
Signal suspend and free the given search result.
Definition: fs_search.c:1501
GNUNET_FS_SearchContext::mq
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
GNUNET_MQ_destroy
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_CONTAINER_multihashmap_iterate
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Definition: container_multihashmap.c:356
GNUNET_FS_SearchContext::client_info
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1564
SearchRequestEntry::keyword
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1509
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1230
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 1673 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().

1676 {
1677  struct GNUNET_FS_SearchContext *sc = cls;
1678  struct GNUNET_FS_SearchResult *sr = value;
1679  struct GNUNET_FS_ProgressInfo pi;
1680 
1681  GNUNET_FS_search_stop_probe_ (sr);
1682  if (NULL != sr->download)
1683  {
1684  sr->download->search = NULL;
1685  sr->download->top
1686  = GNUNET_FS_make_top (sr->download->h,
1687  &GNUNET_FS_download_signal_suspend_,
1688  sr->download);
1689  if (NULL != sr->download->serialization)
1690  {
1691  GNUNET_FS_remove_sync_file_ (sc->h,
1692  GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
1693  sr->download->serialization);
1694  GNUNET_free (sr->download->serialization);
1695  sr->download->serialization = NULL;
1696  }
1697  pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT;
1698  GNUNET_FS_download_make_status_ (&pi,
1699  sr->download);
1700  GNUNET_FS_download_sync_ (sr->download);
1701  sr->download = NULL;
1702  }
1703  if (0 != sr->mandatory_missing)
1704  {
1705  /* client is unaware of search result as
1706  it does not match required keywords */
1707  GNUNET_break (NULL == sr->client_info);
1708  return GNUNET_OK;
1709  }
1710  pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED;
1711  pi.value.search.specifics.result_stopped.cctx = sr->client_info;
1712  pi.value.search.specifics.result_stopped.meta = sr->meta;
1713  pi.value.search.specifics.result_stopped.uri = sr->uri;
1714  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sc);
1715  return GNUNET_OK;
1716 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_FS_SearchResult::download
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:560
GNUNET_FS_DownloadContext::h
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1774
GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
#define GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
Name of the directory with downloads that are part of another download or a search.
Definition: fs_api.h:71
GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
Event generated for each search result when the respective search is stopped.
Definition: gnunet_fs_service.h:670
GNUNET_FS_download_sync_
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:1944
GNUNET_FS_download_make_status_
void GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_DownloadContext *dc)
Fill in all of the generic fields for a download event and call the callback.
Definition: fs_download.c:106
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
pi
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Definition: gnunet-daemon-hostlist_client.c:311
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_download_signal_suspend_
void GNUNET_FS_download_signal_suspend_(void *cls)
Create SUSPEND event for the given download operation and then clean up our state (without stop signa...
Definition: fs_download.c:1953
GNUNET_FS_DownloadContext::serialization
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1842
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_FS_SearchResult::h
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
GNUNET_FS_search_stop_probe_
static void GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
Stop probing activity associated with a search result.
Definition: fs_search.c:509
GNUNET_FS_DownloadContext::top
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1779
GNUNET_FS_DownloadContext::search
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none...
Definition: fs_api.h:1796
sc
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_FS_make_top
struct TopLevelActivity * GNUNET_FS_make_top(struct GNUNET_FS_Handle *h, SuspendSignalFunction ssf, void *ssf_cls)
Create a top-level activity entry.
Definition: fs_api.c:393
GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT
Notification that this download is no longer part of a recursive download or search but now a &#39;stand-...
Definition: gnunet_fs_service.h:606
GNUNET_FS_SearchResult::mandatory_missing
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:610
GNUNET_FS_SearchContext
Handle for controlling a search.
Definition: fs_api.h:1533
GNUNET_FS_SearchContext::h
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
GNUNET_FS_search_make_status_
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
GNUNET_FS_remove_sync_file_
void GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Remove serialization/deserialization file from disk.
Definition: fs_api.c:738
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1230
GNUNET_FS_ProgressInfo
Argument given to the progress callback with information about what is going on.
Definition: gnunet_fs_service.h:775
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 1728 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().

1731 {
1732  struct GNUNET_FS_SearchResult *sr = value;
1733 
1734  if (NULL != sr->update_search)
1735  {
1736  GNUNET_FS_search_stop (sr->update_search);
1737  GNUNET_assert (NULL == sr->update_search);
1738  }
1739  GNUNET_break (NULL == sr->probe_ctx);
1740  GNUNET_break (NULL == sr->probe_cancel_task);
1741  GNUNET_break (NULL == sr->client_info);
1742  GNUNET_free_non_null (sr->serialization);
1743  GNUNET_FS_uri_destroy (sr->uri);
1744  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
1745  GNUNET_free_non_null (sr->keyword_bitmap);
1746  GNUNET_free (sr);
1747  return GNUNET_OK;
1748 }
GNUNET_FS_SearchResult::client_info
void * client_info
Client info for this search result.
Definition: fs_api.h:548
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition: gnunet_common.h:859
GNUNET_FS_SearchResult::keyword_bitmap
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
GNUNET_FS_SearchResult::uri
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
GNUNET_OK
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_free_non_null
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Definition: gnunet_common.h:1239
GNUNET_FS_SearchResult::probe_ctx
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:554
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: gnunet_common.h:918
GNUNET_FS_SearchResult::update_search
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:566
value
static char * value
Value of the record to add/remove.
Definition: gnunet-namestore.c:152
GNUNET_FS_SearchResult
Information we store for each search result.
Definition: fs_api.h:511
GNUNET_CONTAINER_meta_data_destroy
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
Definition: container_meta_data.c:252
GNUNET_FS_uri_destroy
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
GNUNET_FS_SearchResult::meta
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
GNUNET_FS_SearchResult::serialization
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:571
GNUNET_FS_search_stop
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1757
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition: gnunet_common.h:1230
GNUNET_FS_SearchResult::probe_cancel_task
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
Here is the call graph for this function:
Here is the caller graph for this function:
Generated by   doxygen 1.8.13