[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r36437 - in gnunet/src: hello include peerinfo
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r36437 - in gnunet/src: hello include peerinfo |
|
Date: |
Sat, 3 Oct 2015 22:12:09 +0200 |
Author: grothoff
Date: 2015-10-03 22:12:09 +0200 (Sat, 03 Oct 2015)
New Revision: 36437
Modified:
gnunet/src/hello/gnunet-hello.c
gnunet/src/hello/hello.c
gnunet/src/hello/test_friend_hello.c
gnunet/src/hello/test_hello.c
gnunet/src/include/gnunet_hello_lib.h
gnunet/src/peerinfo/gnunet-service-peerinfo.c
Log:
improving comments and coding style for libgnunethello library
Modified: gnunet/src/hello/gnunet-hello.c
===================================================================
--- gnunet/src/hello/gnunet-hello.c 2015-10-03 16:50:24 UTC (rev 36436)
+++ gnunet/src/hello/gnunet-hello.c 2015-10-03 20:12:09 UTC (rev 36437)
@@ -114,7 +114,7 @@
struct GNUNET_DISK_FileHandle *fh;
struct GNUNET_HELLO_Message *orig;
struct GNUNET_HELLO_Message *result;
- struct GNUNET_CRYPTO_EddsaPublicKey pk;
+ struct GNUNET_PeerIdentity pid;
uint64_t fsize;
address_count = 0;
@@ -167,7 +167,8 @@
GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
orig = (struct GNUNET_HELLO_Message *) buf;
if ( (fsize != GNUNET_HELLO_size (orig)) ||
- (GNUNET_OK != GNUNET_HELLO_get_key (orig, &pk)) )
+ (GNUNET_OK != GNUNET_HELLO_get_id (orig,
+ &pid)) )
{
FPRINTF (stderr,
_("Did not find well-formed HELLO in file `%s'\n"),
@@ -175,15 +176,16 @@
return 1;
}
{
- char *pid;
+ char *pids;
- pid = GNUNET_CRYPTO_eddsa_public_key_to_string (&pk);
+ pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid.public_key);
fprintf (stdout,
"Processing HELLO for peer `%s'\n",
- pid);
- GNUNET_free (pid);
+ pids);
+ GNUNET_free (pids);
}
- result = GNUNET_HELLO_create (&pk, &add_from_hello,
+ result = GNUNET_HELLO_create (&pid.public_key,
+ &add_from_hello,
&orig,
GNUNET_HELLO_is_friend_only (orig));
GNUNET_assert (NULL != result);
Modified: gnunet/src/hello/hello.c
===================================================================
--- gnunet/src/hello/hello.c 2015-10-03 16:50:24 UTC (rev 36436)
+++ gnunet/src/hello/hello.c 2015-10-03 20:12:09 UTC (rev 36437)
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2009 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009, 2015 Christian Grothoff (and other contributing
authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -108,7 +108,6 @@
*/
unsigned int counter_added;
-
/**
* Function for finding transport plugins by name.
*/
@@ -120,13 +119,13 @@
* Return HELLO type
*
* @param h HELLO Message to test
- * @return #GNUNET_YES or #GNUNET_NO
+ * @return #GNUNET_YES for friend-only or #GNUNET_NO otherwise
*/
int
GNUNET_HELLO_is_friend_only (const struct GNUNET_HELLO_Message *h)
{
if (GNUNET_YES == ntohl(h->friend_only))
- return GNUNET_YES;
+ return GNUNET_YES;
return GNUNET_NO;
}
@@ -173,9 +172,9 @@
* Get the size of an address entry in a HELLO message.
*
* @param buf pointer to the start of the address entry
- * @param max maximum size of the entry (end of buf)
+ * @param max maximum size of the entry (end of @a buf)
* @param ralen set to the address length
- * @return size of the entry, or 0 if max is not large enough
+ * @return size of the entry, or 0 if @a max is not large enough
*/
static size_t
get_hello_address_size (const char *buf,
@@ -228,10 +227,17 @@
* 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.
+ *
+ * @param public_key public key to include in the HELLO
+ * @param addrgen callback to invoke to get addresses
+ * @param addrgen_cls closure for @a addrgen
+ * @param friend_only should the returned HELLO be only visible to friends?
* @return the hello message
*/
struct GNUNET_HELLO_Message *
-GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EddsaPublicKey *publicKey,
+GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EddsaPublicKey *public_key,
GNUNET_HELLO_GenerateAddressListCallback addrgen,
void *addrgen_cls,
int friend_only)
@@ -243,14 +249,16 @@
size_t ret;
struct GNUNET_HELLO_Message *hello;
- GNUNET_assert (NULL != publicKey);
- GNUNET_assert ((GNUNET_YES == friend_only) || (GNUNET_NO == friend_only));
-
+ GNUNET_assert (NULL != public_key);
+ GNUNET_assert ( (GNUNET_YES == friend_only) ||
+ (GNUNET_NO == friend_only) );
max = sizeof (buffer);
used = 0;
- if (addrgen != NULL)
+ if (NULL != addrgen)
{
- while (GNUNET_SYSERR != (ret = addrgen (addrgen_cls, max, &buffer[used])))
+ while (GNUNET_SYSERR != (ret = addrgen (addrgen_cls,
+ max,
+ &buffer[used])))
{
max -= ret;
used += ret;
@@ -260,10 +268,10 @@
hello->header.type = htons (GNUNET_MESSAGE_TYPE_HELLO);
hello->header.size = htons (sizeof (struct GNUNET_HELLO_Message) + used);
hello->friend_only = htonl (friend_only);
-
- memcpy (&hello->publicKey, publicKey,
- sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
- memcpy (&hello[1], buffer, used);
+ hello->publicKey = *public_key;
+ memcpy (&hello[1],
+ buffer,
+ used);
return hello;
}
@@ -304,16 +312,20 @@
if (return_modified)
{
ret = GNUNET_malloc (msize);
- memcpy (ret, msg, msize);
+ memcpy (ret,
+ msg,
+ msize);
}
inptr = (const char *) &msg[1];
insize = msize - sizeof (struct GNUNET_HELLO_Message);
wpos = 0;
- woff = (ret != NULL) ? (char *) &ret[1] : NULL;
+ woff = (NULL != ret) ? (char *) &ret[1] : NULL;
address.peer.public_key = msg->publicKey;
while (insize > 0)
{
- esize = get_hello_address_size (inptr, insize, &alen);
+ esize = get_hello_address_size (inptr,
+ insize,
+ &alen);
if (0 == esize)
{
GNUNET_break (0);
@@ -320,6 +332,7 @@
GNUNET_free_non_null (ret);
return NULL;
}
+ /* need memcpy() due to possibility of misalignment */
memcpy (&expire,
&inptr[esize - alen - sizeof (struct GNUNET_TIME_AbsoluteNBO)],
sizeof (struct GNUNET_TIME_AbsoluteNBO));
@@ -327,16 +340,18 @@
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 (iret == GNUNET_SYSERR)
+ iret = it (it_cls,
+ &address,
+ GNUNET_TIME_absolute_ntoh (expire));
+ if (GNUNET_SYSERR == iret)
+ break;
+ if ( (GNUNET_OK == iret) &&
+ (NULL != ret) )
{
- if (ret != NULL)
- ret->header.size = ntohs (sizeof (struct GNUNET_HELLO_Message) + wpos);
- return ret;
- }
- if ((iret == GNUNET_OK) && (ret != NULL))
- {
- memcpy (woff, inptr, esize);
+ /* copy address over */
+ memcpy (woff,
+ inptr,
+ esize);
woff += esize;
wpos += esize;
}
@@ -343,7 +358,7 @@
insize -= esize;
inptr += esize;
}
- if (ret != NULL)
+ if (NULL != ret)
ret->header.size = ntohs (sizeof (struct GNUNET_HELLO_Message) + wpos);
return ret;
}
@@ -386,53 +401,56 @@
{
struct ExpireContext *ec = cls;
- if (0 == GNUNET_HELLO_address_cmp (address, ec->address))
- {
- ec->found = GNUNET_YES;
- ec->expiration = expiration;
- return GNUNET_SYSERR; /* done here */
- }
- return GNUNET_OK;
+ if (0 != GNUNET_HELLO_address_cmp (address,
+ ec->address))
+ return GNUNET_OK;
+ ec->found = GNUNET_YES;
+ ec->expiration = expiration;
+ return GNUNET_SYSERR; /* done here */
}
/**
- *
+ * Context for a #GNUNET_HELLO_Merge operation.
*/
struct MergeContext
{
/**
- *
+ * First HELLO we are merging.
*/
const struct GNUNET_HELLO_Message *h1;
/**
- *
+ * Second HELLO we are merging.
*/
const struct GNUNET_HELLO_Message *h2;
/**
- *
+ * Either @e h1 or @e h2, used when copying
+ * to compare against (so we only copy the
+ * most recent entry).
*/
const struct GNUNET_HELLO_Message *other;
/**
- *
+ * Buffer where we copy to.
*/
char *buf;
/**
- *
+ * Number of bytes allocated in @e buf
*/
size_t max;
/**
- *
+ * Current (write) offset in @e buf.
*/
size_t ret;
/**
- *
+ * Should we copy addresses with an identical value
+ * and expiration time in @e other, or do we only
+ * copy addresses with strictly later expiration times?
*/
int take_equal;
@@ -440,12 +458,14 @@
/**
+ * Append the address @a address to the buffer from
+ * the merge context IF it is more recent than equivalent
+ * addresses in `other`.
*
- *
- * @param cls
- * @param address
- * @param expiration
- * @return
+ * @param cls the `struct MergeContext`
+ * @param address the HELLO address we might copy
+ * @param expiration expiration time for @a address
+ * @return always #GNUNET_OK
*/
static int
copy_latest (void *cls,
@@ -457,14 +477,21 @@
ec.address = address;
ec.found = GNUNET_NO;
- GNUNET_HELLO_iterate_addresses (mc->other, GNUNET_NO, &get_match_exp, &ec);
- if ((ec.found == GNUNET_NO) ||
- (ec.expiration.abs_value_us < expiration.abs_value_us) ||
- ((ec.expiration.abs_value_us == expiration.abs_value_us) &&
- (mc->take_equal == GNUNET_YES)))
+ /* 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],
+ GNUNET_HELLO_add_address (address,
+ expiration,
+ &mc->buf[mc->ret],
mc->max - mc->ret);
}
return GNUNET_OK;
@@ -472,7 +499,14 @@
/**
+ * Function called to build the HELLO during
+ * #GNUNET_HELLO_merge() by merging addresses from
+ * two original HELLOs.
*
+ * @param cls the `struct MergeContext`
+ * @param max number of bytes we can write at most in @a buf
+ * @param buf where to copy the addresses
+ * @return #GNUNET_SYSERR to end iteration, otherwise number of bytes written
to @a buf
*/
static ssize_t
merge_addr (void *cls,
@@ -481,7 +515,7 @@
{
struct MergeContext *mc = cls;
- if (mc->h1 == NULL)
+ if (NULL == mc->h1)
return GNUNET_SYSERR; /* Stop iteration */
mc->ret = 0;
mc->max = max;
@@ -488,10 +522,19 @@
mc->buf = buf;
mc->take_equal = GNUNET_NO;
mc->other = mc->h2;
- GNUNET_HELLO_iterate_addresses (mc->h1, GNUNET_NO, ©_latest, mc);
+ /* copy addresses from h1, if strictly larger expiration than h2 */
+ GNUNET_HELLO_iterate_addresses (mc->h1,
+ GNUNET_NO,
+ ©_latest,
+ mc);
mc->take_equal = GNUNET_YES;
mc->other = mc->h1;
- GNUNET_HELLO_iterate_addresses (mc->h2, GNUNET_NO, ©_latest, mc);
+ /* copy addresses from h2, if larger or equal expiration than h1 */
+ GNUNET_HELLO_iterate_addresses (mc->h2,
+ GNUNET_NO,
+ ©_latest,
+ mc);
+ /* set marker to stop iteration */
mc->h1 = NULL;
return mc->ret;
}
@@ -504,7 +547,7 @@
*
* @param h1 first HELLO message
* @param h2 the second HELLO message
- * @return the combined hello message
+ * @return the combined HELLO message
*/
struct GNUNET_HELLO_Message *
GNUNET_HELLO_merge (const struct GNUNET_HELLO_Message *h1,
@@ -526,17 +569,18 @@
/**
- *
+ * Context used in #GNUNET_HELLO_iterate_new_addresses() to
+ * figure out which addresses are in fact 'new'.
*/
struct DeltaContext
{
/**
- *
+ * We should ignore addresses that expire before this time.
*/
struct GNUNET_TIME_Absolute expiration_limit;
/**
- *
+ * Function to call on addresses that are indeed new.
*/
GNUNET_HELLO_AddressIterator it;
@@ -546,7 +590,8 @@
void *it_cls;
/**
- *
+ * HELLO with known addresses, addresses in this HELLO
+ * we must always ignore.
*/
const struct GNUNET_HELLO_Message *old_hello;
};
@@ -553,7 +598,16 @@
/**
+ * 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).
*
+ * @param cls the `struct DeltaContext`
+ * @param address an address to check whether it is new
+ * @param expiration expiration time for @a address
+ * @return #GNUNET_YES if the address is ignored, otherwise
+ * whatever the iterator returned.
*/
static int
delta_match (void *cls,
@@ -570,22 +624,26 @@
GNUNET_NO,
&get_match_exp,
&ec);
- if ((ec.found == GNUNET_YES) &&
- ((ec.expiration.abs_value_us > expiration.abs_value_us) ||
- (ec.expiration.abs_value_us >= dc->expiration_limit.abs_value_us)))
- return GNUNET_YES; /* skip */
- ret = dc->it (dc->it_cls, address, expiration);
+ 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;
}
/**
- * Iterate over addresses in "new_hello" that
- * are NOT already present in "old_hello".
+ * Iterate over addresses in @a new_hello that are NOT already present
+ * in @a old_hello. Note that if the address is present in @a old_hello
+ * but the expiration time in @a new_hello is more recent, the iterator
+ * is also called.
*
* @param new_hello a HELLO message
* @param old_hello a HELLO message
- * @param expiration_limit ignore addresses in old_hello
+ * @param expiration_limit ignore addresses in @a old_hello
* that expired before the given time stamp
* @param it iterator to call on each address
* @param it_cls closure for @a it
@@ -603,7 +661,11 @@
dc.it = it;
dc.it_cls = it_cls;
dc.old_hello = old_hello;
- GNUNET_HELLO_iterate_addresses (new_hello, GNUNET_NO, &delta_match, &dc);
+ GNUNET_assert (NULL ==
+ GNUNET_HELLO_iterate_addresses (new_hello,
+ GNUNET_NO,
+ &delta_match,
+ &dc));
}
@@ -625,27 +687,6 @@
/**
- * Get the public key from a HELLO message.
- *
- * @param hello the hello message
- * @param publicKey where to copy the public key information, can be NULL
- * @return #GNUNET_SYSERR if the HELLO was malformed
- */
-int
-GNUNET_HELLO_get_key (const struct GNUNET_HELLO_Message *hello,
- struct GNUNET_CRYPTO_EddsaPublicKey *publicKey)
-{
- 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;
- *publicKey = hello->publicKey;
- return GNUNET_OK;
-}
-
-
-/**
* Get the peer identity from a HELLO message.
*
* @param hello the hello message
@@ -688,37 +729,41 @@
/**
- *
+ * Context used for comparing HELLOs in #GNUNET_HELLO_equals().
*/
struct EqualsContext
{
/**
- *
+ * Addresses that expired before this date are ignored for
+ * the comparisson.
*/
struct GNUNET_TIME_Absolute expiration_limit;
/**
- *
+ * Earliest expiration time for which we found a match
+ * with a difference in expiration times.
+ * At this time, the two HELLOs may start to diverge.
*/
struct GNUNET_TIME_Absolute result;
/**
- *
+ * HELLO message to compare against. (First set to the second
+ * HELLO, then set to the first HELLO.)
*/
- const struct GNUNET_HELLO_Message *h2;
+ const struct GNUNET_HELLO_Message *ref;
/**
- *
+ * Address we are currently looking for.
*/
const struct GNUNET_HELLO_Address *address;
/**
- *
+ * Expiration time of @e address.
*/
struct GNUNET_TIME_Absolute expiration;
/**
- *
+ * Did we find the address we were looking for?
*/
int found;
@@ -726,7 +771,16 @@
/**
+ * 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 @a expiration and the existing value
*
+ * @param cls the `struct EqualsContext`
+ * @param address address from the reference HELLO
+ * @param expiration expiration time for @a address
+ * @return #GNUNET_YES if the address is expired or does not match
+ * #GNUNET_SYSERR if the address does match.
*/
static int
find_other_matching (void *cls,
@@ -741,7 +795,8 @@
{
ec->found = GNUNET_YES;
if (expiration.abs_value_us < ec->expiration.abs_value_us)
- ec->result = GNUNET_TIME_absolute_min (expiration, ec->result);
+ ec->result = GNUNET_TIME_absolute_min (expiration,
+ ec->result);
return GNUNET_SYSERR;
}
return GNUNET_YES;
@@ -749,7 +804,16 @@
/**
+ * Helper function for #GNUNET_HELLO_equals(). Checks
+ * if the given @a address exists also in the other HELLO;
+ * if not, the result time is set to zero and the iteration
+ * is aborted.
*
+ * @param cls the `struct EqualsContext`
+ * @param address address to locate
+ * @param expiration expiration time of the current address
+ * @return #GNUNET_OK if the address exists or is expired,
+ * #GNUNET_SYSERR if it was not found
*/
static int
find_matching (void *cls,
@@ -759,13 +823,17 @@
struct EqualsContext *ec = cls;
if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
- return GNUNET_YES;
+ return GNUNET_OK; /* expired, we don't care */
ec->address = address;
ec->expiration = expiration;
ec->found = GNUNET_NO;
- GNUNET_HELLO_iterate_addresses (ec->h2, GNUNET_NO, &find_other_matching, ec);
- if (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;
}
@@ -776,7 +844,7 @@
/**
* 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
+ * expiration time larger than @a now where they differ
* is returned.
*
* @param h1 first HELLO message
@@ -784,9 +852,9 @@
* @param now time to use for deciding which addresses have
* expired and should not be considered at all
* @return absolute time forever if the two HELLOs are
- * totally identical; smallest timestamp >= now if
+ * totally identical; smallest timestamp >= @a now if
* they only differ in timestamps;
- * zero if the some addresses with expirations >= now
+ * zero if the some addresses with expirations >= @a now
* do not match at all
*/
struct GNUNET_TIME_Absolute
@@ -797,15 +865,15 @@
struct EqualsContext ec;
if (h1->header.type != h2->header.type)
- return GNUNET_TIME_UNIT_ZERO_ABS;
-
+ return GNUNET_TIME_UNIT_ZERO_ABS;
if (0 !=
- memcmp (&h1->publicKey, &h2->publicKey,
+ memcmp (&h1->publicKey,
+ &h2->publicKey,
sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)))
return GNUNET_TIME_UNIT_ZERO_ABS;
ec.expiration_limit = now;
ec.result = GNUNET_TIME_UNIT_FOREVER_ABS;
- ec.h2 = h2;
+ ec.ref = h2;
GNUNET_HELLO_iterate_addresses (h1,
GNUNET_NO,
&find_matching,
@@ -812,7 +880,7 @@
&ec);
if (ec.result.abs_value_us == GNUNET_TIME_UNIT_ZERO.rel_value_us)
return ec.result;
- ec.h2 = h1;
+ ec.ref = h1;
GNUNET_HELLO_iterate_addresses (h2,
GNUNET_NO,
&find_matching,
@@ -822,7 +890,13 @@
/**
+ * Iterator to find the time when the last address will expire.
+ * Updates the maximum value stored in @a cls.
*
+ * @param cls where to store the max, a `struct GNUNET_TIME_Absolute`
+ * @param address an address (ignored)
+ * @param expiration expiration time for @a address
+ * @return #GNUNET_OK (always)
*/
static int
find_max_expire (void *cls,
@@ -847,7 +921,7 @@
{
struct GNUNET_TIME_Absolute ret;
- ret.abs_value_us = 0;
+ ret = GNUNET_TIME_UNIT_ZERO_ABS;
GNUNET_HELLO_iterate_addresses (msg,
GNUNET_NO,
&find_max_expire,
@@ -954,7 +1028,10 @@
"%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",
+ strftime (tbuf,
+ sizeof (tbuf),
+ "%Y%m%d%H%M%S",
+ t) ? tbuf : "0",
GNUNET_HELLO_URI_SEP,
address->transport_name,
GNUNET_HELLO_URI_SEP,
@@ -1006,7 +1083,9 @@
* @return number of bytes added to buffer, #GNUNET_SYSERR on error
*/
static ssize_t
-add_address_to_hello (void *cls, size_t max, void *buffer)
+add_address_to_hello (void *cls,
+ size_t max,
+ void *buffer)
{
struct GNUNET_HELLO_ParseUriContext *ctx = cls;
const char *tname;
@@ -1033,7 +1112,8 @@
}
ctx->pos++;
- if ('0' == ctx->pos[0] && GNUNET_HELLO_URI_SEP == ctx->pos[1])
+ if ( ('0' == ctx->pos[0]) &&
+ (GNUNET_HELLO_URI_SEP == ctx->pos[1]) )
{
expire = GNUNET_TIME_UNIT_FOREVER_ABS;
tname = ctx->pos + 1;
@@ -1162,18 +1242,18 @@
GNUNET_HELLO_URI_PREFIX,
strlen (GNUNET_HELLO_URI_PREFIX)))
{
- pks = &uri[strlen (GNUNET_HELLO_URI_PREFIX)];
- friend_only = GNUNET_NO;
+ 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;
+ pks = &uri[strlen (GNUNET_FRIEND_HELLO_URI_PREFIX)];
+ friend_only = GNUNET_YES;
}
else
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
exc = strchr (pks, GNUNET_HELLO_URI_SEP);
if (GNUNET_OK !=
@@ -1188,11 +1268,15 @@
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);
+ *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);
+ "HELLO URI contained %u addresses, added %u addresses\n",
+ ctx.counter_total,
+ ctx.counter_added);
return ctx.ret;
}
Modified: gnunet/src/hello/test_friend_hello.c
===================================================================
--- gnunet/src/hello/test_friend_hello.c 2015-10-03 16:50:24 UTC (rev
36436)
+++ gnunet/src/hello/test_friend_hello.c 2015-10-03 20:12:09 UTC (rev
36437)
@@ -18,7 +18,7 @@
Boston, MA 02110-1301, USA.
*/
/**
- * @file hello/test_hello.c
+ * @file hello/test_friend_hello.c
* @brief test for hello.c
* @author Christian Grothoff
*/
@@ -25,8 +25,11 @@
#include "platform.h"
#include "gnunet_hello_lib.h"
+
static ssize_t
-my_addr_gen (void *cls, size_t max, void *buf)
+my_addr_gen (void *cls,
+ size_t max,
+ void *buf)
{
unsigned int *i = cls;
size_t ret;
@@ -49,7 +52,8 @@
static int
-check_addr (void *cls, const struct GNUNET_HELLO_Address *address,
+check_addr (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
unsigned int *i = cls;
@@ -69,7 +73,8 @@
static int
-remove_some (void *cls, const struct GNUNET_HELLO_Address *address,
+remove_some (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
unsigned int *i = cls;
@@ -94,7 +99,6 @@
struct GNUNET_HELLO_Message *msg2;
struct GNUNET_HELLO_Message *msg3;
struct GNUNET_CRYPTO_EddsaPublicKey publicKey;
- struct GNUNET_CRYPTO_EddsaPublicKey pk;
struct GNUNET_TIME_Absolute startup_time;
unsigned int i;
@@ -127,11 +131,6 @@
GNUNET_HELLO_iterate_addresses (msg2, GNUNET_NO, &check_addr,
&i));
GNUNET_assert (i == 0);
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Testing get_key from HELLO...\n");
- GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_key (msg2, &pk));
- GNUNET_assert (0 == memcmp (&publicKey, &pk, sizeof (pk)));
GNUNET_free (msg1);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
Modified: gnunet/src/hello/test_hello.c
===================================================================
--- gnunet/src/hello/test_hello.c 2015-10-03 16:50:24 UTC (rev 36436)
+++ gnunet/src/hello/test_hello.c 2015-10-03 20:12:09 UTC (rev 36437)
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet
- Copyright (C) 2009 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009, 2015 Christian Grothoff (and other contributing
authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -25,8 +25,19 @@
#include "platform.h"
#include "gnunet_hello_lib.h"
+
+/**
+ *
+ *
+ * @param cls
+ * @param max
+ * @param buf
+ * @return
+ */
static ssize_t
-my_addr_gen (void *cls, size_t max, void *buf)
+my_addr_gen (void *cls,
+ size_t max,
+ void *buf)
{
unsigned int *i = cls;
size_t ret;
@@ -33,7 +44,8 @@
struct GNUNET_HELLO_Address address;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "DEBUG: my_addr_gen called with i = %d\n", *i);
+ "DEBUG: my_addr_gen called with i = %d\n",
+ *i);
if (0 == *i)
return GNUNET_SYSERR;
memset (&address.peer, 0, sizeof (struct GNUNET_PeerIdentity));
@@ -40,36 +52,58 @@
address.address = "address_information";
address.transport_name = "test";
address.address_length = *i;
- ret =
- GNUNET_HELLO_add_address (&address, GNUNET_TIME_absolute_get (), buf,
- max);
+ ret = GNUNET_HELLO_add_address (&address,
+ GNUNET_TIME_absolute_get (),
+ buf,
+ max);
(*i)--;
return ret;
}
+/**
+ *
+ *
+ * @param cls
+ * @param address
+ * @param expiration
+ * @return
+ */
static int
-check_addr (void *cls, const struct GNUNET_HELLO_Address *address,
+check_addr (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
unsigned int *i = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "DEBUG: check_addr called with i = %d and addrlen = %u\n",
- *i, (unsigned int) address->address_length);
+ "DEBUG: check_addr called with i = %d and addrlen = %u\n",
+ *i,
+ (unsigned int) address->address_length);
GNUNET_assert (address->address_length > 0);
GNUNET_assert (*i & (1 << (address->address_length - 1)));
*i -= (1 << (address->address_length - 1));
GNUNET_assert (0 ==
- strncmp ("address_information", address->address,
+ strncmp ("address_information",
+ address->address,
address->address_length));
- GNUNET_assert (0 == strcmp ("test", address->transport_name));
+ GNUNET_assert (0 == strcmp ("test",
+ address->transport_name));
return GNUNET_OK;
}
+/**
+ *
+ *
+ * @param cls
+ * @param address
+ * @param expiration
+ * @return
+ */
static int
-remove_some (void *cls, const struct GNUNET_HELLO_Address *address,
+remove_some (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
unsigned int *i = cls;
@@ -76,7 +110,8 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"DEBUG: remove_some called with i = %d and addrlen = %u\n",
- *i, (unsigned int) address->address_length);
+ *i,
+ (unsigned int) address->address_length);
GNUNET_assert (address->address_length > 0);
if (*i & (1 << (address->address_length - 1)))
{
@@ -88,23 +123,29 @@
int
-main (int argc, char *argv[])
+main (int argc,
+ char *argv[])
{
struct GNUNET_HELLO_Message *msg1;
struct GNUNET_HELLO_Message *msg2;
struct GNUNET_HELLO_Message *msg3;
struct GNUNET_CRYPTO_EddsaPublicKey publicKey;
- struct GNUNET_CRYPTO_EddsaPublicKey pk;
+ struct GNUNET_PeerIdentity pid;
struct GNUNET_TIME_Absolute startup_time;
unsigned int i;
- GNUNET_log_setup ("test-hello", "DEBUG", NULL);
+ GNUNET_log_setup ("test-hello",
+ "DEBUG",
+ NULL);
startup_time = GNUNET_TIME_absolute_get ();
memset (&publicKey, 42, sizeof (publicKey));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing HELLO creation (without addresses)...\n");
i = 0;
- msg1 = GNUNET_HELLO_create (&publicKey, &my_addr_gen, &i, GNUNET_NO);
+ msg1 = GNUNET_HELLO_create (&publicKey,
+ &my_addr_gen,
+ &i,
+ GNUNET_NO);
GNUNET_assert (msg1 != NULL);
GNUNET_assert (0 < GNUNET_HELLO_size (msg1));
@@ -111,12 +152,17 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing address iteration (empty set)...\n");
GNUNET_assert (NULL ==
- GNUNET_HELLO_iterate_addresses (msg1, GNUNET_NO, &check_addr,
+ GNUNET_HELLO_iterate_addresses (msg1,
+ GNUNET_NO,
+ &check_addr,
&i));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing HELLO creation (with one address)...\n");
i = 1;
- msg2 = GNUNET_HELLO_create (&publicKey, &my_addr_gen, &i, GNUNET_NO);
+ msg2 = GNUNET_HELLO_create (&publicKey,
+ &my_addr_gen,
+ &i,
+ GNUNET_NO);
GNUNET_assert (msg2 != NULL);
GNUNET_assert (GNUNET_HELLO_size (msg1) < GNUNET_HELLO_size (msg2));
@@ -124,20 +170,27 @@
"Testing address iteration (one address)...\n");
i = 1;
GNUNET_assert (NULL ==
- GNUNET_HELLO_iterate_addresses (msg2, GNUNET_NO, &check_addr,
+ GNUNET_HELLO_iterate_addresses (msg2,
+ GNUNET_NO,
+ &check_addr,
&i));
GNUNET_assert (i == 0);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing get_key from HELLO...\n");
- GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_key (msg2, &pk));
- GNUNET_assert (0 == memcmp (&publicKey, &pk, sizeof (pk)));
+ GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (msg2, &pid));
+ GNUNET_assert (0 == memcmp (&publicKey,
+ &pid.public_key,
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)));
GNUNET_free (msg1);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing HELLO creation (with two addresses)...\n");
i = 2;
- msg3 = GNUNET_HELLO_create (&publicKey, &my_addr_gen, &i, GNUNET_NO);
+ msg3 = GNUNET_HELLO_create (&publicKey,
+ &my_addr_gen,
+ &i,
+ GNUNET_NO);
GNUNET_assert (msg3 != NULL);
GNUNET_assert (GNUNET_HELLO_size (msg2) < GNUNET_HELLO_size (msg3));
@@ -145,7 +198,9 @@
"Testing address iteration (two addresses)...\n");
i = 3;
GNUNET_assert (NULL ==
- GNUNET_HELLO_iterate_addresses (msg3, GNUNET_NO, &check_addr,
+ GNUNET_HELLO_iterate_addresses (msg3,
+ GNUNET_NO,
+ &check_addr,
&i));
GNUNET_assert (i == 0);
@@ -156,7 +211,9 @@
i = 3;
GNUNET_assert (NULL ==
- GNUNET_HELLO_iterate_addresses (msg1, GNUNET_NO, &check_addr,
+ GNUNET_HELLO_iterate_addresses (msg1,
+ GNUNET_NO,
+ &check_addr,
&i));
GNUNET_assert (i == 0);
GNUNET_free (msg1);
@@ -164,12 +221,17 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing address iteration to copy HELLO...\n");
i = 2;
- msg1 = GNUNET_HELLO_iterate_addresses (msg3, GNUNET_YES, &remove_some, &i);
+ msg1 = GNUNET_HELLO_iterate_addresses (msg3,
+ GNUNET_YES,
+ &remove_some,
+ &i);
GNUNET_assert (msg1 != NULL);
GNUNET_assert (i == 0);
i = 1;
GNUNET_assert (NULL ==
- GNUNET_HELLO_iterate_addresses (msg1, GNUNET_NO, &check_addr,
+ GNUNET_HELLO_iterate_addresses (msg1,
+ GNUNET_NO,
+ &check_addr,
&i));
GNUNET_assert (i == 0);
GNUNET_free (msg1);
@@ -177,7 +239,10 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing delta address iteration...\n");
i = 2;
- GNUNET_HELLO_iterate_new_addresses (msg3, msg2, startup_time, &check_addr,
+ GNUNET_HELLO_iterate_new_addresses (msg3,
+ msg2,
+ startup_time,
+ &check_addr,
&i);
GNUNET_assert (i == 0);
GNUNET_free (msg2);
@@ -184,3 +249,5 @@
GNUNET_free (msg3);
return 0; /* testcase passed */
}
+
+/* end of test_hello.c */
Modified: gnunet/src/include/gnunet_hello_lib.h
===================================================================
--- gnunet/src/include/gnunet_hello_lib.h 2015-10-03 16:50:24 UTC (rev
36436)
+++ gnunet/src/include/gnunet_hello_lib.h 2015-10-03 20:12:09 UTC (rev
36437)
@@ -204,7 +204,7 @@
* Return HELLO type
*
* @param h HELLO Message to test
- * @return #GNUNET_YES or #GNUNET_NO
+ * @return #GNUNET_YES for friend-only or #GNUNET_NO otherwise
*/
int
GNUNET_HELLO_is_friend_only (const struct GNUNET_HELLO_Message *h);
@@ -253,7 +253,7 @@
* If friend only is set to #GNUNET_YES we create a FRIEND_HELLO which
* will not be gossiped to other peers.
*
- * @param publicKey public key to include in the HELLO
+ * @param public_key public key to include in the HELLO
* @param addrgen callback to invoke to get addresses
* @param addrgen_cls closure for @a addrgen
* @param friend_only should the returned HELLO be only visible to friends?
@@ -260,7 +260,7 @@
* @return the hello message
*/
struct GNUNET_HELLO_Message *
-GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EddsaPublicKey *publicKey,
+GNUNET_HELLO_create (const struct GNUNET_CRYPTO_EddsaPublicKey *public_key,
GNUNET_HELLO_GenerateAddressListCallback addrgen,
void *addrgen_cls,
int friend_only);
@@ -357,8 +357,10 @@
/**
- * Iterate over addresses in "new_hello" that
- * are NOT already present in "old_hello".
+ * Iterate over addresses in @a new_hello that are NOT already present
+ * in @a old_hello. Note that if the address is present in @a old_hello
+ * but the expiration time in @a new_hello is more recent, the
+ * iterator is also called.
*
* @param new_hello a HELLO message
* @param old_hello a HELLO message
@@ -376,18 +378,6 @@
/**
- * Get the public key from a HELLO message.
- *
- * @param hello the hello message
- * @param publicKey where to copy the public key information, can be NULL
- * @return #GNUNET_SYSERR if the HELLO was malformed
- */
-int
-GNUNET_HELLO_get_key (const struct GNUNET_HELLO_Message *hello,
- struct GNUNET_CRYPTO_EddsaPublicKey *publicKey);
-
-
-/**
* Get the peer identity from a HELLO message.
*
* @param hello the hello message
@@ -412,9 +402,11 @@
/**
- * FIXME.
+ * Helper function to load/access transport plugins.
+ * FIXME: pass closure!
*
- * @param name
+ * @param name name of the transport plugin to load
+ * @return NULL if a plugin with name @a name is not known/loadable
*/
typedef struct GNUNET_TRANSPORT_PluginFunctions *
(*GNUNET_HELLO_TransportPluginsFind) (const char *name);
Modified: gnunet/src/peerinfo/gnunet-service-peerinfo.c
===================================================================
--- gnunet/src/peerinfo/gnunet-service-peerinfo.c 2015-10-03 16:50:24 UTC
(rev 36436)
+++ gnunet/src/peerinfo/gnunet-service-peerinfo.c 2015-10-03 20:12:09 UTC
(rev 36437)
@@ -700,7 +700,7 @@
{
struct GNUNET_HELLO_Message * res;
struct GNUNET_HELLO_Message * tmp;
- struct GNUNET_CRYPTO_EddsaPublicKey pk;
+ struct GNUNET_PeerIdentity pid;
if (NULL != friend_hello)
{
@@ -710,12 +710,15 @@
}
if (GNUNET_OK !=
- GNUNET_HELLO_get_key (hello, &pk))
+ GNUNET_HELLO_get_id (hello, &pid))
{
GNUNET_break (0);
return NULL;
}
- tmp = GNUNET_HELLO_create (&pk, NULL, NULL, GNUNET_YES);
+ tmp = GNUNET_HELLO_create (&pid.public_key,
+ NULL,
+ NULL,
+ GNUNET_YES);
res = GNUNET_HELLO_merge (hello, tmp);
GNUNET_free (tmp);
GNUNET_assert (GNUNET_YES == GNUNET_HELLO_is_friend_only (res));
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r36437 - in gnunet/src: hello include peerinfo,
gnunet <=