GNUnet debian-0.24.3-23-g589b01d60
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
334static void *
336 const struct GNUNET_PeerIdentity *peer,
337 struct GNUNET_MQ_Handle *mq,
338 enum GNUNET_CORE_PeerClass class)
339{
340 struct Plugin *plugin = cls;
341 struct GNUNET_DHTU_Target *target;
342
343 target = GNUNET_new (struct GNUNET_DHTU_Target);
344 target->plugin = plugin;
345 target->mq = mq;
346 target->pid = *peer;
347 plugin->env->connect_cb (plugin->env->cls,
348 target,
349 &target->pid,
350 &target->app_ctx);
351 return target;
352}
353
354
363static void
365 const struct GNUNET_PeerIdentity *peer,
366 void *peer_cls)
367{
368 struct Plugin *plugin = cls;
369 struct GNUNET_DHTU_Target *target = peer_cls;
370
371 plugin->env->disconnect_cb (target->app_ctx);
372 if (NULL != target->ash)
374 GNUNET_free (target);
375}
376
377
378static void
379add_addr (void *cls,
380 const struct GNUNET_PeerIdentity *pid,
381 const char *addr)
382{
383 struct Plugin *plugin = cls;
384
386 "peerinfo_cb addr %s\n",
387 addr);
388 plugin->env->address_add_cb (plugin->env->cls,
389 addr,
390 &plugin->src,
391 &plugin->src.app_ctx);
392}
393
394
407static void
408peerinfo_cb (void *cls,
409 const struct GNUNET_PEERSTORE_Record *record,
410 const char *emsg)
411{
412 struct Plugin *plugin = cls;
414 struct GNUNET_MessageHeader *hello;
415
416 hello = record->value;
417 if (NULL == hello)
418 return;
419 if (0 !=
420 GNUNET_memcmp (&record->peer,
421 &plugin->my_identity))
422 {
423 GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
424 return;
425 }
428 add_addr,
429 plugin);
431 GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
432}
433
434
435static void
436error_cb (void *cls)
437{
439 "Error in PEERSTORE monitoring\n");
440}
441
442
443static void
444sync_cb (void *cls)
445{
447 "Done with initial PEERSTORE iteration during monitoring\n");
448}
449
450
463static void
464core_init_cb (void *cls,
465 const struct GNUNET_PeerIdentity *my_identity)
466{
467 struct Plugin *plugin = cls;
468
469 plugin->my_identity = *my_identity;
470 plugin->peerstore_notify = GNUNET_PEERSTORE_monitor_start (plugin->env->cfg,
472 "peerstore",
473 NULL,
475 &error_cb,
476 NULL,
477 &sync_cb,
478 NULL,
480 plugin);
481}
482
483
491static int
493 const struct GNUNET_MessageHeader *msg)
494{
495 (void) cls;
496 (void) msg;
497 return GNUNET_OK;
498}
499
500
508static void
510 const struct GNUNET_MessageHeader *msg)
511{
512 struct GNUNET_DHTU_Target *origin = cls;
513 struct Plugin *plugin = origin->plugin;
514
515 plugin->env->receive_cb (plugin->env->cls,
516 &origin->app_ctx,
517 &plugin->src.app_ctx,
518 &msg[1],
519 ntohs (msg->size) - sizeof (*msg));
520}
521
522
531static void
532nse_cb (void *cls,
534 double logestimate,
535 double std_dev)
536{
537 struct Plugin *plugin = cls;
538
539 plugin->env->network_size_cb (plugin->env->cls,
540 timestamp,
541 logestimate,
542 std_dev);
543}
544
545
552void *
554{
555 struct Plugin *plugin = api->cls;
556
557 if (NULL != plugin->nse)
559 plugin->env->network_size_cb (plugin->env->cls,
561 0.0,
562 0.0);
563 if (NULL != plugin->core)
565 if (NULL != plugin->transport)
567 if (NULL != plugin->peerstore_notify)
568 GNUNET_PEERSTORE_monitor_stop (plugin->peerstore_notify);
569 if (NULL != plugin->peerstore)
571 // GPI_plugins_unload ();
572 GNUNET_free (plugin->my_priv);
575 return NULL;
576}
577
578
587{
588 struct GNUNET_DHTU_PluginFunctions *api;
589 struct Plugin *plugin;
591 GNUNET_MQ_hd_var_size (core_message,
594 NULL),
596 };
597 const struct GNUNET_CORE_ServiceInfo service_info =
598 {
600 .version = { 1, 0 },
601 .version_max = { 1, 0 },
602 .version_min = { 1, 0 },
603 };
604
605 plugin = GNUNET_new (struct Plugin);
607 env->cfg);
608 plugin->env = env;
610 api->cls = plugin;
612 api->hold = &gnunet_hold;
613 api->drop = &gnunet_drop;
614 api->send = &gnunet_send;
615 plugin->peerstore = GNUNET_PEERSTORE_connect (env->cfg);
616 plugin->transport = GNUNET_TRANSPORT_application_init (env->cfg);
617 plugin->core = GNUNET_CORE_connect (env->cfg,
618 plugin,
622 handlers,
623 &service_info);
624 plugin->nse = GNUNET_NSE_connect (env->cfg,
625 &nse_cb,
626 plugin);
627 if ( (NULL == plugin->transport) ||
628 (NULL == plugin->core) ||
629 (NULL == plugin->nse) )
630 {
631 GNUNET_break (0);
632 DHTU_gnunet_done (api);
633 return NULL;
634 }
635 // GPI_plugins_load (env->cfg);
636 return api;
637}
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 struct GNUNET_TESTING_PluginFunctions * plugin
Plugin to dynamically load a test case.
static void finished_cb(void *cls, enum GNUNET_GenericReturnValue rv)
static uint64_t timestamp(void)
Get current timestamp.
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 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.
GNUNET_CORE_PeerClass
The peer class gives a hint about the capabilities of a peer.
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, struct GNUNET_CORE_ServiceInfo *service_info)
Connect to the core service.
Definition: core_api.c:698
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:744
@ GNUNET_CORE_SERVICE_DHT
Identifier for dht (distributed hash table) service.
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_parser_free(struct GNUNET_HELLO_Parser *parser)
Release resources of a builder.
Definition: hello-uri.c:379
struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_msg(const struct GNUNET_MessageHeader *msg)
Parse msg.
Definition: hello-uri.c:415
const struct GNUNET_PeerIdentity * GNUNET_HELLO_parser_iterate(const struct GNUNET_HELLO_Parser *parser, GNUNET_HELLO_UriCallback uc, void *uc_cls)
Iterate over URIs in a parser.
Definition: hello-uri.c:975
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ 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:305
#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:61
#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:655
@ 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".
static void * core_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
Method called whenever a given peer connects.
void * DHTU_gnunet_done(struct GNUNET_DHTU_PluginFunctions *api)
Exit point from the plugin.
static void sync_cb(void *cls)
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
Gnunet service info - identifying compatibility with a range of version of a service communicating ov...
enum GNUNET_CORE_Service service
Identifier of the service on top of CORE.
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 parsing HELLOs.
Definition: hello-uri.c:232
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
Handle for talking with the NSE service.
Definition: nse_api.c:40
Handle to the PEERSTORE service.
Definition: peerstore_api.c:44
Context for a monitor.
Single PEERSTORE record.
The identity of the host (wraps the signing key of the peer).
void * cls
Closure to pass to start_testcase.
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.