GNUnet  0.10.x
Data Structures | Functions
hello.c File Reference

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:

Go to the source code of this file.

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_MessageGNUNET_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_MessageGNUNET_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_MessageGNUNET_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_MessageHeaderGNUNET_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
bufpointer to the start of the address entry
maxmaximum size of the entry (end of buf)
ralenset to the address length
Returns
size of the entry, or 0 if max is not large enough

Definition at line 142 of file hello.c.

References buf, GNUNET_break_op, and GNUNET_memcpy.

Referenced by GNUNET_HELLO_iterate_addresses().

145 {
146  const char *pos;
147  uint16_t alen;
148  size_t left;
149  size_t slen;
150 
151  left = max;
152  pos = buf;
153  slen = 1;
154  while ((left > 0) && ('\0' != *pos))
155  {
156  left--;
157  pos++;
158  slen++;
159  }
160  if (0 == left)
161  {
162  /* 0-termination not found */
163  GNUNET_break_op(0);
164  return 0;
165  }
166  pos++;
167  if (left < sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO))
168  {
169  /* not enough space for addrlen */
170  GNUNET_break_op(0);
171  return 0;
172  }
173  GNUNET_memcpy(&alen, pos, sizeof(uint16_t));
174  alen = ntohs(alen);
175  *ralen = alen;
176  slen += alen + sizeof(uint16_t) + sizeof(struct GNUNET_TIME_AbsoluteNBO);
177  if (max < slen)
178  {
179  /* not enough space for addr */
180  GNUNET_break_op(0);
181  return 0;
182  }
183  return slen;
184 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
static char buf[2048]
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
clsthe struct ExpireContext
addressaddress to match against the template
expirationexpiration time of address, to store in cls
Returns
GNUNET_SYSERR if we found a matching address, GNUNET_OK otherwise

Definition at line 366 of file hello.c.

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

369 {
370  struct ExpireContext *ec = cls;
371 
372  if (0 != GNUNET_HELLO_address_cmp(address,
373  ec->address))
374  return GNUNET_OK;
375  ec->found = GNUNET_YES;
376  ec->expiration = expiration;
377  return GNUNET_SYSERR; /* done here */
378 }
int found
Set to GNUNET_YES if we found the address.
Definition: hello.c:348
static char * expiration
Credential TTL.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
const struct GNUNET_HELLO_Address * address
Address we are looking for.
Definition: hello.c:343
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_TIME_Absolute expiration
Set to the expiration of the match if found is GNUNET_YES.
Definition: hello.c:353
Closure for get_match_exp().
Definition: hello.c:339
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsthe struct MergeContext
addressthe HELLO address we might copy
expirationexpiration time for address
Returns
always GNUNET_OK

Definition at line 437 of file hello.c.

References GNUNET_TIME_Absolute::abs_value_us, address, ExpireContext::address, MergeContext::buf, ExpireContext::expiration, ExpireContext::found, get_match_exp(), GNUNET_HELLO_add_address(), GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_OK, GNUNET_YES, MergeContext::max, mc, MergeContext::other, MergeContext::ret, and MergeContext::take_equal.

Referenced by merge_addr().

440 {
441  struct MergeContext *mc = cls;
442  struct ExpireContext ec;
443 
444  ec.address = address;
445  ec.found = GNUNET_NO;
446  /* check if address exists in other */
448  GNUNET_NO,
449  &get_match_exp,
450  &ec);
451  if ((GNUNET_NO == ec.found) ||
452  (ec.expiration.abs_value_us < expiration.abs_value_us) ||
453  ((ec.expiration.abs_value_us == expiration.abs_value_us) &&
454  (GNUNET_YES == mc->take_equal)))
455  {
456  /* copy address to buffer */
457  mc->ret +=
458  GNUNET_HELLO_add_address(address,
459  expiration,
460  &mc->buf[mc->ret],
461  mc->max - mc->ret);
462  }
463  return GNUNET_OK;
464 }
Closure for merge_pr().
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint64_t abs_value_us
The actual value.
char * buf
Buffer where we copy to.
Definition: hello.c:405
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.
Definition: hello.c:252
const struct GNUNET_HELLO_Address * address
Address we are looking for.
Definition: hello.c:343
static struct GNUNET_TESTBED_Controller * mc
Handle to the master controller.
int take_equal
Should we copy addresses with an identical value and expiration time in other, or do we only copy add...
Definition: hello.c:422
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.
Definition: hello.c:107
size_t ret
Current (write) offset in buf.
Definition: hello.c:415
size_t max
Number of bytes allocated in buf.
Definition: hello.c:410
Closure for get_match_exp().
Definition: hello.c:339
const struct GNUNET_HELLO_Message * other
Either h1 or h2, used when copying to compare against (so we only copy the most recent entry)...
Definition: hello.c:400
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.
Definition: hello.c:366
#define GNUNET_YES
Definition: gnunet_common.h:77
static char * address
GNS address for this phone.
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
clsthe struct MergeContext
maxnumber of bytes we can write at most in buf
bufwhere to copy the addresses
Returns
GNUNET_SYSERR to end iteration, otherwise number of bytes written to buf

Definition at line 478 of file hello.c.

References buf, MergeContext::buf, copy_latest(), GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, MergeContext::h1, MergeContext::h2, MergeContext::max, mc, MergeContext::other, MergeContext::ret, and MergeContext::take_equal.

Referenced by GNUNET_HELLO_merge().

481 {
482  struct MergeContext *mc = cls;
483 
484  if (NULL == mc->h1)
485  return GNUNET_SYSERR; /* Stop iteration */
486  mc->ret = 0;
487  mc->max = max;
488  mc->buf = buf;
489  mc->take_equal = GNUNET_NO;
490  mc->other = mc->h2;
491  /* copy addresses from h1, if strictly larger expiration than h2 */
493  GNUNET_NO,
494  &copy_latest,
495  mc);
496  mc->take_equal = GNUNET_YES;
497  mc->other = mc->h1;
498  /* copy addresses from h2, if larger or equal expiration than h1 */
500  GNUNET_NO,
501  &copy_latest,
502  mc);
503  /* set marker to stop iteration */
504  mc->h1 = NULL;
505  return mc->ret;
506 }
Closure for merge_pr().
const struct GNUNET_HELLO_Message * h1
First HELLO we are merging.
Definition: hello.c:388
#define GNUNET_NO
Definition: gnunet_common.h:78
char * buf
Buffer where we copy to.
Definition: hello.c:405
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.
Definition: hello.c:252
static char buf[2048]
static struct GNUNET_TESTBED_Controller * mc
Handle to the master controller.
int take_equal
Should we copy addresses with an identical value and expiration time in other, or do we only copy add...
Definition: hello.c:422
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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 ...
Definition: hello.c:437
const struct GNUNET_HELLO_Message * h2
Second HELLO we are merging.
Definition: hello.c:393
size_t ret
Current (write) offset in buf.
Definition: hello.c:415
size_t max
Number of bytes allocated in buf.
Definition: hello.c:410
const struct GNUNET_HELLO_Message * other
Either h1 or h2, used when copying to compare against (so we only copy the most recent entry)...
Definition: hello.c:400
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsthe struct DeltaContext
addressan address to check whether it is new
expirationexpiration time for address
Returns
GNUNET_YES if the address is ignored, otherwise whatever the iterator returned.

Definition at line 578 of file hello.c.

References GNUNET_TIME_Absolute::abs_value_us, address, ExpireContext::address, dc, ExpireContext::expiration, DeltaContext::expiration_limit, ExpireContext::found, get_match_exp(), GNUNET_HELLO_iterate_addresses(), GNUNET_NO, GNUNET_YES, DeltaContext::it, DeltaContext::it_cls, DeltaContext::old_hello, and ret.

Referenced by GNUNET_HELLO_iterate_new_addresses().

581 {
582  struct DeltaContext *dc = cls;
583  int ret;
584  struct ExpireContext ec;
585 
586  ec.address = address;
587  ec.found = GNUNET_NO;
589  GNUNET_NO,
590  &get_match_exp,
591  &ec);
592  if ((GNUNET_YES == ec.found) &&
593  ((ec.expiration.abs_value_us > expiration.abs_value_us) ||
594  (ec.expiration.abs_value_us >= dc->expiration_limit.abs_value_us)))
595  return GNUNET_YES; /* skip: found and boring */
596  ret = dc->it(dc->it_cls,
597  address,
598  expiration);
599  return ret;
600 }
Context used in GNUNET_HELLO_iterate_new_addresses() to figure out which addresses are in fact &#39;new&#39;...
Definition: hello.c:541
GNUNET_HELLO_AddressIterator it
Function to call on addresses that are indeed new.
Definition: hello.c:550
#define GNUNET_NO
Definition: gnunet_common.h:78
static int ret
Final status code.
Definition: gnunet-arm.c:89
uint64_t abs_value_us
The actual value.
const struct GNUNET_HELLO_Message * old_hello
HELLO with known addresses, addresses in this HELLO we must always ignore.
Definition: hello.c:561
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.
Definition: hello.c:252
const struct GNUNET_HELLO_Address * address
Address we are looking for.
Definition: hello.c:343
void * it_cls
Closure for it.
Definition: hello.c:555
struct GNUNET_TIME_Absolute expiration_limit
We should ignore addresses that expire before this time.
Definition: hello.c:545
Closure for get_match_exp().
Definition: hello.c:339
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.
Definition: hello.c:366
#define GNUNET_YES
Definition: gnunet_common.h:77
static char * address
GNS address for this phone.
static struct GNUNET_FS_DownloadContext * dc
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
clsthe struct EqualsContext
addressaddress from the reference HELLO
expirationexpiration 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 749 of file hello.c.

References GNUNET_TIME_Absolute::abs_value_us, EqualsContext::address, 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().

752 {
753  struct EqualsContext *ec = cls;
754 
755  if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
756  return GNUNET_YES;
757  if (0 == GNUNET_HELLO_address_cmp(address, ec->address))
758  {
759  ec->found = GNUNET_YES;
760  if (expiration.abs_value_us < ec->expiration.abs_value_us)
761  ec->result = GNUNET_TIME_absolute_min(expiration,
762  ec->result);
763  return GNUNET_SYSERR;
764  }
765  return GNUNET_YES;
766 }
struct GNUNET_TIME_Absolute expiration
Expiration time of address.
Definition: hello.c:727
struct GNUNET_TIME_Absolute expiration_limit
Addresses that expired before this date are ignored for the comparisson.
Definition: hello.c:704
uint64_t abs_value_us
The actual value.
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
int found
Did we find the address we were looking for?
Definition: hello.c:732
struct GNUNET_TIME_Absolute result
Earliest expiration time for which we found a match with a difference in expiration times...
Definition: hello.c:711
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the minimum of two absolute time values.
Definition: time.c:302
#define GNUNET_YES
Definition: gnunet_common.h:77
Context used for comparing HELLOs in GNUNET_HELLO_equals().
Definition: hello.c:699
const struct GNUNET_HELLO_Address * address
Address we are currently looking for.
Definition: hello.c:722
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
clsthe struct EqualsContext
addressaddress to locate
expirationexpiration 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 782 of file hello.c.

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.

Referenced by GNUNET_HELLO_equals().

785 {
786  struct EqualsContext *ec = cls;
787 
788  if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
789  return GNUNET_OK; /* expired, we don't care */
790  ec->address = address;
791  ec->expiration = expiration;
792  ec->found = GNUNET_NO;
794  GNUNET_NO,
796  ec);
797  if (GNUNET_NO == ec->found)
798  {
799  /* not found, we differ *now* */
801  return GNUNET_SYSERR;
802  }
803  return GNUNET_OK;
804 }
static char * expiration
Credential TTL.
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
struct GNUNET_TIME_Absolute expiration
Expiration time of address.
Definition: hello.c:727
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_TIME_Absolute expiration_limit
Addresses that expired before this date are ignored for the comparisson.
Definition: hello.c:704
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint64_t abs_value_us
The actual value.
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.
Definition: hello.c:749
const struct GNUNET_HELLO_Message * ref
HELLO message to compare against.
Definition: hello.c:717
int found
Did we find the address we were looking for?
Definition: hello.c:732
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.
Definition: hello.c:252
struct GNUNET_TIME_Absolute result
Earliest expiration time for which we found a match with a difference in expiration times...
Definition: hello.c:711
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Context used for comparing HELLOs in GNUNET_HELLO_equals().
Definition: hello.c:699
static char * address
GNS address for this phone.
const struct GNUNET_HELLO_Address * address
Address we are currently looking for.
Definition: hello.c:722
Here is the call graph for this function:
Here is the caller 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
clswhere to store the max, a struct GNUNET_TIME_Absolute
addressan address (ignored)
expirationexpiration time for address
Returns
GNUNET_OK (always)

Definition at line 864 of file hello.c.

References GNUNET_OK, and GNUNET_TIME_absolute_max().

Referenced by GNUNET_HELLO_get_last_expiration().

867 {
868  struct GNUNET_TIME_Absolute *max = cls;
869 
870  *max = GNUNET_TIME_absolute_max(*max, expiration);
871  return GNUNET_OK;
872 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_max(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the maximum of two absolute time values.
Definition: time.c:317
Time for absolute times used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller 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 differenciated 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
clsthe struct GNUNET_HELLO_ComposeUriContext
addressaddress to add
expirationexpiration time for the address
Returns
GNUNET_OK (continue iteration).

Definition at line 949 of file hello.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_HELLO_Address::address, GNUNET_HELLO_Address::address_length, GNUNET_TRANSPORT_PluginFunctions::address_to_string, GNUNET_TRANSPORT_PluginFunctions::cls, ctx, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_URI_SEP, GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_strdup, GNUNET_HELLO_ComposeUriContext::plugins_find, ret, t, GNUNET_HELLO_Address::transport_name, and GNUNET_HELLO_ComposeUriContext::uri.

Referenced by GNUNET_HELLO_compose_uri().

952 {
953  struct GNUNET_HELLO_ComposeUriContext *ctx = cls;
955  const char *addr;
956  char *ret;
957  char *addr_dup;
958  char *pos;
959  char tbuf[16] = "";
960  char *client_str = "_client";
961  struct tm *t;
962  time_t seconds;
963 
964  papi = ctx->plugins_find(address->transport_name);
965  if (NULL == papi)
966  {
967  /* Not an error - we might just not have the right plugin. */
968  return GNUNET_OK;
969  }
970  if (NULL == papi->address_to_string)
971  {
973  "URI conversion not implemented for plugin `%s'\n",
974  address->transport_name);
975  return GNUNET_OK;
976  }
977  addr = papi->address_to_string(papi->cls,
978  address->address,
979  address->address_length);
980  if ((NULL == addr) ||
981  (0 == strlen(addr)))
982  return GNUNET_OK;
983 
984  addr_dup = GNUNET_strdup(addr);
985  if (NULL != (pos = strstr(addr_dup, "_server")))
986  GNUNET_memcpy(pos,
987  client_str,
988  strlen(client_str)); /* Replace all server addresses with client addresses */
989 
990  seconds = expiration.abs_value_us / 1000LL / 1000LL;
991  t = gmtime(&seconds);
992 
993  GNUNET_asprintf(&ret,
994  "%s%c%s%c%s%c%s",
995  ctx->uri,
997  strftime(tbuf,
998  sizeof(tbuf),
999  "%Y%m%d%H%M%S",
1000  t) ? tbuf : "0",
1002  address->transport_name,
1004  addr_dup);
1005  GNUNET_free(addr_dup);
1006  GNUNET_free(ctx->uri);
1007  ctx->uri = ret;
1008  return GNUNET_OK;
1009 }
size_t address_length
Number of bytes in address.
GNUNET_TRANSPORT_AddressToString address_to_string
Function that will be called to convert a binary address to a string (numeric conversion only)...
const void * address
Binary representation of the address (plugin-specific).
#define GNUNET_HELLO_URI_SEP
Separator used in HELLO URI.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_SCHEDULER_Task * t
Main task.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
uint64_t abs_value_us
The actual value.
char * uri
Final URI.
Definition: hello.c:40
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
GNUNET_HELLO_TransportPluginsFind plugins_find
Function for finding transport plugins by name.
Definition: hello.c:45
void * cls
Closure for all of the callbacks.
const char * transport_name
Name of the transport plugin enabling the communication using this address.
#define GNUNET_log(kind,...)
Context used for building our own URI.
Definition: hello.c:36
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe struct GNUNET_HELLO_ParseUriContext
maxnumber of bytes available for HELLO construction
bufferwhere to copy the next address (in binary format)
Returns
number of bytes added to buffer, GNUNET_SYSERR on error

Definition at line 1056 of file hello.c.

References _, GNUNET_TIME_Absolute::abs_value_us, GNUNET_HELLO_Address::address, address, GNUNET_HELLO_Address::address_length, GNUNET_TRANSPORT_PluginFunctions::cls, GNUNET_HELLO_ParseUriContext::counter_added, GNUNET_HELLO_ParseUriContext::counter_total, ctx, end, 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, plugin_name, GNUNET_HELLO_ParseUriContext::plugins_find, GNUNET_HELLO_ParseUriContext::pos, GNUNET_HELLO_ParseUriContext::ret, ret, GNUNET_TRANSPORT_PluginFunctions::string_to_address, and GNUNET_HELLO_Address::transport_name.

Referenced by GNUNET_HELLO_parse_uri().

1059 {
1060  struct GNUNET_HELLO_ParseUriContext *ctx = cls;
1061  const char *tname;
1062  const char *address;
1063  char *uri_address;
1064  const char *end;
1065  char *plugin_name;
1066  struct tm expiration_time;
1067  time_t expiration_seconds;
1069  struct GNUNET_TRANSPORT_PluginFunctions *papi;
1070  void *addr;
1071  size_t addr_len;
1072  struct GNUNET_HELLO_Address haddr;
1073  ssize_t ret;
1074 
1075  if (NULL == ctx->pos)
1076  return GNUNET_SYSERR;
1077  if (GNUNET_HELLO_URI_SEP != ctx->pos[0])
1078  {
1079  ctx->ret = GNUNET_SYSERR;
1080  GNUNET_break(0);
1081  return GNUNET_SYSERR;
1082  }
1083  ctx->pos++;
1084 
1085  if (('0' == ctx->pos[0]) &&
1086  (GNUNET_HELLO_URI_SEP == ctx->pos[1]))
1087  {
1089  tname = ctx->pos + 1;
1090  }
1091  else
1092  {
1093  memset(&expiration_time, 0, sizeof(expiration_time));
1094  tname = strptime(ctx->pos,
1095  "%Y%m%d%H%M%S",
1096  &expiration_time);
1097  if (NULL == tname)
1098  {
1099  ctx->ret = GNUNET_SYSERR;
1101  _("Failed to parse HELLO message: missing expiration time\n"));
1102  GNUNET_break(0);
1103  return GNUNET_SYSERR;
1104  }
1105 
1106  expiration_seconds = mktime(&expiration_time);
1107  if (expiration_seconds == (time_t)-1)
1108  {
1110  _("Failed to parse HELLO message: invalid expiration time\n"));
1111  ctx->ret = GNUNET_SYSERR;
1112  GNUNET_break(0);
1113  return GNUNET_SYSERR;
1114  }
1115  expire.abs_value_us = expiration_seconds * 1000LL * 1000LL;
1116  }
1117  if (GNUNET_HELLO_URI_SEP != tname[0])
1118  {
1120  _("Failed to parse HELLO message: malformed\n"));
1121  ctx->ret = GNUNET_SYSERR;
1122  GNUNET_break(0);
1123  return GNUNET_SYSERR;
1124  }
1125  tname++;
1126  address = strchr(tname,
1127  (int)GNUNET_HELLO_URI_SEP);
1128  if (NULL == address)
1129  {
1131  _("Failed to parse HELLO message: missing transport plugin\n"));
1132  ctx->ret = GNUNET_SYSERR;
1133  GNUNET_break(0);
1134  return GNUNET_SYSERR;
1135  }
1136  address++;
1137  end = strchr(address, (int)GNUNET_HELLO_URI_SEP);
1138  ctx->pos = end;
1139  ctx->counter_total++;
1140  plugin_name = GNUNET_strndup(tname, address - (tname + 1));
1141  papi = ctx->plugins_find(plugin_name);
1142  if (NULL == papi)
1143  {
1144  /* Not an error - we might just not have the right plugin.
1145  * Skip this part, advance to the next one and recurse.
1146  * But only if this is not the end of string.
1147  */
1149  _("Plugin `%s' not found, skipping address\n"),
1150  plugin_name);
1151  GNUNET_free(plugin_name);
1152  return 0;
1153  }
1154  if (NULL == papi->string_to_address)
1155  {
1157  _("Plugin `%s' does not support URIs yet\n"),
1158  plugin_name);
1159  GNUNET_free(plugin_name);
1160  GNUNET_break(0);
1161  return 0;
1162  }
1163  uri_address = GNUNET_strndup(address, end - address);
1164  if (GNUNET_OK !=
1165  papi->string_to_address(papi->cls,
1166  uri_address,
1167  strlen(uri_address) + 1,
1168  &addr,
1169  &addr_len))
1170  {
1172  _("Failed to parse `%s' as an address for plugin `%s'\n"),
1173  uri_address,
1174  plugin_name);
1175  GNUNET_free(plugin_name);
1176  GNUNET_free(uri_address);
1177  return 0;
1178  }
1179  GNUNET_free(uri_address);
1180  /* address.peer is unset - not used by add_address() */
1181  haddr.address_length = addr_len;
1182  haddr.address = addr;
1183  haddr.transport_name = plugin_name;
1184  ret = GNUNET_HELLO_add_address(&haddr,
1185  expire,
1186  buffer,
1187  max);
1188  ctx->counter_added++;
1189  GNUNET_free(addr);
1190  GNUNET_free(plugin_name);
1191  return ret;
1192 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
#define GNUNET_HELLO_URI_SEP
Separator used in HELLO URI.
static void expire(void *cls)
Expire a PooledConnection object.
const char * pos
Position in the URI with the next address to parse.
Definition: hello.c:56
int ret
Set to GNUNET_SYSERR to indicate parse errors.
Definition: hello.c:61
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
Context for add_address_to_hello().
Definition: hello.c:52
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
void * cls
Closure for all of the callbacks.
GNUNET_TRANSPORT_StringToAddress string_to_address
Function that will be called to convert a string address to binary (numeric conversion only)...
static char * plugin_name
Solver plugin name as string.
unsigned int counter_added
Counter skipped addresses.
Definition: hello.c:71
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.
Definition: hello.c:107
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
An address for communicating with a peer.
#define GNUNET_log(kind,...)
Time for absolute times used by GNUnet, in microseconds.
GNUNET_HELLO_TransportPluginsFind plugins_find
Function for finding transport plugins by name.
Definition: hello.c:76
unsigned int counter_total
Counter.
Definition: hello.c:66
static char * address
GNS address for this phone.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function: