GNUnet 0.21.1
plugin_dhtu_gnunet.c File Reference

plain IP based DHT network underlay More...

Include dependency graph for plugin_dhtu_gnunet.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_DHTU_Source
 Opaque handle that the underlay offers for our address to be used when sending messages to another peer. More...
 
struct  GNUNET_DHTU_Target
 Opaque handle that the underlay offers for the target peer when sending messages to another peer. More...
 
struct  GNUNET_DHTU_PreferenceHandle
 Opaque handle expressing a preference of the DHT to keep a particular target connected. More...
 
struct  Plugin
 Handle for a plugin. More...
 

Functions

static void gnunet_try_connect (void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
 Request creation of a session with a peer at the given address. More...
 
static struct GNUNET_DHTU_PreferenceHandlegnunet_hold (void *cls, struct GNUNET_DHTU_Target *target)
 Request underlay to keep the connection to target alive if possible. More...
 
static void gnunet_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
 Do no long request underlay to keep the connection alive. More...
 
static void gnunet_send (void *cls, struct GNUNET_DHTU_Target *target, const void *msg, size_t msg_size, GNUNET_SCHEDULER_TaskCallback finished_cb, void *finished_cb_cls)
 Send message to some other participant over the network. More...
 
static void * core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
 Method called whenever a given peer connects. More...
 
static void core_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
 Method called whenever a peer disconnects. More...
 
static void add_addr (void *cls, const struct GNUNET_PeerIdentity *pid, const char *addr)
 
static void peerinfo_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 Find the hello for our identity and then pass it to the DHT as a URL. More...
 
static void error_cb (void *cls)
 
static void sync_cb (void *cls)
 
static void core_init_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
 Function called after GNUNET_CORE_connect has succeeded (or failed for good). More...
 
static int check_core_message (void *cls, const struct GNUNET_MessageHeader *msg)
 Anything goes, always return GNUNET_OK. More...
 
static void handle_core_message (void *cls, const struct GNUNET_MessageHeader *msg)
 Handle message from CORE for the DHT. More...
 
static void nse_cb (void *cls, struct GNUNET_TIME_Absolute timestamp, double logestimate, double std_dev)
 Callback to call when network size estimate is updated. More...
 
void * DHTU_gnunet_done (struct GNUNET_DHTU_PluginFunctions *api)
 Exit point from the plugin. More...
 
struct GNUNET_DHTU_PluginFunctionsDHTU_gnunet_init (struct GNUNET_DHTU_PluginEnvironment *env)
 Entry point for the plugin. More...
 

Detailed Description

plain IP based DHT network underlay

Author
Christian Grothoff

Definition in file plugin_dhtu_gnunet.c.

Function Documentation

◆ gnunet_try_connect()

static void gnunet_try_connect ( void *  cls,
const struct GNUNET_PeerIdentity pid,
const char *  address 
)
static

Request creation of a session with a peer at the given address.

Parameters
clsclosure (internal context for the plugin)
pidtarget identity of the peer to connect to
addresstarget address to connect to

Definition at line 191 of file plugin_dhtu_gnunet.c.

194{
195 struct Plugin *plugin = cls;
196 enum GNUNET_NetworkType nt = 0;
197 char *addr;
198 const char *eou;
199 int pfx_len;
200
201 eou = strstr (address,
202 "://");
203 if (NULL == eou)
204 {
205 GNUNET_break (0);
206 return;
207 }
208 pfx_len = eou - address;
209 eou += 3;
210 GNUNET_asprintf (&addr,
211 "%.*s-%s",
212 pfx_len,
213 address,
214 eou);
216 pid,
217 nt,
218 addr);
219 GNUNET_free (addr);
220}
static struct GNUNET_TESTING_PluginFunctions * plugin
Plugin to dynamically load a test case.
static char * address
GNS address for this phone.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
void GNUNET_TRANSPORT_application_validate(struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_NetworkType nt, const char *addr)
An application (or a communicator) has received a HELLO (or other address data of another peer) and w...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:44
Handle for a plugin.
Definition: block.c:38

References address, GNUNET_asprintf(), GNUNET_break, GNUNET_free, GNUNET_TRANSPORT_application_validate(), nt, pid, and plugin.

Referenced by DHTU_gnunet_init().

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

◆ gnunet_hold()

static struct GNUNET_DHTU_PreferenceHandle * gnunet_hold ( void *  cls,
struct GNUNET_DHTU_Target target 
)
static

Request underlay to keep the connection to target alive if possible.

Hold may be called multiple times to express a strong preference to keep a connection, say because a target is in multiple tables.

Parameters
clsclosure
targetconnection to keep alive

Definition at line 232 of file plugin_dhtu_gnunet.c.

234{
235 struct Plugin *plugin = cls;
237
239 ph->target = target;
242 ph);
243 target->ph_count++;
244 if (NULL != target->ash)
246 target->ash
248 &target->pid,
251 return ph;
252}
struct GNUNET_TRANSPORT_ApplicationSuggestHandle * GNUNET_TRANSPORT_application_suggest(struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_MQ_PriorityPreferences pk, struct GNUNET_BANDWIDTH_Value32NBO bw)
An application would like TRANSPORT to connect to a peer.
void GNUNET_TRANSPORT_application_suggest_cancel(struct GNUNET_TRANSPORT_ApplicationSuggestHandle *sh)
We no longer care about being connected to a peer.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
@ GNUNET_MQ_PRIO_BEST_EFFORT
Best-effort traffic (e.g.
Opaque handle expressing a preference of the DHT to keep a particular target connected.
struct GNUNET_DHTU_Target * target
Target a preference was expressed for.
struct GNUNET_TRANSPORT_ApplicationSuggestHandle * ash
Transport suggest handle.
struct GNUNET_DHTU_PreferenceHandle * ph_head
Head of preferences expressed for this target.
unsigned int ph_count
Preference counter, length of the ph_head DLL.
struct GNUNET_DHTU_PreferenceHandle * ph_tail
Tail of preferences expressed for this target.
struct GNUNET_PeerIdentity pid
Identity of this peer.

References GNUNET_DHTU_Target::ash, GNUNET_BANDWIDTH_ZERO, GNUNET_CONTAINER_DLL_insert, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_new, GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, GNUNET_DHTU_Target::pid, plugin, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by DHTU_gnunet_init().

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

◆ gnunet_drop()

static void gnunet_drop ( struct GNUNET_DHTU_PreferenceHandle ph)
static

Do no long request underlay to keep the connection alive.

Parameters
clsclosure
targetconnection to keep alive

Definition at line 262 of file plugin_dhtu_gnunet.c.

263{
264 struct GNUNET_DHTU_Target *target = ph->target;
265 struct Plugin *plugin = target->plugin;
266
268 target->ph_tail,
269 ph);
270 target->ph_count--;
271 GNUNET_free (ph);
272 if (NULL != target->ash)
274 if (0 == target->ph_count)
275 target->ash = NULL;
276 else
277 target->ash
279 &target->pid,
282}
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Opaque handle that the underlay offers for the target peer when sending messages to another peer.
struct Plugin * plugin
Our plugin with its environment.

References GNUNET_DHTU_Target::ash, GNUNET_BANDWIDTH_ZERO, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, GNUNET_DHTU_Target::pid, plugin, GNUNET_DHTU_Target::plugin, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by DHTU_gnunet_init().

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

◆ gnunet_send()

static void gnunet_send ( void *  cls,
struct GNUNET_DHTU_Target target,
const void *  msg,
size_t  msg_size,
GNUNET_SCHEDULER_TaskCallback  finished_cb,
void *  finished_cb_cls 
)
static

Send message to some other participant over the network.

Note that sending is not guaranteeing that the other peer actually received the message. For any given target, the DHT must wait for the finished_cb to be called before calling send() again.

Parameters
clsclosure (internal context for the plugin)
targetreceiver identification
msgmessage
msg_sizenumber of bytes in msg
finished_cbfunction called once transmission is done (not called if target disconnects, then only the disconnect_cb is called).
finished_cb_clsclosure for finished_cb

Definition at line 301 of file plugin_dhtu_gnunet.c.

307{
308 struct GNUNET_MQ_Envelope *env;
309 struct GNUNET_MessageHeader *cmsg;
310
311 env = GNUNET_MQ_msg_extra (cmsg,
312 msg_size,
316 finished_cb_cls);
317 memcpy (&cmsg[1],
318 msg,
319 msg_size);
320 GNUNET_MQ_send (target->mq,
321 env);
322}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void finished_cb(void *cls, enum GNUNET_GenericReturnValue rv)
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
#define GNUNET_MESSAGE_TYPE_DHT_CORE
Encapsulation of DHT messages in CORE service.
struct GNUNET_MQ_Handle * mq
CORE MQ to send messages to this peer.
Header for all communications.

References env, finished_cb(), GNUNET_MESSAGE_TYPE_DHT_CORE, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_DHTU_Target::mq, and msg.

Referenced by DHTU_gnunet_init().

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

◆ core_connect_cb()

static void * core_connect_cb ( void *  cls,
const struct GNUNET_PeerIdentity peer,
struct GNUNET_MQ_Handle mq 
)
static

Method called whenever a given peer connects.

Parameters
clsclosure
peerpeer identity this notification is about
Returns
closure associated with peer. given to mq callbacks and GNUNET_CORE_DisconnectEventHandler

Definition at line 334 of file plugin_dhtu_gnunet.c.

337{
338 struct Plugin *plugin = cls;
339 struct GNUNET_DHTU_Target *target;
340
341 target = GNUNET_new (struct GNUNET_DHTU_Target);
342 target->plugin = plugin;
343 target->mq = mq;
344 target->pid = *peer;
345 plugin->env->connect_cb (plugin->env->cls,
346 target,
347 &target->pid,
348 &target->app_ctx);
349 return target;
350}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
void * app_ctx
Application context for this target.
void * cls
Closure to pass to start_testcase.

References GNUNET_DHTU_Target::app_ctx, GNUNET_TESTING_PluginFunctions::cls, GNUNET_new, mq, GNUNET_DHTU_Target::mq, GNUNET_DHTU_Target::pid, plugin, and GNUNET_DHTU_Target::plugin.

Referenced by DHTU_gnunet_init().

Here is the caller graph for this function:

◆ core_disconnect_cb()

static void core_disconnect_cb ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  peer_cls 
)
static

Method called whenever a peer disconnects.

Parameters
clsclosure
peerpeer identity this notification is about
peer_clsclosure associated with peer. given in GNUNET_CORE_ConnectEventHandler

Definition at line 362 of file plugin_dhtu_gnunet.c.

365{
366 struct Plugin *plugin = cls;
367 struct GNUNET_DHTU_Target *target = peer_cls;
368
369 plugin->env->disconnect_cb (target->app_ctx);
370 if (NULL != target->ash)
372 GNUNET_free (target);
373}

References GNUNET_DHTU_Target::app_ctx, GNUNET_DHTU_Target::ash, GNUNET_free, GNUNET_TRANSPORT_application_suggest_cancel(), and plugin.

Referenced by DHTU_gnunet_init().

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

◆ add_addr()

static void add_addr ( void *  cls,
const struct GNUNET_PeerIdentity pid,
const char *  addr 
)
static

Definition at line 377 of file plugin_dhtu_gnunet.c.

380{
381 struct Plugin *plugin = cls;
382
384 "peerinfo_cb addr %s\n",
385 addr);
386 plugin->env->address_add_cb (plugin->env->cls,
387 addr,
388 &plugin->src,
389 &plugin->src.app_ctx);
390}
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG

References GNUNET_TESTING_PluginFunctions::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and plugin.

Referenced by peerinfo_cb().

Here is the caller graph for this function:

◆ peerinfo_cb()

static void peerinfo_cb ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Find the hello for our identity and then pass it to the DHT as a URL.

Note that we only add addresses, never remove them, due to limitations of the current peerinfo/core/transport APIs. This will change with TNG.

Parameters
clsa struct Plugin
peerid of the peer, NULL for last call
hellohello message for the peer (can be NULL)
err_msgmessage

Definition at line 406 of file plugin_dhtu_gnunet.c.

409{
410 struct Plugin *plugin = cls;
412 struct GNUNET_MessageHeader *hello;
413
414 hello = record->value;
415 if (NULL == hello)
416 return;
417 if (0 !=
418 GNUNET_memcmp (&record->peer,
419 &plugin->my_identity))
420 {
421 GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
422 return;
423 }
426 add_addr,
427 plugin);
429 GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
430}
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static struct HostSet * builder
NULL if we are not currently iterating over peer information.
void GNUNET_HELLO_builder_free(struct GNUNET_HELLO_Builder *builder)
Release resources of a builder.
Definition: hello-uri.c:373
const struct GNUNET_PeerIdentity * GNUNET_HELLO_builder_iterate(const struct GNUNET_HELLO_Builder *builder, GNUNET_HELLO_UriCallback uc, void *uc_cls)
Iterate over URIs in a builder.
Definition: hello-uri.c:909
struct GNUNET_HELLO_Builder * GNUNET_HELLO_builder_from_msg(const struct GNUNET_MessageHeader *msg)
Parse msg into builder.
Definition: hello-uri.c:391
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
void GNUNET_PEERSTORE_monitor_next(struct GNUNET_PEERSTORE_Monitor *zm, uint64_t limit)
Calls the monitor processor specified in GNUNET_PEERSTORE_monitor_start for the next record(s).
static void add_addr(void *cls, const struct GNUNET_PeerIdentity *pid, const char *addr)
Context for building (or parsing) HELLO URIs.
Definition: hello-uri.c:205

References add_addr(), builder, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_msg(), GNUNET_HELLO_builder_iterate(), GNUNET_memcmp, GNUNET_PEERSTORE_monitor_next(), plugin, and record().

Referenced by core_init_cb().

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

◆ error_cb()

static void error_cb ( void *  cls)
static

Definition at line 434 of file plugin_dhtu_gnunet.c.

435{
437 "Error in PEERSTORE monitoring\n");
438}
@ GNUNET_ERROR_TYPE_WARNING

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by core_init_cb().

Here is the caller graph for this function:

◆ sync_cb()

static void sync_cb ( void *  cls)
static

Definition at line 442 of file plugin_dhtu_gnunet.c.

443{
445 "Done with initial PEERSTORE iteration during monitoring\n");
446}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by core_init_cb().

Here is the caller graph for this function:

◆ core_init_cb()

static void core_init_cb ( void *  cls,
const struct GNUNET_PeerIdentity my_identity 
)
static

Function called after GNUNET_CORE_connect has succeeded (or failed for good).

Note that the private key of the peer is intentionally not exposed here; if you need it, your process should try to read the private key file directly (which should work if you are authorized...). Implementations of this function must not call GNUNET_CORE_disconnect (other than by scheduling a new task to do this later).

Parameters
clsclosure
my_identityID of this peer, NULL if we failed

Definition at line 462 of file plugin_dhtu_gnunet.c.

464{
465 struct Plugin *plugin = cls;
466
467 plugin->my_identity = *my_identity;
468 plugin->peerstore_notify = GNUNET_PEERSTORE_monitor_start (plugin->env->cfg,
470 "peerstore",
471 NULL,
473 &error_cb,
474 NULL,
475 &sync_cb,
476 NULL,
478 plugin);
479}
struct GNUNET_PeerIdentity my_identity
Our peer identity.
@ GNUNET_YES
struct GNUNET_PEERSTORE_Monitor * GNUNET_PEERSTORE_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, int iterate_first, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Request watching a given key The monitoring can be filtered to contain only records matching peer and...
#define GNUNET_PEERSTORE_HELLO_KEY
Key used for storing HELLO in the peerstore.
static void sync_cb(void *cls)
static void error_cb(void *cls)
static void peerinfo_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Find the hello for our identity and then pass it to the DHT as a URL.

References error_cb(), GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_YES, my_identity, peerinfo_cb(), plugin, and sync_cb().

Referenced by DHTU_gnunet_init().

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

◆ check_core_message()

static int check_core_message ( void *  cls,
const struct GNUNET_MessageHeader msg 
)
static

Anything goes, always return GNUNET_OK.

Parameters
clsunused
msgmessage to check
Returns
GNUNET_OK if all is fine

Definition at line 490 of file plugin_dhtu_gnunet.c.

492{
493 (void) cls;
494 (void) msg;
495 return GNUNET_OK;
496}
@ GNUNET_OK

References GNUNET_OK, and msg.

◆ handle_core_message()

static void handle_core_message ( void *  cls,
const struct GNUNET_MessageHeader msg 
)
static

Handle message from CORE for the DHT.

Passes it to the DHT logic.

Parameters
clsa struct GNUNET_DHTU_Target of the sender
msgthe message we received

Definition at line 507 of file plugin_dhtu_gnunet.c.

509{
510 struct GNUNET_DHTU_Target *origin = cls;
511 struct Plugin *plugin = origin->plugin;
512
513 plugin->env->receive_cb (plugin->env->cls,
514 &origin->app_ctx,
515 &plugin->src.app_ctx,
516 &msg[1],
517 ntohs (msg->size) - sizeof (*msg));
518}
static char origin[GNUNET_DNSPARSER_MAX_NAME_LENGTH]
Current origin.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.

References GNUNET_TESTING_PluginFunctions::cls, msg, origin, plugin, and GNUNET_MessageHeader::size.

◆ nse_cb()

static void nse_cb ( void *  cls,
struct GNUNET_TIME_Absolute  timestamp,
double  logestimate,
double  std_dev 
)
static

Callback to call when network size estimate is updated.

Parameters
clsclosure
timestamptime when the estimate was received from the server (or created by the server)
logestimatethe log(Base 2) value of the current network size estimate
std_devstandard deviation for the estimate

Definition at line 530 of file plugin_dhtu_gnunet.c.

534{
535 struct Plugin *plugin = cls;
536
537 plugin->env->network_size_cb (plugin->env->cls,
538 timestamp,
539 logestimate,
540 std_dev);
541}

References GNUNET_TESTING_PluginFunctions::cls, and plugin.

Referenced by DHTU_gnunet_init().

Here is the caller graph for this function:

◆ DHTU_gnunet_done()

void * DHTU_gnunet_done ( struct GNUNET_DHTU_PluginFunctions api)

Exit point from the plugin.

Parameters
clsclosure (our struct Plugin)
Returns
NULL

Definition at line 551 of file plugin_dhtu_gnunet.c.

552{
553 struct Plugin *plugin = api->cls;
554
555 if (NULL != plugin->nse)
557 plugin->env->network_size_cb (plugin->env->cls,
559 0.0,
560 0.0);
561 if (NULL != plugin->core)
563 if (NULL != plugin->transport)
565 if (NULL != plugin->peerstore_notify)
566 GNUNET_PEERSTORE_monitor_stop (plugin->peerstore_notify);
567 if (NULL != plugin->peerstore)
569 // GPI_plugins_unload ();
570 GNUNET_free (plugin->my_priv);
573 return NULL;
574}
void GNUNET_TRANSPORT_application_done(struct GNUNET_TRANSPORT_ApplicationHandle *ch)
Shutdown TRANSPORT application client.
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:729
void GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
Disconnect from network size estimation service.
Definition: nse_api.c:192
void GNUNET_PEERSTORE_monitor_stop(struct GNUNET_PEERSTORE_Monitor *zm)
Stop monitoring.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the PEERSTORE service.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
void * cls
Closure for all of the callbacks.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_TESTING_PluginFunctions::cls, GNUNET_CORE_disconnect(), GNUNET_free, GNUNET_NSE_disconnect(), GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_application_done(), and plugin.

Referenced by DHTU_gnunet_init(), and shutdown_task().

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

◆ DHTU_gnunet_init()

struct GNUNET_DHTU_PluginFunctions * DHTU_gnunet_init ( struct GNUNET_DHTU_PluginEnvironment env)

Entry point for the plugin.

Parameters
clsclosure (the struct GNUNET_DHTU_PluginEnvironment)
Returns
the plugin's API

Definition at line 584 of file plugin_dhtu_gnunet.c.

585{
586 struct GNUNET_DHTU_PluginFunctions *api;
587 struct Plugin *plugin;
589 GNUNET_MQ_hd_var_size (core_message,
592 NULL),
594 };
595
596 plugin = GNUNET_new (struct Plugin);
598 env->cfg);
599 plugin->env = env;
601 api->cls = plugin;
603 api->hold = &gnunet_hold;
604 api->drop = &gnunet_drop;
605 api->send = &gnunet_send;
606 plugin->peerstore = GNUNET_PEERSTORE_connect (env->cfg);
607 plugin->transport = GNUNET_TRANSPORT_application_init (env->cfg);
608 plugin->core = GNUNET_CORE_connect (env->cfg,
609 plugin,
613 handlers);
614 plugin->nse = GNUNET_NSE_connect (env->cfg,
615 &nse_cb,
616 plugin);
617 if ( (NULL == plugin->transport) ||
618 (NULL == plugin->core) ||
619 (NULL == plugin->nse) )
620 {
621 GNUNET_break (0);
622 DHTU_gnunet_done (api);
623 return NULL;
624 }
625 // GPI_plugins_load (env->cfg);
626 return api;
627}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
struct GNUNET_TRANSPORT_ApplicationHandle * GNUNET_TRANSPORT_application_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the TRANSPORT application client handle.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:691
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_NSE_Handle * GNUNET_NSE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NSE_Callback func, void *func_cls)
Connect to the network size estimation service.
Definition: nse_api.c:164
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
void * DHTU_gnunet_done(struct GNUNET_DHTU_PluginFunctions *api)
Exit point from the plugin.
static void * core_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
static void gnunet_drop(struct GNUNET_DHTU_PreferenceHandle *ph)
Do no long request underlay to keep the connection alive.
static void core_disconnect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
Method called whenever a peer disconnects.
static void gnunet_try_connect(void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
Request creation of a session with a peer at the given address.
static void nse_cb(void *cls, struct GNUNET_TIME_Absolute timestamp, double logestimate, double std_dev)
Callback to call when network size estimate is updated.
static struct GNUNET_DHTU_PreferenceHandle * gnunet_hold(void *cls, struct GNUNET_DHTU_Target *target)
Request underlay to keep the connection to target alive if possible.
static void gnunet_send(void *cls, struct GNUNET_DHTU_Target *target, const void *msg, size_t msg_size, GNUNET_SCHEDULER_TaskCallback finished_cb, void *finished_cb_cls)
Send message to some other participant over the network.
static void core_init_cb(void *cls, const struct GNUNET_PeerIdentity *my_identity)
Function called after GNUNET_CORE_connect has succeeded (or failed for good).
struct returned by the initialization function of the plugin
void(* try_connect)(void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
Request creation of a session with a peer at the given address.
void * cls
Closure to pass to all plugin functions.
struct GNUNET_DHTU_PreferenceHandle *(* hold)(void *cls, struct GNUNET_DHTU_Target *target)
Request underlay to keep the connection to target alive if possible.
void(* drop)(struct GNUNET_DHTU_PreferenceHandle *ph)
Do no longer request underlay to keep the connection alive.
void(* send)(void *cls, struct GNUNET_DHTU_Target *target, const void *msg, size_t msg_size, GNUNET_SCHEDULER_TaskCallback finished_cb, void *finished_cb_cls)
Send message to some other participant over the network.
Message handler for a specific message type.

References GNUNET_DHTU_PluginFunctions::cls, core_connect_cb(), core_disconnect_cb(), core_init_cb(), DHTU_gnunet_done(), GNUNET_DHTU_PluginFunctions::drop, env, GNUNET_break, GNUNET_CORE_connect(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), gnunet_drop(), gnunet_hold(), GNUNET_MESSAGE_TYPE_DHT_CORE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_NSE_connect(), GNUNET_PEERSTORE_connect(), gnunet_send(), GNUNET_TRANSPORT_application_init(), gnunet_try_connect(), handlers, GNUNET_DHTU_PluginFunctions::hold, nse_cb(), plugin, GNUNET_DHTU_PluginFunctions::send, and GNUNET_DHTU_PluginFunctions::try_connect.

Referenced by load_underlay().

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