/**
* name to shorten
*/
- char name[MAX_DNS_NAME_LENGTH];
+ char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
/**
* name of private zone (relative to root)
*/
- char private_zone_id[MAX_DNS_NAME_LENGTH];
+ char private_zone_id[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
/**
* name of shorten zone (relative to root)
*/
- char shorten_zone_id[MAX_DNS_NAME_LENGTH];
+ char shorten_zone_id[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
};
/**
* optional zone private key used for shorten
*/
- struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key;
+ struct GNUNET_CRYPTO_EccPrivateKey *shorten_key;
/**
* the name to look up
/**
* Our zone's private key
*/
-static struct GNUNET_CRYPTO_RsaPrivateKey *zone_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *zone_key;
/**
* Our handle to the namestore service
struct ClientShortenHandle *csh_tmp;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Shutting down!");
+ "Shutting down!\n");
while (NULL != (csh_tmp = csh_head))
{
GNUNET_CONTAINER_DLL_remove (csh_head, csh_tail, csh_tmp);
*/
static void
put_gns_record (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct GNSNameRecordBlock *nrb;
struct GNUNET_CRYPTO_ShortHashCode zhash;
nrb_data += namelen;
rd_payload_length += sizeof(struct GNSNameRecordBlock) + namelen;
GNUNET_CRYPTO_short_hash (key,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
&zhash);
if (-1 == GNUNET_NAMESTORE_records_serialize (rd_count,
rd,
*/
static void
process_shorten_in_private_zone_lookup (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ClientShortenHandle *csh = cls;
struct GNUNET_CRYPTO_ShortHashCode *szone = &csh->shorten_zone;
*/
static void
process_shorten_in_root_zone_lookup (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ClientShortenHandle *csh = cls;
struct GNUNET_CRYPTO_ShortHashCode *szone = &csh->shorten_zone;
*/
static void
process_private_in_root_zone_lookup (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ClientShortenHandle *csh = cls;
{
struct ClientShortenHandle *csh;
const char *utf_in;
- char name[MAX_DNS_NAME_LENGTH];
+ char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
char* nameptr = name;
uint16_t msg_size;
const struct GNUNET_GNS_ClientShortenMessage *sh_msg;
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
- if (strlen (name) > MAX_DNS_NAME_LENGTH)
+ if (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"SHORTEN: %s is too long\n", name);
{
struct ClientGetAuthHandle *cah;
const char *utf_in;
- char name[MAX_DNS_NAME_LENGTH];
+ char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
char* nameptr = name;
uint16_t msg_size;
const struct GNUNET_GNS_ClientGetAuthMessage *sh_msg;
send_get_auth_response(cah, name);
return;
}
- if (strlen (name) > MAX_DNS_NAME_LENGTH)
+ if (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GET_AUTH: `%s' is too long", name);
GNUNET_free(clh->name);
if (NULL != clh->shorten_key)
- GNUNET_CRYPTO_rsa_key_free (clh->shorten_key);
+ GNUNET_CRYPTO_ecc_key_free (clh->shorten_key);
GNUNET_free (clh);
GNUNET_STATISTICS_update (statistics,
"Completed lookups", 1, GNUNET_NO);
const struct GNUNET_MessageHeader * message)
{
size_t namelen;
- char name[MAX_DNS_NAME_LENGTH];
+ char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
struct ClientLookupHandle *clh;
char* nameptr = name;
const char *utf_in;
int only_cached;
- struct GNUNET_CRYPTO_RsaPrivateKey *key;
- struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey;
+ struct GNUNET_CRYPTO_EccPrivateKey *key;
+ struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *pkey;
char* tmp_pkey;
uint16_t msg_size;
const struct GNUNET_GNS_ClientLookupMessage *sh_msg;
GNUNET_SERVER_notification_context_add (nc, client);
if (GNUNET_YES == ntohl (sh_msg->have_key))
{
- pkey = (struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *) &sh_msg[1];
+ pkey = (struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *) &sh_msg[1];
tmp_pkey = (char*) &sh_msg[1];
- key = GNUNET_CRYPTO_rsa_decode_key (tmp_pkey, ntohs (pkey->len));
- GNUNET_STRINGS_utf8_tolower (&tmp_pkey[ntohs (pkey->len)], &nameptr);
+ key = GNUNET_CRYPTO_ecc_decode_key (tmp_pkey, ntohs (pkey->size),
+ GNUNET_NO);
+ GNUNET_STRINGS_utf8_tolower (&tmp_pkey[ntohs (pkey->size)], &nameptr);
}
else
{
only_cached = ntohl (sh_msg->only_cached);
- if (strlen (name) > MAX_DNS_NAME_LENGTH) {
+ if (strlen (name) > GNUNET_DNSPARSER_MAX_NAME_LENGTH) {
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"LOOKUP: %s is too long", name);
clh->name = NULL;
}
if (1 == ntohl (sh_msg->use_default_zone))
- clh->zone = zone_hash; //Default zone
+ clh->zone = zone_hash; /* Default zone */
else
clh->zone = sh_msg->zone;
{&handle_get_authority, NULL, GNUNET_MESSAGE_TYPE_GNS_GET_AUTH, 0}
};
char* keyfile;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+ struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
unsigned long long max_parallel_bg_queries = 0;
int ignore_pending = GNUNET_NO;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Using keyfile %s for root zone.\n", keyfile);
- zone_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
- GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
+ zone_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
+ GNUNET_CRYPTO_ecc_key_get_public (zone_key, &pkey);
GNUNET_CRYPTO_short_hash(&pkey,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
&zone_hash);
GNUNET_free(keyfile);
namestore_handle = GNUNET_NAMESTORE_connect (c);
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns", "HIJACK_DNS"))
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- "DNS hijacking enabled... connecting to service.\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "DNS hijacking enabled. Connecting to DNS service.\n");
- if (gns_interceptor_init(zone_hash, zone_key, c) == GNUNET_SYSERR)
+ if (GNUNET_SYSERR ==
+ gns_interceptor_init (zone_hash, zone_key, c))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- "Failed to enable the dns interceptor!\n");
+ "Failed to enable the DNS interceptor!\n");
}
}