/*
This file is part of GNUnet.
- (C) 2009-2014 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2014 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* hashing.
*/
-
-/**
- * FIXME: URGENT
- * We should have a message type like notify successor result. only when
- * this message is being recvied by the new successor. we should schedule
- * another round of verify successor.
- */
#define DEBUG(...) \
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
/**
* How long to wait before sending another find finger trail request
*/
-#define DHT_FIND_FINGER_TRAIL_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
+#define DHT_FIND_FINGER_TRAIL_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
+
+/**
+ * How long to wait before sending another verify successor message.
+ */
+#define DHT_SEND_VERIFY_SUCCESSOR_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
/**
* How long to wait before sending another verify successor message.
*/
-#define DHT_SEND_VERIFY_SUCCESSOR_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 60)
+#define DHT_SEND_VERIFY_SUCCESSOR_RETRY_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+/**
+ * How long to wait before retrying notify successor.
+ */
+#define DHT_SEND_NOTIFY_SUCCESSOR_RETRY_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
/**
* How long at most to wait for transmission of a request to a friend ?
*/
#define CONGESTION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
+/**
+ * In case we don't hear back from the current successor, then we can start
+ * verify successor.
+ */
+#define WAIT_NOTIFY_CONFIRMATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 200)
+
/**
* Maximum number of trails allowed to go through a friend.
*/
/**
* Maximum number of trails stored per finger.
*/
-#define MAXIMUM_TRAILS_PER_FINGER 1
+#define MAXIMUM_TRAILS_PER_FINGER 4
/**
* Finger map index for predecessor entry in finger table.
*/
#define PREDECESSOR_FINGER_ID 64
-/**
- * Wrap around in peer identity circle.
- */
-#define PEER_IDENTITES_WRAP_AROUND pow(2, 64) - 1
-
/**
* FIXME: Its use only at 3 places check if you can remove it.
* To check if a finger is predecessor or not.
*/
};
+/**
+ * P2P Notify Successor Confirmation message.
+ */
+struct PeerNotifyConfirmationMessage
+{
+ /**
+ * Type: #GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_TEARDOWN
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Unique identifier of the trail.
+ */
+ struct GNUNET_HashCode trail_id;
+
+ /**
+ * Direction of trail.
+ */
+ uint32_t trail_direction;
+};
+
/**
* P2P Trail Tear Down message.
*/
};
+
GNUNET_NETWORK_STRUCT_END
/**
*/
struct GNUNET_TIME_Absolute congestion_timestamp;
-
+
// TODO : Change name of head and tail to pending_messages_list_head and so.
/**
* Head of pending messages to be sent to this friend.
*/
struct GNUNET_PeerIdentity finger_identity;
+ /**
+ * In case not 0, this amount is time to wait for notify successor message.
+ * Used ONLY for successor. NOT for any other finger.
+ */
+ struct GNUNET_TIME_Absolute wait_notify_confirmation;
+
/**
* Is any finger stored at this finger index.
*/
* to reach to it. In other case, same as best_known_destination.
*/
struct GNUNET_PeerIdentity next_hop;
-
+
/**
* In case finger is the next hop, it contains a valid finger table index
* at which the finger is stored. Else, It contains 65, which is out of range
- * of finger table index.
+ * of finger table index.
*/
unsigned int finger_table_index;
};
+/**
+ * Context for send_verify_successor_task.
+ */
+struct VerifySuccessorContext
+{
+ /**
+ * Number of times this has been scheduled.
+ */
+ unsigned int num_retries_scheduled;
+};
/**
* Task that sends FIND FINGER TRAIL requests. This task is started when we have
* get our first friend.
*/
-static GNUNET_SCHEDULER_TaskIdentifier find_finger_trail_task;
+static struct GNUNET_SCHEDULER_Task * find_finger_trail_task;
+
+/**
+ * Task that sends verify successor message. This task is started when we get
+ * our successor for the first time.
+ */
+static struct GNUNET_SCHEDULER_Task * send_verify_successor_task;
+
+/**
+ * Task that sends verify successor message. This task is started when we get
+ * our successor for the first time.
+ */
+static struct GNUNET_SCHEDULER_Task * send_verify_successor_retry_task;
/**
* Task that sends verify successor message. This task is started when we get
* our successor for the first time.
*/
-static GNUNET_SCHEDULER_TaskIdentifier send_verify_successor_task;
+static struct GNUNET_SCHEDULER_Task * send_notify_new_successor_retry_task;
/**
* Identity of this peer.
*/
static unsigned int current_search_finger_index;
+/**
+ * Time duration to schedule find finger trail task.
+ */
+static struct GNUNET_TIME_Relative find_finger_trail_task_next_send_time;
+
+/**
+ * Time duration to schedule verify successor task.
+ */
+static struct GNUNET_TIME_Relative verify_successor_next_send_time;
+
+/**
+ * Time duration to send verify successor again, if result was not received in time.
+ */
+static struct GNUNET_TIME_Relative verify_successor_retry_time;
+
+/**
+ * Time duration to retry send_notify_successor.
+ */
+static struct GNUNET_TIME_Relative notify_successor_retry_time;
+
+/**
+ * Are we waiting for confirmation from our new successor that it got the
+ * message
+ */
+//static unsigned int waiting_for_notify_confirmation;
+
+/* Below variables are used only for testing, and statistics collection. */
/**
* Should we store our topology predecessor and successor IDs into statistics?
*/
unsigned int track_topology;
/**
- * Should I be a malicious peer and drop the PUT/GET packets?
+ * Should I be a malicious peer and drop the PUT/GET packets?
* if 0 then NOT malicious.
*/
unsigned int act_malicious;
/**
- * Time duration to schedule find finger trail task.
+ * Count of fingers found. Ideally we should have O(logn) fingers for a
+ * stable network.
*/
-static struct GNUNET_TIME_Relative find_finger_trail_task_next_send_time;
+static unsigned int total_fingers_found;
/**
- * Time duration to schedule verify successor task.
+ * Number of times we found the same successor.
*/
-static struct GNUNET_TIME_Relative verify_successor_next_send_time;
+static unsigned int successor_times;
+/**
+ * Number of rounds for which we should search for finger.
+ */
+static unsigned int fingers_round_count;
/**
* Called when core is ready to send a message we asked for
* out to the destination.
size_t msize;
peer->th = NULL;
- while ((NULL != (pending = peer->head)) &&
- (0 == GNUNET_TIME_absolute_get_remaining (pending->timeout).rel_value_us))
+ while ( (NULL != (pending = peer->head)) &&
+ (0 == GNUNET_TIME_absolute_get_remaining (pending->timeout).rel_value_us) )
{
+ GNUNET_STATISTICS_update (GDS_stats,
+ gettext_noop
+ ("# Messages dropped (CORE timeout)"),
+ 1,
+ GNUNET_NO);
peer->pending_count--;
- GNUNET_CONTAINER_DLL_remove (peer->head, peer->tail, pending);
+ GNUNET_CONTAINER_DLL_remove (peer->head,
+ peer->tail,
+ pending);
GNUNET_free (pending);
}
if (NULL == pending)
{
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
- ("# Bytes transmitted to other peers"), msize,
+ ("# Bytes transmitted to other peers"),
+ msize,
GNUNET_NO);
memcpy (&cbuf[off], pending->msg, msize);
off += msize;
{
return;
}
-
+
peer->th =
GNUNET_CORE_notify_transmit_ready (core_api, GNUNET_NO,
pending->importance,
* Set the ENABLE_MALICIOUS value to malicious.
* @param malicious
*/
-void
+int
GDS_NEIGHBOURS_act_malicious (unsigned int malicious)
{
act_malicious = malicious;
+ return GNUNET_OK;
}
#endif
pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
pending->importance = 0;
- pending->timeout = GNUNET_TIME_relative_to_absolute (PENDING_MESSAGE_TIMEOUT);
+ pending->timeout = GNUNET_TIME_relative_to_absolute (PENDING_MESSAGE_TIMEOUT);
tsrm = (struct PeerTrailSetupResultMessage *) &pending[1];
pending->msg = &tsrm->header;
tsrm->header.size = htons (msize);
GNUNET_htonll (ultimate_destination_finger_value);
peer_list = (struct GNUNET_PeerIdentity *) &tsrm[1];
memcpy (peer_list, trail_peer_list, trail_length * sizeof (struct GNUNET_PeerIdentity));
-
+
+ /* Send the message to chosen friend. */
+ GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail, pending);
+ target_friend->pending_count++;
+ process_friend_queue (target_friend);
+}
+
+/**
+ * Send notify successor confirmation message.
+ * @param trail_id Unique Identifier of the trail.
+ * @param trail_direction Destination to Source.
+ * @param target_friend Friend to get this message next.
+ */
+void
+GDS_NEIGHBOURS_send_notify_succcessor_confirmation (struct GNUNET_HashCode trail_id,
+ unsigned int trail_direction,
+ struct FriendInfo *target_friend)
+{
+ struct PeerNotifyConfirmationMessage *ncm;
+ struct P2PPendingMessage *pending;
+ size_t msize;
+
+ msize = sizeof (struct PeerNotifyConfirmationMessage);
+ if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
+ {
+ GNUNET_break (0);
+ return;
+ }
+
+ if (target_friend->pending_count >= MAXIMUM_PENDING_PER_FRIEND)
+ {
+ GNUNET_STATISTICS_update (GDS_stats, gettext_noop ("# P2P messages dropped due to full queue"),
+ 1, GNUNET_NO);
+ }
+
+ pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
+ pending->importance = 0; /* FIXME */
+ pending->timeout = GNUNET_TIME_relative_to_absolute (PENDING_MESSAGE_TIMEOUT);
+ ncm = (struct PeerNotifyConfirmationMessage *) &pending[1];
+ pending->msg = &ncm->header;
+ ncm->header.size = htons (msize);
+ ncm->header.type = htons (GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_SUCCESSOR_CONFIRMATION);
+ ncm->trail_id = trail_id;
+ ncm->trail_direction = htonl (trail_direction);
+
/* Send the message to chosen friend. */
GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail, pending);
target_friend->pending_count++;
msize = sizeof (struct PeerVerifySuccessorMessage) +
(trail_length * sizeof (struct GNUNET_PeerIdentity));
-
+
if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
{
GNUNET_break (0);
* the pointer to friend in routing table rather than gnunet_peeridentity.
* if yes then we should keep friend info in.h andmake lot of changes.
* Construct a trail teardown message and forward it to target friend.
+ *
* @param trail_id Unique identifier of the trail.
* @param trail_direction Direction of trail.
* @param target_friend Friend to get this message.
*/
void
-GDS_NEIGHBOURS_send_trail_teardown (struct GNUNET_HashCode trail_id,
+GDS_NEIGHBOURS_send_trail_teardown (const struct GNUNET_HashCode *trail_id,
unsigned int trail_direction,
- struct GNUNET_PeerIdentity peer)
+ const struct GNUNET_PeerIdentity *peer)
{
struct PeerTrailTearDownMessage *ttdm;
struct P2PPendingMessage *pending;
size_t msize;
msize = sizeof (struct PeerTrailTearDownMessage);
-
if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
{
GNUNET_break (0);
return;
}
- /*FIXME:In what case friend can be null. ?*/
if (NULL == (target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap, &peer)));
- return;
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap, peer)))
+ {
+ /* FIXME: In what case friend can be null. ?*/
+ GNUNET_break (0);
+ return;
+ }
if (target_friend->pending_count >= MAXIMUM_PENDING_PER_FRIEND)
{
pending->msg = &ttdm->header;
ttdm->header.size = htons (msize);
ttdm->header.type = htons (GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_TEARDOWN);
- ttdm->trail_id = trail_id;
+ ttdm->trail_id = *trail_id;
ttdm->trail_direction = htonl (trail_direction);
/* Send the message to chosen friend. */
vsmr->current_successor = current_successor;
vsmr->probable_successor = probable_successor;
vsmr->trail_direction = htonl (trail_direction);
- vsmr->trail_id = trail_id;
+ vsmr->trail_id = trail_id;
peer_list = (struct GNUNET_PeerIdentity *) &vsmr[1];
memcpy (peer_list, trail, trail_length * sizeof (struct GNUNET_PeerIdentity));
-
+
/* Send the message to chosen friend. */
GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail, pending);
target_friend->pending_count++;
GNUNET_STATISTICS_update (GDS_stats, gettext_noop ("# P2P messages dropped due to full queue"),
1, GNUNET_NO);
}
-
+
pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
pending->importance = 0; /* FIXME */
pending->timeout = GNUNET_TIME_relative_to_absolute (PENDING_MESSAGE_TIMEOUT);
peer_list = (struct GNUNET_PeerIdentity *) &nsm[1];
memcpy (peer_list, successor_trail,
successor_trail_length * sizeof (struct GNUNET_PeerIdentity));
-
+
/* Send the message to chosen friend. */
GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail, pending);
target_friend->pending_count++;
adm->trail_id = trail_id;
peer_list = (struct GNUNET_PeerIdentity *)&adm[1];
memcpy (peer_list, trail, sizeof (struct GNUNET_PeerIdentity) * trail_length);
-
+
/* Send the message to chosen friend. */
GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail, pending);
target_friend->pending_count++;
int i;
int index_seen = trail_length + 1;
int flag = 0;
-
+
for (i = 0; i < trail_length; i++)
{
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &trail[i]))
* @param value Value to be compare
* @return Closest peer
*/
-static struct GNUNET_PeerIdentity
+static struct GNUNET_PeerIdentity
select_closest_finger (const struct GNUNET_PeerIdentity *peer1,
const struct GNUNET_PeerIdentity *peer2,
uint64_t value)
peer1_value = GNUNET_ntohll (peer1_value);
peer2_value = GNUNET_ntohll (peer2_value);
- // TODO: Can use a simpler (to understand) idea here!
if (peer1_value == value)
{
return *peer1;
return *peer2;
}
- if (peer2_value < peer1_value)
+ if (value < peer1_value && peer1_value < peer2_value)
{
- if ((peer2_value < value) && (value < peer1_value))
- {
- return *peer1;
- }
- else if (((peer1_value < value) && (value < PEER_IDENTITES_WRAP_AROUND)) ||
- ((0 < value) && (value < peer2_value)))
- {
- return *peer2;
- }
+ return *peer1;
+ }
+ else if (value < peer2_value && peer2_value < peer1_value)
+ {
+ return *peer2;
+ }
+ else if (peer1_value < value && value < peer2_value)
+ {
+ return *peer2;
+ }
+ else if (peer2_value < value && value < peer1_value)
+ {
+ return *peer1;
+ }
+ else if (peer1_value < peer2_value && peer2_value < value)
+ {
+ return *peer1;
+ }
+ else // if (peer2_value < peer1_value && peer1_value < value)
+ {
+ return *peer2;
}
-
- //if (peer1_value < peer2_value)
- //{
- if ((peer1_value < value) && (value < peer2_value))
- {
- return *peer2;
- }
- //else if (((peer2_value < value) && (value < PEER_IDENTITES_WRAP_AROUND)) ||
- // ((0 < value) && (value < peer1_value)))
- //{
- return *peer1;
- //}
- // }
}
* @param value Value to be compare
* @return Peer which precedes value in the network.
*/
-static struct GNUNET_PeerIdentity
+static struct GNUNET_PeerIdentity
select_closest_predecessor (const struct GNUNET_PeerIdentity *peer1,
const struct GNUNET_PeerIdentity *peer2,
uint64_t value)
peer1_value = GNUNET_ntohll (peer1_value);
peer2_value = GNUNET_ntohll (peer2_value);
- if (peer1_value == value)
+ if (peer1_value == value)
+ {
return *peer1;
+ }
if (peer2_value == value)
+ {
return *peer2;
+ }
- if (peer1_value < peer2_value)
+ if (value < peer1_value && peer1_value < peer2_value)
{
- if ((peer1_value < value) && (value < peer2_value))
- {
- return *peer1;
- }
- else if (((peer2_value < value) && (value < PEER_IDENTITES_WRAP_AROUND)) ||
- ((PEER_IDENTITES_WRAP_AROUND > value) && (value < peer1_value)))
- {
- return *peer2;
- }
+ return *peer2;
+ }
+ else if (value < peer2_value && peer2_value < peer1_value)
+ {
+ return *peer1;
+ }
+ else if (peer1_value < value && value < peer2_value)
+ {
+ return *peer1;
+ }
+ else if (peer2_value < value && value < peer1_value)
+ {
+ return *peer2;
+ }
+ else if (peer1_value < peer2_value && peer2_value < value)
+ {
+ return *peer2;
+ }
+ else // if (peer2_value < peer1_value && peer1_value < value)
+ {
+ return *peer1;
}
-
- // if (peer2_value < peer1_value)
- //{
- if ((peer2_value < value) && (value < peer1_value))
- {
- return *peer2;
- }
- //else if (((peer1_value < value) && (value < PEER_IDENTITES_WRAP_AROUND)) ||
- // ((PEER_IDENTITES_WRAP_AROUND > value) && (value < peer2_value)))
- //{
- return *peer1;
- //}
- // }
}
-
+#if 0
/**
- *
+ *
*
*/
void
{
struct GNUNET_PeerIdentity print_peer;
int i;
-
+
FPRINTF (stderr,_("\nSUPU %s, %s, %d,trail_length = %d"),
__FILE__, __func__,__LINE__,trail_length);
for (i =0 ; i< trail_length; i++)
__FILE__, __func__,__LINE__,i,GNUNET_i2s(&print_peer));
}
}
-
+#endif
#if 0
/**
* @param is_predecessor Is value a predecessor or any other finger.
* @return Closest peer among two peers.
*/
-static struct GNUNET_PeerIdentity
+static struct GNUNET_PeerIdentity
select_closest_peer (const struct GNUNET_PeerIdentity *peer1,
const struct GNUNET_PeerIdentity *peer2,
uint64_t value,
* to Finger, choose the one with shortest trail length.
* Note: We use length as parameter. But we can use any other suitable parameter
* also.
- * @param finger Finger
- * @return Trail
+ * @param finger Finger Finger whose trail we have to select.
+ * @return Trail Selected Trail.
*/
static struct Trail *
select_finger_trail (struct FingerInfo *finger)
unsigned int i;
GNUNET_assert (finger->trails_count > 0);
-
for (i = 0; i < finger->trails_count; i++)
{
current_finger_trail = &finger->trail_list[i];
if (GNUNET_NO == current_finger_trail->is_present)
continue;
- /* SUPUS: I am not changing anything here. as i assume that in case we have
- a finger which is friend and we have trail length = 0, then it will
- be the first friend to which we send the request. As I have removed
- the condition in trail setup where we check for source is a friend. */
GNUNET_assert (NULL !=
(friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap,
if (GNUNET_YES == is_friend_congested (friend))
continue;
- if (NULL == best_trail ||
+ if (NULL == best_trail ||
best_trail->trail_length > current_finger_trail->trail_length)
{
best_trail = current_finger_trail;
if (GNUNET_NO == finger->is_present)
continue;
- /* SUPUS: As we have friend stored as finger also, it may happen that
- * friend corresponding to this finger has been chosen as the best
- * known destination, then just move to next element. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&finger->finger_identity,
¤t_closest_peer->best_known_destination))
continue;
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&finger->finger_identity,
&my_identity))
continue;
-
- /* If finger is a friend, then do nothing. As we have already checked
- * for each friend in compare_friend_and_current_successor().
- * SUPUS: Here we have all the friends in the friend table. So even if
- * that friend is a finger, we have checked it with trail length = 0.
- * So its okay. No need to change anything here. Note: finger may have
- * trail length > 0 but its okay. */
+
+ /* If finger is a friend, we have already checked it in previous function. */
if (NULL != (GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&finger->finger_identity)))
{
current_closest_peer->destination_finger_value,
current_closest_peer->is_predecessor);
- /* SUPUS: Ideally if finger is a friend, but with trail length > 0, then
- also we have already handled the case in above condition. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity(&finger->finger_identity, &closest_peer))
{
/* Choose one of the trail to reach to finger. */
* @return Updated closest_peer
*/
static struct Closest_Peer
-init_current_successor (struct GNUNET_PeerIdentity my_identity,
+init_closest_peer (struct GNUNET_PeerIdentity my_identity,
uint64_t destination_finger_value,
unsigned int is_predecessor)
{
current_closest_peer.is_predecessor = is_predecessor;
current_closest_peer.next_hop = my_identity;
current_closest_peer.best_known_destination = my_identity;
- current_closest_peer.finger_table_index = 65; //65 is a for non valid finger table index.
+ current_closest_peer.finger_table_index = 65; //65 is a for non valid finger table index.
return current_closest_peer;
}
/**
- * FIXME: at the moment, there is not 100% get and put in case of non-malicious
- * peer. It could be because of the logic we wrote here. Verify if its correct.
- * If not then return immediate_successor.
+ * Find locally best known peer, among your own identity, friend and finger list,
+ * which is closest to given destination_finger_value.
*
- * Find the successor for destination_finger_value among my_identity, my
- * friends and my fingers. Don't consider friends or fingers which are either
- * congested or have crossed the threshold.
* NOTE: In case a friend is also a finger, then it is always chosen as friend
* not a finger.
- * @param destination_finger_value Peer closest to this value will be the next successor.
+ * @param destination_finger_value Peer closest to this value will be the next destination.
* @param is_predecessor Are we looking for predecessor or finger?
- * @return Successor It is never NULL, in case none of friend or finger is closest,
- * then we return my_identity.
+ * @return Closest_Peer that contains all the relevant field to reach to
+ * @a destination_finger_value
*/
static struct Closest_Peer
-find_successor (uint64_t destination_finger_value,
- unsigned int is_predecessor)
+find_local_best_known_next_hop (uint64_t destination_finger_value,
+ unsigned int is_predecessor)
{
struct Closest_Peer current_closest_peer;
/* Initialize current_successor to my_identity. */
- current_closest_peer = init_current_successor (my_identity,
- destination_finger_value,
- is_predecessor);
+ current_closest_peer = init_closest_peer (my_identity,
+ destination_finger_value,
+ is_predecessor);
/* Compare each friend entry with current_successor and update current_successor
* with friend if its closest. */
return current_closest_peer;
}
+
/**
- * FIXME; Send put message across all the trail to reach to next hop to handle
- * malicious peers.
* Construct a Put message and send it to target_peer.
* @param key Key for the content
* @param block_type Type of the block
struct FriendInfo *target_friend;
struct GNUNET_PeerIdentity *pp;
size_t msize;
-
+
msize = put_path_length * sizeof (struct GNUNET_PeerIdentity) + data_size +
sizeof (struct PeerPutMessage);
if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
msize = data_size + sizeof (struct PeerPutMessage);
}
- /* Should it be GNUNET_SERVER_MAX_MESSAGE_SIZE? */
if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
{
DEBUG("msize = %lu\n",msize);
GNUNET_break (0);
return;
}
-
+
GNUNET_assert (NULL !=
(target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap, target_peer)));
/**
- * Handle the put request from the client.
+ * Handle the put request from the client.
* @param key Key for the content
* @param block_type Type of the block
* @param options Routing options
struct GNUNET_PeerIdentity next_hop;
uint64_t key_value;
struct Closest_Peer successor;
-
+
memcpy (&key_value, key, sizeof (uint64_t));
key_value = GNUNET_ntohll (key_value);
- successor = find_successor (key_value, GDS_FINGER_TYPE_NON_PREDECESSOR);
+ successor = find_local_best_known_next_hop (key_value,
+ GDS_FINGER_TYPE_NON_PREDECESSOR);
best_known_dest = successor.best_known_destination;
next_hop = successor.next_hop;
intermediate_trail_id = successor.trail_id;
- DEBUG("PUT_REQUEST_RECEVIED KEY = %s \n",GNUNET_h2s(key));
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&best_known_dest, &my_identity))
{
+ DEBUG("\n PUT_REQUEST_SUCCESSFUL for key = %s",GNUNET_h2s(key));
/* I am the destination. */
GDS_DATACACHE_handle_put (expiration_time, key, 0, NULL,
block_type,data_size,data);
GDS_CLIENTS_process_put (options, block_type, 0,
ntohl (desired_replication_level),
- 1, &my_identity, expiration_time, //FIXME: GNUNETnthoh something on expiration time.
+ 1, &my_identity, expiration_time, //FIXME: GNUNETnthoh something on expiration time.
key, data, data_size);
return;
}
-
/* In case we are sending the request to a finger, then send across all of its
trail.*/
-#if 0
+#if ENABLE_MALICIOUS
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination,
&successor.next_hop))
{
struct FingerInfo *next_hop_finger;
unsigned int i;
-
+
next_hop_finger = &finger_table[successor.finger_table_index];
for (i = 0; i < next_hop_finger->trails_count; i++)
{
if (GNUNET_YES == next_hop_finger->trail_list[i].is_present)
{
+ if(0 == next_hop_finger->trail_list[i].trail_length)
+ {
+ GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level,
+ best_known_dest, intermediate_trail_id, &next_hop,
+ 0, 1, &my_identity, expiration_time,
+ data, data_size);
+ return;
+ }
+ next_hop = next_hop_finger->trail_list[i].trail_head->peer;
GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level,
- best_known_dest,
- next_hop_finger->trail_list[i].trail_id,
- &next_hop, hop_count, put_path_length, put_path,
+ best_known_dest,
+ next_hop_finger->trail_list[i].trail_id,
+ &next_hop, 0, 1, &my_identity,
expiration_time,
data, data_size);
}
}
+ return;
}
- else
#endif
- GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level,
- best_known_dest, intermediate_trail_id, &next_hop,
- 0, 1, &my_identity, expiration_time,
- data, data_size);
+ GDS_NEIGHBOURS_send_put (key, block_type, options, desired_replication_level,
+ best_known_dest, intermediate_trail_id, &next_hop,
+ 0, 1, &my_identity, expiration_time,
+ data, data_size);
}
/**
- * FIXME; Send get message across all the trail to reach to next hop to handle
- * malicious peers.
* Construct a Get message and send it to target_peer.
* @param key Key for the content
* @param block_type Type of the block
}
GNUNET_assert (NULL !=
(target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap, target_peer)));
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap, target_peer)));
pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
pending->timeout = GNUNET_TIME_relative_to_absolute (PENDING_MESSAGE_TIMEOUT);
/**
- * Handle the get request from the client file. If I am destination do
+ * Handle the get request from the client file. If I am destination do
* datacache put and return. Else find the target friend and forward message
- * to it.
+ * to it.
* @param key Key for the content
* @param block_type Type of the block
* @param options Routing options
* @param desired_replication_level Desired replication count
*/
-void
+void
GDS_NEIGHBOURS_handle_get(const struct GNUNET_HashCode *key,
enum GNUNET_BLOCK_Type block_type,
enum GNUNET_DHT_RouteOption options,
struct GNUNET_PeerIdentity best_known_dest;
struct GNUNET_HashCode intermediate_trail_id;
uint64_t key_value;
-
+
memcpy (&key_value, key, sizeof (uint64_t));
key_value = GNUNET_ntohll (key_value);
- successor = find_successor (key_value, GDS_FINGER_TYPE_NON_PREDECESSOR);
-
+ successor = find_local_best_known_next_hop (key_value,
+ GDS_FINGER_TYPE_NON_PREDECESSOR);
+
best_known_dest = successor.best_known_destination;
intermediate_trail_id = successor.trail_id;
-
- DEBUG("GET_REQUEST_RECEVIED KEY = %s \n",GNUNET_h2s(key));
+
/* I am the destination. I have the data. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
&best_known_dest))
NULL, 0, 1, &my_identity, NULL,&my_identity);
return;
}
-
- /* fixme; for multiple trails, we need to send back finger index and send trail
- across all the fingers. but in current implementation we don't have this case.
- compare finger and current_successor returns, */
+
+#if ENABLE_MALICIOUS
+ struct GNUNET_PeerIdentity next_hop;
+ if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination,
+ &successor.next_hop))
+ {
+ struct FingerInfo *next_hop_finger;
+ unsigned int i;
+
+ next_hop_finger = &finger_table[successor.finger_table_index];
+ for (i = 0; i < next_hop_finger->trails_count; i++)
+ {
+ if (GNUNET_YES == next_hop_finger->trail_list[i].is_present)
+ {
+ if(0 == next_hop_finger->trail_list[i].trail_length)
+ {
+ GDS_NEIGHBOURS_send_get (key, block_type, options,
+ desired_replication_level,
+ best_known_dest,intermediate_trail_id,
+ &successor.next_hop,
+ 0, 1, &my_identity);
+ return;
+ }
+ next_hop = next_hop_finger->trail_list[i].trail_head->peer;
+ GDS_NEIGHBOURS_send_get (key, block_type, options, desired_replication_level,
+ best_known_dest,
+ next_hop_finger->trail_list[i].trail_id,
+ &next_hop, 0, 1, &my_identity);
+ }
+ }
+ return;
+ }
+#endif
GDS_NEIGHBOURS_send_get (key, block_type, options, desired_replication_level,
best_known_dest,intermediate_trail_id, &successor.next_hop,
0, 1, &my_identity);
/**
* Send the get result to requesting client.
+ *
* @param key Key of the requested data.
* @param type Block type
* @param target_peer Next peer to forward the message to.
if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
{
put_path_length = 0;
- msize = msize - put_path_length;
- return;
+ msize = msize - put_path_length * sizeof (struct GNUNET_PeerIdentity);
}
if (msize >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
for (j = 0; j < index ; j++)
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL, NULL));
-
+
do
{
/* Reset the index in friend peermap to 0 as we reached to the end. */
struct GNUNET_HashCode intermediate_trail_id;
unsigned int is_predecessor = 0;
uint64_t finger_id_value;
-
- /* Schedule another send_find_finger_trail_message task. When we have seen
- * one round of fingers, then this time is exponentially backoff to reduce
- * traffic caused by this task. */
+
+ /* Schedule another send_find_finger_trail_message task. After one round of
+ * finger search, this time is exponentially backoff. */
find_finger_trail_task_next_send_time.rel_value_us =
find_finger_trail_task_next_send_time.rel_value_us +
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
&send_find_finger_trail_message,
NULL);
- /* No space in my routing table. (Source and destination peers also store entries
+ /* No space in my routing table. (Source and destination peers also store entries
* in their routing table). */
if (GNUNET_YES == GDS_ROUTING_threshold_reached())
return;
finger_id_value = compute_finger_identity_value (current_search_finger_index);
if (PREDECESSOR_FINGER_ID == current_search_finger_index)
is_predecessor = 1;
-
+
/* Generate a unique trail id for trail we are trying to setup. */
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG,
&trail_id, sizeof (trail_id));
* 2. if the new trail is completely disjoint than the
* other trails, then may be choosing it is better.
*
- * @param finger Finger
+ * @param finger Finger
* @param new_finger_trail List of peers to reach from me to @a finger, NOT
- * including the endpoints.
+ * including the endpoints.
* @param new_finger_trail_length Total number of peers in @a new_finger_trail
* @param new_finger_trail_id Unique identifier of @a new_finger_trail.
*/
unsigned int new_trail_length,
struct GNUNET_HashCode new_trail_id)
{
- struct Trail *trail;
+ struct Trail *current_trail;
unsigned int largest_trail_length;
unsigned int largest_trail_index;
struct Trail_Element *trail_element;
+ struct GNUNET_PeerIdentity *next_hop;
unsigned int i;
largest_trail_length = new_trail_length;
for (i = 0; i < finger->trails_count; i++)
{
- trail = &finger->trail_list[i];
- if (trail->trail_length > largest_trail_length)
+ current_trail = &finger->trail_list[i];
+ GNUNET_assert (GNUNET_YES == current_trail->is_present);
+ if (current_trail->trail_length > largest_trail_length)
{
- largest_trail_length = trail->trail_length;
+ largest_trail_length = current_trail->trail_length;
largest_trail_index = i;
}
}
/* New trail is not better than existing ones. Send trail teardown. */
if (largest_trail_index == (MAXIMUM_TRAILS_PER_FINGER + 1))
{
- struct GNUNET_PeerIdentity next_hop;
-
- memcpy (&next_hop, &new_trail[0], sizeof(struct GNUNET_PeerIdentity));
+ next_hop = GDS_ROUTING_get_next_hop (new_trail_id, GDS_ROUTING_SRC_TO_DEST);
GDS_ROUTING_remove_trail (new_trail_id);
- GDS_NEIGHBOURS_send_trail_teardown (new_trail_id,
+ GDS_NEIGHBOURS_send_trail_teardown (&new_trail_id,
GDS_ROUTING_SRC_TO_DEST,
next_hop);
return;
/* Send trail teardown message across the replaced trail. */
struct Trail *replace_trail = &finger->trail_list[largest_trail_index];
-
+ next_hop = GDS_ROUTING_get_next_hop (replace_trail->trail_id, GDS_ROUTING_SRC_TO_DEST);
GNUNET_assert (GNUNET_YES == GDS_ROUTING_remove_trail (replace_trail->trail_id));
- GDS_NEIGHBOURS_send_trail_teardown (replace_trail->trail_id,
+ GDS_NEIGHBOURS_send_trail_teardown (&replace_trail->trail_id,
GDS_ROUTING_SRC_TO_DEST,
- replace_trail->trail_head->peer);
+ next_hop);
+
/* Free the trail. */
while (NULL != (trail_element = replace_trail->trail_head))
{
replace_trail->is_present = GNUNET_YES;
replace_trail->trail_length = new_trail_length;
replace_trail->trail_id = new_trail_id;
-
+
for (i = 0; i < new_trail_length; i++)
{
struct Trail_Element *element = GNUNET_new (struct Trail_Element);
const struct GNUNET_PeerIdentity *new_trail,
unsigned int trail_length)
{
- struct Trail *trail;
+ struct Trail *current_trail;
struct Trail_Element *trail_element;
int i;
int j;
-
+
GNUNET_assert (existing_finger->trails_count > 0);
/* Iterate over list of trails. */
for (i = 0; i < existing_finger->trails_count; i++)
{
- trail = &(existing_finger->trail_list[i]);
- GNUNET_assert (GNUNET_YES == trail->is_present);
+ current_trail = &(existing_finger->trail_list[i]);
+ if(GNUNET_NO == current_trail->is_present)
+ continue;
/* New trail and existing trail length are not same. */
- if (trail->trail_length != trail_length)
+ if (current_trail->trail_length != trail_length)
{
return GNUNET_YES;
}
- trail_element = trail->trail_head;
- GNUNET_assert (trail_element != NULL);
- for (j = 0; j < trail->trail_length; j++)
+ trail_element = current_trail->trail_head;
+ for (j = 0; j < current_trail->trail_length; j++)
{
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&new_trail[j],
&trail_element->peer))
return GNUNET_NO;
}
-
-/**
+/**
* FIXME; In case of multiple trails, we may have a case where a trail from in
* between has been removed, then we should try to find a free slot , not simply
- * add a trail at then end of the list.
- * Add a new trail to existing finger. This function is called only when finger
- * is not my own identity or a friend.
+ * add a trail at then end of the list.
+ * Add a new trail at a free slot in trail array of existing finger.
* @param existing_finger Finger
* @param new_finger_trail New trail from me to finger, NOT including endpoints
* @param new_finger_trail_length Total number of peers in @a new_finger_trail
unsigned int new_trail_length,
struct GNUNET_HashCode new_trail_id)
{
+ struct FriendInfo *friend;
struct Trail *trail;
- struct FriendInfo *first_friend;
- int i;
- int index;
-
+ unsigned int i;
+ int free_slot = -1;
+
if (GNUNET_NO == is_new_trail_unique (existing_finger, new_trail,
new_trail_length))
- {
return;
- }
-
- index = existing_finger->trails_count;
- trail = &existing_finger->trail_list[index];
- GNUNET_assert (GNUNET_NO == trail->is_present);
- trail->trail_id = new_trail_id;
- trail->trail_length = new_trail_length;
- existing_finger->trails_count++;
- trail->is_present = GNUNET_YES;
+
+ for (i = 0; i < existing_finger->trails_count; i++)
+ {
+ if (GNUNET_NO == existing_finger->trail_list[i].is_present)
+ {
+ free_slot = i;
+ break;
+ }
+ }
+
+ if (-1 == free_slot)
+ free_slot = i;
+
+ trail = &existing_finger->trail_list[free_slot];
+ GNUNET_assert (GNUNET_NO == trail->is_present);
+ trail->trail_id = new_trail_id;
+ trail->trail_length = new_trail_length;
+ existing_finger->trails_count++;
+ trail->is_present = GNUNET_YES;
+ if (0 == new_trail_length)
+ {
+ friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
+ &existing_finger->finger_identity);
+ }
+ else
+ {
+ friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
+ &new_trail[0]);
+ }
+ GNUNET_assert (NULL != friend);
+ friend->trails_count++;
+ for (i = 0; i < new_trail_length; i++)
+ {
+ struct Trail_Element *element;
+
+ element = GNUNET_new (struct Trail_Element);
+ element->peer = new_trail[i];
+ GNUNET_CONTAINER_DLL_insert_tail (trail->trail_head,
+ trail->trail_tail,
+ element);
+ }
+
+ existing_finger->trail_list[free_slot].trail_head = trail->trail_head;
+ existing_finger->trail_list[free_slot].trail_tail = trail->trail_tail;
+ existing_finger->trail_list[free_slot].trail_length = new_trail_length;
+ existing_finger->trail_list[free_slot].trail_id = new_trail_id;
+ existing_finger->trail_list[free_slot].is_present = GNUNET_YES;
+}
+
+
+#if 0
+/**
+ * FIXME; In case of multiple trails, we may have a case where a trail from in
+ * between has been removed, then we should try to find a free slot , not simply
+ * add a trail at then end of the list.
+ * Add a new trail at a free slot in trail array of existing finger.
+ * @param existing_finger Finger
+ * @param new_finger_trail New trail from me to finger, NOT including endpoints
+ * @param new_finger_trail_length Total number of peers in @a new_finger_trail
+ * @param new_finger_trail_id Unique identifier of the trail.
+ */
+static void
+add_new_trail (struct FingerInfo *existing_finger,
+ const struct GNUNET_PeerIdentity *new_trail,
+ unsigned int new_trail_length,
+ struct GNUNET_HashCode new_trail_id)
+{
+ struct Trail *trail;
+ struct FriendInfo *first_friend;
+ int i;
+ int index;
+
+ if (GNUNET_NO == is_new_trail_unique (existing_finger, new_trail,
+ new_trail_length))
+ return;
+
+ index = existing_finger->trails_count;
+ trail = &existing_finger->trail_list[index];
+ GNUNET_assert (GNUNET_NO == trail->is_present);
+ trail->trail_id = new_trail_id;
+ trail->trail_length = new_trail_length;
+ existing_finger->trails_count++;
+ trail->is_present = GNUNET_YES;
GNUNET_assert (NULL == (GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&existing_finger->finger_identity)));
existing_finger->trail_list[index].trail_id = new_trail_id;
existing_finger->trail_list[index].is_present = GNUNET_YES;
}
-
+#endif
/**
- * FIXME Check if this function is called for opposite direction if yes then
- * take it as parameter.
* Get the next hop to send trail teardown message from routing table and
* then delete the entry from routing table. Send trail teardown message for a
* specific trail of a finger.
next_hop = GDS_ROUTING_get_next_hop (trail->trail_id,
GDS_ROUTING_SRC_TO_DEST);
-
if (NULL == next_hop)
{
- DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line",
- GNUNET_i2s(&my_identity), GNUNET_h2s(&trail->trail_id), __LINE__);
- GNUNET_break(0);
+// DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line=%d,traillength = %d",
+// GNUNET_i2s(&my_identity), GNUNET_h2s(&trail->trail_id), __LINE__,trail->trail_length);
return;
}
-
GNUNET_assert (0 != GNUNET_CRYPTO_cmp_peer_identity (&finger->finger_identity,
&my_identity));
- /*FIXME: here was an assertion that trail->is_present = GNUNET_YES. But it
- used to fail. We have removed assertion with a condition, just for now.
- Find out the reason why assertion failed. */
- if (trail->is_present == GNUNET_NO)
- {
- DEBUG(" trail id %s of peer %s is not present to send a trail teardown message., line",
- GNUNET_i2s(&my_identity), GNUNET_h2s(&trail->trail_id), __LINE__);
- return;
- }
-
- /* Finger is not a friend. */
+ GNUNET_assert(GNUNET_YES == trail->is_present);
if (trail->trail_length > 0)
{
friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
if (0 != GNUNET_CRYPTO_cmp_peer_identity (next_hop, &friend->id)
&& (0 == trail->trail_length))
{
- //FIXME HERE WE GOT NEXT HOP FRM ROUTING TABLE, AND TRAIL ENGTH - 0, IT ITS
- // THE CASE WEHERE WE SET IT TO 0.
DEBUG ("\n LINE NO: = %d, Friend not found for trail id %s of peer %s trail length = %d",
__LINE__,GNUNET_h2s(&trail->trail_id), GNUNET_i2s(&my_identity),trail->trail_length);
return;
}
GNUNET_assert (GNUNET_YES == GDS_ROUTING_remove_trail (trail->trail_id));
friend->trails_count--;
- GDS_NEIGHBOURS_send_trail_teardown (trail->trail_id,
+ GDS_NEIGHBOURS_send_trail_teardown (&trail->trail_id,
GDS_ROUTING_SRC_TO_DEST,
- friend->id);
+ &friend->id);
}
send_all_finger_trails_teardown (struct FingerInfo *finger)
{
unsigned int i;
+
for (i = 0; i < finger->trails_count; i++)
{
struct Trail *trail;
trail = &finger->trail_list[i];
- GNUNET_assert (trail->is_present == GNUNET_YES);
- send_trail_teardown (finger, trail);
- trail->is_present = GNUNET_NO;
- }
+ if (GNUNET_YES == trail->is_present)
+ {
+ send_trail_teardown (finger, trail);
+ trail->is_present = GNUNET_NO;
+ }
+ }
}
struct FingerInfo *new_entry;
struct FriendInfo *first_trail_hop;
struct Trail *trail;
- int i;
-
+ unsigned int i;
+
new_entry = GNUNET_new (struct FingerInfo);
new_entry->finger_identity = finger_identity;
new_entry->finger_table_index = finger_table_index;
new_entry->is_present = GNUNET_YES;
-
+
/* If the new entry is my own identity. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
&finger_identity))
GNUNET_free (new_entry);
return;
}
-
- /* If finger is a friend, then we don't actually have a trail.
- * Just a trail id */
- if (NULL != GNUNET_CONTAINER_multipeermap_get (friend_peermap,
- &finger_identity))
+
+ /* Finger is a friend. */
+ if (0 == finger_trail_length)
{
- //FIXME: HERE WE SET TRAIL LENGTH TO 0, EVEN THOUGH IT HAS ENTRIES.
new_entry->trail_list[0].trail_id = trail_id;
new_entry->trails_count = 1;
new_entry->trail_list[0].is_present = GNUNET_YES;
&finger_trail[0])));
new_entry->trails_count = 1;
first_trail_hop->trails_count++;
- GNUNET_assert (finger_trail_length != 0);
/* Copy the finger trail into trail. */
- trail = GNUNET_new (struct Trail);
+ trail = &new_entry->trail_list[0];
for(i = 0; i < finger_trail_length; i++)
{
struct Trail_Element *element = GNUNET_new (struct Trail_Element);
trail->trail_tail,
element);
}
-
/* Add trail to trail list. */
- new_entry->trail_list[0].trail_head = trail->trail_head;
- new_entry->trail_list[0].trail_tail = trail->trail_tail;
- new_entry->trail_list[0].trail_length = finger_trail_length;
- new_entry->trail_list[0].trail_id = trail_id;
- new_entry->trail_list[0].is_present = GNUNET_YES;
+ trail->trail_length = finger_trail_length;
+ trail->trail_id = trail_id;
+ trail->is_present = GNUNET_YES;
finger_table[finger_table_index] = *new_entry;
GNUNET_free (new_entry);
- return;
}
*/
static void
send_verify_successor_message (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct FriendInfo *target_friend;
struct GNUNET_HashCode trail_id;
- int i;
struct Trail *trail;
struct Trail_Element *element;
unsigned int trail_length;
- unsigned int j = 0;
+ unsigned int i = 0;
struct FingerInfo *successor;
- /* Schedule another send_find_finger_trail_message task.
- verify_successor_next_send_time.rel_value_us =
- verify_successor_next_send_time.rel_value_us +
- GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
- DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us);*/
- send_verify_successor_task =
- GNUNET_SCHEDULER_add_delayed (verify_successor_next_send_time,
- &send_verify_successor_message,
- NULL);
-
successor = &finger_table[0];
+
+ /* This task will be scheduled when the result for Verify Successor is received. */
+ send_verify_successor_task = NULL;
+
+ /* When verify successor is being called for first time *for current context*
+ * cls will be NULL. If send_verify_successor_retry_task is not NO_TASK, we
+ * must cancel the retry task scheduled for verify_successor of previous
+ * context.
+ */
+ if (NULL == cls)
+ {
+ /* FIXME: Here we are scheduling a new verify successor task, as we
+ got a new successor. But a send verify successor task may be in progress.
+ 1. We need to be sure that this is indeed a new successor. As this function
+ is called even if we add a new trail to reach t old successor.
+ 2. Assuming the new successor is different, then verify successor message
+ * to old successor may be following stages.
+ * --> Waiting for verify successor result. Don't wait anymore. there is
+ * no trail to reach from old successor to me, hence, routing
+ * lookup will fail.
+ * --> Waiting for notify confirmation. again don't wait for it. notify
+ * confirmation will not succeded.
+ */
+ if (send_verify_successor_retry_task != NULL)
+ {
+ /* FIXME: Are we scheduling retry task as soon as we send verify message.
+ If yes then here before making this task, first check if the message
+ is for the same peer again. */
+ struct VerifySuccessorContext *old_ctx =
+ GNUNET_SCHEDULER_cancel(send_verify_successor_retry_task);
+ /* old_ctx must not be NULL, as the retry task had been scheduled */
+ GNUNET_assert(NULL != old_ctx);
+ GNUNET_free(old_ctx);
+ /* FIXME: Why don't we reset the task to NO_TASK here? */
+ }
+
+ struct VerifySuccessorContext *ctx;
+ ctx = GNUNET_new(struct VerifySuccessorContext);
+
+ ctx->num_retries_scheduled++;
+ send_verify_successor_retry_task =
+ GNUNET_SCHEDULER_add_delayed (verify_successor_retry_time,
+ &send_verify_successor_message,
+ ctx);
+ }
+ else
+ {
+ /* This is a retry attempt for verify_successor for a previous context */
+ struct VerifySuccessorContext *ctx;
+
+ ctx = cls;
+ ctx->num_retries_scheduled++;
+ send_verify_successor_retry_task =
+ GNUNET_SCHEDULER_add_delayed (verify_successor_retry_time,
+ &send_verify_successor_message,
+ ctx);
+ }
+
+ /* Among all the trails to reach to successor, select first one which is present.*/
for (i = 0; i < successor->trails_count; i++)
{
trail = &successor->trail_list[i];
if(GNUNET_YES == trail->is_present)
break;
}
-
+
/* No valid trail found to reach to successor. */
if (i == successor->trails_count)
return;
-
+
GNUNET_assert(0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
&successor->finger_identity));
-
/* Trail stored at this index. */
GNUNET_assert (GNUNET_YES == trail->is_present);
-
trail_id = trail->trail_id;
if (NULL == GDS_ROUTING_get_next_hop(trail_id,GDS_ROUTING_SRC_TO_DEST))
{
return;
}
trail_length = trail->trail_length;
-
if (trail_length > 0)
{
/* Copy the trail into peer list. */
struct GNUNET_PeerIdentity peer_list[trail_length];
-
element = trail->trail_head;
- for(j = 0; j < trail_length; j++)
+ for(i = 0; i < trail_length; i++)
{
- peer_list[j] = element->peer;
+ peer_list[i] = element->peer;
element = element->next;
}
-
GNUNET_assert (NULL != (target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&peer_list[0])));
successor->finger_identity,
trail_id, peer_list, trail_length,
target_friend);
- return;
}
else
{
successor->finger_identity,
trail_id, NULL, 0,
target_friend);
- return;
}
}
/**
* FIXME: should this be a periodic task, incrementing the search finger index?
* Update the current search finger index.
- *
- * FIXME document parameters!
+ * @a finger_identity
+ * @a finger_table_index
*/
static void
-update_current_search_finger_index (struct GNUNET_PeerIdentity finger_identity,
- unsigned int finger_table_index)
+update_current_search_finger_index (unsigned int finger_table_index)
{
struct FingerInfo *successor;
/* We were looking for immediate successor. */
if (0 == current_search_finger_index)
{
- /* Start looking for immediate predecessor. */
current_search_finger_index = PREDECESSOR_FINGER_ID;
-
- if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &finger_identity))
+ if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &successor->finger_identity))
{
- if (GNUNET_SCHEDULER_NO_TASK == send_verify_successor_task)
+ if (NULL == send_verify_successor_task)
{
- send_verify_successor_task =
+ send_verify_successor_task =
GNUNET_SCHEDULER_add_now (&send_verify_successor_message, NULL);
}
}
/**
* Remove finger and its associated data structures from finger table.
- * @param existing_finger Finger to be removed which is in finger table.
+ * @param existing_finger Finger to be removed which is in finger table.
* @param finger_table_index Index in finger table where @a existing_finger
* is stored.
*/
finger, and free the finger. */
send_all_finger_trails_teardown (existing_finger);
free_finger (existing_finger, finger_table_index);
- return;
}
return;
}
- /* New entry same as successor. */
+ /* Check if new entry is same as successor. */
if ((0 != finger_table_index) &&
(PREDECESSOR_FINGER_ID != finger_table_index))
{
successor = &finger_table[0];
if (GNUNET_NO == successor->is_present)
{
- GNUNET_break (0);
+ GNUNET_break (0); //ASSERTION FAILS HERE. FIXME
return;
}
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&finger_identity,
&successor->finger_identity))
{
- find_finger_trail_task_next_send_time =
+ if (0 == fingers_round_count)
+ {
+ find_finger_trail_task_next_send_time =
GNUNET_TIME_STD_BACKOFF(find_finger_trail_task_next_send_time);
+ }
+ else
+ fingers_round_count--;
current_search_finger_index = 0;
+ GNUNET_STATISTICS_update (GDS_stats,
+ gettext_noop
+ ("# FINGERS_COUNT"), (int64_t) total_fingers_found,
+ GNUNET_NO);
+ total_fingers_found = 0;
return;
}
-
+
struct FingerInfo prev_finger;
prev_finger = finger_table[finger_table_index - 1];
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&finger_identity,
}
}
+ total_fingers_found++;
existing_finger = &finger_table[finger_table_index];
/* No entry present in finger_table for given finger map index. */
if (GNUNET_NO == existing_finger->is_present)
{
+ /* Shorten the trail if possible. */
add_new_finger (finger_identity, finger_trail,
finger_trail_length,
finger_trail_id, finger_table_index);
- update_current_search_finger_index (finger_identity,
- finger_table_index);
+ update_current_search_finger_index (finger_table_index);
return;
}
-
/* If existing entry and finger identity are not same. */
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&(existing_finger->finger_identity),
&finger_identity))
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&finger_identity, &my_identity))
{
if (finger_trail_length > 0)
- GDS_NEIGHBOURS_send_trail_teardown (finger_trail_id,
+ GDS_NEIGHBOURS_send_trail_teardown (&finger_trail_id,
GDS_ROUTING_SRC_TO_DEST,
- finger_trail[0]);
+ &finger_trail[0]);
else
- GDS_NEIGHBOURS_send_trail_teardown (finger_trail_id,
+ GDS_NEIGHBOURS_send_trail_teardown (&finger_trail_id,
GDS_ROUTING_SRC_TO_DEST,
- finger_identity);
+ &finger_identity);
}
}
}
{
return;
}
- /* If the existing finger is not a friend. */
- if (NULL ==
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
- &existing_finger->finger_identity))
- {
- /* If there is space to store more trails. */
- if (existing_finger->trails_count < MAXIMUM_TRAILS_PER_FINGER)
+
+ /* If there is space to store more trails. */
+ if (existing_finger->trails_count < MAXIMUM_TRAILS_PER_FINGER)
add_new_trail (existing_finger, finger_trail,
finger_trail_length, finger_trail_id);
- else
+ else
select_and_replace_trail (existing_finger, finger_trail,
finger_trail_length, finger_trail_id);
-
- }
}
- update_current_search_finger_index (finger_identity, finger_table_index);
+ update_current_search_finger_index (finger_table_index);
return;
}
/**
- * FIXME: Check for loop in the request. If you already are part of put path,
- * then you need to reset the put path length.
* Core handler for P2P put messages.
* @param cls closure
* @param peer sender of the request
{
struct PeerPutMessage *put;
struct GNUNET_PeerIdentity *put_path;
+ struct GNUNET_PeerIdentity current_best_known_dest;
struct GNUNET_PeerIdentity best_known_dest;
+ struct GNUNET_HashCode received_intermediate_trail_id;
struct GNUNET_HashCode intermediate_trail_id;
- struct GNUNET_PeerIdentity *next_hop;
+ struct GNUNET_PeerIdentity next_hop;
+ struct GNUNET_PeerIdentity *next_routing_hop;
enum GNUNET_DHT_RouteOption options;
struct GNUNET_HashCode test_key;
void *payload;
size_t payload_size;
uint64_t key_value;
-#if ENABLE_MALICIOUS
- if(1 == act_malicious)
- {
- DEBUG("I am malicious,dropping put request. \n");
- return GNUNET_OK;
- }
-#endif
-
msize = ntohs (message->size);
if (msize < sizeof (struct PeerPutMessage))
{
sizeof (struct PeerPutMessage) +
putlen * sizeof (struct GNUNET_PeerIdentity)) ||
(putlen >
- GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)))
+ GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)))
{
GNUNET_break_op (0);
return GNUNET_OK;
}
- DEBUG("GET FOR DATA_SIZE = %lu\n",msize);
+#if ENABLE_MALICIOUS
+ if(1 == act_malicious)
+ {
+ DEBUG("\n I AM MALICIOUS PUT_REQUEST_DROPPED for key = %ss",GNUNET_h2s(&put->key));
+ return GNUNET_OK;
+ }
+#endif
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), (int64_t) msize,
GNUNET_NO);
-
- best_known_dest = put->best_known_destination;
+
+ current_best_known_dest = put->best_known_destination;
put_path = (struct GNUNET_PeerIdentity *) &put[1];
payload = &put_path[putlen];
options = ntohl (put->options);
- intermediate_trail_id = put->intermediate_trail_id;
+ received_intermediate_trail_id = put->intermediate_trail_id;
hop_count = ntohl(put->hop_count);
payload_size = msize - (sizeof (struct PeerPutMessage) +
putlen * sizeof (struct GNUNET_PeerIdentity));
{
switch (GNUNET_BLOCK_evaluate (GDS_block_context,
ntohl (put->block_type),
+ GNUNET_BLOCK_EO_NONE,
NULL, /* query */
NULL, 0, /* bloom filer */
NULL, 0, /* xquery */
return GNUNET_OK;
}
}
-
+
/* Check if you are already a part of put path. */
unsigned int i;
for (i = 0; i < putlen; i++)
break;
}
}
-
+
/* Add yourself to the list. */
struct GNUNET_PeerIdentity pp[putlen + 1];
- if (0 != (options & GNUNET_DHT_RO_RECORD_ROUTE))
+ //if (0 != (options & GNUNET_DHT_RO_RECORD_ROUTE))
+ if (1)
{
memcpy (pp, put_path, putlen * sizeof (struct GNUNET_PeerIdentity));
pp[putlen] = my_identity;
}
else
putlen = 0;
-
+
memcpy (&key_value, &(put->key), sizeof (uint64_t));
- if (0 != (GNUNET_CRYPTO_cmp_peer_identity (&best_known_dest, &my_identity)))
+ struct Closest_Peer successor;
+ key_value = GNUNET_ntohll (key_value);
+ successor = find_local_best_known_next_hop (key_value,
+ GDS_FINGER_TYPE_NON_PREDECESSOR);
+ next_hop = successor.next_hop;
+ intermediate_trail_id = successor.trail_id;
+ best_known_dest = successor.best_known_destination;
+
+ if (0 != (GNUNET_CRYPTO_cmp_peer_identity (¤t_best_known_dest, &my_identity)))
{
- next_hop = GDS_ROUTING_get_next_hop (intermediate_trail_id,
- GDS_ROUTING_SRC_TO_DEST);
- if (NULL == next_hop)
- {
- DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line",
- GNUNET_i2s(&my_identity), GNUNET_h2s(&intermediate_trail_id), __LINE__);
- GNUNET_STATISTICS_update (GDS_stats,
- gettext_noop ("# Next hop to forward the packet not found "
- "trail setup request, packet dropped."),
- 1, GNUNET_NO);
-
- GNUNET_break_op (0);
- //FIXME: Adding put here,only to ensure that process does not hang. but
- // should not be here. fix the logic.
- GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh (put->expiration_time),
- &(put->key),putlen, pp, ntohl (put->block_type),
- payload_size, payload);
- return GNUNET_OK;
- }
- else
+ next_routing_hop = GDS_ROUTING_get_next_hop (received_intermediate_trail_id,
+ GDS_ROUTING_SRC_TO_DEST);
+ if (NULL != next_routing_hop)
{
- GNUNET_assert (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
- next_hop));
+ next_hop = *next_routing_hop;
+ intermediate_trail_id = received_intermediate_trail_id;
+ best_known_dest = current_best_known_dest;
}
}
- else
- {
- struct Closest_Peer successor;
- key_value = GNUNET_ntohll (key_value);
- successor = find_successor (key_value, GDS_FINGER_TYPE_NON_PREDECESSOR);
- next_hop = GNUNET_new (struct GNUNET_PeerIdentity);
- *next_hop = successor.next_hop;
- intermediate_trail_id = successor.trail_id;
- best_known_dest = successor.best_known_destination;
- }
-
-
GDS_CLIENTS_process_put (options,
ntohl (put->block_type),
hop_count,
/* I am the final destination */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &best_known_dest))
{
+ DEBUG("\n PUT_REQUEST_SUCCESSFUL for key = %s",GNUNET_h2s(&put->key));
GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh (put->expiration_time),
&(put->key),putlen, pp, ntohl (put->block_type),
payload_size, payload);
}
else
{
- GDS_NEIGHBOURS_send_put (&put->key,
- ntohl (put->block_type),ntohl (put->options),
- ntohl (put->desired_replication_level),
- best_known_dest, intermediate_trail_id, next_hop,
- hop_count, putlen, pp,
- GNUNET_TIME_absolute_ntoh (put->expiration_time),
- payload, payload_size);
+#if ENABLE_MALICIOUS
+ if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination,
+ &successor.next_hop))
+ {
+ struct FingerInfo *next_hop_finger;
+ unsigned int i;
+
+ next_hop_finger = &finger_table[successor.finger_table_index];
+ for (i = 0; i < next_hop_finger->trails_count; i++)
+ {
+ if (GNUNET_YES == next_hop_finger->trail_list[i].is_present)
+ {
+ if(0 == next_hop_finger->trail_list[i].trail_length)
+ {
+ GDS_NEIGHBOURS_send_put (&put->key,
+ ntohl (put->block_type),ntohl (put->options),
+ ntohl (put->desired_replication_level),
+ best_known_dest, intermediate_trail_id, &next_hop,
+ hop_count, putlen, pp,
+ GNUNET_TIME_absolute_ntoh (put->expiration_time),
+ payload, payload_size);
+ return GNUNET_OK;
+ }
+ next_hop = next_hop_finger->trail_list[i].trail_head->peer;
+ GDS_NEIGHBOURS_send_put (&put->key,
+ ntohl (put->block_type),ntohl (put->options),
+ ntohl (put->desired_replication_level),
+ best_known_dest,
+ next_hop_finger->trail_list[i].trail_id,
+ &next_hop, hop_count, putlen, pp,
+ GNUNET_TIME_absolute_ntoh (put->expiration_time),
+ payload, payload_size);
+ }
+ }
+ return GNUNET_OK;
+ }
+#endif
+ GDS_NEIGHBOURS_send_put (&put->key,
+ ntohl (put->block_type),ntohl (put->options),
+ ntohl (put->desired_replication_level),
+ best_known_dest, intermediate_trail_id, &next_hop,
+ hop_count, putlen, pp,
+ GNUNET_TIME_absolute_ntoh (put->expiration_time),
+ payload, payload_size);
}
return GNUNET_OK;
}
const struct PeerGetMessage *get;
const struct GNUNET_PeerIdentity *get_path;
struct GNUNET_PeerIdentity best_known_dest;
+ struct GNUNET_PeerIdentity current_best_known_dest;
struct GNUNET_HashCode intermediate_trail_id;
- struct GNUNET_PeerIdentity *next_hop;
+ struct GNUNET_HashCode received_intermediate_trail_id;
+ struct Closest_Peer successor;
+ struct GNUNET_PeerIdentity next_hop;
+ struct GNUNET_PeerIdentity *next_routing_hop;
uint32_t get_length;
uint64_t key_value;
uint32_t hop_count;
size_t msize;
-#if ENABLE_MALICIOUS
- if(1 == act_malicious)
- {
- DEBUG("I am malicious,dropping get request. \n");
- return GNUNET_OK;
- }
-#endif
-
msize = ntohs (message->size);
if (msize < sizeof (struct PeerGetMessage))
{
get = (const struct PeerGetMessage *)message;
get_length = ntohl (get->get_path_length);
- best_known_dest = get->best_known_destination;
- intermediate_trail_id = get->intermediate_trail_id;
- get_path = (const struct GNUNET_PeerIdentity *)&get[1];
- hop_count = get->hop_count;
- hop_count++;
-
if ((msize <
sizeof (struct PeerGetMessage) +
get_length * sizeof (struct GNUNET_PeerIdentity)) ||
(get_length >
- GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)))
+ GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)))
{
GNUNET_break_op (0);
return GNUNET_YES;
}
-
+
+#if ENABLE_MALICIOUS
+ if(1 == act_malicious)
+ {
+ DEBUG("I am malicious,GET_REQUEST_DROPPED for key = %s. \n",GNUNET_h2s(&get->key));
+ return GNUNET_OK;
+ }
+#endif
+ current_best_known_dest = get->best_known_destination;
+ received_intermediate_trail_id = get->intermediate_trail_id;
+ get_path = (const struct GNUNET_PeerIdentity *)&get[1];
+ hop_count = get->hop_count;
+ hop_count++;
+
+
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
memcpy (&key_value, &(get->key), sizeof (uint64_t));
key_value = GNUNET_ntohll (key_value);
-
+
/* Check if you are already a part of get path. */
unsigned int i;
for (i = 0; i < get_length; i++)
break;
}
}
-
+
/* Add yourself in the get path. */
struct GNUNET_PeerIdentity gp[get_length + 1];
memcpy (gp, get_path, get_length * sizeof (struct GNUNET_PeerIdentity));
GDS_CLIENTS_process_get (get->options, get->block_type, hop_count,
get->desired_replication_level, get->get_path_length,
gp, &get->key);
-
+
+
+ successor = find_local_best_known_next_hop (key_value,
+ GDS_FINGER_TYPE_NON_PREDECESSOR);
+ next_hop = successor.next_hop;
+ best_known_dest = successor.best_known_destination;
+ intermediate_trail_id = successor.trail_id;
/* I am not the final destination. I am part of trail to reach final dest. */
- if (0 != (GNUNET_CRYPTO_cmp_peer_identity (&best_known_dest, &my_identity)))
+ if (0 != (GNUNET_CRYPTO_cmp_peer_identity (¤t_best_known_dest, &my_identity)))
{
- next_hop = GDS_ROUTING_get_next_hop (intermediate_trail_id,
- GDS_ROUTING_SRC_TO_DEST);
- if (NULL == next_hop)
+ next_routing_hop = GDS_ROUTING_get_next_hop (received_intermediate_trail_id,
+ GDS_ROUTING_SRC_TO_DEST);
+ if (NULL != next_routing_hop)
{
- DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line",
- GNUNET_i2s(&my_identity), GNUNET_h2s(&intermediate_trail_id), __LINE__);
- GNUNET_STATISTICS_update (GDS_stats,
- gettext_noop ("# Next hop to forward the packet not found "
- "GET request, packet dropped."),
- 1, GNUNET_NO);
- GNUNET_break (0);
- /* We are not able to proceed further*/
- GDS_DATACACHE_handle_get (&(get->key),(get->block_type), NULL, 0, NULL, 0,
- get_length, gp, &gp[get_length - 2],
- &my_identity);
- return GNUNET_OK;
+ next_hop = *next_routing_hop;
+ best_known_dest = current_best_known_dest;
+ intermediate_trail_id = received_intermediate_trail_id;
}
}
- else
- {
- struct Closest_Peer successor;
- successor = find_successor (key_value, GDS_FINGER_TYPE_NON_PREDECESSOR);
- next_hop = GNUNET_new (struct GNUNET_PeerIdentity);
- *next_hop = successor.next_hop;
- best_known_dest = successor.best_known_destination;
- intermediate_trail_id = successor.trail_id;
- }
-
/* I am the final destination. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity(&my_identity, &best_known_dest))
{
if (1 == get_length)
{
+ DEBUG("\n GET_REQUEST DONE for key = %s",GNUNET_h2s(&get->key));
GDS_DATACACHE_handle_get (&(get->key),(get->block_type), NULL, 0,
NULL, 0, 1, &my_identity, NULL,&my_identity);
}
else
{
GDS_DATACACHE_handle_get (&(get->key),(get->block_type), NULL, 0, NULL, 0,
- get_length, gp, &gp[get_length - 2],
+ get_length, gp, &gp[get_length - 2],
&my_identity);
}
}
else
{
+
+#if ENABLE_MALICIOUS
+ if (0 != GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination,
+ &successor.next_hop))
+ {
+ struct FingerInfo *next_hop_finger;
+ unsigned int i;
+
+ next_hop_finger = &finger_table[successor.finger_table_index];
+ for (i = 0; i < next_hop_finger->trails_count; i++)
+ {
+ if(0 == next_hop_finger->trail_list[i].trail_length)
+ {
+ GDS_NEIGHBOURS_send_get (&(get->key), get->block_type, get->options,
+ get->desired_replication_level, best_known_dest,
+ intermediate_trail_id, &next_hop, hop_count,
+ get_length, gp);
+ return GNUNET_OK;
+ }
+ if (GNUNET_YES == next_hop_finger->trail_list[i].is_present)
+ {
+ next_hop = next_hop_finger->trail_list[i].trail_head->peer;
+ GDS_NEIGHBOURS_send_get (&(get->key), get->block_type, get->options,
+ get->desired_replication_level, best_known_dest,
+ next_hop_finger->trail_list[i].trail_id,
+ &next_hop, hop_count,
+ get_length, gp);
+ }
+ }
+ return GNUNET_OK;
+ }
+#endif
GDS_NEIGHBOURS_send_get (&(get->key), get->block_type, get->options,
get->desired_replication_level, best_known_dest,
- intermediate_trail_id, next_hop, hop_count,
+ intermediate_trail_id, &next_hop, hop_count,
get_length, gp);
}
return GNUNET_YES;
getlen * sizeof (struct GNUNET_PeerIdentity) +
putlen * sizeof (struct GNUNET_PeerIdentity)) ||
(getlen >
- GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity) ||
+ GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity) ||
(putlen >
- GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity))))
+ GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity))))
{
GNUNET_break_op (0);
return GNUNET_YES;
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
put_path = (const struct GNUNET_PeerIdentity *) &get_result[1];
get_path = &put_path[putlen];
payload = (const void *) &get_path[getlen];
* finger, then it is the trail id to reach to
* that finger, else set to 0.
* @param is_predecessor Are we looking for closest successor or predecessor.
+ * @param source Source of trail setup message.
* @param current_dest In case you are part of trail, then finger to which
* we should forward the message. Else my own identity
* @return Closest Peer for @a final_dest_finger_val
get_local_best_known_next_hop (uint64_t final_dest_finger_val,
struct GNUNET_HashCode intermediate_trail_id,
unsigned int is_predecessor,
- struct GNUNET_PeerIdentity prev_hop,
struct GNUNET_PeerIdentity source,
struct GNUNET_PeerIdentity *current_dest)
{
struct Closest_Peer peer;
- /* Find a local best known peer. */
- peer = find_successor (final_dest_finger_val, is_predecessor);//FIXME: chnage to better name
+ peer = find_local_best_known_next_hop (final_dest_finger_val, is_predecessor);
/* Am I just a part of a trail towards a finger (current_destination)? */
- /* Select best successor among one found locally and current_destination
- * that we got from network.*/
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity, current_dest) &&
0 != GNUNET_CRYPTO_cmp_peer_identity (&peer.best_known_destination,
current_dest))
{
struct GNUNET_PeerIdentity closest_peer;
+ /* Select best successor among one found locally and current_destination
+ * that we got from network.*/
closest_peer = select_closest_peer (&peer.best_known_destination,
current_dest,
final_dest_finger_val,
if (0 == GNUNET_CRYPTO_cmp_peer_identity (current_dest, &closest_peer))
{
struct GNUNET_PeerIdentity *next_hop;
-
+
next_hop = GDS_ROUTING_get_next_hop (intermediate_trail_id,
GDS_ROUTING_SRC_TO_DEST);
/* next_hop NULL is a valid case. This intermediate trail id is set by
struct GNUNET_PeerIdentity current_dest;
struct FriendInfo *target_friend;
struct GNUNET_PeerIdentity source;
- uint64_t final_dest_finger_val;
struct GNUNET_HashCode intermediate_trail_id;
struct GNUNET_HashCode trail_id;
unsigned int is_predecessor;
uint32_t trail_length;
+ uint64_t final_dest_finger_val;
int i;
size_t msize;
}
trail_length = (msize - sizeof (struct PeerTrailSetupMessage))/
sizeof (struct GNUNET_PeerIdentity);
-
+
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail_peer_list = (const struct GNUNET_PeerIdentity *)&trail_setup[1];
current_dest = trail_setup->best_known_destination;
trail_id = trail_setup->trail_id;
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
-
+
/* If I was the source and got the message back, then set trail length to 0.*/
if (0 == GNUNET_CRYPTO_cmp_peer_identity(&my_identity, &source))
- {
+ {
trail_length = 0;
}
-
- /* SUPUS: remove the check that source is a friend, because again source
- may become aware about it later. and by that time lookup may fail. */
-
+
/* Check if you are present in the trail seen so far? */
for (i = 0; i < trail_length ; i++)
{
if(0 == GNUNET_CRYPTO_cmp_peer_identity(&trail_peer_list[i],&my_identity))
{
- trail_length = i; /* Check that you add yourself again */
+ /* We will add ourself later in code, if NOT destination. */
+ trail_length = i;
break;
}
}
{
if (trail_length > 0)
target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&trail_peer_list[trail_length - 1]);
else
target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&source);
-
if(NULL == target_friend)
{
DEBUG ("\n friend not found");
GNUNET_break(0);
return GNUNET_OK;
}
-
GDS_NEIGHBOURS_send_trail_rejection (source, final_dest_finger_val,
my_identity, is_predecessor,
trail_peer_list, trail_length,
get_local_best_known_next_hop (final_dest_finger_val,
intermediate_trail_id,
is_predecessor,
- *peer,
source,
¤t_dest);
final_dest_finger_val, trail_id);
return GNUNET_OK;
}
-
+
if (trail_length > 0)
- target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
+ target_friend =
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&trail_peer_list[trail_length-1]);
else
- target_friend =
+ target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap, &source);
-
if (NULL == target_friend)
{
GNUNET_break_op (0);
GNUNET_break (0);
return GNUNET_OK;
}
-
if (0 != GNUNET_CRYPTO_cmp_peer_identity(&my_identity, &source))
{
/* Add yourself to list of peers. */
}
trail_length = (msize - sizeof (struct PeerTrailSetupResultMessage))/
sizeof (struct GNUNET_PeerIdentity);
-
+
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
is_predecessor = ntohl (trail_result->is_predecessor);
querying_peer = trail_result->querying_peer;
finger_identity = trail_result->finger_identity;
GNUNET_break_op(0);
return GNUNET_SYSERR;
}
-
+
//TODO; Refactor code here and above to check if sender peer is correct
if (my_index == 0)
{
{
if(my_index == trail_length - 1)
{
- GNUNET_assert(0 ==
+ GNUNET_assert(0 ==
GNUNET_CRYPTO_cmp_peer_identity (&finger_identity,
- peer));
+ peer));
}
else
- GNUNET_assert(0 ==
+ GNUNET_assert(0 ==
GNUNET_CRYPTO_cmp_peer_identity (&trail_peer_list[my_index + 1],
peer));
next_hop = trail_peer_list[my_index - 1];
}
-
+
target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap, &next_hop);
if (NULL == target_friend)
{
struct GNUNET_PeerIdentity *trail_list;
unsigned int i;
- trail = GNUNET_new (struct Trail);
-
/* Get the shortest trail to reach to current successor. */
for (i = 0; i < finger->trails_count; i++)
{
/**
- * Check if trail_1 and trail_2 have any common element. If yes then join
- * them at common element. trail_1 always preceeds trail_2 in joined trail.
+ * Check if trail_1 and trail_2 have any common element. If yes then join
+ * them at common element. trail_1 always preceeds trail_2 in joined trail.
* @param trail_1 Trail from source to me, NOT including endpoints.
* @param trail_1_len Total number of peers @a trail_1
* @param trail_2 Trail from me to current predecessor, NOT including endpoints.
unsigned int i;
unsigned int j;
unsigned int k;
-
+
for (i = 0; i < trail_1_len; i++)
{
for (j = 0; j < trail_2_len; j++)
{
if(0 != GNUNET_CRYPTO_cmp_peer_identity (&trail_1[i],&trail_2[j]))
continue;
-
+
*joined_trail_len = i + (trail_2_len - j);
- joined_trail = GNUNET_malloc (*joined_trail_len *
+ joined_trail = GNUNET_malloc (*joined_trail_len *
sizeof(struct GNUNET_PeerIdentity));
-
-
+
+
/* Copy all the elements from 0 to i into joined_trail. */
for(k = 0; k < ( i+1); k++)
{
joined_trail[k] = trail_1[k];
}
-
+
/* Increment j as entry stored is same as entry stored at i*/
j = j+1;
-
+
/* Copy all the elements from j to trail_2_len-1 to joined trail.*/
while(k <= (*joined_trail_len - 1))
{
j++;
k++;
}
-
+
return joined_trail;
}
}
-
+
/* Here you should join the trails. */
*joined_trail_len = trail_1_len + trail_2_len + 1;
- joined_trail = GNUNET_malloc (*joined_trail_len *
+ joined_trail = GNUNET_malloc (*joined_trail_len *
sizeof(struct GNUNET_PeerIdentity));
-
-
+
+
for(i = 0; i < trail_1_len;i++)
{
joined_trail[i] = trail_1[i];
}
-
+
joined_trail[i] = my_identity;
i++;
-
+
for (j = 0; i < *joined_trail_len; i++,j++)
{
joined_trail[i] = trail_2[j];
}
-
+
return joined_trail;
}
struct FingerInfo *current_predecessor;
int i;
unsigned int j;
+ unsigned int len;
current_predecessor = &finger_table[PREDECESSOR_FINGER_ID];
-
+
/* Check if trail_src_to_me contains current_predecessor. */
for (i = 0; i < trail_src_to_me_len; i++)
{
- if(0 != GNUNET_CRYPTO_cmp_peer_identity(&trail_src_to_me[i],
- ¤t_predecessor->finger_identity))
- continue;
-
-
+ if (0 != GNUNET_CRYPTO_cmp_peer_identity(&trail_src_to_me[i],
+ ¤t_predecessor->finger_identity))
+ continue;
+
+
*trail_src_to_curr_pred_length = i;
-
+
if(0 == i)
return NULL;
-
+
trail_src_to_curr_pred = GNUNET_malloc (*trail_src_to_curr_pred_length *
sizeof(struct GNUNET_PeerIdentity));
- for(j = 0; j < i;j++)
+ for (j = 0; j < i; j++)
trail_src_to_curr_pred[j] = trail_src_to_me[j];
return trail_src_to_curr_pred;
}
-
+
trail_me_to_curr_pred = get_shortest_trail (current_predecessor,
&trail_me_to_curr_pred_length);
-
+
/* Check if trail contains the source_peer. */
- for(i = trail_me_to_curr_pred_length - 1; i >= 0; i--)
- {
- if(0 != GNUNET_CRYPTO_cmp_peer_identity (&source_peer,
- &trail_me_to_curr_pred[i]))
- continue;
-
- /* Source is NOT part of trail. */
- i = i+1;
-
- /* Source is the last element in the trail to reach to my pred.
- Source is direct friend of the pred. */
- if (trail_me_to_curr_pred_length == i)
- {
- *trail_src_to_curr_pred_length = 0;
- return NULL;
- }
-
- *trail_src_to_curr_pred_length = trail_me_to_curr_pred_length - i;
- trail_src_to_curr_pred = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)*
- *trail_src_to_curr_pred_length);
-
- for(j = 0; j < *trail_src_to_curr_pred_length; i++,j++)
- {
- trail_src_to_curr_pred[j] = trail_me_to_curr_pred[i];
- }
- GNUNET_free_non_null(trail_me_to_curr_pred);
- return trail_src_to_curr_pred;
+ for (i = trail_me_to_curr_pred_length - 1; i >= 0; i--)
+ {
+ if (0 != GNUNET_CRYPTO_cmp_peer_identity (&source_peer,
+ &trail_me_to_curr_pred[i]))
+ continue;
+
+ /* Source is NOT part of trail. */
+ i++;
+
+ /* Source is the last element in the trail to reach to my pred.
+ Source is direct friend of the pred. */
+ if (trail_me_to_curr_pred_length == i)
+ {
+ *trail_src_to_curr_pred_length = 0;
+ GNUNET_free_non_null (trail_me_to_curr_pred);
+ return NULL;
+ }
+
+ *trail_src_to_curr_pred_length = trail_me_to_curr_pred_length - i;
+ trail_src_to_curr_pred = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)*
+ *trail_src_to_curr_pred_length);
+
+ for (j = 0; j < *trail_src_to_curr_pred_length; i++,j++)
+ trail_src_to_curr_pred[j] = trail_me_to_curr_pred[i];
+ GNUNET_free_non_null (trail_me_to_curr_pred);
+ return trail_src_to_curr_pred;
}
-
- unsigned int len;
- trail_src_to_curr_pred = check_for_duplicate_entries (trail_src_to_me,
+
+ trail_src_to_curr_pred = check_for_duplicate_entries (trail_src_to_me,
trail_src_to_me_len,
trail_me_to_curr_pred,
trail_me_to_curr_pred_length,
- &len);
+ &len);
*trail_src_to_curr_pred_length = len;
GNUNET_free_non_null(trail_me_to_curr_pred);
return trail_src_to_curr_pred;
&trail_to_new_predecessor_id,
sizeof (trail_to_new_predecessor_id));
- /* Finger is a friend. */
- if (trail_length == 0)
+ if (0 == trail_length)
{
trail_to_new_predecessor = NULL;
GDS_ROUTING_add (trail_to_new_predecessor_id, my_identity, finger);
- GNUNET_assert (NULL != (target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
- &finger)));
+ target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap, &finger);
+ if (NULL == target_friend)
+ {
+ GNUNET_break (0);
+ return;
+ }
}
else
{
endpoints.*/
GNUNET_assert(NULL != GNUNET_CONTAINER_multipeermap_get(friend_peermap,
&trail[trail_length-1]));
-
trail_to_new_predecessor = invert_trail (trail, trail_length);
-
+
/* Add an entry in your routing table. */
GDS_ROUTING_add (trail_to_new_predecessor_id,
my_identity,
GNUNET_assert (NULL != (target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&trail_to_new_predecessor[0])));
- GNUNET_assert (NULL != (
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
- &trail[trail_length - 1])));
}
/* Add entry in routing table of all peers that are part of trail from me
update_predecessor (finger, trail, trail_length);
return;
}
-
+
if (0 == GNUNET_CRYPTO_cmp_peer_identity (¤t_predecessor->finger_identity,
&finger))
{
struct GNUNET_PeerIdentity *trail_src_to_curr_pred;
unsigned int trail_length;
size_t msize;
-
+
msize = ntohs (message->size);
if (msize < sizeof (struct PeerVerifySuccessorMessage))
GNUNET_break_op (0);
return GNUNET_OK;
}
-
+
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail_id = vsm->trail_id;
source_peer = vsm->source_peer;
successor = vsm->successor;
trail = (struct GNUNET_PeerIdentity *)&vsm[1];
-
+
/* I am NOT the successor of source_peer. Pass the message to next_hop on
* the trail. */
if(0 != (GNUNET_CRYPTO_cmp_peer_identity (&successor, &my_identity)))
{
- next_hop = GDS_ROUTING_get_next_hop (trail_id, GDS_ROUTING_SRC_TO_DEST);
+ next_hop = GDS_ROUTING_get_next_hop (trail_id, GDS_ROUTING_SRC_TO_DEST);
if (NULL == next_hop)
{
- DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line",
- GNUNET_i2s(&my_identity), GNUNET_h2s(&trail_id), __LINE__);
- GNUNET_break_op (0);
return GNUNET_OK;
}
-
+
target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap, next_hop);
-
+
if(NULL == target_friend)
{
GNUNET_break_op(0);
* it. */
compare_and_update_predecessor (source_peer, trail, trail_length);
current_predecessor = finger_table[PREDECESSOR_FINGER_ID];
-
+
/* Is source of this message NOT my predecessor. */
if (0 != (GNUNET_CRYPTO_cmp_peer_identity (¤t_predecessor.finger_identity,
&source_peer)))
{
- trail_src_to_curr_pred =
+ trail_src_to_curr_pred =
get_trail_src_to_curr_pred (source_peer,
trail,
trail_length,
trail_src_to_curr_pred_len = trail_length;
unsigned int i;
- trail_src_to_curr_pred =
+ trail_src_to_curr_pred =
GNUNET_malloc (sizeof(struct GNUNET_PeerIdentity)
*trail_src_to_curr_pred_len);
for(i = 0; i < trail_src_to_curr_pred_len; i++)
trail_src_to_curr_pred[i] = trail[i];
}
}
-
+
GNUNET_assert (NULL !=
(target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap, peer)));
*trail_to_new_successor_length = 0;
return trail_to_new_successor;
}
-
+
/* Is there any friend of yours in this trail. */
if(trail_me_to_probable_successor_len > 1)
{
trail_to_new_successor = GNUNET_malloc (sizeof(struct GNUNET_PeerIdentity)*
*trail_to_new_successor_length);
-
- for(j = 0;j < *trail_to_new_successor_length;i++,j++)
+
+ for(j = 0; j < *trail_to_new_successor_length; i++,j++)
{
trail_to_new_successor[j] = trail_me_to_probable_successor[i];
}
-
+
return trail_to_new_successor;
}
}
return (struct GNUNET_PeerIdentity*)trail_me_to_probable_successor;
}
+// TODO: Move up
+struct SendNotifyContext
+{
+ struct GNUNET_PeerIdentity source_peer;
+ struct GNUNET_PeerIdentity successor;
+ struct GNUNET_PeerIdentity *successor_trail;
+ unsigned int successor_trail_length;
+ struct GNUNET_HashCode succesor_trail_id;
+ struct FriendInfo *target_friend;
+ unsigned int num_retries_scheduled;
+};
+
+void
+send_notify_new_successor (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext
+ * tc);
/**
* Check if the peer which sent us verify successor result message is still ours
* @param curr_succ Peer to which we sent the verify successor message. It may
* or may not be our real current successor, as we may have few iterations of
* find finger trail task.
- * @param probable_successor Peer which should be our successor accroding to @a
+ * @param probable_successor Peer which should be our successor accroding to @a
* curr_succ
* @param trail List of peers to reach from me to @a probable successor, NOT including
* endpoints.
/* If probable successor is same as current_successor, do nothing. */
if(0 == GNUNET_CRYPTO_cmp_peer_identity (&probable_successor,
¤t_successor->finger_identity))
+ {
+ if ((NULL != GDS_stats))
+ {
+ char *my_id_str;
+ uint64_t succ;
+ char *key;
+ uint64_t my_id;
+ memcpy (&my_id, &my_identity, sizeof(uint64_t));
+ my_id_str = GNUNET_strdup (GNUNET_i2s_full (&my_identity));
+ memcpy(&succ, ¤t_successor->finger_identity, sizeof(uint64_t));
+ succ = GNUNET_ntohll(succ);
+ GNUNET_asprintf (&key, "XDHT:%s:", my_id_str);
+ GNUNET_free (my_id_str);
+
+ GNUNET_STATISTICS_set (GDS_stats, key, succ, 0);
+ GNUNET_free (key);
+ }
+ if (send_verify_successor_task == NULL)
+ send_verify_successor_task =
+ GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
+ &send_verify_successor_message,
+ NULL);
return;
-
+ }
closest_peer = select_closest_peer (&probable_successor,
¤t_successor->finger_identity,
successor_value, is_predecessor);
if (0 == GNUNET_CRYPTO_cmp_peer_identity (&closest_peer ,
¤t_successor->finger_identity))
{
+ //FIXME: Is this a good place to return the stats.
if ((NULL != GDS_stats))
{
char *my_id_str;
uint64_t succ;
char *key;
-
+
my_id_str = GNUNET_strdup (GNUNET_i2s_full (&my_identity));
memcpy(&succ, ¤t_successor->finger_identity, sizeof(uint64_t));
GNUNET_asprintf (&key, "XDHT:%s:", my_id_str);
GNUNET_STATISTICS_set (GDS_stats, key, succ, 0);
GNUNET_free (key);
}
+
+ if(0 == successor_times)
+ {
+// successor_times = 3;
+ verify_successor_next_send_time =
+ GNUNET_TIME_STD_BACKOFF (verify_successor_next_send_time);
+ }
+ else
+ successor_times--;
+
+
+ if (send_verify_successor_task == NULL)
+ send_verify_successor_task =
+ GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
+ &send_verify_successor_message,
+ NULL);
return;
}
-
+
/* Probable successor is the closest peer.*/
if(trail_length > 0)
{
GNUNET_assert(NULL != GNUNET_CONTAINER_multipeermap_get(friend_peermap,
&probable_successor));
}
-
+
trail_me_to_probable_succ_len = 0;
trail_me_to_probable_succ =
check_trail_me_to_probable_succ (probable_successor,
add_new_finger (probable_successor, trail_me_to_probable_succ,
trail_me_to_probable_succ_len, trail_id, 0);
-
- GDS_NEIGHBOURS_send_notify_new_successor (my_identity, probable_successor,
- trail_me_to_probable_succ,
- trail_me_to_probable_succ_len,
- trail_id,
- target_friend);
- return;
+
+ struct SendNotifyContext *notify_ctx;
+
+ notify_ctx = GNUNET_new(struct SendNotifyContext);
+
+ notify_ctx->source_peer = my_identity;
+ notify_ctx->successor = probable_successor;
+ notify_ctx->successor_trail =
+ GNUNET_malloc(sizeof(struct GNUNET_PeerIdentity) * trail_me_to_probable_succ_len);
+ memcpy(notify_ctx->successor_trail, trail_me_to_probable_succ,
+ sizeof(struct GNUNET_PeerIdentity) * trail_me_to_probable_succ_len);
+ notify_ctx->successor_trail_length = trail_me_to_probable_succ_len;
+ notify_ctx->succesor_trail_id = trail_id;
+ notify_ctx->target_friend = target_friend;
+ notify_ctx->num_retries_scheduled = 0;
+ GNUNET_free_non_null (trail_me_to_probable_succ);
+
+ // TODO: Check if we should verify before schedule if already scheduled.
+ GNUNET_SCHEDULER_add_now(&send_notify_new_successor, (void*)notify_ctx);
}
+
+void
+send_notify_new_successor (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext
+ * tc)
+{
+ struct SendNotifyContext *ctx = (struct SendNotifyContext *) cls;
+
+ GDS_NEIGHBOURS_send_notify_new_successor (ctx->source_peer,
+ ctx->successor,
+ ctx->successor_trail,
+ ctx->successor_trail_length,
+ ctx->succesor_trail_id,
+ ctx->target_friend);
+
+ if (0 == ctx->num_retries_scheduled &&
+ send_notify_new_successor_retry_task != NULL)
+ {
+ // Result from previous notify successos hasn't arrived, so the retry task
+ // hasn't been cancelled! Already a new notify successor must be called.
+ // We will cancel the retry request.
+ struct SendNotifyContext *old_notify_ctx;
+ old_notify_ctx = GNUNET_SCHEDULER_cancel(send_notify_new_successor_retry_task);
+ GNUNET_free (old_notify_ctx->successor_trail);
+ GNUNET_free (old_notify_ctx);
+ send_notify_new_successor_retry_task = NULL;
+ }
+
+ ctx->num_retries_scheduled++;
+ send_notify_new_successor_retry_task = GNUNET_SCHEDULER_add_delayed(notify_successor_retry_time,
+ &send_notify_new_successor,
+ cls);
+}
+
/*
- * FIXME: Check for duplicate elements everywhere when you are making
- * trails.
* Core handle for p2p verify successor result messages.
* @param cls closure
* @param message message
size_t msize;
msize = ntohs (message->size);
- /* We send a trail to reach from old successor to new successor, if
- * old_successor != new_successor.*/
if (msize < sizeof (struct PeerVerifySuccessorResultMessage))
{
GNUNET_break_op (0);
}
vsrm = (const struct PeerVerifySuccessorResultMessage *) message;
- trail_length = (msize - sizeof (struct PeerVerifySuccessorResultMessage))/
- sizeof (struct GNUNET_PeerIdentity);
-
if ((msize - sizeof (struct PeerVerifySuccessorResultMessage)) %
sizeof (struct GNUNET_PeerIdentity) != 0)
{
GNUNET_break_op (0);
return GNUNET_OK;
}
+ trail_length = (msize - sizeof (struct PeerVerifySuccessorResultMessage))/
+ sizeof (struct GNUNET_PeerIdentity);
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail = (const struct GNUNET_PeerIdentity *) &vsrm[1];
querying_peer = vsrm->querying_peer;
trail_direction = ntohl (vsrm->trail_direction);
trail_id = vsrm->trail_id;
probable_successor = vsrm->probable_successor;
current_successor = vsrm->current_successor;
-
- verify_successor_next_send_time =
- GNUNET_TIME_STD_BACKOFF(verify_successor_next_send_time);
+
/* I am the querying_peer. */
if(0 == (GNUNET_CRYPTO_cmp_peer_identity (&querying_peer, &my_identity)))
{
+ /* Cancel Retry Task */
+ if (NULL != send_verify_successor_retry_task)
+ {
+ struct VerifySuccessorContext *ctx;
+ ctx = GNUNET_SCHEDULER_cancel(send_verify_successor_retry_task);
+ GNUNET_free(ctx);
+ send_verify_successor_retry_task = NULL;
+ }
compare_and_update_successor (current_successor,
probable_successor, trail, trail_length);
return GNUNET_OK;
}
-
+
/*If you are not the querying peer then pass on the message */
if(NULL == (next_hop =
GDS_ROUTING_get_next_hop (trail_id, trail_direction)))
{
+ /* Here it may happen that source peer has found a new successor, and removed
+ the trail, Hence no entry found in the routing table. Fail silently.*/
DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line",
GNUNET_i2s(&my_identity), GNUNET_h2s(&trail_id), __LINE__);
GNUNET_break_op(0);
uint32_t trail_length;
msize = ntohs (message->size);
-
- /* We have the trail to reach from source to new successor. */
if (msize < sizeof (struct PeerNotifyNewSuccessorMessage))
{
GNUNET_break_op (0);
return GNUNET_YES;
}
-
nsm = (const struct PeerNotifyNewSuccessorMessage *) message;
- trail_length = (msize - sizeof (struct PeerNotifyNewSuccessorMessage))/
- sizeof (struct GNUNET_PeerIdentity);
if ((msize - sizeof (struct PeerNotifyNewSuccessorMessage)) %
sizeof (struct GNUNET_PeerIdentity) != 0)
{
GNUNET_break_op (0);
return GNUNET_OK;
}
-
+ trail_length = (msize - sizeof (struct PeerNotifyNewSuccessorMessage))/
+ sizeof (struct GNUNET_PeerIdentity);
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail = (struct GNUNET_PeerIdentity *) &nsm[1];
source = nsm->source_peer;
new_successor = nsm->new_successor;
trail_id = nsm->trail_id;
-
+
/* I am the new_successor to source_peer. */
if ( 0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &new_successor))
{
if(trail_length > 0)
GNUNET_assert(0 == GNUNET_CRYPTO_cmp_peer_identity(&trail[trail_length - 1],
peer));
- else
+ else
GNUNET_assert(0 == GNUNET_CRYPTO_cmp_peer_identity(&source, peer));
-
+
compare_and_update_predecessor (source, trail, trail_length);
+ target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap, peer);
+ GNUNET_assert (NULL != target_friend);
+ GDS_NEIGHBOURS_send_notify_succcessor_confirmation (trail_id,
+ GDS_ROUTING_DEST_TO_SRC,
+ target_friend);
return GNUNET_OK;
}
next_hop = new_successor;
else
next_hop = trail[my_index + 1];
- /* Add an entry in routing table for trail from source to its new successor. */
- GNUNET_assert (GNUNET_OK == GDS_ROUTING_add (trail_id, *peer, next_hop));
- GNUNET_assert (NULL !=
- (target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap, &next_hop)));
+
+ GDS_ROUTING_add(trail_id, *peer, next_hop);
+ target_friend =
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap, &next_hop);
+ if (NULL == target_friend)
+ {
+ GNUNET_break(0);
+ return GNUNET_OK;
+ }
GDS_NEIGHBOURS_send_notify_new_successor (source, new_successor, trail,
trail_length,
trail_id, target_friend);
}
+/**
+ * Core handler for P2P notify successor message
+ * @param cls closure
+ * @param message message
+ * @param peer peer identity this notification is about
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static int
+handle_dht_p2p_notify_succ_confirmation (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_MessageHeader *message)
+{
+ const struct PeerNotifyConfirmationMessage *notify_confirmation;
+ enum GDS_ROUTING_trail_direction trail_direction;
+ struct GNUNET_HashCode trail_id;
+ struct FriendInfo *target_friend;
+ struct GNUNET_PeerIdentity *next_hop;
+ size_t msize;
+
+ msize = ntohs (message->size);
+
+ if (msize != sizeof (struct PeerNotifyConfirmationMessage))
+ {
+ GNUNET_break_op (0);
+ return GNUNET_OK;
+ }
+ GNUNET_STATISTICS_update (GDS_stats,
+ gettext_noop
+ ("# Bytes received from other peers"), msize,
+ GNUNET_NO);
+
+ notify_confirmation = (const struct PeerNotifyConfirmationMessage *) message;
+ trail_direction = ntohl (notify_confirmation->trail_direction);
+ trail_id = notify_confirmation->trail_id;
+
+ next_hop = GDS_ROUTING_get_next_hop (trail_id, trail_direction);
+ if (NULL == next_hop)
+ {
+ /* The source of notify new successor, might have found even a better
+ successor. In that case it send a trail teardown message, and hence,
+ the next hop is NULL. */
+ //Fixme: Add some print to confirm the above theory.
+ return GNUNET_OK;
+ }
+
+ /* I peer which sent the notify successor message to the successor. */
+ if (0 == GNUNET_CRYPTO_cmp_peer_identity (next_hop, &my_identity))
+ {
+ /*
+ * Schedule another round of verify sucessor with your current successor
+ * which may or may not be source of this message. This message is used
+ * only to ensure that we have a path setup to reach to our successor.
+ */
+
+ // TODO: cancel schedule of notify_successor_retry_task
+ if (send_notify_new_successor_retry_task != NULL)
+ {
+ struct SendNotifyContext *notify_ctx;
+ notify_ctx = GNUNET_SCHEDULER_cancel(send_notify_new_successor_retry_task);
+ GNUNET_free (notify_ctx->successor_trail);
+ GNUNET_free (notify_ctx);
+ send_notify_new_successor_retry_task = NULL;
+ }
+ if (send_verify_successor_task == NULL)
+ {
+ verify_successor_next_send_time.rel_value_us =
+ DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us +
+ GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+ DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us);
+ send_verify_successor_task =
+ GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
+ &send_verify_successor_message,
+ NULL);
+ }
+ }
+ else
+ {
+ target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap, next_hop);
+ if (NULL == target_friend)
+ {
+ DEBUG ("\n friend not found, line number = %d",__LINE__);
+ return GNUNET_SYSERR;
+ }
+ GDS_NEIGHBOURS_send_notify_succcessor_confirmation (trail_id,
+ GDS_ROUTING_DEST_TO_SRC,
+ target_friend);
+ }
+ return GNUNET_OK;
+}
+
+
/**
* Core handler for P2P trail rejection message
* @param cls closure
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail_peer_list = (const struct GNUNET_PeerIdentity *)&trail_rejection[1];
is_predecessor = ntohl (trail_rejection->is_predecessor);
congestion_timeout = trail_rejection->congestion_time;
/* First remove yourself from the trail. */
unsigned int new_trail_length = trail_length - 1;
struct GNUNET_PeerIdentity trail[new_trail_length];
-
+
memcpy (trail, trail_peer_list, new_trail_length * sizeof(struct GNUNET_PeerIdentity));
if (0 == trail_length)
next_peer = source;
}
struct Closest_Peer successor;
- successor = find_successor (ultimate_destination_finger_value, is_predecessor);
+ successor = find_local_best_known_next_hop (ultimate_destination_finger_value, is_predecessor);
/* Am I the final destination? */
if (0 == (GNUNET_CRYPTO_cmp_peer_identity (&successor.best_known_destination,
/*Here you are already part of trail. Copy the trail removing yourself. */
unsigned int new_trail_length = trail_length - 1;
struct GNUNET_PeerIdentity trail[new_trail_length];
-
+
memcpy (trail, trail_peer_list, new_trail_length * sizeof(struct GNUNET_PeerIdentity));
-
+
if (0 == new_trail_length)
next_peer = source;
else
}
target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap, &next_peer);
-
+
if (NULL == target_friend)
{
DEBUG ("\nLINE = %d ,No friend found.",__LINE__);
{
/* Here I was already part of trail. So no need to add. */
target_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
+ GNUNET_CONTAINER_multipeermap_get (friend_peermap,
&successor.next_hop);
if (NULL == target_friend)
{
GNUNET_break(0);
return GNUNET_OK;
}
-
+
GDS_NEIGHBOURS_send_trail_setup (source,
ultimate_destination_finger_value,
successor.best_known_destination,
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail_teardown = (const struct PeerTrailTearDownMessage *) message;
trail_direction = ntohl (trail_teardown->trail_direction);
trail_id = trail_teardown->trail_id;
/* If not final destination, then send a trail teardown message to next hop.*/
GNUNET_assert (NULL != GNUNET_CONTAINER_multipeermap_get (friend_peermap, next_hop));
GNUNET_assert (GNUNET_YES == GDS_ROUTING_remove_trail (trail_id));
- GDS_NEIGHBOURS_send_trail_teardown (trail_id, trail_direction, *next_hop);
+ GDS_NEIGHBOURS_send_trail_teardown (&trail_id, trail_direction, next_hop);
}
return GNUNET_OK;
gettext_noop
("# Bytes received from other peers"), msize,
GNUNET_NO);
-
+
trail = (const struct GNUNET_PeerIdentity *)&add_trail[1];
destination_peer = add_trail->destination_peer;
source_peer = add_trail->source_peer;
trail_id = add_trail->trail_id;
- //FIXME: add a check that sender peer is not malicious. Make it a generic
- // function so that it can be used in all other functions where we need the
- // same functionality.
-
/* I am not the destination of the trail. */
if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &destination_peer))
{
next_hop = trail[my_index + 1];
}
/* Add in your routing table. */
- GNUNET_assert (GNUNET_OK == GDS_ROUTING_add (trail_id, next_hop, *peer));
+ GNUNET_assert (GNUNET_OK == GDS_ROUTING_add (trail_id, *peer, next_hop));
+ //GNUNET_assert (GNUNET_OK == GDS_ROUTING_add (trail_id, next_hop, *peer));
GNUNET_assert (NULL !=
(target_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap, &next_hop)));
remove_matching_trails (const struct GNUNET_PeerIdentity *disconnected_friend,
struct FingerInfo *finger)
{
+ struct GNUNET_PeerIdentity *next_hop;
+ struct FriendInfo *remove_friend;
+ struct Trail *current_trail;
unsigned int matching_trails_count = 0;
int i;
/* Iterate over all the trails of finger. */
for (i = 0; i < finger->trails_count; i++)
{
- struct Trail *current_trail;
current_trail = &finger->trail_list[i];
- //FIXME: This assertion fails if we have gap in trail list from o to trails count.
- GNUNET_assert (GNUNET_YES == current_trail->is_present);
+ if (GNUNET_NO == current_trail->is_present)
+ continue;
+
/* First friend to reach to finger is disconnected_peer. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (¤t_trail->trail_head->peer,
disconnected_friend))
{
- struct GNUNET_PeerIdentity *next_hop;
- struct FriendInfo *remove_friend;
-
- GNUNET_assert (NULL !=
- (remove_friend =
+ remove_friend =
GNUNET_CONTAINER_multipeermap_get (friend_peermap,
- disconnected_friend)));
+ disconnected_friend);
+ GNUNET_assert (NULL != remove_friend);
next_hop = GDS_ROUTING_get_next_hop (current_trail->trail_id,
GDS_ROUTING_SRC_TO_DEST);
if (NULL != next_hop)
{
GNUNET_assert (0 == (GNUNET_CRYPTO_cmp_peer_identity (disconnected_friend,
- next_hop)));
+ next_hop)));
GNUNET_assert (GNUNET_YES == GDS_ROUTING_remove_trail (current_trail->trail_id));
}
matching_trails_count++;
remove_matching_fingers (const struct GNUNET_PeerIdentity *disconnected_peer)
{
struct FingerInfo *current_finger;
- struct FriendInfo *remove_friend;
int removed_trails_count;
int i;
for (i = 0; i < MAX_FINGERS; i++)
{
current_finger = &finger_table[i];
-
- /* No finger stored at this trail index. */
+
+ /* No finger stored at this trail index or I am the finger. */
if ((GNUNET_NO == current_finger->is_present) ||
(0 == GNUNET_CRYPTO_cmp_peer_identity (¤t_finger->finger_identity,
- &my_identity)))
+ &my_identity)))
continue;
-
+
/* Is disconnected_peer a finger? */
if (0 == GNUNET_CRYPTO_cmp_peer_identity (disconnected_peer,
¤t_finger->finger_identity))
{
- struct GNUNET_PeerIdentity *next_hop;
- struct GNUNET_HashCode trail_id;
-
- GNUNET_assert (0 == current_finger->trail_list[0].trail_length);
- GNUNET_assert (GNUNET_YES == (current_finger->trail_list[0].is_present));
- trail_id = current_finger->trail_list[0].trail_id;
-
- if(NULL !=
- (next_hop =
- GDS_ROUTING_get_next_hop (trail_id, GDS_ROUTING_SRC_TO_DEST)))
- {
- GNUNET_assert (GNUNET_YES == GDS_ROUTING_remove_trail (trail_id));
- GNUNET_assert (NULL !=
- (remove_friend =
- GNUNET_CONTAINER_multipeermap_get (friend_peermap,
- disconnected_peer)));
- }
- current_finger->trail_list[0].is_present = GNUNET_NO;
- current_finger->is_present = GNUNET_NO;
- memset ((void *)&finger_table[i], 0, sizeof (finger_table[i]));
- continue;
+ remove_existing_finger (current_finger, i);
}
/* If finger is a friend but not disconnected_friend, then continue. */
struct FriendInfo *remove_friend;
struct P2PPendingMessage *pos;
unsigned int discarded;
-
+
/* If disconnected to own identity, then return. */
if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
return;
DEBUG("\n friend already disconnected.");
return;
}
-
+
remove_matching_fingers (peer);
GNUNET_assert (GNUNET_SYSERR != GDS_ROUTING_remove_trail_by_peer (peer));
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (friend_peermap,
peer,
remove_friend));
-
+
/* Remove all the messages queued in pending list of this peer is discarded.*/
if (remove_friend->th != NULL)
{
GNUNET_CORE_notify_transmit_ready_cancel(remove_friend->th);
remove_friend->th = NULL;
}
-
+
discarded = 0;
while (NULL != (pos = remove_friend->head))
{
discarded++;
GNUNET_free (pos);
}
-
+
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Queued messages discarded (peer disconnected)"),
discarded, GNUNET_NO);
//GNUNET_free (remove_friend);
-
+
if (0 != GNUNET_CONTAINER_multipeermap_size (friend_peermap))
return;
- if (GNUNET_SCHEDULER_NO_TASK != find_finger_trail_task)
+ if (NULL != find_finger_trail_task)
{
GNUNET_SCHEDULER_cancel (find_finger_trail_task);
- find_finger_trail_task = GNUNET_SCHEDULER_NO_TASK;
+ find_finger_trail_task = NULL;
}
else
GNUNET_break (0);
friend = GNUNET_new (struct FriendInfo);
friend->id = *peer_identity;
+
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (friend_peermap,
peer_identity, friend,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- /* SUPUS: We should add a congestion timestamp on the friend, so that it is
- selected after some time out. This is to ensure that both peers have added
- each other as their friend. */
- /* got a first connection, good time to start with FIND FINGER TRAIL requests...*/
- if (GNUNET_SCHEDULER_NO_TASK == find_finger_trail_task)
+ /* FIXME: now we are not making a distinction between fingers which are friends
+ * also.But later, we should add a congestion timestamp on the friend, so that it is
+ * selected after some time out. This is to ensure that both peers have added
+ * each other as their friend. */
+ /* Got a first connection, good time to start with FIND FINGER TRAIL requests...*/
+ if (NULL == find_finger_trail_task)
{
find_finger_trail_task = GNUNET_SCHEDULER_add_now (&send_find_finger_trail_message, NULL);
}
{&handle_dht_p2p_trail_teardown, GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_TEARDOWN,
sizeof (struct PeerTrailTearDownMessage)},
{&handle_dht_p2p_add_trail, GNUNET_MESSAGE_TYPE_XDHT_P2P_ADD_TRAIL, 0},
+ {&handle_dht_p2p_notify_succ_confirmation, GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_SUCCESSOR_CONFIRMATION,
+ sizeof (struct PeerNotifyConfirmationMessage)},
{NULL, 0, 0}
};
-
+
#if ENABLE_MALICIOUS
act_malicious = 0;
#endif
-
+
core_api =
GNUNET_CORE_connect (GDS_cfg, NULL, &core_init, &handle_core_connect,
&handle_core_disconnect, NULL, GNUNET_NO, NULL,
GNUNET_NO, core_handlers);
-
+
if (NULL == core_api)
return GNUNET_SYSERR;
- //TODO: check size of this peer map?
+ //TODO: check size of this peer map?
friend_peermap = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_NO);
finger_table_init ();
-
+ successor_times = 10;
+ fingers_round_count = 5;
find_finger_trail_task_next_send_time.rel_value_us =
DHT_FIND_FINGER_TRAIL_INTERVAL.rel_value_us +
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
DHT_FIND_FINGER_TRAIL_INTERVAL.rel_value_us);
-
- verify_successor_next_send_time.rel_value_us =
+
+ verify_successor_next_send_time.rel_value_us =
DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us +
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
- DHT_FIND_FINGER_TRAIL_INTERVAL.rel_value_us);
-
+ DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us);
+
+ verify_successor_retry_time.rel_value_us =
+ DHT_SEND_VERIFY_SUCCESSOR_RETRY_INTERVAL.rel_value_us +
+ GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+ DHT_SEND_VERIFY_SUCCESSOR_RETRY_INTERVAL.rel_value_us);
+
+ notify_successor_retry_time.rel_value_us =
+ DHT_SEND_NOTIFY_SUCCESSOR_RETRY_INTERVAL.rel_value_us +
+ GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+ DHT_SEND_NOTIFY_SUCCESSOR_RETRY_INTERVAL.rel_value_us);
+
+
return GNUNET_OK;
}
+
/**
- * Free the memory held up by trails of a finger.
+ * Free the memory held up by trails of a finger.
*/
static void
delete_finger_table_entries()
{
unsigned int i;
unsigned int j;
-
+
for(i = 0; i < MAX_FINGERS; i++)
{
- if(GNUNET_NO == finger_table[i].is_present)
- continue;
-
- /* FREE ALL THE TRAILS. */
- /* SUPUS: Here in free trail, it will delete the entry
- if there is a trail with trail length != 0.OKAY */
- for(j = 0; j < finger_table[i].trails_count; j++)
+ if(GNUNET_YES == finger_table[i].is_present)
{
- free_trail(&finger_table[i].trail_list[i]);
+ for(j = 0; j < finger_table[i].trails_count; j++)
+ free_trail(&finger_table[i].trail_list[j]);
}
}
}
core_api = NULL;
delete_finger_table_entries();
-
GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (friend_peermap));
GNUNET_CONTAINER_multipeermap_destroy (friend_peermap);
friend_peermap = NULL;
- if (GNUNET_SCHEDULER_NO_TASK != find_finger_trail_task)
+ if (NULL != find_finger_trail_task)
{
- GNUNET_break (0);
GNUNET_SCHEDULER_cancel (find_finger_trail_task);
- find_finger_trail_task = GNUNET_SCHEDULER_NO_TASK;
+ find_finger_trail_task = NULL;
}
- if (GNUNET_SCHEDULER_NO_TASK != send_verify_successor_task)
+ if (NULL != send_verify_successor_task)
{
GNUNET_SCHEDULER_cancel (send_verify_successor_task);
- send_verify_successor_task = GNUNET_SCHEDULER_NO_TASK;
+ send_verify_successor_task = NULL;
+ }
+
+ if (NULL != send_verify_successor_retry_task)
+ {
+ struct VerifySuccessorContext *ctx;
+ ctx = GNUNET_SCHEDULER_cancel (send_verify_successor_retry_task);
+ GNUNET_free(ctx);
+ send_verify_successor_retry_task = NULL;
+ }
+
+ if (send_notify_new_successor_retry_task != NULL)
+ {
+ struct SendNotifyContext *notify_ctx;
+ notify_ctx = GNUNET_SCHEDULER_cancel(send_notify_new_successor_retry_task);
+ GNUNET_free (notify_ctx->successor_trail);
+ GNUNET_free (notify_ctx);
+ send_notify_new_successor_retry_task = NULL;
}
}
projects / oweals / gnunet.git / blobdiff