GNUnet 0.21.1
plugin_dhtu_gnunet.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet
3 Copyright (C) 2021 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
27#include "platform.h"
28#include "gnunet_dhtu_plugin.h"
29#include "gnunet_core_service.h"
33#include "gnunet_nse_service.h"
34#include "plugin_dhtu_gnunet.h"
35
41{
42
46 void *app_ctx;
47
48};
49
50
56{
57
61 void *app_ctx;
62
66 struct Plugin *plugin;
67
72
77
82
87
92
96 unsigned int ph_count;
97
98};
99
100
106{
111
116
121};
122
123
127struct Plugin
128{
129
135
140
145
150
155
160
166
171
176
177};
178
179
180// #include "../peerinfo-tool/gnunet-peerinfo_plugins.c"
181
182
190static void
192 const struct GNUNET_PeerIdentity *pid,
193 const char *address)
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}
221
222
231static struct GNUNET_DHTU_PreferenceHandle *
232gnunet_hold (void *cls,
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}
253
254
261static void
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}
283
284
300static void
301gnunet_send (void *cls,
302 struct GNUNET_DHTU_Target *target,
303 const void *msg,
304 size_t msg_size,
306 void *finished_cb_cls)
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}
323
324
333static void *
335 const struct GNUNET_PeerIdentity *peer,
336 struct GNUNET_MQ_Handle *mq)
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}
351
352
361static void
363 const struct GNUNET_PeerIdentity *peer,
364 void *peer_cls)
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}
374
375
376static void
377add_addr (void *cls,
378 const struct GNUNET_PeerIdentity *pid,
379 const char *addr)
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}
391
392
405static void
406peerinfo_cb (void *cls,
407 const struct GNUNET_PEERSTORE_Record *record,
408 const char *emsg)
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}
431
432
433static void
434error_cb (void *cls)
435{
437 "Error in PEERSTORE monitoring\n");
438}
439
440
441static void
442sync_cb (void *cls)
443{
445 "Done with initial PEERSTORE iteration during monitoring\n");
446}
447
448
461static void
462core_init_cb (void *cls,
463 const struct GNUNET_PeerIdentity *my_identity)
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}
480
481
489static int
491 const struct GNUNET_MessageHeader *msg)
492{
493 (void) cls;
494 (void) msg;
495 return GNUNET_OK;
496}
497
498
506static void
508 const struct GNUNET_MessageHeader *msg)
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}
519
520
529static void
530nse_cb (void *cls,
531 struct GNUNET_TIME_Absolute timestamp,
532 double logestimate,
533 double std_dev)
534{
535 struct Plugin *plugin = cls;
536
537 plugin->env->network_size_cb (plugin->env->cls,
538 timestamp,
539 logestimate,
540 std_dev);
541}
542
543
550void *
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}
575
576
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_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void finished_cb(enum GNUNET_GenericReturnValue rv)
struct TestcasePlugin * plugin
The process handle to the testbed service.
struct GNUNET_PeerIdentity my_identity
Our peer identity.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * address
GNS address for this phone.
static struct HostSet * builder
NULL if we are not currently iterating over peer information.
static char origin[GNUNET_DNSPARSER_MAX_NAME_LENGTH]
Current origin.
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.
Core service; the main API for encrypted P2P communications.
Helper library for handling HELLO URIs.
API to retrieve the current network size estimate.
API to the peerstore service.
Bandwidth allocation API for applications to interact with.
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_done(struct GNUNET_TRANSPORT_ApplicationHandle *ch)
Shutdown TRANSPORT application client.
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...
void GNUNET_TRANSPORT_application_suggest_cancel(struct GNUNET_TRANSPORT_ApplicationSuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_TRANSPORT_ApplicationHandle * GNUNET_TRANSPORT_application_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the TRANSPORT application client handle.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
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
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:729
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_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_OK
@ GNUNET_YES
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
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
@ GNUNET_MQ_PRIO_BEST_EFFORT
Best-effort traffic (e.g.
void GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
Disconnect from network size estimation service.
Definition: nse_api.c:192
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
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:44
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.
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...
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
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).
#define GNUNET_PEERSTORE_HELLO_KEY
Key used for storing HELLO in the peerstore.
#define GNUNET_MESSAGE_TYPE_DHT_CORE
Encapsulation of DHT messages in CORE service.
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
void * DHTU_gnunet_done(struct GNUNET_DHTU_PluginFunctions *api)
Exit point from the plugin.
static void sync_cb(void *cls)
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 handle_core_message(void *cls, const struct GNUNET_MessageHeader *msg)
Handle message from CORE for the DHT.
struct GNUNET_DHTU_PluginFunctions * DHTU_gnunet_init(struct GNUNET_DHTU_PluginEnvironment *env)
Entry point for the plugin.
static int check_core_message(void *cls, const struct GNUNET_MessageHeader *msg)
Anything goes, always return GNUNET_OK.
static void gnunet_drop(struct GNUNET_DHTU_PreferenceHandle *ph)
Do no long request underlay to keep the connection alive.
static void add_addr(void *cls, const struct GNUNET_PeerIdentity *pid, const char *addr)
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 error_cb(void *cls)
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 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.
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).
void * cls
Closure for all of the callbacks.
Context for the core service connection.
Definition: core_api.c:78
Private ECC key encoded for transmission.
The datastore service will pass a pointer to a struct of this type as the first and only argument to ...
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.
Opaque handle expressing a preference of the DHT to keep a particular target connected.
struct GNUNET_DHTU_PreferenceHandle * prev
Kept in a DLL.
struct GNUNET_DHTU_Target * target
Target a preference was expressed for.
struct GNUNET_DHTU_PreferenceHandle * next
Kept in a DLL.
Opaque handle that the underlay offers for our address to be used when sending messages to another pe...
void * app_ctx
Application context for this source.
Opaque handle that the underlay offers for the target peer when sending messages to another peer.
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 Plugin * plugin
Our plugin with its environment.
struct GNUNET_MQ_Handle * mq
CORE MQ to send messages to this peer.
void * app_ctx
Application context for this target.
struct GNUNET_DHTU_PreferenceHandle * ph_tail
Tail of preferences expressed for this target.
struct sockaddr_storage addr
Target IP address.
struct GNUNET_PeerIdentity pid
Identity of this peer.
Context for building (or parsing) HELLO URIs.
Definition: hello-uri.c:205
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle for talking with the NSE service.
Definition: nse_api.c:40
Handle to the PEERSTORE service.
Definition: peerstore_api.c:46
Context for a monitor.
Single PEERSTORE record.
The identity of the host (wraps the signing key of the peer).
Time for absolute times used by GNUnet, in microseconds.
Handle to the TRANSPORT subsystem for application management.
Handle for TRANSPORT address suggestion requests.
Handle for a plugin.
Definition: block.c:38
struct GNUNET_DHTU_PluginEnvironment * env
Callbacks into the DHT.
struct GNUNET_PEERSTORE_Monitor * peerstore_notify
Our peerstore notification context.
struct GNUNET_PEERSTORE_Handle * peerstore
Handle to the PEERSTORE service.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
struct GNUNET_DHTU_Source src
Our "source" address.
struct GNUNET_PeerIdentity my_identity
Identity of this peer.
struct GNUNET_NSE_Handle * nse
Handle to the NSE service.
struct GNUNET_TRANSPORT_ApplicationHandle * transport
Handle to Transport service.
struct GNUNET_CRYPTO_EddsaPrivateKey * my_priv
Our private key.
struct GNUNET_CORE_Handle * core
Handle to the CORE service.