/**
* Function scheduled to be run on the successful start of services
* tries to look up the dns record for TEST_DOMAIN
*/
static void
commence_testing (void *cls, int32_t success, const char *emsg)
{
char name[MAX_DNS_NAME_LENGTH];
char* pos;
struct GNUNET_CRYPTO_ShortHashAsciiEncoded hash_str;
GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES);
gns_handle = GNUNET_GNS_connect(cfg);
if (NULL == gns_handle)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to GNS!\n");
}
pos = name;
strcpy(pos, TEST_RECORD_NAME);
pos += strlen(TEST_RECORD_NAME);
strcpy(pos, ".");
pos++;
GNUNET_CRYPTO_short_hash_to_enc(&bob_hash, &hash_str);
strcpy(pos, (char*)&hash_str);
pos += strlen((char*)&hash_str);
strcpy(pos, ".");
pos++;
strcpy(pos, GNUNET_GNS_TLD_ZKEY);
GNUNET_GNS_lookup(gns_handle, name, GNUNET_GNS_RECORD_TYPE_A,
&on_lookup_result, NULL);
}
/**
* Convert a short hash to a string (for printing debug messages).
* This is one of the very few calls in the entire API that is
* NOT reentrant!
*
* @param hc the short hash code
* @return string form; will be overwritten by next call to GNUNET_h2s.
*/
const char *
GNUNET_short_h2s (const struct GNUNET_CRYPTO_ShortHashCode * hc)
{
static struct GNUNET_CRYPTO_ShortHashAsciiEncoded ret;
GNUNET_CRYPTO_short_hash_to_enc (hc, &ret);
return (const char *) &ret;
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CRYPTO_RsaPrivateKey *pk;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
struct GNUNET_PeerIdentity pid;
if (NULL == args[0])
{
fprintf (stderr, _("No hostkey file specified on command line\n"));
return;
}
if (0 != weak_random)
GNUNET_CRYPTO_random_disable_entropy_gathering ();
if (make_keys > 0)
{
create_keys (args[0]);
return;
}
pk = GNUNET_CRYPTO_rsa_key_create_from_file (args[0]);
if (NULL == pk)
return;
if (print_public_key)
{
char *s;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
s = GNUNET_CRYPTO_rsa_public_key_to_string (&pub);
fprintf (stdout, "%s\n", s);
GNUNET_free (s);
}
if (print_peer_identity)
{
struct GNUNET_CRYPTO_HashAsciiEncoded enc;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
GNUNET_CRYPTO_hash (&pub, sizeof (pub), &pid.hashPubKey);
GNUNET_CRYPTO_hash_to_enc (&pid.hashPubKey, &enc);
fprintf (stdout, "%s\n", enc.encoding);
}
if (print_short_identity)
{
struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc;
struct GNUNET_CRYPTO_ShortHashCode sh;
GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
GNUNET_CRYPTO_short_hash (&pub, sizeof (pub), &sh);
GNUNET_CRYPTO_short_hash_to_enc (&sh, &enc);
fprintf (stdout, "%s\n", enc.short_encoding);
}
GNUNET_CRYPTO_rsa_key_free (pk);
}
/**
* Lookup the private key for the zone
*
* @param zone the zone we want a private key for
* @return NULL of not found else the key
*/
struct GNUNET_CRYPTO_RsaPrivateKey*
lookup_private_key(struct GNUNET_CRYPTO_ShortHashCode *zone)
{
char* keydir;
struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
char* location;
struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Looking for private key\n");
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (GNS_cfg,
"namestore",
"ZONEFILE_DIRECTORY", &keydir))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"No zonefile directory!\n");
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Zonefile directory is %s\n", keydir);
GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Zonefile is %s.zkey\n", &zonename);
GNUNET_asprintf(&location, "%s%s%s.zkey", keydir,
DIR_SEPARATOR_STR, &zonename);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Checking for %s\n", location);
if (GNUNET_YES == GNUNET_DISK_file_test (location))
key = GNUNET_CRYPTO_rsa_key_create_from_file (location);
GNUNET_free(location);
GNUNET_free(keydir);
return key;
}
/**
* Convert the 'value' of a record to a string.
*
* @param type type of the record
* @param data value in binary encoding
* @param data_size number of bytes in data
* @return NULL on error, otherwise human-readable representation of the value
*/
char *
GNUNET_NAMESTORE_value_to_string (uint32_t type,
const void *data,
size_t data_size)
{
uint16_t mx_pref;
const struct soa_data *soa;
const struct vpn_data *vpn;
const struct srv_data *srv;
const struct tlsa_data *tlsa;
struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc;
struct GNUNET_CRYPTO_HashAsciiEncoded s_peer;
const char *cdata;
char* vpn_str;
char* srv_str;
char* tlsa_str;
char* result;
const char* soa_rname;
const char* soa_mname;
char tmp[INET6_ADDRSTRLEN];
switch (type)
{
case 0:
return NULL;
case GNUNET_DNSPARSER_TYPE_A:
if (data_size != sizeof (struct in_addr))
return NULL;
if (NULL == inet_ntop (AF_INET, data, tmp, sizeof (tmp)))
return NULL;
return GNUNET_strdup (tmp);
case GNUNET_DNSPARSER_TYPE_NS:
return GNUNET_strndup (data, data_size);
case GNUNET_DNSPARSER_TYPE_CNAME:
return GNUNET_strndup (data, data_size);
case GNUNET_DNSPARSER_TYPE_SOA:
if (data_size <= sizeof (struct soa_data))
return NULL;
soa = data;
soa_rname = (const char*) &soa[1];
soa_mname = memchr (soa_rname, 0, data_size - sizeof (struct soa_data) - 1);
if (NULL == soa_mname)
return NULL;
soa_mname++;
if (NULL == memchr (soa_mname, 0,
data_size - (sizeof (struct soa_data) + strlen (soa_rname) + 1)))
return NULL;
GNUNET_asprintf (&result,
"rname=%s mname=%s %lu,%lu,%lu,%lu,%lu",
soa_rname, soa_mname,
ntohl (soa->serial),
ntohl (soa->refresh),
ntohl (soa->retry),
ntohl (soa->expire),
ntohl (soa->minimum));
return result;
case GNUNET_DNSPARSER_TYPE_PTR:
return GNUNET_strndup (data, data_size);
case GNUNET_DNSPARSER_TYPE_MX:
mx_pref = ntohs(*((uint16_t*)data));
if (GNUNET_asprintf(&result, "%hu,%s", mx_pref, data+sizeof(uint16_t))
!= 0)
return result;
else
{
GNUNET_free (result);
return NULL;
}
case GNUNET_DNSPARSER_TYPE_TXT:
return GNUNET_strndup (data, data_size);
case GNUNET_DNSPARSER_TYPE_AAAA:
if (data_size != sizeof (struct in6_addr))
return NULL;
if (NULL == inet_ntop (AF_INET6, data, tmp, sizeof (tmp)))
return NULL;
return GNUNET_strdup (tmp);
case GNUNET_NAMESTORE_TYPE_PKEY:
if (data_size != sizeof (struct GNUNET_CRYPTO_ShortHashCode))
return NULL;
GNUNET_CRYPTO_short_hash_to_enc (data,
&enc);
return GNUNET_strdup ((const char*) enc.short_encoding);
case GNUNET_NAMESTORE_TYPE_PSEU:
return GNUNET_strndup (data, data_size);
case GNUNET_NAMESTORE_TYPE_LEHO:
return GNUNET_strndup (data, data_size);
case GNUNET_NAMESTORE_TYPE_VPN:
cdata = data;
if ( (data_size <= sizeof (struct vpn_data)) ||
('\0' != cdata[data_size - 1]) )
return NULL; /* malformed */
vpn = data;
GNUNET_CRYPTO_hash_to_enc (&vpn->peer, &s_peer);
if (0 == GNUNET_asprintf (&vpn_str, "%u %s %s",
(unsigned int) ntohs (vpn->proto),
(const char*) &s_peer,
(const char*) &vpn[1]))
{
GNUNET_free (vpn_str);
return NULL;
}
return vpn_str;
case GNUNET_DNSPARSER_TYPE_SRV:
cdata = data;
if ( (data_size <= sizeof (struct srv_data)) ||
('\0' != cdata[data_size - 1]) )
return NULL; /* malformed */
srv = data;
if (0 == GNUNET_asprintf (&srv_str,
"%d %d %d %s",
ntohs (srv->prio),
ntohs (srv->weight),
ntohs (srv->port),
(const char *)&srv[1]))
{
GNUNET_free (srv_str);
return NULL;
}
return srv_str;
case GNUNET_DNSPARSER_TYPE_TLSA:
cdata = data;
if ( (data_size <= sizeof (struct tlsa_data)) ||
('\0' != cdata[data_size - 1]) )
return NULL; /* malformed */
tlsa = data;
if (0 == GNUNET_asprintf (&tlsa_str,
"%c %c %c %s",
tlsa->usage,
tlsa->selector,
tlsa->matching_type,
(const char *) &tlsa[1]))
{
GNUNET_free (tlsa_str);
return NULL;
}
return tlsa_str;
default:
GNUNET_break (0);
}
GNUNET_break (0); // not implemented
return NULL;
}
