GNUnet 0.21.0
gnunet-daemon-topology.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2007-2016 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
30#include "platform.h"
31#include "gnunet_util_lib.h"
33#include "gnunet_constants.h"
34#include "gnunet_core_service.h"
35#include "gnunet_protocols.h"
39#include <assert.h>
40
41
45#define HELLO_ADVERTISEMENT_MIN_FREQUENCY \
46 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
47
51#define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY \
52 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
53
54
58struct Peer
59{
64
70
75
81
86
91
97
102
106 uint32_t strength;
107
108};
109
113struct StoreHelloEntry
114{
118 struct StoreHelloEntry *prev;
119
123 struct StoreHelloEntry *next;
124
129};
130
136
137
143
147static const struct GNUNET_CONFIGURATION_Handle *cfg;
148
153
158
163
168
173
180
185
191
195static unsigned int connection_count;
196
200static unsigned int target_connection_count;
201
206
211
220static int
221free_peer (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
222{
223 struct Peer *pos = value;
224
225 GNUNET_break (NULL == pos->mq);
228 if (NULL != pos->hello_delay_task)
229 {
231 pos->hello_delay_task = NULL;
232 }
233 if (NULL != pos->ash)
234 {
236 pos->ash = NULL;
237 }
238 if (NULL != pos->hello)
239 {
240 GNUNET_free (pos->hello);
241 pos->hello = NULL;
242 }
243 if (NULL != pos->filter)
244 {
246 pos->filter = NULL;
247 }
248 GNUNET_free (pos);
249 return GNUNET_YES;
250}
251
252
259static void
261{
262 uint32_t strength;
264
265 if (0 == GNUNET_memcmp (&my_identity, &pos->pid))
266 return; /* This is myself, nothing to do. */
268 strength = 1;
269 else
270 strength = 0;
271 if (NULL != pos->mq)
272 strength *= 2; /* existing connections preferred */
273 if (NULL != pos->ash)
274 {
276 pos->ash = NULL;
277 }
278 pos->strength = strength;
279 if (0 != strength)
280 {
282 "Asking to connect to `%s' with strength %u\n",
283 GNUNET_i2s (&pos->pid),
284 (unsigned int) strength);
286 gettext_noop ("# connect requests issued to ATS"),
287 1,
288 GNUNET_NO);
289 // TODO Use strength somehow.
290 bw.value__ = 0;
292 &pos->pid,
294 bw);
295 }
296}
297
298
306static struct Peer *
307make_peer (const struct GNUNET_PeerIdentity *peer,
308 const struct GNUNET_MessageHeader *hello)
309{
310 struct Peer *ret;
311
312 ret = GNUNET_new (struct Peer);
313 ret->pid = *peer;
314 if (NULL != hello)
315 {
316 ret->hello = GNUNET_malloc (ntohs (hello->size));
317 GNUNET_memcpy (ret->hello, hello, ntohs (hello->size));
318 }
321 peers,
322 peer,
323 ret,
325 return ret;
326}
327
328
334static void
335setup_filter (struct Peer *peer)
336{
337 struct GNUNET_HashCode hc;
338
339 /* 2^{-5} chance of not sending a HELLO to a peer is
340 * acceptably small (if the filter is 50% full);
341 * 64 bytes of memory are small compared to the rest
342 * of the data structure and would only really become
343 * "useless" once a HELLO has been passed on to ~100
344 * other peers, which is likely more than enough in
345 * any case; hence 64, 5 as bloomfilter parameters. */peer->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, 64, 5);
346 peer->filter_expiration =
348 /* never send a peer its own HELLO */
349 GNUNET_CRYPTO_hash (&peer->pid, sizeof(struct GNUNET_PeerIdentity), &hc);
351}
352
353
358{
362 struct Peer *peer;
363
367 struct Peer *result;
368
372 size_t max_size;
373
375};
376
377
386static int
388 const struct GNUNET_PeerIdentity *pid,
389 void *value)
390{
391 struct FindAdvHelloContext *fah = cls;
392 struct Peer *pos = value;
393 struct GNUNET_TIME_Relative rst_time;
394 struct GNUNET_HashCode hc;
395 size_t hs;
396
398 "find_advertisable_hello\n");
399 if (pos == fah->peer)
400 return GNUNET_YES;
402 "find_advertisable_hello 2\n");
403 if (pos->hello == NULL)
404 return GNUNET_YES;
406 "find_advertisable_hello 3\n");
408 if (0 == rst_time.rel_value_us)
409 {
410 /* time to discard... */
412 setup_filter (pos);
413 }
414 fah->next_adv = GNUNET_TIME_relative_min (rst_time, fah->next_adv);
415 hs = pos->hello->size;
416 if (hs > fah->max_size)
417 return GNUNET_YES;
419 "find_advertisable_hello 4\n");
421 sizeof(struct GNUNET_PeerIdentity),
422 &hc);
424 fah->result = pos;
425 return GNUNET_YES;
426}
427
428
435static void
437{
438 struct Peer *pl = cls;
439 struct FindAdvHelloContext fah;
440 struct GNUNET_MQ_Envelope *env;
441 size_t want;
442 struct GNUNET_TIME_Relative delay;
443 struct GNUNET_HashCode hc;
444
446 "schedule_next_hello\n");
447 pl->hello_delay_task = NULL;
448 GNUNET_assert (NULL != pl->mq);
449 /* find applicable HELLOs */
450 fah.peer = pl;
451 fah.result = NULL;
455 pl->hello_delay_task =
457 if (NULL == fah.result)
458 return;
460 "schedule_next_hello 2\n");
462 if (0 != delay.rel_value_us)
463 return;
464
466 "schedule_next_hello 3\n");
467 want = ntohs (fah.result->hello->size);
469 "Sending HELLO with %u bytes for peer %s\n",
470 (unsigned int) want,
471 GNUNET_i2s (&pl->pid));
473 GNUNET_MQ_send (pl->mq, env);
474
475 /* avoid sending this one again soon */
476 GNUNET_CRYPTO_hash (&pl->pid, sizeof(struct GNUNET_PeerIdentity), &hc);
478
480 gettext_noop ("# HELLO messages gossipped"),
481 1,
482 GNUNET_NO);
483 /* prepare to send the next one */
486 if (NULL != pl->hello_delay_task)
489}
490
491
502static int
504 const struct GNUNET_PeerIdentity *pid,
505 void *value)
506{
507 (void) cls;
508 struct Peer *peer = value;
509
511 "Reschedule for `%s'\n",
512 GNUNET_i2s (&peer->pid));
513 if (NULL == peer->mq)
514 return GNUNET_YES;
515 if (NULL != peer->hello_delay_task)
516 {
518 peer->hello_delay_task = NULL;
519 }
521 "Schedule_next_hello\n");
522 peer->hello_delay_task =
524 return GNUNET_YES;
525}
526
527
536static void *
537connect_notify (void *cls,
538 const struct GNUNET_PeerIdentity *peer,
539 struct GNUNET_MQ_Handle *mq)
540{
541 struct Peer *pos;
542
544 "Core told us that we are connecting to `%s'\n",
545 GNUNET_i2s (peer));
546 if (0 == GNUNET_memcmp (&my_identity, peer))
547 return NULL;
551 gettext_noop ("# peers connected"),
553 GNUNET_NO);
555 if (NULL == pos)
556 {
557 pos = make_peer (peer, NULL);
558 }
559 else
560 {
561 GNUNET_assert (NULL == pos->mq);
562 }
563 pos->mq = mq;
564 reschedule_hellos (NULL, peer, pos);
565 return pos;
566}
567
568
577static int
578try_add_peers (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
579{
580 struct Peer *pos = value;
581
582 attempt_connect (pos);
583 return GNUNET_YES;
584}
585
586
592static void
593add_peer_task (void *cls)
594{
595 add_task = NULL;
596
598}
599
600
608static void
610 const struct GNUNET_PeerIdentity *peer,
611 void *internal_cls)
612{
613 struct Peer *pos = internal_cls;
614
615 if (NULL == pos)
616 return; /* myself, we're shutting down */
618 "Core told us that we disconnected from `%s'\n",
619 GNUNET_i2s (peer));
620 if (NULL == pos->mq)
621 {
622 GNUNET_break (0);
623 return;
624 }
625 pos->mq = NULL;
627 if (NULL != pos->hello_delay_task)
628 {
630 pos->hello_delay_task = NULL;
631 }
633 gettext_noop ("# peers connected"),
635 GNUNET_NO);
637 (NULL == add_task))
639
640}
641
642
650static void
652 const struct GNUNET_PeerIdentity *pid,
653 const char *uri)
654{
655 (void) pid;
656 int *flag = cls;
657
658 *flag = *flag + 1;
659 // *flag = GNUNET_YES;
660}
661
662
669static void
671{
672 int num_addresses_old = 0;
673 int num_addresses_new = 0;
675 const struct GNUNET_PeerIdentity *pid;
676 struct Peer *peer;
677 uint16_t size;
678
681 &num_addresses_new);
683 "consider 0 for %s\n",
684 GNUNET_i2s (pid));
685 if (0 == num_addresses_new)
686 {
688 return; /* no point in advertising this one... */
689 }
691 if (NULL == peer)
692 {
693 peer = make_peer (pid, hello);
694 }
695 else if (NULL != peer->hello)
696 {
698 struct GNUNET_TIME_Absolute new_hello_exp =
700 struct GNUNET_TIME_Absolute old_hello_exp =
703 peer->hello);
704
705 GNUNET_HELLO_builder_iterate (builder_old,
707 &num_addresses_old);
708 if (GNUNET_TIME_absolute_cmp (new_hello_exp, >, now) &&
709 (GNUNET_TIME_absolute_cmp (new_hello_exp, >, old_hello_exp) ||
710 num_addresses_old < num_addresses_new))
711 {
712 GNUNET_free (peer->hello);
713 size = ntohs (hello->size);
714 peer->hello = GNUNET_malloc (size);
715 GNUNET_memcpy (peer->hello, hello, size);
716 }
717 else
718 {
720 "consider 3\n");
722 return;
723 }
724 }
725 else
726 {
727 size = ntohs (hello->size);
728 peer->hello = GNUNET_malloc (size);
729 GNUNET_memcpy (peer->hello, hello, size);
730 }
732 "Found HELLO from peer `%s' for advertising\n",
733 GNUNET_i2s (pid));
734 if (NULL != peer->filter)
735 {
737 peer->filter = NULL;
738 }
739 setup_filter (peer);
740 /* since we have a new HELLO to pick from, re-schedule all
741 * HELLO requests that are not bound by the HELLO send rate! */
744}
745
746
747static void
748error_cb (void *cls)
749{
751 _ (
752 "Error in communication with PEERSTORE service to monitor.\n"));
753 return;
754}
755
756
757static void
758sync_cb (void *cls)
759{
761 _ ("Finished initial PEERSTORE iteration in monitor.\n"));
762 return;
763}
764
765
775static void
776process_peer (void *cls,
777 const struct GNUNET_PEERSTORE_Record *record,
778 const char *err_msg)
779{
780 struct Peer *pos;
781 struct GNUNET_MessageHeader *hello;
782
783 if (NULL != err_msg)
784 {
786 _ ("Error in communication with PEERSTORE service: %s\n"),
787 err_msg);
792 "peerstore",
793 NULL,
795 error_cb,
796 NULL,
797 sync_cb,
798 NULL,
800 NULL);
801 return;
802 }
803 GNUNET_assert (NULL != record);
804 hello = record->value;
805 if (NULL == hello)
806 {
807 /* free existing HELLO, if any */
809 if (NULL != pos)
810 {
811 GNUNET_free (pos->hello);
812 pos->hello = NULL;
813 if (NULL != pos->filter)
814 {
816 pos->filter = NULL;
817 }
818 if (NULL == pos->mq)
819 free_peer (NULL, &pos->pid, pos);
820 }
822 return;
823 }
826 if (NULL == pos)
827 pos = make_peer (&record->peer, hello);
828 attempt_connect (pos);
830}
831
832
833static void
834start_notify (void *cls)
835{
836 (void) cls;
837
839 "Starting to process new hellos for gossiping.\n");
843 "peerstore",
844 NULL,
846 &error_cb,
847 NULL,
848 &sync_cb,
849 NULL,
851 NULL);
852}
853
854
862static void
863core_init (void *cls, const struct GNUNET_PeerIdentity *my_id)
864{
865 if (NULL == my_id)
866 {
867 GNUNET_log (
869 _ ("Failed to connect to core service, can not manage topology!\n"));
871 return;
872 }
873 my_identity = *my_id;
874 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am peer `%s'\n", GNUNET_i2s (my_id));
878 NULL);
879}
880
881
891static int
892check_hello (void *cls, const struct GNUNET_MessageHeader *message)
893{
895 message);
897
898 if (NULL == pid)
899 {
900 GNUNET_break_op (0);
901 return GNUNET_SYSERR;
902 }
903 return GNUNET_OK;
904}
905
906
907static void
908shc_cont (void *cls, int success)
909{
910 struct StoreHelloEntry *she = cls;
911
912 she->sc = NULL;
913 if (GNUNET_YES == success)
915 "Hello stored successfully!\n");
916 else
918 "Error storing hello!\n");
920 GNUNET_free (she);
921}
922
923
931static void
932handle_hello (void *cls, const struct GNUNET_MessageHeader *message)
933{
934 struct StoreHelloEntry *she;
935 const struct GNUNET_PeerIdentity *other = cls;
937 message);
938
940 "Received encrypted HELLO from peer `%s'",
941 GNUNET_i2s (other));
943 gettext_noop ("# HELLO messages received"),
944 1,
945 GNUNET_NO);
947 she = GNUNET_new (struct StoreHelloEntry);
948 she->sc = GNUNET_PEERSTORE_hello_add (ps, message, &shc_cont, she);
949 if (NULL != she->sc)
950 {
952 }
953 else
954 GNUNET_free (she);
956}
957
958
965static void
966cleaning_task (void *cls)
967{
968 struct StoreHelloEntry *pos;
969
970 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Topology shutdown\n");
971 while (NULL != (pos = she_head))
972 {
974 if (NULL != pos->sc)
976 GNUNET_free (pos);
977 }
978 if (NULL != peerstore_notify)
979 {
981 peerstore_notify = NULL;
982 }
983 else if (NULL != peerstore_notify_task)
984 {
986 }
987 if (NULL != handle)
988 {
990 handle = NULL;
991 }
992 if (NULL != add_task)
993 {
995 add_task = NULL;
996 }
999 peers = NULL;
1000 if (NULL != transport)
1001 {
1003 transport = NULL;
1004 }
1005 if (NULL != ps)
1006 {
1008 ps = NULL;
1009 }
1010 if (NULL != stats)
1011 {
1013 stats = NULL;
1014 }
1015}
1016
1017
1026static void
1027run (void *cls,
1028 char *const *args,
1029 const char *cfgfile,
1030 const struct GNUNET_CONFIGURATION_Handle *c)
1031{
1033 { GNUNET_MQ_hd_var_size (hello,
1035 struct GNUNET_MessageHeader,
1036 NULL),
1038 unsigned long long opt;
1039
1040 cfg = c;
1043 stats = GNUNET_STATISTICS_create ("topology", cfg);
1044
1045 if (GNUNET_OK !=
1047 "TOPOLOGY",
1048 "TARGET-CONNECTION-COUNT",
1049 &opt))
1050 opt = 16;
1051 target_connection_count = (unsigned int) opt;
1053 GNUNET_NO);
1057 NULL,
1058 &core_init,
1061 handlers);
1063 if (NULL == handle)
1064 {
1066 _ ("Failed to connect to `%s' service.\n"),
1067 "core");
1069 return;
1070 }
1071}
1072
1073
1081int
1082main (int argc, char *const *argv)
1083{
1084 static const struct GNUNET_GETOPT_CommandLineOption options[] = {
1086 };
1087 int ret;
1088
1089 if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1090 return 2;
1091
1092 ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
1093 argv,
1094 "gnunet-daemon-topology",
1095 _ ("GNUnet topology control"),
1096 options,
1097 &run,
1098 NULL))
1099 ? 0
1100 : 1;
1101 GNUNET_free_nz ((void *) argv);
1102 return ret;
1103}
1104
1105
1106#if defined(__linux__) && defined(__GLIBC__)
1107#include <malloc.h>
1108
1112void __attribute__ ((constructor))
1113GNUNET_TOPOLOGY_memory_init ()
1114{
1115 mallopt (M_TRIM_THRESHOLD, 4 * 1024);
1116 mallopt (M_TOP_PAD, 1 * 1024);
1117 malloc_trim (0);
1118}
1119
1120
1121#endif
1122
1123/* end of gnunet-daemon-topology.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define gettext_noop(String)
Definition: gettext.h:70
static int ret
Final status code.
Definition: gnunet-arm.c:94
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.
static struct GNUNET_CORE_Handle * handle
Handle to the CORE service.
static struct GNUNET_CONTAINER_MultiPeerMap * peers
All of our current neighbours and all peers for which we have HELLOs.
static void sync_cb(void *cls)
static void cleaning_task(void *cls)
Last task run during shutdown.
static void add_peer_task(void *cls)
Add peers and schedule connection attempt.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
static void consider_for_advertising(const struct GNUNET_MessageHeader *hello)
We've gotten a HELLO from another peer.
static unsigned int target_connection_count
Target number of connections.
static void schedule_next_hello(void *cls)
Calculate when we would like to send the next HELLO to this peer and ask for it.
static struct GNUNET_PEERSTORE_Handle * ps
Handle to the PEERSTORE service.
static struct GNUNET_PEERSTORE_Monitor * peerstore_notify
Our peerstore notification context.
static void disconnect_notify(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a peer disconnects.
static struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void address_iterator(void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
Iterator called on each address.
static unsigned int connection_count
Number of peers that we are currently connected to.
static struct StoreHelloEntry * she_head
Head of the linkd list to store the store context for hellos.
static int check_hello(void *cls, const struct GNUNET_MessageHeader *message)
This function is called whenever an encrypted HELLO message is received.
static void start_notify(void *cls)
static struct StoreHelloEntry * she_tail
Tail of the linkd list to store the store context for hellos.
struct GNUNET_SCHEDULER_Task * peerstore_notify_task
The task to delayed start the notification process intially.
static void handle_hello(void *cls, const struct GNUNET_MessageHeader *message)
This function is called whenever an encrypted HELLO message is received.
static void process_peer(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *err_msg)
PEERSTORE calls this function to let us know about a possible peer that we might want to connect to.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
static void core_init(void *cls, const struct GNUNET_PeerIdentity *my_id)
Function called after GNUNET_CORE_connect has succeeded (or failed for good).
static void * connect_notify(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a peer connects.
static void shc_cont(void *cls, int success)
#define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY
After what time period do we expire the HELLO Bloom filter?
static int reschedule_hellos(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Cancel existing requests for sending HELLOs to this peer and recalculate when we should send HELLOs t...
struct GNUNET_TRANSPORT_ApplicationHandle * transport
Handle to Transport service.
#define HELLO_ADVERTISEMENT_MIN_FREQUENCY
At what frequency do we sent HELLOs to a peer?
static void setup_filter(struct Peer *peer)
Setup bloom filter for the given peer entry.
static int free_peer(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free all resources associated with the given peer.
static void error_cb(void *cls)
int main(int argc, char *const *argv)
The main function for the topology daemon.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
static struct GNUNET_SCHEDULER_Task * add_task
Task scheduled to asynchronously reconsider adding/removing peer connectivity suggestions.
static void attempt_connect(struct Peer *pos)
Recalculate how much we want to be connected to the specified peer and let ATS know about the result.
static int find_advertisable_hello(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Find a peer that would be reasonable for advertising.
static struct Peer * make_peer(const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *hello)
Create a new entry in the peer list.
static int try_add_peers(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Try to add more peers to our connection set.
static char * value
Value of the record to add/remove.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
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 the peerstore service.
struct GNUNET_PQ_ResultSpec __attribute__
Constants for network protocols.
API to create, modify and access statistics.
Bandwidth allocation API for applications to interact with.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
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_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.
struct GNUNET_CONTAINER_BloomFilter * GNUNET_CONTAINER_bloomfilter_init(const char *data, size_t size, unsigned int k)
Create a Bloom filter from raw bits.
void GNUNET_CONTAINER_bloomfilter_add(struct GNUNET_CONTAINER_BloomFilter *bf, const struct GNUNET_HashCode *e)
Add an element to the filter.
bool GNUNET_CONTAINER_bloomfilter_test(const struct GNUNET_CONTAINER_BloomFilter *bf, const struct GNUNET_HashCode *e)
Test if an element is in the filter.
void GNUNET_CONTAINER_bloomfilter_free(struct GNUNET_CONTAINER_BloomFilter *bf)
Free the space associated with a filter in memory, flush to drive if needed (do not free the space on...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
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_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
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
const struct GNUNET_PeerIdentity * GNUNET_HELLO_builder_get_id(const struct GNUNET_HELLO_Builder *builder)
Get the PeerIdentity for this builder.
Definition: hello-uri.c:366
struct GNUNET_TIME_Absolute GNUNET_HELLO_builder_get_expiration_time(const struct GNUNET_MessageHeader *msg)
Get the expiration time for this HELLO.
Definition: hello-uri.c:470
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:533
void GNUNET_MQ_set_options(struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this queue.
Definition: mq.c:871
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_hd_var_size(name, code, str, ctx)
@ GNUNET_MQ_PRIO_BEST_EFFORT
Best-effort traffic (e.g.
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).
void GNUNET_PEERSTORE_hello_add_cancel(struct GNUNET_PEERSTORE_StoreHelloContext *huc)
Cancel the request to add a hello.
#define GNUNET_PEERSTORE_HELLO_KEY
Key used for storing HELLO in the peerstore.
struct GNUNET_PEERSTORE_StoreHelloContext * GNUNET_PEERSTORE_hello_add(struct GNUNET_PEERSTORE_Handle *h, const struct GNUNET_MessageHeader *msg, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Add hello to peerstore.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
#define GNUNET_MESSAGE_TYPE_HELLO_URI
Latest HELLO messages used for communicating peer addresses.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1230
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:343
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:405
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
#define GNUNET_TIME_absolute_cmp(t1, op, t2)
Compare two absolute times.
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
Closure for find_advertisable_hello().
size_t max_size
Maximum HELLO size we can use right now.
struct Peer * peer
Peer we want to advertise to.
struct GNUNET_TIME_Relative next_adv
struct Peer * result
Where to store the result (peer selected for advertising).
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
uint32_t value__
The actual value (bytes per second).
Internal representation of the hash map.
Context for the core service connection.
Definition: core_api.c:78
Private ECC key encoded for transmission.
Definition of a command line option.
Context for building (or parsing) HELLO URIs.
Definition: hello-uri.c:205
A 512-bit hashcode.
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 to the PEERSTORE service.
Definition: peerstore_api.c:46
Context for a monitor.
Single PEERSTORE record.
Context for a add hello uri request.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle for the service.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Handle to the TRANSPORT subsystem for application management.
Handle for TRANSPORT address suggestion requests.
Record for neighbours and blacklisted peers.
struct GNUNET_PeerIdentity pid
Which peer is this entry about?
struct GNUNET_MessageHeader * hello
Pointer to the hello uri of this peer; can be NULL.
struct GNUNET_TIME_Absolute next_hello_allowed
Next time we are allowed to transmit a HELLO to this peer?
struct GNUNET_CONTAINER_BloomFilter * filter
Bloom filter used to mark which peers already got the HELLO from this peer.
struct GNUNET_SCHEDULER_Task * hello_delay_task
ID of task we use to wait for the time to send the next HELLO to this peer.
struct GNUNET_TIME_Absolute filter_expiration
When should we reset the bloom filter of this entry?
struct GNUNET_TRANSPORT_ApplicationSuggestHandle * ash
Transport suggest handle.
uint32_t strength
How much would we like to connect to this peer?
struct GNUNET_MQ_Handle * mq
Our handle for transmitting to this peer; NULL if peer is not connected.
Context for a add hello uri request.
struct GNUNET_PEERSTORE_StoreHelloContext * sc
Store hello ctx.
struct StoreHelloEntry * prev
Kept (also) in a DLL.
struct StoreHelloEntry * next
Kept (also) in a DLL.