/*
This file is part of GNUnet.
- (C) 2003--2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2003--2014 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
case GNUNET_FS_URI_LOC:
GNUNET_CRYPTO_hash (&uri->data.loc.fi,
sizeof (struct FileIdentifier) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
+ sizeof (struct GNUNET_PeerIdentity),
key);
break;
default:
* @return decodded string with leading space (or preserved plus)
*/
static char *
-percent_decode_keyword (const char *in, char **emsg)
+percent_decode_keyword (const char *in,
+ char **emsg)
{
char *out;
char *ret;
{
GNUNET_free (out);
*emsg = GNUNET_strdup (_(/* xgettext:no-c-format */
- "`%' must be followed by HEX number"));
+ "Malformed KSK URI (`%' must be followed by HEX number)"));
return NULL;
}
rpos += 3;
* @return NULL on error, otherwise the KSK URI
*/
static struct GNUNET_FS_Uri *
-uri_ksk_parse (const char *s, char **emsg)
+uri_ksk_parse (const char *s,
+ char **emsg)
{
struct GNUNET_FS_Uri *ret;
char **keywords;
char *dup;
int saw_quote;
- GNUNET_assert (NULL != s);
slen = strlen (s);
pos = strlen (GNUNET_FS_URI_KSK_PREFIX);
if ((slen <= pos) || (0 != strncmp (s, GNUNET_FS_URI_KSK_PREFIX, pos)))
max++;
if (s[i - 1] == '+')
{
- *emsg = GNUNET_strdup (_("`++' not allowed in KSK URI"));
+ *emsg = GNUNET_strdup (_("Malformed KSK URI (`++' not allowed)"));
return NULL;
}
}
}
if (saw_quote == 1)
{
- *emsg = GNUNET_strdup (_("Quotes not balanced in KSK URI"));
+ *emsg = GNUNET_strdup (_("Malformed KSK URI (quotes not balanced)"));
return NULL;
}
iret = max;
dup = GNUNET_strdup (s);
- keywords = GNUNET_malloc (max * sizeof (char *));
- for (i = slen - 1; i >= pos; i--)
+ 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;
- i += 3;
continue;
}
if ((dup[i] == '+') && (saw_quote == 0))
keywords[--max] = percent_decode_keyword (&dup[pos], emsg);
if (NULL == keywords[max])
goto CLEANUP;
- GNUNET_assert (max == 0);
+ GNUNET_assert (0 == max);
GNUNET_free (dup);
ret = GNUNET_new (struct GNUNET_FS_Uri);
ret->type = GNUNET_FS_URI_KSK;
* @return NULL on error, SKS URI otherwise
*/
static struct GNUNET_FS_Uri *
-uri_sks_parse (const char *s, char **emsg)
+uri_sks_parse (const char *s,
+ char **emsg)
{
struct GNUNET_FS_Uri *ret;
- struct GNUNET_CRYPTO_EccPublicSignKey ns;
+ struct GNUNET_CRYPTO_EcdsaPublicKey ns;
size_t pos;
char *end;
- GNUNET_assert (s != NULL);
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 */
&ns,
sizeof (ns))) )
{
- *emsg = GNUNET_strdup (_("Malformed SKS URI"));
+ *emsg = GNUNET_strdup (_("Malformed SKS URI (wrong syntax)"));
return NULL; /* malformed */
}
end++; /* skip over '/' */
* @return NULL on error, CHK URI otherwise
*/
static struct GNUNET_FS_Uri *
-uri_chk_parse (const char *s, char **emsg)
+uri_chk_parse (const char *s,
+ char **emsg)
{
struct GNUNET_FS_Uri *ret;
struct FileIdentifier fi;
char h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
char h2[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
- if (NULL == s)
- return NULL;
- GNUNET_assert (s != NULL);
slen = strlen (s);
pos = strlen (GNUNET_FS_URI_CHK_PREFIX);
if ((slen < pos + 2 * sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) + 1) ||
if ((s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
(s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.'))
{
- *emsg = GNUNET_strdup (_("Malformed CHK URI"));
+ *emsg = GNUNET_strdup (_("Malformed CHK URI (wrong syntax)"));
return NULL;
}
- memcpy (h1, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+ GNUNET_memcpy (h1, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
- memcpy (h2, &s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)],
+ GNUNET_memcpy (h2, &s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)],
sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
h2[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
SSCANF (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
"%llu", &flen)))
{
- *emsg = GNUNET_strdup (_("Malformed CHK URI"));
+ *emsg = GNUNET_strdup (_("Malformed CHK URI (failed to decode CHK)"));
return NULL;
}
fi.file_length = GNUNET_htonll (flen);
}
-/**
- * Convert a character back to the binary value
- * that it represents (given base64-encoding).
- *
- * @param a character to convert
- * @return offset in the "tbl" array
- */
-static unsigned int
-c2v (unsigned char a)
-{
- if ((a >= '0') && (a <= '9'))
- return a - '0';
- if ((a >= 'A') && (a <= 'Z'))
- return (a - 'A' + 10);
- if ((a >= 'a') && (a <= 'z'))
- return (a - 'a' + 36);
- if (a == '_')
- return 62;
- if (a == '=')
- return 63;
- return -1;
-}
-
-
-/**
- * Convert string back to binary data.
- *
- * @param input '\\0'-terminated string
- * @param data where to write binary data
- * @param size how much data should be converted
- * @return number of characters processed from input,
- * -1 on error
- */
-static int
-enc2bin (const char *input, void *data, size_t size)
-{
- size_t len;
- size_t pos;
- unsigned int bits;
- unsigned int hbits;
-
- len = size * 8 / 6;
- if (((size * 8) % 6) != 0)
- len++;
- if (strlen (input) < len)
- return -1; /* error! */
- bits = 0;
- hbits = 0;
- len = 0;
- for (pos = 0; pos < size; pos++)
- {
- while (hbits < 8)
- {
- bits |= (c2v (input[len++]) << hbits);
- hbits += 6;
- }
- (((unsigned char *) data)[pos]) = (unsigned char) bits;
- bits >>= 8;
- hbits -= 8;
- }
- return len;
-}
-
-
GNUNET_NETWORK_STRUCT_BEGIN
/**
* Structure that defines how the contents of a location URI must be
#define GNUNET_FS_URI_LOC_PREFIX GNUNET_FS_URI_PREFIX GNUNET_FS_URI_LOC_INFIX
+#define SIGNATURE_ASCII_LENGTH 103
+
/**
* Parse a LOC URI.
* Also verifies validity of the location URI.
* @return NULL on error, valid LOC URI otherwise
*/
static struct GNUNET_FS_Uri *
-uri_loc_parse (const char *s, char **emsg)
+uri_loc_parse (const char *s,
+ char **emsg)
{
struct GNUNET_FS_Uri *uri;
char h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
unsigned long long exptime;
unsigned long long flen;
struct GNUNET_TIME_Absolute et;
- struct GNUNET_CRYPTO_EccSignature sig;
+ struct GNUNET_CRYPTO_EddsaSignature sig;
struct LocUriAssembly ass;
- int ret;
size_t slen;
- GNUNET_assert (s != NULL);
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 an SKS URI */
+ 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 (_("SKS URI malformed"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed (wrong syntax)"));
return NULL;
}
- memcpy (h1, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+ GNUNET_memcpy (h1, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
- memcpy (h2, &s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)],
+ GNUNET_memcpy (h2, &s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)],
sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
h2[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
SSCANF (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
"%llu", &flen)))
{
- *emsg = GNUNET_strdup (_("LOC URI malformed"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed (no CHK)"));
return NULL;
}
ass.fi.file_length = GNUNET_htonll (flen);
npos++;
if (s[npos] == '\0')
{
- *emsg = GNUNET_strdup (_("LOC URI malformed"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed (missing LOC)"));
goto ERR;
}
npos++;
- ret =
- enc2bin (&s[npos], &ass.peer,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
- if (ret == -1)
+ 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 += ret;
+ npos += GNUNET_CRYPTO_PKEY_ASCII_LENGTH;
if (s[npos++] != '.')
{
- *emsg = GNUNET_strdup (_("SKS URI malformed (could not find signature)"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed (could not find signature)"));
goto ERR;
}
- ret = enc2bin (&s[npos], &sig, sizeof (struct GNUNET_CRYPTO_EccSignature));
- if (ret == -1)
+ if ( (strlen (&s[npos]) <= SIGNATURE_ASCII_LENGTH + 1) ||
+ ('.' != s[npos + SIGNATURE_ASCII_LENGTH]) )
{
- *emsg = GNUNET_strdup (_("SKS URI malformed (could not decode signature)"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed (wrong syntax for signature)"));
goto ERR;
}
- npos += ret;
+ 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 (_("SKS URI malformed"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed (wrong syntax for expiration time)"));
goto ERR;
}
if (1 != SSCANF (&s[npos], "%llu", &exptime))
{
*emsg =
- GNUNET_strdup (_
- ("SKS URI malformed (could not parse expiration time)"));
+ GNUNET_strdup (_("LOC URI malformed (could not parse expiration time)"));
goto ERR;
}
ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
et.abs_value_us = exptime * 1000LL * 1000LL;
ass.exptime = GNUNET_TIME_absolute_hton (et);
if (GNUNET_OK !=
- GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
- &ass.purpose, &sig, &ass.peer.public_key))
+ GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
+ &ass.purpose, &sig, &ass.peer.public_key))
{
*emsg =
- GNUNET_strdup (_("SKS URI malformed (signature failed validation)"));
+ GNUNET_strdup (_("LOC URI malformed (signature failed validation)"));
goto ERR;
}
uri = GNUNET_new (struct GNUNET_FS_Uri);
* @return NULL on error
*/
struct GNUNET_FS_Uri *
-GNUNET_FS_uri_parse (const char *uri, char **emsg)
+GNUNET_FS_uri_parse (const char *uri,
+ char **emsg)
{
struct GNUNET_FS_Uri *ret;
char *msg;
+ if (NULL == uri)
+ {
+ GNUNET_break (0);
+ if (NULL != emsg)
+ *emsg = GNUNET_strdup (_("invalid argument"));
+ return NULL;
+ }
if (NULL == emsg)
emsg = &msg;
*emsg = NULL;
{
unsigned int i;
- GNUNET_assert (uri != NULL);
switch (uri->type)
{
case GNUNET_FS_URI_KSK:
GNUNET_free (uri);
}
+
/**
* How many keywords are ANDed in this keyword URI?
*
if (uri->type != GNUNET_FS_URI_KSK)
return -1;
- if (iterator == NULL)
+ if (NULL == iterator)
return uri->data.ksk.keywordCount;
for (i = 0; i < uri->data.ksk.keywordCount; i++)
{
* @param is_mandatory is this keyword mandatory?
*/
void
-GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri, const char *keyword,
+GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri,
+ const char *keyword,
int is_mandatory)
{
unsigned int i;
}
-
/**
* Obtain the URI of the content itself.
*
/**
* Construct a location URI (this peer will be used for the location).
+ * This function should only be called from within gnunet-service-fs,
+ * as it requires the peer's private key which is generally unavailable
+ * to processes directly under the user's control. However, for
+ * testing and as it logically fits under URIs, it is in this API.
*
- * @param baseUri content offered by the sender
- * @param cfg configuration information (used to find our hostkey)
+ * @param base_uri content offered by the sender
+ * @param sign_key private key of the peer
* @param expiration_time how long will the content be offered?
* @return the location URI, NULL on error
*/
struct GNUNET_FS_Uri *
-GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+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)
{
struct GNUNET_FS_Uri *uri;
- struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
- struct GNUNET_CRYPTO_EccPublicSignKey my_public_key;
- char *keyfile;
+ struct GNUNET_CRYPTO_EddsaPublicKey my_public_key;
struct LocUriAssembly ass;
struct GNUNET_TIME_Absolute et;
- if (baseUri->type != GNUNET_FS_URI_CHK)
+ if (GNUNET_FS_URI_CHK != base_uri->type)
return NULL;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER", "PRIVATE_KEY",
- &keyfile))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Lacking key configuration settings.\n"));
- return NULL;
- }
- if (NULL == (my_private_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not access hostkey file `%s'.\n"), keyfile);
- GNUNET_free (keyfile);
- return NULL;
- }
- GNUNET_free (keyfile);
/* we round expiration time to full seconds for SKS URIs */
et.abs_value_us = (expiration_time.abs_value_us / 1000000LL) * 1000000LL;
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key, &my_public_key);
+ GNUNET_CRYPTO_eddsa_key_get_public (sign_key,
+ &my_public_key);
ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
ass.exptime = GNUNET_TIME_absolute_hton (et);
- ass.fi = baseUri->data.chk;
+ ass.fi = base_uri->data.chk;
ass.peer.public_key = my_public_key;
uri = GNUNET_new (struct GNUNET_FS_Uri);
uri->type = GNUNET_FS_URI_LOC;
- uri->data.loc.fi = baseUri->data.chk;
+ uri->data.loc.fi = base_uri->data.chk;
uri->data.loc.expirationTime = et;
uri->data.loc.peer.public_key = my_public_key;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_ecc_sign (my_private_key, &ass.purpose,
- &uri->data.loc.contentSignature));
- GNUNET_free (my_private_key);
+ GNUNET_CRYPTO_eddsa_sign (sign_key,
+ &ass.purpose,
+ &uri->data.loc.contentSignature));
return uri;
}
* @return an FS URI for the given namespace and identifier
*/
struct GNUNET_FS_Uri *
-GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EccPublicSignKey *ns,
+GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
const char *id)
{
struct GNUNET_FS_Uri *ns_uri;
return NULL;
}
kc = u1->data.ksk.keywordCount;
- kl = GNUNET_malloc ((kc + u2->data.ksk.keywordCount) * sizeof (char *));
+ kl = GNUNET_new_array (kc + u2->data.ksk.keywordCount,
+ char *);
for (i = 0; i < u1->data.ksk.keywordCount; i++)
kl[i] = GNUNET_strdup (u1->data.ksk.keywords[i]);
for (i = 0; i < u2->data.ksk.keywordCount; i++)
if (uri == NULL)
return NULL;
ret = GNUNET_new (struct GNUNET_FS_Uri);
- memcpy (ret, uri, sizeof (struct GNUNET_FS_Uri));
+ GNUNET_memcpy (ret, uri, sizeof (struct GNUNET_FS_Uri));
switch (ret->type)
{
case GNUNET_FS_URI_KSK:
}
if (ret->data.ksk.keywordCount > 0)
{
- ret->data.ksk.keywords =
- GNUNET_malloc (ret->data.ksk.keywordCount * sizeof (char *));
+ ret->data.ksk.keywords
+ = GNUNET_new_array (ret->data.ksk.keywordCount,
+ char *);
for (i = 0; i < ret->data.ksk.keywordCount; i++)
ret->data.ksk.keywords[i] = GNUNET_strdup (uri->data.ksk.keywords[i]);
}
* if keywords is not legal (i.e. empty).
*/
struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create (const char *keywords, char **emsg)
+GNUNET_FS_uri_ksk_create (const char *keywords,
+ char **emsg)
{
char **keywordarr;
unsigned int num_Words;
*emsg = GNUNET_strdup (_("Number of double-quotes not balanced!\n"));
return NULL;
}
- keywordarr = GNUNET_malloc (num_Words * sizeof (char *));
+ keywordarr = GNUNET_new_array (num_Words,
+ char *);
num_Words = 0;
inWord = 0;
pos = searchString;
* if keywords is not legal (i.e. empty).
*/
struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create_from_args (unsigned int argc, const char **argv)
+GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
+ const char **argv)
{
unsigned int i;
struct GNUNET_FS_Uri *uri;
uri = GNUNET_new (struct GNUNET_FS_Uri);
uri->type = GNUNET_FS_URI_KSK;
uri->data.ksk.keywordCount = argc;
- uri->data.ksk.keywords = GNUNET_malloc (argc * sizeof (char *));
+ uri->data.ksk.keywords = GNUNET_new_array (argc,
+ char *);
for (i = 0; i < argc; i++)
{
keyword = argv[i];
*
* @param u1 one of the URIs
* @param u2 the other URI
- * @return GNUNET_YES if the URIs are equal
+ * @return #GNUNET_YES if the URIs are equal
*/
int
GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
case GNUNET_FS_URI_SKS:
if ((0 ==
memcmp (&u1->data.sks.ns, &u2->data.sks.ns,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey))) &&
+ sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) &&
(0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))
return GNUNET_YES;
if (memcmp
(&u1->data.loc, &u2->data.loc,
sizeof (struct FileIdentifier) +
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
+ sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
sizeof (struct GNUNET_TIME_Absolute) + sizeof (unsigned short) +
sizeof (unsigned short)) != 0)
return GNUNET_NO;
* Is this a namespace URI?
*
* @param uri the uri to check
- * @return GNUNET_YES if this is an SKS uri
+ * @return #GNUNET_YES if this is an SKS uri
*/
int
GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
*
* @param uri the uri to get the namespace ID from
* @param pseudonym where to store the ID of the namespace
- * @return GNUNET_OK on success
+ * @return #GNUNET_OK on success
*/
int
GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
- struct GNUNET_CRYPTO_EccPublicSignKey *pseudonym)
+ struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym)
{
if (!GNUNET_FS_uri_test_sks (uri))
{
* Is this a file (or directory) URI?
*
* @param uri the uri to check
- * @return GNUNET_YES if this is a CHK uri
+ * @return #GNUNET_YES if this is a CHK uri
*/
int
GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
* Is this a location URI?
*
* @param uri the uri to check
- * @return GNUNET_YES if this is a LOC uri
+ * @return #GNUNET_YES if this is a LOC uri
*/
int
GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
* @param index offset where to add the keyword
*/
static void
-insert_non_mandatory_keyword (const char *s, char **array, int index)
+insert_non_mandatory_keyword (const char *s,
+ char **array,
+ int index)
{
char *nkword;
* @return #GNUNET_YES if the keyword exists, #GNUNET_NO if not
*/
static int
-find_duplicate (const char *s, const char **array, int array_length)
+find_duplicate (const char *s,
+ const char **array,
+ int array_length)
{
int j;
{
/* u8_tolower allocates a non-NULL-terminated string! */
free_str = GNUNET_malloc (r_len + 1);
- memcpy (free_str, normalized, r_len);
+ GNUNET_memcpy (free_str, normalized, r_len);
free_str[r_len] = '\0';
free (normalized);
normalized = free_str;
return (char *) normalized;
}
+
/**
* Counts the number of UTF-8 characters (not bytes) in the string,
* returns that count.
* @param array array to fill with enclosed tokens. If NULL, then tokens
* are only counted.
* @param index index at which to start filling the array (entries prior
- * to it are used to check for duplicates). ignored if array == NULL.
+ * to it are used to check for duplicates). ignored if @a array == NULL.
* @return 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).
*/
static int
-get_keywords_from_parens (const char *s, char **array, int index)
+get_keywords_from_parens (const char *s,
+ char **array,
+ int index)
{
int count = 0;
char *open_paren;
* @param array array to fill with tokens. If NULL, then tokens are only
* counted.
* @param index index at which to start filling the array (entries prior
- * to it are used to check for duplicates). ignored if array == NULL.
+ * to it are used to check for duplicates). ignored if @a array == NULL.
* @return 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).
*/
static int
-get_keywords_from_tokens (const char *s, char **array, int index)
+get_keywords_from_tokens (const char *s,
+ char **array,
+ int index)
{
char *p;
char *ss;
}
/* x3 because there might be a normalized variant of every keyword,
plus theoretically one more for mime... */
- ret->data.ksk.keywords = GNUNET_malloc
- (sizeof (char *) * (ent + tok_keywords + paren_keywords) * 3);
+ ret->data.ksk.keywords
+ = GNUNET_new_array ((ent + tok_keywords + paren_keywords) * 3,
+ char *);
GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
}
if (tok_keywords > 0)
if (GNUNET_FS_URI_SKS != uri->type)
return NULL;
ret = GNUNET_STRINGS_data_to_string (&uri->data.sks.ns,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
+ sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
buf,
sizeof (buf));
GNUNET_assert (NULL != ret);
return ret;
}
-/**
- * Convert binary data to a string.
- *
- * @param data binary data to convert
- * @param size number of bytes in data
- * @return converted data
- */
-static char *
-bin2enc (const void *data, size_t size)
-{
- /**
- * 64 characters for encoding, 6 bits per character
- */
- static char *tbl =
- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_=";
-
- size_t len;
- size_t pos;
- unsigned int bits;
- unsigned int hbits;
- char *ret;
-
- GNUNET_assert (strlen (tbl) == 64);
- len = size * 8 / 6;
- if (((size * 8) % 6) != 0)
- len++;
- ret = GNUNET_malloc (len + 1);
- ret[len] = '\0';
- len = 0;
- bits = 0;
- hbits = 0;
- for (pos = 0; pos < size; pos++)
- {
- bits |= ((((const unsigned char *) data)[pos]) << hbits);
- hbits += 8;
- while (hbits >= 6)
- {
- ret[len++] = tbl[bits & 63];
- bits >>= 6;
- hbits -= 6;
- }
- }
- if (hbits > 0)
- ret[len] = tbl[bits & 63];
- return ret;
-}
-
/**
* Convert a LOC URI to a string.
char *ret;
struct GNUNET_CRYPTO_HashAsciiEncoded keyhash;
struct GNUNET_CRYPTO_HashAsciiEncoded queryhash;
- char *peerId;
- char *peerSig;
+ 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);
- peerId =
- bin2enc (&uri->data.loc.peer,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
- peerSig =
- bin2enc (&uri->data.loc.contentSignature,
- sizeof (struct GNUNET_CRYPTO_EccSignature));
+ 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), peerId,
- peerSig,
+ fi.file_length),
+ peer_id,
+ peer_sig,
(unsigned long long) uri->data.loc.expirationTime.abs_value_us / 1000000LL);
- GNUNET_free (peerSig);
- GNUNET_free (peerId);
+ GNUNET_free (peer_id);
return ret;
}