GNUnet 0.25.0
 
Loading...
Searching...
No Matches
gnunet-service-core.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009, 2010, 2011, 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
26#include "platform.h"
27#include <gcrypt.h>
28#include "gnunet_util_lib.h"
29#include "gnunet-service-core.h"
32#include "gnunet_constants.h"
33
40#define SOFT_MAX_QUEUE 128
41
47#define HARD_MAX_QUEUE 256
48
49
50struct GSC_ServicesInfo;
51
56{
61
66
71
76
82 uint16_t *types;
83
89
94
99 uint32_t options;
100
106
111 unsigned int tcnt;
112};
113
114
119
124
129
134
139
143static uint32_t all_client_options;
144
148static struct GSC_Client *client_head;
149
153static struct GSC_Client *client_tail;
154
155// TODO
157
158/*************************************
159 * Services Info Utils *
160 ************************************/
161
162// TODO put into gnunet-service-core_services_info.[h|c]
163// TODO write its own test
164// TODO rewrite: don't keep the big string, have only a known data structure
165// (DLL? array?) have a from_string() and a to_string()
166
167// TODO
169{
170 // TODO
171 // pointer to the beginning of service name
172 char *name; // TODO find syntax to set array size to num_entries
173 // TODO
174 uint32_t name_len;
175 // TODO
176 // pointer to the beginning of service version
177 char *version; // TODO find syntax to set array size to num_entries
178 // TODO
179 uint32_t version_len;
180};
181
182// TODO
184{
185 // TODO
186 uint32_t num_entries;
187
188 // TODO
190};
191
192// TODO
193// (?) _remove()
194// (?) _iter()
195
196// TODO
197static struct GSC_ServicesInfo *
199{
200 struct GSC_ServicesInfo *services_info = GNUNET_new (struct GSC_ServicesInfo);
201 services_info->num_entries = 0;
202 services_info->entries = NULL;
203 return services_info;
204}
205
206
207// TODO
208static void
209GSC_SVCI_destroy (struct GSC_ServicesInfo *services_info)
210{
211 GNUNET_assert (NULL != services_info);
212 GNUNET_free (services_info);
213}
214
215
216// TODO
217// todo check string size while adding!
218static void
220 char *name, uint32_t name_len,
221 char *version, uint32_t version_len)
222{
223 struct GSC_ServicesInfo_Entry *entry;
224
225 GNUNET_array_grow (services->entries, services->num_entries, 1);
226 entry = &services->entries[services->num_entries - 1];
227 entry->name = GNUNET_strdup (name);
228 entry->name_len = name_len;
229 entry->version = GNUNET_strdup (version);
230 entry->version_len = version_len;
231}
232
233
234// TODO
235static void
237 char *name, uint32_t name_len)
238{
239 struct GSC_ServicesInfo_Entry *entry;
240 uint64_t i_entry;
241
242 /* Find element */
243 entry = NULL;
244 for (uint64_t i = 0; i < services->num_entries; i++)
245 {
246 if (services->entries[i].name_len != name_len)
247 continue;
248 if (0 == memcmp (&services->entries[i].name, name, name_len))
249 {
250 entry = &services->entries[i];
251 i_entry = i;
252 break;
253 }
254 }
255 if (NULL == entry)
256 {
257 /* No matching entry was found!*/
259 "No matching service entry `%s' was found in services info.\n",
260 name);
261 return;
262 }
263
264 /* Remove element */
265 GNUNET_free (entry->name);
266 GNUNET_free (entry->version);
267 for (uint64_t i = i_entry; i < services->num_entries - 1; i++)
268 {
269 GNUNET_memcpy (&services->entries[i],
270 &services->entries[i + 1],
271 sizeof (services->entries[i + 1]));
272 }
273 GNUNET_array_grow (services->entries,
274 services->num_entries,
275 services->num_entries - 1);
276}
277
278
279/*************************************
280 * End of Services Info Utils *
281 ************************************/
282
283
291static int
292type_match (uint16_t type, struct GSC_Client *c)
293{
294 if ((0 == c->tcnt) && (0 != c->options))
295 return GNUNET_YES; /* peer without handlers and inbound/outbond
296 callbacks matches ALL */
297 if (NULL == c->types)
298 return GNUNET_NO;
299 for (unsigned int i = 0; i < c->tcnt; i++)
300 if (type == c->types[i])
301 return GNUNET_YES;
302 return GNUNET_NO;
303}
304
305
313static int
314check_client_init (void *cls, const struct InitMessage *im)
315{
316 return GNUNET_OK;
317}
318
319
326static void
327handle_client_init (void *cls, const struct InitMessage *im)
328{
329 struct GSC_Client *c = cls;
330 struct GNUNET_MQ_Envelope *env;
331 struct InitReplyMessage *irm;
332 uint16_t msize;
333 const uint16_t *types;
334
335 /* check that we don't have an entry already */
336 msize = ntohs (im->header.size) - sizeof(struct InitMessage);
337 types = (const uint16_t *) &im[1];
338 c->tcnt = msize / sizeof(uint16_t);
339 c->options = ntohl (im->options);
340 c->got_init = GNUNET_YES;
342 c->types = GNUNET_malloc (msize);
345 c->connectmap,
347 NULL,
349 for (unsigned int i = 0; i < c->tcnt; i++)
350 c->types[i] = ntohs (types[i]);
351 // TODO
352 GSC_SVCI_add (own_services, "example", 7, "0.1", 3);
353 GNUNET_log (
355 "Client connecting to core service is interested in %u message types\n",
356 (unsigned int) c->tcnt);
357 for (unsigned int i = 0; i < c->tcnt; i++)
359 " type[%u]: %u\n",
360 i,
361 c->types[i]);
362 /* send init reply message */
364 irm->reserved = htonl (0);
366 irm->class = GSC_peer_class;
367 GNUNET_MQ_send (c->mq, env);
370}
371
372
385void
387 int drop_client)
388{
390 GNUNET_YES ==
392 &car->target,
393 car));
394 if (GNUNET_YES == drop_client)
396 GNUNET_free (car);
397}
398
399
407void
409{
410 struct GSC_Client *c;
411 struct GNUNET_MQ_Envelope *env;
412 struct SendMessageReady *smr;
413 struct GNUNET_TIME_Relative delay;
414 struct GNUNET_TIME_Relative left;
415
416 c = car->client_handle;
417 if (GNUNET_YES !=
419 {
420 /* connection has gone down since, drop request */
421 GNUNET_assert (0 !=
422 GNUNET_memcmp (&car->target,
426 return;
427 }
430 if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
431 GNUNET_log (
433 "Client waited %s for permission to transmit to `%s'%s (priority %u)\n",
435 GNUNET_i2s (&car->target),
436 (0 == left.rel_value_us) ? " (past deadline)" : "",
437 car->priority);
439 smr->size = htons (car->msize);
440 smr->smr_id = car->smr_id;
441 smr->peer = car->target;
442 GNUNET_MQ_send (c->mq, env);
443}
444
445
452static void
453handle_client_send_request (void *cls, const struct SendMessageRequest *req)
454{
455 struct GSC_Client *c = cls;
456 struct GSC_ClientActiveRequest *car;
457 int is_loopback;
458
459 if (NULL == c->requests)
462 "Client asked for transmission to `%s'\n",
463 GNUNET_i2s (&req->peer));
464 is_loopback = (0 == GNUNET_memcmp (&req->peer,
466 if ((! is_loopback) &&
467 (GNUNET_YES !=
469 {
470 /* neighbour must have disconnected since request was issued,
471 * ignore (client will realize it once it processes the
472 * disconnect notification) */
475 "# send requests dropped (disconnected)"),
476 1,
477 GNUNET_NO);
479 return;
480 }
481
483 if (NULL == car)
484 {
485 /* create new entry */
486 car = GNUNET_new (struct GSC_ClientActiveRequest);
489 c->requests,
490 &req->peer,
491 car,
493 car->client_handle = c;
494 }
495 else
496 {
497 /* dequeue and recycle memory from pending request, there can only
498 be at most one per client and peer */
501 "# dequeuing CAR (duplicate request)"),
502 1,
503 GNUNET_NO);
506 "Transmission request to `%s' was a duplicate!\n",
507 GNUNET_i2s (&req->peer));
508 }
509 car->target = req->peer;
512 car->priority = ntohl (req->priority);
513 car->msize = ntohs (req->size);
514 car->smr_id = req->smr_id;
517 if (is_loopback)
518 {
519 /* loopback, satisfy immediately */
521 return;
522 }
524}
525
526
542
543
556static int
557tokenized_cb (void *cls, const struct GNUNET_MessageHeader *message)
558{
559 struct TokenizerContext *tc = cls;
560 struct GSC_ClientActiveRequest *car = tc->car;
561 char buf[92];
562
563 GNUNET_snprintf (buf,
564 sizeof(buf),
565 gettext_noop ("# bytes of messages of type %u received"),
566 (unsigned int) ntohs (message->type));
567 GNUNET_STATISTICS_update (GSC_stats, buf, ntohs (message->size), GNUNET_NO);
568 if (0 == GNUNET_memcmp (&car->target,
570 {
572 "Delivering message of type %u to myself\n",
573 ntohs (message->type));
575 message,
576 ntohs (message->size),
579 message,
580 sizeof(struct GNUNET_MessageHeader),
583 message,
584 ntohs (message->size),
587 message,
588 sizeof(struct GNUNET_MessageHeader),
590 }
591 else
592 {
594 "Delivering message of type %u and size %u to %s\n",
595 ntohs (message->type),
596 ntohs (message->size),
597 GNUNET_i2s (&car->target));
599 message,
600 ntohs (message->size),
603 message,
604 sizeof(struct GNUNET_MessageHeader),
606 GSC_SESSIONS_transmit (car, message, tc->priority);
607 }
608 return GNUNET_OK;
609}
610
611
619static int
620check_client_send (void *cls, const struct SendMessage *sm)
621{
622 return GNUNET_OK;
623}
624
625
632static void
633handle_client_send (void *cls, const struct SendMessage *sm)
634{
635 struct GSC_Client *c = cls;
636 struct TokenizerContext tc;
637 uint16_t msize;
638 struct GNUNET_TIME_Relative delay;
640
641 msize = ntohs (sm->header.size) - sizeof(struct SendMessage);
643 if (NULL == tc.car)
644 {
645 /* Must have been that we first approved the request, then got disconnected
646 * (which triggered removal of the 'car') and now the client gives us a message
647 * just *before* the client learns about the disconnect. Theoretically, we
648 * might also now be *again* connected. So this can happen (but should be
649 * rare). If it does happen, the message is discarded. */
652 "# messages discarded (session disconnected)"),
653 1,
654 GNUNET_NO);
656 return;
657 }
658 delay = GNUNET_TIME_absolute_get_duration (tc.car->received_time);
659 tc.priority = ntohl (sm->priority);
660 if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
662 "Client waited %s for transmission of %u bytes to `%s'\n",
664 msize,
665 GNUNET_i2s (&sm->peer));
666 else
668 "Client waited %s for transmission of %u bytes to `%s'\n",
670 msize,
671 GNUNET_i2s (&sm->peer));
672
674 GNUNET_YES ==
678 (const char *) &sm[1],
679 msize,
681 GNUNET_NO);
682 GNUNET_MST_destroy (mst);
684 GNUNET_free (tc.car);
686}
687
688
697static int
699 const struct GNUNET_PeerIdentity *key,
700 void *value)
701{
702 struct GSC_ClientActiveRequest *car = value;
703
705 GNUNET_YES ==
707 &car->target,
708 car));
710 GNUNET_free (car);
711 return GNUNET_YES;
712}
713
714
723static void *
725 struct GNUNET_SERVICE_Client *client,
726 struct GNUNET_MQ_Handle *mq)
727{
728 struct GSC_Client *c;
729
730 c = GNUNET_new (struct GSC_Client);
731 c->client = client;
732 c->mq = mq;
735 return c;
736}
737
738
746static void
749 void *app_ctx)
750{
751 struct GSC_Client *c = app_ctx;
752
754 "Client %p has disconnected from core service.\n",
755 client);
757 if (NULL != c->requests)
758 {
761 NULL);
763 }
765 c->connectmap = NULL;
766 // TODO
767 GSC_SVCI_remove (own_services, "example", 7);
768
769 /* recalculate 'all_client_options' */
771 for (c = client_head; NULL != c; c = c->next)
773}
774
775
787void
789 struct GSC_Client *client,
790 const struct GNUNET_PeerIdentity *neighbour,
791 enum GNUNET_CORE_PeerClass class)
792{
793 struct GNUNET_MQ_Envelope *env;
794 struct ConnectNotifyMessage *cnm;
795
796 if (GNUNET_YES != client->got_init)
797 return;
798 // TODO
799 // GSC_SVCI_contains (own_services, "example", 7);
801 "Notifying client about neighbour %s\n",
802 GNUNET_i2s (neighbour));
803
804 /* send connect */
805 // TODO this used to be an assert. evaluate what handling makes sense here.
807 neighbour))
808 {
809 return;
810 }
813 client->connectmap,
814 neighbour,
815 NULL,
818 cnm->reserved = htonl (0);
820 "Sending NOTIFY_CONNECT message about peer %s to client.\n",
821 GNUNET_i2s (neighbour));
822 cnm->peer = *neighbour;
823 cnm->peer_class = class;
824 GNUNET_MQ_send (client->mq, env);
825}
826
827
833void
835{
839 _ ("Core service of `%s' ready.\n"),
841}
842
843
854void
856 const struct GNUNET_PeerIdentity *neighbour,
857 enum GNUNET_CORE_PeerClass class)
858{
859 struct GSC_Client *c;
860
861 for (c = client_head; NULL != c; c = c->next)
863 neighbour,
864 class);
865}
866
867
879void
881 const struct GNUNET_MessageHeader *msg,
882 uint16_t msize,
883 uint32_t options)
884{
885 size_t size = msize + sizeof(struct NotifyTrafficMessage);
886
888 {
889 GNUNET_break (0);
890 return;
891 }
892 if (! ((0 != (all_client_options & options)) ||
894 {
895 return; /* no client cares about this message notification */
896 }
898 "Core service passes message from `%s' of type %u to client.\n",
899 GNUNET_i2s (sender),
900 (unsigned int) ntohs (msg->type));
901 // TODO
902 // GSC_SVCI_add (sender->services, "example", 7, "0.1", 3);
903
904 for (struct GSC_Client *c = client_head; NULL != c; c = c->next)
905 {
906 struct GNUNET_MQ_Envelope *env;
907 struct NotifyTrafficMessage *ntm;
908 uint16_t mtype;
909 unsigned int qlen;
910 int tm;
911
912 tm = type_match (ntohs (msg->type), c);
913 if (! ((0 != (c->options & options)) ||
915 (GNUNET_YES == tm))))
916 continue; /* neither options nor type match permit the message */
918 ((0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
919 (GNUNET_YES == tm)))
920 continue;
922 (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)))
923 continue;
924
925 /* Drop messages if:
926 1) We are above the hard limit, or
927 2) We are above the soft limit, and a coin toss limited
928 to the message size (giving larger messages a
929 proportionally higher chance of being queued) falls
930 below the threshold. The threshold is based on where
931 we are between the soft and the hard limit, scaled
932 to match the range of message sizes we usually encounter
933 (i.e. up to 32k); so a 64k message has a 50% chance of
934 being kept if we are just barely below the hard max,
935 and a 99% chance of being kept if we are at the soft max.
936 The reason is to make it more likely to drop control traffic
937 (ACK, queries) which may be cumulative or highly redundant,
938 and cheap to drop than data traffic. */qlen = GNUNET_MQ_get_length (c->mq);
939 if ((qlen >= HARD_MAX_QUEUE) ||
940 ((qlen > SOFT_MAX_QUEUE) &&
942 ntohs (msg->size))) <
943 (qlen - SOFT_MAX_QUEUE) * 0x8000
945 {
946 char buf[1024];
947
948 GNUNET_log (
950 "Dropping decrypted message of type %u as client is too busy (queue full)\n",
951 (unsigned int) ntohs (msg->type));
952 GNUNET_snprintf (buf,
953 sizeof(buf),
955 "# messages of type %u discarded (client busy)"),
956 (unsigned int) ntohs (msg->type));
958 continue;
959 }
960
961 GNUNET_log (
963 "Sending %u message with %u bytes to client interested in messages of type %u.\n",
964 options,
965 ntohs (msg->size),
966 (unsigned int) ntohs (msg->type));
967
971 else
973 env = GNUNET_MQ_msg_extra (ntm, msize, mtype);
974 ntm->peer = *sender;
975 GNUNET_memcpy (&ntm[1], msg, msize);
976
978 (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
979 (GNUNET_YES != tm) ||
980 (GNUNET_YES ==
981 GNUNET_CONTAINER_multipeermap_contains (c->connectmap, sender)));
982 GNUNET_MQ_send (c->mq, env);
983 }
984}
985
986
993static void
994shutdown_task (void *cls)
995{
996 struct GSC_Client *c;
997
998 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core service shutting down.\n");
999 while (NULL != (c = client_head))
1002 GSC_KX_done ();
1004 if (NULL != GSC_stats)
1005 {
1007 GSC_stats = NULL;
1008 }
1009 GSC_cfg = NULL;
1010}
1011
1012
1022static void
1024 const struct GNUNET_MessageHeader *message)
1025{
1026 struct GSC_Client *c = cls;
1027
1030}
1031
1032
1040static void
1041run (void *cls,
1042 const struct GNUNET_CONFIGURATION_Handle *c,
1044{
1045 GSC_cfg = c;
1048 {
1049 /* Read the peer class from the configuration */
1050 const char *peer_class_str = "UNKNOWN";
1051 const char *choices[] = {
1052 "UNKNOWN",
1053 "UNWILLING",
1054 "MOBILE",
1055 "DESKTOP",
1056 "ROUTER",
1057 "SERVER",
1058 NULL
1059 };
1061 "Starting CORE service\n");
1062 if (GNUNET_OK !=
1064 "core",
1065 "CLASS",
1066 choices,
1067 &peer_class_str))
1068 {
1070 "No class found in configuration! (Continuing with unknown class)");
1072 }
1073 if (0 == strcasecmp (peer_class_str, "UNKNOWN"))
1075 else if (0 == strcasecmp (peer_class_str, "UNWILLING"))
1077 else if (0 == strcasecmp (peer_class_str, "MOBILE"))
1079 else if (0 == strcasecmp (peer_class_str, "DESKTOP"))
1081 else if (0 == strcasecmp (peer_class_str, "ROUTER"))
1083 else if (0 == strcasecmp (peer_class_str, "SERVER"))
1085 else
1086 GNUNET_assert (0);
1087 }
1091 if (GNUNET_OK != GSC_KX_init ())
1092 {
1094 return;
1095 }
1096}
1097
1098
1104 "core",
1106 &run,
1109 NULL,
1110 GNUNET_MQ_hd_var_size (client_init,
1112 struct InitMessage,
1113 NULL),
1114 GNUNET_MQ_hd_fixed_size (client_monitor_peers,
1116 struct GNUNET_MessageHeader,
1117 NULL),
1118 GNUNET_MQ_hd_fixed_size (client_send_request,
1120 struct SendMessageRequest,
1121 NULL),
1122 GNUNET_MQ_hd_var_size (client_send,
1124 struct SendMessage,
1125 NULL),
1127
1128
1129/* end of gnunet-service-core.c */
struct GNUNET_GETOPT_CommandLineOption options[]
Definition 002.c:5
struct GNUNET_MessageHeader * msg
Definition 005.c:2
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
#define GNUNET_CORE_OPTION_SEND_FULL_INBOUND
Client wants all inbound messages in full.
Definition core.h:53
#define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND
Client just wants the 4-byte message headers of all outbound messages.
Definition core.h:70
#define GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND
Client wants all outbound messages in full.
Definition core.h:64
#define GNUNET_CORE_OPTION_SEND_HDR_INBOUND
Client just wants the 4-byte message headers of all inbound messages.
Definition core.h:59
#define gettext_noop(String)
Definition gettext.h:74
static struct GNUNET_CONTAINER_MultiHashMap * services
This hashmaps saves interesting things about the configured services.
struct GNUNET_HashCode key
The key used in the DHT.
struct GNUNET_SCHEDULER_Task * shutdown_task
static char * name
Name (label) of the records to list.
static char * value
Value of the record to add/remove.
static uint32_t type
Type string converted to DNS type value.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
const struct GNUNET_CONFIGURATION_Handle * GSC_cfg
Our configuration.
static struct GSC_ServicesInfo * own_services
static struct GSC_Client * client_head
Head of linked list of our clients.
static struct GSC_ServicesInfo * GSC_SVCI_init()
static void handle_client_monitor_peers(void *cls, const struct GNUNET_MessageHeader *message)
Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.
static void handle_client_init(void *cls, const struct InitMessage *im)
Handle GNUNET_MESSAGE_TYPE_CORE_INIT request.
static int type_match(uint16_t type, struct GSC_Client *c)
Test if the client is interested in messages of the given type.
static void GSC_SVCI_destroy(struct GSC_ServicesInfo *services_info)
struct GNUNET_SERVICE_Handle * service_h
Handle to the running service.
static uint32_t all_client_options
Big "or" of all client options.
void GSC_complete_initialization_cb(void)
This function is called from GSC_KX_init() once it got its peer id from pils.
struct GNUNET_PeerIdentity GSC_my_identity
Our identity.
void GSC_CLIENTS_deliver_message(const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, uint16_t msize, uint32_t options)
Deliver P2P message to interested clients.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected, set up.
static int destroy_active_client_request(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Free client request records.
static void GSC_SVCI_add(struct GSC_ServicesInfo *services, char *name, uint32_t name_len, char *version, uint32_t version_len)
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initiate core service.
static void handle_client_send_request(void *cls, const struct SendMessageRequest *req)
Handle GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST message.
#define SOFT_MAX_QUEUE
How many messages do we queue up at most for any client? This can cause messages to be dropped if cli...
static void handle_client_send(void *cls, const struct SendMessage *sm)
Handle GNUNET_MESSAGE_TYPE_CORE_SEND request.
static enum GNUNET_CORE_PeerClass GSC_peer_class
Our peer class.
static int check_client_init(void *cls, const struct InitMessage *im)
Check GNUNET_MESSAGE_TYPE_CORE_INIT request.
void GSC_CLIENTS_notify_client_about_neighbour(struct GSC_Client *client, const struct GNUNET_PeerIdentity *neighbour, enum GNUNET_CORE_PeerClass class)
Notify a particular client about a change to existing connection to one of our neighbours (check if t...
static int check_client_send(void *cls, const struct SendMessage *sm)
Check GNUNET_MESSAGE_TYPE_CORE_SEND request.
void GSC_CLIENTS_reject_request(struct GSC_ClientActiveRequest *car, int drop_client)
We will never be ready to transmit the given message in (disconnect or invalid request).
static struct GSC_Client * client_tail
Tail of linked list of our clients.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
A client disconnected, clean up.
void GSC_CLIENTS_notify_clients_about_neighbour(const struct GNUNET_PeerIdentity *neighbour, enum GNUNET_CORE_PeerClass class)
Notify all clients about a change to existing session.
struct GNUNET_STATISTICS_Handle * GSC_stats
For creating statistics.
static int tokenized_cb(void *cls, const struct GNUNET_MessageHeader *message)
Functions with this signature are called whenever a complete message is received by the tokenizer.
void GSC_CLIENTS_solicit_request(struct GSC_ClientActiveRequest *car)
Tell a client that we are ready to receive the message.
#define HARD_MAX_QUEUE
How many messages do we queue up at most for any client? This can cause messages to be dropped if cli...
static void GSC_SVCI_remove(struct GSC_ServicesInfo *services, char *name, uint32_t name_len)
Globals for gnunet-service-core.
void GSC_KX_handle_client_monitor_peers(struct GNUNET_MQ_Handle *mq)
Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.
void GSC_KX_done()
Shutdown KX subsystem.
int GSC_KX_init(void)
Initialize KX subsystem.
code for managing the key exchange (SET_KEY, PING, PONG) with other peers
void GSC_SESSIONS_dequeue_request(struct GSC_ClientActiveRequest *car)
Dequeue a request from a client from transmission to a particular peer.
void GSC_SESSIONS_transmit(struct GSC_ClientActiveRequest *car, const struct GNUNET_MessageHeader *msg, enum GNUNET_MQ_PriorityPreferences priority)
Transmit a message to a particular peer.
void GSC_SESSIONS_notify_client_about_sessions(struct GSC_Client *client)
We have a new client, notify it about all current sessions.
void GSC_SESSIONS_init()
Initialize sessions subsystem.
void GSC_SESSIONS_queue_request(struct GSC_ClientActiveRequest *car)
Queue a request from a client for transmission to a particular peer.
void GSC_SESSIONS_done()
Shutdown sessions subsystem.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_choice(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *const *choices, const char **value)
Get a configuration value that should be in a set of predefined strings.
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
GNUNET_CORE_PeerClass
The peer class gives a hint about the capabilities of a peer.
@ GNUNET_CORE_CLASS_SERVER
This is something like a server.
@ GNUNET_CORE_CLASS_UNKNOWN
The device's capabilities are currently unknown.
@ GNUNET_CORE_CLASS_ROUTER
This is a piece of network infrastructure.
@ GNUNET_CORE_CLASS_MOBILE
This is a mobile device.
@ GNUNET_CORE_CLASS_DESKTOP
This is a desktop computer.
@ GNUNET_CORE_CLASS_UNWILLING
This device is currently unwilling to spend more then the absolutely necessary resources.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#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_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.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL).
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_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ 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...
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#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.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
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_WARNING
@ GNUNET_ERROR_TYPE_BULK
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#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.
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition mq.c:293
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.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_gnunet(void)
Return default project data used by 'libgnunetutil' for GNUnet.
#define GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST
Request from client to transmit message.
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND
Notify clients about outgoing P2P transmissions.
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
Notify clients about new peer-to-peer connections (triggered after key exchange).
#define GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS
Request for connection monitoring from CORE service.
#define GNUNET_MESSAGE_TYPE_CORE_INIT
Initial setup message from core client to core.
#define GNUNET_MESSAGE_TYPE_CORE_SEND
Client with message to transmit (after SEND_READY confirmation was received).
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
Notify clients about incoming P2P messages.
#define GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
Response from core to core client to INIT message.
#define GNUNET_MESSAGE_TYPE_CORE_SEND_READY
Confirmation from core that message can now be sent.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition scheduler.c:567
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:1339
enum GNUNET_GenericReturnValue GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition mst.c:101
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition mst.c:86
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition mst.c:404
#define GNUNET_SERVICE_MAIN(pd, service_name, service_options, init_cb, connect_cb, disconnect_cb, cls,...)
Creates the "main" function for a GNUnet service.
void GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh)
Suspend accepting connections from the listen socket temporarily.
Definition service.c:2380
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition service.c:2462
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition service.c:2433
void GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh)
Resume accepting connections from the listen socket.
Definition service.c:2388
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
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_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).
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition time.c:438
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition strings.c:599
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition time.c:741
static unsigned int size
Size of the "table".
Definition peer.c:68
#define _(String)
GNU gettext support macro.
Definition platform.h:179
static struct GNUNET_MQ_Handle * mq
Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition scheduler.c:431
Message sent by the service to clients to notify them about a peer connecting.
Definition core.h:129
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition core.h:143
uint32_t reserved
Always zero.
Definition core.h:138
enum GNUNET_CORE_PeerClass peer_class
Class of the connecting peer TODO is it correct to send an enum like this?
Definition core.h:149
Internal representation of the hash map.
Handle to a message queue.
Definition mq.c:87
Header for all communications.
Handle to a message stream tokenizer.
Definition mst.c:45
size_t off
How many bytes in buffer have we already processed?
Definition mst.c:64
The identity of the host (wraps the signing key of the peer).
Handle to a client that is connected to a service.
Definition service.c:249
Handle to a service.
Definition service.c:116
Handle for the service.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Record kept for each request for transmission issued by a client that is still pending.
uint16_t smr_id
Unique request ID (in big endian).
struct GNUNET_TIME_Absolute deadline
By what time would the client want to see this message out?
struct GNUNET_TIME_Absolute received_time
At what time did we first see this request?
struct GNUNET_PeerIdentity target
Which peer is the message going to be for?
int was_solicited
Has this request been solicited yet?
uint16_t msize
How many bytes does the client intend to send?
struct GSC_Client * client_handle
Handle to the client.
enum GNUNET_MQ_PriorityPreferences priority
How important is this request.
Data structure for each client connected to the CORE service.
uint32_t options
Options for messages this client cares about, see GNUNET_CORE_OPTION_ values.
unsigned int tcnt
Number of types of incoming messages this client specifically cares about.
struct GNUNET_SERVICE_Client * client
Handle for the client with the server API.
struct GSC_Client * next
Clients are kept in a linked list.
struct GNUNET_MQ_Handle * mq
Message queue to talk to client.
struct GNUNET_CONTAINER_MultiPeerMap * requests
Map of peer identities to active transmission requests of this client to the peer (of type struct GSC...
struct GSC_Client * prev
Clients are kept in a linked list.
struct GNUNET_CONTAINER_MultiPeerMap * connectmap
Map containing all peers that this client knows we're connected to.
int got_init
Have we gotten the GNUNET_MESSAGE_TYPE_CORE_INIT message from this client already?
uint16_t * types
Array of the types of messages this peer cares about (with tcnt entries).
char * name
uint32_t name_len
uint32_t version_len
char * version
struct GSC_ServicesInfo_Entry * entries
Message transmitted core clients to gnunet-service-core to start the interaction.
Definition core.h:82
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_CORE_INIT.
Definition core.h:86
uint32_t options
Options, see GNUNET_CORE_OPTION_ values.
Definition core.h:91
Message transmitted by the gnunet-service-core process to its clients in response to an INIT message.
Definition core.h:100
enum GNUNET_CORE_PeerClass class
Class of the peer TODO is it correct to send an enum like this?
Definition core.h:120
struct GNUNET_PeerIdentity my_identity
Public key of the local peer.
Definition core.h:114
uint32_t reserved
Always zero.
Definition core.h:109
Message sent by the service to clients to notify them about messages being received or transmitted.
Definition core.h:186
struct GNUNET_PeerIdentity peer
Identity of the receiver or sender.
Definition core.h:196
Core notifying client that it is allowed to now transmit a message to the given target (response to G...
Definition core.h:252
uint16_t smr_id
smr_id from the request.
Definition core.h:269
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition core.h:274
uint16_t size
How many bytes are allowed for transmission? Guaranteed to be at least as big as the requested size,...
Definition core.h:264
Client notifying core about the maximum-priority message it has in the queue for a particular target.
Definition core.h:207
uint32_t priority
How important is this message?
Definition core.h:216
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition core.h:227
uint16_t size
How large is the message?
Definition core.h:237
uint16_t smr_id
Counter for this peer to match SMRs to replies.
Definition core.h:242
struct GNUNET_TIME_AbsoluteNBO deadline
By what time would the sender really like to see this message transmitted?
Definition core.h:222
Client asking core to transmit a particular message to a particular target (response to GNUNET_MESSAG...
Definition core.h:283
uint32_t priority
How important is this message? Contains a enum GNUNET_MQ_PriorityPreferences in NBO.
Definition core.h:293
struct GNUNET_PeerIdentity peer
Identity of the intended receiver.
Definition core.h:304
Closure for the #client_tokenizer_callback().
struct GSC_ClientActiveRequest * car
Active request handle for the message.
enum GNUNET_MQ_PriorityPreferences priority
How important is this message.