DHT service

Distributed Hash Table. More...

Collaboration diagram for DHT service:

Data Structures
struct	GNUNET_DHT_HopSignature
	Message signed by a peer when doing path tracking. More...
struct	GNUNET_DHT_PathElement
	A (signed) path tracking a block's flow through the DHT is represented by an array of path elements, each consisting of a peer on the path and a signature by which the peer affirms its routing decision. More...

Macros
#define	GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY
	Default republication frequency for stored data in the DHT.
#define	GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL   16
	Maximum allowed replication level for all requests.

Typedefs
typedef void(*	GNUNET_DHT_GetIterator) (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *query_hash, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
	Iterator called on each result obtained for a DHT operation that expects a reply.
typedef void(*	GNUNET_DHT_MonitorGetCB) (void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_HashCode *key)
	Callback called on each GET request going through the DHT.
typedef void(*	GNUNET_DHT_MonitorGetRespCB) (void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)
	Callback called on each GET reply going through the DHT.
typedef void(*	GNUNET_DHT_MonitorPutCB) (void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_PeerIdentity *trunc_peer, unsigned int path_length, const struct GNUNET_DHT_PathElement *path, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)
	Callback called on each PUT request going through the DHT.
typedef void(*	GNUNET_DHT_HelloGetCallback) (void *cls, const char *hello_url)
	Signature called with the result of a HELLO GET operation.

Enumerations
enum	GNUNET_DHT_RouteOption {   GNUNET_DHT_RO_NONE = 0 , GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE = 1 , GNUNET_DHT_RO_RECORD_ROUTE = 2 , GNUNET_DHT_RO_FIND_APPROXIMATE = 4 ,   GNUNET_DHT_RO_TRUNCATED = 8 , GNUNET_DHT_RO_LAST_HOP = 32768 }
	Options for routing. More...

Functions
struct GNUNET_DHT_Handle *	GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
	Initialize the connection with the DHT service.
void	GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle)
	Shutdown connection with the DHT service.
struct GNUNET_DHT_PutHandle *	GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, size_t size, const void *data, struct GNUNET_TIME_Absolute exp, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
	Perform a PUT operation storing data in the DHT.
void	GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph)
	Cancels a DHT PUT operation.
struct GNUNET_DHT_GetHandle *	GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, const void *xquery, size_t xquery_size, GNUNET_DHT_GetIterator iter, void *iter_cls)
	Perform an asynchronous GET operation on the DHT identified.
void	GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle, unsigned int num_results, const struct GNUNET_HashCode *results)
	Tell the DHT not to return any of the following known results to this client.
void	GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
	Stop async DHT-get.
struct GNUNET_DHT_MonitorHandle *	GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, GNUNET_DHT_MonitorGetCB get_cb, GNUNET_DHT_MonitorGetRespCB get_resp_cb, GNUNET_DHT_MonitorPutCB put_cb, void *cb_cls)
	Start monitoring the local DHT service.
void	GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *handle)
	Stop monitoring.
char *	GNUNET_DHT_pp2s (const struct GNUNET_DHT_PathElement *path, unsigned int path_len)
	Convert a peer path to a human-readable string.
unsigned int	GNUNET_DHT_verify_path (const void *data, size_t data_size, struct GNUNET_TIME_Absolute exp_time, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_len, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_len, const struct GNUNET_PeerIdentity *me)
	Verify signatures on a path consisting of put_path and get_path in reverse order (starting at the last element of the get_path).
struct GNUNET_DHT_HelloGetHandle *	GNUNET_DHT_hello_get (struct GNUNET_DHT_Handle *dht_handle, GNUNET_DHT_HelloGetCallback cb, void *cb_cls)
	Obtain HELLO URL of the DHT identified by dht_handle.
void	GNUNET_DHT_hello_get_cancel (struct GNUNET_DHT_HelloGetHandle *hgh)
	Cancel hello get operation.
void	GNUNET_DHT_hello_offer (struct GNUNET_DHT_Handle *dht_handle, const char *url, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	Offer HELLO URL of the DHT identified by dht_handle.

Detailed Description

Distributed Hash Table.

See also

Documentation

Macro Definition Documentation

GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY

#define GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 60)

Default republication frequency for stored data in the DHT.

Definition at line 59 of file gnunet_dht_service.h.

{
  GNUNET_DHT_RO_NONE = 0,
 
  GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE = 1,
 
  GNUNET_DHT_RO_RECORD_ROUTE = 2,
 
  GNUNET_DHT_RO_FIND_APPROXIMATE = 4,
 
  GNUNET_DHT_RO_TRUNCATED = 8,
 
  GNUNET_DHT_RO_LAST_HOP = 32768
};
 
 
GNUNET_NETWORK_STRUCT_BEGIN
 
struct GNUNET_DHT_HopSignature
{
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_TIME_AbsoluteNBO expiration_time;
 
  struct GNUNET_HashCode h_data GNUNET_PACKED;
 
  struct GNUNET_PeerIdentity pred;
 
  struct GNUNET_PeerIdentity succ;
};
 
 
struct GNUNET_DHT_PathElement
{
  struct GNUNET_CRYPTO_EddsaSignature sig;
 
  struct GNUNET_PeerIdentity pred;
 
};
 
 
GNUNET_NETWORK_STRUCT_END
 
struct GNUNET_DHT_Handle *
GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                    unsigned int ht_len);
 
 
void
GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle);
 
 
/* *************** Standard API: get and put ******************* */
 
 
struct GNUNET_DHT_PutHandle;
 
 
struct GNUNET_DHT_PutHandle *
GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,
                const struct GNUNET_HashCode *key,
                uint32_t desired_replication_level,
                enum GNUNET_DHT_RouteOption options,
                enum GNUNET_BLOCK_Type type,
                size_t size,
                const void *data,
                struct GNUNET_TIME_Absolute exp,
                GNUNET_SCHEDULER_TaskCallback cont,
                void *cont_cls);
 
 
void
GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph);
 
 
typedef void
(*GNUNET_DHT_GetIterator) (void *cls,
                           struct GNUNET_TIME_Absolute exp,
                           const struct GNUNET_HashCode *query_hash,
                           const struct GNUNET_PeerIdentity *trunc_peer,
                           const struct GNUNET_DHT_PathElement *get_path,
                           unsigned int get_path_length,
                           const struct GNUNET_DHT_PathElement *put_path,
                           unsigned int put_path_length,
                           enum GNUNET_BLOCK_Type type,
                           size_t size,
                           const void *data);
 
 
struct GNUNET_DHT_GetHandle *
GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
                      enum GNUNET_BLOCK_Type type,
                      const struct GNUNET_HashCode *key,
                      uint32_t desired_replication_level,
                      enum GNUNET_DHT_RouteOption options,
                      const void *xquery,
                      size_t xquery_size,
                      GNUNET_DHT_GetIterator iter,
                      void *iter_cls);
 
 
void
GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle,
                                     unsigned int num_results,
                                     const struct GNUNET_HashCode *results);
 
void
GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle);
 
 
/* *************** Extended API: monitor ******************* */
 
struct GNUNET_DHT_MonitorHandle;
 
typedef void
(*GNUNET_DHT_MonitorGetCB) (void *cls,
                            enum GNUNET_DHT_RouteOption options,
                            enum GNUNET_BLOCK_Type type,
                            uint32_t hop_count,
                            uint32_t desired_replication_level,
                            const struct GNUNET_HashCode *key);
 
 
typedef void
(*GNUNET_DHT_MonitorGetRespCB) (void *cls,
                                enum GNUNET_BLOCK_Type type,
                                const struct GNUNET_PeerIdentity *trunc_peer,
                                const struct GNUNET_DHT_PathElement *get_path,
                                unsigned int get_path_length,
                                const struct GNUNET_DHT_PathElement *put_path,
                                unsigned int put_path_length,
                                struct GNUNET_TIME_Absolute exp,
                                const struct GNUNET_HashCode *key,
                                const void *data,
                                size_t size);
 
 
typedef void
(*GNUNET_DHT_MonitorPutCB) (void *cls,
                            enum GNUNET_DHT_RouteOption options,
                            enum GNUNET_BLOCK_Type type,
                            uint32_t hop_count,
                            uint32_t desired_replication_level,
                            const struct GNUNET_PeerIdentity *trunc_peer,
                            unsigned int path_length,
                            const struct GNUNET_DHT_PathElement *path,
                            struct GNUNET_TIME_Absolute exp,
                            const struct GNUNET_HashCode *key,
                            const void *data,
                            size_t size);
 
 
struct GNUNET_DHT_MonitorHandle *
GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle,
                          enum GNUNET_BLOCK_Type type,
                          const struct GNUNET_HashCode *key,
                          GNUNET_DHT_MonitorGetCB get_cb,
                          GNUNET_DHT_MonitorGetRespCB get_resp_cb,
                          GNUNET_DHT_MonitorPutCB put_cb,
                          void *cb_cls);
 
 
void
GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *handle);
 
 
char *
GNUNET_DHT_pp2s (const struct GNUNET_DHT_PathElement *path,
                 unsigned int path_len);
 
 
unsigned int
GNUNET_DHT_verify_path (const void *data,
                        size_t data_size,
                        struct GNUNET_TIME_Absolute exp_time,
                        const struct GNUNET_PeerIdentity *trunc_peer,
                        const struct GNUNET_DHT_PathElement *put_path,
                        unsigned int put_path_len,
                        const struct GNUNET_DHT_PathElement *get_path,
                        unsigned int get_path_len,
                        const struct GNUNET_PeerIdentity *me);
 
 
struct GNUNET_DHT_HelloGetHandle;
 
 
typedef void
(*GNUNET_DHT_HelloGetCallback)(void *cls,
                               const char *hello_url);
 
 
struct GNUNET_DHT_HelloGetHandle *
GNUNET_DHT_hello_get (struct GNUNET_DHT_Handle *dht_handle,
                      GNUNET_DHT_HelloGetCallback cb,
                      void *cb_cls);
 
 
void
GNUNET_DHT_hello_get_cancel (struct GNUNET_DHT_HelloGetHandle *hgh);
 
 
void
GNUNET_DHT_hello_offer (struct GNUNET_DHT_Handle *dht_handle,
                        const char *url,
                        GNUNET_SCHEDULER_TaskCallback cb,
                        void *cb_cls);
 
 
#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif
 
 
 

GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL

#define GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL   16

Maximum allowed replication level for all requests.

Definition at line 66 of file gnunet_dht_service.h.

Typedef Documentation

GNUNET_DHT_GetIterator

typedef void(* GNUNET_DHT_GetIterator) (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *query_hash, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)

Iterator called on each result obtained for a DHT operation that expects a reply.

Parameters

cls	closure
exp	when will this value expire
query_hash	key of the query
trunc_peer	peer where the path was truncated, or NULL if the path is complete
get_path	peers on reply path (or NULL if not recorded) [0] = datastore's first neighbor, [length - 1] = local peer
get_path_length	number of entries in get_path
put_path	peers on the PUT path (or NULL if not recorded) [0] = origin, [length - 1] = datastore
put_path_length	number of entries in put_path, note that the last signature will be all zeros as we did not forward and thus did not sign!
type	type of the result
size	number of bytes in data
data	pointer to the result data

Definition at line 288 of file gnunet_dht_service.h.

GNUNET_DHT_MonitorGetCB

typedef void(* GNUNET_DHT_MonitorGetCB) (void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_HashCode *key)

Callback called on each GET request going through the DHT.

Parameters

cls	Closure.
options	Options, for instance RecordRoute, DemultiplexEverywhere.
type	The type of data in the request.
hop_count	Hop count so far.
desired_replication_level	Desired replication level.
key	Key of the requested data.

Definition at line 371 of file gnunet_dht_service.h.

GNUNET_DHT_MonitorGetRespCB

typedef void(* GNUNET_DHT_MonitorGetRespCB) (void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)

Callback called on each GET reply going through the DHT.

Parameters

cls	Closure.
type	The type of data in the result.
trunc_peer	peer where the path was truncated, or NULL if the path is complete
get_path	Peers on GET path (or NULL if not recorded). note that the last signature will be all zeros as we did not forward and thus did not sign!
get_path_length	number of entries in get_path.
put_path	peers on the PUT path (or NULL if not recorded).
put_path_length	number of entries in get_path.
exp	Expiration time of the data.
key	Key of the data.
data	Pointer to the result data.
size	Number of bytes in data.

Definition at line 397 of file gnunet_dht_service.h.

GNUNET_DHT_MonitorPutCB

typedef void(* GNUNET_DHT_MonitorPutCB) (void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_PeerIdentity *trunc_peer, unsigned int path_length, const struct GNUNET_DHT_PathElement *path, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)

Callback called on each PUT request going through the DHT.

Parameters

cls	Closure.
options	Options, for instance RecordRoute, DemultiplexEverywhere.
type	The type of data in the request.
hop_count	Hop count so far.
desired_replication_level	Desired replication level.
trunc_peer	peer where the path was truncated, or NULL if the path is complete
path_length	number of entries in path (or 0 if not recorded).
path	peers on the PUT path (or NULL if not recorded). note that the last signature will be all zeros as we did not forward and thus did not sign!
exp	Expiration time of the data.
key	Key under which data is to be stored.
data	Pointer to the data carried.
size	Number of bytes in data.

Definition at line 429 of file gnunet_dht_service.h.

GNUNET_DHT_HelloGetCallback

typedef void(* GNUNET_DHT_HelloGetCallback) (void *cls, const char *hello_url)

Signature called with the result of a HELLO GET operation.

Parameters

cls	closure
hello_url	the resulting HELLO URL, NULL on error

Definition at line 533 of file gnunet_dht_service.h.

Enumeration Type Documentation

GNUNET_DHT_RouteOption

enum GNUNET_DHT_RouteOption

Options for routing.

Enumerator
GNUNET_DHT_RO_NONE	Default. Do nothing special.
GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE	Each peer along the way should process the request (otherwise only peers locally closest to the key when the random walk is over should look at it).
GNUNET_DHT_RO_RECORD_ROUTE	We should keep track of the route that the message took in the P2P network.
GNUNET_DHT_RO_FIND_APPROXIMATE	Approximate results are fine.
GNUNET_DHT_RO_TRUNCATED	Flag set if the path was truncated.
GNUNET_DHT_RO_LAST_HOP	Flag given to monitors if this was the last hop for a GET/PUT. This is only used for internal processing.

Definition at line 88 of file gnunet_dht_service.h.

{
  GNUNET_DHT_RO_NONE = 0,
 
  GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE = 1,
 
  GNUNET_DHT_RO_RECORD_ROUTE = 2,
 
  GNUNET_DHT_RO_FIND_APPROXIMATE = 4,
 
  GNUNET_DHT_RO_TRUNCATED = 8,
 
  GNUNET_DHT_RO_LAST_HOP = 32768
};

Function Documentation

GNUNET_DHT_connect()

struct GNUNET_DHT_Handle * GNUNET_DHT_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		unsigned int	ht_len
	)

Initialize the connection with the DHT service.

Parameters

cfg	configuration to use
ht_len	size of the internal hash table to use for processing multiple GET/FIND requests in parallel

Returns

NULL on error

Definition at line 1036 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle;
 
  handle = GNUNET_new (struct GNUNET_DHT_Handle);
  handle->cfg = cfg;
  handle->uid_gen
    = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                UINT64_MAX);
  handle->active_requests
    = GNUNET_CONTAINER_multihashmap_create (ht_len,
                                            GNUNET_YES);
  if (GNUNET_NO == try_connect (handle))
  {
    GNUNET_DHT_disconnect (handle);
    return NULL;
  }
  return handle;
}

References cfg, GNUNET_VPN_Handle::cfg, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_DHT_disconnect(), GNUNET_new, GNUNET_NO, GNUNET_YES, handle, and try_connect().

Referenced by advertise_dns_exit(), dht_ca(), dht_ca(), dht_connect(), GCD_init(), run(), run(), run(), run(), run(), run(), run(), run(), run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_disconnect()

void GNUNET_DHT_disconnect

(

struct GNUNET_DHT_Handle *

handle

)

Shutdown connection with the DHT service.

Parameters

handle

connection to shut down

Definition at line 1059 of file dht_api.c.

{
  struct GNUNET_DHT_PutHandle *ph;
 
  GNUNET_assert (0 ==
                 GNUNET_CONTAINER_multihashmap_size (handle->active_requests));
  while (NULL != (ph = handle->put_head))
  {
    if (NULL != ph->cont)
      ph->cont (ph->cont_cls);
    GNUNET_DHT_put_cancel (ph);
  }
  if (NULL != handle->mq)
  {
    GNUNET_MQ_destroy (handle->mq);
    handle->mq = NULL;
  }
  if (NULL != handle->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
    handle->reconnect_task = NULL;
  }
  GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests);
  GNUNET_free (handle);
}

References GNUNET_DHT_PutHandle::cont, GNUNET_DHT_PutHandle::cont_cls, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_DHT_put_cancel(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), handle, and GNUNET_VPN_Handle::mq.

Referenced by cleanup(), cleanup(), cleanup_task(), cleanup_task(), cleanup_task(), cleanup_task(), dht_da(), dht_da(), dht_disconnect(), GCD_shutdown(), GNUNET_DHT_connect(), shutdown_task(), shutdown_task(), shutdown_task(), shutdown_task(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_put()

struct GNUNET_DHT_PutHandle * GNUNET_DHT_put	(	struct GNUNET_DHT_Handle *	handle,
		const struct GNUNET_HashCode *	key,
		uint32_t	desired_replication_level,
		enum GNUNET_DHT_RouteOption	options,
		enum GNUNET_BLOCK_Type	type,
		size_t	size,
		const void *	data,
		struct GNUNET_TIME_Absolute	exp,
		GNUNET_SCHEDULER_TaskCallback	cont,
		void *	cont_cls
	)

Perform a PUT operation storing data in the DHT.

Parameters

handle	handle to DHT service
key	the key to store under
desired_replication_level	estimate of how many nearest peers this request should reach
options	routing options for this message
type	type of the value
size	number of bytes in data; must be less than 64k
data	the data to store
exp	desired expiration time for the value
cont	continuation to call when done (transmitting request to service) You must not call GNUNET_DHT_disconnect in this continuation
cont_cls	closure for cont

Returns

handle to cancel the "PUT" operation, NULL on error (size too big)

Definition at line 1087 of file dht_api.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_ClientPutMessage *put_msg;
  size_t msize;
  struct GNUNET_DHT_PutHandle *ph;
 
  if (0 == size)
  {
    GNUNET_break (0);
    return NULL;
  }
  msize = sizeof(struct GNUNET_DHT_ClientPutMessage) + size;
  if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
      (size >= GNUNET_MAX_MESSAGE_SIZE))
  {
    GNUNET_break (0);
    return NULL;
  }
  if (NULL == handle->mq)
    return NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending PUT for %s to DHT via %p\n",
       GNUNET_h2s (key),
       handle);
  ph = GNUNET_new (struct GNUNET_DHT_PutHandle);
  ph->dht_handle = handle;
  ph->cont = cont;
  ph->cont_cls = cont_cls;
  GNUNET_CONTAINER_DLL_insert_tail (handle->put_head,
                                    handle->put_tail,
                                    ph);
  env = GNUNET_MQ_msg_extra (put_msg,
                             size,
                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT);
  GNUNET_MQ_notify_sent (env,
                         &handle_put_cont,
                         ph);
  ph->env = env;
  put_msg->type = htonl ((uint32_t) type);
  put_msg->options = htonl ((uint32_t) options);
  put_msg->desired_replication_level = htonl (desired_replication_level);
  put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
  put_msg->key = *key;
  GNUNET_memcpy (&put_msg[1],
                 data,
                 size);
  GNUNET_MQ_send (handle->mq,
                  env);
  return ph;
}

References GNUNET_DHT_PutHandle::cont, GNUNET_DHT_PutHandle::cont_cls, data, GNUNET_DHT_ClientPutMessage::desired_replication_level, GNUNET_DHT_PutHandle::dht_handle, env, GNUNET_DHT_PutHandle::env, GNUNET_DHT_ClientPutMessage::expiration, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_new, GNUNET_TIME_absolute_hton(), handle, handle_put_cont(), key, GNUNET_DHT_ClientPutMessage::key, LOG, GNUNET_VPN_Handle::mq, options, GNUNET_DHT_ClientPutMessage::options, size, type, and GNUNET_DHT_ClientPutMessage::type.

Referenced by announce_id(), delayed_put(), do_dht_put(), initiate_put_from_pipe_trigger(), process_dht_put_content(), regex_iterator(), run(), and sign_accept_block().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_put_cancel()

void GNUNET_DHT_put_cancel

(

struct GNUNET_DHT_PutHandle *

ph

)

Cancels a DHT PUT operation.

Note that the PUT request may still go out over the network (we can't stop that); However, if the PUT has not yet been sent to the service, cancelling the PUT will stop this from happening (but there is no way for the user of this API to tell if that is the case). The only use for this API is to prevent a later call to 'cont' from GNUNET_DHT_put (e.g. because the system is shutting down).

Parameters

ph	put operation to cancel ('cont' will no longer be called)

Definition at line 1150 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = ph->dht_handle;
 
  if (NULL != ph->env)
    GNUNET_MQ_notify_sent (ph->env,
                           NULL,
                           NULL);
  GNUNET_CONTAINER_DLL_remove (handle->put_head,
                               handle->put_tail,
                               ph);
  GNUNET_free (ph);
}

References GNUNET_DHT_PutHandle::dht_handle, GNUNET_DHT_PutHandle::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_notify_sent(), and handle.

Referenced by cleanup(), do_dht_put(), do_disconnect(), do_shutdown(), GNUNET_DHT_disconnect(), GSF_put_done_(), handle_put_cont(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_get_start()

struct GNUNET_DHT_GetHandle * GNUNET_DHT_get_start	(	struct GNUNET_DHT_Handle *	handle,
		enum GNUNET_BLOCK_Type	type,
		const struct GNUNET_HashCode *	key,
		uint32_t	desired_replication_level,
		enum GNUNET_DHT_RouteOption	options,
		const void *	xquery,
		size_t	xquery_size,
		GNUNET_DHT_GetIterator	iter,
		void *	iter_cls
	)

Perform an asynchronous GET operation on the DHT identified.

See also #GNUNET_BLOCK_evaluate.

Parameters

handle	handle to the DHT service
type	expected type of the response object
key	the key to look up
desired_replication_level	estimate of how many nearest peers this request should reach
options	routing options for this message
xquery	extended query data (can be NULL, depending on type)
xquery_size	number of bytes in xquery
iter	function to call on each result
iter_cls	closure for iter

Returns

handle to stop the async get

Definition at line 1166 of file dht_api.c.

{
  struct GNUNET_DHT_GetHandle *gh;
  size_t msize;
 
  msize = sizeof(struct GNUNET_DHT_ClientGetMessage) + xquery_size;
  if ((msize >= GNUNET_MAX_MESSAGE_SIZE) ||
      (xquery_size >= GNUNET_MAX_MESSAGE_SIZE))
  {
    GNUNET_break (0);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending query for %s to DHT %p\n",
       GNUNET_h2s (key),
       handle);
  gh = GNUNET_malloc (sizeof(struct GNUNET_DHT_GetHandle)
                      + xquery_size);
  gh->iter = iter;
  gh->iter_cls = iter_cls;
  gh->dht_handle = handle;
  gh->key = *key;
  gh->unique_id = ++handle->uid_gen;
  gh->xquery_size = xquery_size;
  gh->desired_replication_level = desired_replication_level;
  gh->type = type;
  gh->options = options;
  GNUNET_memcpy (&gh[1],
                 xquery,
                 xquery_size);
  GNUNET_CONTAINER_multihashmap_put (handle->active_requests,
                                     &gh->key,
                                     gh,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  if (NULL != handle->mq)
    send_get (gh);
  return gh;
}

References GNUNET_DHT_ClientGetMessage::desired_replication_level, GNUNET_DHT_GetHandle::desired_replication_level, GNUNET_DHT_GetHandle::dht_handle, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, handle, GNUNET_DHT_GetHandle::iter, GNUNET_DHT_GetHandle::iter_cls, key, GNUNET_DHT_GetHandle::key, LOG, GNUNET_VPN_Handle::mq, options, GNUNET_DHT_GetHandle::options, send_get(), type, GNUNET_DHT_GetHandle::type, GNUNET_DHT_GetHandle::unique_id, and GNUNET_DHT_GetHandle::xquery_size.

Referenced by delayed_get(), GCD_search(), GSF_dht_lookup_(), regex_find_path(), REGEX_INTERNAL_search(), regex_next_edge(), run(), run(), and start_dht_request().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_get_filter_known_results()

void GNUNET_DHT_get_filter_known_results	(	struct GNUNET_DHT_GetHandle *	get_handle,
		unsigned int	num_results,
		const struct GNUNET_HashCode *	results
	)

Tell the DHT not to return any of the following known results to this client.

Parameters

get_handle	get operation for which results should be filtered
num_results	number of results to be blocked that are provided in this call (size of the results array)
results	array of hash codes over the data of the results to be blocked

Definition at line 1215 of file dht_api.c.

{
  unsigned int needed;
  unsigned int had;
 
  had = get_handle->seen_results_end;
  needed = had + num_results;
  if (needed > get_handle->seen_results_size)
    GNUNET_array_grow (get_handle->seen_results,
                       get_handle->seen_results_size,
                       needed);
  GNUNET_memcpy (&get_handle->seen_results[get_handle->seen_results_end],
                 results,
                 num_results * sizeof(struct GNUNET_HashCode));
  get_handle->seen_results_end += num_results;
  if (NULL != get_handle->dht_handle->mq)
    send_get_known_results (get_handle,
                            had);
}

References GNUNET_DHT_GetHandle::dht_handle, get_handle, GNUNET_array_grow, GNUNET_memcpy, GNUNET_DHT_Handle::mq, results, GNUNET_DHT_GetHandle::seen_results, GNUNET_DHT_GetHandle::seen_results_end, GNUNET_DHT_GetHandle::seen_results_size, and send_get_known_results().

Referenced by GSF_dht_lookup_(), and GSF_pending_request_update_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_get_stop()

void GNUNET_DHT_get_stop

(

struct GNUNET_DHT_GetHandle *

get_handle

)

Stop async DHT-get.

Frees associated resources.

Parameters

get_handle

GET operation to stop.

Definition at line 1239 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = get_handle->dht_handle;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending STOP for %s to DHT via %p\n",
       GNUNET_h2s (&get_handle->key),
       handle);
  if (NULL != handle->mq)
  {
    struct GNUNET_MQ_Envelope *env;
    struct GNUNET_DHT_ClientGetStopMessage *stop_msg;
 
    env = GNUNET_MQ_msg (stop_msg,
                         GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);
    stop_msg->reserved = htonl (0);
    stop_msg->unique_id = get_handle->unique_id;
    stop_msg->key = get_handle->key;
    GNUNET_MQ_send (handle->mq,
                    env);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (handle->active_requests,
                                                       &get_handle->key,
                                                       get_handle));
  GNUNET_array_grow (get_handle->seen_results,
                     get_handle->seen_results_end,
                     0);
  GNUNET_free (get_handle);
}

References GNUNET_DHT_GetHandle::dht_handle, env, get_handle, GNUNET_array_grow, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, handle, GNUNET_DHT_ClientGetStopMessage::key, GNUNET_DHT_GetHandle::key, LOG, GNUNET_VPN_Handle::mq, GNUNET_DHT_ClientGetStopMessage::reserved, GNUNET_DHT_GetHandle::seen_results, GNUNET_DHT_GetHandle::seen_results_end, GNUNET_DHT_ClientGetStopMessage::unique_id, and GNUNET_DHT_GetHandle::unique_id.

Referenced by cancel_get(), clean_request(), cleanup(), cleanup_task(), do_shutdown(), GCD_search_stop(), get_iter(), get_result_iterator(), GNS_resolver_lookup_cancel(), GSF_dht_lookup_(), GSF_pending_request_cancel_(), handle_dht_response(), and regex_cancel_dht_get().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_monitor_start()

struct GNUNET_DHT_MonitorHandle * GNUNET_DHT_monitor_start	(	struct GNUNET_DHT_Handle *	handle,
		enum GNUNET_BLOCK_Type	type,
		const struct GNUNET_HashCode *	key,
		GNUNET_DHT_MonitorGetCB	get_cb,
		GNUNET_DHT_MonitorGetRespCB	get_resp_cb,
		GNUNET_DHT_MonitorPutCB	put_cb,
		void *	cb_cls
	)

Start monitoring the local DHT service.

Parameters

handle	Handle to the DHT service.
type	Type of blocks that are of interest.
key	Key of data of interest, NULL for all.
get_cb	Callback to process monitored get messages.
get_resp_cb	Callback to process monitored get response messages.
put_cb	Callback to process monitored put messages.
cb_cls	Closure for callbacks

Returns

Handle to stop monitoring.

Definition at line 1272 of file dht_api.c.

{
  struct GNUNET_DHT_MonitorHandle *mh;
 
  mh = GNUNET_new (struct GNUNET_DHT_MonitorHandle);
  mh->get_cb = get_cb;
  mh->get_resp_cb = get_resp_cb;
  mh->put_cb = put_cb;
  mh->cb_cls = cb_cls;
  mh->type = type;
  mh->dht_handle = handle;
  if (NULL != key)
  {
    mh->key = GNUNET_new (struct GNUNET_HashCode);
    *mh->key = *key;
  }
  GNUNET_CONTAINER_DLL_insert (handle->monitor_head,
                               handle->monitor_tail,
                               mh);
  if (NULL != handle->mq)
    send_monitor_start (mh);
  return mh;
}

References GNUNET_DHT_MonitorHandle::cb_cls, get_cb(), GNUNET_DHT_MonitorHandle::get_resp_cb, GNUNET_CONTAINER_DLL_insert, GNUNET_new, handle, key, mh, GNUNET_VPN_Handle::mq, put_cb(), send_monitor_start(), and type.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_monitor_stop()

void GNUNET_DHT_monitor_stop

(

struct GNUNET_DHT_MonitorHandle *

handle

)

Stop monitoring.

On return handle will no longer be valid, caller must not use it anymore.

Parameters

handle

The handle to the monitor request returned by GNUNET_DHT_monitor_start().

Definition at line 1304 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = mh->dht_handle;
  struct GNUNET_DHT_MonitorStartStopMessage *m;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_CONTAINER_DLL_remove (handle->monitor_head,
                               handle->monitor_tail,
                               mh);
  env = GNUNET_MQ_msg (m,
                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP);
  m->type = htonl (mh->type);
  m->get = htons (NULL != mh->get_cb);
  m->get_resp = htons (NULL != mh->get_resp_cb);
  m->put = htons (NULL != mh->put_cb);
  if (NULL != mh->key)
  {
    m->filter_key = htons (1);
    m->key = *mh->key;
  }
  GNUNET_MQ_send (handle->mq,
                  env);
  GNUNET_free (mh->key);
  GNUNET_free (mh);
}

References env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, m, mh, and GNUNET_VPN_Handle::mq.

Referenced by cleanup_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_pp2s()

char * GNUNET_DHT_pp2s	(	const struct GNUNET_DHT_PathElement *	path,
		unsigned int	path_len
	)

Convert a peer path to a human-readable string.

Parameters

path	array of path elements to convert to a string
path_len	length of the path array

Returns

string representing the array of pids

Definition at line 1332 of file dht_api.c.

{
  char *buf;
  size_t off;
  size_t plen = path_len * 5 + 1;
 
  GNUNET_assert (path_len < UINT32_MAX / 5);
  off = 0;
  buf = GNUNET_malloc (plen);
  for (unsigned int i = 0; i < path_len; i++)
  {
    off += GNUNET_snprintf (&buf[off],
                            plen - off,
                            "%s%s",
                            GNUNET_i2s (&path[i].pred),
                            (i == path_len - 1) ? "" : "-");
  }
  return buf;
}

References GNUNET_assert, GNUNET_i2s(), GNUNET_malloc, and GNUNET_snprintf().

Referenced by process_client_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_verify_path()

unsigned int GNUNET_DHT_verify_path	(	const void *	data,
		size_t	data_size,
		struct GNUNET_TIME_Absolute	exp_time,
		const struct GNUNET_PeerIdentity *	trunc_peer,
		const struct GNUNET_DHT_PathElement *	put_path,
		unsigned int	put_path_len,
		const struct GNUNET_DHT_PathElement *	get_path,
		unsigned int	get_path_len,
		const struct GNUNET_PeerIdentity *	me
	)

Verify signatures on a path consisting of put_path and get_path in reverse order (starting at the last element of the get_path).

Note that the last signature on the path is never verified as that is the slot where our peer (me) would need to sign.

Parameters

data	payload (the block)
data_size	number of bytes in data
exp_time	expiration time of data
trunc_peer	peer which signature was broken or where the path was truncated, NULL if path is not truncated
get_path	array of path elements to verify
get_path_len	length of the get_path array
put_path	array of path elements to verify
put_path_len	length of the put_path array
me	our own peer identity (needed to verify the last element)

Returns

0 on success, otherwise the index of the last path element that succeeded with verification; get_path_len + put_path_len if no signature was valid

Definition at line 1355 of file dht_api.c.

{
  static struct GNUNET_PeerIdentity zero;
  struct GNUNET_DHT_HopSignature hs = {
    .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_DHT_HOP),
    .purpose.size = htonl (sizeof (hs)),
    .expiration_time = GNUNET_TIME_absolute_hton (exp_time)
  };
  unsigned int i;
 
  if (0 == get_path_len + put_path_len)
    return 0;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%s is verifying signatures with GPL: %u PPL: %u!\n",
              GNUNET_i2s (me),
              get_path_len,
              put_path_len);
  for (unsigned int j = 0; j<put_path_len; j++)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "PP%u=%s\n",
                j,
                GNUNET_i2s (&put_path[j].pred));
  for (unsigned int j = 0; j<get_path_len; j++)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "GP%u=%s\n",
                j,
                GNUNET_i2s (&get_path[j].pred));
  GNUNET_CRYPTO_hash (data,
                      data_size,
                      &hs.h_data);
  i = put_path_len + get_path_len;
  while (i > 0)
  {
    const struct GNUNET_PeerIdentity *pred;
    const struct GNUNET_PeerIdentity *succ;
    const struct GNUNET_DHT_PathElement *pe;
 
    i--;
    if (0 == i)
    {
      pred = (NULL == bpid) ? &zero : bpid;
    }
    else
    {
      unsigned int off = i - 1;
 
      pred = (off >= put_path_len)
        ? &get_path[off - put_path_len].pred
        : &put_path[off].pred;
    }
    if (i == get_path_len + put_path_len - 1)
    {
      succ = me;
    }
    else
    {
      unsigned int off = i + 1;
 
      succ = (off >= put_path_len)
        ? &get_path[off - put_path_len].pred
        : &put_path[off].pred;
    }
    hs.pred = *pred;
    hs.succ = *succ;
    pe = (i >= put_path_len)
      ? &get_path[i - put_path_len]
      : &put_path[i];
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_verify (
          GNUNET_SIGNATURE_PURPOSE_DHT_HOP,
          &hs,
          &pe->sig,
          &pe->pred.public_key))
    {
      GNUNET_break_op (0);
      return i + 1;
    }
  }
  return i;
}

References data, data_size, GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_DHT_HOP, GNUNET_TIME_absolute_hton(), GNUNET_DHT_HopSignature::h_data, me, GNUNET_DHT_HopSignature::pred, GNUNET_DHT_PathElement::pred, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_SignaturePurpose::purpose, GNUNET_DHT_HopSignature::purpose, GNUNET_DHT_PathElement::sig, GNUNET_DHT_HopSignature::succ, and zero.

Referenced by cb_path_signed(), forward_reply(), GDS_CLIENTS_handle_reply(), GDS_helper_put_message_get_size(), GDS_NEIGHBOURS_handle_reply(), get_result_iterator(), handle_dht_p2p_put(), and handle_dht_p2p_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_hello_get()

struct GNUNET_DHT_HelloGetHandle * GNUNET_DHT_hello_get	(	struct GNUNET_DHT_Handle *	dht_handle,
		GNUNET_DHT_HelloGetCallback	cb,
		void *	cb_cls
	)

Obtain HELLO URL of the DHT identified by dht_handle.

Parameters

dht_handle	DHT to query
cb	function to call with the result
cb_cls	closure for cb

Returns

NULL on failure

Definition at line 1446 of file dht_api.c.

{
  struct GNUNET_DHT_HelloGetHandle *hgh;
  struct GNUNET_MessageHeader *hdr;
  struct GNUNET_MQ_Envelope *env;
 
  hgh = GNUNET_new (struct GNUNET_DHT_HelloGetHandle);
  hgh->cb = cb;
  hgh->cb_cls = cb_cls;
  hgh->dht_handle = dht_handle;
  GNUNET_CONTAINER_DLL_insert (dht_handle->hgh_head,
                               dht_handle->hgh_tail,
                               hgh);
  env = GNUNET_MQ_msg (hdr,
                       GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_GET);
  GNUNET_MQ_send (dht_handle->mq,
                  env);
  return hgh;
}

References GNUNET_DHT_HelloGetHandle::cb, GNUNET_DHT_HelloGetHandle::cb_cls, dht_handle, GNUNET_DHT_HelloGetHandle::dht_handle, env, GNUNET_CONTAINER_DLL_insert, GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_GET, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_DHT_Handle::hgh_head, GNUNET_DHT_Handle::hgh_tail, and GNUNET_DHT_Handle::mq.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DHT_hello_get_cancel()

void GNUNET_DHT_hello_get_cancel

(

struct GNUNET_DHT_HelloGetHandle *

hgh

)

Cancel hello get operation.

Parameters

[in]

hgh

operation to cancel.

Definition at line 1470 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *dht_handle = hgh->dht_handle;
 
  GNUNET_CONTAINER_DLL_remove (dht_handle->hgh_head,
                               dht_handle->hgh_tail,
                               hgh);
  GNUNET_free (hgh);
}

References dht_handle, GNUNET_DHT_HelloGetHandle::dht_handle, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_DHT_Handle::hgh_head, and GNUNET_DHT_Handle::hgh_tail.

Referenced by cleanup_task(), and handle_client_hello().

Here is the caller graph for this function:

GNUNET_DHT_hello_offer()

void GNUNET_DHT_hello_offer	(	struct GNUNET_DHT_Handle *	dht_handle,
		const char *	url,
		GNUNET_SCHEDULER_TaskCallback	cb,
		void *	cb_cls
	)

Offer HELLO URL of the DHT identified by dht_handle.

Callback may be invoked once, only way to cancel is to disconnect dht_handle.

Parameters

dht_handle	DHT to query
url	URL with a HELLO to offer to the DHT
cb	function called when done
cb_cls	closure for cb

Definition at line 1482 of file dht_api.c.

{
  struct GNUNET_MessageHeader *hdr;
  size_t slen = strlen (url) + 1;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg_extra (hdr,
                             slen,
                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL);
  memcpy (&hdr[1],
          url,
          slen);
  GNUNET_MQ_notify_sent (env,
                         cb,
                         cb_cls);
  GNUNET_MQ_send (dht_handle->mq,
                  env);
}

References dht_handle, env, GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), and GNUNET_DHT_Handle::mq.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function: