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 (GNUNET_OS_project_data_gnunet(), "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_Handle *	GSC_cfg
	Our configuration. More...
struct GNUNET_STATISTICS_Handle *	GSC_stats
	For creating statistics. More...
static uint32_t	all_client_options
	Big "or" of all client options. More...
static struct GSC_Client *	client_head
	Head of linked list of our clients. More...
static struct GSC_Client *	client_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

type	message type
c	client to test

Returns

GNUNET_YES if c is interested, GNUNET_NO if not.

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

{
  if ((0 == c->tcnt) && (0 != c->options))
    return GNUNET_YES; /* peer without handlers and inbound/outbond
                                   callbacks matches ALL */
  if (NULL == c->types)
    return GNUNET_NO;
  for (unsigned int i = 0; i < c->tcnt; i++)
    if (type == c->types[i])
      return GNUNET_YES;
  return GNUNET_NO;
}

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

cls	client that sent GNUNET_MESSAGE_TYPE_CORE_INIT
im	the struct InitMessage

Returns

GNUNET_OK if im is well-formed

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

{
  return 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

cls	client that sent GNUNET_MESSAGE_TYPE_CORE_INIT
im	the struct InitMessage

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

{
  struct GSC_Client *c = cls;
  struct GNUNET_MQ_Envelope *env;
  struct InitReplyMessage *irm;
  uint16_t msize;
  const uint16_t *types;
 
  /* check that we don't have an entry already */
  msize = ntohs (im->header.size) - sizeof(struct InitMessage);
  types = (const uint16_t *) &im[1];
  c->tcnt = msize / sizeof(uint16_t);
  c->options = ntohl (im->options);
  c->got_init = GNUNET_YES;
  all_client_options |= c->options;
  c->types = GNUNET_malloc (msize);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (
                   c->connectmap,
                   &GSC_my_identity,
                   NULL,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  for (unsigned int i = 0; i < c->tcnt; i++)
    c->types[i] = ntohs (types[i]);
  GSC_TYPEMAP_add (c->types, c->tcnt);
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Client connecting to core service is interested in %u message types\n",
    (unsigned int) c->tcnt);
  /* send init reply message */
  env = GNUNET_MQ_msg (irm, GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY);
  irm->reserved = htonl (0);
  irm->my_identity = GSC_my_identity;
  GNUNET_MQ_send (c->mq, env);
  GSC_SESSIONS_notify_client_about_sessions (c);
  GNUNET_SERVICE_client_continue (c->client);
}

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

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

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

{
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (car->client_handle->requests,
                                          &car->target,
                                          car));
  if (GNUNET_YES == drop_client)
    GNUNET_SERVICE_client_drop (car->client_handle->client);
  GNUNET_free (car);
}

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

car	request 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.

{
  struct GSC_Client *c;
  struct GNUNET_MQ_Envelope *env;
  struct SendMessageReady *smr;
  struct GNUNET_TIME_Relative delay;
  struct GNUNET_TIME_Relative left;
 
  c = car->client_handle;
  if (GNUNET_YES !=
      GNUNET_CONTAINER_multipeermap_contains (c->connectmap, &car->target))
  {
    /* connection has gone down since, drop request */
    GNUNET_assert (0 !=
                   GNUNET_memcmp (&car->target,
                                  &GSC_my_identity));
    GSC_SESSIONS_dequeue_request (car);
    GSC_CLIENTS_reject_request (car, GNUNET_NO);
    return;
  }
  delay = GNUNET_TIME_absolute_get_duration (car->received_time);
  left = GNUNET_TIME_absolute_get_duration (car->deadline);
  if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      "Client waited %s for permission to transmit to `%s'%s (priority %u)\n",
      GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
      GNUNET_i2s (&car->target),
      (0 == left.rel_value_us) ? " (past deadline)" : "",
      car->priority);
  env = GNUNET_MQ_msg (smr, GNUNET_MESSAGE_TYPE_CORE_SEND_READY);
  smr->size = htons (car->msize);
  smr->smr_id = car->smr_id;
  smr->peer = car->target;
  GNUNET_MQ_send (c->mq, env);
}

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

cls	client that sent a GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST
req	the struct SendMessageRequest

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

{
  struct GSC_Client *c = cls;
  struct GSC_ClientActiveRequest *car;
  int is_loopback;
 
  if (NULL == c->requests)
    c->requests = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client asked for transmission to `%s'\n",
              GNUNET_i2s (&req->peer));
  is_loopback = (0 == GNUNET_memcmp (&req->peer,
                                     &GSC_my_identity));
  if ((! is_loopback) &&
      (GNUNET_YES !=
       GNUNET_CONTAINER_multipeermap_contains (c->connectmap, &req->peer)))
  {
    /* neighbour must have disconnected since request was issued,
     * ignore (client will realize it once it processes the
     * disconnect notification) */
    GNUNET_STATISTICS_update (GSC_stats,
                              gettext_noop (
                                "# send requests dropped (disconnected)"),
                              1,
                              GNUNET_NO);
    GNUNET_SERVICE_client_continue (c->client);
    return;
  }
 
  car = GNUNET_CONTAINER_multipeermap_get (c->requests, &req->peer);
  if (NULL == car)
  {
    /* create new entry */
    car = GNUNET_new (struct GSC_ClientActiveRequest);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (
                     c->requests,
                     &req->peer,
                     car,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
    car->client_handle = c;
  }
  else
  {
    /* dequeue and recycle memory from pending request, there can only
       be at most one per client and peer */
    GNUNET_STATISTICS_update (GSC_stats,
                              gettext_noop (
                                "# dequeuing CAR (duplicate request)"),
                              1,
                              GNUNET_NO);
    GSC_SESSIONS_dequeue_request (car);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission request to `%s' was a duplicate!\n",
                GNUNET_i2s (&req->peer));
  }
  car->target = req->peer;
  car->received_time = GNUNET_TIME_absolute_get ();
  car->deadline = GNUNET_TIME_absolute_ntoh (req->deadline);
  car->priority = ntohl (req->priority);
  car->msize = ntohs (req->size);
  car->smr_id = req->smr_id;
  car->was_solicited = GNUNET_NO;
  GNUNET_SERVICE_client_continue (c->client);
  if (is_loopback)
  {
    /* loopback, satisfy immediately */
    GSC_CLIENTS_solicit_request (car);
    return;
  }
  GSC_SESSIONS_queue_request (car);
}

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

cls	reservation request (struct TokenizerContext)
message	the 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.

{
  struct TokenizerContext *tc = cls;
  struct GSC_ClientActiveRequest *car = tc->car;
  char buf[92];
 
  GNUNET_snprintf (buf,
                   sizeof(buf),
                   gettext_noop ("# bytes of messages of type %u received"),
                   (unsigned int) ntohs (message->type));
  GNUNET_STATISTICS_update (GSC_stats, buf, ntohs (message->size), GNUNET_NO);
  if (0 == GNUNET_memcmp (&car->target,
                          &GSC_my_identity))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Delivering message of type %u to myself\n",
                ntohs (message->type));
    GSC_CLIENTS_deliver_message (&GSC_my_identity,
                                 message,
                                 ntohs (message->size),
                                 GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
    GSC_CLIENTS_deliver_message (&GSC_my_identity,
                                 message,
                                 sizeof(struct GNUNET_MessageHeader),
                                 GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
    GSC_CLIENTS_deliver_message (&GSC_my_identity,
                                 message,
                                 ntohs (message->size),
                                 GNUNET_CORE_OPTION_SEND_FULL_INBOUND);
    GSC_CLIENTS_deliver_message (&GSC_my_identity,
                                 message,
                                 sizeof(struct GNUNET_MessageHeader),
                                 GNUNET_CORE_OPTION_SEND_HDR_INBOUND);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Delivering message of type %u and size %u to %s\n",
                ntohs (message->type),
                ntohs (message->size),
                GNUNET_i2s (&car->target));
    GSC_CLIENTS_deliver_message (&car->target,
                                 message,
                                 ntohs (message->size),
                                 GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
    GSC_CLIENTS_deliver_message (&car->target,
                                 message,
                                 sizeof(struct GNUNET_MessageHeader),
                                 GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
    GSC_SESSIONS_transmit (car, message, tc->priority);
  }
  return GNUNET_OK;
}

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

cls	the struct GSC_Client
sm	the struct SendMessage

Returns

GNUNET_OK if sm is well-formed

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

{
  return GNUNET_OK;
}

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

cls	the struct GSC_Client
sm	the struct SendMessage

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

{
  struct GSC_Client *c = cls;
  struct TokenizerContext tc;
  uint16_t msize;
  struct GNUNET_TIME_Relative delay;
  struct GNUNET_MessageStreamTokenizer *mst;
 
  msize = ntohs (sm->header.size) - sizeof(struct SendMessage);
  tc.car = GNUNET_CONTAINER_multipeermap_get (c->requests, &sm->peer);
  if (NULL == tc.car)
  {
    /* Must have been that we first approved the request, then got disconnected
     * (which triggered removal of the 'car') and now the client gives us a message
     * just *before* the client learns about the disconnect.  Theoretically, we
     * might also now be *again* connected.  So this can happen (but should be
     * rare).  If it does happen, the message is discarded. */GNUNET_STATISTICS_update (GSC_stats,
                              gettext_noop (
                                "# messages discarded (session disconnected)"),
                              1,
                              GNUNET_NO);
    GNUNET_SERVICE_client_continue (c->client);
    return;
  }
  delay = GNUNET_TIME_absolute_get_duration (tc.car->received_time);
  tc.priority = ntohl (sm->priority);
  if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Client waited %s for transmission of %u bytes to `%s'\n",
                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
                msize,
                GNUNET_i2s (&sm->peer));
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Client waited %s for transmission of %u bytes to `%s'\n",
                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
                msize,
                GNUNET_i2s (&sm->peer));
 
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (c->requests, &sm->peer, tc.car));
  mst = GNUNET_MST_create (&tokenized_cb, &tc);
  GNUNET_MST_from_buffer (mst,
                          (const char *) &sm[1],
                          msize,
                          GNUNET_YES,
                          GNUNET_NO);
  GNUNET_MST_destroy (mst);
  GSC_SESSIONS_dequeue_request (tc.car);
  GNUNET_free (tc.car);
  GNUNET_SERVICE_client_continue (c->client);
}

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

cls	NULL
key	identity of peer for which this is an active request
value	the struct GSC_ClientActiveRequest to free

Returns

GNUNET_YES (continue iteration)

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

{
  struct GSC_ClientActiveRequest *car = value;
 
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (car->client_handle->requests,
                                          &car->target,
                                          car));
  GSC_SESSIONS_dequeue_request (car);
  GNUNET_free (car);
  return GNUNET_YES;
}

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

cls	closure
client	identification of the client
mq	message queue to talk to client

Returns

our client handle

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

{
  struct GSC_Client *c;
 
  c = GNUNET_new (struct GSC_Client);
  c->client = client;
  c->mq = mq;
  c->connectmap = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
  GNUNET_CONTAINER_DLL_insert (client_head, client_tail, c);
  return c;
}

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

cls	closure
client	identification of the client
app_ctx	our struct GST_Client for client

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

{
  struct GSC_Client *c = app_ctx;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p has disconnected from core service.\n",
              client);
  GNUNET_CONTAINER_DLL_remove (client_head, client_tail, c);
  if (NULL != c->requests)
  {
    GNUNET_CONTAINER_multipeermap_iterate (c->requests,
                                           &destroy_active_client_request,
                                           NULL);
    GNUNET_CONTAINER_multipeermap_destroy (c->requests);
  }
  GNUNET_CONTAINER_multipeermap_destroy (c->connectmap);
  c->connectmap = NULL;
  if (NULL != c->types)
  {
    GSC_TYPEMAP_remove (c->types, c->tcnt);
    GNUNET_free (c->types);
  }
  GNUNET_free (c);
 
  /* recalculate 'all_client_options' */
  all_client_options = 0;
  for (c = client_head; NULL != c; c = c->next)
    all_client_options |= c->options;
}

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

client	client to notify
neighbour	identity of the neighbour that changed status
tmap_old	previous type map for the neighbour, NULL for connect
tmap_new	updated type map for the neighbour, NULL for disconnect

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

{
  struct GNUNET_MQ_Envelope *env;
  int old_match;
  int new_match;
 
  if (GNUNET_YES != client->got_init)
    return;
  old_match = GSC_TYPEMAP_test_match (tmap_old, client->types, client->tcnt);
  new_match = GSC_TYPEMAP_test_match (tmap_new, client->types, client->tcnt);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Notifying client about neighbour %s (%d/%d)\n",
              GNUNET_i2s (neighbour),
              old_match,
              new_match);
  if (old_match == new_match)
  {
    GNUNET_assert (
      old_match ==
      GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour));
    return;   /* no change */
  }
  if (GNUNET_NO == old_match)
  {
    struct ConnectNotifyMessage *cnm;
 
    /* send connect */
    GNUNET_assert (
      GNUNET_NO ==
      GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour));
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_put (
                     client->connectmap,
                     neighbour,
                     NULL,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    env = GNUNET_MQ_msg (cnm, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
    cnm->reserved = htonl (0);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending NOTIFY_CONNECT message about peer %s to client.\n",
                GNUNET_i2s (neighbour));
    cnm->peer = *neighbour;
    GNUNET_MQ_send (client->mq, env);
  }
  else
  {
    struct DisconnectNotifyMessage *dcm;
 
    /* send disconnect */
    GNUNET_assert (
      GNUNET_YES ==
      GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour));
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_remove (client->connectmap,
                                                         neighbour,
                                                         NULL));
    env = GNUNET_MQ_msg (dcm, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
    dcm->reserved = htonl (0);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending NOTIFY_DISCONNECT message about peer %s to client.\n",
                GNUNET_i2s (neighbour));
    dcm->peer = *neighbour;
    GNUNET_MQ_send (client->mq, env);
  }
}

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

neighbour	identity of the neighbour that changed status
tmap_old	previous type map for the neighbour, NULL for connect
tmap_new	updated type map for the neighbour, NULL for disconnect

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

{
  struct GSC_Client *c;
 
  for (c = client_head; NULL != c; c = c->next)
    GSC_CLIENTS_notify_client_about_neighbour (c,
                                               neighbour,
                                               tmap_old,
                                               tmap_new);
}

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

sender	peer who sent us the message
msg	the message
msize	number of bytes to transmit
options	options for checking which clients should receive the message

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

{
  size_t size = msize + sizeof(struct NotifyTrafficMessage);
 
  if (size >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return;
  }
  if (! ((0 != (all_client_options & options)) ||
         (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))))
    return; /* no client cares about this message notification */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Core service passes message from `%s' of type %u to client.\n",
              GNUNET_i2s (sender),
              (unsigned int) ntohs (msg->type));
  GSC_SESSIONS_add_to_typemap (sender, ntohs (msg->type));
 
  for (struct GSC_Client *c = client_head; NULL != c; c = c->next)
  {
    struct GNUNET_MQ_Envelope *env;
    struct NotifyTrafficMessage *ntm;
    uint16_t mtype;
    unsigned int qlen;
    int tm;
 
    tm = type_match (ntohs (msg->type), c);
    if (! ((0 != (c->options & options)) ||
           ((0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) &&
            (GNUNET_YES == tm))))
      continue;   /* neither options nor type match permit the message */
    if ((0 != (options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)) &&
        ((0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
         (GNUNET_YES == tm)))
      continue;
    if ((0 != (options & GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND)) &&
        (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)))
      continue;
 
    /* Drop messages if:
       1) We are above the hard limit, or
       2) We are above the soft limit, and a coin toss limited
          to the message size (giving larger messages a
          proportionally higher chance of being queued) falls
          below the threshold. The threshold is based on where
          we are between the soft and the hard limit, scaled
          to match the range of message sizes we usually encounter
          (i.e. up to 32k); so a 64k message has a 50% chance of
          being kept if we are just barely below the hard max,
          and a 99% chance of being kept if we are at the soft max.
       The reason is to make it more likely to drop control traffic
       (ACK, queries) which may be cumulative or highly redundant,
       and cheap to drop than data traffic.  */qlen = GNUNET_MQ_get_length (c->mq);
    if ((qlen >= HARD_MAX_QUEUE) ||
        ((qlen > SOFT_MAX_QUEUE) &&
         ((GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                     ntohs (msg->size))) <
          (qlen - SOFT_MAX_QUEUE) * 0x8000
          / (HARD_MAX_QUEUE - SOFT_MAX_QUEUE))))
    {
      char buf[1024];
 
      GNUNET_log (
        GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
        "Dropping decrypted message of type %u as client is too busy (queue full)\n",
        (unsigned int) ntohs (msg->type));
      GNUNET_snprintf (buf,
                       sizeof(buf),
                       gettext_noop (
                         "# messages of type %u discarded (client busy)"),
                       (unsigned int) ntohs (msg->type));
      GNUNET_STATISTICS_update (GSC_stats, buf, 1, GNUNET_NO);
      continue;
    }
 
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "Sending %u message with %u bytes to client interested in messages of type %u.\n",
      options,
      ntohs (msg->size),
      (unsigned int) ntohs (msg->type));
 
    if (0 != (options & (GNUNET_CORE_OPTION_SEND_FULL_INBOUND
                         | GNUNET_CORE_OPTION_SEND_HDR_INBOUND)))
      mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND;
    else
      mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND;
    env = GNUNET_MQ_msg_extra (ntm, msize, mtype);
    ntm->peer = *sender;
    GNUNET_memcpy (&ntm[1], msg, msize);
 
    GNUNET_assert (
      (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
      (GNUNET_YES != tm) ||
      (GNUNET_YES ==
       GNUNET_CONTAINER_multipeermap_contains (c->connectmap, sender)));
    GNUNET_MQ_send (c->mq, env);
  }
}

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

cls	NULL, unused

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

{
  struct GSC_Client *c;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core service shutting down.\n");
  while (NULL != (c = client_head))
    GNUNET_SERVICE_client_drop (c->client);
  GSC_SESSIONS_done ();
  GSC_KX_done ();
  GSC_TYPEMAP_done ();
  if (NULL != GSC_stats)
  {
    GNUNET_STATISTICS_destroy (GSC_stats, GNUNET_NO);
    GSC_stats = NULL;
  }
  GSC_cfg = NULL;
}

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

cls	client sending the iteration request
message	iteration request message

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

{
  struct GSC_Client *c = cls;
 
  GNUNET_SERVICE_client_continue (c->client);
  GSC_KX_handle_client_monitor_peers (c->mq);
}

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

cls	closure
c	configuration to use
service	the initialized service

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

{
  struct GNUNET_CRYPTO_EddsaPrivateKey pk;
  char *keyfile;
 
  GSC_cfg = c;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (GSC_cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ ("Core service is lacking HOSTKEY configuration setting.  Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  GNUNET_SERVICE_suspend (service);
  GSC_TYPEMAP_init ();
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &pk))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup peer's private key\n");
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (keyfile);
    return;
  }
  GNUNET_free (keyfile);
  if (GNUNET_OK != GSC_KX_init (&pk))
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GSC_SESSIONS_init ();
  GNUNET_SERVICE_resume (service);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Core service of `%s' ready.\n"),
              GNUNET_i2s (&GSC_my_identity));
}

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	(	GNUNET_OS_project_data_gnunet()	,
		"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

struct GNUNET_PeerIdentity GSC_my_identity

Our identity.

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

Referenced by derive_session_keys(), GSC_CLIENTS_solicit_request(), GSC_KX_init(), GSC_SESSIONS_add_to_typemap(), GSC_SESSIONS_dequeue_request(), handle_client_init(), handle_client_send_request(), handle_encrypted(), handle_ping(), handle_pong(), handle_transport_notify_connect(), run(), sign_ephemeral_key(), and tokenized_cb().

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

struct GNUNET_STATISTICS_Handle* GSC_stats

For creating statistics.

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

Referenced by broadcast_my_type_map(), deliver_message(), do_decrypt(), do_encrypt(), GSC_CLIENTS_deliver_message(), GSC_SESSIONS_confirm_typemap(), GSC_SESSIONS_create(), GSC_SESSIONS_end(), GSC_TYPEMAP_get_from_message(), handle_client_send(), handle_client_send_request(), handle_encrypted(), handle_ephemeral_key(), handle_ping(), handle_pong(), handle_transport_notify_connect(), handle_transport_notify_disconnect(), run(), send_keep_alive(), send_ping(), shutdown_task(), tokenized_cb(), transmit_typemap_task(), and try_transmission().

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

Head of linked list of our clients.

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

Referenced by client_connect_cb(), client_disconnect_cb(), GSC_CLIENTS_deliver_message(), GSC_CLIENTS_notify_clients_about_neighbour(), and shutdown_task().

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