+/**
+ * Get the header from a HELLO message, used so other code
+ * can correctly send HELLO messages.
+ *
+ * @param hello the hello message
+ *
+ * @return header or NULL if the HELLO was malformed
+ */
+struct GNUNET_MessageHeader *
+GNUNET_HELLO_get_header (struct GNUNET_HELLO_Message *hello)
+{
+ 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;
+}
+
+
+/**
+ * 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 *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;
+
+};
+
+
+/**
+ * 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,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_TIME_Absolute expiration)
+{
+ struct EqualsContext *ec = cls;
+
+ if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
+ return GNUNET_YES;
+ if (0 == GNUNET_HELLO_address_cmp (address, ec->address))
+ {
+ ec->found = GNUNET_YES;
+ if (expiration.abs_value_us < ec->expiration.abs_value_us)
+ ec->result = GNUNET_TIME_absolute_min (expiration,
+ ec->result);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_YES;
+}
+
+
+/**
+ * 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,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_TIME_Absolute expiration)
+{
+ struct EqualsContext *ec = cls;
+
+ if (expiration.abs_value_us < ec->expiration_limit.abs_value_us)
+ return GNUNET_OK; /* expired, we don't care */
+ ec->address = address;
+ ec->expiration = expiration;
+ ec->found = GNUNET_NO;
+ GNUNET_HELLO_iterate_addresses (ec->ref,
+ GNUNET_NO,
+ &find_other_matching,
+ ec);
+ if (GNUNET_NO == ec->found)
+ {
+ /* not found, we differ *now* */
+ ec->result = GNUNET_TIME_UNIT_ZERO_ABS;
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
+}
+
+
+/**
+ * Test if two HELLO messages contain the same addresses.
+ * If they only differ in expiration time, the lowest
+ * expiration time larger than @a now where they differ
+ * is returned.
+ *
+ * @param h1 first HELLO message
+ * @param h2 the second HELLO message
+ * @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 >= @a now if
+ * they only differ in timestamps;
+ * zero if the some addresses with expirations >= @a now
+ * do not match at all
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_HELLO_equals (const struct GNUNET_HELLO_Message *h1,
+ const struct GNUNET_HELLO_Message *h2,
+ struct GNUNET_TIME_Absolute now)
+{
+ struct EqualsContext ec;
+
+ if (h1->header.type != h2->header.type)
+ return GNUNET_TIME_UNIT_ZERO_ABS;
+ if (0 !=
+ 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.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;
+}
+
+
+/**
+ * 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,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_TIME_Absolute expiration)
+{
+ struct GNUNET_TIME_Absolute *max = cls;
+
+ *max = GNUNET_TIME_absolute_max (*max, expiration);
+ return GNUNET_OK;
+}
+
+
+/**
+ * When does the last address in the given HELLO expire?
+ *
+ * @param msg HELLO to inspect
+ * @return time the last address expires, 0 if there are no addresses in the HELLO
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_HELLO_get_last_expiration (const struct GNUNET_HELLO_Message *msg)
+{
+ struct GNUNET_TIME_Absolute ret;
+
+ ret = GNUNET_TIME_UNIT_ZERO_ABS;
+ GNUNET_HELLO_iterate_addresses (msg,
+ GNUNET_NO,
+ &find_max_expire,
+ &ret);
+ return ret;
+}
+
+
+/**
+ * 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").
+ * <p>
+ *
+ * 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:
+ *
+ * <ul><li>
+ *
+ * <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):
+ * [XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX]:PPPPP
+ * PPPPP is the port number. May be 0.
+ *
+ * </li><li>
+ *
+ * [add SMTP, HTTP and other addresses here]
+ *
+ * </li></ul>
+ *
+ * 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
+ *
+ * <p>
+ */
+
+
+
+/**
+ * Function that is called on each address of this peer.
+ * Expands the corresponding URI string.
+ *
+ * @param cls the `struct GNUNET_HELLO_ComposeUriContext`
+ * @param address address to add
+ * @param expiration expiration time for the address
+ * @return #GNUNET_OK (continue iteration).
+ */
+static int
+add_address_to_uri (void *cls,
+ const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_TIME_Absolute expiration)
+{
+ struct GNUNET_HELLO_ComposeUriContext *ctx = cls;
+ struct GNUNET_TRANSPORT_PluginFunctions *papi;
+ const char *addr;
+ char *ret;
+ char *addr_dup;
+ char *pos;
+ char tbuf[16] = "";
+ char *client_str = "_client";
+ struct tm *t;
+ time_t seconds;
+
+ papi = ctx->plugins_find (address->transport_name);
+ if (NULL == papi)
+ {
+ /* Not an error - we might just not have the right plugin. */
+ return GNUNET_OK;
+ }
+ if (NULL == papi->address_to_string)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "URI conversion not implemented for plugin `%s'\n",
+ address->transport_name);
+ return GNUNET_OK;
+ }
+ addr = papi->address_to_string (papi->cls,
+ address->address,
+ address->address_length);
+ if ( (NULL == addr) ||
+ (0 == strlen(addr)) )
+ return GNUNET_OK;
+
+ addr_dup = GNUNET_strdup (addr);
+ if (NULL != (pos = strstr (addr_dup, "_server")))
+ GNUNET_memcpy (pos,
+ client_str,
+ strlen (client_str)); /* Replace all server addresses with client addresses */
+
+ seconds = expiration.abs_value_us / 1000LL / 1000LL;
+ t = gmtime (&seconds);
+
+ GNUNET_asprintf (&ret,
+ "%s%c%s%c%s%c%s",
+ ctx->uri,
+ GNUNET_HELLO_URI_SEP,
+ strftime (tbuf,
+ sizeof (tbuf),
+ "%Y%m%d%H%M%S",
+ t) ? tbuf : "0",
+ GNUNET_HELLO_URI_SEP,
+ address->transport_name,
+ GNUNET_HELLO_URI_SEP,
+ addr_dup);
+ GNUNET_free (addr_dup);
+ GNUNET_free (ctx->uri);
+ ctx->uri = ret;
+ return GNUNET_OK;
+}
+
+
+/**
+ * Compose a hello URI string from a hello message.
+ *
+ * @param hello Hello message
+ * @param plugins_find Function to find transport plugins by name
+ * @return Hello URI string
+ */
+char *
+GNUNET_HELLO_compose_uri (const struct GNUNET_HELLO_Message *hello,
+ GNUNET_HELLO_TransportPluginsFind plugins_find)
+{
+ 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;
+}
+
+
+/* ************************* Parse HELLO URI ********************* */
+
+
+/**
+ * We're building a HELLO. Parse the next address from the
+ * parsing context and append it.
+ *
+ * @param cls the `struct GNUNET_HELLO_ParseUriContext`
+ * @param max number of bytes available for HELLO construction
+ * @param buffer where to copy the next address (in binary format)
+ * @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)
+{
+ struct GNUNET_HELLO_ParseUriContext *ctx = cls;
+ const char *tname;
+ const char *address;
+ char *uri_address;
+ const char *end;
+ char *plugin_name;
+ struct tm expiration_time;
+ time_t expiration_seconds;
+ struct GNUNET_TIME_Absolute expire;
+ struct GNUNET_TRANSPORT_PluginFunctions *papi;
+ void *addr;
+ size_t addr_len;
+ struct GNUNET_HELLO_Address haddr;
+ ssize_t ret;
+
+ if (NULL == ctx->pos)
+ return GNUNET_SYSERR;
+ if (GNUNET_HELLO_URI_SEP != ctx->pos[0])
+ {
+ ctx->ret = GNUNET_SYSERR;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ ctx->pos++;
+
+ if ( ('0' == ctx->pos[0]) &&
+ (GNUNET_HELLO_URI_SEP == ctx->pos[1]) )
+ {
+ expire = GNUNET_TIME_UNIT_FOREVER_ABS;
+ tname = ctx->pos + 1;
+ }
+ else
+ {
+ memset (&expiration_time, 0, sizeof (expiration_time));
+ tname = strptime (ctx->pos,
+ "%Y%m%d%H%M%S",
+ &expiration_time);
+ if (NULL == tname)
+ {
+ ctx->ret = GNUNET_SYSERR;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to parse HELLO message: missing expiration time\n"));
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ expiration_seconds = mktime (&expiration_time);
+ if (expiration_seconds == (time_t) -1)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to parse HELLO message: invalid expiration time\n"));
+ ctx->ret = GNUNET_SYSERR;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ expire.abs_value_us = expiration_seconds * 1000LL * 1000LL;
+ }
+ if (GNUNET_HELLO_URI_SEP != tname[0])
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to parse HELLO message: malformed\n"));
+ ctx->ret = GNUNET_SYSERR;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ tname++;
+ address = strchr (tname,
+ (int) GNUNET_HELLO_URI_SEP);
+ if (NULL == address)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to parse HELLO message: missing transport plugin\n"));
+ ctx->ret = GNUNET_SYSERR;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ address++;
+ end = strchr (address, (int) GNUNET_HELLO_URI_SEP);
+ ctx->pos = end;
+ ctx->counter_total ++;
+ plugin_name = GNUNET_strndup (tname, address - (tname+1));
+ papi = ctx->plugins_find (plugin_name);
+ if (NULL == papi)
+ {
+ /* Not an error - we might just not have the right plugin.
+ * Skip this part, advance to the next one and recurse.
+ * But only if this is not the end of string.
+ */
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Plugin `%s' not found, skipping address\n"),
+ plugin_name);
+ GNUNET_free (plugin_name);
+ return 0;
+ }
+ if (NULL == papi->string_to_address)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Plugin `%s' does not support URIs yet\n"),
+ plugin_name);
+ GNUNET_free (plugin_name);
+ GNUNET_break (0);
+ return 0;
+ }
+ uri_address = GNUNET_strndup (address, end - address);
+ if (GNUNET_OK !=
+ papi->string_to_address (papi->cls,
+ uri_address,
+ strlen (uri_address) + 1,
+ &addr,
+ &addr_len))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to parse `%s' as an address for plugin `%s'\n"),
+ uri_address,
+ plugin_name);
+ GNUNET_free (plugin_name);
+ GNUNET_free (uri_address);
+ return 0;
+ }
+ GNUNET_free (uri_address);
+ /* address.peer is unset - not used by add_address() */
+ haddr.address_length = addr_len;
+ haddr.address = addr;
+ haddr.transport_name = plugin_name;
+ ret = GNUNET_HELLO_add_address (&haddr,
+ expire,
+ buffer,
+ max);
+ ctx->counter_added ++;
+ GNUNET_free (addr);
+ GNUNET_free (plugin_name);
+ return ret;
+}
+
+
+/**
+ * Parse a hello URI string to a hello message.
+ *
+ * @param uri URI string to parse
+ * @param pubkey Pointer to struct where public key is parsed
+ * @param hello Pointer to struct where hello message is parsed
+ * @param plugins_find Function to find transport plugins by name
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the URI was invalid, #GNUNET_NO on other errors
+ */
+int
+GNUNET_HELLO_parse_uri (const char *uri,
+ struct GNUNET_CRYPTO_EddsaPublicKey *pubkey,
+ struct GNUNET_HELLO_Message **hello,
+ GNUNET_HELLO_TransportPluginsFind plugins_find)
+{
+ 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;
+}
+