helper library for handling HELLOs More...

#include "platform.h"
#include "gnunet_hello_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_util_lib.h"
#include "gnunet_transport_plugin.h"

Include dependency graph for hello.c:

Data Structures
struct	GNUNET_HELLO_ComposeUriContext
	Context used for building our own URI. More...

struct	GNUNET_HELLO_ParseUriContext
	Context for add_address_to_hello(). More...

struct	ExpireContext
	Closure for get_match_exp(). More...

struct	MergeContext
	Closure for merge_pr(). More...

struct	DeltaContext
	Context used in GNUNET_HELLO_iterate_new_addresses() to figure out which addresses are in fact 'new'. More...

struct	EqualsContext
	Context used for comparing HELLOs in GNUNET_HELLO_equals(). More...

Functions
int	GNUNET_HELLO_is_friend_only (const struct GNUNET_HELLO_Message *h)
	Return HELLO type. More...

size_t	GNUNET_HELLO_add_address (const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration, char target, size_t max)
	Copy the given address information into the given buffer using the format of HELLOs. More...

static size_t	get_hello_address_size (const char buf, size_t max, uint16_t ralen)
	Get the size of an address entry in a HELLO message. More...

struct GNUNET_HELLO_Message *	GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EddsaPublicKey public_key, GNUNET_HELLO_GenerateAddressListCallback addrgen, void addrgen_cls, int friend_only)
	Construct a HELLO message given the public key, expiration time and an iterator that spews the transport addresses. More...

struct GNUNET_HELLO_Message *	GNUNET_HELLO_iterate_addresses (const struct GNUNET_HELLO_Message msg, int return_modified, GNUNET_HELLO_AddressIterator it, void it_cls)
	Iterate over all of the addresses in the HELLO. More...

static int	get_match_exp (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Store the expiration time of an address that matches the template. More...

static int	copy_latest (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Append the address address to the buffer from the merge context IF it is more recent than equivalent addresses in `other`. More...

static ssize_t	merge_addr (void cls, size_t max, void buf)
	Function called to build the HELLO during GNUNET_HELLO_merge() by merging addresses from two original HELLOs. More...

struct GNUNET_HELLO_Message *	GNUNET_HELLO_merge (const struct GNUNET_HELLO_Message h1, const struct GNUNET_HELLO_Message h2)
	Construct a HELLO message by merging the addresses in two existing HELLOs (which must be for the same peer). More...

static int	delta_match (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Check if the given address is 'new', and if so, call the iterator. More...

void	GNUNET_HELLO_iterate_new_addresses (const struct GNUNET_HELLO_Message new_hello, const struct GNUNET_HELLO_Message old_hello, struct GNUNET_TIME_Absolute expiration_limit, GNUNET_HELLO_AddressIterator it, void *it_cls)
	Iterate over addresses in new_hello that are NOT already present in old_hello. More...

uint16_t	GNUNET_HELLO_size (const struct GNUNET_HELLO_Message *hello)
	Return the size of the given HELLO message. More...

int	GNUNET_HELLO_get_id (const struct GNUNET_HELLO_Message hello, struct GNUNET_PeerIdentity peer)
	Get the peer identity from a HELLO message. More...

struct GNUNET_MessageHeader *	GNUNET_HELLO_get_header (struct GNUNET_HELLO_Message *hello)
	Get the header from a HELLO message, used so other code can correctly send HELLO messages. More...

static int	find_other_matching (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Check if the given address matches the address we are currently looking for. More...

static int	find_matching (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Helper function for GNUNET_HELLO_equals(). More...

struct GNUNET_TIME_Absolute	GNUNET_HELLO_equals (const struct GNUNET_HELLO_Message h1, const struct GNUNET_HELLO_Message h2, struct GNUNET_TIME_Absolute now)
	Test if two HELLO messages contain the same addresses. More...

static int	find_max_expire (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Iterator to find the time when the last address will expire. More...

struct GNUNET_TIME_Absolute	GNUNET_HELLO_get_last_expiration (const struct GNUNET_HELLO_Message *msg)
	When does the last address in the given HELLO expire? More...

static int	add_address_to_uri (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	GNUnet URIs are of the general form "gnunet://MODULE/IDENTIFIER". More...

char *	GNUNET_HELLO_compose_uri (const struct GNUNET_HELLO_Message *hello, GNUNET_HELLO_TransportPluginsFind plugins_find)
	Compose a hello URI string from a hello message. More...

static ssize_t	add_address_to_hello (void cls, size_t max, void buffer)
	We're building a HELLO. More...

int	GNUNET_HELLO_parse_uri (const char uri, struct GNUNET_CRYPTO_EddsaPublicKey pubkey, struct GNUNET_HELLO_Message **hello, GNUNET_HELLO_TransportPluginsFind plugins_find)
	Parse a hello URI string to a hello message. More...

Detailed Description

helper library for handling HELLOs

Author: Christian Grothoff; Matthias Wachs

Definition in file hello.c.

Function Documentation

◆ get_hello_address_size()

static size_t get_hello_address_size	(	const char *	buf,
		size_t	max,
		uint16_t *	ralen
	)

static

Get the size of an address entry in a HELLO message.

Parameters

buf	pointer to the start of the address entry
max	maximum size of the entry (end of buf)
ralen	set to the address length

Returns: size of the entry, or 0 if max is not large enough

Definition at line 144 of file hello.c.

 {
   const char *pos;
   uint16_t alen;
   size_t left;
   size_t slen;
  
   left = max;
   pos = buf;
   slen = 1;
   while ((left > 0) && ('\0' != *pos))
   {
     left--;
     pos++;
     slen++;
   }
   if (0 == left)
   {
     /* 0-termination not found */
     GNUNET_break_op (0);
     return 0;
   }
   pos++;
   if (left < sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO))
   {
     /* not enough space for addrlen */
     GNUNET_break_op (0);
     return 0;
   }
   GNUNET_memcpy (&alen, pos, sizeof(uint16_t));
   alen = ntohs (alen);
   *ralen = alen;
   slen += alen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO);
   if (max < slen)
   {
     /* not enough space for addr */
     GNUNET_break_op (0);
     return 0;
   }
   return slen;
 }

References buf, GNUNET_break_op, GNUNET_memcpy, and max.

Referenced by GNUNET_HELLO_iterate_addresses().

Here is the caller graph for this function:

◆ get_match_exp()

static int get_match_exp	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Store the expiration time of an address that matches the template.

Parameters

cls	the `struct ExpireContext`
address	address to match against the template
expiration	expiration time of address, to store in cls

Returns: GNUNET_SYSERR if we found a matching address, GNUNET_OK otherwise

Definition at line 370 of file hello.c.

 {
   struct ExpireContext *ec = cls;
  
   if (0 != GNUNET_HELLO_address_cmp (address,
                                      ec->address))
     return GNUNET_OK;
   ec->found = GNUNET_YES;
   ec->expiration = expiration;
   return GNUNET_SYSERR;       /* done here */
 }

References address, ExpireContext::address, expiration, ExpireContext::expiration, ExpireContext::found, GNUNET_HELLO_address_cmp(), GNUNET_OK, GNUNET_SYSERR, and GNUNET_YES.

Referenced by copy_latest(), and delta_match().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_latest()

static int copy_latest	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Append the address address to the buffer from the merge context IF it is more recent than equivalent addresses in other.

Parameters

cls	the `struct MergeContext`
address	the HELLO address we might copy
expiration	expiration time for address

Returns: always GNUNET_OK

Definition at line 442 of file hello.c.

 {
   struct MergeContext *mc = cls;
   struct ExpireContext ec;
  
   ec.address = address;
   ec.found = GNUNET_NO;
   /* check if address exists in other */
   GNUNET_HELLO_iterate_addresses (mc->other,
                                   GNUNET_NO,
                                   &get_match_exp,
                                   &ec);
   if ((GNUNET_NO == ec.found) ||
       (ec.expiration.abs_value_us < expiration.abs_value_us) ||
       ((ec.expiration.abs_value_us == expiration.abs_value_us) &&
        (GNUNET_YES == mc->take_equal)))
   {
     /* copy address to buffer */
     mc->ret +=
       GNUNET_HELLO_add_address (address,
                                 expiration,
                                 &mc->buf[mc->ret],
                                 mc->max - mc->ret);
   }
   return GNUNET_OK;
 }

References GNUNET_TIME_Absolute::abs_value_us, address, ExpireContext::address, expiration, ExpireContext::expiration, ExpireContext::found, get_match_exp(), GNUNET_HELLO_add_address(), GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_OK, GNUNET_YES, and mc.

Referenced by merge_addr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_addr()

static ssize_t merge_addr	(	void *	cls,
		size_t	max,
		void *	buf
	)

static

Function called to build the HELLO during GNUNET_HELLO_merge() by merging addresses from two original HELLOs.

Parameters

cls	the `struct MergeContext`
max	number of bytes we can write at most in buf
buf	where to copy the addresses

Returns: GNUNET_SYSERR to end iteration, otherwise number of bytes written to buf

Definition at line 483 of file hello.c.

 {
   struct MergeContext *mc = cls;
  
   if (NULL == mc->h1)
     return GNUNET_SYSERR; /* Stop iteration */
   mc->ret = 0;
   mc->max = max;
   mc->buf = buf;
   mc->take_equal = GNUNET_NO;
   mc->other = mc->h2;
   /* copy addresses from h1, if strictly larger expiration than h2 */
   GNUNET_HELLO_iterate_addresses (mc->h1,
                                   GNUNET_NO,
                                   &copy_latest,
                                   mc);
   mc->take_equal = GNUNET_YES;
   mc->other = mc->h1;
   /* copy addresses from h2, if larger or equal expiration than h1 */
   GNUNET_HELLO_iterate_addresses (mc->h2,
                                   GNUNET_NO,
                                   &copy_latest,
                                   mc);
   /* set marker to stop iteration */
   mc->h1 = NULL;
   return mc->ret;
 }

References buf, copy_latest(), GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, max, and mc.

Referenced by GNUNET_HELLO_merge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delta_match()

static int delta_match	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Check if the given address is 'new', and if so, call the iterator.

Compares the existing address against addresses in the context's old_hello and calls the iterator on those that are new (and not expired).

Parameters

cls	the `struct DeltaContext`
address	an address to check whether it is new
expiration	expiration time for address

Returns: GNUNET_YES if the address is ignored, otherwise whatever the iterator returned.

Definition at line 575 of file hello.c.

 {
   struct DeltaContext *dc = cls;
   int ret;
   struct ExpireContext ec;
  
   ec.address = address;
   ec.found = GNUNET_NO;
   GNUNET_HELLO_iterate_addresses (dc->old_hello,
                                   GNUNET_NO,
                                   &get_match_exp,
                                   &ec);
   if ((GNUNET_YES == ec.found) &&
       ((ec.expiration.abs_value_us > expiration.abs_value_us) ||
        (ec.expiration.abs_value_us >= dc->expiration_limit.abs_value_us)))
     return GNUNET_YES;          /* skip: found and boring */
   ret = dc->it (dc->it_cls,
                 address,
                 expiration);
   return ret;
 }

References GNUNET_TIME_Absolute::abs_value_us, address, ExpireContext::address, dc, expiration, ExpireContext::expiration, ExpireContext::found, get_match_exp(), GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_YES, and ret.

Referenced by GNUNET_HELLO_iterate_new_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_other_matching()

static int find_other_matching	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Check if the given address matches the address we are currently looking for.

If so, sets found to GNUNET_YES and, if the expiration times for the two addresses differ, updates result to the minimum of our expiration and the existing value

Parameters

cls	the `struct EqualsContext`
address	address from the reference HELLO
expiration	expiration time for address

Returns: GNUNET_YES if the address is expired or does not match GNUNET_SYSERR if the address does match.

Definition at line 737 of file hello.c.

 {
   struct EqualsContext *ec = cls;
  
   if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
     return GNUNET_YES;
   if (0 == GNUNET_HELLO_address_cmp (address, ec->address))
   {
     ec->found = GNUNET_YES;
     if (expiration.abs_value_us < ec->expiration.abs_value_us)
       ec->result = GNUNET_TIME_absolute_min (expiration,
                                              ec->result);
     return GNUNET_SYSERR;
   }
   return GNUNET_YES;
 }

References GNUNET_TIME_Absolute::abs_value_us, address, EqualsContext::address, expiration, EqualsContext::expiration, EqualsContext::expiration_limit, EqualsContext::found, GNUNET_HELLO_address_cmp(), GNUNET_SYSERR, GNUNET_TIME_absolute_min(), GNUNET_YES, and EqualsContext::result.

Referenced by find_matching().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_matching()

static int find_matching	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Helper function for GNUNET_HELLO_equals().

Checks if the given address exists also in the other HELLO; if not, the result time is set to zero and the iteration is aborted.

Parameters

cls	the `struct EqualsContext`
address	address to locate
expiration	expiration time of the current address

Returns: GNUNET_OK if the address exists or is expired, GNUNET_SYSERR if it was not found

Definition at line 770 of file hello.c.

 {
   struct EqualsContext *ec = cls;
  
   if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
     return GNUNET_OK; /* expired, we don't care */
   ec->address = address;
   ec->expiration = expiration;
   ec->found = GNUNET_NO;
   GNUNET_HELLO_iterate_addresses (ec->ref,
                                   GNUNET_NO,
                                   &find_other_matching,
                                   ec);
   if (GNUNET_NO == ec->found)
   {
     /* not found, we differ *now* */
     ec->result = GNUNET_TIME_UNIT_ZERO_ABS;
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
 }

References GNUNET_TIME_Absolute::abs_value_us, address, EqualsContext::address, expiration, EqualsContext::expiration, EqualsContext::expiration_limit, find_other_matching(), EqualsContext::found, GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_ZERO_ABS, EqualsContext::ref, and EqualsContext::result.

Here is the call graph for this function:

◆ find_max_expire()

static int find_max_expire	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Iterator to find the time when the last address will expire.

Updates the maximum value stored in cls.

Parameters

cls	where to store the max, a `struct GNUNET_TIME_Absolute`
address	an address (ignored)
expiration	expiration time for address

Returns: GNUNET_OK (always)

Definition at line 852 of file hello.c.

 {
   struct GNUNET_TIME_Absolute *max = cls;
  
   *max = GNUNET_TIME_absolute_max (*max, expiration);
   return GNUNET_OK;
 }

References expiration, GNUNET_OK, GNUNET_TIME_absolute_max(), and max.

Here is the call graph for this function:

◆ add_address_to_uri()

static int add_address_to_uri	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

GNUnet URIs are of the general form "gnunet://MODULE/IDENTIFIER".

The specific structure of "IDENTIFIER" depends on the module and maybe differentiated into additional subcategories if applicable. This module only deals with hello identifiers (MODULE = "hello").

The concrete URI format is:

"gnunet://hello/PEER[+YYYYMMDDHHMMSS+<TYPE>+<ADDRESS>]...". These URIs can be used to add a peer record to peerinfo service. PEER is the string representation of peer's public key. YYYYMMDDHHMMSS is the expiration date. TYPE is a transport type. ADDRESS is the address, its format depends upon the transport type. The concrete transport types and corresponding address formats are:

<TCP|UDP>!IPADDRESS IPVDDRESS is either IPV4 .-delimited address in form of XXX.XXX.XXX.XXX:PPPPP or IPV6 :-delimited address with '[' and ']' (according to RFC2732):

PPPPP is the port number. May be 0.
[add SMTP, HTTP and other addresses here]

The encoding for hexadecimal values is defined in the crypto_hash.c module in the gnunetutil library and discussed there.

Examples:

gnunet://hello/V8XXK9GAN5ZJFRFQP8MQX3D83BZTSBQVHKWWD0JPE63Z821906EG+20120302010059+TCP+192.168.0.1:2086+TCP+64.23.8.174:0 gnunet://hello/V8XXK9GAN5ZJFRFQP8MQX3D83BZTSBQVHKWWD0JPE63Z821906EG+20120302010059+TCP+[2001:db8:85a3:8d3:1319:8a2e:370:7348]:2086

Function that is called on each address of this peer. Expands the corresponding URI string.

Parameters

cls	the `struct GNUNET_HELLO_ComposeUriContext`
address	address to add
expiration	expiration time for the address

Returns: GNUNET_OK (continue iteration).

Definition at line 936 of file hello.c.

 {
   struct GNUNET_HELLO_ComposeUriContext *ctx = cls;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   const char *addr;
   char *ret;
   char *addr_dup;
   char *pos;
   char tbuf[16] = "";
   char *client_str = "_client";
   struct tm *t;
   time_t seconds;
  
   papi = ctx->plugins_find (address->transport_name);
   if (NULL == papi)
   {
     /* Not an error - we might just not have the right plugin. */
     return GNUNET_OK;
   }
   if (NULL == papi->address_to_string)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "URI conversion not implemented for plugin `%s'\n",
                 address->transport_name);
     return GNUNET_OK;
   }
   addr = papi->address_to_string (papi->cls,
                                   address->address,
                                   address->address_length);
   if ((NULL == addr) ||
       (0 == strlen (addr)))
     return GNUNET_OK;
  
   addr_dup = GNUNET_strdup (addr);
   if (NULL != (pos = strstr (addr_dup, "_server")))
     GNUNET_memcpy (pos,
                    client_str,
                    strlen (client_str)); /* Replace all server addresses with client addresses */
  
   seconds = expiration.abs_value_us / 1000LL / 1000LL;
   t = gmtime (&seconds);
  
   GNUNET_asprintf (&ret,
                    "%s%c%s%c%s%c%s",
                    ctx->uri,
                    GNUNET_HELLO_URI_SEP,
                    strftime (tbuf,
                              sizeof(tbuf),
                              "%Y%m%d%H%M%S",
                              t) ? tbuf : "0",
                    GNUNET_HELLO_URI_SEP,
                    address->transport_name,
                    GNUNET_HELLO_URI_SEP,
                    addr_dup);
   GNUNET_free (addr_dup);
   GNUNET_free (ctx->uri);
   ctx->uri = ret;
   return GNUNET_OK;
 }

References address, GNUNET_TRANSPORT_PluginFunctions::address_to_string, GNUNET_TRANSPORT_PluginFunctions::cls, ctx, expiration, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_URI_SEP, GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_strdup, ret, and t.

Referenced by GNUNET_HELLO_compose_uri().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_address_to_hello()

static ssize_t add_address_to_hello	(	void *	cls,
		size_t	max,
		void *	buffer
	)

static

We're building a HELLO.

Parse the next address from the parsing context and append it.

Parameters

cls	the `struct GNUNET_HELLO_ParseUriContext`
max	number of bytes available for HELLO construction
buffer	where to copy the next address (in binary format)

Returns: number of bytes added to buffer, GNUNET_SYSERR on error

Definition at line 1043 of file hello.c.

 {
   struct GNUNET_HELLO_ParseUriContext *ctx = cls;
   const char *tname;
   const char *address;
   char *uri_address;
   const char *end;
   char *plugin_name;
   struct tm expiration_time;
   time_t expiration_seconds;
   struct GNUNET_TIME_Absolute expire;
   struct GNUNET_TRANSPORT_PluginFunctions *papi;
   void *addr;
   size_t addr_len;
   struct GNUNET_HELLO_Address haddr;
   ssize_t ret;
  
   if (NULL == ctx->pos)
     return GNUNET_SYSERR;
   if (GNUNET_HELLO_URI_SEP != ctx->pos[0])
   {
     ctx->ret = GNUNET_SYSERR;
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
   ctx->pos++;
  
   if (('0' == ctx->pos[0]) &&
       (GNUNET_HELLO_URI_SEP == ctx->pos[1]))
   {
     expire = GNUNET_TIME_UNIT_FOREVER_ABS;
     tname = ctx->pos + 1;
   }
   else
   {
     memset (&expiration_time, 0, sizeof(expiration_time));
     tname = strptime (ctx->pos,
                       "%Y%m%d%H%M%S",
                       &expiration_time);
     if (NULL == tname)
     {
       ctx->ret = GNUNET_SYSERR;
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ (
                     "Failed to parse HELLO message: missing expiration time\n"));
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
  
     expiration_seconds = mktime (&expiration_time);
     if (expiration_seconds == (time_t) -1)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ (
                     "Failed to parse HELLO message: invalid expiration time\n"));
       ctx->ret = GNUNET_SYSERR;
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
     expire.abs_value_us = expiration_seconds * 1000LL * 1000LL;
   }
   if (GNUNET_HELLO_URI_SEP != tname[0])
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to parse HELLO message: malformed\n"));
     ctx->ret = GNUNET_SYSERR;
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
   tname++;
   address = strchr (tname,
                     (int) GNUNET_HELLO_URI_SEP);
   if (NULL == address)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ (
                   "Failed to parse HELLO message: missing transport plugin\n"));
     ctx->ret = GNUNET_SYSERR;
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
   address++;
   end = strchr (address, (int) GNUNET_HELLO_URI_SEP);
   ctx->pos = end;
   ctx->counter_total++;
   plugin_name = GNUNET_strndup (tname, address - (tname + 1));
   papi = ctx->plugins_find (plugin_name);
   if (NULL == papi)
   {
     /* Not an error - we might just not have the right plugin.
      * Skip this part, advance to the next one and recurse.
      * But only if this is not the end of string.
      */
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Plugin `%s' not found, skipping address\n"),
                 plugin_name);
     GNUNET_free (plugin_name);
     return 0;
   }
   if (NULL == papi->string_to_address)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Plugin `%s' does not support URIs yet\n"),
                 plugin_name);
     GNUNET_free (plugin_name);
     GNUNET_break (0);
     return 0;
   }
   uri_address = GNUNET_strndup (address, end - address);
   if (GNUNET_OK !=
       papi->string_to_address (papi->cls,
                                uri_address,
                                strlen (uri_address) + 1,
                                &addr,
                                &addr_len))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to parse `%s' as an address for plugin `%s'\n"),
                 uri_address,
                 plugin_name);
     GNUNET_free (plugin_name);
     GNUNET_free (uri_address);
     return 0;
   }
   GNUNET_free (uri_address);
   /* address.peer is unset - not used by add_address() */
   haddr.address_length = addr_len;
   haddr.address = addr;
   haddr.transport_name = plugin_name;
   ret = GNUNET_HELLO_add_address (&haddr,
                                   expire,
                                   buffer,
                                   max);
   ctx->counter_added++;
   GNUNET_free (addr);
   GNUNET_free (plugin_name);
   return ret;
 }

References _, address, GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, GNUNET_TRANSPORT_PluginFunctions::cls, ctx, end, expire, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_add_address(), GNUNET_HELLO_URI_SEP, GNUNET_log, GNUNET_OK, GNUNET_strndup, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_ABS, max, plugin_name, ret, GNUNET_TRANSPORT_PluginFunctions::string_to_address, and GNUNET_HELLO_Address::transport_name.

Referenced by GNUNET_HELLO_parse_uri().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Detailed Description

Function Documentation

◆ get_hello_address_size()

◆ get_match_exp()

◆ copy_latest()

◆ merge_addr()

◆ delta_match()

◆ find_other_matching()

◆ find_matching()

◆ find_max_expire()

◆ add_address_to_uri()

◆ add_address_to_hello()