*/
static char *lookup_name;
-
/**
* record type to look up (-t option)
*/
*/
static int raw;
+/**
+ * Requested record type.
+ */
static enum GNUNET_GNS_RecordType rtype;
-/* Handle to lookup request */
+/**
+ * Handle to lookup request
+ */
static struct GNUNET_GNS_LookupRequest *lookup_request;
-/* Handle to shorten request */
+/**
+ * Handle to shorten request
+ */
static struct GNUNET_GNS_ShortenRequest *shorten_request;
-/* Handle to get authority request */
+/**
+ * Handle to get authority request
+ */
static struct GNUNET_GNS_GetAuthRequest *getauth_request;
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != lookup_request)
+ {
GNUNET_GNS_cancel_lookup_request (lookup_request);
-
+ lookup_request = NULL;
+ }
if (NULL != shorten_request)
+ {
GNUNET_GNS_cancel_shorten_request (shorten_request);
-
+ shorten_request = NULL;
+ }
if (NULL != getauth_request)
+ {
GNUNET_GNS_cancel_get_auth_request (getauth_request);
-
+ getauth_request = NULL;
+ }
if (NULL != gns)
+ {
GNUNET_GNS_disconnect (gns);
+ gns = NULL;
+ }
}
+/**
+ * Function called with the result of a shorten operation.
+ * Prints the result.
+ *
+ * @param cls a 'const char *' with the original (long) name
+ * @param nshort the shortened name
+ */
static void
-process_shorten_result (void* cls, const char* nshort)
+process_shorten_result (void* cls, const char *nshort)
{
const char *original_name = cls;
}
+/**
+ * Function called with the result of a GADS lookup.
+ *
+ * @param cls the 'const char *' name that was resolved
+ * @param rd_count number of records returned
+ * @param rd array of 'rd_count' records with the results
+ */
static void
process_lookup_result (void* cls, uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
lookup_request = NULL;
if (!raw)
{
- if (rd_count == 0)
+ if (0 == rd_count)
printf("No results.\n");
else
printf("%s:\n", name);
}
+/**
+ * Function called with the result of an authority lookup.
+ *
+ * @param cls the 'const char *' with the name for which the
+ * authority was resolved
+ * @param auth name of the authority
+ */
static void
-process_auth_result (void* cls, const char* auth)
+process_auth_result (void* cls,
+ const char *auth)
{
getauth_request = NULL;
printf ("%s\n", auth);
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char* keyfile;
- struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+ struct GNUNET_CRYPTO_EccPrivateKey *key = NULL;
+ struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_ShortHashCode *zone = NULL;
struct GNUNET_CRYPTO_ShortHashCode user_zone;
struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
- struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key = NULL;
- struct GNUNET_CRYPTO_RsaPrivateKey *private_key = NULL;
+ struct GNUNET_CRYPTO_EccPrivateKey *shorten_key = NULL;
+ struct GNUNET_CRYPTO_EccPrivateKey *private_key = NULL;
struct GNUNET_CRYPTO_ShortHashCode *private_zone = NULL;
struct GNUNET_CRYPTO_ShortHashCode *shorten_zone = NULL;
}
else
{
- key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
- GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+ key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
+ GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
GNUNET_CRYPTO_short_hash (&pkey,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
&user_zone);
zone = &user_zone;
GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
if (!raw)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Using zone: %s!\n", &zonename);
- GNUNET_CRYPTO_rsa_key_free (key);
+ GNUNET_CRYPTO_ecc_key_free (key);
GNUNET_free(keyfile);
}
}
else
{
- shorten_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
- GNUNET_CRYPTO_rsa_key_get_public (shorten_key, &pkey);
+ shorten_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
+ GNUNET_CRYPTO_ecc_key_get_public (shorten_key, &pkey);
shorten_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
GNUNET_CRYPTO_short_hash(&pkey,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
shorten_zone);
GNUNET_CRYPTO_short_hash_to_enc (shorten_zone, &zonename);
if (! raw)
}
else
{
- private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
- GNUNET_CRYPTO_rsa_key_get_public (private_key, &pkey);
+ private_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
+ GNUNET_CRYPTO_ecc_key_get_public (private_key, &pkey);
private_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
GNUNET_CRYPTO_short_hash(&pkey,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof(struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
private_zone);
GNUNET_CRYPTO_short_hash_to_enc (private_zone, &zonename);
if (! raw)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Using private zone: %s!\n", &zonename);
- GNUNET_CRYPTO_rsa_key_free (private_key);
+ GNUNET_CRYPTO_ecc_key_free (private_key);
}
if (NULL != lookup_type)
else
rtype = GNUNET_GNS_RECORD_A;
- if ((NULL != shorten_name) && (NULL != shorten_zone) && (NULL != private_zone))
+ if ( (NULL != shorten_name) &&
+ (NULL != shorten_zone) &&
+ (NULL != private_zone) )
{
shorten_request = GNUNET_GNS_shorten_zone (gns, shorten_name,
- private_zone,
- shorten_zone,
- zone,
- &process_shorten_result,
- shorten_name);
+ private_zone,
+ shorten_zone,
+ zone,
+ &process_shorten_result,
+ shorten_name);
}
if (NULL != lookup_name)
{
rtype,
GNUNET_NO, /* Use DHT */
shorten_key,
- &process_lookup_result, lookup_name);
+ &process_lookup_result,
+ lookup_name);
}
if (NULL != auth_name)
{
}
if (NULL != shorten_key)
- GNUNET_CRYPTO_rsa_key_free (shorten_key);
+ GNUNET_CRYPTO_ecc_key_free (shorten_key);
if (NULL != shorten_zone)
GNUNET_free (shorten_zone);
if (NULL != private_zone)
GNUNET_free (private_zone);
- if ((NULL == auth_name) &&
- (NULL == shorten_name) &&
- (NULL == lookup_name))
+ if ( (NULL == auth_name) &&
+ (NULL == shorten_name) &&
+ (NULL == lookup_name))
{
fprintf (stderr,
_("Please specify lookup, shorten or authority operation!\n"));
GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
return;
}
-
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&do_shutdown, NULL);
}
main (int argc, char *const *argv)
{
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
- {'s', "shorten", NULL,
+ {'s', "shorten", "NAME",
gettext_noop ("try to shorten a given name"), 1,
&GNUNET_GETOPT_set_string, &shorten_name},
- {'u', "lookup", NULL,
+ {'u', "lookup", "NAME",
gettext_noop ("Lookup a record for the given name"), 1,
&GNUNET_GETOPT_set_string, &lookup_name},
- {'a', "authority", NULL,
+ {'a', "authority", "NAME",
gettext_noop ("Get the authority of a particular name"), 1,
&GNUNET_GETOPT_set_string, &auth_name},
- {'t', "type", NULL,
+ {'t', "type", "TYPE",
gettext_noop ("Specify the type of the record to lookup"), 1,
&GNUNET_GETOPT_set_string, &lookup_type},
{'r', "raw", NULL,
&GNUNET_GETOPT_set_one, &raw},
GNUNET_GETOPT_OPTION_END
};
-
int ret;
if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
_("GNUnet GNS access tool"),
options,
&run, NULL)) ? 0 : 1;
-
+ GNUNET_free ((void*) argv);
return ret;
}