pils_api.c File Reference

#include <string.h>
#include <stdint.h>
#include "platform.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_pils_service.h"
#include "pils.h"

Include dependency graph for pils_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_PILS_Operation
struct	GNUNET_PILS_Handle
	A handle for the PILS service. More...

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

Functions
static struct GNUNET_PILS_Operation *	find_op (struct GNUNET_PILS_Handle *h, uint32_t rid)
	Find the op that matches the rid. More...
static int	check_peer_id (void *cls, const struct PeerIdUpdateMessage *msg)
	Handles sign result. More...
static void	handle_peer_id (void *cls, const struct PeerIdUpdateMessage *pid_msg)
	Handles peer ids sent from the service. More...
static void	handle_sign_result (void *cls, const struct SignResultMessage *msg)
	Handles sign result. More...
static void	handle_decaps_result (void *cls, const struct DecapsResultMessage *msg)
	Handles decaps result. More...
static void	reconnect (void *cls)
	Try again to connect to peer identity lifecycle service. More...
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Handles errors with the mq. More...
struct GNUNET_PILS_Handle *	GNUNET_PILS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_PILS_PidChangeCallback pid_change_cb, void *cls)
	Connect to the PILS service. More...
void	GNUNET_PILS_disconnect (struct GNUNET_PILS_Handle *handle)
	Disconnect from the PILS service. More...
struct GNUNET_PILS_Operation *	GNUNET_PILS_sign_by_peer_identity (struct GNUNET_PILS_Handle *handle, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, GNUNET_PILS_SignResultCallback cb, void *cb_cls)
	Sign data with the peer id. More...
struct GNUNET_PILS_Operation *	GNUNET_PILS_kem_decaps (struct GNUNET_PILS_Handle *handle, const struct GNUNET_CRYPTO_HpkeEncapsulation *c, GNUNET_PILS_DecapsResultCallback cb, void *cb_cls)
	Decaps an encapsulated key with our private key. More...
void	GNUNET_PILS_cancel (struct GNUNET_PILS_Operation *op)
	Cancel request. More...
void	GNUNET_PILS_derive_pid (size_t seed_key_bytes, const uint8_t seed_key[seed_key_bytes], const struct GNUNET_HashCode *addrs_hash, struct GNUNET_CRYPTO_EddsaPrivateKey *outkey)
	Generate the peer id from the addresses hash and the initial secret key. More...
void	GNUNET_PILS_feed_addresses (struct GNUNET_PILS_Handle *handle, const struct GNUNET_HELLO_Builder *builder)
	Feed a set of addresses to pils so that it will generate a new peer id based on the given set of addresses. More...
struct GNUNET_PILS_Operation *	GNUNET_PILS_sign_hello (struct GNUNET_PILS_Handle *handle, const struct GNUNET_HELLO_Builder *builder, struct GNUNET_TIME_Absolute et, GNUNET_PILS_SignResultCallback cb, void *cb_cls)
	Create HELLO signature. More...

Detailed Description

Author

ch3

Peer Identity Lifecycle Service; the API for managing Peer Identities

This api gives access to the PILS service.

The 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 pils_api.c.

Macro Definition Documentation

LOG

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

Definition at line 44 of file pils_api.c.

Function Documentation

find_op()

static struct GNUNET_PILS_Operation * find_op ( struct GNUNET_PILS_Handle *  h, uint32_t  rid  )

static

Find the op that matches the rid.

Parameters

h	PILS handle
rid	id to look up

Returns

NULL if rid was not found

Definition at line 132 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
 
  for (op = h->op_head; op != NULL; op = op->next)
    if (op->op_id == rid)
      return op;
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "Finding request with id %u was unsuccessful\n",
       rid);
  return NULL;
}

References GNUNET_ERROR_TYPE_WARNING, h, LOG, GNUNET_PILS_Operation::next, op, and GNUNET_PILS_Operation::op_id.

Referenced by handle_decaps_result(), and handle_sign_result().

Here is the caller graph for this function:

check_peer_id()

static int check_peer_id ( void *  cls, const struct PeerIdUpdateMessage *  msg  )

static

Handles sign result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the signature

Definition at line 153 of file pils_api.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_peer_id()

static void handle_peer_id ( void *  cls, const struct PeerIdUpdateMessage *  pid_msg  )

static

Handles peer ids sent from the service.

Parameters

cls	closure - Handle to the PILS service
pid_msg	the message containing peer id and addresses hash

Definition at line 182 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_HELLO_Parser *parser;
  uint32_t block_bytes;
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  block_bytes = ntohl (pid_msg->block_len);
  parser = GNUNET_HELLO_parser_from_block (&pid_msg[1],
                                           block_bytes);
  if (NULL == parser)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Error parsing Hello block from PILS!\n");
    return;
  }
  memcpy (&h->hash, &pid_msg->hash, sizeof (struct GNUNET_HashCode));
 
  if (NULL != h->pid_change_cb)
  {
    h->pid_change_cb (h->pid_change_cb_cls,
                      parser,
                      &pid_msg->hash);
  }
  GNUNET_HELLO_parser_free (parser);
}

References PeerIdUpdateMessage::block_len, GNUNET_ERROR_TYPE_ERROR, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_block(), GNUNET_TIME_UNIT_ZERO, h, PeerIdUpdateMessage::hash, LOG, and warningfilter::parser.

Here is the call graph for this function:

handle_sign_result()

static void handle_sign_result ( void *  cls, const struct SignResultMessage *  msg  )

static

Handles sign result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the signature

Definition at line 217 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_PILS_Operation *op;
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  op = find_op (h, ntohl (msg->rid));
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received SIGN_RESULT message from service\n");
 
  if (NULL == op)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Didn't find the operation corresponding to id %u\n",
         ntohl(msg->rid));
    return;
  }
  if (NULL != op->sign_cb)
  {
    // FIXME maybe return NULL of key is 0ed
    // as this indicates an error
    op->sign_cb (op->sign_cb_cls,
                 &msg->peer_id,
                 &msg->sig);
  }
  GNUNET_CONTAINER_DLL_remove (h->op_head,
                               h->op_tail,
                               op);
  GNUNET_free (op);
}

References find_op(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_TIME_UNIT_ZERO, h, LOG, msg, op, GNUNET_PILS_Operation::sign_cb, and GNUNET_PILS_Operation::sign_cb_cls.

Here is the call graph for this function:

handle_decaps_result()

static void handle_decaps_result ( void *  cls, const struct DecapsResultMessage *  msg  )

static

Handles decaps result.

Parameters

cls	closure - Handle to the PILS service
msg	the message containing the decapsulation result

Definition at line 257 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_PILS_Operation *op;
 
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  op = find_op (h, ntohl (msg->rid));
 
  if (NULL == op)
    return;
  if (NULL != op->decaps_cb)
  {
    // FIXME maybe return NULL of key is 0ed
    // as this indicates an error
    op->decaps_cb (op->decaps_cb_cls,
                   &msg->key);
  }
  GNUNET_CONTAINER_DLL_remove (h->op_head,
                               h->op_tail,
                               op);
  GNUNET_free (op);
}

References GNUNET_PILS_Operation::decaps_cb, GNUNET_PILS_Operation::decaps_cb_cls, find_op(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_TIME_UNIT_ZERO, h, msg, and op.

Here is the call graph for this function:

reconnect()

static void reconnect ( void *  cls )

static

Try again to connect to peer identity lifecycle service.

Parameters

cls	the struct GNUNET_PILS_Handle *

Definition at line 321 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (peer_id,
                           GNUNET_MESSAGE_TYPE_PILS_PEER_ID,
                           struct PeerIdUpdateMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (decaps_result,
                             GNUNET_MESSAGE_TYPE_PILS_DECAPS_RESULT,
                             struct DecapsResultMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (sign_result,
                             GNUNET_MESSAGE_TYPE_PILS_SIGN_RESULT,
                             struct SignResultMessage,
                             h),
    GNUNET_MQ_handler_end ()
  };
 
  h->reconnect_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connecting to peer identity lifecycle service.\n");
  GNUNET_assert (NULL == h->mq);
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "pils",
                                 handlers,
                                 &mq_error_handler,
                                 h);
  if (NULL == h->mq)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to connect.\n");
    {
      h->reconnect_task =
        GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
      h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
    }
    return;
  }
  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG,
                           "pils-api",
                           "Connection to service successful!.\n");
}

References GNUNET_ARM_Handle::cfg, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from_nocheck(), GNUNET_MESSAGE_TYPE_PILS_DECAPS_RESULT, GNUNET_MESSAGE_TYPE_PILS_PEER_ID, GNUNET_MESSAGE_TYPE_PILS_SIGN_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), peer_id, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by GNUNET_PILS_connect(), mq_error_handler(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Handles errors with the mq.

Schedules the reconnect task and updates the reconnect delay.

Parameters

cls	closure - handle to PILS
error	error type indicating the kind of problem with mq

Definition at line 298 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = cls;
  (void) error;
 
  // TODO logging
  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_ERROR,
                           "pils-api",
                           "(mq_error_handler) Connection to service failed!.\n");
  GNUNET_MQ_destroy (h->mq);
  h->mq = NULL;
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from_nocheck(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, GNUNET_ARM_Handle::mq, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_connect()

struct GNUNET_PILS_Handle * GNUNET_PILS_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_PILS_PidChangeCallback	pid_change_cb,
		void *	cls
	)

Connect to the PILS service.

Parameters

cfg	configuration to use
pid_change_cb	handler/callback called once the peer id changes
cls	closure for pid_change_cb

Returns

Handle to the PILS service

Definition at line 367 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h;
 
  h = GNUNET_new (struct GNUNET_PILS_Handle);
  h->cfg = cfg;
  h->pid_change_cb = pid_change_cb;
  h->pid_change_cb_cls = cls;
  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
  reconnect (h);
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_new, GNUNET_TIME_UNIT_ZERO, h, pid_change_cb(), and reconnect().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_disconnect()

void GNUNET_PILS_disconnect

(

struct GNUNET_PILS_Handle *

handle

)

Disconnect from the PILS service.

Parameters

handle

handle to the PILS service (was returned by GNUNET_PILS_connect)

Definition at line 390 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
 
  GNUNET_assert (NULL != handle);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Disonnecting from peer identity lifecycle service.\n");
  if (NULL != handle->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
    handle->reconnect_task = NULL;
  }
  if (NULL != handle->mq)
  {
    GNUNET_MQ_destroy (handle->mq);
    handle->mq = NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  while (NULL != (op = handle->op_head))
  {
    GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op);
    GNUNET_free (op);
  }
  GNUNET_free (handle);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), handle, LOG, GNUNET_VPN_Handle::mq, and op.

Referenced by cleaning_task(), do_shutdown(), GCH_shutdown(), GSC_KX_done(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_sign_by_peer_identity()

struct GNUNET_PILS_Operation * GNUNET_PILS_sign_by_peer_identity	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_CRYPTO_EccSignaturePurpose *	purpose,
		GNUNET_PILS_SignResultCallback	cb,
		void *	cb_cls
	)

Sign data with the peer id.

Parameters

handle	handle to the PILS service
purpose	what to sign (size, purpose and data)
cb	callback to call once the signature is ready
cb_cls	closure to cb

Returns

handle to the operation, NULL on error

Definition at line 428 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
  struct SignRequestMessage *msg;
 
  op = GNUNET_new (struct GNUNET_PILS_Operation);
  op->env = GNUNET_MQ_msg_extra (msg,
                                 ntohl (purpose->size),
                                 GNUNET_MESSAGE_TYPE_PILS_SIGN_REQUEST);
  op->h = handle;
  op->sign_cb = cb;
  op->sign_cb_cls = cb_cls;
  msg->rid = htonl (handle->op_id_counter++);
  op->op_id = ntohl (msg->rid);
  memcpy (&msg[1], purpose, ntohl (purpose->size));
  GNUNET_CONTAINER_DLL_insert (handle->op_head,
                               handle->op_tail,
                               op);
  // FIXME resend?
  GNUNET_MQ_send (handle->mq, op->env);
  op->env = NULL;
  return op;
}

References GNUNET_PILS_Operation::env, GNUNET_CONTAINER_DLL_insert, GNUNET_MESSAGE_TYPE_PILS_SIGN_REQUEST, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_PILS_Operation::h, handle, GNUNET_VPN_Handle::mq, msg, op, GNUNET_PILS_Operation::op_id, GNUNET_PILS_Operation::sign_cb, GNUNET_PILS_Operation::sign_cb_cls, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by forward_dv_learn(), GNUNET_PILS_sign_hello(), handle_validation_challenge(), pils_sign_address(), sign_ephemeral(), start_dv_learn(), and transmit_task_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_kem_decaps()

struct GNUNET_PILS_Operation * GNUNET_PILS_kem_decaps	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_CRYPTO_HpkeEncapsulation *	c,
		GNUNET_PILS_DecapsResultCallback	cb,
		void *	cb_cls
	)

Decaps an encapsulated key with our private key.

Parameters

handle	handle to the PILS service
c	the encapsulated key
prk	where to write the key material HKDF-Extract(c||aX)=HKDF-Extract(c||x(aG))

Returns

handle to the operation, NULL on error

Definition at line 468 of file pils_api.c.

{
  struct GNUNET_PILS_Operation *op;
  struct DecapsMessage *msg;
 
  op = GNUNET_new (struct GNUNET_PILS_Operation);
  op->env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_PILS_KEM_DECAPS);
  msg->c = *c;
  op->h = handle;
  op->decaps_cb = cb;
  op->decaps_cb_cls = cb_cls;
  msg->rid = htonl (handle->op_id_counter++);
  op->op_id = ntohl (msg->rid);
  GNUNET_CONTAINER_DLL_insert (handle->op_head,
                               handle->op_tail,
                               op);
  // FIXME resend?
  GNUNET_MQ_send (handle->mq, op->env);
  op->env = NULL;
  return op;
}

References DecapsMessage::c, GNUNET_PILS_Operation::decaps_cb, GNUNET_PILS_Operation::decaps_cb_cls, GNUNET_PILS_Operation::env, GNUNET_CONTAINER_DLL_insert, GNUNET_MESSAGE_TYPE_PILS_KEM_DECAPS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_PILS_Operation::h, handle, GNUNET_VPN_Handle::mq, msg, op, and GNUNET_PILS_Operation::op_id.

Referenced by handle_dv_box(), handle_initiator_hello(), and handle_responder_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_cancel()

void GNUNET_PILS_cancel

(

struct GNUNET_PILS_Operation *

op

)

Cancel request.

Parameters

op	cancel PILS operation

Definition at line 495 of file pils_api.c.

{
  struct GNUNET_PILS_Handle *h = op->h;
 
  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
  if (NULL != op->env)
    GNUNET_MQ_discard (op->env);
  GNUNET_free (op);
}

References GNUNET_PILS_Operation::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), h, GNUNET_PILS_Operation::h, and op.

Referenced by do_shutdown(), GCH_shutdown(), GSC_KX_done(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_derive_pid()

void GNUNET_PILS_derive_pid	(	size_t	seed_key_bytes,
		const uint8_t	seed_key[seed_key_bytes],
		const struct GNUNET_HashCode *	addrs_hash,
		struct GNUNET_CRYPTO_EddsaPrivateKey *	outkey
	)

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

Parameters

	seed_key_bytes	length of the seed key in bytes
	seed_key	the initial secret key
	addrs_hash	the address to use for derivation
[out]	outkey	the (private) peer identity key

Since we should have initial keying material of good quality here, this is effectively a PRF called on the address hash with a uniform random key.

We now expand the PRK to the key size we actually require. FIXME: IF we want to use elligator, we need to find a private key that can actually be used as such. For that, we may want to add a coutner to the initial secret key to the above PRF.

Definition at line 507 of file pils_api.c.

{
  struct GNUNET_ShortHashCode prk;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_hkdf_extract (&prk,
                                             addrs_hash,
                                             sizeof *addrs_hash,
                                             seed_key,
                                             seed_key_bytes));
  GNUNET_CRYPTO_hkdf_expand (outkey,
                             sizeof *outkey,
                             &prk,
                             "gnunet-pils-ephemeral-peer-key",
                             strlen ("gnunet-pils-ephemeral-peer-key"),
                             NULL, 0);
}

References GNUNET_assert, GNUNET_CRYPTO_hkdf_expand(), GNUNET_CRYPTO_hkdf_extract(), GNUNET_OK, and seed_key.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_feed_addresses()

void GNUNET_PILS_feed_addresses	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_HELLO_Builder *	addresses_builder
	)

Feed a set of addresses to pils so that it will generate a new peer id based on the given set of addresses.

THIS IS ONLY TO BE CALLED FROM CORE!

The address representation will be canonicalized/sorted by pils before the new peer id is generated.

Parameters

handle	the handle to the PILS service
addresses_builder	addresses to feed as builder

Definition at line 542 of file pils_api.c.

{
  struct FeedAddressesMessage *msg;
  struct GNUNET_MQ_Envelope *env;
  size_t block_bytes;
 
  block_bytes = GNUNET_HELLO_get_builder_to_block_size (builder);
  // TODO check whether the new hash and the 'current' hash are the same -
  //      nothing to do in that case (directly return the peer id?)
  env = GNUNET_MQ_msg_extra (msg,
                             block_bytes,
                             GNUNET_MESSAGE_TYPE_PILS_FEED_ADDRESSES);
  msg->block_len = htonl (block_bytes);
  GNUNET_HELLO_builder_to_block (
    builder,
    NULL,
    NULL,
    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_ZERO),
    (char*) &msg[1]);
  GNUNET_MQ_send (handle->mq, env);
}

References builder, env, GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_MESSAGE_TYPE_PILS_FEED_ADDRESSES, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_ZERO, handle, GNUNET_VPN_Handle::mq, and msg.

Referenced by feed_addresses_to_pils().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PILS_sign_hello()

struct GNUNET_PILS_Operation * GNUNET_PILS_sign_hello	(	struct GNUNET_PILS_Handle *	handle,
		const struct GNUNET_HELLO_Builder *	builder,
		struct GNUNET_TIME_Absolute	et,
		GNUNET_PILS_SignResultCallback	cb,
		void *	cb_cls
	)

Create HELLO signature.

Parameters

handle	hande to the pils service
builder	the builder to use
et	expiration time to sign
cb	callback to call with the signature
cb_cls	closure to cb

Definition at line 576 of file pils_api.c.

{
  struct PilsHelloSignaturePurpose hsp = {
    .purpose.size = htonl (sizeof (hsp)),
    .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_HELLO),
    .expiration_time = GNUNET_TIME_absolute_hton (et)
  };
  GNUNET_HELLO_builder_hash_addresses (builder,
                                       &hsp.h_addrs);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Address hash is %s\n",
              GNUNET_h2s_full (&hsp.h_addrs));
  return GNUNET_PILS_sign_by_peer_identity (handle,
                                            &hsp.purpose,
                                            cb,
                                            cb_cls);
}

References builder, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s_full(), GNUNET_HELLO_builder_hash_addresses(), GNUNET_log, GNUNET_PILS_sign_by_peer_identity(), GNUNET_SIGNATURE_PURPOSE_HELLO, GNUNET_TIME_absolute_hton(), PilsHelloSignaturePurpose::h_addrs, handle, PilsHelloSignaturePurpose::purpose, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by peerstore_store_own_cb(), and pid_changed_cb().

Here is the call graph for this function:

Here is the caller graph for this function: