static void
clean_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
size_t dsize;
void *ddata;
GNUNET_FS_stop (ctx);
ctx = NULL;
if (output_filename == NULL)
return;
if (GNUNET_OK != GNUNET_FS_directory_builder_finish (db, &dsize, &ddata))
{
GNUNET_break (0);
GNUNET_free (output_filename);
return;
}
if (dsize !=
GNUNET_DISK_fn_write (output_filename, ddata, dsize,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
{
FPRINTF (stderr,
_("Failed to write directory with search results to `%s'\n"),
output_filename);
}
GNUNET_free_non_null (ddata);
GNUNET_free (output_filename);
}
/**
* Write our current proof to disk.
*/
static void
write_proof ()
{
if (sizeof (proof) !=
GNUNET_DISK_fn_write (pwfn, &proof, sizeof (proof),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof);
}
static int
testReadWrite ()
{
char tmp[100 + 1];
int ret;
if (strlen (TESTSTRING) !=
GNUNET_DISK_fn_write (".testfile", TESTSTRING, strlen (TESTSTRING),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
return 1;
if (GNUNET_OK != GNUNET_DISK_file_test (".testfile"))
return 1;
ret = GNUNET_DISK_fn_read (".testfile", tmp, sizeof (tmp) - 1);
if (ret < 0)
{
FPRINTF (stderr, "Error reading file `%s' in testReadWrite\n", ".testfile");
return 1;
}
tmp[ret] = '\0';
if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
{
FPRINTF (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
TESTSTRING, ".testfile");
return 1;
}
GNUNET_DISK_file_copy (".testfile", ".testfile2");
memset (tmp, 0, sizeof (tmp));
ret = GNUNET_DISK_fn_read (".testfile2", tmp, sizeof (tmp) - 1);
if (ret < 0)
{
FPRINTF (stderr, "Error reading file `%s' in testReadWrite\n",
".testfile2");
return 1;
}
tmp[ret] = '\0';
if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
{
FPRINTF (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
TESTSTRING, ".testfile2");
return 1;
}
GNUNET_break (0 == UNLINK (".testfile"));
GNUNET_break (0 == UNLINK (".testfile2"));
if (GNUNET_NO != GNUNET_DISK_file_test (".testfile"))
return 1;
return 0;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_TESTING_Peer *peer)
{
const char *keywords[] = {
"down_foo",
"down_bar",
};
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *kuri;
struct GNUNET_FS_FileInformation *fi;
size_t i;
struct GNUNET_FS_BlockOptions bo;
cfg = c;
fn = GNUNET_DISK_mktemp ("gnunet-unindex-test-dst");
fs = GNUNET_FS_start (cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
GNUNET_assert (NULL != fs);
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
meta = GNUNET_CONTAINER_meta_data_create ();
kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
bo.content_priority = 42;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
fi = GNUNET_FS_file_information_create_from_file (fs, "publish-context", fn,
kuri, meta, GNUNET_YES,
&bo);
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fi);
start = GNUNET_TIME_absolute_get ();
publish =
GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
GNUNET_FS_PUBLISH_OPTION_NONE);
GNUNET_assert (publish != NULL);
}
/**
* Handler for CREATE message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_create_message (void *cls,
const struct CreateRequestMessage *crm)
{
struct GNUNET_SERVICE_Client *client = cls;
struct Ego *ego;
const char *str;
char *fn;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received CREATE message from client\n");
str = (const char *) &crm[1];
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
str))
{
send_result_code (client, 1, gettext_noop ("identifier already in use for another ego"));
GNUNET_SERVICE_client_continue (client);
return;
}
}
ego = GNUNET_new (struct Ego);
ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
*ego->pk = crm->private_key;
ego->identifier = GNUNET_strdup (str);
GNUNET_CONTAINER_DLL_insert (ego_head,
ego_tail,
ego);
send_result_code (client, 0, NULL);
fn = get_ego_filename (ego);
(void) GNUNET_DISK_directory_create_for_file (fn);
if (sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey) !=
GNUNET_DISK_fn_write (fn,
&crm->private_key,
sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
"write", fn);
GNUNET_free (fn);
notify_listeners (ego);
GNUNET_SERVICE_client_continue (client);
}
/**
* Bind a host address (hello) to a hostId.
*
* @param peer the peer for which this is a hello
* @param hello the verified (!) hello message
*/
static void
bind_address (const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Message *hello)
{
char *fn;
struct HostEntry *host;
struct GNUNET_HELLO_Message *mrg;
struct GNUNET_TIME_Absolute delta;
add_host_to_known_hosts (peer);
host = GNUNET_CONTAINER_multihashmap_get (hostmap, &peer->hashPubKey);
GNUNET_assert (host != NULL);
if (host->hello == NULL)
{
host->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
memcpy (host->hello, hello, GNUNET_HELLO_size (hello));
}
else
{
mrg = GNUNET_HELLO_merge (host->hello, hello);
delta = GNUNET_HELLO_equals (mrg, host->hello, GNUNET_TIME_absolute_get ());
if (delta.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
{
GNUNET_free (mrg);
return;
}
GNUNET_free (host->hello);
host->hello = mrg;
}
fn = get_host_filename (peer);
if (GNUNET_OK == GNUNET_DISK_directory_create_for_file (fn))
{
if (GNUNET_SYSERR ==
GNUNET_DISK_fn_write (fn, host->hello, GNUNET_HELLO_size (host->hello),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE |
GNUNET_DISK_PERM_GROUP_READ |
GNUNET_DISK_PERM_OTHER_READ))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
}
GNUNET_free (fn);
notify_all (host);
}
/**
* Write our current proof to disk.
*/
static void
write_proof ()
{
char *proof;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg,
"NSE",
"PROOFFILE",
&proof))
return;
if (sizeof (my_proof) !=
GNUNET_DISK_fn_write (proof,
&my_proof,
sizeof (my_proof),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"write",
proof);
GNUNET_free (proof);
}
/**
* @brief delete expired HELLO entries in data/hosts/
*
* @param cls pointer to current time (struct GNUNET_TIME_Absolute)
* @param fn filename to test to see if the HELLO expired
* @return GNUNET_OK (continue iteration)
*/
static int
discard_hosts_helper (void *cls, const char *fn)
{
struct GNUNET_TIME_Absolute *now = cls;
char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1] GNUNET_ALIGN;
const struct GNUNET_HELLO_Message *hello;
struct GNUNET_HELLO_Message *new_hello;
int size;
size = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
if (size < sizeof (struct GNUNET_MessageHeader))
{
if (0 != UNLINK (fn))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
GNUNET_ERROR_TYPE_BULK, "unlink", fn);
return GNUNET_OK;
}
hello = (const struct GNUNET_HELLO_Message *) buffer;
new_hello =
GNUNET_HELLO_iterate_addresses (hello, GNUNET_YES, &discard_expired, now);
if (new_hello != NULL)
{
GNUNET_DISK_fn_write (fn, new_hello, GNUNET_HELLO_size (new_hello),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE |
GNUNET_DISK_PERM_GROUP_READ |
GNUNET_DISK_PERM_OTHER_READ);
GNUNET_free (new_hello);
}
else
{
if (0 != UNLINK (fn))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
GNUNET_ERROR_TYPE_BULK, "unlink", fn);
}
return GNUNET_OK;
}
/**
* Handler for CREATE message from client, creates
* new identity.
*
* @param cls unused
* @param client who sent the message
* @param message the message received
*/
static void
handle_create_message (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_IDENTITY_CreateRequestMessage *crm;
uint16_t size;
uint16_t name_len;
struct Ego *ego;
const char *str;
char *fn;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received CREATE message from client\n");
size = ntohs (message->size);
if (size <= sizeof (struct GNUNET_IDENTITY_CreateRequestMessage))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
crm = (const struct GNUNET_IDENTITY_CreateRequestMessage *) message;
name_len = ntohs (crm->name_len);
GNUNET_break (0 == ntohs (crm->reserved));
if (name_len + sizeof (struct GNUNET_IDENTITY_CreateRequestMessage) != size)
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
str = (const char *) &crm[1];
if ('\0' != str[name_len - 1])
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
for (ego = ego_head; NULL != ego; ego = ego->next)
{
if (0 == strcmp (ego->identifier,
str))
{
send_result_code (client, 1, gettext_noop ("identifier already in use for another ego"));
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
}
ego = GNUNET_new (struct Ego);
ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
*ego->pk = crm->private_key;
ego->identifier = GNUNET_strdup (str);
GNUNET_CONTAINER_DLL_insert (ego_head,
ego_tail,
ego);
send_result_code (client, 0, NULL);
fn = get_ego_filename (ego);
(void) GNUNET_DISK_directory_create_for_file (fn);
if (sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey) !=
GNUNET_DISK_fn_write (fn,
&crm->private_key,
sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
"write", fn);
GNUNET_free (fn);
notify_listeners (ego);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
const char *keywords[] = {
"down_foo",
"down_bar",
};
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *kuri;
struct GNUNET_FS_FileInformation *fi1;
struct GNUNET_FS_FileInformation *fi2;
struct GNUNET_FS_FileInformation *fidir;
size_t i;
struct GNUNET_FS_BlockOptions bo;
cfg = c;
setup_peer (&p1, "test_fs_publish_data.conf");
fs = GNUNET_FS_start (cfg, "test-fs-publish-persistence", &progress_cb, NULL,
GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
GNUNET_assert (NULL != fs);
fn1 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
fn2 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
meta = GNUNET_CONTAINER_meta_data_create ();
kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
bo.content_priority = 42;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
fi1 =
GNUNET_FS_file_information_create_from_file (fs, "publish-context1", fn1,
kuri, meta, GNUNET_YES, &bo);
GNUNET_assert (NULL != fi1);
bo.anonymity_level = 2;
fi2 =
GNUNET_FS_file_information_create_from_file (fs, "publish-context2", fn2,
kuri, meta, GNUNET_YES, &bo);
GNUNET_assert (NULL != fi2);
bo.anonymity_level = 3;
fidir =
GNUNET_FS_file_information_create_empty_directory (fs,
"publish-context-dir",
kuri, meta, &bo, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fidir);
start = GNUNET_TIME_absolute_get ();
GNUNET_FS_publish_start (fs, fidir, NULL, NULL, NULL,
GNUNET_FS_PUBLISH_OPTION_NONE);
GNUNET_assert (publish != NULL);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
const char *keywords[] = {
"down_foo",
"down_bar",
};
char *fn1;
char *fn2;
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *kuri;
struct GNUNET_FS_FileInformation *fi1;
struct GNUNET_FS_FileInformation *fi2;
struct GNUNET_FS_FileInformation *fidir;
struct GNUNET_FS_Handle *fs;
size_t i;
struct GNUNET_FS_BlockOptions bo;
fs = GNUNET_FS_start (cfg, "test-fs-file-information", NULL, NULL,
GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
fn1 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
fn2 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
meta = GNUNET_CONTAINER_meta_data_create ();
kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
bo.content_priority = 42;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
fi1 =
GNUNET_FS_file_information_create_from_file (fs,
"file_information-context1",
fn1, kuri, meta, GNUNET_YES,
&bo);
GNUNET_assert (fi1 != NULL);
fi2 =
GNUNET_FS_file_information_create_from_file (fs,
"file_information-context2",
fn2, kuri, meta, GNUNET_YES,
&bo);
GNUNET_assert (fi2 != NULL);
fidir =
GNUNET_FS_file_information_create_empty_directory (fs,
"file_information-context-dir",
kuri, meta, &bo, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fidir);
/* FIXME: test more of API! */
GNUNET_FS_file_information_destroy (fidir, &mycleaner, NULL);
GNUNET_DISK_directory_remove (fn1);
GNUNET_DISK_directory_remove (fn2);
GNUNET_free_non_null (fn1);
GNUNET_free_non_null (fn2);
GNUNET_FS_stop (fs);
}
/**
* 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"));
}
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_TESTING_Host *hosts;
struct GNUNET_TESTING_Host *hostpos;
struct GNUNET_TESTING_Host *temphost;
char *hostfile;
struct stat frstat;
char *buf;
char *data;
int count;
int ret;
ok = 1;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
#endif
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
&num_peers))
num_peers = DEFAULT_NUM_PEERS;
GNUNET_assert (num_peers > 0 && num_peers < (unsigned long long) -1);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "hostfile",
&hostfile))
hostfile = NULL;
hosts = NULL;
data = NULL;
if (hostfile != NULL)
{
if (GNUNET_OK != GNUNET_DISK_file_test (hostfile))
GNUNET_DISK_fn_write (hostfile, NULL, 0,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE);
if ((0 != STAT (hostfile, &frstat)) || (frstat.st_size == 0))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Could not open file specified for host list, ending test!");
ok = 1119;
GNUNET_free (hostfile);
return;
}
data = GNUNET_malloc_large (frstat.st_size);
GNUNET_assert (data != NULL);
if (frstat.st_size != GNUNET_DISK_fn_read (hostfile, data, frstat.st_size))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Could not read file %s specified for host list, ending test!",
hostfile);
GNUNET_free (hostfile);
GNUNET_free (data);
return;
}
GNUNET_free_non_null (hostfile);
buf = data;
count = 0;
while (count < frstat.st_size)
{
count++;
if (count >= frstat.st_size)
break;
/* if (((data[count] == '\n') || (data[count] == '\0')) && (buf != &data[count])) */
if (((data[count] == '\n')) && (buf != &data[count]))
{
data[count] = '\0';
temphost = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Host));
ret =
SSCANF (buf, "%a[a-zA-Z0-9]@%a[a-zA-Z0-9.]:%hd",
&temphost->username, &temphost->hostname, &temphost->port);
if (3 == ret)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Successfully read host %s, port %d and user %s from file\n",
temphost->hostname, temphost->port, temphost->username);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Error reading line `%s' in hostfile\n", buf);
GNUNET_free (temphost);
buf = &data[count + 1];
continue;
}
/* temphost->hostname = buf; */
temphost->next = hosts;
hosts = temphost;
buf = &data[count + 1];
}
else if ((data[count] == '\n') || (data[count] == '\0'))
buf = &data[count + 1];
}
}
peers_left = num_peers;
pg = GNUNET_TESTING_daemons_start (cfg, peers_left, /* Total number of peers */
peers_left, /* Number of outstanding connections */
peers_left, /* Number of parallel ssh connections, or peers being started at once */
TIMEOUT, NULL, NULL, &my_cb, NULL, NULL,
NULL, hosts);
hostpos = hosts;
while (hostpos != NULL)
{
temphost = hostpos->next;
GNUNET_free (hostpos->hostname);
GNUNET_free (hostpos->username);
GNUNET_free (hostpos);
hostpos = temphost;
}
GNUNET_free_non_null (data);
GNUNET_assert (pg != NULL);
}
