case GNUNET_FS_URI_LOC:
GNUNET_CRYPTO_hash (&uri->data.loc.fi,
sizeof (struct FileIdentifier) +
- sizeof (struct GNUNET_CRYPTO_EccPublicKey),
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
key);
break;
default:
uri_sks_parse (const char *s, char **emsg)
{
struct GNUNET_FS_Uri *ret;
- struct GNUNET_CRYPTO_EccPublicKey ns;
+ struct GNUNET_CRYPTO_EccPublicSignKey ns;
size_t pos;
char *end;
/**
* Peer offering the file.
*/
- struct GNUNET_CRYPTO_EccPublicKey peer;
+ struct GNUNET_CRYPTO_EccPublicSignKey peer;
};
GNUNET_NETWORK_STRUCT_END
SSCANF (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
"%llu", &flen)))
{
- *emsg = GNUNET_strdup (_("SKS URI malformed"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed"));
return NULL;
}
ass.fi.file_length = GNUNET_htonll (flen);
npos++;
if (s[npos] == '\0')
{
- *emsg = GNUNET_strdup (_("SKS URI malformed"));
+ *emsg = GNUNET_strdup (_("LOC URI malformed"));
goto ERR;
}
npos++;
ret =
enc2bin (&s[npos], &ass.peer,
- sizeof (struct GNUNET_CRYPTO_EccPublicKey));
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
if (ret == -1)
{
*emsg =
- GNUNET_strdup (_("SKS URI malformed (could not decode public key)"));
+ GNUNET_strdup (_("LOC URI malformed (could not decode public key)"));
goto ERR;
}
npos += ret;
}
ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
- et.abs_value = exptime;
+ 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,
if (uri->type != GNUNET_FS_URI_LOC)
return GNUNET_SYSERR;
GNUNET_CRYPTO_hash (&uri->data.loc.peer,
- sizeof (struct GNUNET_CRYPTO_EccPublicKey),
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
&peer->hashPubKey);
return GNUNET_OK;
}
{
struct GNUNET_FS_Uri *uri;
struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
- struct GNUNET_CRYPTO_EccPublicKey my_public_key;
+ struct GNUNET_CRYPTO_EccPublicSignKey my_public_key;
char *keyfile;
struct LocUriAssembly ass;
+ struct GNUNET_TIME_Absolute et;
if (baseUri->type != GNUNET_FS_URI_CHK)
return NULL;
return NULL;
}
GNUNET_free (keyfile);
- GNUNET_CRYPTO_ecc_key_get_public (my_private_key, &my_public_key);
+ /* 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);
ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
- ass.exptime = GNUNET_TIME_absolute_hton (expiration_time);
+ ass.exptime = GNUNET_TIME_absolute_hton (et);
ass.fi = baseUri->data.chk;
ass.peer = 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.expirationTime = expiration_time;
+ uri->data.loc.expirationTime = et;
uri->data.loc.peer = my_public_key;
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_ecc_sign (my_private_key, &ass.purpose,
&uri->data.loc.contentSignature));
- GNUNET_CRYPTO_ecc_key_free (my_private_key);
+ GNUNET_free (my_private_key);
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_EccPublicKey *ns,
+GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EccPublicSignKey *ns,
const char *id)
{
struct GNUNET_FS_Uri *ns_uri;
case GNUNET_FS_URI_SKS:
if ((0 ==
memcmp (&u1->data.sks.ns, &u2->data.sks.ns,
- sizeof (struct GNUNET_CRYPTO_EccPublicKey))) &&
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey))) &&
(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_EccPublicKey) +
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
sizeof (struct GNUNET_TIME_Absolute) + sizeof (unsigned short) +
sizeof (unsigned short)) != 0)
return GNUNET_NO;
*/
int
GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
- struct GNUNET_CRYPTO_EccPublicKey *pseudonym)
+ struct GNUNET_CRYPTO_EccPublicSignKey *pseudonym)
{
if (!GNUNET_FS_uri_test_sks (uri))
{
}
-/**
- * Convert namespace URI to a human readable format
- * (using the namespace description, if available).
- *
- * @param cfg configuration to use
- * @param uri SKS uri to convert
- * @return NULL on error (not an SKS URI)
- */
-char *
-GNUNET_FS_uri_sks_to_string_fancy (struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_FS_Uri *uri)
-{
- char *ret;
- char *name;
- char *unique_name;
-
- if (uri->type != GNUNET_FS_URI_SKS)
- return NULL;
- (void) GNUNET_FS_pseudonym_get_info (cfg, &uri->data.sks.ns,
- NULL, NULL, &name, NULL);
- unique_name = GNUNET_FS_pseudonym_name_uniquify (cfg, &uri->data.sks.ns, name, NULL);
- GNUNET_free (name);
- GNUNET_asprintf (&ret, "%s: %s", unique_name, uri->data.sks.identifier);
- GNUNET_free (unique_name);
- return ret;
-}
-
-
/**
* Is this a keyword URI?
*
* @param uri the uri
- * @return GNUNET_YES if this is a KSK uri
+ * @return #GNUNET_YES if this is a KSK uri
*/
int
GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
if (GNUNET_FS_URI_SKS != uri->type)
return NULL;
ret = GNUNET_STRINGS_data_to_string (&uri->data.sks.ns,
- sizeof (struct GNUNET_CRYPTO_EccPublicKey),
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
buf,
sizeof (buf));
GNUNET_assert (NULL != ret);
GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.query, &queryhash);
peerId =
bin2enc (&uri->data.loc.peer,
- sizeof (struct GNUNET_CRYPTO_EccPublicKey));
+ sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
peerSig =
bin2enc (&uri->data.loc.contentSignature,
sizeof (struct GNUNET_CRYPTO_EccSignature));
- GNUNET_asprintf (&ret, "%s%s%s.%s.%llu.%s.%s.%llu", GNUNET_FS_URI_PREFIX,
+ 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,
- (unsigned long long) uri->data.loc.expirationTime.abs_value);
+ (unsigned long long) uri->data.loc.expirationTime.abs_value_us / 1000000LL);
GNUNET_free (peerSig);
GNUNET_free (peerId);
return ret;