static void
process_hello (void *cls,
const struct GNUNET_MessageHeader *message)
{
struct PeerContext *p = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received (my) `%s' from transport service\n", "HELLO");
GNUNET_assert (message != NULL);
p->hello = GNUNET_copy_message (message);
if ((p == &p1) && (NULL == p2.oh))
p2.oh = GNUNET_TRANSPORT_offer_hello (p2.cfg,
message,
&offer_hello_done,
&p2);
if ((p == &p2) && (NULL == p1.oh))
p1.oh = GNUNET_TRANSPORT_offer_hello (p1.cfg,
message,
&offer_hello_done,
&p1);
if ((p == &p1) && (p2.hello != NULL) && (NULL == p1.oh) )
p1.oh = GNUNET_TRANSPORT_offer_hello (p1.cfg,
p2.hello,
&offer_hello_done,
&p1);
if ((p == &p2) && (p1.hello != NULL) && (NULL == p2.oh) )
p2.oh = GNUNET_TRANSPORT_offer_hello (p2.cfg,
p1.hello,
&offer_hello_done,
&p2);
}
static void
process_hello (void *cls, const struct GNUNET_MessageHeader *message)
{
struct PeerContext *p = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received (my) `%s' from transport service\n", "HELLO");
GNUNET_assert (message != NULL);
if ((p == &p1) && (p2.th != NULL))
GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
if ((p == &p2) && (p1.th != NULL))
GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
}
static void
try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ConnectingContext *cc = cls;
struct PeerContext *p1 = cc->p1;
struct PeerContext *p2 = cc->p2;
cc->tct = GNUNET_SCHEDULER_NO_TASK;
if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
return;
GNUNET_assert (cc != NULL);
GNUNET_assert (cc->p1 != NULL);
GNUNET_assert (cc->p2 != NULL);
char *p2_s = GNUNET_strdup (GNUNET_i2s (&p2->id));
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
"Asking peer %u (`%s') to connect peer %u (`%s'), providing HELLO with %u bytes\n",
p1->no, GNUNET_i2s (&p1->id), p2->no, p2_s,
GNUNET_HELLO_size (cc->p2->hello));
GNUNET_free (p2_s);
GNUNET_TRANSPORT_offer_hello (cc->th_p1,
(const struct GNUNET_MessageHeader *) cc->
p2->hello, NULL, NULL);
GNUNET_TRANSPORT_try_connect (cc->th_p1, &p2->id, NULL, NULL); /*FIXME TRY_CONNECT change */
cc->tct =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &try_connect, cc);
}
/**
* This function is called whenever an encrypted HELLO message is
* received.
*
* @param cls closure with the peer identity of the sender
* @param message the actual HELLO message
*/
static void
handle_hello (void *cls,
const struct GNUNET_HELLO_Message *message)
{
const struct GNUNET_PeerIdentity *other = cls;
struct Peer *peer;
struct GNUNET_PeerIdentity pid;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received encrypted HELLO from peer `%s'",
GNUNET_i2s (other));
GNUNET_assert (GNUNET_OK ==
GNUNET_HELLO_get_id (message,
&pid));
GNUNET_STATISTICS_update (stats,
gettext_noop ("# HELLO messages received"),
1,
GNUNET_NO);
peer = GNUNET_CONTAINER_multipeermap_get (peers,
&pid);
if (NULL == peer)
{
if ( (GNUNET_YES == friends_only) ||
(friend_count < minimum_friend_count) )
return;
}
else
{
if ( (GNUNET_YES != peer->is_friend) &&
(GNUNET_YES == friends_only) )
return;
if ((GNUNET_YES != peer->is_friend) &&
(friend_count < minimum_friend_count))
return;
}
if (NULL != oh)
GNUNET_TRANSPORT_offer_hello_cancel (oh);
oh = GNUNET_TRANSPORT_offer_hello (cfg,
&message->header,
&done_offer_hello,
NULL);
}
/**
* This function is called whenever an encrypted HELLO message is
* received.
*
* @param cls closure
* @param other the other peer involved (sender or receiver, NULL
* for loopback messages where we are both sender and receiver)
* @param message the actual HELLO message
* @param atsi performance data
* @param atsi_count number of records in 'atsi'
* @return GNUNET_OK to keep the connection open,
* GNUNET_SYSERR to close it (signal serious error)
*/
static int
handle_encrypted_hello (void *cls, const struct GNUNET_PeerIdentity *other,
const struct GNUNET_MessageHeader *message,
const struct GNUNET_ATS_Information *atsi,
unsigned int atsi_count)
{
struct Peer *peer;
struct GNUNET_PeerIdentity pid;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received encrypted `%s' from peer `%s'",
"HELLO", GNUNET_i2s (other));
if (GNUNET_OK !=
GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) message, &pid))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
GNUNET_STATISTICS_update (stats, gettext_noop ("# HELLO messages received"),
1, GNUNET_NO);
peer = GNUNET_CONTAINER_multihashmap_get (peers, &pid.hashPubKey);
if (NULL == peer)
{
if ((GNUNET_YES == friends_only) || (friend_count < minimum_friend_count))
return GNUNET_OK;
}
else
{
if ((GNUNET_YES != peer->is_friend) && (GNUNET_YES == friends_only))
return GNUNET_OK;
if ((GNUNET_YES != peer->is_friend) &&
(friend_count < minimum_friend_count))
return GNUNET_OK;
}
if (transport != NULL)
GNUNET_TRANSPORT_offer_hello (transport, message, NULL, NULL);
return GNUNET_OK;
}