/**
* Construct our HELLO message from all of the addresses of
* all of the transports.
*
* @param cls unused
* @param tc scheduler context
*/
static void
refresh_hello_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GeneratorContext gc;
int friend_only;
hello_task = GNUNET_SCHEDULER_NO_TASK;
gc.addr_pos = oal_head;
gc.expiration = GNUNET_TIME_relative_to_absolute (hello_expiration);
friend_only = GNUNET_HELLO_is_friend_only (our_hello);
GNUNET_free (our_hello);
our_hello = GNUNET_HELLO_create (&GST_my_public_key, &address_generator, &gc, friend_only);
GNUNET_assert (NULL != our_hello);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Refreshed my %s `%s', new size is %d\n",
(GNUNET_YES == GNUNET_HELLO_is_friend_only (our_hello)) ? "friend-only" : "public",
"HELLO", GNUNET_HELLO_size (our_hello));
GNUNET_STATISTICS_update (GST_stats, gettext_noop ("# refreshed my HELLO"), 1,
GNUNET_NO);
if (NULL != hello_cb)
hello_cb (hello_cb_cls, GST_hello_get ());
GNUNET_PEERINFO_add_peer (GST_peerinfo, our_hello, NULL, NULL);
hello_task =
GNUNET_SCHEDULER_add_delayed (HELLO_REFRESH_PERIOD, &refresh_hello_task,
NULL);
}
static void
process_w_fo (void *cls, const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Message *hello, const char *err_msg)
{
if (err_msg != NULL )
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Error in communication with PEERINFO service\n"));
GNUNET_SCHEDULER_add_now (&done, NULL );
return;
}
if (NULL != peer)
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Received callback for peer `%s' %s HELLO\n", GNUNET_i2s (peer),
(NULL != hello) ? "with" : "without");
if (NULL == hello)
return;
if (GNUNET_NO == GNUNET_HELLO_is_friend_only (hello))
{
GNUNET_break(0);
return;
}
GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received %s HELLO for peer `%s'\n",
(GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ? "friend only" : "public",
GNUNET_i2s (peer));
if (0 == memcmp (&pid, peer, sizeof(pid)))
{
res_cb_w_fo = GNUNET_YES;
GNUNET_SCHEDULER_add_now (&done, NULL );
}
return;
}
}
/**
* Try to read the HELLOs in the given filename and discard expired
* addresses. Removes the file if one the HELLO is malformed. If all
* addresses are expired, the HELLO is also removed (but the HELLO
* with the public key is still returned if it was found and valid).
* The file can contain multiple HELLO messages.
*
* @param fn name of the file
* @param unlink_garbage if #GNUNET_YES, try to remove useless files
* @param r ReadHostFileContext to store the resutl
*/
static void
read_host_file (const char *fn,
int unlink_garbage,
struct ReadHostFileContext *r)
{
char buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1] GNUNET_ALIGN;
unsigned int size_total;
struct GNUNET_TIME_Absolute now;
unsigned int left;
const struct GNUNET_HELLO_Message *hello;
struct GNUNET_HELLO_Message *hello_clean;
unsigned read_pos;
int size_hello;
r->friend_only_hello = NULL;
r->hello = NULL;
if (GNUNET_YES != GNUNET_DISK_file_test (fn))
return;
size_total = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Read %u bytes from `%s'\n",
size_total,
fn);
if (size_total < sizeof (struct GNUNET_MessageHeader))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to parse HELLO in file `%s': %s\n"),
fn, "Fail has invalid size");
if ( (GNUNET_YES == unlink_garbage) &&
(0 != UNLINK (fn)) &&
(ENOENT != errno) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"unlink",
fn);
return;
}
read_pos = 0;
while (read_pos < size_total)
{
hello = (const struct GNUNET_HELLO_Message *) &buffer[read_pos];
size_hello = GNUNET_HELLO_size (hello);
if ( (0 == size_hello) ||
(size_total - read_pos < size_hello) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to parse HELLO in file `%s'\n"),
fn);
if (0 == read_pos)
{
if ((GNUNET_YES == unlink_garbage) &&
(0 != UNLINK (fn)) &&
(ENOENT != errno) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"unlink",
fn);
}
else
{
if ((GNUNET_YES == unlink_garbage) &&
(0 != TRUNCATE (fn, read_pos)) &&
(ENOENT != errno) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"truncate",
fn);
}
return;
}
now = GNUNET_TIME_absolute_get ();
hello_clean = GNUNET_HELLO_iterate_addresses (hello, GNUNET_YES,
&discard_expired, &now);
if (NULL == hello_clean)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to parse HELLO in file `%s'\n"),
fn);
if ((GNUNET_YES == unlink_garbage) &&
(0 != UNLINK (fn)) &&
(ENOENT != errno) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"unlink",
fn);
return;
}
left = 0;
(void) GNUNET_HELLO_iterate_addresses (hello_clean, GNUNET_NO,
&count_addresses, &left);
if (0 == left)
{
GNUNET_free (hello_clean);
break;
}
if (GNUNET_NO == GNUNET_HELLO_is_friend_only (hello_clean))
{
if (NULL == r->hello)
r->hello = hello_clean;
else
{
GNUNET_break (0);
GNUNET_free (r->hello);
r->hello = hello_clean;
}
}
else
{
if (NULL == r->friend_only_hello)
r->friend_only_hello = hello_clean;
else
{
GNUNET_break (0);
GNUNET_free (r->friend_only_hello);
r->friend_only_hello = hello_clean;
}
}
read_pos += size_hello;
}
if (0 == left)
{
/* no addresses left, remove from disk */
if ( (GNUNET_YES == unlink_garbage) &&
(0 != UNLINK (fn)) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"unlink",
fn);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Found `%s' and `%s' HELLO message in file\n",
(NULL != r->hello) ? "public" : "NON-public",
(NULL != r->friend_only_hello) ? "friend only" : "NO friend only");
}
