GNUnet 0.22.1
gnunet-service-core.c File Reference

high-level P2P messaging More...

#include "platform.h"
#include <gcrypt.h>
#include "gnunet_util_lib.h"
#include "gnunet-service-core.h"
#include "gnunet-service-core_kx.h"
#include "gnunet-service-core_sessions.h"
#include "gnunet-service-core_typemap.h"
#include "gnunet_constants.h"
Include dependency graph for gnunet-service-core.c:

Go to the source code of this file.

Data Structures

struct  GSC_Client
 Data structure for each client connected to the CORE service. More...
 
struct  TokenizerContext
 Closure for the #client_tokenizer_callback(). More...
 

Macros

#define SOFT_MAX_QUEUE   128
 How many messages do we queue up at most for any client? This can cause messages to be dropped if clients do not process them fast enough! Note that this is a soft limit; we try to keep a few larger messages above the limit. More...
 
#define HARD_MAX_QUEUE   256
 How many messages do we queue up at most for any client? This can cause messages to be dropped if clients do not process them fast enough! Note that this is the hard limit. More...
 

Functions

static int type_match (uint16_t type, struct GSC_Client *c)
 Test if the client is interested in messages of the given type. More...
 
static int check_client_init (void *cls, const struct InitMessage *im)
 Check GNUNET_MESSAGE_TYPE_CORE_INIT request. More...
 
static void handle_client_init (void *cls, const struct InitMessage *im)
 Handle GNUNET_MESSAGE_TYPE_CORE_INIT request. More...
 
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). More...
 
void GSC_CLIENTS_solicit_request (struct GSC_ClientActiveRequest *car)
 Tell a client that we are ready to receive the message. More...
 
static void handle_client_send_request (void *cls, const struct SendMessageRequest *req)
 Handle GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST message. More...
 
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. More...
 
static int check_client_send (void *cls, const struct SendMessage *sm)
 Check GNUNET_MESSAGE_TYPE_CORE_SEND request. More...
 
static void handle_client_send (void *cls, const struct SendMessage *sm)
 Handle GNUNET_MESSAGE_TYPE_CORE_SEND request. More...
 
static int destroy_active_client_request (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Free client request records. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 A client connected, set up. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 A client disconnected, clean up. More...
 
void GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, const struct GNUNET_PeerIdentity *neighbour, const struct GSC_TypeMap *tmap_old, const struct GSC_TypeMap *tmap_new)
 Notify a particular client about a change to existing connection to one of our neighbours (check if the client is interested). More...
 
void GSC_CLIENTS_notify_clients_about_neighbour (const struct GNUNET_PeerIdentity *neighbour, const struct GSC_TypeMap *tmap_old, const struct GSC_TypeMap *tmap_new)
 Notify all clients about a change to existing session. More...
 
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. More...
 
static void shutdown_task (void *cls)
 Last task run during shutdown. More...
 
static void handle_client_monitor_peers (void *cls, const struct GNUNET_MessageHeader *message)
 Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Initiate core service. More...
 
 GNUNET_SERVICE_MAIN ("core", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(client_init, GNUNET_MESSAGE_TYPE_CORE_INIT, struct InitMessage, NULL), GNUNET_MQ_hd_fixed_size(client_monitor_peers, GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_send_request, GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST, struct SendMessageRequest, NULL), GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_CORE_SEND, struct SendMessage, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

struct GNUNET_PeerIdentity GSC_my_identity
 Our identity. More...
 
const struct GNUNET_CONFIGURATION_HandleGSC_cfg
 Our configuration. More...
 
struct GNUNET_STATISTICS_HandleGSC_stats
 For creating statistics. More...
 
static uint32_t all_client_options
 Big "or" of all client options. More...
 
static struct GSC_Clientclient_head
 Head of linked list of our clients. More...
 
static struct GSC_Clientclient_tail
 Tail of linked list of our clients. More...
 

Detailed Description

high-level P2P messaging

Author
Christian Grothoff

Definition in file gnunet-service-core.c.

Macro Definition Documentation

◆ SOFT_MAX_QUEUE

#define SOFT_MAX_QUEUE   128

How many messages do we queue up at most for any client? This can cause messages to be dropped if clients do not process them fast enough! Note that this is a soft limit; we try to keep a few larger messages above the limit.

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

◆ HARD_MAX_QUEUE

#define HARD_MAX_QUEUE   256

How many messages do we queue up at most for any client? This can cause messages to be dropped if clients do not process them fast enough! Note that this is the hard limit.

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

Function Documentation

◆ type_match()

static int type_match ( uint16_t  type,
struct GSC_Client c 
)
static

Test if the client is interested in messages of the given type.

Parameters
typemessage type
cclient to test
Returns
GNUNET_YES if c is interested, GNUNET_NO if not.

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

154{
155 if ((0 == c->tcnt) && (0 != c->options))
156 return GNUNET_YES; /* peer without handlers and inbound/outbond
157 callbacks matches ALL */
158 if (NULL == c->types)
159 return GNUNET_NO;
160 for (unsigned int i = 0; i < c->tcnt; i++)
161 if (type == c->types[i])
162 return GNUNET_YES;
163 return GNUNET_NO;
164}
static uint32_t type
Type string converted to DNS type value.
@ GNUNET_YES
@ GNUNET_NO
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.
uint16_t * types
Array of the types of messages this peer cares about (with tcnt entries).

References GNUNET_NO, GNUNET_YES, GSC_Client::options, GSC_Client::tcnt, type, and GSC_Client::types.

Referenced by GSC_CLIENTS_deliver_message().

Here is the caller graph for this function:

◆ check_client_init()

static int check_client_init ( void *  cls,
const struct InitMessage im 
)
static

Check GNUNET_MESSAGE_TYPE_CORE_INIT request.

Parameters
clsclient that sent GNUNET_MESSAGE_TYPE_CORE_INIT
imthe struct InitMessage
Returns
GNUNET_OK if im is well-formed

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

176{
177 return GNUNET_OK;
178}
@ GNUNET_OK

References GNUNET_OK.

◆ handle_client_init()

static void handle_client_init ( void *  cls,
const struct InitMessage im 
)
static

Handle GNUNET_MESSAGE_TYPE_CORE_INIT request.

Parameters
clsclient that sent GNUNET_MESSAGE_TYPE_CORE_INIT
imthe struct InitMessage

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

189{
190 struct GSC_Client *c = cls;
191 struct GNUNET_MQ_Envelope *env;
192 struct InitReplyMessage *irm;
193 uint16_t msize;
194 const uint16_t *types;
195
196 /* check that we don't have an entry already */
197 msize = ntohs (im->header.size) - sizeof(struct InitMessage);
198 types = (const uint16_t *) &im[1];
199 c->tcnt = msize / sizeof(uint16_t);
200 c->options = ntohl (im->options);
201 c->got_init = GNUNET_YES;
203 c->types = GNUNET_malloc (msize);
206 c->connectmap,
208 NULL,
210 for (unsigned int i = 0; i < c->tcnt; i++)
211 c->types[i] = ntohs (types[i]);
212 GSC_TYPEMAP_add (c->types, c->tcnt);
213 GNUNET_log (
215 "Client connecting to core service is interested in %u message types\n",
216 (unsigned int) c->tcnt);
217 /* send init reply message */
219 irm->reserved = htonl (0);
221 GNUNET_MQ_send (c->mq, env);
224}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static uint32_t all_client_options
Big "or" of all client options.
struct GNUNET_PeerIdentity GSC_my_identity
Our identity.
void GSC_SESSIONS_notify_client_about_sessions(struct GSC_Client *client)
We have a new client, notify it about all current sessions.
void GSC_TYPEMAP_add(const uint16_t *types, unsigned int tlen)
Add a set of types to our type map.
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...
#define GNUNET_log(kind,...)
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_malloc(size)
Wrapper around malloc.
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.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
Response from core to core client to INIT message.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2348
Data structure for each client connected to the CORE service.
struct GNUNET_SERVICE_Client * client
Handle for the client with the server API.
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.
int got_init
Have we gotten the GNUNET_MESSAGE_TYPE_CORE_INIT message from this client already?
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
struct GNUNET_PeerIdentity my_identity
Public key of the local peer.
Definition: core.h:114
uint32_t reserved
Always zero.
Definition: core.h:109

References all_client_options, GSC_Client::client, GSC_Client::connectmap, env, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_YES, GSC_Client::got_init, GSC_my_identity, GSC_SESSIONS_notify_client_about_sessions(), GSC_TYPEMAP_add(), InitMessage::header, GSC_Client::mq, InitReplyMessage::my_identity, InitMessage::options, GSC_Client::options, InitReplyMessage::reserved, GNUNET_MessageHeader::size, GSC_Client::tcnt, and GSC_Client::types.

Here is the call 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 240 of file gnunet-service-core.c.

242{
244 GNUNET_YES ==
246 &car->target,
247 car));
248 if (GNUNET_YES == drop_client)
250 GNUNET_free (car);
251}
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:2377
struct GNUNET_PeerIdentity target
Which peer is the message going to be for?
struct GSC_Client * client_handle
Handle to the client.
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_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 262 of file gnunet-service-core.c.

263{
264 struct GSC_Client *c;
265 struct GNUNET_MQ_Envelope *env;
266 struct SendMessageReady *smr;
267 struct GNUNET_TIME_Relative delay;
268 struct GNUNET_TIME_Relative left;
269
270 c = car->client_handle;
271 if (GNUNET_YES !=
273 {
274 /* connection has gone down since, drop request */
275 GNUNET_assert (0 !=
276 GNUNET_memcmp (&car->target,
280 return;
281 }
284 if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
285 GNUNET_log (
287 "Client waited %s for permission to transmit to `%s'%s (priority %u)\n",
289 GNUNET_i2s (&car->target),
290 (0 == left.rel_value_us) ? " (past deadline)" : "",
291 car->priority);
293 smr->size = htons (car->msize);
294 smr->smr_id = car->smr_id;
295 smr->peer = car->target;
296 GNUNET_MQ_send (c->mq, env);
297}
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_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
#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:579
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?
uint16_t msize
How many bytes does the client intend to send?
enum GNUNET_MQ_PriorityPreferences priority
How important is this request.
Core notifying client that it is allowed to now transmit a message to the given target (response to G...
Definition: core.h:240
uint16_t smr_id
smr_id from the request.
Definition: core.h:257
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition: core.h:262
uint16_t size
How many bytes are allowed for transmission? Guaranteed to be at least as big as the requested size,...
Definition: core.h:252

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:

◆ handle_client_send_request()

static void handle_client_send_request ( void *  cls,
const struct SendMessageRequest req 
)
static

Handle GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST message.

Parameters
clsclient that sent a GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST
reqthe struct SendMessageRequest

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

308{
309 struct GSC_Client *c = cls;
310 struct GSC_ClientActiveRequest *car;
311 int is_loopback;
312
313 if (NULL == c->requests)
316 "Client asked for transmission to `%s'\n",
317 GNUNET_i2s (&req->peer));
318 is_loopback = (0 == GNUNET_memcmp (&req->peer,
320 if ((! is_loopback) &&
321 (GNUNET_YES !=
323 {
324 /* neighbour must have disconnected since request was issued,
325 * ignore (client will realize it once it processes the
326 * disconnect notification) */
329 "# send requests dropped (disconnected)"),
330 1,
331 GNUNET_NO);
333 return;
334 }
335
337 if (NULL == car)
338 {
339 /* create new entry */
340 car = GNUNET_new (struct GSC_ClientActiveRequest);
343 c->requests,
344 &req->peer,
345 car,
347 car->client_handle = c;
348 }
349 else
350 {
351 /* dequeue and recycle memory from pending request, there can only
352 be at most one per client and peer */
355 "# dequeuing CAR (duplicate request)"),
356 1,
357 GNUNET_NO);
360 "Transmission request to `%s' was a duplicate!\n",
361 GNUNET_i2s (&req->peer));
362 }
363 car->target = req->peer;
366 car->priority = ntohl (req->priority);
367 car->msize = ntohs (req->size);
368 car->smr_id = req->smr_id;
371 if (is_loopback)
372 {
373 /* loopback, satisfy immediately */
375 return;
376 }
378}
#define gettext_noop(String)
Definition: gettext.h:74
struct GNUNET_STATISTICS_Handle * GSC_stats
For creating statistics.
void GSC_CLIENTS_solicit_request(struct GSC_ClientActiveRequest *car)
Tell a client that we are ready to receive the message.
void GSC_SESSIONS_queue_request(struct GSC_ClientActiveRequest *car)
Queue a request from a client for transmission to a particular peer.
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.
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).
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
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:739
Record kept for each request for transmission issued by a client that is still pending.
int was_solicited
Has this request been solicited yet?
uint32_t priority
How important is this message?
Definition: core.h:204
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition: core.h:215
uint16_t size
How large is the message?
Definition: core.h:225
uint16_t smr_id
Counter for this peer to match SMRs to replies.
Definition: core.h:230
struct GNUNET_TIME_AbsoluteNBO deadline
By what time would the sender really like to see this message transmitted?
Definition: core.h:210

References GSC_Client::client, GSC_ClientActiveRequest::client_handle, GSC_Client::connectmap, SendMessageRequest::deadline, GSC_ClientActiveRequest::deadline, gettext_noop, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, GSC_CLIENTS_solicit_request(), GSC_my_identity, GSC_SESSIONS_dequeue_request(), GSC_SESSIONS_queue_request(), GSC_stats, GSC_ClientActiveRequest::msize, SendMessageRequest::peer, SendMessageRequest::priority, GSC_ClientActiveRequest::priority, GSC_ClientActiveRequest::received_time, GSC_Client::requests, SendMessageRequest::size, SendMessageRequest::smr_id, GSC_ClientActiveRequest::smr_id, GSC_ClientActiveRequest::target, and GSC_ClientActiveRequest::was_solicited.

Here is the call graph for this function:

◆ tokenized_cb()

static int tokenized_cb ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Functions with this signature are called whenever a complete message is received by the tokenizer.

Used by handle_client_send() for dispatching messages from clients to either the SESSION subsystem or other CLIENT (for loopback).

Parameters
clsreservation request (struct TokenizerContext)
messagethe actual message
Returns
GNUNET_OK on success, GNUNET_NO to stop further processing (no error) GNUNET_SYSERR to stop further processing with error

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

412{
413 struct TokenizerContext *tc = cls;
414 struct GSC_ClientActiveRequest *car = tc->car;
415 char buf[92];
416
417 GNUNET_snprintf (buf,
418 sizeof(buf),
419 gettext_noop ("# bytes of messages of type %u received"),
420 (unsigned int) ntohs (message->type));
421 GNUNET_STATISTICS_update (GSC_stats, buf, ntohs (message->size), GNUNET_NO);
422 if (0 == GNUNET_memcmp (&car->target,
424 {
426 "Delivering message of type %u to myself\n",
427 ntohs (message->type));
429 message,
430 ntohs (message->size),
433 message,
434 sizeof(struct GNUNET_MessageHeader),
437 message,
438 ntohs (message->size),
441 message,
442 sizeof(struct GNUNET_MessageHeader),
444 }
445 else
446 {
448 "Delivering message of type %u and size %u to %s\n",
449 ntohs (message->type),
450 ntohs (message->size),
451 GNUNET_i2s (&car->target));
453 message,
454 ntohs (message->size),
457 message,
458 sizeof(struct GNUNET_MessageHeader),
460 GSC_SESSIONS_transmit (car, message, tc->priority);
461 }
462 return GNUNET_OK;
463}
#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
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_SESSIONS_transmit(struct GSC_ClientActiveRequest *car, const struct GNUNET_MessageHeader *msg, enum GNUNET_MQ_PriorityPreferences priority)
Transmit a message to a particular peer.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
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.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:430
Header for all communications.
Closure for the #client_tokenizer_callback().

References gettext_noop, 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_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_snprintf(), GNUNET_STATISTICS_update(), GSC_CLIENTS_deliver_message(), GSC_my_identity, GSC_SESSIONS_transmit(), GSC_stats, GNUNET_MessageHeader::size, GSC_ClientActiveRequest::target, tc, and GNUNET_MessageHeader::type.

Referenced by handle_client_send().

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

◆ check_client_send()

static int check_client_send ( void *  cls,
const struct SendMessage sm 
)
static

Check GNUNET_MESSAGE_TYPE_CORE_SEND request.

Parameters
clsthe struct GSC_Client
smthe struct SendMessage
Returns
GNUNET_OK if sm is well-formed

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

475{
476 return GNUNET_OK;
477}

References GNUNET_OK.

◆ handle_client_send()

static void handle_client_send ( void *  cls,
const struct SendMessage sm 
)
static

Handle GNUNET_MESSAGE_TYPE_CORE_SEND request.

Parameters
clsthe struct GSC_Client
smthe struct SendMessage

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

488{
489 struct GSC_Client *c = cls;
490 struct TokenizerContext tc;
491 uint16_t msize;
492 struct GNUNET_TIME_Relative delay;
494
495 msize = ntohs (sm->header.size) - sizeof(struct SendMessage);
497 if (NULL == tc.car)
498 {
499 /* Must have been that we first approved the request, then got disconnected
500 * (which triggered removal of the 'car') and now the client gives us a message
501 * just *before* the client learns about the disconnect. Theoretically, we
502 * might also now be *again* connected. So this can happen (but should be
503 * rare). If it does happen, the message is discarded. */GNUNET_STATISTICS_update (GSC_stats,
505 "# messages discarded (session disconnected)"),
506 1,
507 GNUNET_NO);
509 return;
510 }
511 delay = GNUNET_TIME_absolute_get_duration (tc.car->received_time);
512 tc.priority = ntohl (sm->priority);
513 if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
515 "Client waited %s for transmission of %u bytes to `%s'\n",
517 msize,
518 GNUNET_i2s (&sm->peer));
519 else
521 "Client waited %s for transmission of %u bytes to `%s'\n",
523 msize,
524 GNUNET_i2s (&sm->peer));
525
527 GNUNET_YES ==
531 (const char *) &sm[1],
532 msize,
534 GNUNET_NO);
535 GNUNET_MST_destroy (mst);
537 GNUNET_free (tc.car);
539}
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.
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
Handle to a message stream tokenizer.
Definition: mst.c:45
Client asking core to transmit a particular message to a particular target (response to GNUNET_MESSAG...
Definition: core.h:271
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_CORE_SEND.
Definition: core.h:275
uint32_t priority
How important is this message? Contains a enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: core.h:281
struct GNUNET_PeerIdentity peer
Identity of the intended receiver.
Definition: core.h:292

References GSC_Client::client, gettext_noop, GNUNET_assert, GNUNET_CONSTANTS_LATENCY_WARN, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MST_create(), GNUNET_MST_destroy(), GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, GSC_SESSIONS_dequeue_request(), GSC_stats, SendMessage::header, SendMessage::peer, SendMessage::priority, GNUNET_TIME_Relative::rel_value_us, GSC_Client::requests, GNUNET_MessageHeader::size, tc, and tokenized_cb().

Here is the call graph for this function:

◆ destroy_active_client_request()

static int destroy_active_client_request ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Free client request records.

Parameters
clsNULL
keyidentity of peer for which this is an active request
valuethe struct GSC_ClientActiveRequest to free
Returns
GNUNET_YES (continue iteration)

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

554{
555 struct GSC_ClientActiveRequest *car = value;
556
558 GNUNET_YES ==
560 &car->target,
561 car));
563 GNUNET_free (car);
564 return GNUNET_YES;
565}
static char * value
Value of the record to add/remove.

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

Referenced by client_disconnect_cb().

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

◆ client_connect_cb()

static void * client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

A client connected, set up.

Parameters
clsclosure
clientidentification of the client
mqmessage queue to talk to client
Returns
our client handle

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

580{
581 struct GSC_Client *c;
582
583 c = GNUNET_new (struct GSC_Client);
584 c->client = client;
585 c->mq = mq;
588 return c;
589}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct GSC_Client * client_head
Head of linked list of our clients.
static struct GSC_Client * client_tail
Tail of linked list of our clients.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.

References GSC_Client::client, client_head, client_tail, GSC_Client::connectmap, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multipeermap_create(), GNUNET_new, GNUNET_NO, mq, and GSC_Client::mq.

Here is the call graph for this function:

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_ctx 
)
static

A client disconnected, clean up.

Parameters
clsclosure
clientidentification of the client
app_ctxour struct GST_Client for client

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

603{
604 struct GSC_Client *c = app_ctx;
605
607 "Client %p has disconnected from core service.\n",
608 client);
610 if (NULL != c->requests)
611 {
614 NULL);
616 }
618 c->connectmap = NULL;
619 if (NULL != c->types)
620 {
622 GNUNET_free (c->types);
623 }
624 GNUNET_free (c);
625
626 /* recalculate 'all_client_options' */
628 for (c = client_head; NULL != c; c = c->next)
630}
static int destroy_active_client_request(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Free client request records.
void GSC_TYPEMAP_remove(const uint16_t *types, unsigned int tlen)
Remove a set of message types from our type map.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
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 GSC_Client * next
Clients are kept in a linked list.

References all_client_options, GSC_Client::client, client_head, client_tail, GSC_Client::connectmap, destroy_active_client_request(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GSC_TYPEMAP_remove(), GSC_Client::next, GSC_Client::options, GSC_Client::requests, GSC_Client::tcnt, and GSC_Client::types.

Here is the call 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,
const struct GSC_TypeMap tmap_old,
const struct GSC_TypeMap tmap_new 
)

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

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

649{
650 struct GNUNET_MQ_Envelope *env;
651 int old_match;
652 int new_match;
653
654 if (GNUNET_YES != client->got_init)
655 return;
656 old_match = GSC_TYPEMAP_test_match (tmap_old, client->types, client->tcnt);
657 new_match = GSC_TYPEMAP_test_match (tmap_new, client->types, client->tcnt);
659 "Notifying client about neighbour %s (%d/%d)\n",
660 GNUNET_i2s (neighbour),
661 old_match,
662 new_match);
663 if (old_match == new_match)
664 {
666 old_match ==
668 return; /* no change */
669 }
670 if (GNUNET_NO == old_match)
671 {
672 struct ConnectNotifyMessage *cnm;
673
674 /* send connect */
676 GNUNET_NO ==
680 client->connectmap,
681 neighbour,
682 NULL,
685 cnm->reserved = htonl (0);
687 "Sending NOTIFY_CONNECT message about peer %s to client.\n",
688 GNUNET_i2s (neighbour));
689 cnm->peer = *neighbour;
690 GNUNET_MQ_send (client->mq, env);
691 }
692 else
693 {
694 struct DisconnectNotifyMessage *dcm;
695
696 /* send disconnect */
698 GNUNET_YES ==
702 neighbour,
703 NULL));
705 dcm->reserved = htonl (0);
707 "Sending NOTIFY_DISCONNECT message about peer %s to client.\n",
708 GNUNET_i2s (neighbour));
709 dcm->peer = *neighbour;
710 GNUNET_MQ_send (client->mq, env);
711 }
712}
int GSC_TYPEMAP_test_match(const struct GSC_TypeMap *tmap, const uint16_t *types, unsigned int tcnt)
Test if any of the types from the types array is in the given type map.
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
Notify clients about new peer-to-peer connections (triggered after key exchange).
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT
Notify clients about peer disconnecting.
Message sent by the service to clients to notify them about a peer connecting.
Definition: core.h:123
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition: core.h:137
uint32_t reserved
Always zero.
Definition: core.h:132
Message sent by the service to clients to notify them about a peer disconnecting.
Definition: core.h:146
uint32_t reserved
Always zero.
Definition: core.h:155
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition: core.h:160

References GSC_Client::connectmap, env, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, GSC_Client::got_init, GSC_TYPEMAP_test_match(), GSC_Client::mq, ConnectNotifyMessage::peer, DisconnectNotifyMessage::peer, ConnectNotifyMessage::reserved, DisconnectNotifyMessage::reserved, GSC_Client::tcnt, and GSC_Client::types.

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_notify_clients_about_neighbour()

void GSC_CLIENTS_notify_clients_about_neighbour ( const struct GNUNET_PeerIdentity neighbour,
const struct GSC_TypeMap tmap_old,
const struct GSC_TypeMap tmap_new 
)

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

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

729{
730 struct GSC_Client *c;
731
732 for (c = client_head; NULL != c; c = c->next)
734 neighbour,
735 tmap_old,
736 tmap_new);
737}
void GSC_CLIENTS_notify_client_about_neighbour(struct GSC_Client *client, const struct GNUNET_PeerIdentity *neighbour, const struct GSC_TypeMap *tmap_old, const struct GSC_TypeMap *tmap_new)
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_add_to_typemap(), GSC_SESSIONS_create(), GSC_SESSIONS_end(), and GSC_SESSIONS_set_typemap().

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 752 of file gnunet-service-core.c.

756{
757 size_t size = msize + sizeof(struct NotifyTrafficMessage);
758
760 {
761 GNUNET_break (0);
762 return;
763 }
764 if (! ((0 != (all_client_options & options)) ||
766 return; /* no client cares about this message notification */
768 "Core service passes message from `%s' of type %u to client.\n",
769 GNUNET_i2s (sender),
770 (unsigned int) ntohs (msg->type));
771 GSC_SESSIONS_add_to_typemap (sender, ntohs (msg->type));
772
773 for (struct GSC_Client *c = client_head; NULL != c; c = c->next)
774 {
775 struct GNUNET_MQ_Envelope *env;
776 struct NotifyTrafficMessage *ntm;
777 uint16_t mtype;
778 unsigned int qlen;
779 int tm;
780
781 tm = type_match (ntohs (msg->type), c);
782 if (! ((0 != (c->options & options)) ||
784 (GNUNET_YES == tm))))
785 continue; /* neither options nor type match permit the message */
787 ((0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
788 (GNUNET_YES == tm)))
789 continue;
791 (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)))
792 continue;
793
794 /* Drop messages if:
795 1) We are above the hard limit, or
796 2) We are above the soft limit, and a coin toss limited
797 to the message size (giving larger messages a
798 proportionally higher chance of being queued) falls
799 below the threshold. The threshold is based on where
800 we are between the soft and the hard limit, scaled
801 to match the range of message sizes we usually encounter
802 (i.e. up to 32k); so a 64k message has a 50% chance of
803 being kept if we are just barely below the hard max,
804 and a 99% chance of being kept if we are at the soft max.
805 The reason is to make it more likely to drop control traffic
806 (ACK, queries) which may be cumulative or highly redundant,
807 and cheap to drop than data traffic. */qlen = GNUNET_MQ_get_length (c->mq);
808 if ((qlen >= HARD_MAX_QUEUE) ||
809 ((qlen > SOFT_MAX_QUEUE) &&
811 ntohs (msg->size))) <
812 (qlen - SOFT_MAX_QUEUE) * 0x8000
814 {
815 char buf[1024];
816
817 GNUNET_log (
819 "Dropping decrypted message of type %u as client is too busy (queue full)\n",
820 (unsigned int) ntohs (msg->type));
821 GNUNET_snprintf (buf,
822 sizeof(buf),
824 "# messages of type %u discarded (client busy)"),
825 (unsigned int) ntohs (msg->type));
827 continue;
828 }
829
830 GNUNET_log (
832 "Sending %u message with %u bytes to client interested in messages of type %u.\n",
833 options,
834 ntohs (msg->size),
835 (unsigned int) ntohs (msg->type));
836
840 else
842 env = GNUNET_MQ_msg_extra (ntm, msize, mtype);
843 ntm->peer = *sender;
844 GNUNET_memcpy (&ntm[1], msg, msize);
845
847 (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
848 (GNUNET_YES != tm) ||
849 (GNUNET_YES ==
850 GNUNET_CONTAINER_multipeermap_contains (c->connectmap, sender)));
851 GNUNET_MQ_send (c->mq, env);
852 }
853}
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int type_match(uint16_t type, struct GSC_Client *c)
Test if the client is interested in messages of the given type.
#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...
#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...
void GSC_SESSIONS_add_to_typemap(const struct GNUNET_PeerIdentity *peer, uint16_t type)
The given peer send a message of the specified type.
#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).
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#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
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.
Definition: gnunet_mq_lib.h:63
#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.
static unsigned int size
Size of the "table".
Definition: peer.c:68
Message sent by the service to clients to notify them about messages being received or transmitted.
Definition: core.h:174
struct GNUNET_PeerIdentity peer
Identity of the receiver or sender.
Definition: core.h:184

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_SESSIONS_add_to_typemap(), 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:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Last task run during shutdown.

Disconnects us from the transport.

Parameters
clsNULL, unused

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

864{
865 struct GSC_Client *c;
866
867 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core service shutting down.\n");
868 while (NULL != (c = client_head))
871 GSC_KX_done ();
873 if (NULL != GSC_stats)
874 {
876 GSC_stats = NULL;
877 }
878 GSC_cfg = NULL;
879}
const struct GNUNET_CONFIGURATION_Handle * GSC_cfg
Our configuration.
void GSC_KX_done()
Shutdown KX subsystem.
void GSC_SESSIONS_done()
Shutdown sessions subsystem.
void GSC_TYPEMAP_done()
Shutdown typemap subsystem.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

References GSC_Client::client, client_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_destroy(), GSC_cfg, GSC_KX_done(), GSC_SESSIONS_done(), GSC_stats, and GSC_TYPEMAP_done().

Referenced by run().

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

◆ handle_client_monitor_peers()

static void handle_client_monitor_peers ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.

For this request type, the client does not have to have transmitted an INIT request. All current peers are returned, regardless of which message types they accept.

Parameters
clsclient sending the iteration request
messageiteration request message

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

894{
895 struct GSC_Client *c = cls;
896
899}
void GSC_KX_handle_client_monitor_peers(struct GNUNET_MQ_Handle *mq)
Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.

References GSC_Client::client, GNUNET_SERVICE_client_continue(), GSC_KX_handle_client_monitor_peers(), and GSC_Client::mq.

Here is the call graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Initiate core service.

Parameters
clsclosure
cconfiguration to use
servicethe initialized service

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

913{
915 char *keyfile;
916
917 GSC_cfg = c;
918 if (GNUNET_OK !=
920 "PEER",
921 "PRIVATE_KEY",
922 &keyfile))
923 {
924 GNUNET_log (
926 _ ("Core service is lacking HOSTKEY configuration setting. Exiting.\n"));
928 return;
929 }
934 if (GNUNET_SYSERR ==
937 &pk))
938 {
940 "Failed to setup peer's private key\n");
942 GNUNET_free (keyfile);
943 return;
944 }
945 GNUNET_free (keyfile);
946 if (GNUNET_OK != GSC_KX_init (&pk))
947 {
949 return;
950 }
954 _ ("Core service of `%s' ready.\n"),
956}
struct GNUNET_CRYPTO_PrivateKey pk
Private key from command line option, or NULL.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void shutdown_task(void *cls)
Last task run during shutdown.
int GSC_KX_init(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Initialize KX subsystem.
void GSC_SESSIONS_init()
Initialize sessions subsystem.
void GSC_TYPEMAP_init()
Initialize typemap subsystem.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_key_from_file(const char *filename, int do_create, struct GNUNET_CRYPTO_EddsaPrivateKey *pkey)
Create a new private key by reading it from a file.
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_ERROR
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:566
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:1338
void GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh)
Suspend accepting connections from the listen socket temporarily.
Definition: service.c:2295
void GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh)
Resume accepting connections from the listen socket.
Definition: service.c:2303
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
Private ECC key encoded for transmission.

References _, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_resume(), GNUNET_SERVICE_suspend(), GNUNET_STATISTICS_create(), GNUNET_SYSERR, GNUNET_YES, GSC_cfg, GSC_KX_init(), GSC_my_identity, GSC_SESSIONS_init(), GSC_stats, GSC_TYPEMAP_init(), pk, service, and shutdown_task().

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( "core"  ,
GNUNET_SERVICE_OPTION_NONE  ,
run,
client_connect_cb,
client_disconnect_cb,
NULL  ,
GNUNET_MQ_hd_var_size(client_init, GNUNET_MESSAGE_TYPE_CORE_INIT, struct InitMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(client_monitor_peers, GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS, struct GNUNET_MessageHeader, NULL)  ,
GNUNET_MQ_hd_fixed_size(client_send_request, GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST, struct SendMessageRequest, NULL)  ,
GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_CORE_SEND, struct SendMessage, NULL)  ,
GNUNET_MQ_handler_end()   
)

Define "main" method using service macro.

Variable Documentation

◆ GSC_my_identity

◆ GSC_cfg

const struct GNUNET_CONFIGURATION_Handle* GSC_cfg

Our configuration.

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

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

◆ GSC_stats

◆ all_client_options

uint32_t all_client_options
static

Big "or" of all client options.

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

Referenced by client_disconnect_cb(), GSC_CLIENTS_deliver_message(), and handle_client_init().

◆ client_head

struct GSC_Client* client_head
static

◆ client_tail

struct GSC_Client* client_tail
static

Tail of linked list of our clients.

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

Referenced by client_connect_cb(), and client_disconnect_cb().