gnunet-service-pils.c File Reference

peer identity lifecycle service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_pils_service.h"
#include "pils.h"

Include dependency graph for gnunet-service-pils.c:

Go to the source code of this file.

Data Structures
struct	P_Client
	Data structure for each client connected to the CORE service. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "pils", __VA_ARGS__)

Functions
static void	load_ikm ()
	Get the initial secret key for generating the peer id.
static void	print_uri (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
static void	do_generate_pid (const struct GNUNET_HELLO_Parser *parser)
	Generate the peer id from the addresses hash and the initial secret key.
static int	check_feed_addresses (void *cls, const struct FeedAddressesMessage *msg)
	Checker for feed messages.
static void	handle_feed_addresses (void *cls, const struct FeedAddressesMessage *message)
	Handler for feed addresses message from client.
static void	handle_decaps (void *cls, const struct DecapsMessage *message)
	Handler for decaps request message from client.
static int	check_sign (void *cls, const struct SignRequestMessage *msg)
	Handler for sign request message from client.
static void	handle_sign (void *cls, const struct SignRequestMessage *message)
	Handler for sign request message from client.
static void	shutdown_task (void *cls)
	Task run during shutdown.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Set up the service.
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
	Callback called when a client connects to the service.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
	Callback called when a client disconnected from the service.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "pils", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(feed_addresses, GNUNET_MESSAGE_TYPE_PILS_FEED_ADDRESSES, struct FeedAddressesMessage, NULL), GNUNET_MQ_hd_fixed_size(decaps, GNUNET_MESSAGE_TYPE_PILS_KEM_DECAPS, struct DecapsMessage, NULL), GNUNET_MQ_hd_var_size(sign, GNUNET_MESSAGE_TYPE_PILS_SIGN_REQUEST, struct SignRequestMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our current configuration.
static struct GNUNET_SCHEDULER_Task *	generate_pid_task
	Task to schedule the generation of the peer id.
struct GNUNET_HashCode	addresses_hash
	Hash of the canonicalized addresses.
struct GNUNET_CRYPTO_EddsaPrivateKey	my_private_key
	The current private key.
struct GNUNET_CRYPTO_EddsaPublicKey	my_public_key
	The current public key.
static unsigned char	ikm [256/8]
	The initial key material for the peer.
static struct P_Client *	clients_head
	Head of the liked list of clients.
static struct P_Client *	clients_tail
	Tail of the liked list of clients.
static int	have_id
	Peer ID was calculated already at least once.
static struct GNUNET_MQ_Envelope *	signed_hello
	Current signed HELLO.

Detailed Description

peer identity lifecycle service

Author

ch3

Martin Schanzenbach

This service maintains the peer identity. On address change it generates a new identity and informs subscribed components. It also signs data with the identity on request.

Definition in file gnunet-service-pils.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "pils", __VA_ARGS__)

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

Function Documentation

load_ikm()

static void load_ikm ( )

static

Get the initial secret key for generating the peer id.

This is supposed to be generated at random once in the lifetime of a peer, so all generated peer ids use the same initial secret key to obtain the same peer id per set of addresses.

First check whether there's already a initial secret key. If so: return it. If no initial secret key exists yet, generate at random and store it where it will be found.

Parameters

initial

secret key the memory the initial secret key can be written to.

Definition at line 140 of file gnunet-service-pils.c.

{
  char *keyfile;
  struct GNUNET_CRYPTO_EddsaPrivateKey key;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "PEER",
                               "PRIVATE_KEY");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup peer's private key\n");
    GNUNET_free (keyfile);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_free (keyfile);
  GNUNET_assert (sizeof ikm == sizeof key.d);
  memcpy (ikm, key.d, sizeof ikm);
}

References cfg, GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_YES, ikm, and key.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

print_uri()

static void print_uri ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const char *  uri  )

static

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

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%s\n", uri);
}

References GNUNET_ERROR_TYPE_DEBUG, LOG, and uri.

Referenced by do_generate_pid().

Here is the caller graph for this function:

do_generate_pid()

static void do_generate_pid ( const struct GNUNET_HELLO_Parser *  parser )

static

Generate the peer id from the addresses hash and the initial secret key.

Notify all subscribed clients with the new peer id.

Parameters

cls	Closure - unused.

Definition at line 192 of file gnunet-service-pils.c.

{
  struct GNUNET_HELLO_Builder *builder;
  struct GNUNET_HashCode new_addresses_hash;
  LOG (GNUNET_ERROR_TYPE_INFO, "Going to generate a new peer id\n");
  generate_pid_task = NULL;
 
  if (NULL == parser)
  {
    builder = GNUNET_HELLO_builder_new ();
  }
  else
  {
    builder = GNUNET_HELLO_builder_from_parser (parser, NULL);
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got new address list to derive PID:\n");
  GNUNET_HELLO_builder_iterate (builder, &print_uri, NULL);
  GNUNET_HELLO_builder_hash_addresses (builder,
                                       &new_addresses_hash);
#if HELLO_DETERMINISTIC_PID_DERIVATION
  if (0 == GNUNET_CRYPTO_hash_cmp (&new_addresses_hash,
                                   &addresses_hash))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Address hash unchanged at %s, ignoring...\n",
         GNUNET_h2s (&addresses_hash));
    GNUNET_HELLO_builder_free (builder);
    return;
  }
#endif
  addresses_hash = new_addresses_hash;
  GNUNET_PILS_derive_pid (sizeof ikm,
                          (uint8_t*) ikm,
                          &addresses_hash,
                          &my_private_key);
  GNUNET_CRYPTO_eddsa_key_get_public (&my_private_key, &my_public_key);
  have_id = GNUNET_YES;
  LOG (GNUNET_ERROR_TYPE_ERROR,
       "Successfully generated a new peer id %s - inform clients\n",
       GNUNET_p2s (&my_public_key));
 
  {
    struct P_Client *client;
    struct PeerIdUpdateMessage *msg;
    struct GNUNET_CRYPTO_EddsaSignature sig;
    struct GNUNET_TIME_Absolute et;
    size_t block_bytes;
    et = GNUNET_TIME_relative_to_absolute (GNUNET_HELLO_ADDRESS_EXPIRATION);
 
    struct PilsHelloSignaturePurpose hsp = {
      .purpose.size = htonl (sizeof (hsp)),
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_HELLO),
      .expiration_time = GNUNET_TIME_absolute_hton (et)
    };
    GNUNET_free (signed_hello);
    hsp.h_addrs = addresses_hash;
    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign_ (&my_private_key,
                                                           &hsp.purpose,
                                                           &sig));
    block_bytes = GNUNET_HELLO_get_builder_to_block_size (builder);
 
    signed_hello = GNUNET_MQ_msg_extra (msg,
                                        block_bytes,
                                        GNUNET_MESSAGE_TYPE_PILS_PEER_ID);
    msg->hash = addresses_hash;
    msg->block_len = htonl (block_bytes);
    GNUNET_HELLO_builder_to_block (
      builder,
      (struct GNUNET_PeerIdentity*) &my_public_key,
      &sig,
      et,
      (char *) &msg[1]);
    client = clients_head;
    while (NULL != client)
    {
      GNUNET_MQ_send_copy (client->mq, signed_hello);
      client = client->next;
    }
  }
}

References addresses_hash, builder, P_Client::client, clients_head, generate_pid_task, GNUNET_assert, GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_sign_(), GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_HELLO_ADDRESS_EXPIRATION, GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_parser(), GNUNET_HELLO_builder_hash_addresses(), GNUNET_HELLO_builder_iterate(), GNUNET_HELLO_builder_new(), GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_MESSAGE_TYPE_PILS_PEER_ID, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_OK, GNUNET_p2s(), GNUNET_PILS_derive_pid(), GNUNET_SIGNATURE_PURPOSE_HELLO, GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, PilsHelloSignaturePurpose::h_addrs, have_id, ikm, LOG, P_Client::mq, msg, my_private_key, my_public_key, P_Client::next, print_uri(), PilsHelloSignaturePurpose::purpose, signed_hello, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by handle_feed_addresses(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

check_feed_addresses()

static int check_feed_addresses ( void *  cls, const struct FeedAddressesMessage *  msg  )

static

Checker for feed messages.

Parameters

cls	client who sent the message
message	the message received

Definition at line 283 of file gnunet-service-pils.c.

{
  size_t msg_size;
  uint32_t block_bytes;
  (void) cls;
 
  msg_size = ntohs (msg->header.size);
  block_bytes = ntohl (msg->block_len);
  if (msg_size != sizeof (*msg) + block_bytes)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "The msg_size (%lu) is not  %lu (header) + %u (block)\n",
         msg_size,
         sizeof (*msg),
         block_bytes);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG, msg, and GNUNET_MessageHeader::size.

handle_feed_addresses()

static void handle_feed_addresses ( void *  cls, const struct FeedAddressesMessage *  message  )

static

Handler for feed addresses message from client.

A client (must be core) sent us the hash of the current set of addresses. This triggers the generation of the new peer id.

Parameters

cls	client who sent the message
message	the message received

Definition at line 315 of file gnunet-service-pils.c.

{
  struct P_Client *client = cls;
  struct GNUNET_HELLO_Parser *parser;
  uint32_t block_bytes;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "PILS received FEED_ADDRESSES message from client\n");
 
  /* If there's a peer id generation scheduled, just kill it and generate an id
   * on the more recent address */
  block_bytes = ntohl (message->block_len);
  parser = GNUNET_HELLO_parser_from_block_ (&message[1],
                                            block_bytes,
                                            GNUNET_YES);
  do_generate_pid (parser);
 
  GNUNET_HELLO_parser_free (parser);
  GNUNET_SERVICE_client_continue (client->client);
}

References FeedAddressesMessage::block_len, P_Client::client, do_generate_pid(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_block_(), GNUNET_SERVICE_client_continue(), GNUNET_YES, and LOG.

Here is the call graph for this function:

handle_decaps()

static void handle_decaps ( void *  cls, const struct DecapsMessage *  message  )

static

Handler for decaps request message from client.

Parameters

cls	client who sent the message
message	the message received

Definition at line 345 of file gnunet-service-pils.c.

{
  struct P_Client *client = cls;
  struct DecapsResultMessage *rmsg;
  struct GNUNET_MQ_Envelope *env;
  env = GNUNET_MQ_msg (rmsg, GNUNET_MESSAGE_TYPE_PILS_DECAPS_RESULT);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "PILS received KEM_DECAPS message from client\n");
 
  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_kem_decaps (&my_private_key,
                                                   &message->c,
                                                   &rmsg->key))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "PILS failed to decapsulate encapsulation received from client\n");
    memset (&rmsg->key, 0, sizeof (rmsg->key));
  }
 
  rmsg->rid = message->rid;
  GNUNET_MQ_send (client->mq, env);
  GNUNET_SERVICE_client_continue (client->client);
}

References DecapsMessage::c, P_Client::client, env, GNUNET_CRYPTO_eddsa_kem_decaps(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_PILS_DECAPS_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SERVICE_client_continue(), DecapsResultMessage::key, LOG, P_Client::mq, my_private_key, DecapsMessage::rid, and DecapsResultMessage::rid.

Here is the call graph for this function:

check_sign()

static int check_sign ( void *  cls, const struct SignRequestMessage *  msg  )

static

Handler for sign request message from client.

Parameters

cls	client sending the message
er_msg	message of type struct EditRecordSetMessage

Returns

GNUNET_OK if er_msg is well-formed

Definition at line 379 of file gnunet-service-pils.c.

{
  struct GNUNET_CRYPTO_EccSignaturePurpose *purp;
  size_t msg_size;
  (void) cls;
 
  msg_size = ntohs (msg->header.size);
  if (msg_size <= sizeof (*msg) + sizeof (struct
                                          GNUNET_CRYPTO_EccSignaturePurpose))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "The msg_size (%lu) is not big enough for msg (%lu) + purpose struct (%lu)\n",
         msg_size,
         sizeof (*msg),
         sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
    return GNUNET_SYSERR;
  }
  purp = (struct GNUNET_CRYPTO_EccSignaturePurpose*) &msg[1];
  if (msg_size <= sizeof (*msg) + ntohs (purp->size))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "The msg_size (%lu) is not big enough for msg (%lu) + purpose (%u)\n",
         msg_size,
         sizeof (*msg),
         ntohs (purp->size));
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG, msg, GNUNET_MessageHeader::size, and GNUNET_CRYPTO_EccSignaturePurpose::size.

handle_sign()

static void handle_sign ( void *  cls, const struct SignRequestMessage *  message  )

static

Handler for sign request message from client.

Parameters

cls	client who sent the message
message	the message received

Definition at line 417 of file gnunet-service-pils.c.

{
  struct P_Client *client = cls;
  struct SignResultMessage *rmsg;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CRYPTO_EccSignaturePurpose *purp;
  env = GNUNET_MQ_msg (rmsg, GNUNET_MESSAGE_TYPE_PILS_SIGN_RESULT);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "PILS received SIGN message from client\n");
 
  purp = (struct GNUNET_CRYPTO_EccSignaturePurpose*) &message[1];
  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_sign_ (&my_private_key,
                                              purp,
                                              &rmsg->sig))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "PILS failed to sign message received from client\n");
    memset (&rmsg->sig, 0, sizeof (rmsg->sig));
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "PILS sent SIGN_RESULT message to client %p\n",
       client->mq);
  rmsg->peer_id.public_key = my_public_key;
  rmsg->rid = message->rid;
  GNUNET_MQ_send (client->mq, env);
  GNUNET_SERVICE_client_continue (client->client);
}

References P_Client::client, env, GNUNET_CRYPTO_eddsa_sign_(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_PILS_SIGN_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SERVICE_client_continue(), LOG, P_Client::mq, my_private_key, my_public_key, SignResultMessage::peer_id, GNUNET_PeerIdentity::public_key, SignResultMessage::rid, SignRequestMessage::rid, and SignResultMessage::sig.

Here is the call graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 454 of file gnunet-service-pils.c.

{
  struct P_Client *c;
  (void) cls;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "PILS shutting down\n");
  c = clients_head;
  while (NULL != c)
  {
    struct P_Client *c_delete = c;
 
    c = c->next;
    GNUNET_SERVICE_client_drop (c_delete->client);
    /* No need to remove from DLL or free here - #client_disconnect_cb(), which
     * is called by GNUNET_SERVICE_client_drop(), takes care of this. */
  }
  if (NULL != signed_hello)
    GNUNET_free (signed_hello);
  cfg = NULL;
  if (NULL != generate_pid_task)
    GNUNET_SCHEDULER_cancel (generate_pid_task);
  GNUNET_CRYPTO_eddsa_key_clear (&my_private_key);
}

References cfg, P_Client::client, clients_head, generate_pid_task, GNUNET_CRYPTO_eddsa_key_clear(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_drop(), LOG, my_private_key, P_Client::next, and signed_hello.

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

Set up the service.

Parameters

cls	closure - unused
c	configuration to use
service	the initialized service - unused

Definition at line 488 of file gnunet-service-pils.c.

{
  cfg = c;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "PILS starting\n");
  have_id = GNUNET_NO;
  load_ikm ();
  /* Generate an initial peer id from no addresses at all
   * This is needed for scenarios in which we have only local addresses. */
  do_generate_pid (NULL);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

References cfg, do_generate_pid(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_shutdown(), have_id, load_ikm(), LOG, and shutdown_task.

Here is the call graph for this function:

client_connect_cb()

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

static

Callback called when a client connects to the service.

This stores the client in a DLL. If we have a peer id, send it immediately to the api/client.

Parameters

cls	closure for the service - unused
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

the P_Client as closure to handlers and disconnect

Definition at line 516 of file gnunet-service-pils.c.

{
  struct P_Client *client;
  (void) cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "A client `%p' connected\n",
       mq);
  client = GNUNET_new (struct P_Client);
  client->client = c;
  client->mq = mq;
  GNUNET_CONTAINER_DLL_insert (clients_head,
                               clients_tail,
                               client);
  if (GNUNET_YES == have_id)
  {
    GNUNET_MQ_send_copy (client->mq, signed_hello);
  }
  return client;
}

References P_Client::client, clients_head, clients_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_YES, have_id, LOG, mq, GNUNET_SERVICE_Client::mq, and signed_hello.

Here is the call graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, void *  internal_cls  )

static

Callback called when a client disconnected from the service.

Remove the client from the DLL

Parameters

cls	closure for the service
c	the client that disconnected
internal_cls	should be equal to c

Definition at line 549 of file gnunet-service-pils.c.

{
  struct P_Client *client_iter;
  (void) cls;
 
  client_iter = clients_head;
  while (NULL != client_iter)
  {
    struct P_Client *client_next = client_iter->next;
 
    if (client_iter->client == c)
    {
      GNUNET_CONTAINER_DLL_remove (clients_head,
                                   clients_tail,
                                   client_iter);
      GNUNET_free (client_iter);
    }
    client_iter = client_next;
  }
}

References P_Client::client, clients_head, clients_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, and P_Client::next.

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"pils"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(feed_addresses, GNUNET_MESSAGE_TYPE_PILS_FEED_ADDRESSES, struct FeedAddressesMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(decaps, GNUNET_MESSAGE_TYPE_PILS_KEM_DECAPS, struct DecapsMessage, NULL)	,
		GNUNET_MQ_hd_var_size(sign, GNUNET_MESSAGE_TYPE_PILS_SIGN_REQUEST, struct SignRequestMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to our current configuration.

Definition at line 46 of file gnunet-service-pils.c.

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

generate_pid_task

struct GNUNET_SCHEDULER_Task* generate_pid_task

static

Task to schedule the generation of the peer id.

Definition at line 52 of file gnunet-service-pils.c.

Referenced by do_generate_pid(), and shutdown_task().

addresses_hash

struct GNUNET_HashCode addresses_hash

Hash of the canonicalized addresses.

This is computed by the api, passed to the service as representation of the addresses. From it the service generates the peer id. It is also passed back to the api alongside the peer id to connect the peer id to the addresses it was based upon.

Definition at line 61 of file gnunet-service-pils.c.

Referenced by do_generate_pid().

my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey my_private_key

The current private key.

Own private key.

Definition at line 67 of file gnunet-service-pils.c.

Referenced by do_generate_pid(), handle_decaps(), handle_sign(), and shutdown_task().

my_public_key

struct GNUNET_CRYPTO_EddsaPublicKey my_public_key

The current public key.

Definition at line 73 of file gnunet-service-pils.c.

Referenced by do_generate_pid(), GNUNET_FS_uri_loc_create(), and handle_sign().

ikm

unsigned char ikm[256/8]

static

The initial key material for the peer.

Definition at line 78 of file gnunet-service-pils.c.

Referenced by checkvec(), do_generate_pid(), labeled_extract(), load_ikm(), load_ikm(), output_vectors(), and pid_change_cb().

clients_head

struct P_Client* clients_head

static

Head of the liked list of clients.

Definition at line 110 of file gnunet-service-pils.c.

Referenced by client_connect_cb(), client_disconnect_cb(), do_generate_pid(), and shutdown_task().

clients_tail

struct P_Client* clients_tail

static

Tail of the liked list of clients.

Definition at line 116 of file gnunet-service-pils.c.

Referenced by client_connect_cb(), and client_disconnect_cb().

have_id

int have_id

static

Peer ID was calculated already at least once.

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

Referenced by client_connect_cb(), do_generate_pid(), and run().

signed_hello

struct GNUNET_MQ_Envelope* signed_hello

static

Current signed HELLO.

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

Referenced by client_connect_cb(), do_generate_pid(), and shutdown_task().