Parses and produces uri strings. More...

#include "platform.h"
#include "gnunet_fs_service.h"
#include "gnunet_signatures.h"
#include "fs_api.h"
#include <unitypes.h>
#include <unicase.h>
#include <uniconv.h>
#include <unistr.h>
#include <unistdio.h>

Include dependency graph for fs_uri.c:

Data Structures
struct	LocUriAssembly
	Structure that defines how the contents of a location URI must be assembled in memory to create or verify the signature of a location URI. More...

Macros
#define	GNUNET_FS_URI_KSK_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_KSK_INFIX

#define	GNUNET_FS_URI_SKS_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_SKS_INFIX

#define	GNUNET_FS_URI_CHK_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_CHK_INFIX

#define	GNUNET_FS_URI_LOC_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_LOC_INFIX

#define	SIGNATURE_ASCII_LENGTH 103

#define	TOKENS "_. /-!?#&+@\"\'\\;:,()[]{}$<>\|"
	Where to break up keywords. More...

Functions
int	GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri uri, struct GNUNET_HashCode key)
	Get a unique key from a URI. More...

char *	GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri)
	Convert keyword URI to a human readable format (i.e. More...

static char *	percent_decode_keyword (const char in, char *emsg)
	Given a keyword with %-encoding (and possibly quotes to protect spaces), return a copy of the keyword without %-encoding and without double-quotes (%22). More...

static struct GNUNET_FS_Uri *	uri_ksk_parse (const char s, char *emsg)
	Parse a KSK URI. More...

static struct GNUNET_FS_Uri *	uri_sks_parse (const char s, char *emsg)
	Parse an SKS URI. More...

static struct GNUNET_FS_Uri *	uri_chk_parse (const char s, char *emsg)
	Parse a CHK URI. More...

static struct GNUNET_FS_Uri *	uri_loc_parse (const char s, char *emsg)
	Parse a LOC URI. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_parse (const char uri, char *emsg)
	Convert a UTF-8 String to a URI. More...

void	GNUNET_FS_uri_destroy (struct GNUNET_FS_Uri *uri)
	Free URI. More...

unsigned int	GNUNET_FS_uri_ksk_get_keyword_count (const struct GNUNET_FS_Uri *uri)
	How many keywords are ANDed in this keyword URI? More...

int	GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri uri, GNUNET_FS_KeywordIterator iterator, void iterator_cls)
	Iterate over all keywords in this keyword URI. More...

void	GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri uri, const char keyword, int is_mandatory)
	Add the given keyword to the set of keywords represented by the URI. More...

void	GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri uri, const char keyword)
	Remove the given keyword from the set of keywords represented by the URI. More...

int	GNUNET_FS_uri_loc_get_peer_identity (const struct GNUNET_FS_Uri uri, struct GNUNET_PeerIdentity peer)
	Obtain the identity of the peer offering the data. More...

struct GNUNET_TIME_Absolute	GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri)
	Obtain the expiration of the LOC URI. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri)
	Obtain the URI of the content itself. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri base_uri, const struct GNUNET_CRYPTO_EddsaPrivateKey sign_key, struct GNUNET_TIME_Absolute expiration_time)
	Construct a location URI (this peer will be used for the location). More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EcdsaPublicKey ns, const char id)
	Create an SKS URI from a namespace ID and an identifier. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri u1, const struct GNUNET_FS_Uri u2)
	Merge the sets of keywords from two KSK URIs. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri)
	Duplicate URI. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_create (const char keywords, char *emsg)
	Create an FS URI from a single user-supplied string of keywords. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_create_from_args (unsigned int argc, const char **argv)
	Create an FS URI from a user-supplied command line of keywords. More...

int	GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri u1, const struct GNUNET_FS_Uri u2)
	Test if two URIs are equal. More...

int	GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
	Is this a namespace URI? More...

int	GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri uri, struct GNUNET_CRYPTO_EcdsaPublicKey pseudonym)
	Get the ID of a namespace from the given namespace URI. More...

char *	GNUNET_FS_uri_sks_get_content_id (const struct GNUNET_FS_Uri *uri)
	Get the content identifier of an SKS URI. More...

int	GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
	Is this a keyword URI? More...

int	GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
	Is this a file (or directory) URI? More...

uint64_t	GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri *uri)
	What is the size of the file that this URI refers to? More...

const struct GNUNET_HashCode *	GNUNET_FS_uri_chk_get_file_hash (const struct GNUNET_FS_Uri *uri)
	What is the hash of the original file's content that this URI refers to? More...

int	GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
	Is this a location URI? More...

static void	insert_non_mandatory_keyword (const char s, char *array, int index)
	Add a keyword as non-mandatory (with ' '-prefix) to the given keyword list at offset 'index'. More...

static int	find_duplicate (const char s, const char *array, int array_length)
	Test if the given keyword s is already present in the given array, ignoring the '+'-mandatory prefix in the array. More...

static char *	normalize_metadata (enum EXTRACTOR_MetaFormat format, const char *data, size_t data_len)
	FIXME: comment. More...

static size_t	u8_strcount (const uint8_t *s)
	Counts the number of UTF-8 characters (not bytes) in the string, returns that count. More...

static int	get_keywords_from_parens (const char s, char *array, int index)
	Break the filename up by matching [], () and {} pairs to make keywords. More...

static int	get_keywords_from_tokens (const char s, char *array, int index)
	Break the filename up by TOKENS to make keywords. More...

static int	gather_uri_data (void cls, const char plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char data_mime_type, const char data, size_t data_len)
	Function called on each value in the meta data. More...

struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_FS_MetaData *md)
	Construct a keyword-URI from meta-data (take all entries in the meta-data and construct one large keyword URI that lists all keywords that can be found in the meta-data). More...

static int	needs_percent (char c)
	In URI-encoding, does the given character need to be encoded using %-encoding? More...

static char *	uri_ksk_to_string (const struct GNUNET_FS_Uri *uri)
	Convert a KSK URI to a string. More...

static char *	uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
	Convert SKS URI to a string. More...

static char *	uri_chk_to_string (const struct GNUNET_FS_Uri *uri)
	Convert a CHK URI to a string. More...

static char *	uri_loc_to_string (const struct GNUNET_FS_Uri *uri)
	Convert a LOC URI to a string. More...

char *	GNUNET_FS_uri_to_string (const struct GNUNET_FS_Uri *uri)
	Convert a URI to a UTF-8 String. More...

Detailed Description

Parses and produces uri strings.

Author: Igor Wronsky, Christian Grothoff

GNUnet URIs are of the general form "gnunet://MODULE/IDENTIFIER". The specific structure of "IDENTIFIER" depends on the module and maybe differentiated into additional subcategories if applicable. This module only deals with fs identifiers (MODULE = "fs").

This module only parses URIs for the AFS module. The FS URIs fall into four categories, "chk", "sks", "ksk" and "loc". The first three categories were named in analogy (!) to Freenet, but they do NOT work in exactly the same way. They are very similar from the user's point of view (unique file identifier, subspace, keyword), but the implementation is rather different in pretty much every detail. The concrete URI formats are:

First, there are URIs that identify a file. They have the format "gnunet://fs/chk/HEX1.HEX2.SIZE". These URIs can be used to download the file. The description, filename, mime-type and other meta-data is NOT part of the file-URI since a URI uniquely identifies a resource (and the contents of the file would be the same even if it had a different description).
The second category identifies entries in a namespace. The format is "gnunet://fs/sks/NAMESPACE/IDENTIFIER" where the namespace should be given in HEX. Applications may allow using a nickname for the namespace if the nickname is not ambiguous. The identifier can be either an ASCII sequence or a HEX-encoding. If the identifier is in ASCII but the format is ambiguous and could denote a HEX-string a "/" is appended to indicate ASCII encoding.
The third category identifies ordinary searches. The format is "gnunet://fs/ksk/KEYWORD[+KEYWORD]*". Using the "+" syntax it is possible to encode searches with the boolean "AND" operator. "+" is used since it indicates a commutative 'and' operation and is unlikely to be used in a keyword by itself.
The last category identifies a datum on a specific machine. The format is "gnunet://fs/loc/HEX1.HEX2.SIZE.PEER.SIG.EXPTIME". PEER is the BinName of the public key of the peer storing the datum. The signature (SIG) certifies that this peer has this content. HEX1, HEX2 and SIZE correspond to a 'chk' URI.

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

Definition in file fs_uri.c.

Macro Definition Documentation

◆ GNUNET_FS_URI_KSK_PREFIX

#define GNUNET_FS_URI_KSK_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_KSK_INFIX

Definition at line 262 of file fs_uri.c.

◆ GNUNET_FS_URI_SKS_PREFIX

#define GNUNET_FS_URI_SKS_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_SKS_INFIX

Definition at line 356 of file fs_uri.c.

◆ GNUNET_FS_URI_CHK_PREFIX

#define GNUNET_FS_URI_CHK_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_CHK_INFIX

Definition at line 395 of file fs_uri.c.

◆ GNUNET_FS_URI_LOC_PREFIX

#define GNUNET_FS_URI_LOC_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_LOC_INFIX

Definition at line 483 of file fs_uri.c.

◆ SIGNATURE_ASCII_LENGTH

#define SIGNATURE_ASCII_LENGTH 103

Definition at line 485 of file fs_uri.c.

◆ TOKENS

#define TOKENS "_. /-!?#&+@\"\'\\;:,()[]{}$<>|"

Where to break up keywords.

Definition at line 1631 of file fs_uri.c.

Function Documentation

◆ percent_decode_keyword()

static char * percent_decode_keyword	(	const char *	in,
		char **	emsg
	)

static

Given a keyword with %-encoding (and possibly quotes to protect spaces), return a copy of the keyword without %-encoding and without double-quotes (%22).

Also, add a space at the beginning if there is not a '+'.

Parameters

in	string with %-encoding
emsg	where to store the parser error message (if any)

Returns: decoded string with leading space (or preserved plus)

Definition at line 212 of file fs_uri.c.

{
  char *out;
  char *ret;
  unsigned int rpos;
  unsigned int wpos;
  unsigned int hx;
 
  out = GNUNET_strdup (in);
  rpos = 0;
  wpos = 0;
  while (out[rpos] != '\0')
  {
    if (out[rpos] == '%')
    {
      if (1 != sscanf (&out[rpos + 1], "%2X", &hx))
      {
        GNUNET_free (out);
        *emsg = GNUNET_strdup (
          _ (     /* xgettext:no-c-format */
            "Malformed KSK URI (`%' must be followed by HEX number)"));
        return NULL;
      }
      rpos += 3;
      if (hx == '"')
        continue;     /* skip double quote */
      out[wpos++] = (char) hx;
    }
    else
    {
      out[wpos++] = out[rpos++];
    }
  }
  out[wpos] = '\0';
  if (out[0] == '+')
  {
    ret = GNUNET_strdup (out);
  }
  else
  {
    /* need to prefix with space */
    ret = GNUNET_malloc (strlen (out) + 2);
    strcpy (ret, " ");
    strcat (ret, out);
  }
  GNUNET_free (out);
  return ret;
}

References _, GNUNET_free, GNUNET_malloc, GNUNET_strdup, and ret.

Referenced by uri_ksk_parse().

Here is the caller graph for this function:

◆ uri_ksk_parse()

static struct GNUNET_FS_Uri * uri_ksk_parse	(	const char *	s,
		char **	emsg
	)

static

Parse a KSK URI.

Parameters

s	an uri string
emsg	where to store the parser error message (if any)

Returns: NULL on error, otherwise the KSK URI

Definition at line 272 of file fs_uri.c.

{
  struct GNUNET_FS_Uri *ret;
  char **keywords;
  unsigned int pos;
  int max;
  int iret;
  int i;
  size_t slen;
  char *dup;
  int saw_quote;
 
  slen = strlen (s);
  pos = strlen (GNUNET_FS_URI_KSK_PREFIX);
  if ((slen <= pos) || (0 != strncmp (s, GNUNET_FS_URI_KSK_PREFIX, pos)))
    return NULL; /* not KSK URI */
  if ((s[slen - 1] == '+') || (s[pos] == '+'))
  {
    *emsg =
      GNUNET_strdup (_ ("Malformed KSK URI (must not begin or end with `+')"));
    return NULL;
  }
  max = 1;
  saw_quote = 0;
  for (i = pos; i < slen; i++)
  {
    if ((s[i] == '%') && (&s[i] == strstr (&s[i], "%22")))
    {
      saw_quote = (saw_quote + 1) % 2;
      i += 3;
      continue;
    }
    if ((s[i] == '+') && (saw_quote == 0))
    {
      max++;
      if (s[i - 1] == '+')
      {
        *emsg = GNUNET_strdup (_ ("Malformed KSK URI (`++' not allowed)"));
        return NULL;
      }
    }
  }
  if (saw_quote == 1)
  {
    *emsg = GNUNET_strdup (_ ("Malformed KSK URI (quotes not balanced)"));
    return NULL;
  }
  iret = max;
  dup = GNUNET_strdup (s);
  keywords = GNUNET_new_array (max, char *);
  for (i = slen - 1; i >= (int) pos; i--)
  {
    if ((s[i] == '%') && (&s[i] == strstr (&s[i], "%22")))
    {
      saw_quote = (saw_quote + 1) % 2;
      continue;
    }
    if ((dup[i] == '+') && (saw_quote == 0))
    {
      keywords[--max] = percent_decode_keyword (&dup[i + 1], emsg);
      if (NULL == keywords[max])
        goto CLEANUP;
      dup[i] = '\0';
    }
  }
  keywords[--max] = percent_decode_keyword (&dup[pos], emsg);
  if (NULL == keywords[max])
    goto CLEANUP;
  GNUNET_assert (0 == max);
  GNUNET_free (dup);
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  ret->type = GNUNET_FS_URI_KSK;
  ret->data.ksk.keywordCount = iret;
  ret->data.ksk.keywords = keywords;
  return ret;
  CLEANUP:
  for (i = 0; i < max; i++)
    GNUNET_free (keywords[i]);
  GNUNET_free (keywords);
  GNUNET_free (dup);
  return NULL;
}

References _, GNUNET_assert, GNUNET_free, GNUNET_FS_URI_KSK, GNUNET_FS_URI_KSK_PREFIX, GNUNET_new, GNUNET_new_array, GNUNET_strdup, GNUNET_FS_Uri::keywords, max, percent_decode_keyword(), and ret.

Referenced by GNUNET_FS_uri_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uri_sks_parse()

static struct GNUNET_FS_Uri * uri_sks_parse	(	const char *	s,
		char **	emsg
	)

static

Parse an SKS URI.

Parameters

s	an uri string
emsg	where to store the parser error message (if any)

Returns: NULL on error, SKS URI otherwise

Definition at line 366 of file fs_uri.c.

{
  struct GNUNET_FS_Uri *ret;
  struct GNUNET_CRYPTO_EcdsaPublicKey ns;
  size_t pos;
  char *end;
 
  pos = strlen (GNUNET_FS_URI_SKS_PREFIX);
  if ((strlen (s) <= pos) || (0 != strncmp (s, GNUNET_FS_URI_SKS_PREFIX, pos)))
    return NULL; /* not an SKS URI */
  end = strchr (&s[pos], '/');
  if ((NULL == end) ||
      (GNUNET_OK != GNUNET_STRINGS_string_to_data (&s[pos],
                                                   end - &s[pos],
                                                   &ns,
                                                   sizeof(ns))))
  {
    *emsg = GNUNET_strdup (_ ("Malformed SKS URI (wrong syntax)"));
    return NULL;   /* malformed */
  }
  end++; /* skip over '/' */
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  ret->type = GNUNET_FS_URI_SKS;
  ret->data.sks.ns = ns;
  ret->data.sks.identifier = GNUNET_strdup (end);
  return ret;
}

References _, end, GNUNET_FS_URI_SKS, GNUNET_FS_URI_SKS_PREFIX, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_string_to_data(), ns, and ret.

Referenced by GNUNET_FS_uri_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uri_chk_parse()

static struct GNUNET_FS_Uri * uri_chk_parse	(	const char *	s,
		char **	emsg
	)

static

Parse a CHK URI.

Parameters

s	an uri string
emsg	where to store the parser error message (if any)

Returns: NULL on error, CHK URI otherwise

Definition at line 406 of file fs_uri.c.

{
  struct GNUNET_FS_Uri *ret;
  struct FileIdentifier fi;
  unsigned int pos;
  unsigned long long flen;
  size_t slen;
  char h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
  char h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
 
  slen = strlen (s);
  pos = strlen (GNUNET_FS_URI_CHK_PREFIX);
  if ((slen < pos + 2 * sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) + 1) ||
      (0 != strncmp (s, GNUNET_FS_URI_CHK_PREFIX, pos)))
    return NULL; /* not a CHK URI */
  if ((s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
      (s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.'))
  {
    *emsg = GNUNET_strdup (_ ("Malformed CHK URI (wrong syntax)"));
    return NULL;
  }
  GNUNET_memcpy (h1, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
  h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
  GNUNET_memcpy (h2,
                 &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
                 sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
  h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
 
  if ((GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h1, &fi.chk.key)) ||
      (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h2, &fi.chk.query)) ||
      (1 !=
       sscanf (&s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
               "%llu",
               &flen)))
  {
    *emsg = GNUNET_strdup (_ ("Malformed CHK URI (failed to decode CHK)"));
    return NULL;
  }
  fi.file_length = GNUNET_htonll (flen);
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  ret->type = GNUNET_FS_URI_CHK;
  ret->data.chk = fi;
  return ret;
}

References _, FileIdentifier::chk, FileIdentifier::file_length, GNUNET_CRYPTO_hash_from_string, GNUNET_FS_URI_CHK, GNUNET_FS_URI_CHK_PREFIX, GNUNET_htonll(), GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_strdup, ContentHashKey::key, ContentHashKey::query, and ret.

Referenced by GNUNET_FS_uri_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uri_loc_parse()

static struct GNUNET_FS_Uri * uri_loc_parse	(	const char *	s,
		char **	emsg
	)

static

Parse a LOC URI.

Also verifies validity of the location URI.

Parameters

s	an uri string
emsg	where to store the parser error message (if any)

Returns: NULL on error, valid LOC URI otherwise

Definition at line 496 of file fs_uri.c.

{
  struct GNUNET_FS_Uri *uri;
  char h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
  char h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
  unsigned int pos;
  unsigned int npos;
  unsigned long long exptime;
  unsigned long long flen;
  struct GNUNET_TIME_Absolute et;
  struct GNUNET_CRYPTO_EddsaSignature sig;
  struct LocUriAssembly ass;
  size_t slen;
 
  slen = strlen (s);
  pos = strlen (GNUNET_FS_URI_LOC_PREFIX);
  if ((slen < pos + 2 * sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) + 1) ||
      (0 != strncmp (s, GNUNET_FS_URI_LOC_PREFIX, pos)))
    return NULL; /* not a LOC URI */
  if ((s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
      (s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.'))
  {
    *emsg = GNUNET_strdup (_ ("LOC URI malformed (wrong syntax)"));
    return NULL;
  }
  GNUNET_memcpy (h1, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
  h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
  GNUNET_memcpy (h2,
                 &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
                 sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
  h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
 
  if ((GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h1, &ass.fi.chk.key)) ||
      (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h2, &ass.fi.chk.query)) ||
      (1 !=
       sscanf (&s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
               "%llu",
               &flen)))
  {
    *emsg = GNUNET_strdup (_ ("LOC URI malformed (no CHK)"));
    return NULL;
  }
  ass.fi.file_length = GNUNET_htonll (flen);
 
  npos = pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2;
  while ((s[npos] != '\0') && (s[npos] != '.'))
    npos++;
  if (s[npos] == '\0')
  {
    *emsg = GNUNET_strdup (_ ("LOC URI malformed (missing LOC)"));
    goto ERR;
  }
  npos++;
  if ((strlen (&s[npos]) <= GNUNET_CRYPTO_PKEY_ASCII_LENGTH + 1) ||
      ('.' != s[npos + GNUNET_CRYPTO_PKEY_ASCII_LENGTH]))
  {
    *emsg =
      GNUNET_strdup (_ ("LOC URI malformed (wrong syntax for public key)"));
  }
  if (
    GNUNET_OK !=
    GNUNET_CRYPTO_eddsa_public_key_from_string (&s[npos],
                                                GNUNET_CRYPTO_PKEY_ASCII_LENGTH,
                                                &ass.peer.public_key))
  {
    *emsg =
      GNUNET_strdup (_ ("LOC URI malformed (could not decode public key)"));
    goto ERR;
  }
  npos += GNUNET_CRYPTO_PKEY_ASCII_LENGTH;
  if (s[npos++] != '.')
  {
    *emsg = GNUNET_strdup (_ ("LOC URI malformed (could not find signature)"));
    goto ERR;
  }
  if ((strlen (&s[npos]) <= SIGNATURE_ASCII_LENGTH + 1) ||
      ('.' != s[npos + SIGNATURE_ASCII_LENGTH]))
  {
    *emsg =
      GNUNET_strdup (_ ("LOC URI malformed (wrong syntax for signature)"));
    goto ERR;
  }
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (&s[npos],
                                     SIGNATURE_ASCII_LENGTH,
                                     &sig,
                                     sizeof(
                                       struct GNUNET_CRYPTO_EddsaSignature)))
  {
    *emsg =
      GNUNET_strdup (_ ("LOC URI malformed (could not decode signature)"));
    goto ERR;
  }
  npos += SIGNATURE_ASCII_LENGTH;
  if (s[npos++] != '.')
  {
    *emsg = GNUNET_strdup (
      _ ("LOC URI malformed (wrong syntax for expiration time)"));
    goto ERR;
  }
  if (1 != sscanf (&s[npos], "%llu", &exptime))
  {
    *emsg =
      GNUNET_strdup (_ ("LOC URI malformed (could not parse expiration time)"));
    goto ERR;
  }
  ass.purpose.size = htonl (sizeof(struct LocUriAssembly));
  ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
  et.abs_value_us = exptime * 1000LL * 1000LL;
  ass.exptime = GNUNET_TIME_absolute_hton (et);
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
                                  &ass,
                                  &sig,
                                  &ass.peer.public_key))
  {
    *emsg =
      GNUNET_strdup (_ ("LOC URI malformed (signature failed validation)"));
    goto ERR;
  }
  uri = GNUNET_new (struct GNUNET_FS_Uri);
  uri->type = GNUNET_FS_URI_LOC;
  uri->data.loc.fi = ass.fi;
  uri->data.loc.peer = ass.peer;
  uri->data.loc.expirationTime = et;
  uri->data.loc.contentSignature = sig;
 
  return uri;
  ERR:
  return NULL;
}

References _, GNUNET_TIME_Absolute::abs_value_us, FileIdentifier::chk, Location::contentSignature, GNUNET_FS_Uri::data, Location::expirationTime, LocUriAssembly::exptime, Location::fi, LocUriAssembly::fi, FileIdentifier::file_length, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_hash_from_string, GNUNET_CRYPTO_PKEY_ASCII_LENGTH, GNUNET_FS_URI_LOC, GNUNET_FS_URI_LOC_PREFIX, GNUNET_htonll(), GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT, GNUNET_strdup, GNUNET_STRINGS_string_to_data(), GNUNET_TIME_absolute_hton(), ContentHashKey::key, GNUNET_FS_Uri::loc, Location::peer, LocUriAssembly::peer, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, LocUriAssembly::purpose, ContentHashKey::query, SIGNATURE_ASCII_LENGTH, GNUNET_CRYPTO_EccSignaturePurpose::size, GNUNET_FS_Uri::type, and uri.

Referenced by GNUNET_FS_uri_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_non_mandatory_keyword()

static void insert_non_mandatory_keyword	(	const char *	s,
		char **	array,
		int	index
	)

static

Add a keyword as non-mandatory (with ' '-prefix) to the given keyword list at offset 'index'.

The array is guaranteed to be long enough.

Parameters

s	keyword to add
array	array to add the keyword to
index	offset where to add the keyword

Definition at line 1417 of file fs_uri.c.

{
  char *nkword;
 
  GNUNET_asprintf (&nkword,
                   " %s", /* space to mark as 'non mandatory' */
                   s);
  array[index] = nkword;
}

References GNUNET_asprintf().

Referenced by gather_uri_data(), get_keywords_from_parens(), and get_keywords_from_tokens().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_duplicate()

static int find_duplicate	(	const char *	s,
		const char **	array,
		int	array_length
	)

static

Test if the given keyword s is already present in the given array, ignoring the '+'-mandatory prefix in the array.

Parameters

s	keyword to test
array	keywords to test against, with ' ' or '+' prefix to ignore
array_length	length of the array

Returns: GNUNET_YES if the keyword exists, GNUNET_NO if not

Definition at line 1438 of file fs_uri.c.

{
  int j;
 
  for (j = array_length - 1; j >= 0; j--)
    if (0 == strcmp (&array[j][1], s))
      return GNUNET_YES;
  return GNUNET_NO;
}

References GNUNET_NO, and GNUNET_YES.

Referenced by gather_uri_data(), get_keywords_from_parens(), and get_keywords_from_tokens().

Here is the caller graph for this function:

◆ normalize_metadata()

static char * normalize_metadata	(	enum EXTRACTOR_MetaFormat	format,
		const char *	data,
		size_t	data_len
	)

static

FIXME: comment.

Definition at line 1453 of file fs_uri.c.

{
  uint8_t *free_str = NULL;
  uint8_t *str_to_normalize = (uint8_t *) data;
  uint8_t *normalized;
  size_t r_len;
 
  if (str_to_normalize == NULL)
    return NULL;
  /* Don't trust libextractor */
  if (format == EXTRACTOR_METAFORMAT_UTF8)
  {
    free_str = (uint8_t *) u8_check ((const uint8_t *) data, data_len);
    if (free_str == NULL)
      free_str = NULL;
    else
      format = EXTRACTOR_METAFORMAT_C_STRING;
  }
  if (format == EXTRACTOR_METAFORMAT_C_STRING)
  {
    free_str = u8_strconv_from_encoding (data,
                                         locale_charset (),
                                         iconveh_escape_sequence);
    if (free_str == NULL)
      return NULL;
  }
 
  normalized = u8_tolower (str_to_normalize,
                           strlen ((char *) str_to_normalize),
                           NULL,
                           UNINORM_NFD,
                           NULL,
                           &r_len);
  /* free_str is allocated by libunistring internally, use free() */
  if (free_str != NULL)
    free (free_str);
  if (normalized != NULL)
  {
    /* u8_tolower allocates a non-NULL-terminated string! */
    free_str = GNUNET_malloc (r_len + 1);
    GNUNET_memcpy (free_str, normalized, r_len);
    free_str[r_len] = '\0';
    free (normalized);
    normalized = free_str;
  }
  return (char *) normalized;
}

References data, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, GNUNET_malloc, and GNUNET_memcpy.

Referenced by gather_uri_data(), get_keywords_from_parens(), and get_keywords_from_tokens().

Here is the caller graph for this function:

◆ u8_strcount()

static size_t u8_strcount ( const uint8_t * s )

static

Counts the number of UTF-8 characters (not bytes) in the string, returns that count.

Definition at line 1509 of file fs_uri.c.

{
  size_t count;
  ucs4_t c;
 
  GNUNET_assert (s != NULL);
  if (s[0] == 0)
    return 0;
  for (count = 0; s != NULL; count++)
    s = u8_next (&c, s);
  return count - 1;
}

References GNUNET_assert.

Referenced by gather_uri_data(), get_keywords_from_parens(), and get_keywords_from_tokens().

Here is the caller graph for this function:

◆ get_keywords_from_parens()

static int get_keywords_from_parens	(	const char *	s,
		char **	array,
		int	index
	)

static

Break the filename up by matching [], () and {} pairs to make keywords.

In case of nesting parentheses only the inner pair counts. You can't escape parentheses to scan something like "[blah\{foo]" to make a "blah{foo" keyword, this function is only a heuristic!

Parameters

s	string to break down.
array	array to fill with enclosed tokens. If NULL, then tokens are only counted.
index	index at which to start filling the array (entries prior to it are used to check for duplicates). ignored if array == NULL.

Returns: number of tokens counted (including duplicates), or number of tokens extracted (excluding duplicates). 0 if there are no matching parens in the string (when counting), or when all tokens were duplicates (when extracting).

Definition at line 1540 of file fs_uri.c.

{
  int count = 0;
  char *open_paren;
  char *close_paren;
  char *ss;
  char tmp;
 
  if (NULL == s)
    return 0;
  ss = GNUNET_strdup (s);
  open_paren = ss - 1;
  while (NULL != (open_paren = strpbrk (open_paren + 1, "[{(")))
  {
    int match = 0;
 
    close_paren = strpbrk (open_paren + 1, "]})");
    if (NULL == close_paren)
      continue;
    switch (open_paren[0])
    {
    case '[':
      if (']' == close_paren[0])
        match = 1;
      break;
 
    case '{':
      if ('}' == close_paren[0])
        match = 1;
      break;
 
    case '(':
      if (')' == close_paren[0])
        match = 1;
      break;
 
    default:
      break;
    }
    if (match && (close_paren - open_paren > 1))
    {
      tmp = close_paren[0];
      close_paren[0] = '\0';
      /* Keywords must be at least 3 characters long */
      if (u8_strcount ((const uint8_t *) &open_paren[1]) <= 2)
      {
        close_paren[0] = tmp;
        continue;
      }
      if (NULL != array)
      {
        char *normalized;
        if (GNUNET_NO == find_duplicate ((const char *) &open_paren[1],
                                         (const char **) array,
                                         index + count))
        {
          insert_non_mandatory_keyword ((const char *) &open_paren[1],
                                        array,
                                        index + count);
          count++;
        }
        normalized = normalize_metadata (EXTRACTOR_METAFORMAT_UTF8,
                                         &open_paren[1],
                                         close_paren - &open_paren[1]);
        if (normalized != NULL)
        {
          if (GNUNET_NO == find_duplicate ((const char *) normalized,
                                           (const char **) array,
                                           index + count))
          {
            insert_non_mandatory_keyword ((const char *) normalized,
                                          array,
                                          index + count);
            count++;
          }
          GNUNET_free (normalized);
        }
      }
      else
        count++;
      close_paren[0] = tmp;
    }
  }
  GNUNET_free (ss);
  return count;
}

References EXTRACTOR_METAFORMAT_UTF8, find_duplicate(), GNUNET_free, GNUNET_NO, GNUNET_strdup, insert_non_mandatory_keyword(), normalize_metadata(), and u8_strcount().

Referenced by GNUNET_FS_uri_ksk_create_from_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_keywords_from_tokens()

static int get_keywords_from_tokens	(	const char *	s,
		char **	array,
		int	index
	)

static

Break the filename up by TOKENS to make keywords.

Parameters

s	string to break down.
array	array to fill with tokens. If NULL, then tokens are only counted.
index	index at which to start filling the array (entries prior to it are used to check for duplicates). ignored if array == NULL.

Returns: number of tokens (>1) counted (including duplicates), or number of tokens extracted (excluding duplicates). 0 if there are no separators in the string (when counting), or when all tokens were duplicates (when extracting).

Definition at line 1648 of file fs_uri.c.

{
  char *p;
  char *ss;
  int seps = 0;
 
  ss = GNUNET_strdup (s);
  for (p = strtok (ss, TOKENS); p != NULL; p = strtok (NULL, TOKENS))
  {
    /* Keywords must be at least 3 characters long */
    if (u8_strcount ((const uint8_t *) p) <= 2)
      continue;
    if (NULL != array)
    {
      char *normalized;
      if (GNUNET_NO == find_duplicate (p, (const char **) array, index + seps))
      {
        insert_non_mandatory_keyword (p, array, index + seps);
        seps++;
      }
      normalized =
        normalize_metadata (EXTRACTOR_METAFORMAT_UTF8, p, strlen (p));
      if (normalized != NULL)
      {
        if (GNUNET_NO == find_duplicate ((const char *) normalized,
                                         (const char **) array,
                                         index + seps))
        {
          insert_non_mandatory_keyword ((const char *) normalized,
                                        array,
                                        index + seps);
          seps++;
        }
        GNUNET_free (normalized);
      }
    }
    else
      seps++;
  }
  GNUNET_free (ss);
  return seps;
}

References EXTRACTOR_METAFORMAT_UTF8, find_duplicate(), GNUNET_free, GNUNET_NO, GNUNET_strdup, insert_non_mandatory_keyword(), normalize_metadata(), p, TOKENS, and u8_strcount().

Referenced by GNUNET_FS_uri_ksk_create_from_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gather_uri_data()

static int gather_uri_data	(	void *	cls,
		const char *	plugin_name,
		enum EXTRACTOR_MetaType	type,
		enum EXTRACTOR_MetaFormat	format,
		const char *	data_mime_type,
		const char *	data,
		size_t	data_len
	)

static

Function called on each value in the meta data.

Adds it to the URI.

Parameters

cls	URI to update
plugin_name	name of the plugin that produced this value; special values can be used (e.g. '<zlib>' for zlib being used in the main libextractor library and yielding meta data).
type	libextractor-type describing the meta data
format	basic format information about data
data_mime_type	mime-type of data (not of the original file); can be NULL (if mime-type is not known)
data	actual meta-data found
data_len	number of bytes in data

Returns: 0 (always)

Definition at line 1713 of file fs_uri.c.

{
  struct GNUNET_FS_Uri *uri = cls;
  char *normalized_data;
  const char *sep;
 
  if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
      (format != EXTRACTOR_METAFORMAT_C_STRING))
    return 0;
  /* Keywords must be at least 3 characters long
   * If given non-utf8 string it will, most likely, find it to be invalid,
   * and will return the length of its valid part, skipping the keyword.
   * If it does - fix the extractor, not this check!
   */if (u8_strcount ((const uint8_t *) data) <= 2)
    return 0;
  if ((EXTRACTOR_METATYPE_MIMETYPE == type) &&
      (NULL != (sep = memchr (data, '/', data_len))) && (sep != data))
  {
    char *xtra;
 
    GNUNET_asprintf (&xtra, "mimetype:%.*s", (int) (sep - data), data);
    if (! find_duplicate (xtra,
                          (const char **) uri->data.ksk.keywords,
                          uri->data.ksk.keywordCount))
    {
      insert_non_mandatory_keyword (xtra,
                                    uri->data.ksk.keywords,
                                    uri->data.ksk.keywordCount);
      uri->data.ksk.keywordCount++;
    }
    GNUNET_free (xtra);
  }
 
  normalized_data = normalize_metadata (format, data, data_len);
  if (! find_duplicate (data,
                        (const char **) uri->data.ksk.keywords,
                        uri->data.ksk.keywordCount))
  {
    insert_non_mandatory_keyword (data,
                                  uri->data.ksk.keywords,
                                  uri->data.ksk.keywordCount);
    uri->data.ksk.keywordCount++;
  }
  if (NULL != normalized_data)
  {
    if (! find_duplicate (normalized_data,
                          (const char **) uri->data.ksk.keywords,
                          uri->data.ksk.keywordCount))
    {
      insert_non_mandatory_keyword (normalized_data,
                                    uri->data.ksk.keywords,
                                    uri->data.ksk.keywordCount);
      uri->data.ksk.keywordCount++;
    }
    GNUNET_free (normalized_data);
  }
  return 0;
}

References data, GNUNET_FS_Uri::data, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_MIMETYPE, find_duplicate(), GNUNET_asprintf(), GNUNET_free, insert_non_mandatory_keyword(), GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, normalize_metadata(), type, u8_strcount(), and uri.

Referenced by GNUNET_FS_uri_ksk_create_from_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ needs_percent()

static int needs_percent ( char c )

static

In URI-encoding, does the given character need to be encoded using %-encoding?

Definition at line 1845 of file fs_uri.c.

{
  return(! ((isalnum ((unsigned char) c)) || (c == '-') || (c == '_') ||
            (c == '.') || (c == '~')));
}

Referenced by uri_ksk_to_string().

Here is the caller graph for this function:

◆ uri_ksk_to_string()

static char * uri_ksk_to_string ( const struct GNUNET_FS_Uri * uri )

static

Convert a KSK URI to a string.

Parameters

uri	the URI to convert

Returns: NULL on error (i.e. keywordCount == 0)

Definition at line 1859 of file fs_uri.c.

{
  char **keywords;
  unsigned int keywordCount;
  size_t n;
  char *ret;
  unsigned int i;
  unsigned int j;
  unsigned int wpos;
  size_t slen;
  const char *keyword;
 
  if (uri->type != GNUNET_FS_URI_KSK)
    return NULL;
  keywords = uri->data.ksk.keywords;
  keywordCount = uri->data.ksk.keywordCount;
  n = keywordCount + strlen (GNUNET_FS_URI_PREFIX)
      + strlen (GNUNET_FS_URI_KSK_INFIX) + 1;
  for (i = 0; i < keywordCount; i++)
  {
    keyword = keywords[i];
    slen = strlen (keyword);
    n += slen;
    for (j = 0; j < slen; j++)
    {
      if ((j == 0) && (keyword[j] == ' '))
      {
        n--;
        continue;       /* skip leading space */
      }
      if (needs_percent (keyword[j]))
        n += 2;     /* will use %-encoding */
    }
  }
  ret = GNUNET_malloc (n);
  strcpy (ret, GNUNET_FS_URI_PREFIX);
  strcat (ret, GNUNET_FS_URI_KSK_INFIX);
  wpos = strlen (ret);
  for (i = 0; i < keywordCount; i++)
  {
    keyword = keywords[i];
    slen = strlen (keyword);
    for (j = 0; j < slen; j++)
    {
      if ((j == 0) && (keyword[j] == ' '))
        continue;     /* skip leading space */
      if (needs_percent (keyword[j]))
      {
        sprintf (&ret[wpos], "%%%02X", (unsigned char) keyword[j]);
        wpos += 3;
      }
      else
      {
        ret[wpos++] = keyword[j];
      }
    }
    if (i != keywordCount - 1)
      ret[wpos++] = '+';
  }
  return ret;
}

References GNUNET_FS_Uri::data, GNUNET_FS_URI_KSK, GNUNET_FS_URI_KSK_INFIX, GNUNET_FS_URI_PREFIX, GNUNET_malloc, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, needs_percent(), ret, GNUNET_FS_Uri::type, and uri.

Referenced by GNUNET_FS_uri_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uri_sks_to_string()

static char * uri_sks_to_string ( const struct GNUNET_FS_Uri * uri )

static

Convert SKS URI to a string.

Parameters

uri	sks uri to convert

Returns: NULL on error

Definition at line 1929 of file fs_uri.c.

{
  char *ret;
  char buf[1024];
 
  if (GNUNET_FS_URI_SKS != uri->type)
    return NULL;
  ret =
    GNUNET_STRINGS_data_to_string (&uri->data.sks.ns,
                                   sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
                                   buf,
                                   sizeof(buf));
  GNUNET_assert (NULL != ret);
  ret[0] = '\0';
  GNUNET_asprintf (&ret,
                   "%s%s%s/%s",
                   GNUNET_FS_URI_PREFIX,
                   GNUNET_FS_URI_SKS_INFIX,
                   buf,
                   uri->data.sks.identifier);
  return ret;
}

References GNUNET_FS_Uri::data, GNUNET_asprintf(), GNUNET_assert, GNUNET_FS_URI_PREFIX, GNUNET_FS_URI_SKS, GNUNET_FS_URI_SKS_INFIX, GNUNET_STRINGS_data_to_string(), GNUNET_FS_Uri::identifier, GNUNET_FS_Uri::ns, ret, GNUNET_FS_Uri::sks, GNUNET_FS_Uri::type, and uri.

Referenced by GNUNET_FS_uri_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uri_chk_to_string()

static char * uri_chk_to_string ( const struct GNUNET_FS_Uri * uri )

static

Convert a CHK URI to a string.

Parameters

uri	chk uri to convert

Returns: NULL on error

Definition at line 1960 of file fs_uri.c.

{
  const struct FileIdentifier *fi;
  char *ret;
  struct GNUNET_CRYPTO_HashAsciiEncoded keyhash;
  struct GNUNET_CRYPTO_HashAsciiEncoded queryhash;
 
  if (uri->type != GNUNET_FS_URI_CHK)
    return NULL;
  fi = &uri->data.chk;
  GNUNET_CRYPTO_hash_to_enc (&fi->chk.key, &keyhash);
  GNUNET_CRYPTO_hash_to_enc (&fi->chk.query, &queryhash);
 
  GNUNET_asprintf (&ret,
                   "%s%s%s.%s.%llu",
                   GNUNET_FS_URI_PREFIX,
                   GNUNET_FS_URI_CHK_INFIX,
                   (const char *) &keyhash,
                   (const char *) &queryhash,
                   (unsigned long long) GNUNET_ntohll (fi->file_length));
  return ret;
}

References FileIdentifier::chk, GNUNET_FS_Uri::chk, GNUNET_FS_Uri::data, FileIdentifier::file_length, GNUNET_asprintf(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_FS_URI_CHK, GNUNET_FS_URI_CHK_INFIX, GNUNET_FS_URI_PREFIX, GNUNET_ntohll(), ContentHashKey::key, ContentHashKey::query, ret, GNUNET_FS_Uri::type, and uri.

Referenced by GNUNET_FS_uri_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uri_loc_to_string()

static char * uri_loc_to_string ( const struct GNUNET_FS_Uri * uri )

static

Convert a LOC URI to a string.

Parameters

uri	loc uri to convert

Returns: NULL on error

Definition at line 1991 of file fs_uri.c.

{
  char *ret;
  struct GNUNET_CRYPTO_HashAsciiEncoded keyhash;
  struct GNUNET_CRYPTO_HashAsciiEncoded queryhash;
  char *peer_id;
  char peer_sig[SIGNATURE_ASCII_LENGTH + 1];
 
  GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.key, &keyhash);
  GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.query, &queryhash);
  peer_id =
    GNUNET_CRYPTO_eddsa_public_key_to_string (&uri->data.loc.peer.public_key);
  GNUNET_assert (
    NULL !=
    GNUNET_STRINGS_data_to_string (&uri->data.loc.contentSignature,
                                   sizeof(struct GNUNET_CRYPTO_EddsaSignature),
                                   peer_sig,
                                   sizeof(peer_sig)));
  GNUNET_asprintf (&ret,
                   "%s%s%s.%s.%llu.%s.%s.%llu",
                   GNUNET_FS_URI_PREFIX,
                   GNUNET_FS_URI_LOC_INFIX,
                   (const char *) &keyhash,
                   (const char *) &queryhash,
                   (unsigned long long) GNUNET_ntohll (
                     uri->data.loc.fi.file_length),
                   peer_id,
                   peer_sig,
                   (unsigned long long)
                   uri->data.loc.expirationTime.abs_value_us
                   / 1000000LL);
  GNUNET_free (peer_id);
  return ret;
}

References GNUNET_TIME_Absolute::abs_value_us, FileIdentifier::chk, Location::contentSignature, GNUNET_FS_Uri::data, Location::expirationTime, Location::fi, FileIdentifier::file_length, GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_free, GNUNET_FS_URI_LOC_INFIX, GNUNET_FS_URI_PREFIX, GNUNET_ntohll(), GNUNET_STRINGS_data_to_string(), ContentHashKey::key, GNUNET_FS_Uri::loc, Location::peer, peer_id, GNUNET_PeerIdentity::public_key, ContentHashKey::query, ret, SIGNATURE_ASCII_LENGTH, and uri.

Referenced by GNUNET_FS_uri_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ GNUNET_FS_URI_KSK_PREFIX

◆ GNUNET_FS_URI_SKS_PREFIX

◆ GNUNET_FS_URI_CHK_PREFIX

◆ GNUNET_FS_URI_LOC_PREFIX

◆ SIGNATURE_ASCII_LENGTH

◆ TOKENS

Function Documentation

◆ percent_decode_keyword()

◆ uri_ksk_parse()

◆ uri_sks_parse()

◆ uri_chk_parse()

◆ uri_loc_parse()

◆ insert_non_mandatory_keyword()

◆ find_duplicate()

◆ normalize_metadata()

◆ u8_strcount()

◆ get_keywords_from_parens()

◆ get_keywords_from_tokens()

◆ gather_uri_data()

◆ needs_percent()

◆ uri_ksk_to_string()

◆ uri_sks_to_string()

◆ uri_chk_to_string()

◆ uri_loc_to_string()