static void
nick_2_cont (void *cls, int32_t success, const char *emsg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Nick added : %s\n",
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
GNUNET_asprintf(&s_name_1, "dummy1");
s_rd_1 = create_record(1);
GNUNET_NAMESTORE_records_store (nsh, privkey, s_name_1,
1, s_rd_1,
&put_cont, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Created record 2 \n");
GNUNET_asprintf(&s_name_2, "dummy2");
s_rd_2 = create_record(1);
GNUNET_NAMESTORE_records_store (nsh, privkey, s_name_2,
1, s_rd_2, &put_cont, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Created record 3\n");
/* name in different zone */
GNUNET_asprintf(&s_name_3, "dummy3");
s_rd_3 = create_record(1);
GNUNET_NAMESTORE_records_store (nsh, privkey2, s_name_3,
1, s_rd_3,
&put_cont, NULL);
}
static void
put_cont (void *cls, int32_t success,
const char *emsg)
{
const char *name = cls;
GNUNET_assert (NULL != cls);
if (GNUNET_SYSERR == success)
{
GNUNET_break (0);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Namestore could not store record: `%s'\n",
emsg);
if (endbadly_task != NULL)
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Name store added record for `%s': %s\n",
name,
(success == GNUNET_OK) ? "SUCCESS" : "FAIL");
nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name,
0, NULL, &remove_cont, (void *) name);
}
/**
* Method called to inform about the egos of this peer.
*
* When used with #GNUNET_IDENTITY_connect, this function is
* initially called for all egos and then again whenever a
* ego's name changes or if it is deleted. At the end of
* the initial pass over all egos, the function is once called
* with 'NULL' for @a ego. That does NOT mean that the callback won't
* be invoked in the future or that there was an error.
*
* When used with #GNUNET_IDENTITY_create or #GNUNET_IDENTITY_get,
* this function is only called ONCE, and 'NULL' being passed in
* @a ego does indicate an error (i.e. name is taken or no default
* value is known). If @a ego is non-NULL and if '*ctx'
* is set in those callbacks, the value WILL be passed to a subsequent
* call to the identity callback of #GNUNET_IDENTITY_connect (if
* that one was not NULL).
*
* When an identity is renamed, this function is called with the
* (known) @a ego but the NEW @a name.
*
* When an identity is deleted, this function is called with the
* (known) ego and "NULL" for the @a name. In this case,
* the @a ego is henceforth invalid (and the @a ctx should also be
* cleaned up).
*
* @param cls closure
* @param ego ego handle
* @param ctx context for application to store data for this ego
* (during the lifetime of this process, initially NULL)
* @param name name assigned by the user for this ego,
* NULL if the user just deleted the ego and it
* must thus no longer be used
*/
static void
identity_cb (void *cls,
struct GNUNET_IDENTITY_Ego *ego,
void **ctx,
const char *name)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key;
struct GNUNET_GNSRECORD_Data rd;
char *rd_string;
char *peername;
if (NULL == name)
return;
if (NULL == ego)
{
if (NULL == qe)
{
fprintf (stderr,
"Failed to find master-zone ego\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_IDENTITY_disconnect (identity);
identity = NULL;
return;
}
GNUNET_assert (NULL != name);
if (0 != strcmp (name,
"master-zone"))
{
fprintf (stderr,
"Unexpected name %s\n",
name);
return;
}
zone_key = GNUNET_IDENTITY_ego_get_private_key (ego);
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
peername = GNUNET_strdup (GNUNET_i2s_full (&id));
GNUNET_asprintf (&rd_string,
"6 %s %s",
peername,
"www");
GNUNET_free (peername);
GNUNET_assert (GNUNET_OK ==
GNUNET_GNSRECORD_string_to_value (GNUNET_GNSRECORD_TYPE_VPN,
rd_string,
(void**) &rd.data,
&rd.data_size));
rd.record_type = GNUNET_GNSRECORD_TYPE_VPN;
qe = GNUNET_NAMESTORE_records_store (namestore,
zone_key,
"www",
1, &rd,
&commence_testing,
NULL);
GNUNET_free ((void**)rd.data);
GNUNET_free (rd_string);
}
static void
identity_cb (void *cls,
struct GNUNET_IDENTITY_Ego *ego,
void **ctx,
const char *name)
{
struct GNUNET_GNSRECORD_Data rd;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
if (NULL == name)
return;
if (NULL == ego)
return;
if (0 == strcmp (name, "phone-ego"))
{
GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
GNUNET_asprintf (&gns_name,
"phone.%s",
GNUNET_GNSRECORD_pkey_to_zkey (&pub));
phone = GNUNET_CONVERSATION_phone_create (cfg,
ego,
&phone_event_handler,
NULL);
GNUNET_assert (NULL != phone);
memset (&rd, 0, sizeof (rd));
GNUNET_CONVERSATION_phone_get_record (phone,
&rd);
GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
rd.expiration_time = UINT64_MAX;
qe = GNUNET_NAMESTORE_records_store (ns,
GNUNET_IDENTITY_ego_get_private_key (ego),
"phone" /* GNS label */,
1,
&rd,
&namestore_put_cont,
NULL);
return;
}
if (0 == strcmp (name, "caller-ego"))
{
GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
GNUNET_asprintf (&gns_caller_id,
"%s",
GNUNET_GNSRECORD_pkey_to_zkey (&pub));
call = GNUNET_CONVERSATION_call_start (cfg,
ego,
ego,
gns_name,
&call_speaker,
&call_mic,
&call_event_handler,
NULL);
return;
}
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_GNSRECORD_Data rd;
char *hostkey_file;
directory = NULL;
GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", "GNUNET_TEST_HOME", &directory);
GNUNET_DISK_directory_remove (directory);
update_performed = GNUNET_NO;
endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&endbadly, NULL);
GNUNET_asprintf (&hostkey_file,
"zonefiles%s%s",
DIR_SEPARATOR_STR,
"N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file (hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey != NULL);
GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
rd.flags = GNUNET_GNSRECORD_RF_NONE;
rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
rd.record_type = TEST_RECORD_TYPE;
rd.data_size = TEST_RECORD_DATALEN;
rd.data = GNUNET_malloc (TEST_RECORD_DATALEN);
memset ((char *) rd.data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
nsh = GNUNET_NAMESTORE_connect (cfg);
GNUNET_break (NULL != nsh);
nch = GNUNET_NAMECACHE_connect (cfg);
GNUNET_break (NULL != nch);
nsqe = GNUNET_NAMESTORE_records_store (nsh,
privkey, name,
1, &rd,
&put_cont, (void *) name);
if (NULL == nsqe)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Namestore cannot store no block\n"));
}
GNUNET_free ((void *)rd.data);
}
static void
rd_decrypt_cb (void *cls,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNUNET_GNSRECORD_Data rd_new;
GNUNET_assert (1 == rd_count);
GNUNET_assert (NULL != rd);
if (GNUNET_NO == update_performed)
{
char rd_cmp_data[TEST_RECORD_DATALEN];
memset (rd_cmp_data, TEST_RECORD_DATA, TEST_RECORD_DATALEN);
GNUNET_assert (TEST_RECORD_TYPE == rd[0].record_type);
GNUNET_assert (TEST_RECORD_DATALEN == rd[0].data_size);
GNUNET_assert (0 == memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Block was decrypted successfully, updating record \n");
rd_new.flags = GNUNET_GNSRECORD_RF_NONE;
rd_new.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
rd_new.record_type = TEST_RECORD_TYPE2;
rd_new.data_size = TEST_RECORD_DATALEN2;
rd_new.data = GNUNET_malloc (TEST_RECORD_DATALEN2);
memset ((char *) rd_new.data, TEST_RECORD_DATA2, TEST_RECORD_DATALEN2);
nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name,
1, &rd_new, &put_cont, (void *) name);
update_performed = GNUNET_YES;
}
else
{
char rd_cmp_data[TEST_RECORD_DATALEN2];
memset (rd_cmp_data, TEST_RECORD_DATA2, TEST_RECORD_DATALEN2);
GNUNET_assert (TEST_RECORD_TYPE2 == rd[0].record_type);
GNUNET_assert (TEST_RECORD_DATALEN2 == rd[0].data_size);
GNUNET_assert (0 == memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN2));
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_SCHEDULER_add_now (&end, NULL);
}
}
/**
* Namestore calls this function if we have record for this name.
* (or with rd_count=0 to indicate no matches).
*
* @param cls the pending query
* @param rd_count the number of records with 'name'
* @param rd the record data
*/
static void
process_pseu_lookup_ns (void *cls,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct GetPseuAuthorityHandle *gph = cls;
struct GNUNET_GNSRECORD_Data new_pkey;
gph->namestore_task = NULL;
if (rd_count > 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Name `%s' already taken, cannot shorten.\n",
gph->current_label);
/* if this was not yet the original label, try one more
time, this time not using PSEU but the original label */
if (0 == strcmp (gph->current_label,
gph->label))
{
free_get_pseu_authority_handle (gph);
}
else
{
perform_nick_lookup (gph, gph->label);
}
return;
}
/* name is available */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Shortening `%s' to `%s'\n",
GNUNET_GNSRECORD_z2s (&gph->target_zone),
gph->current_label);
new_pkey.expiration_time = UINT64_MAX;
new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
new_pkey.data = &gph->target_zone;
new_pkey.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
new_pkey.flags = GNUNET_GNSRECORD_RF_NONE
| GNUNET_GNSRECORD_RF_PRIVATE;
gph->namestore_task
= GNUNET_NAMESTORE_records_store (namestore_handle,
&gph->shorten_zone_key,
gph->current_label,
1, &new_pkey,
&create_pkey_cont, gph);
}
/**
* Test if a name mapping was found, if so, refuse. If not, initiate storing of the record.
*
* @param cls closure
* @param zone_key public key of the zone
* @param name name that is being mapped (at most 255 characters long)
* @param rd_count number of entries in @a rd array
* @param rd array of records with data to store
*/
static void
zone_to_name_cb (void *cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *name,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct Request *request = cls;
struct GNUNET_GNSRECORD_Data r;
request->qe = NULL;
if (0 != rd_count)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Found existing name `%s' for the given key\n"),
name);
request->phase = RP_FAIL;
run_httpd_now ();
return;
}
if (NULL == zone_key)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Error when mapping zone to name\n"));
request->phase = RP_FAIL;
run_httpd_now ();
return;
}
r.data = &request->pub;
r.data_size = sizeof (request->pub);
r.expiration_time = UINT64_MAX;
r.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
r.flags = GNUNET_GNSRECORD_RF_NONE;
request->qe = GNUNET_NAMESTORE_records_store (ns,
&fcfs_zone_pkey,
request->domain_name,
1, &r,
&put_continuation,
request);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
char *hostkey_file;
const char * name = "dummy.dummy.gnunet";
directory = NULL;
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", "GNUNET_TEST_HOME", &directory));
GNUNET_DISK_directory_remove (directory);
endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&endbadly, NULL);
GNUNET_asprintf (&hostkey_file,
"zonefiles%s%s",
DIR_SEPARATOR_STR,
"N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Using zonekey file `%s' \n",
hostkey_file);
privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file (hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey != NULL);
GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey);
nsh = GNUNET_NAMESTORE_connect (cfg);
GNUNET_break (NULL != nsh);
nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name,
0, NULL,
&put_cont, (void *) name);
if (NULL == nsqe)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Namestore cannot store no block\n"));
}
}
/**
* Callback called from the zone iterator when we iterate over
* the empty zone. Check that we got no records and then
* start the actual tests by filling the zone.
*/
static void
empty_zone_proc (void *cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
char *hostkey_file;
GNUNET_assert (nsh == cls);
if (NULL != zone)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Expected empty zone but received zone private key\n"));
GNUNET_break (0);
if (endbadly_task != NULL)
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
return;
}
if ((NULL != label) || (NULL != rd) || (0 != rd_count))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Expected no zone content but received data\n"));
GNUNET_break (0);
if (endbadly_task != NULL)
GNUNET_SCHEDULER_cancel (endbadly_task);
endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
return;
}
zi = NULL;
GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
"N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey != NULL);
GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
"HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey2 = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey2 != NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Created record 1\n");
GNUNET_asprintf(&s_name_1, "dummy1");
s_rd_1 = create_record(1);
GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_1,
1, s_rd_1, &put_cont, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Created record 2 \n");
GNUNET_asprintf(&s_name_2, "dummy2");
s_rd_2 = create_record(1);
GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_2,
1, s_rd_2, &put_cont, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Created record 3\n");
/* name in different zone */
GNUNET_asprintf(&s_name_3, "dummy3");
s_rd_3 = create_record(1);
GNUNET_NAMESTORE_records_store(nsh, privkey2, s_name_3,
1, s_rd_3, &put_cont, NULL);
}
/**
* Function called with the result from the check if the namestore
* service is actually running. If it is, we start the actual
* operation.
*
* @param cls closure with our configuration
* @param result #GNUNET_YES if the namestore service is running
*/
static void
testservice_task (void *cls,
int result)
{
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct GNUNET_CRYPTO_EcdsaPublicKey pub;
struct GNUNET_GNSRECORD_Data rd;
if (GNUNET_YES != result)
{
FPRINTF (stderr, _("Service `%s' is not running\n"),
"namestore");
return;
}
if (! (add|del|list|(NULL != nickstring)|(NULL != uri)|(NULL != reverse_pkey)) )
{
/* nothing more to be done */
fprintf (stderr,
_("No options given\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_CRYPTO_ecdsa_key_get_public (&zone_pkey,
&pub);
ns = GNUNET_NAMESTORE_connect (cfg);
if (NULL == ns)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to namestore\n"));
return;
}
if (add)
{
if (NULL == name)
{
fprintf (stderr,
_("Missing option `%s' for operation `%s'\n"),
"-n", _("add"));
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
if (NULL == typestring)
{
fprintf (stderr,
_("Missing option `%s' for operation `%s'\n"),
"-t", _("add"));
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
type = GNUNET_GNSRECORD_typename_to_number (typestring);
if (UINT32_MAX == type)
{
fprintf (stderr, _("Unsupported type `%s'\n"), typestring);
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
if (NULL == value)
{
fprintf (stderr,
_("Missing option `%s' for operation `%s'\n"),
"-V", _("add"));
ret = 1;
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_GNSRECORD_string_to_value (type,
value,
&data,
&data_size))
{
fprintf (stderr, _("Value `%s' invalid for record type `%s'\n"),
value,
typestring);
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
if (NULL == expirationstring)
{
fprintf (stderr,
_("Missing option `%s' for operation `%s'\n"),
"-e", _("add"));
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
if (0 == strcmp (expirationstring, "never"))
{
etime_abs = GNUNET_TIME_UNIT_FOREVER_ABS;
etime_is_rel = GNUNET_NO;
}
else if (GNUNET_OK ==
GNUNET_STRINGS_fancy_time_to_relative (expirationstring,
&etime_rel))
{
etime_is_rel = GNUNET_YES;
}
else if (GNUNET_OK ==
GNUNET_STRINGS_fancy_time_to_absolute (expirationstring,
&etime_abs))
{
etime_is_rel = GNUNET_NO;
}
else
{
fprintf (stderr,
_("Invalid time format `%s'\n"),
expirationstring);
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
add_qe = GNUNET_NAMESTORE_records_lookup (ns, &zone_pkey, name,
&get_existing_record, NULL );
}
if (del)
{
if (NULL == name)
{
fprintf (stderr,
_("Missing option `%s' for operation `%s'\n"),
"-n", _("del"));
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
del_qe = GNUNET_NAMESTORE_records_lookup (ns,
&zone_pkey,
name,
&del_monitor,
NULL);
}
if (list)
{
list_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
&zone_pkey,
&display_record,
NULL);
}
if (NULL != reverse_pkey)
{
struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
if (GNUNET_OK !=
GNUNET_CRYPTO_ecdsa_public_key_from_string (reverse_pkey,
strlen (reverse_pkey),
&pubkey))
{
fprintf (stderr,
_("Invalid public key for reverse lookup `%s'\n"),
reverse_pkey);
GNUNET_SCHEDULER_shutdown ();
}
reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
&zone_pkey,
&pubkey,
&handle_reverse_lookup,
NULL);
}
if (NULL != uri)
{
char sh[105];
char sname[64];
struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
GNUNET_STRINGS_utf8_tolower (uri, uri);
if ( (2 != (sscanf (uri,
"gnunet://gns/%52s/%63s",
sh,
sname)) ) ||
(GNUNET_OK != GNUNET_CRYPTO_ecdsa_public_key_from_string (sh, strlen (sh), &pkey)) )
{
fprintf (stderr,
_("Invalid URI `%s'\n"),
uri);
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
memset (&rd, 0, sizeof (rd));
rd.data = &pkey;
rd.data_size = sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey);
rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
if (GNUNET_YES == etime_is_rel)
{
rd.expiration_time = etime_rel.rel_value_us;
rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
}
else if (GNUNET_NO == etime_is_rel)
rd.expiration_time = etime_abs.abs_value_us;
else
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
if (1 == is_shadow)
rd.flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
add_qe_uri = GNUNET_NAMESTORE_records_store (ns,
&zone_pkey,
sname,
1,
&rd,
&add_continuation,
&add_qe_uri);
}
if (NULL != nickstring)
{
if (0 == strlen(nickstring))
{
fprintf (stderr,
_("Invalid nick `%s'\n"),
nickstring);
GNUNET_SCHEDULER_shutdown ();
ret = 1;
return;
}
add_qe_uri = GNUNET_NAMESTORE_set_nick(ns, &zone_pkey, nickstring,
&add_continuation, &add_qe_uri);
}
if (monitor)
{
zm = GNUNET_NAMESTORE_zone_monitor_start (cfg,
&zone_pkey,
GNUNET_YES,
&display_record,
&sync_cb,
NULL);
}
}
/**
* We were asked to delete something; this function is called with
* the existing records. Now we should determine what should be
* deleted and then issue the deletion operation.
*
* @param cls NULL
* @param zone private key of the zone we are deleting from
* @param label name of the records we are editing
* @param rd_count size of the @a rd array
* @param rd existing records
*/
static void
del_monitor (void *cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
const char *label,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNUNET_GNSRECORD_Data rdx[rd_count];
unsigned int rd_left;
unsigned int i;
uint32_t type;
char *vs;
del_qe = NULL;
if (0 == rd_count)
{
FPRINTF (stderr,
_("There are no records under label `%s' that could be deleted.\n"),
label);
test_finished ();
return;
}
if ( (NULL == value) &&
(NULL == typestring) )
{
/* delete everything */
del_qe = GNUNET_NAMESTORE_records_store (ns,
&zone_pkey,
name,
0, NULL,
&del_continuation,
NULL);
return;
}
rd_left = 0;
if (NULL != typestring)
type = GNUNET_GNSRECORD_typename_to_number (typestring);
else
type = GNUNET_GNSRECORD_TYPE_ANY;
for (i=0;i<rd_count;i++)
{
vs = NULL;
if (! ( ( (GNUNET_GNSRECORD_TYPE_ANY == type) ||
(rd[i].record_type == type) ) &&
( (NULL == value) ||
(NULL == (vs = (GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
rd[i].data,
rd[i].data_size)))) ||
(0 == strcmp (vs, value)) ) ) )
rdx[rd_left++] = rd[i];
GNUNET_free_non_null (vs);
}
if (rd_count == rd_left)
{
/* nothing got deleted */
FPRINTF (stderr,
_("There are no records under label `%s' that match the request for deletion.\n"),
label);
test_finished ();
return;
}
/* delete everything but what we copied to 'rdx' */
del_qe = GNUNET_NAMESTORE_records_store (ns,
&zone_pkey,
name,
rd_left, rdx,
&del_continuation,
NULL);
}
/**
* We're storing a record; this function is given the existing record
* so that we can merge the information.
*
* @param cls closure, unused
* @param zone_key private key of the zone
* @param rec_name name that is being mapped (at most 255 characters long)
* @param rd_count number of entries in @a rd array
* @param rd array of records with data to store
*/
static void
get_existing_record (void *cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
const char *rec_name,
unsigned int rd_count,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
struct GNUNET_GNSRECORD_Data *rde;
unsigned int i;
add_qe = NULL;
if ( (NULL != zone_key) &&
(0 != strcmp (rec_name, name)) )
{
GNUNET_break (0);
ret = 1;
test_finished ();
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received %u records for name `%s'\n",
rd_count, rec_name);
for (i=0;i<rd_count;i++)
{
switch (rd[i].record_type)
{
case GNUNET_DNSPARSER_TYPE_CNAME:
fprintf (stderr,
_("A %s record exists already under `%s', no other records can be added.\n"),
"CNAME",
rec_name);
ret = 1;
test_finished ();
return;
case GNUNET_GNSRECORD_TYPE_PKEY:
fprintf (stderr,
_("A %s record exists already under `%s', no other records can be added.\n"),
"PKEY",
rec_name);
ret = 1;
test_finished ();
return;
case GNUNET_GNSRECORD_TYPE_GNS2DNS:
fprintf (stderr,
_("A %s record exists already under `%s', no other records can be added.\n"),
"GNS2DNS",
rec_name);
ret = 1;
test_finished ();
return;
}
}
switch (type)
{
case GNUNET_DNSPARSER_TYPE_CNAME:
if (0 != rd_count)
{
fprintf (stderr,
_("Records already exist under `%s', cannot add `%s' record.\n"),
rec_name,
"CNAME");
ret = 1;
test_finished ();
return;
}
break;
case GNUNET_GNSRECORD_TYPE_PKEY:
if (0 != rd_count)
{
fprintf (stderr,
_("Records already exist under `%s', cannot add `%s' record.\n"),
rec_name,
"PKEY");
ret = 1;
test_finished ();
return;
}
break;
case GNUNET_GNSRECORD_TYPE_GNS2DNS:
if (0 != rd_count)
{
fprintf (stderr,
_("Records already exist under `%s', cannot add `%s' record.\n"),
rec_name,
"GNS2DNS");
ret = 1;
test_finished ();
return;
}
break;
}
memset (rdn, 0, sizeof (struct GNUNET_GNSRECORD_Data));
memcpy (&rdn[1], rd, rd_count * sizeof (struct GNUNET_GNSRECORD_Data));
rde = &rdn[0];
rde->data = data;
rde->data_size = data_size;
rde->record_type = type;
if (1 == is_shadow)
rde->flags |= GNUNET_GNSRECORD_RF_SHADOW_RECORD;
if (1 != is_public)
rde->flags |= GNUNET_GNSRECORD_RF_PRIVATE;
if (GNUNET_YES == etime_is_rel)
{
rde->expiration_time = etime_rel.rel_value_us;
rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
}
else if (GNUNET_NO == etime_is_rel)
rde->expiration_time = etime_abs.abs_value_us;
else
rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
GNUNET_assert (NULL != name);
add_qe = GNUNET_NAMESTORE_records_store (ns,
&zone_pkey,
name,
rd_count + 1,
rde,
&add_continuation,
&add_qe);
}
/**
* This function updates the old token with new attributes,
* removes deleted attributes and expiration times.
*
* @param cls the ego entry
* @param tc task context
*/
static void
handle_token_update (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *token_header;
char *token_payload;
char *token_payload_json;
char *new_token;
char *new_payload_str;
char *new_payload_base64;
char *sig_str;
char *key;
char *padding;
const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
struct EgoEntry *ego_entry = cls;
struct GNUNET_GNSRECORD_Data token_record;
struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
struct GNUNET_CRYPTO_EcdsaSignature sig;
struct GNUNET_HashCode key_hash;
struct GNUNET_TIME_Relative token_rel_exp;
struct GNUNET_TIME_Relative token_ttl;
struct GNUNET_TIME_Absolute token_exp;
struct GNUNET_TIME_Absolute token_nbf;
struct GNUNET_TIME_Absolute new_exp;
struct GNUNET_TIME_Absolute new_iat;
struct GNUNET_TIME_Absolute new_nbf;
json_t *payload_json;
json_t *value;
json_t *cur_value;
json_t *new_payload_json;
json_t *token_nbf_json;
json_t *token_exp_json;
json_error_t json_err;
priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
//Note: We need the token expiration time here. Not the record expiration
//time.
//There are two types of tokens: Token that expire on GNS level with
//an absolute expiration time. Those are basically tokens that will
//be automatically revoked on (record)expiration.
//Tokens stored with relative expiration times will expire on the token level (token expiration)
//but this service will reissue new tokens that can be retrieved from GNS
//automatically.
token_header = strtok (token, ".");
token_payload = strtok (NULL, ".");
GNUNET_STRINGS_base64_decode (token_payload,
strlen (token_payload),
&token_payload_json);
payload_json = json_loads (token_payload_json, JSON_DECODE_ANY, &json_err);
GNUNET_free (token_payload_json);
token_exp_json = json_object_get (payload_json, "exp");
token_nbf_json = json_object_get (payload_json, "nbf");
token_exp.abs_value_us = json_integer_value(token_exp_json);
token_nbf.abs_value_us = json_integer_value(token_nbf_json);
token_rel_exp = GNUNET_TIME_absolute_get_difference (token_nbf, token_exp);
token_ttl = GNUNET_TIME_absolute_get_remaining (token_exp);
if (0 != GNUNET_TIME_absolute_get_remaining (token_exp).rel_value_us)
{
//This token is not yet expired! Save and skip
if (min_rel_exp.rel_value_us > token_ttl.rel_value_us)
{
min_rel_exp = token_ttl;
}
json_decref (payload_json);
GNUNET_free (token);
token = NULL;
GNUNET_free (label);
label = NULL;
GNUNET_NAMESTORE_zone_iterator_next (ns_it);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Token is expired. Create a new one\n");
new_exp = GNUNET_TIME_relative_to_absolute (token_rel_exp);
new_nbf = GNUNET_TIME_absolute_get ();
new_iat = new_nbf;
new_payload_json = json_object();
json_object_foreach(payload_json, key, value) {
if (0 == strcmp (key, "exp"))
{
json_object_set_new (new_payload_json, key, json_integer (new_exp.abs_value_us));
}
else if (0 == strcmp (key, "nbf"))
{
json_object_set_new (new_payload_json, key, json_integer (new_nbf.abs_value_us));
}
else if (0 == strcmp (key, "iat"))
{
json_object_set_new (new_payload_json, key, json_integer (new_iat.abs_value_us));
}
else if ((0 == strcmp (key, "iss"))
|| (0 == strcmp (key, "aud"))
|| (0 == strcmp (key, "sub"))
|| (0 == strcmp (key, "rnl")))
{
json_object_set (new_payload_json, key, value);
}
else {
GNUNET_CRYPTO_hash (key,
strlen (key),
&key_hash);
//Check if attr still exists. omit of not
if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains (ego_entry->attr_map,
&key_hash))
{
cur_value = GNUNET_CONTAINER_multihashmap_get (ego_entry->attr_map,
&key_hash);
json_object_set (new_payload_json, key, cur_value);
}
}
}
// reassemble and set
new_payload_str = json_dumps (new_payload_json, JSON_COMPACT);
json_decref (payload_json);
json_decref (new_payload_json);
GNUNET_STRINGS_base64_encode (new_payload_str,
strlen (new_payload_str),
&new_payload_base64);
//Remove padding
padding = strtok(new_payload_base64, "=");
while (NULL != padding)
padding = strtok(NULL, "=");
GNUNET_asprintf (&new_token, "%s,%s", token_header, new_payload_base64);
purpose =
GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
strlen (new_token));
purpose->size =
htonl (strlen (new_token) + sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TOKEN);
memcpy (&purpose[1], new_token, strlen (new_token));
if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_sign (priv_key,
purpose,
&sig))
GNUNET_break(0);
GNUNET_free (new_token);
sig_str = GNUNET_STRINGS_data_to_string_alloc (&sig,
sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
GNUNET_asprintf (&new_token, "%s.%s.%s",
token_header, new_payload_base64, sig_str);
GNUNET_free (sig_str);
GNUNET_free (new_payload_str);
GNUNET_free (new_payload_base64);
GNUNET_free (purpose);
token_record.data = new_token;
token_record.data_size = strlen (new_token);
token_record.expiration_time = new_exp.abs_value_us;
token_record.record_type = GNUNET_GNSRECORD_TYPE_ID_TOKEN;
token_record.flags = GNUNET_GNSRECORD_RF_NONE | GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
ns_qe = GNUNET_NAMESTORE_records_store (ns_handle,
priv_key,
label,
1,
&token_record,
&store_token_cont,
ego_entry);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, ">>> Updating Token w/ %s\n", new_token);
GNUNET_free (new_token);
GNUNET_free (token);
token = NULL;
GNUNET_free (label);
label = NULL;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *mycfg,
struct GNUNET_TESTING_Peer *peer)
{
char *hostkey_file;
directory = NULL;
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string(mycfg, "PATHS", "GNUNET_TEST_HOME", &directory));
GNUNET_DISK_directory_remove (directory);
res = 1;
GNUNET_asprintf(&hostkey_file,
"zonefiles%s%s",
DIR_SEPARATOR_STR,
"N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Using zonekey file `%s' \n", hostkey_file);
privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey != NULL);
cfg = mycfg;
endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &endbadly, NULL);
/* Connect to namestore */
nsh = GNUNET_NAMESTORE_connect (cfg);
if (NULL == nsh)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connect to namestore\n");
GNUNET_break (0);
endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL);
return;
}
GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",
DIR_SEPARATOR_STR,
"HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
privkey2 = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
GNUNET_free (hostkey_file);
GNUNET_assert (privkey2 != NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 3\n");
/* name in different zone */
GNUNET_asprintf(&s_name_3, "dummy3");
s_rd_3 = create_record(1);
GNUNET_assert (NULL != (ns_ops[2] = GNUNET_NAMESTORE_records_store (nsh, privkey2, s_name_3,
1, s_rd_3, &put_cont, s_name_3)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 1\n");
GNUNET_asprintf(&s_name_1, "dummy1");
s_rd_1 = create_record(1);
GNUNET_assert (NULL != (ns_ops[0] = GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_1,
1, s_rd_1, &put_cont, s_name_1)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created record 2 \n");
GNUNET_asprintf(&s_name_2, "dummy2");
s_rd_2 = create_record(1);
GNUNET_assert (NULL != (ns_ops[1] = GNUNET_NAMESTORE_records_store(nsh, privkey, s_name_2,
1, s_rd_2, &put_cont, s_name_2)));
}
