/*
This file is part of GNUnet.
- (C) 2003--2014 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
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ Affero General Public License for more details.
- 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.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
* implementation is rather different in pretty much every detail.
* The concrete URI formats are:
*
+ * </p>
+ *
* <ul><li>
*
* First, there are URIs that identify a file. They have the format
*
* The encoding for hexadecimal values is defined in the hashing.c
* module in the gnunetutil library and discussed there.
- * <p>
+ *
*/
#include "platform.h"
#include "gnunet_fs_service.h"
*
* @param uri uri to convert to a unique key
* @param key where to store the unique key
+ * @return #GNUNET_OK on success
*/
-void
+int
GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri,
struct GNUNET_HashCode *key)
{
{
case GNUNET_FS_URI_CHK:
*key = uri->data.chk.chk.query;
- return;
+ return GNUNET_OK;
case GNUNET_FS_URI_SKS:
GNUNET_CRYPTO_hash (uri->data.sks.identifier,
- strlen (uri->data.sks.identifier), key);
- break;
+ strlen (uri->data.sks.identifier),
+ key);
+ return GNUNET_OK;
case GNUNET_FS_URI_KSK:
if (uri->data.ksk.keywordCount > 0)
+ {
GNUNET_CRYPTO_hash (uri->data.ksk.keywords[0],
- strlen (uri->data.ksk.keywords[0]), key);
+ strlen (uri->data.ksk.keywords[0]),
+ key);
+ return GNUNET_OK;
+ }
+ else
+ {
+ memset (key, 0, sizeof (struct GNUNET_HashCode));
+ return GNUNET_SYSERR;
+ }
break;
case GNUNET_FS_URI_LOC:
GNUNET_CRYPTO_hash (&uri->data.loc.fi,
sizeof (struct FileIdentifier) +
sizeof (struct GNUNET_PeerIdentity),
key);
- break;
+ return GNUNET_OK;
default:
memset (key, 0, sizeof (struct GNUNET_HashCode));
- break;
+ return GNUNET_SYSERR;
}
}
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)))
}
iret = max;
dup = GNUNET_strdup (s);
- keywords = GNUNET_malloc (max * sizeof (char *));
+ 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))
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 */
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) ||
*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';
*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';
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;
/**
* 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_EddsaPrivateKey *my_private_key;
struct GNUNET_CRYPTO_EddsaPublicKey my_public_key;
- char *keyfile;
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_eddsa_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_eddsa_key_get_public (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_eddsa_sign (my_private_key, &ass.purpose,
+ GNUNET_CRYPTO_eddsa_sign (sign_key,
+ &ass.purpose,
&uri->data.loc.contentSignature));
- GNUNET_free (my_private_key);
return 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]);
}
*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;
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];
{
/* 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;
}
/* 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)
projects / oweals / gnunet.git / blobdiff