/**
* Function that is called on each HELLO file in a particular directory.
* Try to parse the file and add the HELLO to our list.
*
* @param cls pointer to 'unsigned int' to increment for each file, or NULL
* if the file is from a read-only, read-once resource directory
* @param fullname name of the file to parse
* @return GNUNET_OK (continue iteration)
*/
static int
hosts_directory_scan_callback (void *cls, const char *fullname)
{
unsigned int *matched = cls;
struct GNUNET_PeerIdentity identity;
const char *filename;
struct HostEntry *entry;
struct GNUNET_HELLO_Message *hello;
if (GNUNET_DISK_file_test (fullname) != GNUNET_YES)
return GNUNET_OK; /* ignore non-files */
if (strlen (fullname) < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded))
{
if (NULL != matched)
remove_garbage (fullname);
return GNUNET_OK;
}
filename =
&fullname[strlen (fullname) -
sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) + 1];
if (filename[-1] != DIR_SEPARATOR)
{
if (NULL != matched)
remove_garbage (fullname);
return GNUNET_OK;
}
if (GNUNET_OK !=
GNUNET_CRYPTO_hash_from_string (filename, &identity.hashPubKey))
{
if (NULL != (hello = read_host_file (filename)))
{
entry = GNUNET_malloc (sizeof (struct HostEntry));
if (GNUNET_OK ==
GNUNET_HELLO_get_id (hello,
&entry->identity))
{
GNUNET_CONTAINER_multihashmap_put (hostmap, &entry->identity.hashPubKey, entry,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
entry->hello = hello;
notify_all (entry);
return GNUNET_OK;
}
GNUNET_free (entry);
}
if (NULL != matched)
remove_garbage (fullname);
return GNUNET_OK;
}
if (NULL != matched)
(*matched)++;
add_host_to_known_hosts (&identity);
return GNUNET_OK;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
ret = 1;
end ();
return;
}
/* Set up peer */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID0, &p.id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID0, GNUNET_i2s_full (&p.id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s_full(&p.id));
/* Prepare ATS Information */
test_ats_info[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
test_ats_info[0].value = htonl(GNUNET_ATS_NET_WAN);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
test_ats_info[1].value = htonl(1);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
test_ats_info[1].value = htonl(10);
test_ats_count = 2;
/* Adding address without session */
test_session = &test_addr;
create_test_address (&test_addr, "test", &test_addr, "test", strlen ("test") + 1);
test_hello_address.peer = p.id;
test_hello_address.transport_name = test_addr.plugin;
test_hello_address.address = test_addr.addr;
test_hello_address.address_length = test_addr.addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address, test_session, test_ats_info, test_ats_count);
/* Request address */
GNUNET_ATS_suggest_address (sched_ats, &p.id);
}
/**
* Call MESH's monitor API, get info of one tunnel.
*
* @param cls Closure (unused).
* @param tc TaskContext
*/
static void
show_tunnel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_PeerIdentity pid;
if (GNUNET_OK !=
GNUNET_CRYPTO_hash_from_string (tunnel_id, &pid.hashPubKey))
{
GNUNET_SCHEDULER_shutdown();
return;
}
GNUNET_MESH_show_tunnel (mh, &pid, 0, tunnel_callback, NULL);
}
static int
test (int number)
{
struct GNUNET_HashCode h1;
struct GNUNET_HashCode h2;
struct GNUNET_CRYPTO_HashAsciiEncoded enc;
memset (&h1, number, sizeof (struct GNUNET_HashCode));
GNUNET_CRYPTO_hash_to_enc (&h1, &enc);
if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &h2))
{
printf ("enc2hash failed!\n");
return 1;
}
if (0 != memcmp (&h1, &h2, sizeof (struct GNUNET_HashCode)))
return 1;
return 0;
}
/**
* the help function to list all available pseudonyms
* @param cls point to a struct ListPseudonymClosure
* @param fullname name of pseudonym
*/
static int
list_pseudonym_helper (void *cls, const char *fullname)
{
struct ListPseudonymClosure *c = cls;
int ret;
struct GNUNET_HashCode id;
int32_t rating;
struct GNUNET_CONTAINER_MetaData *meta;
const char *fn;
char *str;
char *name_unique;
if (strlen (fullname) < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded))
return GNUNET_OK;
fn = &fullname[strlen (fullname) + 1 -
sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
if (fn[-1] != DIR_SEPARATOR)
return GNUNET_OK;
ret = GNUNET_OK;
if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (fn, &id))
return GNUNET_OK; /* invalid name */
str = NULL;
if (GNUNET_OK != GNUNET_PSEUDONYM_get_info (c->cfg, &id, &meta, &rating,
&str, NULL))
{
/* ignore entry. FIXME: Why? Lack of data about a pseudonym is not a reason
* to ignore it... So yeah, it will have placeholders instead of name,
* empty metadata container and a default rank == -1, so what? We know
* its nsid - that's all we really need. Right? */
GNUNET_free (str);
GNUNET_CONTAINER_meta_data_destroy (meta);
return GNUNET_OK;
}
name_unique = GNUNET_PSEUDONYM_name_uniquify (c->cfg, &id, str, NULL);
if (c->iterator != NULL)
ret = c->iterator (c->closure, &id, str, name_unique, meta, rating);
GNUNET_free_non_null (str);
GNUNET_free_non_null (name_unique);
GNUNET_CONTAINER_meta_data_destroy (meta);
return ret;
}
/**
* Convert human-readable version of a 'value' of a record to the binary
* representation.
*
* @param type type of the record
* @param s human-readable string
* @param data set to value in binary encoding (will be allocated)
* @param data_size set to number of bytes in data
* @return GNUNET_OK on success
*/
int
GNUNET_NAMESTORE_string_to_value (uint32_t type,
const char *s,
void **data,
size_t *data_size)
{
struct in_addr value_a;
struct in6_addr value_aaaa;
struct GNUNET_CRYPTO_ShortHashCode pkey;
struct soa_data *soa;
struct vpn_data *vpn;
struct tlsa_data *tlsa;
char result[253 + 1];
char soa_rname[253 + 1];
char soa_mname[253 + 1];
char s_peer[103 + 1];
char s_serv[253 + 1];
unsigned int soa_serial;
unsigned int soa_refresh;
unsigned int soa_retry;
unsigned int soa_expire;
unsigned int soa_min;
uint16_t mx_pref;
uint16_t mx_pref_n;
unsigned int proto;
switch (type)
{
case 0:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unsupported record type %d\n"),
(int) type);
return GNUNET_SYSERR;
case GNUNET_DNSPARSER_TYPE_A:
if (1 != inet_pton (AF_INET, s, &value_a))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse IPv4 address `%s'\n"),
s);
return GNUNET_SYSERR;
}
*data = GNUNET_malloc (sizeof (struct in_addr));
memcpy (*data, &value_a, sizeof (value_a));
*data_size = sizeof (value_a);
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_NS:
*data = GNUNET_strdup (s);
*data_size = strlen (s) + 1;
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_CNAME:
*data = GNUNET_strdup (s);
*data_size = strlen (s) + 1;
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_SOA:
if (7 != SSCANF (s,
"rname=%253s mname=%253s %u,%u,%u,%u,%u",
soa_rname, soa_mname,
&soa_serial, &soa_refresh, &soa_retry, &soa_expire, &soa_min))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse SOA record `%s'\n"),
s);
return GNUNET_SYSERR;
}
*data_size = sizeof (struct soa_data)+strlen(soa_rname)+strlen(soa_mname)+2;
*data = GNUNET_malloc (*data_size);
soa = (struct soa_data*)*data;
soa->serial = htonl(soa_serial);
soa->refresh = htonl(soa_refresh);
soa->retry = htonl(soa_retry);
soa->expire = htonl(soa_expire);
soa->minimum = htonl(soa_min);
strcpy((char*)&soa[1], soa_rname);
strcpy((char*)&soa[1]+strlen(*data)+1, soa_mname);
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_PTR:
*data = GNUNET_strdup (s);
*data_size = strlen (s);
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_MX:
if (2 != SSCANF(s, "%hu,%253s", &mx_pref, result))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse MX record `%s'\n"),
s);
return GNUNET_SYSERR;
}
*data_size = sizeof (uint16_t)+strlen(result)+1;
*data = GNUNET_malloc (*data_size);
mx_pref_n = htons(mx_pref);
memcpy(*data, &mx_pref_n, sizeof (uint16_t));
strcpy((*data)+sizeof (uint16_t), result);
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_TXT:
*data = GNUNET_strdup (s);
*data_size = strlen (s);
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_AAAA:
if (1 != inet_pton (AF_INET6, s, &value_aaaa))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse IPv6 address `%s'\n"),
s);
return GNUNET_SYSERR;
}
*data = GNUNET_malloc (sizeof (struct in6_addr));
*data_size = sizeof (struct in6_addr);
memcpy (*data, &value_aaaa, sizeof (value_aaaa));
return GNUNET_OK;
case GNUNET_NAMESTORE_TYPE_PKEY:
if (GNUNET_OK !=
GNUNET_CRYPTO_short_hash_from_string (s, &pkey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse PKEY record `%s'\n"),
s);
return GNUNET_SYSERR;
}
*data = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
memcpy (*data, &pkey, sizeof (pkey));
*data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
return GNUNET_OK;
case GNUNET_NAMESTORE_TYPE_PSEU:
*data = GNUNET_strdup (s);
*data_size = strlen (s);
return GNUNET_OK;
case GNUNET_NAMESTORE_TYPE_LEHO:
*data = GNUNET_strdup (s);
*data_size = strlen (s);
return GNUNET_OK;
case GNUNET_NAMESTORE_TYPE_VPN:
if (3 != SSCANF (s,"%u %103s %253s",
&proto, s_peer, s_serv))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse VPN record string `%s'\n"),
s);
return GNUNET_SYSERR;
}
*data_size = sizeof (struct vpn_data) + strlen (s_serv) + 1;
*data = vpn = GNUNET_malloc (*data_size);
if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char*)&s_peer,
&vpn->peer))
{
GNUNET_free (vpn);
*data_size = 0;
return GNUNET_SYSERR;
}
vpn->proto = htons ((uint16_t) proto);
strcpy ((char*)&vpn[1], s_serv);
return GNUNET_OK;
case GNUNET_DNSPARSER_TYPE_TLSA:
*data_size = sizeof (struct tlsa_data) + strlen (s) - 6;
*data = tlsa = GNUNET_malloc (*data_size);
if (4 != SSCANF (s, "%c %c %c %s",
&tlsa->usage,
&tlsa->selector,
&tlsa->matching_type,
(char*)&tlsa[1]))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to parse TLSA record string `%s'\n"),
s);
*data_size = 0;
GNUNET_free (tlsa);
return GNUNET_SYSERR;
}
return GNUNET_OK;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unsupported record type %d\n"),
(int) type);
return GNUNET_SYSERR;
}
}
static void
testservice_task (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
int counter = 0;
ret = 1;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
{
FPRINTF (stderr, _("Service `%s' is not running\n"), "transport");
return;
}
if ((NULL != cpid) && (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (cpid, &pid.hashPubKey)))
{
FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), cpid);
return;
}
counter = benchmark_send + benchmark_receive + iterate_connections +
monitor_connections + monitor_connects + try_connect;
if (1 < counter)
{
FPRINTF (stderr, _("Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s\n"),
"connect", "benchmark send", "benchmark receive", "information", "monitor", "events");
return;
}
if (0 == counter)
{
FPRINTF (stderr, _("No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s\n"),
"connect", "benchmark send", "benchmark receive", "information", "monitor", "events");
return;
}
if (try_connect) /* -C: Connect to peer */
{
if (NULL == cpid)
{
FPRINTF (stderr, _("Option `%s' makes no sense without option `%s'.\n"),
"-C", "-p");
ret = 1;
return;
}
handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL,
¬ify_receive,
¬ify_connect,
¬ify_disconnect);
if (NULL == handle)
{
FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
ret = 1;
return;
}
tc_handle = GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, NULL);
if (NULL == tc_handle)
{
FPRINTF (stderr, "%s", _("Failed to send request to transport service\n"));
ret = 1;
return;
}
op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
&operation_timeout, NULL);
}
else if (benchmark_send) /* -s: Benchmark sending */
{
if (NULL == cpid)
{
FPRINTF (stderr, _("Option `%s' makes no sense without option `%s'.\n"),
"-s", "-p");
ret = 1;
return;
}
handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL,
¬ify_receive,
¬ify_connect,
¬ify_disconnect);
if (NULL == handle)
{
FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
ret = 1;
return;
}
tc_handle = GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, NULL);
if (NULL == tc_handle)
{
FPRINTF (stderr, "%s", _("Failed to send request to transport service\n"));
ret = 1;
return;
}
start_time = GNUNET_TIME_absolute_get ();
op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
&operation_timeout, NULL);
}
else if (benchmark_receive) /* -b: Benchmark receiving */
{
handle =
GNUNET_TRANSPORT_connect (cfg, NULL, NULL, ¬ify_receive,
NULL, NULL);
if (NULL == handle)
{
FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
ret = 1;
return;
}
if (verbosity > 0)
FPRINTF (stdout, "%s", _("Starting to receive benchmark data\n"));
start_time = GNUNET_TIME_absolute_get ();
}
else if (iterate_connections) /* -i: List all active addresses once */
{
peers = GNUNET_CONTAINER_multihashmap_create (20, GNUNET_NO);
address_resolution_in_progress = GNUNET_YES;
pic = GNUNET_TRANSPORT_peer_get_active_addresses (cfg,
(NULL == cpid) ? NULL : &pid,
GNUNET_YES,
TIMEOUT,
&process_address, (void *) cfg);
op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
&operation_timeout, NULL);
}
else if (monitor_connections) /* -m: List all active addresses continously */
{
peers = GNUNET_CONTAINER_multihashmap_create (20, GNUNET_NO);
address_resolution_in_progress = GNUNET_YES;
pic = GNUNET_TRANSPORT_peer_get_active_addresses (cfg,
(NULL == cpid) ? NULL : &pid,
GNUNET_NO,
TIMEOUT,
&process_address, (void *) cfg);
}
else if (monitor_connects) /* -e : Monitor (dis)connect events continously */
{
monitor_connect_counter = 0;
handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL, NULL,
&monitor_notify_connect,
&monitor_notify_disconnect);
if (NULL == handle)
{
FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
ret = 1;
return;
}
ret = 0;
}
else
{
GNUNET_break (0);
return;
}
end = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
void testservice_ats (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_PeerIdentity pid;
struct GNUNET_CONFIGURATION_Handle *cfg = cls;
unsigned int c;
unsigned int type;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
{
FPRINTF (stderr, _("Service `%s' is not running\n"), "ats");
return;
}
results = 0;
if (NULL != pid_str)
{
if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (pid_str, &pid.hashPubKey))
{
FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), pid_str);
return;
}
}
c = op_list_all + op_list_used + op_monitor + op_set_pref;
if ((1 < c))
{
FPRINTF (stderr, _("Please select one operation : %s or %s or %s or %s\n"),
"--used", "--all", "--monitor", "--preference");
return;
}
if ((0 == c))
op_list_used = GNUNET_YES; /* set default */
if (op_list_all)
{
ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (NULL == ph)
{
fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
return;
}
alh = GNUNET_ATS_performance_list_addresses (ph,
(NULL == pid_str) ? NULL : &pid,
GNUNET_YES, ats_perf_cb, NULL);
if (NULL == alh)
{
fprintf (stderr, _("Cannot issue request to ATS service, exiting...\n"));
end_task = GNUNET_SCHEDULER_add_now (&end, NULL);
return;
}
end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end, NULL);
}
else if (op_list_used)
{
ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (NULL == ph)
fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
alh = GNUNET_ATS_performance_list_addresses (ph,
(NULL == pid_str) ? NULL : &pid,
GNUNET_NO, ats_perf_cb, NULL);
if (NULL == alh)
{
fprintf (stderr, _("Cannot issue request to ATS service, exiting...\n"));
end_task = GNUNET_SCHEDULER_add_now (&end, NULL);
return;
}
end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end, NULL);
}
else if (op_monitor)
{
ph = GNUNET_ATS_performance_init (cfg, ats_perf_cb, NULL);
if (NULL == ph)
fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &end, NULL);
}
else if (op_set_pref)
{
for (c = 0; c<strlen(type_str); c++)
{
if (isupper (type_str[c]))
type_str[c] = tolower (type_str[c]);
}
if (0 == strcasecmp("latency", type_str))
type = GNUNET_ATS_PREFERENCE_LATENCY;
else if (0 == strcasecmp("bandwidth", type_str))
type = GNUNET_ATS_PREFERENCE_BANDWIDTH;
else
{
FPRINTF (stderr, "%s", _("Type required\n"));
return;
}
/* set */
ph = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (NULL == ph)
fprintf (stderr, _("Cannot connect to ATS service, exiting...\n"));
GNUNET_ATS_change_preference (ph, &pid, type, (double) value, GNUNET_ATS_PREFERENCE_END);
end_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &end, NULL);
}
ret = 1;
}
/**
* Read the friends file.
*/
static void
read_friends_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char *fn;
char *data;
size_t pos;
struct GNUNET_PeerIdentity pid;
uint64_t fsize;
struct GNUNET_CRYPTO_HashAsciiEncoded enc;
unsigned int entries_found;
struct Peer *fl;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "TOPOLOGY", "FRIENDS", &fn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"topology", "FRIENDS");
return;
}
if (GNUNET_OK != GNUNET_DISK_file_test (fn))
GNUNET_DISK_fn_write (fn, NULL, 0,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE);
if (GNUNET_OK != GNUNET_DISK_file_size (fn,
&fsize, GNUNET_NO, GNUNET_YES))
{
if ((friends_only) || (minimum_friend_count > 0))
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not read friends list `%s'\n"), fn);
GNUNET_free (fn);
return;
}
if (fsize == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Friends file `%s' is empty.\n"),
fn);
GNUNET_free (fn);
return;
}
data = GNUNET_malloc_large (fsize);
if (data == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to read friends list from `%s': out of memory\n"),
fn);
GNUNET_free (fn);
return;
}
if (fsize != GNUNET_DISK_fn_read (fn, data, fsize))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to read friends list from `%s'\n"), fn);
GNUNET_free (fn);
GNUNET_free (data);
return;
}
entries_found = 0;
pos = 0;
while ((pos < fsize) && isspace ((unsigned char) data[pos]))
pos++;
while ((fsize >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
(pos <=
fsize - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
{
memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
if (!isspace
((unsigned char)
enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Syntax error in topology specification at offset %llu, skipping bytes.\n"),
(unsigned long long) pos);
pos++;
while ((pos < fsize) && (!isspace ((unsigned char) data[pos])))
pos++;
continue;
}
enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
if (GNUNET_OK !=
GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Syntax error in topology specification at offset %llu, skipping bytes `%s'.\n"),
(unsigned long long) pos, &enc);
}
else
{
if (0 != memcmp (&pid, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
{
entries_found++;
fl = make_peer (&pid, NULL, GNUNET_YES);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Found friend `%s' in configuration\n"),
GNUNET_i2s (&fl->pid));
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Found myself `%s' in friend list (useless, ignored)\n"),
GNUNET_i2s (&pid));
}
}
pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
while ((pos < fsize) && isspace ((unsigned char) data[pos]))
pos++;
}
GNUNET_free (data);
GNUNET_free (fn);
GNUNET_STATISTICS_update (stats, gettext_noop ("# friends in configuration"),
entries_found, GNUNET_NO);
if ((minimum_friend_count > entries_found) && (friends_only == GNUNET_NO))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("Fewer friends specified than required by minimum friend count. Will only connect to friends.\n"));
}
if ((minimum_friend_count > target_connection_count) &&
(friends_only == GNUNET_NO))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_
("More friendly connections required than target total number of connections.\n"));
}
}
/**
* Initialize the database connections and associated
* data structures (create tables and indices
* as needed as well).
*
* @param plugin the plugin context (state for this module)
* @return #GNUNET_OK on success
*/
static int
database_setup (struct Plugin *plugin)
{
char *afsdir;
char* block_buffer;
char* buffer;
char* line;
char* query;
char* block;
size_t size;
struct FlatFileEntry *entry;
struct GNUNET_DISK_FileHandle *fh;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "namecache-flat",
"FILENAME", &afsdir))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"namecache-flat", "FILENAME");
return GNUNET_SYSERR;
}
if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
{
if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
{
GNUNET_break (0);
GNUNET_free (afsdir);
return GNUNET_SYSERR;
}
}
/* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
plugin->fn = afsdir;
/* Load data from file into hashmap */
plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
GNUNET_NO);
fh = GNUNET_DISK_file_open (afsdir,
GNUNET_DISK_OPEN_CREATE |
GNUNET_DISK_OPEN_READWRITE,
GNUNET_DISK_PERM_USER_WRITE |
GNUNET_DISK_PERM_USER_READ);
if (NULL == fh)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to initialize file: %s.\n"),
afsdir);
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR == GNUNET_DISK_file_size (afsdir,
&size,
GNUNET_YES,
GNUNET_YES))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to get filesize: %s.\n"),
afsdir);
return GNUNET_SYSERR;
}
if (0 == size)
return GNUNET_OK;
buffer = GNUNET_malloc (size);
if (GNUNET_SYSERR == GNUNET_DISK_file_read (fh,
buffer,
size))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Unable to read file: %s.\n"),
afsdir);
return GNUNET_SYSERR;
}
GNUNET_DISK_file_close (fh);
if (0 < size) {
line = strtok (buffer, "\n");
while (line != NULL) {
query = strtok (line, ",");
if (NULL == query)
break;
block = strtok (NULL, ",");
if (NULL == block)
break;
line = strtok (NULL, "\n");
entry = GNUNET_malloc (sizeof (struct FlatFileEntry));
GNUNET_CRYPTO_hash_from_string (query,
&entry->query);
GNUNET_STRINGS_base64_decode (block,
strlen (block),
&block_buffer);
entry->block = (struct GNUNET_GNSRECORD_Block *) block_buffer;
if (GNUNET_OK !=
GNUNET_CONTAINER_multihashmap_put (plugin->hm,
&entry->query,
entry,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_free (entry);
GNUNET_break (0);
}
}
}
GNUNET_free (buffer);
return GNUNET_OK;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
char *quota_str;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", "a_str))
{
fprintf (stderr, "Cannot load WAN outbound quota from configuration, exit!\n");
ret = 1;
return;
}
if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_str, &wan_quota_out))
{
fprintf (stderr, "Cannot load WAN outbound quota from configuration, exit!\n");
ret = 1;
GNUNET_free (quota_str);
return;
}
GNUNET_free (quota_str);
quota_str = NULL;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", "a_str))
{
fprintf (stderr, "Cannot load WAN inbound quota from configuration, exit!\n");
ret = 1;
return;
}
if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_str, &wan_quota_in))
{
fprintf (stderr, "Cannot load WAN inbound quota from configuration, exit!\n");
GNUNET_free (quota_str);
ret = 1;
return;
}
GNUNET_free (quota_str);
quota_str = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Configured WAN inbound quota: %llu\n", wan_quota_in);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Configured WAN outbound quota: %llu\n", wan_quota_out);
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
ret = 1;
end ();
return;
}
perf_ats = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (perf_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS performance!\n");
ret = 1;
end ();
return;
}
/* Set up peer 0 */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID0, &p[0].id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID0, GNUNET_i2s_full (&p[0].id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s(&p[0].id));
/* Set up peer 0 */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID1, &p[1].id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID1, GNUNET_i2s_full (&p[1].id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s(&p[1].id));
/* Prepare ATS Information */
test_ats_info[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
test_ats_info[0].value = htonl(GNUNET_ATS_NET_WAN);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
test_ats_info[1].value = htonl(1);
test_ats_count = 2;
/* Adding address with session */
test_session[0] = &test_addr[0];
create_test_address (&test_addr[0], "test0", test_session[0], "test0", strlen ("test0") + 1);
test_hello_address[0].peer = p[0].id;
test_hello_address[0].transport_name = test_addr[0].plugin;
test_hello_address[0].address = test_addr[0].addr;
test_hello_address[0].address_length = test_addr[0].addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address[0], test_session[0], test_ats_info, test_ats_count);
/* Adding address with session */
test_session[1] = &test_addr[1];
create_test_address (&test_addr[1], "test1", test_session[1], "test1", strlen ("test1") + 1);
test_hello_address[1].peer = p[1].id;
test_hello_address[1].transport_name = test_addr[0].plugin;
test_hello_address[1].address = test_addr[0].addr;
test_hello_address[1].address_length = test_addr[0].addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address[1], test_session[1], test_ats_info, test_ats_count);
/* Change bandwidth preference */
GNUNET_ATS_change_preference (perf_ats,
&p[0].id,
GNUNET_ATS_PREFERENCE_BANDWIDTH,(double) 1000, GNUNET_ATS_PREFERENCE_END);
GNUNET_ATS_change_preference (perf_ats,
&p[1].id,
GNUNET_ATS_PREFERENCE_BANDWIDTH,(double) 1000, GNUNET_ATS_PREFERENCE_END);
/* Change latency preference */
GNUNET_ATS_change_preference (perf_ats,
&p[0].id,
GNUNET_ATS_PREFERENCE_LATENCY,(double) 10, GNUNET_ATS_PREFERENCE_END);
GNUNET_ATS_change_preference (perf_ats,
&p[1].id,
GNUNET_ATS_PREFERENCE_LATENCY,(double) 100, GNUNET_ATS_PREFERENCE_END);
GNUNET_SCHEDULER_add_delayed (SLEEP, &sleep_task, NULL);
}
