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_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 235 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, 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(), and pid_change_cb().

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

{
  uint16_t 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);
    }
  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);
      GNUNET_free (block);
      return p;
    }
  default:
    GNUNET_break (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, pid, GNUNET_MessageHeader::size, size, and GNUNET_MessageHeader::type.

Referenced by build_json_response(), 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(), and peerinfo_cb().

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 560 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(), GNUNET_HELLO_parser_from_msg(), 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 570 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(), 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 710 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 (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, 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(), pid, 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 633 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 (0);
      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 (0);
      return GNUNET_TIME_UNIT_ZERO_ABS;
    }
 
    et = GNUNET_TIME_absolute_ntoh (dht_hello->expiration_time);
    return et;
  }
  else
    GNUNET_break (0);
  return GNUNET_TIME_UNIT_ZERO_ABS;
}

References BlockHeader::expiration_time, DhtHelloMessage::expiration_time, GNUNET_break, 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 950 of file hello-uri.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct HelloUriMessage *msg;
  size_t blen;
 
  if (parser->a_length > UINT16_MAX)
  {
    GNUNET_break (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, 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 850 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 (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, 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 907 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 671 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 979 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 1003 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 1022 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 1044 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 (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, 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, 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 1109 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 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 1121 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 (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, GNUNET_free, GNUNET_OK, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_STRINGS_urlencode(), GNUNET_SYSERR, 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 1257 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, 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 1219 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 1292 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, 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 1181 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 1189 of file hello-uri.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct HelloUriMessage *msg;
  size_t blen;
 
  if (builder->a_length > UINT16_MAX)
  {
    GNUNET_break (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, GNUNET_HELLO_builder_to_block(), GNUNET_HELLO_get_builder_to_block_size(), GNUNET_MESSAGE_TYPE_HELLO_URI, GNUNET_MQ_msg_extra, msg, and pid.

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 1360 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 1342 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(), pid, 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 1327 of file hello-uri.c.

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

References builder, GNUNET_HELLO_build_url(), pid, 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 1378 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: