Hello_Uri library

Helper library for handling HELLO URIs. More...

Collaboration diagram for Hello_Uri library:

Macros
#define	GNUNET_HELLO_ADDRESS_EXPIRATION
	For how long are HELLO signatures valid?

Typedefs
typedef void(*	GNUNET_HELLO_UriCallback) (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
	Callback function used to extract URIs from a builder.

Functions
struct GNUNET_HELLO_Builder *	GNUNET_HELLO_builder_new ()
	Allocate builder.
struct GNUNET_HELLO_Builder *	GNUNET_HELLO_builder_from_parser (const struct GNUNET_HELLO_Parser *parser, struct GNUNET_PeerIdentity *pid)
	Allocate builder from parser.
const struct GNUNET_PeerIdentity *	GNUNET_HELLO_parser_get_id (const struct GNUNET_HELLO_Parser *parser)
	Get the PeerIdentity for this builder.
void	GNUNET_HELLO_builder_free (struct GNUNET_HELLO_Builder *builder)
	Release resources of a builder.
void	GNUNET_HELLO_parser_free (struct GNUNET_HELLO_Parser *parser)
	Release resources of a builder.
struct GNUNET_HELLO_Parser *	GNUNET_HELLO_parser_from_msg (const struct GNUNET_MessageHeader *msg, const struct GNUNET_PeerIdentity *pid)
	Parse msg.
struct GNUNET_HELLO_Parser *	GNUNET_HELLO_parser_from_msg_ (const struct GNUNET_MessageHeader *msg, const struct GNUNET_PeerIdentity *pid, int noverify)
	Parse msg.
struct GNUNET_HELLO_Parser *	GNUNET_HELLO_parser_from_block (const void *block, size_t block_size)
	Parse block.
struct GNUNET_HELLO_Parser *	GNUNET_HELLO_parser_from_block_ (const void *block, size_t block_size, int noverify)
	Parse block.
struct GNUNET_HELLO_Parser *	GNUNET_HELLO_parser_from_url (const char *url)
	Parse GNUnet HELLO url.
struct GNUNET_TIME_Absolute	GNUNET_HELLO_get_expiration_time_from_msg (const struct GNUNET_MessageHeader *msg)
	Get the expiration time for this HELLO.
struct GNUNET_MQ_Envelope *	GNUNET_HELLO_parser_to_env (const struct GNUNET_HELLO_Parser *parser)
	Generate envelope with GNUnet HELLO message (including peer ID) from a parser.
char *	GNUNET_HELLO_parser_to_url (const struct GNUNET_HELLO_Parser *parser)
	Generate GNUnet HELLO URI from a parser.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_parser_to_block (const struct GNUNET_HELLO_Parser *parser, void *block, size_t *block_size)
	Generate DHT block from a parser.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_builder_add_address (struct GNUNET_HELLO_Builder *builder, const char *address)
	Add individual address to the builder.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_builder_del_address (struct GNUNET_HELLO_Builder *builder, const char *address)
	Remove individual address from the builder.
void	GNUNET_HELLO_builder_iterate (const struct GNUNET_HELLO_Builder *builder, GNUNET_HELLO_UriCallback uc, void *uc_cls)
	Iterate over URIs in a builder.
const struct GNUNET_PeerIdentity *	GNUNET_HELLO_parser_iterate (const struct GNUNET_HELLO_Parser *parser, GNUNET_HELLO_UriCallback uc, void *uc_cls)
	Iterate over URIs in a parser.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_dht_msg_to_block (const struct GNUNET_MessageHeader *hello, const struct GNUNET_PeerIdentity *pid, void **block, size_t *block_size, struct GNUNET_TIME_Absolute *block_expiration)
	Convert a DHT hello message to a HELLO block.
char *	GNUNET_HELLO_address_to_prefix (const char *address)
	Given an address as a string, extract the prefix that identifies the communicator offering transmissions to that address.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_build_url (const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig, struct GNUNET_TIME_Absolute expiration, char **result)
struct GNUNET_MessageHeader *	GNUNET_HELLO_builder_to_dht_hello_msg (const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig, struct GNUNET_TIME_Absolute expiration_time)
	Generate DHT HELLO message (without peer ID) from a builder.
struct GNUNET_MessageHeader *	GNUNET_HELLO_parser_to_dht_hello_msg (const struct GNUNET_HELLO_Parser *parser)
	Generate DHT HELLO message from a parser.
void	GNUNET_HELLO_builder_to_block (const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig, struct GNUNET_TIME_Absolute expiration_time, char *outbuf)
	Generate DHT block from a builder.
void	GNUNET_HELLO_builder_hash_addresses (const struct GNUNET_HELLO_Builder *builder, struct GNUNET_HashCode *hash)
	Compute hash over addresses in builder.
struct GNUNET_MQ_Envelope *	GNUNET_HELLO_builder_to_env (const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig, struct GNUNET_TIME_Absolute expiration_time)
	Generate envelope with GNUnet HELLO message (including peer ID) from a builder.
size_t	GNUNET_HELLO_get_builder_to_block_size (const struct GNUNET_HELLO_Builder *builder)
	Get projected block size for builder.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_builder_to_url (const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig, char **result)
	Generate GNUnet HELLO URI from a builder.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_builder_to_url2 (const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig, struct GNUNET_TIME_Absolute validity, char **result)
	Generate GNUnet HELLO URI from a builder.
enum GNUNET_GenericReturnValue	GNUNET_HELLO_builder_address_list_cmp (const struct GNUNET_HELLO_Builder *abuilder, const struct GNUNET_HELLO_Builder *bbuilder)
	Compare address lists of two builders.

Detailed Description

Helper library for handling HELLO URIs.

Macro Definition Documentation

GNUNET_HELLO_ADDRESS_EXPIRATION

#define GNUNET_HELLO_ADDRESS_EXPIRATION

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_DAYS, 2)

For how long are HELLO signatures valid?

Definition at line 63 of file gnunet_hello_uri_lib.h.

{
#endif
#ifdef __cplusplus
}
#endif
 
/* ifndef GNUNET_HELLO_URI_LIB_H */
#endif
 
 
 
/* end of gnunet_hello_uri_lib.h */

Typedef Documentation

GNUNET_HELLO_UriCallback

typedef void(* GNUNET_HELLO_UriCallback) (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)

Callback function used to extract URIs from a builder.

Parameters

cls	closure
uri	one of the URIs

Definition at line 252 of file gnunet_hello_uri_lib.h.

Function Documentation

GNUNET_HELLO_builder_new()

struct GNUNET_HELLO_Builder * GNUNET_HELLO_builder_new

(

)

Allocate builder.

Returns

new builder

Definition at line 344 of file hello-uri.c.

{
  struct GNUNET_HELLO_Builder *builder;
 
  builder = GNUNET_new (struct GNUNET_HELLO_Builder);
  return builder;
}

References builder, and GNUNET_new.

Referenced by do_generate_pid(), GNUNET_HELLO_builder_from_parser(), pils_pid_change_cb(), run(), and run().

Here is the caller graph for this function:

GNUNET_HELLO_builder_from_parser()

struct GNUNET_HELLO_Builder * GNUNET_HELLO_builder_from_parser	(	const struct GNUNET_HELLO_Parser *	parser,
		struct GNUNET_PeerIdentity *	pid
	)

Allocate builder from parser.

Parameters

parser	the parser
pid	the peer identity from the parsed hello

Returns

new builder

Definition at line 361 of file hello-uri.c.

{
  struct GNUNET_HELLO_Builder *builder;
  struct Address *a;
 
  builder = GNUNET_HELLO_builder_new ();
  if (NULL != pid)
    *pid = p->pid;
  /* check for duplicates */
  for (a = p->a_head;
       NULL != a;
       a = a->next)
    GNUNET_HELLO_builder_add_address (builder, a->uri);
  return builder;
}

References builder, GNUNET_HELLO_builder_add_address(), GNUNET_HELLO_builder_new(), Address::next, p, GNUNET_Process::pid, and Address::uri.

Referenced by do_generate_pid(), pid_changed_cb(), and pils_pid_change_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_get_id()

const struct GNUNET_PeerIdentity * GNUNET_HELLO_parser_get_id

(

const struct GNUNET_HELLO_Parser *

parser

)

Get the PeerIdentity for this builder.

Definition at line 354 of file hello-uri.c.

{
  return &parser->pid;
}

Referenced by callback_peer_id_changed(), check_hello(), GNUNET_PEERSTORE_hello_add(), handle_hello_for_client(), handle_peer_id(), hello_iter(), hosts_directory_scan_callback(), pid_change_cb(), pid_change_cb(), pid_change_cb(), and process_notify().

Here is the caller graph for this function:

GNUNET_HELLO_builder_free()

void GNUNET_HELLO_builder_free

(

struct GNUNET_HELLO_Builder *

builder

)

Release resources of a builder.

Parameters

[in]

builder

to free

Definition at line 398 of file hello-uri.c.

{
  struct Address *a;
 
  while (NULL != (a = builder->a_head))
  {
    GNUNET_CONTAINER_DLL_remove (builder->a_head,
                                 builder->a_tail,
                                 a);
    builder->a_length--;
    GNUNET_free (a);
  }
  GNUNET_assert (0 == builder->a_length);
  GNUNET_free (builder);
}

References builder, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, and GNUNET_free.

Referenced by do_generate_pid(), do_shutdown(), env_resign_cb(), GCH_shutdown(), pils_pid_change_cb(), and url_resign_cb().

Here is the caller graph for this function:

GNUNET_HELLO_parser_free()

void GNUNET_HELLO_parser_free

(

struct GNUNET_HELLO_Parser *

parser

)

Release resources of a builder.

Parameters

[in]

builder

to free

Definition at line 380 of file hello-uri.c.

{
  struct Address *a;
 
  while (NULL != (a = parser->a_head))
  {
    GNUNET_CONTAINER_DLL_remove (parser->a_head,
                                 parser->a_tail,
                                 a);
    parser->a_length--;
    GNUNET_free (a);
  }
  GNUNET_assert (0 == parser->a_length);
  GNUNET_free (parser);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, and GNUNET_free.

Referenced by block_plugin_dht_check_block(), block_plugin_dht_check_reply(), block_plugin_dht_get_key(), build_json_response(), check_for_burst_address(), check_for_global_natted(), consider_for_advertising(), GNUNET_HELLO_dht_msg_to_block(), GNUNET_HELLO_parser_from_block_(), GNUNET_HELLO_parser_from_url(), GNUNET_PEERSTORE_hello_add(), handle_dht_local_hello_get(), handle_dht_local_hello_offer(), handle_feed_addresses(), handle_hello(), handle_hello_for_client(), handle_hello_for_incoming(), handle_peer_id(), hello_check(), hello_iter(), hosts_directory_scan_callback(), peerinfo_cb(), process_notify(), and run().

Here is the caller graph for this function:

GNUNET_HELLO_parser_from_msg()

struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_msg	(	const struct GNUNET_MessageHeader *	msg,
		const struct GNUNET_PeerIdentity *	pid
	)

Parse msg.

Parameters

msg	message to parse
pid	peer identity

Returns

builder, NULL on failure

Definition at line 416 of file hello-uri.c.

{
  return GNUNET_HELLO_parser_from_msg_ (msg,
                                        pid,
                                        GNUNET_NO);
}

References GNUNET_HELLO_parser_from_msg_(), GNUNET_NO, msg, and GNUNET_HELLO_Parser::pid.

Referenced by check_for_burst_address(), check_for_global_natted(), check_hello(), consider_for_advertising(), GNUNET_PEERSTORE_hello_add(), handle_dht_local_hello_get(), handle_hello(), handle_hello_for_client(), handle_hello_for_incoming(), hello_iter(), peerinfo_cb(), and process_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_from_msg_()

struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_msg_	(	const struct GNUNET_MessageHeader *	msg,
		const struct GNUNET_PeerIdentity *	pid,
		int	noverify
	)

Parse msg.

Optionally do not verify the signature.

Only pass GNUNET_YES for noverify if the signature over this very HELLO was already checked, and the bytes have not left our hands since.

Parameters

msg	message to parse
pid	peer identity
noverify	not verifying signature if GNUNET_YES

Returns

parser, NULL on failure

Definition at line 426 of file hello-uri.c.

{
  uint16_t size;
 
  /* Callers routinely pass the value of a PEERSTORE record straight in,
     and a zero-length record has a NULL value.  Failing that the same way
     as any other unusable input beats dereferencing it. */
  if (NULL == msg)
  {
    GNUNET_break (0);
    return NULL;
  }
  size = ntohs (msg->size);
  switch (ntohs (msg->type))
  {
  case GNUNET_MESSAGE_TYPE_HELLO_URI:
    {
      const struct HelloUriMessage *h;
 
      if (sizeof (struct HelloUriMessage) > size)
      {
        GNUNET_break_op (0);
        return NULL;
      }
 
      h = (const struct HelloUriMessage *) msg;
      size -= sizeof (*h);
      return GNUNET_HELLO_parser_from_block_ (&h[1],
                                              size,
                                              noverify);
    }
  case GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO:
    {
      struct GNUNET_TIME_Absolute block_expiration;
      struct GNUNET_HELLO_Parser *p;
      size_t block_size;
      void *block;
 
      if (sizeof (struct DhtHelloMessage) > size)
      {
        GNUNET_break_op (0);
        return NULL;
      }
 
      if (GNUNET_SYSERR == GNUNET_HELLO_dht_msg_to_block (
            msg,
            pid,
            &block,
            &block_size,
            &block_expiration))
      {
        GNUNET_break_op (0);
        return NULL;
      }
 
      p = GNUNET_HELLO_parser_from_block_ (block,
                                           block_size,
                                           noverify);
      GNUNET_free (block);
      return p;
    }
  default:
    GNUNET_break_op (0);
    return NULL;
  }
}

References GNUNET_break, GNUNET_break_op, GNUNET_free, GNUNET_HELLO_dht_msg_to_block(), GNUNET_HELLO_parser_from_block_(), GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO, GNUNET_MESSAGE_TYPE_HELLO_URI, GNUNET_SYSERR, h, msg, p, GNUNET_HELLO_Parser::pid, GNUNET_MessageHeader::size, size, and GNUNET_MessageHeader::type.

Referenced by build_json_response(), and GNUNET_HELLO_parser_from_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_from_block()

struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_block	(	const void *	block,
		size_t	block_size
	)

Parse block.

Parameters

block	DHT block to parse
block_size	number of bytes in block

Returns

parser, NULL on failure

Definition at line 582 of file hello-uri.c.

{
  return GNUNET_HELLO_parser_from_block_ (block,
                                          block_size,
                                          GNUNET_NO);
}

References GNUNET_HELLO_parser_from_block_(), and GNUNET_NO.

Referenced by block_plugin_dht_check_block(), block_plugin_dht_check_reply(), block_plugin_dht_get_key(), GNUNET_HELLO_dht_msg_to_block(), handle_peer_id(), and hello_check().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_from_block_()

struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_block_	(	const void *	block,
		size_t	block_size,
		int	noverify
	)

Parse block.

Optionally Do not verify signature.

Parameters

block	DHT block to parse
block_size	number of bytes in block
noverify	not verifying signature if GNUNET_YES

Returns

parser, NULL on failure

Definition at line 592 of file hello-uri.c.

{
  const struct BlockHeader *bh = block;
  struct GNUNET_HELLO_Parser *p;
 
  if (block_size < sizeof (*bh))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  p = parser_new (&bh->pid);
  block += sizeof (*bh);
  block_size -= sizeof (*bh);
  while (block_size > 0)
  {
    const void *end = memchr (block,
                              '\0',
                              block_size);
 
    if (NULL == end)
    {
      GNUNET_break_op (0);
      GNUNET_HELLO_parser_free (p);
      return NULL;
    }
    if (GNUNET_OK !=
        parser_add_address (p,
                            block))
    {
      GNUNET_break_op (0);
      GNUNET_HELLO_parser_free (p);
      return NULL;
    }
    end++;
    block_size -= (end - block);
    block = end;
  }
  {
    struct GNUNET_TIME_Absolute et;
    et = GNUNET_TIME_absolute_ntoh (bh->expiration_time);
    if (GNUNET_YES != noverify)
    {
      enum GNUNET_GenericReturnValue ret;
      ret = verify_hello (p,
                          et,
                          &bh->sig);
      GNUNET_break_op (GNUNET_SYSERR != ret);
      if (GNUNET_OK != ret)
      {
        GNUNET_HELLO_parser_free (p);
        return NULL;
      }
    }
    p->et = et;
    p->sig = bh->sig;
  }
  return p;
}

References end, BlockHeader::expiration_time, GNUNET_break_op, GNUNET_HELLO_parser_free(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_ntoh(), GNUNET_YES, p, parser_add_address(), parser_new(), BlockHeader::pid, ret, BlockHeader::sig, and verify_hello().

Referenced by GNUNET_HELLO_parser_from_block(), GNUNET_HELLO_parser_from_msg_(), and handle_feed_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_from_url()

struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_url

(

const char *

url

)

Parse GNUnet HELLO url.

Parameters

url	URL to parse

Returns

builder, NULL on failure

Definition at line 740 of file hello-uri.c.

{
  const char *q;
  const char *s1;
  const char *s2;
  struct GNUNET_PeerIdentity pid;
  struct GNUNET_TIME_Absolute et;
  size_t len;
  struct GNUNET_HELLO_Parser *p;
  struct GNUNET_CRYPTO_EddsaSignature sig;
 
  if (0 != strncasecmp (url,
                        "gnunet://hello/",
                        strlen ("gnunet://hello/")))
    return NULL;
  url += strlen ("gnunet://hello/");
  s1 = strchr (url, '/');
  if (NULL == s1)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  s2 = strchr (s1 + 1, '/');
  if (NULL == s2)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  q = strchr (url, '?');
  if (NULL == q)
    q = url + strlen (url);
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (url,
                                     s1 - url,
                                     &pid,
                                     sizeof(pid)))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (s1 + 1,
                                     s2 - (s1 + 1),
                                     &sig,
                                     sizeof(sig)))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  {
    uint64_t sec;
    char dummy = '?';
 
    if ( (0 == sscanf (s2 + 1,
                       "%" PRIu64 "%c",
                       &sec,
                       &dummy)) ||
         ('?' != dummy) )
    {
      GNUNET_break_op (0);
      return NULL;
    }
    et.abs_value_us = sec;
  }
 
  p = parser_new (&pid);
  p->et = et;
  p->sig = sig;
  len = strlen (q);
  while (len > 0)
  {
    const char *eq;
    const char *amp;
    char *addr = NULL;
    char *uri;
 
    /* skip ?/& separator */
    len--;
    q++;
    eq = strchr (q, '=');
    if ( (eq == q) ||
         (NULL == eq) )
    {
      GNUNET_break_op (0);
      GNUNET_HELLO_parser_free (p);
      return NULL;
    }
    amp = strchr (eq, '&');
    if (NULL == amp)
      amp = &q[len];
    GNUNET_STRINGS_urldecode (eq + 1,
                              amp - (eq + 1),
                              &addr);
    if ( (NULL == addr) ||
         (0 == strlen (addr)) )
    {
      GNUNET_free (addr);
      GNUNET_break_op (0);
      GNUNET_HELLO_parser_free (p);
      return NULL;
    }
    GNUNET_asprintf (&uri,
                     "%.*s://%s",
                     (int) (eq - q),
                     q,
                     addr);
    GNUNET_free (addr);
    if (GNUNET_OK !=
        parser_add_address (p,
                            uri))
    {
      GNUNET_break_op (0);
      GNUNET_free (uri);
      GNUNET_HELLO_parser_free (p);
      return NULL;
    }
    GNUNET_free (uri);
    /* move to next URL */
    len -= (amp - q);
    q = amp;
  }
 
  {
    enum GNUNET_GenericReturnValue ret;
 
    ret = verify_hello (p,
                        et,
                        &p->sig);
    GNUNET_break_op (GNUNET_SYSERR != ret);
    if (GNUNET_OK != ret)
    {
      GNUNET_HELLO_parser_free (p);
      return NULL;
    }
  }
  return p;
}

References GNUNET_TIME_Absolute::abs_value_us, dummy, GNUNET_asprintf(), GNUNET_break_op, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_STRINGS_urldecode(), GNUNET_SYSERR, p, parser_add_address(), parser_new(), q, ret, uri, and verify_hello().

Referenced by handle_dht_local_hello_offer(), hosts_directory_scan_callback(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_get_expiration_time_from_msg()

struct GNUNET_TIME_Absolute GNUNET_HELLO_get_expiration_time_from_msg

(

const struct GNUNET_MessageHeader *

msg

)

Get the expiration time for this HELLO.

Parameters

msg	The hello msg.

Returns

The expiration time.

Definition at line 655 of file hello-uri.c.

{
  struct GNUNET_TIME_Absolute et;
  if (GNUNET_MESSAGE_TYPE_HELLO_URI == ntohs (msg->type))
  {
    const struct HelloUriMessage *h = (const struct HelloUriMessage *) msg;
    const struct BlockHeader *bh = (const struct BlockHeader *) &h[1];
    if (ntohs (msg->size) <
        sizeof (struct HelloUriMessage) + sizeof (struct BlockHeader))
    {
      GNUNET_break_op (0);
      return GNUNET_TIME_UNIT_ZERO_ABS;
    }
    if (ntohs (msg->size) ==
        sizeof (struct HelloUriMessage) + sizeof (struct BlockHeader))
    {
      /* Well-formed, but carries no address: nothing worth keeping.  This is
         what our own HELLO looks like before a communicator has reported an
         address, so it is not a protocol violation. */
      return GNUNET_TIME_UNIT_ZERO_ABS;
    }
 
    et = GNUNET_TIME_absolute_ntoh (bh->expiration_time);
    return et;
  }
  else if (GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO == ntohs (msg->type))
  {
    const struct DhtHelloMessage *dht_hello
      = (const struct DhtHelloMessage *) msg;
    if (ntohs (msg->size) < sizeof (struct DhtHelloMessage))
    {
      GNUNET_break_op (0);
      return GNUNET_TIME_UNIT_ZERO_ABS;
    }
 
    et = GNUNET_TIME_absolute_ntoh (dht_hello->expiration_time);
    return et;
  }
  else
    GNUNET_break_op (0);
  return GNUNET_TIME_UNIT_ZERO_ABS;
}

References BlockHeader::expiration_time, DhtHelloMessage::expiration_time, GNUNET_break_op, GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO, GNUNET_MESSAGE_TYPE_HELLO_URI, GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_UNIT_ZERO_ABS, h, msg, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by announce_id(), consider_for_advertising(), consider_peer_destroy(), GCP_set_hello(), GNUNET_PEERSTORE_hello_add(), got_hello(), hello_add_iter(), hello_iter(), and hosts_directory_scan_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_to_env()

struct GNUNET_MQ_Envelope * GNUNET_HELLO_parser_to_env

(

const struct GNUNET_HELLO_Parser *

parser

)

Generate envelope with GNUnet HELLO message (including peer ID) from a parser.

Parameters

builder

builder to serialize

Returns

HELLO message matching parser

Definition at line 980 of file hello-uri.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct HelloUriMessage *msg;
  size_t blen;
 
  if (parser->a_length > UINT16_MAX)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  blen = 0;
  GNUNET_assert (GNUNET_NO ==
                 GNUNET_HELLO_parser_to_block (parser,
                                               NULL,
                                               &blen));
  env = GNUNET_MQ_msg_extra (msg,
                             blen,
                             GNUNET_MESSAGE_TYPE_HELLO_URI);
  msg->url_counter = htons ((uint16_t) parser->a_length);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_HELLO_parser_to_block (parser,
                                               &msg[1],
                                               &blen));
  return env;
}

References env, GNUNET_assert, GNUNET_break_op, GNUNET_HELLO_parser_to_block(), GNUNET_MESSAGE_TYPE_HELLO_URI, GNUNET_MQ_msg_extra, GNUNET_NO, GNUNET_OK, and msg.

Referenced by hosts_directory_scan_callback(), output_parser(), pils_pid_change_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_to_url()

char * GNUNET_HELLO_parser_to_url

(

const struct GNUNET_HELLO_Parser *

parser

)

Generate GNUnet HELLO URI from a parser.

Parameters

parser

HELLO parser to serialize

Returns

hello URI

Definition at line 880 of file hello-uri.c.

{
  char *result;
  char *pids;
  char *sigs;
  const char *sep = "?";
 
  pids = GNUNET_STRINGS_data_to_string_alloc (&parser->pid,
                                              sizeof (parser->pid));
  sigs = GNUNET_STRINGS_data_to_string_alloc (&parser->sig,
                                              sizeof (parser->sig));
  GNUNET_asprintf (&result,
                   "gnunet://hello/%s/%s/%" PRIu64,
                   pids,
                   sigs,
                   parser->et.abs_value_us);
  GNUNET_free (sigs);
  GNUNET_free (pids);
  for (struct Address *a = parser->a_head;
       NULL != a;
       a = a->next)
  {
    char *eou_url_encoded;
    char *tmp;
    int pfx_len;
    const char *eou;
 
    eou = strstr (a->uri,
                  "://");
    if (NULL == eou)
    {
      GNUNET_break_op (0);
      GNUNET_free (result);
      return NULL;
    }
    pfx_len = eou - a->uri;
    eou += 3;
    GNUNET_STRINGS_urlencode (a->uri_len - 4 - pfx_len,
                              eou,
                              &eou_url_encoded);
    GNUNET_asprintf (&tmp,
                     "%s%s%.*s=%s",
                     result,
                     sep,
                     pfx_len,
                     a->uri,
                     eou_url_encoded);
    GNUNET_free (eou_url_encoded);
    GNUNET_free (result);
    result = tmp;
    sep = "&";
  }
  return result;
}

References GNUNET_asprintf(), GNUNET_break_op, GNUNET_free, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_STRINGS_urlencode(), and result.

Referenced by build_json_response(), handle_dht_local_hello_get(), and output_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parser_to_block()

enum GNUNET_GenericReturnValue GNUNET_HELLO_parser_to_block	(	const struct GNUNET_HELLO_Parser *	parser,
		void *	block,
		size_t *	block_size
	)

Generate DHT block from a parser.

Parameters

	builder	the builder to serialize
[out]	block	where to write the block, NULL to only calculate block_size
[in,out]	block_size	input is number of bytes available in block, output is number of bytes needed in block

Returns

GNUNET_OK on success, GNUNET_NO if block_size was too small or if block was NULL

Definition at line 937 of file hello-uri.c.

{
  struct BlockHeader bh;
  size_t needed = sizeof (bh);
  char *pos;
 
  for (struct Address *a = parser->a_head;
       NULL != a;
       a = a->next)
  {
    GNUNET_assert (needed + a->uri_len > needed);
    needed += a->uri_len;
  }
  if ( (NULL == block) ||
       (needed > *block_size) )
  {
    *block_size = needed;
    return GNUNET_NO;
  }
  bh.pid = parser->pid;
  bh.sig = parser->sig;
  bh.expiration_time = GNUNET_TIME_absolute_hton (parser->et);
  memcpy (block,
          &bh,
          sizeof (bh));
  pos = block + sizeof (bh);
  for (struct Address *a = parser->a_head;
       NULL != a;
       a = a->next)
  {
    memcpy (pos,
            a->uri,
            a->uri_len);
    pos += a->uri_len;
  }
  *block_size = needed;
  return GNUNET_OK;
}

References BlockHeader::expiration_time, GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_hton(), BlockHeader::pid, and BlockHeader::sig.

Referenced by GNUNET_HELLO_parser_to_dht_hello_msg(), and GNUNET_HELLO_parser_to_env().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_add_address()

enum GNUNET_GenericReturnValue GNUNET_HELLO_builder_add_address	(	struct GNUNET_HELLO_Builder *	builder,
		const char *	address
	)

Add individual address to the builder.

Parameters

[in,out]	builder	to update
	address	address URI to add

Returns

GNUNET_OK on success, GNUNET_NO if address was already in builder

Definition at line 701 of file hello-uri.c.

{
  struct Address *a;
  enum GNUNET_GenericReturnValue ret;
  size_t alen = strlen (address) + 1;
 
  ret = check_address (address);
  if (GNUNET_OK != ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Failed to add address to builder\n");
    return ret;
  }
  /* check for duplicates */
  for (a = builder->a_head;
       NULL != a;
       a = a->next)
    if (0 == strcmp (address,
                     a->uri))
      return GNUNET_NO;
  a = GNUNET_malloc (sizeof (struct Address) + alen);
  a->uri_len = alen;
  memcpy (&a[1],
          address,
          alen);
  a->uri = (const char *) &a[1];
  GNUNET_CONTAINER_DLL_insert_sorted (struct Address,
                                      cmp_address,
                                      NULL,
                                      builder->a_head,
                                      builder->a_tail,
                                      a);
  builder->a_length++;
  return GNUNET_OK;
}

References address, builder, check_address(), cmp_address(), GNUNET_CONTAINER_DLL_insert_sorted, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_NO, GNUNET_OK, Address::next, ret, Address::uri, and Address::uri_len.

Referenced by GNUNET_HELLO_builder_from_parser(), handle_add_address(), run(), and store_pi().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_del_address()

enum GNUNET_GenericReturnValue GNUNET_HELLO_builder_del_address	(	struct GNUNET_HELLO_Builder *	builder,
		const char *	address
	)

Remove individual address from the builder.

Parameters

[in,out]	builder	to update
	address	address URI to remove

Returns

GNUNET_OK on success, GNUNET_NO if address was not in builder

Definition at line 1009 of file hello-uri.c.

{
  struct Address *a;
 
  /* check for duplicates */
  for (a = builder->a_head;
       NULL != a;
       a = a->next)
    if (0 == strcmp (address,
                     a->uri))
      break;
  if (NULL == a)
    return GNUNET_NO;
  GNUNET_CONTAINER_DLL_remove (builder->a_head,
                               builder->a_tail,
                               a);
  builder->a_length--;
  GNUNET_free (a);
  return GNUNET_OK;
}

References address, builder, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_OK, Address::next, and Address::uri.

Referenced by handle_del_address().

Here is the caller graph for this function:

GNUNET_HELLO_builder_iterate()

void GNUNET_HELLO_builder_iterate	(	const struct GNUNET_HELLO_Builder *	builder,
		GNUNET_HELLO_UriCallback	uc,
		void *	uc_cls
	)

Iterate over URIs in a builder.

Parameters

builder	builder to iterate over
uc	callback invoked for each URI, can be NULL
uc_cls	closure for addrgen

Returns

pid of the peer the builder is for, can be NULL

Definition at line 1033 of file hello-uri.c.

{
  struct Address *nxt;
 
  for (struct Address *a = builder->a_head;
       NULL != a;
       a = nxt)
  {
    nxt = a->next;
    uc (uc_cls,
        NULL,
        a->uri);
  }
}

References builder, Address::next, and uc.

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

Here is the caller graph for this function:

GNUNET_HELLO_parser_iterate()

const struct GNUNET_PeerIdentity * GNUNET_HELLO_parser_iterate	(	const struct GNUNET_HELLO_Parser *	parser,
		GNUNET_HELLO_UriCallback	uc,
		void *	uc_cls
	)

Iterate over URIs in a parser.

Parameters

builder	builder to iterate over
uc	callback invoked for each URI, can be NULL
uc_cls	closure for addrgen

Returns

pid of the peer the builder is for, can be NULL

Definition at line 1052 of file hello-uri.c.

{
  struct Address *nxt;
 
  if (NULL == uc)
    return &parser->pid;
  for (struct Address *a = parser->a_head;
       NULL != a;
       a = nxt)
  {
    nxt = a->next;
    uc (uc_cls,
        &parser->pid,
        a->uri);
  }
  return &parser->pid;
}

References Address::next, and uc.

Referenced by block_plugin_dht_check_block(), block_plugin_dht_check_reply(), block_plugin_dht_get_key(), check_for_burst_address(), check_for_global_natted(), consider_for_advertising(), handle_dht_local_hello_offer(), handle_hello_for_client(), handle_hello_for_incoming(), hello_check(), hello_iter(), and peerinfo_cb().

Here is the caller graph for this function:

GNUNET_HELLO_dht_msg_to_block()

enum GNUNET_GenericReturnValue GNUNET_HELLO_dht_msg_to_block	(	const struct GNUNET_MessageHeader *	hello,
		const struct GNUNET_PeerIdentity *	pid,
		void **	block,
		size_t *	block_size,
		struct GNUNET_TIME_Absolute *	block_expiration
	)

Convert a DHT hello message to a HELLO block.

Parameters

	hello	the HELLO message
	pid	peer that created the hello
[out]	block	set to the HELLO block
[out]	block_size	set to number of bytes in block
[out]	block_expiration	set to expiration time of block

Returns

GNUNET_OK on success, GNUNET_NO if the hello is expired (block is set!) GNUNET_SYSERR if hello is invalid (block will be set to NULL)

Definition at line 1074 of file hello-uri.c.

{
  const struct DhtHelloMessage *msg
    = (const struct DhtHelloMessage *) hello;
  uint16_t len = ntohs (hello->size);
  struct BlockHeader *bh;
  struct GNUNET_HELLO_Parser *b;
  enum GNUNET_GenericReturnValue ret;
 
  if (GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO != ntohs (hello->type))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (len < sizeof (*msg))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  len -= sizeof (*msg);
  *block_size = len + sizeof (*bh);
  *block = GNUNET_malloc (*block_size);
  bh = *block;
  bh->pid = *pid;
  bh->sig = msg->sig;
  bh->expiration_time = msg->expiration_time;
  *block_expiration = GNUNET_TIME_absolute_ntoh (msg->expiration_time);
  memcpy (&bh[1],
          &msg[1],
          len);
  b = GNUNET_HELLO_parser_from_block (*block,
                                      *block_size);
  if (NULL == b)
  {
    GNUNET_break_op (0);
    GNUNET_free (*block);
    *block_size = 0;
    return GNUNET_SYSERR;
  }
  ret = verify_hello (b,
                      *block_expiration,
                      &msg->sig);
  GNUNET_HELLO_parser_free (b);
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_free (*block);
    *block_size = 0;
    return GNUNET_SYSERR;
  }
  return ret;
}

References BlockHeader::expiration_time, GNUNET_break_op, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_block(), GNUNET_malloc, GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO, GNUNET_SYSERR, GNUNET_TIME_absolute_ntoh(), msg, BlockHeader::pid, GNUNET_HELLO_Parser::pid, ret, BlockHeader::sig, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and verify_hello().

Referenced by announce_id(), check_dht_p2p_hello(), GNUNET_HELLO_parser_from_msg_(), handle_dht_p2p_hello(), and handle_find_my_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_address_to_prefix()

char * GNUNET_HELLO_address_to_prefix

(

const char *

address

)

Given an address as a string, extract the prefix that identifies the communicator offering transmissions to that address.

Parameters

address

a peer's address

Returns

NULL if the address is mal-formed, otherwise the prefix

Definition at line 1139 of file hello-uri.c.

{
  const char *dash;
 
  dash = strchr (address, '-');
  if (NULL == dash)
    return NULL;
  return GNUNET_strndup (address, dash - address);
}

References address, and GNUNET_strndup.

Referenced by check_validation_request_pending(), find_queue_by_ip(), GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue(), handle_add_address(), store_pi(), and suggest_to_connect().

Here is the caller graph for this function:

GNUNET_HELLO_build_url()

enum GNUNET_GenericReturnValue GNUNET_HELLO_build_url	(	const struct GNUNET_HELLO_Builder *	builder,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig,
		struct GNUNET_TIME_Absolute	expiration,
		char **	result
	)

Parameters

builder	builder to serialize
pid	peer identity
sig	signature of the hello
expiration_time	expiration time

Definition at line 1151 of file hello-uri.c.

{
  char *pids;
  char *sigs;
  const char *sep = "?";
 
  pids = GNUNET_STRINGS_data_to_string_alloc (pid,
                                              sizeof (*pid));
  sigs = GNUNET_STRINGS_data_to_string_alloc (sig,
                                              sizeof (*sig));
  GNUNET_asprintf (result,
                   "gnunet://hello/%s/%s/%" PRIu64,
                   pids,
                   sigs,
                   expiration.abs_value_us);
  GNUNET_free (sigs);
  GNUNET_free (pids);
  for (struct Address *a = builder->a_head;
       NULL != a;
       a = a->next)
  {
    char *eou_url_encoded;
    char *tmp;
    int pfx_len;
    const char *eou;
 
    eou = strstr (a->uri,
                  "://");
    if (NULL == eou)
    {
      GNUNET_break_op (0);
      GNUNET_free (*result);
      return GNUNET_SYSERR;
    }
    pfx_len = eou - a->uri;
    eou += 3;
    GNUNET_STRINGS_urlencode (a->uri_len - 4 - pfx_len,
                              eou,
                              &eou_url_encoded);
    GNUNET_asprintf (&tmp,
                     "%s%s%.*s=%s",
                     *result,
                     sep,
                     pfx_len,
                     a->uri,
                     eou_url_encoded);
    GNUNET_free (eou_url_encoded);
    GNUNET_free (*result);
    *result = tmp;
    sep = "&";
  }
  return GNUNET_OK;
}

References builder, expiration, GNUNET_asprintf(), GNUNET_break_op, GNUNET_free, GNUNET_OK, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_STRINGS_urlencode(), GNUNET_SYSERR, GNUNET_HELLO_Parser::pid, result, and GNUNET_HELLO_Parser::sig.

Referenced by GNUNET_HELLO_builder_to_url2().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_to_dht_hello_msg()

struct GNUNET_MessageHeader * GNUNET_HELLO_builder_to_dht_hello_msg	(	const struct GNUNET_HELLO_Builder *	builder,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig,
		struct GNUNET_TIME_Absolute	expiration_time
	)

Generate DHT HELLO message (without peer ID) from a builder.

Parameters

builder	builder to serialize
pid	peer identity
sig	signature of the hello
expiration_time	expiration time

Returns

handle to the message

Definition at line 1287 of file hello-uri.c.

{
  struct BlockHeader *block;
  struct DhtHelloMessage *msg;
  size_t block_size;
 
 
  block_size = GNUNET_HELLO_get_builder_to_block_size (builder);
  msg = GNUNET_malloc (sizeof (*msg)
                       + block_size);
  block = (struct BlockHeader*) &msg[1];
  GNUNET_HELLO_builder_to_block (builder,
                                 pid,
                                 hello_sig,
                                 expiration_time,
                                 (char*) &msg[1]);
  msg->sig = block->sig;
  msg->expiration_time = block->expiration_time;
  memmove (&msg[1],
           (char*) block + sizeof (*block),
           block_size - sizeof (*block));
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO);
  msg->header.size = htons (sizeof (*msg)
                            + block_size
                            - sizeof (*block));
  msg->url_counter = htons ((uint16_t) builder->a_length);
  return &msg->header;
}

References builder, BlockHeader::expiration_time, GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_malloc, GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO, msg, BlockHeader::pid, BlockHeader::sig, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

GNUNET_HELLO_parser_to_dht_hello_msg()

struct GNUNET_MessageHeader * GNUNET_HELLO_parser_to_dht_hello_msg

(

const struct GNUNET_HELLO_Parser *

parser

)

Generate DHT HELLO message from a parser.

Parameters

parser

builder to serialize

Returns

handle to the message

Definition at line 1249 of file hello-uri.c.

{
  struct BlockHeader *block;
  struct DhtHelloMessage *msg;
  size_t block_size;
 
 
  block_size = 0;
  GNUNET_assert (GNUNET_NO ==
                 GNUNET_HELLO_parser_to_block (parser,
                                               NULL,
                                               &block_size));
  msg = GNUNET_malloc (sizeof (*msg)
                       + block_size);
  if (GNUNET_OK !=
      GNUNET_HELLO_parser_to_block (parser,
                                    &msg[1],
                                    &block_size))
  {
    GNUNET_free (msg);
    return NULL;
  }
  block = (struct BlockHeader*) &msg[1];
  msg->sig = block->sig;
  msg->expiration_time = block->expiration_time;
  memmove (&msg[1],
           (char*) block + sizeof (*block),
           block_size - sizeof (*block));
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO);
  msg->header.size = htons (sizeof (*msg)
                            + block_size
                            - sizeof (*block));
  msg->url_counter = htons ((uint16_t) parser->a_length);
  return &msg->header;
}

References BlockHeader::expiration_time, GNUNET_assert, GNUNET_free, GNUNET_HELLO_parser_to_block(), GNUNET_malloc, GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO, GNUNET_NO, GNUNET_OK, msg, BlockHeader::sig, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by pid_change_cb(), and sign_hello_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_to_block()

void GNUNET_HELLO_builder_to_block	(	const struct GNUNET_HELLO_Builder *	builder,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig,
		struct GNUNET_TIME_Absolute	expiration_time,
		char *	outbuf
	)

Generate DHT block from a builder.

Parameters

builder	builder to serialize
pid	peer identity
sig	signature of the hello
expiration_time	expiration time
outbuf	the buffer to the block

Definition at line 1322 of file hello-uri.c.

{
  struct BlockHeader bh = { 0 };
  char *pos;
  struct GNUNET_TIME_Absolute et;
 
  if (NULL != pid)
    bh.pid = *pid;
  if (NULL != sig)
    bh.sig = *sig;
  if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us == expiration_time.abs_value_us)
    et = GNUNET_TIME_relative_to_absolute (GNUNET_HELLO_ADDRESS_EXPIRATION);
  else
    et = expiration_time;
  bh.expiration_time = GNUNET_TIME_absolute_hton (et);
  memcpy (block,
          &bh,
          sizeof (bh));
  pos = block + sizeof (bh);
  for (struct Address *a = builder->a_head; NULL != a; a = a->next)
  {
    memcpy (pos,
            a->uri,
            a->uri_len);
    pos += a->uri_len;
  }
}

References GNUNET_TIME_Absolute::abs_value_us, builder, BlockHeader::expiration_time, GNUNET_HELLO_ADDRESS_EXPIRATION, GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_ZERO_ABS, BlockHeader::pid, and BlockHeader::sig.

Referenced by do_generate_pid(), GNUNET_HELLO_builder_to_dht_hello_msg(), GNUNET_HELLO_builder_to_env(), and GNUNET_PILS_feed_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_hash_addresses()

void GNUNET_HELLO_builder_hash_addresses	(	const struct GNUNET_HELLO_Builder *	builder,
		struct GNUNET_HashCode *	hash
	)

Compute hash over addresses in builder.

Note: Duplicate of hash_addresses in src/lib/hello/hello-uri.c

Parameters

	builder	the builder to hash addresses of
[out]	hash	where to write the hash

Definition at line 1211 of file hello-uri.c.

{
  hash_addresses (builder->a_head, hash);
}

References builder, and hash_addresses().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_to_env()

struct GNUNET_MQ_Envelope * GNUNET_HELLO_builder_to_env	(	const struct GNUNET_HELLO_Builder *	builder,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig,
		struct GNUNET_TIME_Absolute	expiration_time
	)

Generate envelope with GNUnet HELLO message (including peer ID) from a builder.

Parameters

builder	builder to serialize
pid	peer identity
sig	signature of the hello
expiration_time	expiration time

Returns

HELLO message matching builder

Definition at line 1219 of file hello-uri.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct HelloUriMessage *msg;
  size_t blen;
 
  if (builder->a_length > UINT16_MAX)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  blen = GNUNET_HELLO_get_builder_to_block_size (builder);
  env = GNUNET_MQ_msg_extra (msg,
                             blen,
                             GNUNET_MESSAGE_TYPE_HELLO_URI);
  msg->url_counter = htons ((uint16_t) builder->a_length);
  GNUNET_HELLO_builder_to_block (builder,
                                 pid,
                                 hello_sig,
                                 expiration_time,
                                 (char*) &msg[1]);
  return env;
}

References builder, env, GNUNET_break_op, GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_MESSAGE_TYPE_HELLO_URI, GNUNET_MQ_msg_extra, and msg.

Referenced by env_resign_cb(), and pils_sign_hello_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_get_builder_to_block_size()

size_t GNUNET_HELLO_get_builder_to_block_size

(

const struct GNUNET_HELLO_Builder *

builder

)

Get projected block size for builder.

Parameters

builder

builder to serialize

Returns

block size

Definition at line 1390 of file hello-uri.c.

{
  struct BlockHeader bh;
  size_t needed = sizeof (bh);
 
  for (struct Address *a = builder->a_head;
       NULL != a;
       a = a->next)
  {
    GNUNET_assert (needed + a->uri_len > needed);
    needed += a->uri_len;
  }
  return needed;
}

References builder, and GNUNET_assert.

Referenced by do_generate_pid(), GNUNET_HELLO_builder_to_dht_hello_msg(), GNUNET_HELLO_builder_to_env(), and GNUNET_PILS_feed_addresses().

Here is the caller graph for this function:

GNUNET_HELLO_builder_to_url()

enum GNUNET_GenericReturnValue GNUNET_HELLO_builder_to_url	(	const struct GNUNET_HELLO_Builder *	builder,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig,
		char **	result
	)

Generate GNUnet HELLO URI from a builder.

Parameters

builder	builder to serialize
pid	peer identity
sig	signature of the hello

Returns

GNUNET_SYSERR on error

Definition at line 1372 of file hello-uri.c.

{
  struct GNUNET_TIME_Absolute et;
 
  et = GNUNET_TIME_relative_to_absolute (GNUNET_HELLO_ADDRESS_EXPIRATION);
 
  return GNUNET_HELLO_builder_to_url2 (builder,
                                       pid,
                                       sig,
                                       et,
                                       result);
}

References builder, GNUNET_HELLO_ADDRESS_EXPIRATION, GNUNET_HELLO_builder_to_url2(), GNUNET_TIME_relative_to_absolute(), and result.

Here is the call graph for this function:

GNUNET_HELLO_builder_to_url2()

enum GNUNET_GenericReturnValue GNUNET_HELLO_builder_to_url2	(	const struct GNUNET_HELLO_Builder *	builder,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig,
		struct GNUNET_TIME_Absolute	validity,
		char **	result
	)

Generate GNUnet HELLO URI from a builder.

Parameters

builder	builder to serialize
pid	peer identity
sig	signature of the hello
validity	relative validity target of hello

Returns

GNUNET_SYSERR on error

Definition at line 1357 of file hello-uri.c.

{
  return GNUNET_HELLO_build_url (builder,
                                 pid,
                                 sig,
                                 validity,
                                 result);
}

References builder, GNUNET_HELLO_build_url(), and result.

Referenced by GNUNET_HELLO_builder_to_url(), and url_resign_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_builder_address_list_cmp()

enum GNUNET_GenericReturnValue GNUNET_HELLO_builder_address_list_cmp	(	const struct GNUNET_HELLO_Builder *	abuilder,
		const struct GNUNET_HELLO_Builder *	bbuilder
	)

Compare address lists of two builders.

Assumes that address lists are already sorted. Will also return GNUNET_YES if address lists are usorted, but values match!

Parameters

abuilder	the first builder
bbuilder	the second builder

Returns

GNUNET_YES if address lists are the same

Definition at line 1408 of file hello-uri.c.

{
  bool found = false;
  for (struct Address *a = abuilder->a_head; NULL != a; a = a->next)
  {
    for (struct Address *b = bbuilder->a_head; NULL != b; b = b->next)
    {
      if (0 != strcmp (b->uri, a->uri))
        continue;
      found = true;
      break;
    }
    if (! found)
      return GNUNET_NO;
    found = false;
  }
  return GNUNET_YES;
}

References GNUNET_HELLO_Builder::a_head, GNUNET_NO, and GNUNET_YES.

Referenced by pils_pid_change_cb().

Here is the caller graph for this function: