GNUnet debian-0.24.3-29-g453fda2cf
 
Loading...
Searching...
No Matches
gnunet-service-core.h File Reference

Globals for gnunet-service-core. More...

#include "gnunet_statistics_service.h"
#include "gnunet_core_service.h"
#include "core.h"
Include dependency graph for gnunet-service-core.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  GSC_ClientActiveRequest
 Record kept for each request for transmission issued by a client that is still pending. More...
 

Functions

void GSC_CLIENTS_solicit_request (struct GSC_ClientActiveRequest *car)
 Tell a client that we are ready to receive the message.
 
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).
 
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 the client is interested).
 
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.
 
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.
 
void GSC_complete_initialization_cb (void)
 This function is called from GSC_KX_init() once it got its peer id from pils.
 

Variables

const struct GNUNET_CONFIGURATION_HandleGSC_cfg
 Our configuration.
 
struct GNUNET_STATISTICS_HandleGSC_stats
 For creating statistics.
 
struct GNUNET_PeerIdentity GSC_my_identity
 Our identity.
 
static enum GNUNET_CORE_PeerClass GSC_peer_class
 Our peer class.
 

Detailed Description

Globals for gnunet-service-core.

Author
Christian Grothoff

Definition in file gnunet-service-core.h.

Function Documentation

◆ GSC_CLIENTS_solicit_request()

void GSC_CLIENTS_solicit_request ( struct GSC_ClientActiveRequest car)

Tell a client that we are ready to receive the message.

Parameters
carrequest that is now ready; the responsibility for the handle remains shared between CLIENTS and SESSIONS after this call.

Definition at line 532 of file gnunet-service-core.c.

533{
534 struct GSC_Client *c;
535 struct GNUNET_MQ_Envelope *env;
536 struct SendMessageReady *smr;
537 struct GNUNET_TIME_Relative delay;
538 struct GNUNET_TIME_Relative left;
539
540 c = car->client_handle;
541 if (GNUNET_YES !=
543 {
544 /* connection has gone down since, drop request */
545 GNUNET_assert (0 !=
546 GNUNET_memcmp (&car->target,
550 return;
551 }
554 if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
555 GNUNET_log (
557 "Client waited %s for permission to transmit to `%s'%s (priority %u)\n",
559 GNUNET_i2s (&car->target),
560 (0 == left.rel_value_us) ? " (past deadline)" : "",
561 car->priority);
563 smr->size = htons (car->msize);
564 smr->smr_id = car->smr_id;
565 smr->peer = car->target;
566 GNUNET_MQ_send (c->mq, env);
567}
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
struct GNUNET_PeerIdentity GSC_my_identity
Our identity.
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).
void GSC_SESSIONS_dequeue_request(struct GSC_ClientActiveRequest *car)
Dequeue a request from a client from transmission to a particular peer.
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
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).
#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_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.
@ GNUNET_ERROR_TYPE_WARNING
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_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
#define GNUNET_MESSAGE_TYPE_CORE_SEND_READY
Confirmation from core that message can now be sent.
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
Time for relative time used by GNUnet, in microseconds.
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?
uint16_t msize
How many bytes does the client intend to send?
struct GSC_Client * client_handle
Handle to the client.
Data structure for each client connected to the CORE service.
struct GNUNET_MQ_Handle * mq
Message queue to talk to client.
struct GNUNET_CONTAINER_MultiPeerMap * connectmap
Map containing all peers that this client knows we're connected to.
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

References GSC_ClientActiveRequest::client_handle, GSC_Client::connectmap, GSC_ClientActiveRequest::deadline, env, GNUNET_assert, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MESSAGE_TYPE_CORE_SEND_READY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, GSC_CLIENTS_reject_request(), GSC_my_identity, GSC_SESSIONS_dequeue_request(), GSC_Client::mq, GSC_ClientActiveRequest::msize, SendMessageReady::peer, GSC_ClientActiveRequest::priority, GSC_ClientActiveRequest::received_time, GNUNET_TIME_Relative::rel_value_us, SendMessageReady::size, SendMessageReady::smr_id, GSC_ClientActiveRequest::smr_id, and GSC_ClientActiveRequest::target.

Referenced by handle_client_send_request(), and solicit_messages().

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

◆ GSC_CLIENTS_reject_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).

Frees resources associated with car. We don't explicitly tell the client, it'll learn with the disconnect (or violated the protocol).

Parameters
carrequest that now permanently failed; the responsibility for the handle is now returned to CLIENTS (SESSIONS is done with it).
drop_clientGNUNET_YES if the client violated the protocol and we should thus drop the connection

Definition at line 510 of file gnunet-service-core.c.

512{
514 GNUNET_YES ==
516 &car->target,
517 car));
518 if (GNUNET_YES == drop_client)
520 GNUNET_free (car);
521}
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.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition service.c:2462
struct GNUNET_SERVICE_Client * client
Handle for the client with the server API.
struct GNUNET_CONTAINER_MultiPeerMap * requests
Map of peer identities to active transmission requests of this client to the peer (of type struct GSC...

References GSC_Client::client, GSC_ClientActiveRequest::client_handle, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_SERVICE_client_drop(), GNUNET_YES, GSC_Client::requests, and GSC_ClientActiveRequest::target.

Referenced by GSC_CLIENTS_solicit_request(), GSC_SESSIONS_end(), and GSC_SESSIONS_queue_request().

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

◆ GSC_CLIENTS_notify_client_about_neighbour()

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 the client is interested).

Called from GSC_SESSIONS_notify_client_about_sessions().

Parameters
clientclient to notify
neighbouridentity of the neighbour that changed status
tmap_oldprevious type map for the neighbour, NULL for connect
tmap_newupdated type map for the neighbour, NULL for disconnect
classthe class of the neighbour that changed status

Definition at line 912 of file gnunet-service-core.c.

916{
917 struct GNUNET_MQ_Envelope *env;
918 struct ConnectNotifyMessage *cnm;
919
920 if (GNUNET_YES != client->got_init)
921 return;
922 // TODO
923 GSC_SVCI_contains (own_services, "example", 7);
925 "Notifying client about neighbour %s\n",
926 GNUNET_i2s (neighbour));
927
928 /* send connect */
929 // TODO this used to be an assert. evaluate what handling makes sense here.
931 neighbour))
932 {
933 return;
934 }
937 client->connectmap,
938 neighbour,
939 NULL,
942 cnm->reserved = htonl (0);
944 "Sending NOTIFY_CONNECT message about peer %s to client.\n",
945 GNUNET_i2s (neighbour));
946 cnm->peer = *neighbour;
947 cnm->peer_class = class;
948 GNUNET_MQ_send (client->mq, env);
949}
static struct GSC_ServicesInfo * own_services
static enum GNUNET_GenericReturnValue GSC_SVCI_contains(struct GSC_ServicesInfo *services, char *name, uint32_t name_len)
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.
@ 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...
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
Notify clients about new peer-to-peer connections (triggered after key exchange).
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
int got_init
Have we gotten the GNUNET_MESSAGE_TYPE_CORE_INIT message from this client already?

References GSC_Client::connectmap, env, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, GSC_Client::got_init, GSC_SVCI_contains(), GSC_Client::mq, own_services, ConnectNotifyMessage::peer, ConnectNotifyMessage::peer_class, and ConnectNotifyMessage::reserved.

Referenced by GSC_CLIENTS_notify_clients_about_neighbour(), and notify_client_about_session().

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

◆ GSC_CLIENTS_deliver_message()

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.

Caller must have checked that the sending peer actually lists the given message type as one of its types.

Parameters
senderpeer who sent us the message
msgthe message
msizenumber of bytes to transmit
optionsoptions for checking which clients should receive the message

Definition at line 1004 of file gnunet-service-core.c.

1008{
1009 size_t size = msize + sizeof(struct NotifyTrafficMessage);
1010
1012 {
1013 GNUNET_break (0);
1014 return;
1015 }
1016 if (! ((0 != (all_client_options & options)) ||
1018 {
1019 return; /* no client cares about this message notification */
1020 }
1022 "Core service passes message from `%s' of type %u to client.\n",
1023 GNUNET_i2s (sender),
1024 (unsigned int) ntohs (msg->type));
1025 // TODO
1026 //GSC_SVCI_add (sender->services, "example", 7, "0.1", 3);
1027
1028 for (struct GSC_Client *c = client_head; NULL != c; c = c->next)
1029 {
1030 struct GNUNET_MQ_Envelope *env;
1031 struct NotifyTrafficMessage *ntm;
1032 uint16_t mtype;
1033 unsigned int qlen;
1034 int tm;
1035
1036 tm = type_match (ntohs (msg->type), c);
1037 if (! ((0 != (c->options & options)) ||
1039 (GNUNET_YES == tm))))
1040 continue; /* neither options nor type match permit the message */
1042 ((0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
1043 (GNUNET_YES == tm)))
1044 continue;
1046 (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)))
1047 continue;
1048
1049 /* Drop messages if:
1050 1) We are above the hard limit, or
1051 2) We are above the soft limit, and a coin toss limited
1052 to the message size (giving larger messages a
1053 proportionally higher chance of being queued) falls
1054 below the threshold. The threshold is based on where
1055 we are between the soft and the hard limit, scaled
1056 to match the range of message sizes we usually encounter
1057 (i.e. up to 32k); so a 64k message has a 50% chance of
1058 being kept if we are just barely below the hard max,
1059 and a 99% chance of being kept if we are at the soft max.
1060 The reason is to make it more likely to drop control traffic
1061 (ACK, queries) which may be cumulative or highly redundant,
1062 and cheap to drop than data traffic. */qlen = GNUNET_MQ_get_length (c->mq);
1063 if ((qlen >= HARD_MAX_QUEUE) ||
1064 ((qlen > SOFT_MAX_QUEUE) &&
1066 ntohs (msg->size))) <
1067 (qlen - SOFT_MAX_QUEUE) * 0x8000
1069 {
1070 char buf[1024];
1071
1072 GNUNET_log (
1074 "Dropping decrypted message of type %u as client is too busy (queue full)\n",
1075 (unsigned int) ntohs (msg->type));
1076 GNUNET_snprintf (buf,
1077 sizeof(buf),
1078 gettext_noop (
1079 "# messages of type %u discarded (client busy)"),
1080 (unsigned int) ntohs (msg->type));
1082 continue;
1083 }
1084
1085 GNUNET_log (
1087 "Sending %u message with %u bytes to client interested in messages of type %u.\n",
1088 options,
1089 ntohs (msg->size),
1090 (unsigned int) ntohs (msg->type));
1091
1095 else
1097 env = GNUNET_MQ_msg_extra (ntm, msize, mtype);
1098 ntm->peer = *sender;
1099 GNUNET_memcpy (&ntm[1], msg, msize);
1100
1102 (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
1103 (GNUNET_YES != tm) ||
1104 (GNUNET_YES ==
1105 GNUNET_CONTAINER_multipeermap_contains (c->connectmap, sender)));
1106 GNUNET_MQ_send (c->mq, env);
1107 }
1108}
struct GNUNET_GETOPT_CommandLineOption options[]
Definition 002.c:5
struct GNUNET_MessageHeader * msg
Definition 005.c:2
#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 GSC_Client * client_head
Head of linked list of our clients.
static int type_match(uint16_t type, struct GSC_Client *c)
Test if the client is interested in messages of the given type.
static uint32_t all_client_options
Big "or" of all client options.
#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...
struct GNUNET_STATISTICS_Handle * GSC_stats
For creating statistics.
#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...
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
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).
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_BULK
@ GNUNET_ERROR_TYPE_INFO
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.
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition mq.c:293
#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_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND
Notify clients about outgoing P2P transmissions.
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
Notify clients about incoming P2P messages.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static unsigned int size
Size of the "table".
Definition peer.c:68
struct GSC_Client * next
Clients are kept in a linked list.
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

References all_client_options, client_head, env, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CORE_OPTION_SEND_FULL_INBOUND, GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND, GNUNET_CORE_OPTION_SEND_HDR_INBOUND, GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND, GNUNET_MQ_get_length(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_snprintf(), GNUNET_STATISTICS_update(), GNUNET_YES, GSC_stats, HARD_MAX_QUEUE, msg, GSC_Client::next, options, NotifyTrafficMessage::peer, GNUNET_MessageHeader::size, size, SOFT_MAX_QUEUE, GNUNET_MessageHeader::type, and type_match().

Referenced by deliver_message(), and tokenized_cb().

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

◆ GSC_CLIENTS_notify_clients_about_neighbour()

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.

Called from SESSIONS whenever there is a change in sessions or types processed by the respective peer.

Parameters
neighbouridentity of the neighbour that changed status
tmap_oldprevious type map for the neighbour, NULL for connect
tmap_newupdated type map for the neighbour, NULL for disconnect
classthe class of the neighbour that changed status

Definition at line 979 of file gnunet-service-core.c.

982{
983 struct GSC_Client *c;
984
985 for (c = client_head; NULL != c; c = c->next)
987 neighbour,
988 class);
989}
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...

References client_head, GSC_CLIENTS_notify_client_about_neighbour(), and GSC_Client::next.

Referenced by GSC_SESSIONS_create(), and GSC_SESSIONS_end().

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

◆ GSC_complete_initialization_cb()

void GSC_complete_initialization_cb ( void  )

This function is called from GSC_KX_init() once it got its peer id from pils.

Parameters
clsclosure to the callback

Definition at line 958 of file gnunet-service-core.c.

959{
963 _ ("Core service of `%s' ready.\n"),
965}
struct GNUNET_SERVICE_Handle * service_h
Handle to the running service.
void GSC_SESSIONS_init()
Initialize sessions subsystem.
void GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh)
Resume accepting connections from the listen socket.
Definition service.c:2388
#define _(String)
GNU gettext support macro.
Definition platform.h:179

References _, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_SERVICE_resume(), GSC_my_identity, GSC_SESSIONS_init(), and service_h.

Referenced by peer_id_change_cb().

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

Variable Documentation

◆ GSC_cfg

const struct GNUNET_CONFIGURATION_Handle* GSC_cfg
extern

Our configuration.

Definition at line 123 of file gnunet-service-core.c.

Referenced by GSC_KX_init(), run(), and shutdown_task().

◆ GSC_stats

◆ GSC_my_identity

◆ GSC_peer_class

enum GNUNET_CORE_PeerClass GSC_peer_class
static

Our peer class.

Definition at line 208 of file gnunet-service-core.h.