Hello library

Helper library for handling HELLOs. More...

Collaboration diagram for Hello library:

Data Structures
struct	GNUNET_HELLO_Address
	An address for communicating with a peer. More...
struct	GNUNET_HELLO_Message
	A HELLO message is used to exchange information about transports with other peers. More...

Macros
#define	GNUNET_HELLO_URI_PREFIX   "gnunet://hello/"
	Prefix that every HELLO URI must start with. More...
#define	GNUNET_FRIEND_HELLO_URI_PREFIX   "gnunet://friend-hello/"
	Prefix that every FRIEND HELLO URI must start with. More...
#define	GNUNET_HELLO_URI_SEP   '+'
	Separator used in HELLO URI. More...
#define	GNUNET_HELLO_address_free(addr)   GNUNET_free (addr)
	Free an address. More...

Typedefs
typedef ssize_t(*	GNUNET_HELLO_GenerateAddressListCallback) (void *cls, size_t max, void *buf)
	Callback function used to fill a buffer of max bytes with a list of addresses in the format used by HELLOs. More...
typedef int(*	GNUNET_HELLO_AddressIterator) (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Iterator callback to go over all addresses. More...
typedef struct GNUNET_TRANSPORT_PluginFunctions *(*	GNUNET_HELLO_TransportPluginsFind) (const char *name)
	Helper function to load/access transport plugins. More...

Enumerations
enum	GNUNET_HELLO_AddressInfo { GNUNET_HELLO_ADDRESS_INFO_NONE = 0 , GNUNET_HELLO_ADDRESS_INFO_INBOUND = 1 }
	Additional local information about an address. More...

Functions
struct GNUNET_HELLO_Address *	GNUNET_HELLO_address_allocate (const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
	Allocate an address struct. More...
struct GNUNET_HELLO_Address *	GNUNET_HELLO_address_copy (const struct GNUNET_HELLO_Address *address)
	Copy an address struct. More...
int	GNUNET_HELLO_address_cmp (const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
	Compare two addresses. More...
size_t	GNUNET_HELLO_address_get_size (const struct GNUNET_HELLO_Address *address)
	Get the size of an address struct. More...
int	GNUNET_HELLO_address_check_option (const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
	Check if an address has a local option set. More...
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...
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...
uint16_t	GNUNET_HELLO_size (const struct GNUNET_HELLO_Message *hello)
	Return the size of the given HELLO message. 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...
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...
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...
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...
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...
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...
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...
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...
void	GNUNET_HELLO_sign_address (const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Absolute mono_time, const struct GNUNET_CRYPTO_EddsaPrivateKey *private_key, void **result, size_t *result_size)
	Build address record by signing raw information with private key. More...
char *	GNUNET_HELLO_extract_address (const void *raw, size_t raw_size, const struct GNUNET_PeerIdentity *pid, enum GNUNET_NetworkType *nt, struct GNUNET_TIME_Absolute *mono_time)
	Check signature and extract address record. More...
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. More...

Detailed Description

Helper library for handling HELLOs.

See also

Documentation

Macro Definition Documentation

GNUNET_HELLO_URI_PREFIX

#define GNUNET_HELLO_URI_PREFIX   "gnunet://hello/"

Prefix that every HELLO URI must start with.

Definition at line 53 of file gnunet_hello_lib.h.

GNUNET_FRIEND_HELLO_URI_PREFIX

#define GNUNET_FRIEND_HELLO_URI_PREFIX   "gnunet://friend-hello/"

Prefix that every FRIEND HELLO URI must start with.

Definition at line 58 of file gnunet_hello_lib.h.

GNUNET_HELLO_URI_SEP

#define GNUNET_HELLO_URI_SEP   '+'

Separator used in HELLO URI.

Definition at line 63 of file gnunet_hello_lib.h.

GNUNET_HELLO_address_free

#define GNUNET_HELLO_address_free

(

addr

)

GNUNET_free (addr)

Free an address.

Parameters

addr	address to free

Definition at line 198 of file gnunet_hello_lib.h.

Typedef Documentation

GNUNET_HELLO_GenerateAddressListCallback

typedef ssize_t(* GNUNET_HELLO_GenerateAddressListCallback) (void *cls, size_t max, void *buf)

Callback function used to fill a buffer of max bytes with a list of addresses in the format used by HELLOs.

Should use GNUNET_HELLO_add_address() as a helper function.

Parameters

cls	closure
max	maximum number of bytes that can be written to buf
buf	where to write the address information

Returns

number of bytes written or 0, GNUNET_SYSERR to signal the end of the iteration.

Definition at line 275 of file gnunet_hello_lib.h.

GNUNET_HELLO_AddressIterator

typedef int(* GNUNET_HELLO_AddressIterator) (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)

Iterator callback to go over all addresses.

Parameters

cls	closure
address	the address
expiration	expiration time

Returns

GNUNET_OK to keep the address, GNUNET_NO to delete it from the HELLO GNUNET_SYSERR to stop iterating (but keep current address)

Definition at line 358 of file gnunet_hello_lib.h.

GNUNET_HELLO_TransportPluginsFind

typedef struct GNUNET_TRANSPORT_PluginFunctions*( * GNUNET_HELLO_TransportPluginsFind) (const char *name)

Helper function to load/access transport plugins.

FIXME: pass closure!

Parameters

name	name of the transport plugin to load

Returns

NULL if a plugin with name name is not known/loadable

Definition at line 436 of file gnunet_hello_lib.h.

Enumeration Type Documentation

GNUNET_HELLO_AddressInfo

enum GNUNET_HELLO_AddressInfo

Additional local information about an address.

These information are only valid for the local peer and are not serialized when a GNUNET_HELLO_Message is created

Enumerator
GNUNET_HELLO_ADDRESS_INFO_NONE	No additional information.
GNUNET_HELLO_ADDRESS_INFO_INBOUND	This is an inbound address and cannot be used to initiate an outbound connection to another peer.

Definition at line 72 of file gnunet_hello_lib.h.

{
  GNUNET_HELLO_ADDRESS_INFO_NONE = 0,
 
  GNUNET_HELLO_ADDRESS_INFO_INBOUND = 1
};

Function Documentation

GNUNET_HELLO_address_allocate()

struct GNUNET_HELLO_Address* GNUNET_HELLO_address_allocate	(	const struct GNUNET_PeerIdentity *	peer,
		const char *	transport_name,
		const void *	address,
		size_t	address_length,
		enum GNUNET_HELLO_AddressInfo	local_info
	)

Allocate an address struct.

Parameters

peer	the peer
transport_name	plugin name
address	binary address
address_length	number of bytes in address
local_info	additional local information for the address

Returns

the address struct

Definition at line 63 of file address.c.

{
  struct GNUNET_HELLO_Address *addr;
  size_t slen;
  char *end;
 
  slen = strlen (transport_name) + 1;
  addr = GNUNET_malloc (sizeof(struct GNUNET_HELLO_Address)
                        + address_length + slen);
  addr->peer = *peer;
  addr->address = &addr[1];
  addr->address_length = address_length;
  addr->local_info = local_info;
  end = (char *) &addr[1];
  addr->transport_name = &end[address_length];
  GNUNET_memcpy (end,
                 address,
                 address_length);
  GNUNET_memcpy (&end[address_length],
                 transport_name,
                 slen);
  return addr;
}

References address, GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, end, GNUNET_malloc, GNUNET_memcpy, GNUNET_HELLO_Address::local_info, GNUNET_HELLO_Address::peer, peer, and GNUNET_HELLO_Address::transport_name.

Referenced by ack_proc(), address_notification(), broadcast_mst_cb(), create_session(), GNUNET_HELLO_address_copy(), handle_helper_message(), handle_response(), handle_tcp_nat_probe(), handle_tcp_welcome(), LIBGNUNET_PLUGIN_TRANSPORT_DONE(), libgnunet_plugin_transport_unix_done(), process_data(), process_udp_message(), read_process_ack(), server_add_address(), server_lookup_connection(), server_notify_external_hostname(), server_remove_address(), tcp_nat_port_map_callback(), udp_nat_port_map_callback(), and unix_demultiplexer().

Here is the caller graph for this function:

GNUNET_HELLO_address_copy()

struct GNUNET_HELLO_Address* GNUNET_HELLO_address_copy

(

const struct GNUNET_HELLO_Address *

address

)

Copy an address struct.

Parameters

address

address to copy

Returns

a copy of the address struct

Definition at line 99 of file address.c.

{
  if (NULL == address)
    return NULL;
  return GNUNET_HELLO_address_allocate (&address->peer,
                                        address->transport_name,
                                        address->address,
                                        address->address_length,
                                        address->local_info);
}

References address, and GNUNET_HELLO_address_allocate().

Referenced by ats_perf_cb(), ats_perf_mon_cb(), create_session(), find_validation_entry(), GNUNET_ATS_address_add(), GST_ats_add_address(), GST_ats_add_inbound_address(), GST_blacklist_test_allowed(), GST_hello_modify_addresses(), http_client_plugin_get_session(), process_peer_monitoring_cb(), resolve_peer_address(), send_with_session(), set_primary_address(), test_connection_ok(), udp_plugin_create_session(), and unix_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_address_cmp()

int GNUNET_HELLO_address_cmp	(	const struct GNUNET_HELLO_Address *	a1,
		const struct GNUNET_HELLO_Address *	a2
	)

Compare two addresses.

Does NOT compare the peer identity, that is assumed already to match!

Parameters

a1	first address
a2	second address

Returns

0 if the addresses are equal, -1 if a1< a2, 1 if a1> a2.

Definition at line 112 of file address.c.

{
  int ret;
 
  if ((NULL == a1) &&
      (NULL == a2))
    return 0;
  if (NULL == a1)
    return 1;
  if (NULL == a2)
    return -1;
  ret = strcmp (a1->transport_name, a2->transport_name);
  if (0 != ret)
    return ret;
  if (a1->local_info != a2->local_info)
    return (((int) a1->local_info) < ((int) a2->local_info)) ? -1 : 1;
  if (a1->address_length < a2->address_length)
    return -1;
  if (a1->address_length > a2->address_length)
    return 1;
  return memcmp (a1->address,
                 a2->address,
                 a1->address_length);
}

References GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, GNUNET_HELLO_Address::local_info, ret, and GNUNET_HELLO_Address::transport_name.

Referenced by find_address_it(), find_ai_cb(), find_ai_no_session_cb(), find_other_matching(), find_session_id(), get_match_exp(), GST_blacklist_abort_matching(), GST_hello_modify_addresses(), GST_hello_test_address(), lookup_session_it(), process_peer_monitoring_cb(), session_cmp_it(), session_lookup_client_by_address(), session_lookup_it(), set_primary_address(), switch_address_bl_check_cont(), try_run_fast_ats_update(), and validation_entry_match().

Here is the caller graph for this function:

GNUNET_HELLO_address_get_size()

size_t GNUNET_HELLO_address_get_size

(

const struct GNUNET_HELLO_Address *

address

)

Get the size of an address struct.

Parameters

address

address

Returns

the size

Definition at line 55 of file address.c.

{
  return sizeof(struct GNUNET_HELLO_Address) + address->address_length
         + strlen (address->transport_name) + 1;
}

References address, GNUNET_HELLO_Address::address_length, and GNUNET_HELLO_Address::transport_name.

GNUNET_HELLO_address_check_option()

int GNUNET_HELLO_address_check_option	(	const struct GNUNET_HELLO_Address *	address,
		enum GNUNET_HELLO_AddressInfo	option
	)

Check if an address has a local option set.

Parameters

address	the address to check
option	the respective option to check for

Returns

GNUNET_YES or GNUNET_NO

Definition at line 39 of file address.c.

{
  if (option == (address->local_info & option))
    return GNUNET_YES;
  return GNUNET_NO;
}

References address, GNUNET_NO, and GNUNET_YES.

Referenced by GNUNET_ATS_address_del_session(), GST_ats_add_address(), GST_ats_add_inbound_address(), GST_ats_block_address(), GST_ats_del_session(), GST_neighbours_switch_to_address(), handle_ats_address_suggestion(), handle_tcp_welcome(), notify_session_monitor(), plugin_env_session_start(), plugin_env_session_start_bl_check_cont(), switch_address_bl_check_cont(), and tcp_plugin_get_session().

Here is the caller graph for this function:

GNUNET_HELLO_is_friend_only()

int GNUNET_HELLO_is_friend_only

(

const struct GNUNET_HELLO_Message *

h

)

Return HELLO type.

Parameters

h	HELLO Message to test

Returns

GNUNET_YES for friend-only or GNUNET_NO otherwise

Definition at line 89 of file hello.c.

{
  if (GNUNET_YES == ntohl (h->friend_only))
    return GNUNET_YES;
  return GNUNET_NO;
}

References GNUNET_NO, GNUNET_YES, and h.

Referenced by dump_my_hello(), GNUNET_HELLO_compose_uri(), GST_validation_handle_hello(), main(), peerinfo_list_iteration(), print_peer_info(), read_host_file(), update_friend_hello(), and update_hello().

Here is the caller graph for this function:

GNUNET_HELLO_add_address()

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.

Parameters

address	address to add
expiration	expiration for the address
target	where to copy the address
max	maximum number of bytes to copy to target

Returns

number of bytes copied, 0 if the target buffer was not big enough.

Parameters

address	the address
expiration	expiration for the address
target	where to copy the address
max	maximum number of bytes to copy to target

Returns

number of bytes copied, 0 if the target buffer was not big enough.

Definition at line 109 of file hello.c.

{
  uint16_t alen;
  size_t slen;
  struct GNUNET_TIME_AbsoluteNBO exp;
 
  slen = strlen (address->transport_name) + 1;
  if (slen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO)
      + address->address_length > max)
    return 0;
  exp = GNUNET_TIME_absolute_hton (expiration);
  alen = htons ((uint16_t) address->address_length);
  GNUNET_memcpy (target, address->transport_name, slen);
  GNUNET_memcpy (&target[slen], &alen, sizeof(uint16_t));
  slen += sizeof(uint16_t);
  GNUNET_memcpy (&target[slen], &exp, sizeof(struct GNUNET_TIME_AbsoluteNBO));
  slen += sizeof(struct GNUNET_TIME_AbsoluteNBO);
  GNUNET_memcpy (&target[slen], address->address, address->address_length);
  slen += address->address_length;
  return slen;
}

References address, expiration, GNUNET_memcpy, GNUNET_TIME_absolute_hton(), and max.

Referenced by add_address_to_hello(), add_to_buf(), add_valid_peer_address(), address_generator(), and copy_latest().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_create()

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.

If friend only is set to GNUNET_YES we create a FRIEND_HELLO which will not be gossiped to other peers.

Parameters

public_key	public key to include in the HELLO
addrgen	callback to invoke to get addresses
addrgen_cls	closure for addrgen
friend_only	should the returned HELLO be only visible to friends?

Returns

the hello message

Definition at line 204 of file hello.c.

{
  char buffer[GNUNET_MAX_MESSAGE_SIZE - 1 - 256
              - sizeof(struct GNUNET_HELLO_Message)];
  size_t max;
  size_t used;
  size_t ret;
  struct GNUNET_HELLO_Message *hello;
 
  GNUNET_assert (NULL != public_key);
  GNUNET_assert ((GNUNET_YES == friend_only) ||
                 (GNUNET_NO == friend_only));
  max = sizeof(buffer);
  used = 0;
  if (NULL != addrgen)
  {
    while (GNUNET_SYSERR != (ret = addrgen (addrgen_cls,
                                            max,
                                            &buffer[used])))
    {
      max -= ret;
      used += ret;
    }
  }
  hello = GNUNET_malloc (sizeof(struct GNUNET_HELLO_Message) + used);
  hello->header.type = htons (GNUNET_MESSAGE_TYPE_HELLO);
  hello->header.size = htons (sizeof(struct GNUNET_HELLO_Message) + used);
  hello->friend_only = htonl (friend_only);
  hello->publicKey = *public_key;
  GNUNET_memcpy (&hello[1],
                 buffer,
                 used);
  return hello;
}

References GNUNET_HELLO_Message::friend_only, GNUNET_assert, GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_HELLO_Message::header, max, GNUNET_HELLO_Message::publicKey, ret, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GNUNET_HELLO_merge(), GNUNET_HELLO_parse_uri(), GST_validation_handle_pong(), main(), refresh_hello_task(), and update_friend_hello().

Here is the caller graph for this function:

GNUNET_HELLO_size()

uint16_t GNUNET_HELLO_size

(

const struct GNUNET_HELLO_Message *

hello

)

Return the size of the given HELLO message.

Parameters

hello

to inspect

Returns

the size, 0 if HELLO is invalid

Definition at line 630 of file hello.c.

{
  uint16_t ret = ntohs (hello->header.size);
 
  if ((ret < sizeof(struct GNUNET_HELLO_Message)) ||
      (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
    return 0;
  return ret;
}

References GNUNET_MESSAGE_TYPE_HELLO, GNUNET_HELLO_Message::header, ret, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by add_to_tc(), announce_id(), callback_download(), check_info(), check_notification(), consider_for_advertising(), dht_get_id_handler(), discard_hosts_helper(), dump_my_hello(), find_advertisable_hello(), GCP_set_hello(), GNUNET_HELLO_iterate_addresses(), got_hello(), host_processor(), main(), make_info_message(), make_peer(), offer_hello(), prepare_beacon(), read_host_file(), refresh_hello_task(), schedule_next_hello(), send_hello_beacon(), and update_hello().

Here is the caller graph for this function:

GNUNET_HELLO_merge()

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

Parameters

h1	first HELLO message
h2	the second HELLO message

Returns

the combined hello message

Definition at line 515 of file hello.c.

{
  struct MergeContext mc = { h1, h2, NULL, NULL, 0, 0, 0 };
  int friend_only;
 
  if (h1->friend_only != h2->friend_only)
    friend_only = GNUNET_YES; /* One of the HELLOs is friend only */
  else
    friend_only = ntohl (h1->friend_only); /* Both HELLO's have the same type */
 
  return GNUNET_HELLO_create (&h1->publicKey,
                              &merge_addr,
                              &mc,
                              friend_only);
}

References GNUNET_HELLO_Message::friend_only, GNUNET_HELLO_create(), GNUNET_YES, MergeContext::h1, MergeContext::h2, mc, merge_addr(), and GNUNET_HELLO_Message::publicKey.

Referenced by consider_for_advertising(), GCP_set_hello(), update_friend_hello(), and update_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_equals()

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.

If they only differ in expiration time, the lowest expiration time larger than 'now' where they differ is returned.

Parameters

h1	first HELLO message
h2	the second HELLO message
now	time to use for deciding which addresses have expired and should not be considered at all

Returns

absolute time forever if the two HELLOs are totally identical; smallest timestamp >= now if they only differ in timestamps; zero if the some addresses with expirations >= now do not match at all

If they only differ in expiration time, the lowest expiration time larger than now where they differ is returned.

Parameters

h1	first HELLO message
h2	the second HELLO message
now	time to use for deciding which addresses have expired and should not be considered at all

Returns

absolute time forever if the two HELLOs are totally identical; smallest timestamp >= now if they only differ in timestamps; zero if the some addresses with expirations >= now do not match at all

Definition at line 770 of file hello.c.

{
  struct EqualsContext ec;
 
  if (h1->header.type != h2->header.type)
    return GNUNET_TIME_UNIT_ZERO_ABS;
  if (0 !=
      GNUNET_memcmp (&h1->publicKey,
                     &h2->publicKey))
    return GNUNET_TIME_UNIT_ZERO_ABS;
  ec.expiration_limit = now;
  ec.result = GNUNET_TIME_UNIT_FOREVER_ABS;
  ec.ref = h2;
  GNUNET_HELLO_iterate_addresses (h1,
                                  GNUNET_NO,
                                  &find_matching,
                                  &ec);
  if (ec.result.abs_value_us == GNUNET_TIME_UNIT_ZERO.rel_value_us)
    return ec.result;
  ec.ref = h1;
  GNUNET_HELLO_iterate_addresses (h2,
                                  GNUNET_NO,
                                  &find_matching,
                                  &ec);
  return ec.result;
}

Referenced by consider_for_advertising(), and update_hello().

Here is the caller graph for this function:

GNUNET_HELLO_get_last_expiration()

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?

Parameters

msg	HELLO to inspect

Returns

time the last address expires, 0 if there are no addresses in the HELLO

Definition at line 852 of file hello.c.

{
  struct GNUNET_TIME_Absolute ret;
 
  ret = GNUNET_TIME_UNIT_ZERO_ABS;
  GNUNET_HELLO_iterate_addresses (msg,
                                  GNUNET_NO,
                                  &find_max_expire,
                                  &ret);
  return ret;
}

Referenced by announce_id(), consider_peer_destroy(), and got_hello().

Here is the caller graph for this function:

GNUNET_HELLO_iterate_addresses()

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.

Parameters

msg	HELLO to iterate over; client does not need to have verified that msg is well-formed (beyond starting with a GNUNET_MessageHeader of the right type).
return_modified	if a modified copy should be returned, otherwise NULL will be returned
it	iterator to call on each address
it_cls	closure for it

Returns

the modified HELLO or NULL

Parameters

msg	HELLO to iterate over
return_modified	if a modified copy should be returned, otherwise NULL will be returned
it	iterator to call on each address
it_cls	closure for it

Returns

modified HELLO message

Definition at line 254 of file hello.c.

{
  struct GNUNET_HELLO_Address address;
  uint16_t msize;
  struct GNUNET_HELLO_Message *ret;
  const char *inptr;
  size_t insize;
  size_t esize;
  size_t wpos;
  char *woff;
  uint16_t alen;
  struct GNUNET_TIME_AbsoluteNBO expire;
  int iret;
 
  msize = GNUNET_HELLO_size (msg);
  if ((msize < sizeof(struct GNUNET_HELLO_Message)) ||
      (ntohs (msg->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  ret = NULL;
  if (return_modified)
  {
    ret = GNUNET_malloc (msize);
    GNUNET_memcpy (ret,
                   msg,
                   msize);
  }
  inptr = (const char *) &msg[1];
  insize = msize - sizeof(struct GNUNET_HELLO_Message);
  wpos = 0;
  woff = (NULL != ret) ? (char *) &ret[1] : NULL;
  address.peer.public_key = msg->publicKey;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "HELLO has %u bytes of address data\n",
              (unsigned int) insize);
 
  while (insize > 0)
  {
    esize = get_hello_address_size (inptr,
                                    insize,
                                    &alen);
    if (0 == esize)
    {
      GNUNET_break (0);
      GNUNET_free (ret);
      return NULL;
    }
    /* need GNUNET_memcpy() due to possibility of misalignment */
    GNUNET_memcpy (&expire,
                   &inptr[esize - alen - sizeof(struct
                                                GNUNET_TIME_AbsoluteNBO)],
                   sizeof(struct GNUNET_TIME_AbsoluteNBO));
    address.address = &inptr[esize - alen];
    address.address_length = alen;
    address.transport_name = inptr;
    address.local_info = GNUNET_HELLO_ADDRESS_INFO_NONE;
    iret = it (it_cls,
               &address,
               GNUNET_TIME_absolute_ntoh (expire));
    if (GNUNET_SYSERR == iret)
      break;
    if ((GNUNET_OK == iret) &&
        (NULL != ret))
    {
      /* copy address over */
      GNUNET_memcpy (woff,
                     inptr,
                     esize);
      woff += esize;
      wpos += esize;
    }
    insize -= esize;
    inptr += esize;
  }
  if (NULL != ret)
    ret->header.size = ntohs (sizeof(struct GNUNET_HELLO_Message) + wpos);
  return ret;
}

References address, expire, get_hello_address_size(), GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_HELLO_size(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_ntoh(), msg, ret, and GNUNET_MessageHeader::type.

Referenced by add_from_hello(), consider_for_advertising(), copy_latest(), delta_match(), discard_hosts_helper(), dump_my_hello(), find_matching(), GNUNET_HELLO_compose_uri(), GNUNET_HELLO_iterate_new_addresses(), GST_validation_handle_hello(), hello_update_cb(), host_processor(), merge_addr(), peerinfo_list_iteration(), print_peer_info(), process_peerinfo_hello(), read_host_file(), and update_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_iterate_new_addresses()

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.

Note that if the address is present in old_hello but the expiration time in new_hello is more recent, the iterator is also called.

Parameters

new_hello	a HELLO message
old_hello	a HELLO message
expiration_limit	ignore addresses in old_hello that expired before the given time stamp
it	iterator to call on each address
it_cls	closure for it

Definition at line 601 of file hello.c.

{
  struct DeltaContext dc;
 
  dc.expiration_limit = expiration_limit;
  dc.it = it;
  dc.it_cls = it_cls;
  dc.old_hello = old_hello;
  GNUNET_assert (NULL ==
                 GNUNET_HELLO_iterate_addresses (new_hello,
                                                 GNUNET_NO,
                                                 &delta_match,
                                                 &dc));
}

References dc, delta_match(), DeltaContext::expiration_limit, GNUNET_assert, GNUNET_HELLO_iterate_addresses(), GNUNET_NO, DeltaContext::it, DeltaContext::it_cls, and DeltaContext::old_hello.

Here is the call graph for this function:

GNUNET_HELLO_get_id()

int GNUNET_HELLO_get_id	(	const struct GNUNET_HELLO_Message *	hello,
		struct GNUNET_PeerIdentity *	peer
	)

Get the peer identity from a HELLO message.

Parameters

hello	the hello message
peer	where to store the peer's identity

Returns

GNUNET_SYSERR if the HELLO was malformed

Definition at line 649 of file hello.c.

{
  uint16_t ret = ntohs (hello->header.size);
 
  if ((ret < sizeof(struct GNUNET_HELLO_Message)) ||
      (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
    return GNUNET_SYSERR;
  peer->public_key = hello->publicKey;
  return GNUNET_OK;
}

References GNUNET_MESSAGE_TYPE_HELLO, GNUNET_OK, GNUNET_SYSERR, GNUNET_HELLO_Message::header, peer, GNUNET_HELLO_Message::publicKey, ret, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by add_valid_address(), check_hello(), check_info(), consider_for_advertising(), get_hello(), GNUNET_PEERINFO_add_peer(), GNUNET_TRANSPORT_offer_hello(), GST_validation_handle_hello(), handle_hello(), hello_callback(), hosts_directory_scan_callback(), main(), process_data(), and update_friend_hello().

Here is the caller graph for this function:

GNUNET_HELLO_get_header()

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.

Parameters

hello

the hello message

Returns

header or NULL if the HELLO was malformed

Definition at line 671 of file hello.c.

{
  uint16_t ret = ntohs (hello->header.size);
 
  if ((ret < sizeof(struct GNUNET_HELLO_Message)) ||
      (ntohs (hello->header.type) != GNUNET_MESSAGE_TYPE_HELLO))
    return NULL;
 
  return &hello->header;
}

References GNUNET_MESSAGE_TYPE_HELLO, GNUNET_HELLO_Message::header, ret, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GCP_set_hello().

Here is the caller graph for this function:

GNUNET_HELLO_compose_uri()

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.

Parameters

hello	Hello message
plugins_find	Function to find transport plugins by name

Returns

Hello URI string

Definition at line 1007 of file hello.c.

{
  struct GNUNET_HELLO_ComposeUriContext ctx;
  char *pkey;
 
  ctx.plugins_find = plugins_find;
  pkey = GNUNET_CRYPTO_eddsa_public_key_to_string (&hello->publicKey);
  GNUNET_asprintf (&ctx.uri,
                   "%s%s",
                   (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello))
                   ? GNUNET_FRIEND_HELLO_URI_PREFIX
                   : GNUNET_HELLO_URI_PREFIX,
                   pkey);
  GNUNET_free (pkey);
  GNUNET_HELLO_iterate_addresses (hello,
                                  GNUNET_NO,
                                  &add_address_to_uri,
                                  &ctx);
  return ctx.uri;
}

References add_address_to_uri(), ctx, GNUNET_asprintf(), GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_free, GNUNET_FRIEND_HELLO_URI_PREFIX, GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_iterate_addresses(), GNUNET_HELLO_URI_PREFIX, GNUNET_NO, GNUNET_YES, pkey, GNUNET_HELLO_ComposeUriContext::plugins_find, and GNUNET_HELLO_Message::publicKey.

Referenced by peerinfo_cb(), and print_my_uri().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_parse_uri()

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.

Parameters

uri	URI string to parse
pubkey	Pointer to struct where public key is parsed
hello	Pointer to struct where hello message is parsed
plugins_find	Function to find transport plugins by name

Returns

GNUNET_OK on success, GNUNET_SYSERR if the URI was invalid, GNUNET_NO on other errors

Definition at line 1195 of file hello.c.

{
  const char *pks;
  const char *exc;
  int friend_only;
  struct GNUNET_HELLO_ParseUriContext ctx;
 
  if (0 == strncmp (uri,
                    GNUNET_HELLO_URI_PREFIX,
                    strlen (GNUNET_HELLO_URI_PREFIX)))
  {
    pks = &uri[strlen (GNUNET_HELLO_URI_PREFIX)];
    friend_only = GNUNET_NO;
  }
  else if (0 == strncmp (uri,
                         GNUNET_FRIEND_HELLO_URI_PREFIX,
                         strlen (GNUNET_FRIEND_HELLO_URI_PREFIX)))
  {
    pks = &uri[strlen (GNUNET_FRIEND_HELLO_URI_PREFIX)];
    friend_only = GNUNET_YES;
  }
  else
    return GNUNET_SYSERR;
  exc = strchr (pks, GNUNET_HELLO_URI_SEP);
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (pks,
                                     (NULL == exc) ? strlen (pks) : (exc - pks),
                                     (unsigned char *) pubkey,
                                     sizeof(*pubkey)))
    return GNUNET_SYSERR;
 
  ctx.pos = exc;
  ctx.ret = GNUNET_OK;
  ctx.counter_total = 0;
  ctx.counter_added = 0;
  ctx.plugins_find = plugins_find;
  *hello = GNUNET_HELLO_create (pubkey,
                                &add_address_to_hello,
                                &ctx,
                                friend_only);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "HELLO URI contained %u addresses, added %u addresses\n",
              ctx.counter_total,
              ctx.counter_added);
 
  return ctx.ret;
}

References add_address_to_hello(), ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FRIEND_HELLO_URI_PREFIX, GNUNET_HELLO_create(), GNUNET_HELLO_URI_PREFIX, GNUNET_HELLO_URI_SEP, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, GNUNET_YES, GNUNET_HELLO_ParseUriContext::plugins_find, pubkey, and uri.

Referenced by gnunet_try_connect(), and parse_hello_uri().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_sign_address()

void GNUNET_HELLO_sign_address	(	const char *	address,
		enum GNUNET_NetworkType	nt,
		struct GNUNET_TIME_Absolute	mono_time,
		const struct GNUNET_CRYPTO_EddsaPrivateKey *	private_key,
		void **	result,
		size_t *	result_size
	)

Build address record by signing raw information with private key.

Parameters

	address	text address to sign
	nt	network type of address
	mono_time	when was address valid
	private_key	signing key to use
[out]	result	where to write address record (allocated)
[out]	result_size	set to size of result
	address	text address at communicator to sign
	nt	network type of address
	mono_time	monotonic time at which address was valid
	private_key	signing key to use
[out]	result	where to write address record (allocated)
[out]	result_size	set to size of result

Definition at line 67 of file hello-ng.c.

{
  struct SignedAddress sa;
  struct GNUNET_CRYPTO_EddsaSignature sig;
  char *sig_str;
 
  sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
  sa.purpose.size = htonl (sizeof(sa));
  sa.mono_time = GNUNET_TIME_absolute_hton (mono_time);
  GNUNET_CRYPTO_hash (address, strlen (address), &sa.addr_hash);
  GNUNET_CRYPTO_eddsa_sign (private_key, &sa, &sig);
  sig_str = NULL;
  (void) GNUNET_STRINGS_base64_encode (&sig, sizeof(sig), &sig_str);
  *result_size =
    1 + GNUNET_asprintf ((char **) result,
                         "%s;%llu;%u;%s",
                         sig_str,
                         (unsigned long long) mono_time.abs_value_us,
                         (unsigned int) nt,
                         address);
  GNUNET_free (sig_str);
}

References GNUNET_TIME_Absolute::abs_value_us, SignedAddress::addr_hash, address, GNUNET_asprintf(), GNUNET_CRYPTO_eddsa_sign, GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS, GNUNET_STRINGS_base64_encode(), GNUNET_TIME_absolute_hton(), SignedAddress::mono_time, nt, SignedAddress::purpose, GNUNET_CRYPTO_EccSignaturePurpose::purpose, result, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by store_pi().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_HELLO_extract_address()

char* GNUNET_HELLO_extract_address	(	const void *	raw,
		size_t	raw_size,
		const struct GNUNET_PeerIdentity *	pid,
		enum GNUNET_NetworkType *	nt,
		struct GNUNET_TIME_Absolute *	mono_time
	)

Check signature and extract address record.

Parameters

	raw	raw signed address
	raw_size	size of raw
	pid	public key to use for signature verification
[out]	nt	set to network type
[out]	mono_time	when was the address generated

Returns

NULL on error, otherwise the address

Parameters

raw	raw signed address
raw_size	size of raw
pid	public key to use for signature verification
nt[out]	set to network type
mono_time[out]	when was the address generated

Returns

NULL on error, otherwise the address

Definition at line 108 of file hello-ng.c.

{
  const struct GNUNET_CRYPTO_EddsaPublicKey *public_key = &pid->public_key;
  const char *raws = raw;
  unsigned long long raw_us = 0;
  unsigned int raw_nt = 0;
  const char *sc;
  const char *sc2;
  const char *sc3;
  const char *raw_addr;
  char *data = NULL;
  struct GNUNET_TIME_Absolute raw_mono_time;
  struct SignedAddress sa;
  struct GNUNET_CRYPTO_EddsaSignature *sig;
 
  if ('\0' != raws[raw_size-1])
  {
    GNUNET_break_op (0);
    return NULL;
  }
  if (NULL == (sc = strchr (raws, ';')))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  if (NULL == (sc2 = strchr (sc + 1, ';')))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  if (NULL == (sc3 = strchr (sc2 + 1, ';')))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  if (2 != sscanf (sc + 1, "%llu;%u;%*s", &raw_us, &raw_nt))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  raw_addr = sc3 + 1;
  raw_mono_time.abs_value_us = raw_us;
    if (sizeof(struct GNUNET_CRYPTO_EddsaSignature) !=
      GNUNET_STRINGS_base64_decode (raws, sc - raws, (void **) &data))
  {
    GNUNET_break_op (0);
    GNUNET_free (data);
    return NULL;
  }
  sig = (struct GNUNET_CRYPTO_EddsaSignature*) data;
  sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
  sa.purpose.size = htonl (sizeof(sa));
  sa.mono_time = GNUNET_TIME_absolute_hton (raw_mono_time);
  GNUNET_CRYPTO_hash (raw_addr, strlen (raw_addr), &sa.addr_hash);
  if (GNUNET_YES !=
      GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS,
                                  &sa,
                                  sig,
                                  public_key))
  {
    GNUNET_free (data);
    GNUNET_break_op (0);
    return NULL;
  }
  GNUNET_free (data);
  *mono_time = raw_mono_time;
  *nt = raw_nt;
  return GNUNET_strdup (raw_addr);
}

References GNUNET_TIME_Absolute::abs_value_us, SignedAddress::addr_hash, data, GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS, GNUNET_strdup, GNUNET_STRINGS_base64_decode(), GNUNET_TIME_absolute_hton(), GNUNET_YES, SignedAddress::mono_time, nt, pid, GNUNET_PeerIdentity::public_key, SignedAddress::purpose, GNUNET_CRYPTO_EccSignaturePurpose::purpose, raw, sc, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by offer_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 191 of file hello-ng.c.

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

Referenced by GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue(), and suggest_to_connect().

Here is the caller graph for this function: