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_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	GSC_ServicesInfo_Entry
struct	GSC_ServicesInfo
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.
#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.

Functions
static struct GSC_ServicesInfo *	GSC_SVCI_init ()
static void	GSC_SVCI_destroy (struct GSC_ServicesInfo *services_info)
static void	GSC_SVCI_add (struct GSC_ServicesInfo *services, char *name, uint32_t name_len, char *version, uint32_t version_len)
static void	GSC_SVCI_remove (struct GSC_ServicesInfo *services, char *name, uint32_t name_len)
static int	type_match (uint16_t type, struct GSC_Client *c)
	Test if the client is interested in messages of the given type.
static int	check_client_init (void *cls, const struct InitMessage *im)
	Check GNUNET_MESSAGE_TYPE_CORE_INIT request.
static void	handle_client_init (void *cls, const struct InitMessage *im)
	Handle GNUNET_MESSAGE_TYPE_CORE_INIT 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).
void	GSC_CLIENTS_solicit_request (struct GSC_ClientActiveRequest *car)
	Tell a client that we are ready to receive the message.
static void	handle_client_send_request (void *cls, const struct SendMessageRequest *req)
	Handle GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST message.
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.
static int	check_client_send (void *cls, const struct SendMessage *sm)
	Check GNUNET_MESSAGE_TYPE_CORE_SEND request.
static void	handle_client_send (void *cls, const struct SendMessage *sm)
	Handle GNUNET_MESSAGE_TYPE_CORE_SEND request.
static int	destroy_active_client_request (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Free client request records.
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	A client connected, set up.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	A client disconnected, clean up.
void	GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client, const struct GNUNET_PeerIdentity *neighbour, enum GNUNET_CORE_PeerClass class)
	Notify a particular client about a change to existing connection to one of our neighbours (check if the client is interested).
void	GSC_complete_initialization_cb (void)
	This function is called from GSC_KX_init() once it got its peer id from pils.
void	GSC_CLIENTS_notify_clients_about_neighbour (const struct GNUNET_PeerIdentity *neighbour, enum GNUNET_CORE_PeerClass class)
	Notify all clients about a change to existing session.
void	GSC_CLIENTS_deliver_message (const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, uint16_t msize, uint32_t options)
	Deliver P2P message to interested clients.
static void	shutdown_task (void *cls)
	Last task run during shutdown.
static void	handle_client_monitor_peers (void *cls, const struct GNUNET_MessageHeader *message)
	Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Initiate core service.
	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.

Variables
struct GNUNET_PeerIdentity	GSC_my_identity
	Our identity.
const struct GNUNET_CONFIGURATION_Handle *	GSC_cfg
	Our configuration.
struct GNUNET_SERVICE_Handle *	service_h
	Handle to the running service.
struct GNUNET_STATISTICS_Handle *	GSC_stats
	For creating statistics.
static enum GNUNET_CORE_PeerClass	GSC_peer_class
	Our peer class.
static uint32_t	all_client_options
	Big "or" of all client options.
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.
static struct GSC_ServicesInfo *	own_services

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

Function Documentation

GSC_SVCI_init()

static struct GSC_ServicesInfo * GSC_SVCI_init ( )

static

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

{
  struct GSC_ServicesInfo *services_info = GNUNET_new (struct GSC_ServicesInfo);
  services_info->num_entries = 0;
  services_info->entries = NULL;
  return services_info;
}

References GSC_ServicesInfo::entries, GNUNET_new, and GSC_ServicesInfo::num_entries.

Referenced by run().

Here is the caller graph for this function:

GSC_SVCI_destroy()

static void GSC_SVCI_destroy ( struct GSC_ServicesInfo *  services_info )

static

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

{
  GNUNET_assert (NULL != services_info);
  GNUNET_free (services_info);
}

References GNUNET_assert, and GNUNET_free.

Referenced by shutdown_task().

Here is the caller graph for this function:

GSC_SVCI_add()

static void GSC_SVCI_add ( struct GSC_ServicesInfo *  services, char *  name, uint32_t  name_len, char *  version, uint32_t  version_len  )

static

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

{
  struct GSC_ServicesInfo_Entry *entry;
 
  GNUNET_array_grow (services->entries, services->num_entries, 1);
  entry = &services->entries[services->num_entries - 1];
  entry->name = GNUNET_strdup (name);
  entry->name_len = name_len;
  entry->version = GNUNET_strdup (version);
  entry->version_len = version_len;
}

References GNUNET_array_grow, GNUNET_strdup, name, GSC_ServicesInfo_Entry::name, GSC_ServicesInfo_Entry::name_len, services, GSC_ServicesInfo_Entry::version, and GSC_ServicesInfo_Entry::version_len.

Referenced by handle_client_init().

Here is the caller graph for this function:

GSC_SVCI_remove()

static void GSC_SVCI_remove ( struct GSC_ServicesInfo *  services, char *  name, uint32_t  name_len  )

static

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

{
  struct GSC_ServicesInfo_Entry *entry;
  uint64_t i_entry;
 
  /* Find element */
  entry = NULL;
  for (uint64_t i = 0; i < services->num_entries; i++)
  {
    if (services->entries[i].name_len != name_len)
      continue;
    if (0 == memcmp (&services->entries[i].name, name, name_len))
    {
      entry = &services->entries[i];
      i_entry = i;
      break;
    }
  }
  if (NULL == entry)
  {
    /* No matching entry was found!*/
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No matching service entry `%s' was found in services info.\n",
                name);
    return;
  }
 
  /* Remove element */
  GNUNET_free (entry->name);
  GNUNET_free (entry->version);
  for (uint64_t i = i_entry; i < services->num_entries - 1; i++)
  {
    GNUNET_memcpy (&services->entries[i],
                   &services->entries[i + 1],
                   sizeof (services->entries[i + 1]));
  }
  GNUNET_array_grow (services->entries,
                     services->num_entries,
                     services->num_entries - 1);
}

References GNUNET_array_grow, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_memcpy, name, GSC_ServicesInfo_Entry::name, GSC_ServicesInfo_Entry::name_len, services, and GSC_ServicesInfo_Entry::version.

Referenced by client_disconnect_cb().

Here is the caller graph for this function:

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 292 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 314 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 327 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]);
  // TODO
  GSC_SVCI_add (own_services, "example", 7, "0.1", 3);
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Client connecting to core service is interested in %u message types\n",
    (unsigned int) c->tcnt);
  for (unsigned int i = 0; i < c->tcnt; i++)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "  type[%u]: %u\n",
                i,
                c->types[i]);
  /* 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;
  irm->class = GSC_peer_class;
  GNUNET_MQ_send (c->mq, env);
  GSC_SESSIONS_notify_client_about_sessions (c);
  GNUNET_SERVICE_client_continue (c->client);
}

References all_client_options, InitReplyMessage::class, 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_peer_class, GSC_SESSIONS_notify_client_about_sessions(), GSC_SVCI_add(), InitMessage::header, GSC_Client::mq, InitReplyMessage::my_identity, InitMessage::options, GSC_Client::options, own_services, 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 386 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 408 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 453 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 557 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 620 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 633 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, GNUNET_MessageStreamTokenizer::off, SendMessage::peer, SendMessage::priority, GNUNET_TIME_Relative::rel_value_us, GSC_Client::requests, 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 698 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 724 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 747 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;
  // TODO
  GSC_SVCI_remove (own_services, "example", 7);
 
  /* 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_log, GSC_SVCI_remove(), GSC_Client::next, GSC_Client::options, own_services, and GSC_Client::requests.

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,
		enum GNUNET_CORE_PeerClass	class
	)

Notify a particular client about a change to existing connection to one of our neighbours (check if the client is interested).

Called from GSC_SESSIONS_notify_client_about_sessions().

Parameters

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
class	the class of the neighbour that changed status

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

{
  struct GNUNET_MQ_Envelope *env;
  struct ConnectNotifyMessage *cnm;
 
  if (GNUNET_YES != client->got_init)
    return;
  // TODO
  // GSC_SVCI_contains (own_services, "example", 7);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Notifying client about neighbour %s\n",
              GNUNET_i2s (neighbour));
 
  /* send connect */
  //  TODO this used to be an assert. evaluate what handling makes sense here.
  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
                                                            neighbour))
  {
    return;
  }
  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;
  cnm->peer_class = class;
  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_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, GSC_Client::got_init, GSC_Client::mq, ConnectNotifyMessage::peer, ConnectNotifyMessage::peer_class, and ConnectNotifyMessage::reserved.

Referenced by GSC_CLIENTS_notify_clients_about_neighbour(), and notify_client_about_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_complete_initialization_cb()

void GSC_complete_initialization_cb

(

void

)

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

Parameters

cls	closure to the callback

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

{
  GSC_SESSIONS_init ();
  GNUNET_SERVICE_resume (service_h);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Core service of `%s' ready.\n"),
              GNUNET_i2s (&GSC_my_identity));
}

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

Referenced by peer_id_change_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_CLIENTS_notify_clients_about_neighbour()

void GSC_CLIENTS_notify_clients_about_neighbour	(	const struct GNUNET_PeerIdentity *	neighbour,
		enum GNUNET_CORE_PeerClass	class
	)

Notify all clients about a change to existing session.

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

Parameters

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
class	the class of the neighbour that changed status

Definition at line 855 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,
                                               class);
}

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

Referenced by GSC_SESSIONS_create(), and GSC_SESSIONS_end().

Here is the call graph for this function:

Here is the caller graph for this function:

GSC_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 880 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));
  // TODO
  // GSC_SVCI_add (sender->services, "example", 7, "0.1", 3);
 
  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_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 994 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_SVCI_destroy (own_services);
  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, GSC_SVCI_destroy(), and own_services.

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

{
  GSC_cfg = c;
  service_h = service;
  GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg);
  {
    /* Read the peer class from the configuration */
    const char *peer_class_str = "UNKNOWN";
    const char *choices[] = {
      "UNKNOWN",
      "UNWILLING",
      "MOBILE",
      "DESKTOP",
      "ROUTER",
      "SERVER",
      NULL
    };
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Starting CORE service\n");
    if (GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_choice (c,
                                               "core",
                                               "CLASS",
                                               choices,
                                               &peer_class_str))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "No class found in configuration! (Continuing with unknown class)");
      GSC_peer_class = GNUNET_CORE_CLASS_UNKNOWN;
    }
    if (0 == strcasecmp (peer_class_str, "UNKNOWN"))
      GSC_peer_class = GNUNET_CORE_CLASS_UNKNOWN;
    else if (0 == strcasecmp (peer_class_str, "UNWILLING"))
      GSC_peer_class = GNUNET_CORE_CLASS_UNWILLING;
    else if (0 == strcasecmp (peer_class_str, "MOBILE"))
      GSC_peer_class = GNUNET_CORE_CLASS_MOBILE;
    else if (0 == strcasecmp (peer_class_str, "DESKTOP"))
      GSC_peer_class = GNUNET_CORE_CLASS_DESKTOP;
    else if (0 == strcasecmp (peer_class_str, "ROUTER"))
      GSC_peer_class = GNUNET_CORE_CLASS_ROUTER;
    else if (0 == strcasecmp (peer_class_str, "SERVER"))
      GSC_peer_class = GNUNET_CORE_CLASS_SERVER;
    else
      GNUNET_assert (0);
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  GNUNET_SERVICE_suspend (service);
  own_services = GSC_SVCI_init ();
  if (GNUNET_OK != GSC_KX_init ())
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References GNUNET_assert, GNUNET_CONFIGURATION_get_value_choice(), GNUNET_CORE_CLASS_DESKTOP, GNUNET_CORE_CLASS_MOBILE, GNUNET_CORE_CLASS_ROUTER, GNUNET_CORE_CLASS_SERVER, GNUNET_CORE_CLASS_UNKNOWN, GNUNET_CORE_CLASS_UNWILLING, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_suspend(), GNUNET_STATISTICS_create(), GSC_cfg, GSC_KX_init(), GSC_peer_class, GSC_stats, GSC_SVCI_init(), own_services, service, service_h, 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 118 of file gnunet-service-core.c.

Referenced by GSC_CLIENTS_solicit_request(), GSC_complete_initialization_cb(), GSC_KX_init(), GSC_SESSIONS_dequeue_request(), handle_client_init(), handle_client_send_request(), handle_initiator_hello(), handle_initiator_hello_cont(), handle_transport_notify_connect(), peer_id_change_cb(), restart_kx(), send_initiator_hello(), and tokenized_cb().

GSC_cfg

const struct GNUNET_CONFIGURATION_Handle* GSC_cfg

Our configuration.

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

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

service_h

struct GNUNET_SERVICE_Handle* service_h

Handle to the running service.

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

Referenced by GSC_complete_initialization_cb(), and run().

GSC_stats

struct GNUNET_STATISTICS_Handle* GSC_stats

For creating statistics.

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

Referenced by GSC_CLIENTS_deliver_message(), GSC_SESSIONS_create(), GSC_SESSIONS_end(), handle_client_send(), handle_client_send_request(), handle_initiator_hello(), handle_transport_notify_disconnect(), restart_kx(), run(), send_heartbeat(), shutdown_task(), tokenized_cb(), and try_transmission().

GSC_peer_class

enum GNUNET_CORE_PeerClass GSC_peer_class

static

Our peer class.

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

Referenced by handle_client_init(), and run().

all_client_options

uint32_t all_client_options

static

Big "or" of all client options.

Definition at line 143 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 148 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 153 of file gnunet-service-core.c.

Referenced by client_connect_cb(), and client_disconnect_cb().

own_services

struct GSC_ServicesInfo* own_services

static

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

Referenced by client_disconnect_cb(), handle_client_init(), run(), and shutdown_task().