[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r33050 - in gnunet/src: dht include
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r33050 - in gnunet/src: dht include |
|
Date: |
Sun, 13 Apr 2014 13:54:17 +0200 |
Author: supriti
Date: 2014-04-13 13:54:17 +0200 (Sun, 13 Apr 2014)
New Revision: 33050
Modified:
gnunet/src/dht/gnunet-service-xdht_clients.c
gnunet/src/dht/gnunet-service-xdht_datacache.c
gnunet/src/dht/gnunet-service-xdht_datacache.h
gnunet/src/dht/gnunet-service-xdht_neighbours.c
gnunet/src/dht/gnunet-service-xdht_neighbours.h
gnunet/src/dht/gnunet-service-xdht_routing.c
gnunet/src/dht/gnunet-service-xdht_routing.h
gnunet/src/include/gnunet_protocols.h
Log:
Framework for trail rejection and threshold on links
first phase changes for get.
Modified: gnunet/src/dht/gnunet-service-xdht_clients.c
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_clients.c 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_clients.c 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -843,15 +843,14 @@
GNUNET_h2s (&cqr->key),
cqr->replication,
cqr->seen_replies_count);
+
+ /* FIXME: Here I am passing NULL for parameters check if its correct or
+ not. */
#if 0
- /* FIXME: Change it to your own handle_get. */
GDS_NEIGHBOURS_handle_get (cqr->type, cqr->msg_options, cqr->replication,
- 0 /* hop count */ ,
- &cqr->key, cqr->xquery, cqr->xquery_size,
reply_bf,
- reply_bf_mutator, peer_bf);
-#endif
-
-
+ 0 /* hop count */ ,NULL, NULL, 0,
+ &cqr->key, NULL, NULL, 0);
+#endif
/* exponential back-off for retries.
* max GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD (15 min) */
cqr->retry_frequency = GNUNET_TIME_STD_BACKOFF (cqr->retry_frequency);
@@ -940,14 +939,14 @@
ntohl (put_msg->type),
size - sizeof (struct GNUNET_DHT_ClientPutMessage),
&put_msg[1]);
- /* store locally */
+ /* FIXME: Should we store locally? */
GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh (put_msg->expiration),
&put_msg->key, 0, NULL, ntohl (put_msg->type),
size - sizeof (struct GNUNET_DHT_ClientPutMessage),
&put_msg[1]);
- /* FIXME: At the moment we don't use replication in x-vine. But keep it for
- time being. Check all the fields again. */
+ /* FIXME: Is it correct to pass NULL for current destination and current
+ source. */
GDS_NEIGHBOURS_handle_put (ntohl (put_msg->type), ntohl (put_msg->options),
ntohl (put_msg->desired_replication_level),
GNUNET_TIME_absolute_ntoh (put_msg->expiration),
@@ -955,7 +954,7 @@
&put_msg->key, 0, NULL, &put_msg[1],
size -
sizeof (struct GNUNET_DHT_ClientPutMessage),
- NULL, 0, NULL);
+ NULL, NULL, 0, NULL);
GDS_CLIENTS_process_put (ntohl (put_msg->options),
ntohl (put_msg->type),
@@ -1047,9 +1046,12 @@
if (GNUNET_SCHEDULER_NO_TASK != retry_task)
GNUNET_SCHEDULER_cancel (retry_task);
retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task, NULL);
- /* perform local lookup */
+ /* perform local lookup
+ * FIXME: Should we call it here or in neighbours file. And how to handle
+ * this case where we may get the data locally. You really need to rethink
+ * this design again.
GDS_DATACACHE_handle_get (&get->key, cqr->type, cqr->xquery, xquery_size,
- NULL, 0);
+ NULL, 0); */
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
Modified: gnunet/src/dht/gnunet-service-xdht_datacache.c
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_datacache.c 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_datacache.c 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -19,7 +19,7 @@
*/
/**
- * @file dht/gnunet-service-xdht_datacache.c
+ * @file dht/gnunet-service-dht_datacache.c
* @brief GNUnet DHT service's datacache integration
* @author Christian Grothoff
* @author Nathan Evans
@@ -29,7 +29,8 @@
#include "gnunet-service-xdht_clients.h"
#include "gnunet-service-xdht_datacache.h"
#include "gnunet-service-xdht_routing.h"
-#include "gnunet-service-xdht.h"
+#include "gnunet-service-xdht_neighbours.h"
+#include "gnunet-service-dht.h"
#define LOG(kind,...) GNUNET_log_from (kind, "dht-dtcache",__VA_ARGS__)
@@ -61,7 +62,7 @@
const void *data)
{
int r;
-
+
if (NULL == datacache)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
@@ -84,7 +85,28 @@
GNUNET_h2s (key), data_size, r, put_path_length);
}
+/**
+ * List of peers in the get path.
+ */
+struct GetPath
+{
+ /**
+ * Pointer to next item in the list
+ */
+ struct GetPath *next;
+
+ /**
+ * Pointer to previous item in the list
+ */
+ struct GetPath *prev;
+
+ /**
+ * An element in the get path.
+ */
+ struct GNUNET_PeerIdentity peer;
+};
+
/**
* Context containing information about a GET request.
*/
@@ -114,11 +136,37 @@
* Mutator value for the reply_bf, see gnunet_block_lib.h
*/
uint32_t reply_bf_mutator;
-
+
/**
+ * Total number of peers in get path.
+ */
+ unsigned int get_path_length;
+
+ /**
* Return value to give back.
*/
enum GNUNET_BLOCK_EvaluationResult eval;
+
+ /**
+ *
+ */
+ unsigned int current_trail_index;
+
+ /**
+ *
+ */
+ struct GNUNET_PeerIdentity next_hop;
+
+ /**
+ * Head of trail to reach this finger.
+ */
+ struct GetPath *head;
+
+ /**
+ * Tail of trail to reach this finger.
+ */
+ struct GetPath *tail;
+ /* get_path */
};
@@ -163,9 +211,22 @@
GNUNET_STATISTICS_update (GDS_stats,
gettext_noop
("# Good RESULTS found in datacache"), 1,
- GNUNET_NO);
- /* GDS_CLIENTS_handle_reply (exp, key, 0, NULL, put_path_length, put_path,
- type, size, data);*/
+ GNUNET_NO);
+ struct GNUNET_PeerIdentity *get_path;
+ get_path = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ struct GetPath *iterator;
+ iterator = ctx->head;
+ int i = 0;
+ while (i < ctx->get_path_length)
+ {
+ memcpy (&get_path[i], &(iterator->peer), sizeof (struct
GNUNET_PeerIdentity));
+ i++;
+ iterator = iterator->next;
+ }
+ GDS_NEIGHBOURS_send_get_result (exp, key, put_path_length, put_path,
+ type, size, data, get_path,
ctx->get_path_length,
+ ctx->current_trail_index,
&(ctx->next_hop));
+
/* forward to other peers */
GDS_ROUTING_process (type, exp, key, put_path_length, put_path, 0, NULL,
data, size);
@@ -217,13 +278,19 @@
* @param reply_bf where the reply bf is (to be) stored, possibly updated, can
be NULL
* @param reply_bf_mutator mutation value for reply_bf
* @return evaluation result for the local replies
+ * @get_path_length Total number of peers in get path
+ * @get_path Peers in get path.
*/
enum GNUNET_BLOCK_EvaluationResult
GDS_DATACACHE_handle_get (const struct GNUNET_HashCode * key,
enum GNUNET_BLOCK_Type type, const void *xquery,
size_t xquery_size,
struct GNUNET_CONTAINER_BloomFilter **reply_bf,
- uint32_t reply_bf_mutator)
+ uint32_t reply_bf_mutator,
+ uint32_t get_path_length,
+ struct GNUNET_PeerIdentity *get_path,
+ unsigned int current_trail_index,
+ struct GNUNET_PeerIdentity *next_hop)
{
struct GetRequestContext ctx;
unsigned int r;
@@ -239,6 +306,23 @@
ctx.xquery_size = xquery_size;
ctx.reply_bf = reply_bf;
ctx.reply_bf_mutator = reply_bf_mutator;
+ ctx.get_path_length = get_path_length;
+ memcpy (&(ctx.next_hop), next_hop, sizeof (struct GNUNET_PeerIdentity));
+ ctx.current_trail_index = current_trail_index;
+ /* FIXME: add the get path into ctx and then call gds_neighbours_handle_get*/
+ int i = 0;
+ while (i < get_path_length)
+ {
+ struct GetPath *element;
+ element = GNUNET_malloc (sizeof (struct GetPath));
+ element->next = NULL;
+ element->prev = NULL;
+
+ memcpy (&(element->peer), &get_path[i], sizeof(struct
GNUNET_PeerIdentity));
+ GNUNET_CONTAINER_DLL_insert_tail(ctx.head, ctx.tail, element);
+ i++;
+ }
+
r = GNUNET_DATACACHE_get (datacache, key, type, &datacache_get_iterator,
&ctx);
LOG (GNUNET_ERROR_TYPE_DEBUG,
Modified: gnunet/src/dht/gnunet-service-xdht_datacache.h
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_datacache.h 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_datacache.h 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -19,13 +19,13 @@
*/
/**
- * @file dht/gnunet-service-xdht_datacache.h
+ * @file dht/gnunet-service-dht_datacache.h
* @brief GNUnet DHT service's datacache integration
* @author Christian Grothoff
* @author Nathan Evans
*/
-#ifndef GNUNET_SERVICE_XDHT_DATACACHE_H
-#define GNUNET_SERVICE_XDHT_DATACACHE_H
+#ifndef GNUNET_SERVICE_DHT_DATACACHE_H
+#define GNUNET_SERVICE_DHT_DATACACHE_H
#include "gnunet_util_lib.h"
#include "gnunet_block_lib.h"
@@ -67,7 +67,11 @@
enum GNUNET_BLOCK_Type type, const void *xquery,
size_t xquery_size,
struct GNUNET_CONTAINER_BloomFilter **reply_bf,
- uint32_t reply_bf_mutator);
+ uint32_t reply_bf_mutator,
+ uint32_t get_path_length,
+ struct GNUNET_PeerIdentity *get_path,
+ unsigned int current_trail_index,
+ struct GNUNET_PeerIdentity *next_hop);
/**
Modified: gnunet/src/dht/gnunet-service-xdht_neighbours.c
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_neighbours.c 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_neighbours.c 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -49,6 +49,8 @@
#include "dht.h"
/* TODO:
+ * 1. when should we use const struct and replace wherever needed.
+ * 2. use assert for each function where you need to check the return value.
1. Use a global array of all known peers in find_successor, Only when
a new peer is added in finger or friend peer map, then re calculate
the array. Or else use the old one.
@@ -118,7 +120,7 @@
/**
* Content type.
*/
- uint32_t type GNUNET_PACKED;
+ uint32_t block_type GNUNET_PACKED;
/**
* Hop count
@@ -135,18 +137,18 @@
*/
uint32_t put_path_length GNUNET_PACKED;
- /**
- * Source peer
- */
- struct GNUNET_PeerIdentity source_peer;
-
/**
- * Current destination
+ * Current destination to which this message is forwarded.
*/
struct GNUNET_PeerIdentity current_destination;
+ /**
+ * Peer whose finger is current_destination.
+ */
+ struct GNUNET_PeerIdentity current_source;
+
/**
- * Current destination type
+ * current_destination type.
*/
enum current_destination_type current_destination_type;
@@ -179,6 +181,11 @@
struct GNUNET_MessageHeader header;
/**
+ * The type for the data.
+ */
+ uint32_t type GNUNET_PACKED;
+
+ /**
* Peer which is sending get result message.
*/
struct GNUNET_PeerIdentity source_peer;
@@ -192,8 +199,18 @@
* Current index in get path.
*/
unsigned int current_path_index;
+ /**
+ * Number of peers recorded in the outgoing path from source to the
+ * storgage location of this message.
+ */
+ uint32_t put_path_length GNUNET_PACKED;
/**
+ * When does this entry expire?
+ */
+ struct GNUNET_TIME_AbsoluteNBO expiration;
+
+ /**
* Length of the GET path that follows (if tracked).
*/
uint32_t get_path_length GNUNET_PACKED;
@@ -228,33 +245,44 @@
struct GNUNET_MessageHeader header;
/**
- * Source peer
+ * Processing options
*/
- struct GNUNET_PeerIdentity source_peer;
+ uint32_t options GNUNET_PACKED;
/**
+ * Desired content type.
+ */
+ uint32_t block_type GNUNET_PACKED;
+
+ /**
+ * Hop count
+ */
+ uint32_t hop_count GNUNET_PACKED;
+
+ /**
+ * Desired replication level for this request.
+ */
+ uint32_t desired_replication_level GNUNET_PACKED;
+
+ /**
* Total number of peers in get path.
*/
unsigned int get_path_length;
/**
- *
+ * Peer which is an intermediate destination.
*/
struct GNUNET_PeerIdentity current_destination;
-
+
/**
- *
+ * Source for which current_destination is the finger.
*/
- enum current_destination_type current_dest_type;
+ struct GNUNET_PeerIdentity current_source;
/**
- * Unique identifier of the request.
+ * Type of current destination
*/
- uint64_t request_id;
- /**
- * When does the content expire?
- */
- struct GNUNET_TIME_AbsoluteNBO expiration_time;
+ enum current_destination_type current_dest_type;
/**
* The key we are looking for.
@@ -298,6 +326,13 @@
struct GNUNET_PeerIdentity current_destination;
/**
+ * In case the packet is forwarded to an intermediate finger, then
+ * current_source contains the peer id whose finger is the intermediate
+ * finger. In case the packet is forwarded to a friend, then it is NULL.
+ */
+ struct GNUNET_PeerIdentity current_source;
+
+ /**
* Index into finger peer map.
*/
unsigned int finger_map_index;
@@ -348,7 +383,45 @@
};
+/**
+ *
+ */
+struct PeerTrailRejectionMessage
+{
+ /**
+ * Type: #GNUNET_MESSAGE_TYPE_DHT_P2P_TRAIL_REJECTION
+ */
+ struct GNUNET_MessageHeader header;
+
+ /**
+ * Source peer which wants to set up the trail.
+ */
+ struct GNUNET_PeerIdentity source_peer;
+
+ /**
+ * Finger identity value.
+ */
+ uint64_t finger_identity;
+
+ /**
+ * Peer which sent trail rejection message.
+ */
+ struct GNUNET_PeerIdentity congested_peer;
+
+ /**
+ * Index in finger peer map of source peer.
+ */
+ unsigned int finger_map_index;
+
+ /**
+ * Total number of peers in the trail.
+ */
+ unsigned int trail_length;
+
+ /* trail_list */
+};
+
/**
* P2P Verify Successor message.
*/
@@ -573,7 +646,7 @@
unsigned int finger_map_index;
/**
- * Total number of entries in trail from [me,finger]
+ * Total number of entries in trail from (me,finger]
*/
unsigned int trail_length;
@@ -614,6 +687,30 @@
/**
+ * FIXME: Think of better comments.
+ * An entry in Failed_Trail_List
+ */
+struct FailedTrail
+{
+ /**
+ * Source peer which was trying to setup up the trail to @a
destination_finger_value
+ */
+ struct GNUNET_PeerIdentity source_peer;
+
+ /**
+ * Value to which we were trying to find the closest successor.
+ */
+ uint64_t destination_finger_value;
+
+ /**
+ * Peer which has crossed the threshold limit on its routing table size.
+ */
+ struct GNUNET_PeerIdentity congested_peer;
+
+};
+
+
+/**
* Task that sends FIND FINGER TRAIL requests.
*/
static GNUNET_SCHEDULER_TaskIdentifier find_finger_trail_task;
@@ -640,6 +737,11 @@
static struct GNUNET_CONTAINER_MultiPeerMap *finger_peermap;
/**
+ * Hash maps of all the trail which failed due to a congested peer.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *failed_trail_list;
+
+/**
* Handle to CORE.
*/
static struct GNUNET_CORE_Handle *core_api;
@@ -754,11 +856,13 @@
}
-/**
+/**FIXME: add better comment for current_source which shows its relation
+ * with current_destination.
* Construct a trail message and forward it to a friend.
* @param source_peer Peer which wants to set up the trail to one of its
finger.
* @param destination_finger Value whose successor we are searching the
network.
* @param current_destination Peer which gets this message.
+ * @param current_source Peer for which current_destination is its finger.
* @param target_friend Current friend to which this message should be
forwarded.
* @param trail_length Numbers of peers in the trail.
* @param trail_peer_list peers this request has traversed so far
@@ -769,6 +873,7 @@
GDS_NEIGHBOURS_send_trail_setup (struct GNUNET_PeerIdentity *source_peer,
uint64_t destination_finger,
struct GNUNET_PeerIdentity
*current_destination,
+ struct GNUNET_PeerIdentity *current_source,
struct FriendInfo *target_friend,
unsigned int trail_length,
struct GNUNET_PeerIdentity *trail_peer_list,
@@ -805,6 +910,9 @@
memcpy (&(tsm->destination_finger), &destination_finger, sizeof (uint64_t));
memcpy (&(tsm->source_peer), source_peer, sizeof (struct
GNUNET_PeerIdentity));
memcpy (&(tsm->current_destination), current_destination, sizeof (struct
GNUNET_PeerIdentity));
+ /* FIXME: Is it correct to use NULL here for comparison? */
+ if (current_source != NULL)
+ memcpy (&(tsm->current_source), current_source, sizeof (struct
GNUNET_PeerIdentity));
tsm->current_destination_type = htonl (type);
tsm->trail_length = htonl (trail_length);
tsm->finger_map_index = htonl (finger_map_index);
@@ -1075,7 +1183,7 @@
* @return Friend
*/
static struct FriendInfo *
-select_random_friend()
+select_random_friend (struct GNUNET_PeerIdentity *congested_peer)
{
unsigned int current_size;
unsigned int *index;
@@ -1099,7 +1207,18 @@
}
if(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next
(iter,&key_ret,(const void **)&friend))
+ {
+ /* TODO: Here you have chosen a random friend. Now you should check the
size
+ of its routing table size, and if its more than threshold, then check
which
+ of the entries has trail length greater than trail length threshold. we
+ should without checking the routing table size also we should check the
+ trail with trail length greater than threshold. then
+ you should try to find a new route through this new node that has joined
in
+ only for those finger entries whose trail length is greater than
threshold.
+ But I don't want the new node to wait for this process to get over. so
+ should i declare a function which will be called after some interval.*/
return friend;
+ }
else
return NULL;
}
@@ -1251,17 +1370,18 @@
}
select_friend:
- /* FIXME: Here should we choose randomly or not. */
- target_friend = select_random_friend();
+ target_friend = select_random_friend (NULL);
finger_map_index = current_finger_index;
current_finger_index = ( current_finger_index + 1) % MAX_FINGERS;
if(NULL != target_friend)
{
+ /* FIXME: Here I am passing NULL for current source, is it correct?
+ also, we set the current source only if current_destination_type
+ is finger. */
GDS_NEIGHBOURS_send_trail_setup (&my_identity, *finger_identity,
&(target_friend->id),
- target_friend, 0, NULL,
- finger_map_index, FRIEND);
+ NULL, target_friend, 0, NULL,
finger_map_index, FRIEND);
}
/* FIXME: How to decide the correct interval? */
@@ -1390,7 +1510,6 @@
{
my_identity = *identity;
-#if 0
/* SUPU TEST CODE */
struct GNUNET_PeerIdentity *print_peer;
print_peer = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
@@ -1398,7 +1517,7 @@
FPRINTF (stderr,_("\nSUPU %s, %s, %d,my_identity = %s"),
__FILE__, __func__,__LINE__, GNUNET_i2s (print_peer));
/* SUPU TEST CODE ENDS */
-#endif
+
}
@@ -1443,7 +1562,6 @@
* @param new_finger
* @return
*/
-#if 0
static int
compare_finger_identity (struct GNUNET_PeerIdentity *existing_finger,
struct GNUNET_PeerIdentity *new_finger)
@@ -1453,16 +1571,16 @@
(existing_finger == new_finger) ? 0 : -1;
return ret;
}
-#endif
+
/**
- * FIXME: Not sure of the logic to find the correct predecessor.
+ * FIXME: Not sure of the logic to find the correct predecessor
+ * I think logic of this code is wrong everything else seems to be correct.
* Given two finger identities, find the closest predecessor.
* @param existing_predecessor
* @param new_predecessor
* @return
*/
-#if 0
static int
compare_predecessor(struct GNUNET_PeerIdentity *existing_predecessor,
struct GNUNET_PeerIdentity *new_predecessor)
@@ -1472,11 +1590,11 @@
(existing_predecessor == new_predecessor) ? 0 : -1;
return ret;
}
-#endif
+
+
/*
* Add an entry in finger table.
- * Add an entry into finger table
* @param finger_identity Peer identity of finger
* @param finger_trail Trail to reach the finger
* @param trail_length Number of peers in the trail.
@@ -1489,15 +1607,15 @@
unsigned int finger_map_index)
{
struct FingerInfo *new_finger_entry;
+ struct GNUNET_PeerIdentity key_ret;
int i;
-#if 0
struct GNUNET_CONTAINER_MultiPeerMapIterator *finger_iter;
- struct GNUNET_PeerIdentity key_ret;
struct FingerInfo *existing_finger;
int finger_index;
- int i;
-
+ /* SUPU Here we trying to check if we already have an entry. If yes then we
+ can keep two trails for redundant routing. if they are different then we
+ need to choose the closest one. and remove the other one. */
finger_iter = GNUNET_CONTAINER_multipeermap_iterator_create
(finger_peermap);
for (finger_index = 0; finger_index < GNUNET_CONTAINER_multipeermap_size
(finger_peermap); finger_index++)
@@ -1505,25 +1623,43 @@
if(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (finger_iter,
&key_ret,
(const void
**)&existing_finger))
{
- /* If we already have an entry at the finger map index. */
if ((finger_map_index == existing_finger->finger_map_index))
{
- /* Check if the finger entry are same. */
if (0 == GNUNET_CRYPTO_cmp_peer_identity
(&(existing_finger->finger_identity),finger_identity))
{
- FPRINTF (stderr,_("\nSUPU %s, %s, %d"), __FILE__,
__func__,__LINE__);
+ FPRINTF (stderr,_("\nSUPU Entries are same. %s, %s, %d"),
__FILE__, __func__,__LINE__);
+ /* FIXME: Here you should check if the trail is same. If yes then
don't add the entry. it
+ seems to be very suboptimal. */
+ if ((existing_finger->trail_length) == trail_length)
+ {
+ struct TrailPeerList *iterate;
+ iterate = existing_finger->head;
+ int k;
+ k = 0;
+ while (k < trail_length)
+ {
+ if (0 == GNUNET_CRYPTO_cmp_peer_identity (&(iterate->peer),
&finger_trail[k]))
+ {
+ k++;
+ iterate = iterate->next;
+ }
+ }
+ if (k == trail_length)
+ return;
+ else
+ goto add_new_entry;
+ }
goto add_new_entry;
}
else
{
- /* FIXME: here you should have something better to check which finger
- is closer one. */
int ret;
if (finger_map_index == 1)
{
- FPRINTF (stderr,_("\nSUPU %s, %s, %d"), __FILE__,
__func__,__LINE__);
+ FPRINTF (stderr,_("\nSUPUP Predecessor are different %s, %s, %d"),
__FILE__, __func__,__LINE__);
ret = compare_predecessor (&(existing_finger->finger_identity),
finger_identity);
+ goto add_new_entry;
}
else
{
@@ -1533,7 +1669,7 @@
}
if (ret > 0)
{
- FPRINTF (stderr,_("\nSUPU %s, %s, %d"), __FILE__,
__func__,__LINE__);
+ FPRINTF (stderr,_("\nSUPU Adding the new one and removing the old
one %s, %s, %d"), __FILE__, __func__,__LINE__);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (finger_peermap,
&(existing_finger->finger_identity),
@@ -1542,7 +1678,7 @@
}
else
{
- FPRINTF (stderr,_("\nSUPU %s, %s, %d"), __FILE__,
__func__,__LINE__);
+ FPRINTF (stderr,_("\nSUPU Nothing to do return %s, %s, %d"),
__FILE__, __func__,__LINE__);
return;
}
}
@@ -1551,36 +1687,81 @@
}
add_new_entry:
-#endif
new_finger_entry = GNUNET_malloc (sizeof (struct FingerInfo));
memcpy (&(new_finger_entry->finger_identity), finger_identity, sizeof
(struct GNUNET_PeerIdentity));
+ new_finger_entry->finger_map_index = finger_map_index;
- i = 0;
- while (i < trail_length)
+ if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity, finger_identity))
{
- struct TrailPeerList *element;
- element = GNUNET_malloc (sizeof (struct TrailPeerList));
- element->next = NULL;
- element->prev = NULL;
+ /* I am the finger */
+ new_finger_entry->trail_length = 0;
+ }
+ else
+ {
+ i = 0;
+ while (i < trail_length)
+ {
+ struct TrailPeerList *element;
+ element = GNUNET_malloc (sizeof (struct TrailPeerList));
+ element->next = NULL;
+ element->prev = NULL;
- memcpy (&(element->peer), &finger_trail[i], sizeof(struct
GNUNET_PeerIdentity));
- GNUNET_CONTAINER_DLL_insert_tail(new_finger_entry->head,
new_finger_entry->tail, element);
- i++;
+ memcpy (&(element->peer), &finger_trail[i], sizeof(struct
GNUNET_PeerIdentity));
+ GNUNET_CONTAINER_DLL_insert_tail(new_finger_entry->head,
new_finger_entry->tail, element);
+ i++;
+ }
+ new_finger_entry->trail_length = trail_length;
}
- new_finger_entry->finger_map_index = finger_map_index;
- new_finger_entry->trail_length = trail_length;
-
/* FIXME: Here we are keeping multiple hashmap option so that there are
multiple routes to reach to same finger, redundant routing.
- * Also same peers could be our fingers for different finger map index */
+ * Also same peers could be our fingers for different finger map index
+ * Should we handle the case where we have same fingers at the different
+ * finger index but with different trail to reach. */
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (finger_peermap,
&(new_finger_entry->finger_identity),
new_finger_entry,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); /* Fixme: change to multiple */
+ /* SUPU TEST CODE */
+ /* Here I want to iterate over finger peer map, print its id and the trail
+ to reach to the finger. */
+ int test_index;
+ struct GNUNET_CONTAINER_MultiPeerMapIterator *test_iter;
+ struct FingerInfo *test_finger;
+ test_iter = GNUNET_CONTAINER_multipeermap_iterator_create (finger_peermap);
+ FPRINTF (stderr,_("\nSUPU #### %s, %s, %d, size = %d####"),__FILE__,
__func__,__LINE__,GNUNET_CONTAINER_multipeermap_size (finger_peermap));
+ for (test_index = 0; test_index < GNUNET_CONTAINER_multipeermap_size
(finger_peermap); test_index++)
+ {
+ FPRINTF (stderr,_("\nSUPU *********%s, %s, %d, %d
entry*********"),__FILE__, __func__,__LINE__,test_index);
+ if(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (test_iter,
&key_ret,
+ (const void
**)&test_finger))
+ {
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d "),__FILE__, __func__,__LINE__);
+ struct GNUNET_PeerIdentity *print_peer;
+ struct TrailPeerList *iterator;
+ int z;
+ iterator = GNUNET_malloc (sizeof (struct TrailPeerList));
+ print_peer = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ memcpy (print_peer, &(test_finger->finger_identity), sizeof (struct
GNUNET_PeerIdentity));
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, finger_index = %d"), __FILE__,
__func__,__LINE__,test_finger->finger_map_index);
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, finger_identity = %s"),
+ __FILE__, __func__,__LINE__, GNUNET_i2s (print_peer));
+ iterator = test_finger->head;
+ z = 0;
+ while (z < test_finger->trail_length)
+ {
+ memcpy (print_peer, &(iterator->peer), sizeof (struct
GNUNET_PeerIdentity));
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, trail[%d] = %s"),__FILE__,
__func__,__LINE__,z,GNUNET_i2s (print_peer));
+ z++;
+ iterator = iterator->next;
+ }
+ }
+ }
+ FPRINTF (stderr,_("\nSUPU End of loop%s, %s, %d"),__FILE__,
__func__,__LINE__);
+ /* SUPU TEST CODE ENDS */
+
-
if (1 == GNUNET_CONTAINER_multipeermap_size (finger_peermap)
&& (new_finger_entry->finger_map_index!= 1))
{
@@ -1774,13 +1955,12 @@
/**
- * FIXME:
- * 1. Do we have an expiration time for get request? Yes but I don't know its
- * use case and how to handle it
* Send a get message to selected target friend. If target friend in NULL,
* then search for a target friend.
- * @param request_id Unique ID identifying this request
- * @param source_peer Peer which started get request
+ * @param block_type type of the block
+ * @param options routing options
+ * @param desired_replication_level desired replication count
+ * @param hop_count how many hops did this request traverse so far?
* @param get_peer_path Peer list to reach to final destination which contains
the data.
* @param get_path_length Total numbers of peer in get_path
* @param key Key key for the content
@@ -1789,12 +1969,16 @@
* @param current_dest_type Type of current destination can be either FRIEND
or FINGER
*/
void
-GDS_NEIGHBOURS_handle_get (struct GNUNET_PeerIdentity *source_peer,
+GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type block_type,
+ enum GNUNET_DHT_RouteOption options,
+ uint32_t desired_replication_level,
+ uint32_t hop_count,
struct GNUNET_PeerIdentity *get_peer_path,
unsigned int get_path_length,
struct GNUNET_HashCode *key,
struct GNUNET_PeerIdentity *target_peer,
struct GNUNET_PeerIdentity *current_destination,
+ struct GNUNET_PeerIdentity *current_source,
enum current_destination_type *current_dest_type)
{
struct PeerGetMessage *get_request;
@@ -1818,32 +2002,33 @@
/* FIXME: Is this correct comparison? */
if (NULL == target_peer)
{
- /* This is the first call made from client file. */
+ /* We have received the request from the client file and we don't know
+ to which peer should we forward the message to. */
struct GNUNET_PeerIdentity *next_hop;
next_hop = find_successor (key_value, current_destination,
current_dest_type);
if (*current_dest_type == MY_ID)
{
- struct GNUNET_PeerIdentity *destination_peer;
get_path = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
memcpy (get_path, &my_identity, sizeof (struct GNUNET_PeerIdentity));
get_path_length = 1;
- destination_peer = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
- memcpy (destination_peer, source_peer, sizeof (struct
GNUNET_PeerIdentity));
- /* FIXME: We enter in this part of code only when this is our first
- call from client file. In client file we already have done datacache_get
- and if we already have the result. So, ideally code should never reach
- here. Remove it after verifying. */
- /* FIXME: Call datacache_get but remove after verified above thing. */
- GDS_NEIGHBOURS_send_get_result (&my_identity,get_path, get_path_length,
- key,destination_peer, 0,
- NULL,0,NULL);
-
+ /* FIXME: At the moment I am just passing null,0 for values which I don't
+ have. Also, handle return type. Modify this function and pass get path
+ and get path length and then in datacache_handle. here in this case
+ you can diretly call gds_client_handle_reply. */
+#if 0
+ GDS_DATACACHE_handle_get (&(get_request->key),(get_request->block_type),
+ get_path, get_path_length,get_path_length -
1,NULL);
+#endif
return;
}
- else
+ else
{
- /* Find the friend corresponding to next_hop */
+ if (*current_dest_type == FINGER)
+ {
+ memcpy (current_source, &my_identity, sizeof (struct
GNUNET_PeerIdentity));
+ }
+
target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
next_hop);
}
}
@@ -1852,16 +2037,16 @@
pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
pending->importance = 0; /* FIXME */
- /* FIXME: Do we have an expiration time for get request */
get_request = (struct PeerGetMessage *) &pending[1];
pending->msg = &get_request->header;
get_request->header.size = htons (msize);
get_request->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_GET);
get_request->get_path_length = htonl (get_path_length);
get_request->key = *key;
-
- memcpy (&(get_request->source_peer), source_peer, sizeof (struct
GNUNET_PeerIdentity));
memcpy (&(get_request->current_destination), current_destination, sizeof
(struct GNUNET_PeerIdentity));
+ /* FIXME: Is this comparison correct? */
+ if (current_source != NULL)
+ memcpy (&(get_request->current_source), current_source, sizeof (struct
GNUNET_PeerIdentity));
get_request->current_dest_type = htonl (*current_dest_type);
get_path = (struct GNUNET_PeerIdentity *) &get_request[1];
memcpy (get_path, get_peer_path, get_path_length * sizeof (struct
GNUNET_PeerIdentity));
@@ -1873,13 +2058,45 @@
/**
- * FIXME: In this function, you just find the target friend and send the
message
- * to next peer. In handle_dht_p2p_put, you should check the options and type
- * and check if you are final destination or not. if not then find the next
- * destination and send the message forward.
- * @param type type of the block
+ * FIXME: Here you should update the fields of struct PeerGetResultMessage.
+ * At the end of this message you should add the data and get path and send
+ * to the original requesting client. and there you should call
GDS_CLIENT_handle_reply
+ * with correct parameter.
+ * @param expiration
+ * @param key
+ * @param get_path_length
+ * @param get_path
+ * @param put_path_length
+ * @param put_path
+ * @param type
+ * @param data_size
+ * @param data
+ */
+void
+GDS_NEIGHBOURS_datacache_get (struct GNUNET_TIME_Absolute expiration,
+ const struct GNUNET_HashCode *key,
+ unsigned int get_path_length,
+ const struct GNUNET_PeerIdentity *get_path,
+ unsigned int put_path_length,
+ const struct GNUNET_PeerIdentity *put_path,
+ enum GNUNET_BLOCK_Type type, size_t data_size,
+ const void *data)
+{
+ /* Here you don't have the get path and get path length. you should call
+ some function get those values and update the message and send them. */
+}
+
+
+/**
+ * TODO: In case of put, you add the peer in the peer list in
handle_dht_p2p_put.
+ * Verify that the addition is correct and we are adding peers correctly and
incrementing
+ * the trail length correctly.
+ * Handle a put request from client file. If I am the final destination,
+ * do a put else forward the message to next peer.
+ * @param block_type type of the block
* @param options routing options
- * @param desired_replication_level desired replication count
+ * @param desired_replication_level desired replication count, 0 for current
+ * implementation of X-Vine.
* @param expiration_time when does the content expire
* @param hop_count how many hops has this message traversed so far
* @param key key for the content
@@ -1887,12 +2104,13 @@
* @param put_path peers this request has traversed so far (if tracked)
* @param data payload to store
* @param data_size number of bytes in @a data
- * @param current_destination
- * @param dest_type
- * @param target_peer_id
+ * @param current_destination intermediate destination of the packet.
+ * @param current_source source for which @a current_destination is
destination.
+ * @param dest_type type of @a current_destination.
+ * @param target_peer_id Next peer to forward the message to.
*/
void
-GDS_NEIGHBOURS_handle_put (enum GNUNET_BLOCK_Type type,
+GDS_NEIGHBOURS_handle_put (enum GNUNET_BLOCK_Type block_type,
enum GNUNET_DHT_RouteOption options,
uint32_t desired_replication_level,
struct GNUNET_TIME_Absolute expiration_time,
@@ -1902,6 +2120,7 @@
struct GNUNET_PeerIdentity *put_path,
const void *data, size_t data_size,
struct GNUNET_PeerIdentity *current_destination,
+ struct GNUNET_PeerIdentity *current_source,
enum current_destination_type dest_type,
struct GNUNET_PeerIdentity *target_peer)
{
@@ -1936,22 +2155,23 @@
So, you need to search for the next peer to send this message to. */
struct GNUNET_PeerIdentity *next_hop;
- next_hop = find_successor (key_value, current_dest, &dest_type);
-
-
+ next_hop = find_successor (key_value, current_dest, &dest_type);
if (dest_type == MY_ID)
{
- /* FIXME: How do we handle different block types? */
- /* FIXME: Here depending on the replication level choose 'r' successors
- to this peer and send put to all of these peers. */
- //replicate_put();
+ /* FIXME: Choose one place to do datacache_put. I am doing put only if
its
+ destination so I will do no put operation
+ in the client file.*/
GDS_DATACACHE_handle_put (expiration_time, key, put_path_length,
put_path,
- type, data_size, data);
+ block_type, data_size, data);
return;
}
else
{
/* Find the friend corresponding to next_hop */
+ if (dest_type == FINGER)
+ {
+ memcpy (current_source, &my_identity, sizeof (struct
GNUNET_PeerIdentity));
+ }
target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
next_hop);
}
}
@@ -1966,11 +2186,19 @@
ppm->header.size = htons (msize);
ppm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_PUT);
ppm->options = htonl (options);
- ppm->type = htonl (type);
+ ppm->block_type = htonl (block_type);
ppm->hop_count = htonl (hop_count + 1);
ppm->desired_replication_level = htonl (desired_replication_level);
ppm->put_path_length = htonl (put_path_length);
ppm->expiration_time = GNUNET_TIME_absolute_hton (expiration_time);
+ /* FIXME: Here I am checking if we have a value in current_source then only
copy.
+ I am not sure if this checking is correct or not. */
+ if (current_source != NULL)
+ memcpy (&(ppm->current_source), current_source, sizeof (struct
GNUNET_PeerIdentity));
+
+ /* FIXME: here current_destination is the parameter, current_dest is what you
+ get when you call find_successor. names don't do justice to the function.
+ Please change it*/
if (current_destination != NULL)
memcpy (&(ppm->current_destination), current_destination, sizeof (struct
GNUNET_PeerIdentity));
else
@@ -1979,8 +2207,14 @@
ppm->key = *key;
pp = (struct GNUNET_PeerIdentity *) &ppm[1];
- memcpy (pp, put_path,
- sizeof (struct GNUNET_PeerIdentity) * put_path_length);
+ /* FIXME: Is this comparison correct? Do we need this comparison. What
happens
+ in the case put_path_length is 0 and put_path is NULL, then at run time
+ memcpy will fail. And I am not sure if comparing NULL is correct or not. */
+ if (put_path_length != 0)
+ {
+ memcpy (pp, put_path,
+ sizeof (struct GNUNET_PeerIdentity) * put_path_length);
+ }
memcpy (&pp[put_path_length], data, data_size);
GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail,
pending);
target_friend->pending_count++;
@@ -1989,29 +2223,36 @@
/**
+ * FIXME: I am removing source peer as the first element in the trail
+ * is source identity.
+ * If I am adding myself when I am source then I don't need destination
+ * peer in get but if I am not adding then I need it. At the moment I am
removing
+ * it but will check later if its wrong.
* Send get result back to requesting client.
- * @param source_peer
+ * @param expiration when will the reply expire
+ * @param key the query this reply is for
+ * @param get_path_length number of peers in @a get_path
+ * @param get_path path the reply took on get
+ * @param put_path_length number of peers in @a put_path
+ * @param put_path path the reply took on put
+ * @param type type of the reply
+ * @param data_size number of bytes in @a data
+ * @param data application payload data
* @param get_path
- * @param target_friend
* @param get_path_length
- * @param key
- * @param destination_peer
- * @param current_path_index
- * @param data
- * @param data_size
*/
void
-GDS_NEIGHBOURS_send_get_result (struct GNUNET_PeerIdentity *source_peer,
+GDS_NEIGHBOURS_send_get_result (struct GNUNET_TIME_Absolute expiration,
+ const struct GNUNET_HashCode *key,
+ unsigned int put_path_length,
+ const struct GNUNET_PeerIdentity *put_path,
+ enum GNUNET_BLOCK_Type type, size_t data_size,
+ const void *data,
struct GNUNET_PeerIdentity *get_path,
unsigned int get_path_length,
- struct GNUNET_HashCode *key,
- struct GNUNET_PeerIdentity *destination_peer,
unsigned int current_path_index,
- const void *data, size_t data_size,
struct GNUNET_PeerIdentity *next_hop)
{
- /* Add get_result into pending message and send the data to target friend.
- make a call GDS_CLIENTS_process_get_result() with all the fields. */
struct PeerGetResultMessage *get_result;
struct GNUNET_PeerIdentity *get_result_path;
struct P2PPendingMessage *pending;
@@ -2026,7 +2267,9 @@
GNUNET_break (0);
return;
}
-
+ /* GET_REULT should have all the things which we want to pass in
client_handle_reply
+ put path put path length get path get length data data_size. and rest things
+ are required to reach to the correct peer. */
pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
pending->importance = 0; /* FIXME */
/* FIXME: Should we add an expiration time like in put message. */
@@ -2034,8 +2277,6 @@
pending->msg = &get_result->header;
get_result->header.size = htons (msize);
get_result->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_GET_RESULT);
- memcpy (&(get_result->source_peer), source_peer, sizeof (struct
GNUNET_PeerIdentity));
- memcpy (&(get_result->destination_peer), destination_peer, sizeof (struct
GNUNET_PeerIdentity));
get_result->current_path_index = current_path_index;
get_result->key = *key;
@@ -2066,8 +2307,8 @@
the requesting client and send back the result. */
struct PeerGetResultMessage *get_result;
struct GNUNET_PeerIdentity *get_path;
- void *payload;
- size_t payload_size;
+ //void *payload;
+ //size_t payload_size;
size_t msize;
unsigned int getlen;
int current_path_index;
@@ -2092,10 +2333,11 @@
return GNUNET_YES;
}
+ /* FIXME: Get the put_path */
get_path = (struct GNUNET_PeerIdentity *) &get_result[1];
- payload = &get_path[getlen];
- payload_size = msize - (sizeof (struct PeerGetResultMessage) +
- getlen * sizeof (struct GNUNET_PeerIdentity));
+ //payload = &get_path[getlen];
+ /* payload_size = msize - (sizeof (struct PeerGetResultMessage) +
+ getlen * sizeof (struct GNUNET_PeerIdentity));*/
current_path_index = ntohl (get_result->current_path_index);
/* Here you just have to check if you are the destination or not if not
@@ -2120,18 +2362,19 @@
if (current_path_index != 0)
current_path_index--;
-
- GDS_NEIGHBOURS_send_get_result (&my_identity, get_path,
-
getlen,&(get_result->key),&(get_result->destination_peer),
- current_path_index,
- payload, payload_size, next_hop);
+#if 0
+ GDS_NEIGHBOURS_send_get_result ((get_result->expiration), get_result->key,
+ get_result->put_path_length, put_path,
+ get_result->type, payload, payload_size
+ get_path, getlen,current_path_index,
+ next_hop);
+#endif
return GNUNET_YES;
}
return GNUNET_SYSERR;
}
-
/**
* Core handler for p2p put requests.
*
@@ -2151,7 +2394,6 @@
enum GNUNET_DHT_RouteOption options;
enum current_destination_type current_dst_type;
struct GNUNET_PeerIdentity *current_destination;
- struct GNUNET_PeerIdentity *source_peer;
struct GNUNET_PeerIdentity *next_hop;
struct GNUNET_HashCode test_key;
uint64_t key_value;
@@ -2180,36 +2422,33 @@
payload_size = msize - (sizeof (struct PeerPutMessage) +
putlen * sizeof (struct GNUNET_PeerIdentity));
- /* FIXME: I don't understand what exactly are we doing here. */
- switch (GNUNET_BLOCK_get_key
- (GDS_block_context, ntohl (put->type), payload, payload_size,
- &test_key))
+ switch (GNUNET_BLOCK_get_key (GDS_block_context, ntohl (put->block_type),
+ payload, payload_size, &test_key))
{
- case GNUNET_YES:
- if (0 != memcmp (&test_key, &put->key, sizeof (struct GNUNET_HashCode)))
- {
- char *put_s = GNUNET_strdup (GNUNET_h2s_full (&put->key));
+ case GNUNET_YES:
+ if (0 != memcmp (&test_key, &put->key, sizeof (struct GNUNET_HashCode)))
+ {
+ char *put_s = GNUNET_strdup (GNUNET_h2s_full (&put->key));
+ GNUNET_break_op (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "PUT with key `%s' for block with key %s\n",
+ put_s, GNUNET_h2s_full (&test_key));
+ GNUNET_free (put_s);
+ return GNUNET_YES;
+ }
+ break;
+ case GNUNET_NO:
GNUNET_break_op (0);
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "PUT with key `%s' for block with key %s\n",
- put_s, GNUNET_h2s_full (&test_key));
- GNUNET_free (put_s);
return GNUNET_YES;
- }
- break;
- case GNUNET_NO:
- GNUNET_break_op (0);
- return GNUNET_YES;
- case GNUNET_SYSERR:
- /* cannot verify, good luck */
- break;
+ case GNUNET_SYSERR:
+ /* cannot verify, good luck */
+ break;
}
- /* FIXME: This part is also not clear to me.*/
- if (ntohl (put->type) == GNUNET_BLOCK_TYPE_REGEX) /* FIXME: do for all tpyes
*/
+ if (ntohl (put->block_type) == GNUNET_BLOCK_TYPE_REGEX) /* FIXME: do for all
tpyes */
{
switch (GNUNET_BLOCK_evaluate (GDS_block_context,
- ntohl (put->type),
+ ntohl (put->block_type),
NULL, /* query */
NULL, 0, /* bloom filer */
NULL, 0, /* xquery */
@@ -2243,54 +2482,73 @@
else
putlen = 0;
- /* Copy the fields of message, call find successor or gds_routing_search,
- depending on the destination_type and if you are the final destination,
- do a datache put or if option is. else call gds_neighbours_handle_get with
- correct parameters. */
current_destination = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
memcpy (current_destination, &(put->current_destination), sizeof (struct
GNUNET_PeerIdentity));
current_dst_type = ntohl (put->current_destination_type);
memcpy (&key_value, &(put->key), sizeof (uint64_t));
- source_peer = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
- memcpy (source_peer, &(put->source_peer), sizeof (struct
GNUNET_PeerIdentity));
- if (current_dst_type == FRIEND)
- {
- next_hop = find_successor (key_value, current_destination,
¤t_dst_type);
- }
- else if (current_dst_type == FINGER)
- {
- next_hop = GDS_ROUTING_search (source_peer, current_destination, peer);
- }
+ if (current_dst_type == FRIEND)
+ {
+ next_hop = find_successor (key_value, current_destination,
¤t_dst_type);
+ }
+ else if (current_dst_type == FINGER)
+ {
+ if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
current_destination))
+ {
+ next_hop = find_successor (key_value, current_destination,
¤t_dst_type);
+ }
+ else
+ {
+ next_hop = GDS_ROUTING_search (&(put->current_source),
current_destination, peer);
+ current_dst_type = FRIEND;
+ }
+ }
- if (current_dst_type == MY_ID)
- {
- /* Here datacache_put*/
- /* FIXME: Here depending on replication, call replicate_put() to do the
- put operation on 'r' successors. */
- GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh (put->expiration_time),
- &(put->key),putlen, pp, ntohl (put->type),
payload_size,
- payload);
- return GNUNET_YES;
- }
- else
- {
- /* here call gds_neighbours*/
- GDS_NEIGHBOURS_handle_put (ntohl (put->type),ntohl (put->options),
- ntohl (put->desired_replication_level),
- GNUNET_TIME_absolute_ntoh
(put->expiration_time),
- ntohl (put->hop_count),&put->key, putlen,
- pp, payload, payload_size,
- current_destination, current_dst_type,
next_hop);
- return GNUNET_YES;
- }
+ if (current_dst_type == MY_ID)
+ {
+ GDS_DATACACHE_handle_put (GNUNET_TIME_absolute_ntoh
(put->expiration_time),
+ &(put->key),putlen, pp, ntohl (put->block_type),
+ payload_size, payload);
+ return GNUNET_YES;
+ }
+ else
+ {
+ struct GNUNET_PeerIdentity *current_source;
+ if (current_dst_type == FINGER)
+ {
+ current_source = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ memcpy (current_source, &my_identity, sizeof (struct
GNUNET_PeerIdentity));
+ }
+ else
+ current_source = NULL;
+
+ GDS_CLIENTS_process_put (options,
+ ntohl (put->block_type),
+ ntohl (put->hop_count),
+ ntohl (put->desired_replication_level),
+ putlen, pp,
+ GNUNET_TIME_absolute_ntoh (put->expiration_time),
+ &put->key,
+ payload,
+ payload_size);
+
+ GDS_NEIGHBOURS_handle_put (ntohl (put->block_type),ntohl (put->options),
+ ntohl (put->desired_replication_level),
+ GNUNET_TIME_absolute_ntoh
(put->expiration_time),
+ ntohl (put->hop_count),&put->key, putlen,
+ pp, payload, payload_size,
+ current_destination,
current_source,current_dst_type, next_hop);
+ return GNUNET_YES;
+ }
return GNUNET_SYSERR;
}
/**
- * FIXME: Handle expiration, options, block type, replication
- * referring the old code.
+ * FIXME
+ * 1. I don't do block evalute as it uses xquery and bf for evaluation.Is
+ * it okay if I just pass NULL. I am anyways going to pass NULL in case of
+ * datacache_get?
* Core handler for p2p get requests.
*
* @param cls closure
@@ -2306,9 +2564,11 @@
struct PeerGetMessage *get;
struct GNUNET_PeerIdentity *current_destination;
uint64_t key_value;
- enum current_destination_type cuurent_dest_type;
+ enum current_destination_type current_dest_type;
struct GNUNET_PeerIdentity *next_hop;
struct GNUNET_PeerIdentity *get_path;
+ enum GNUNET_BLOCK_Type block_type;
+ enum GNUNET_DHT_RouteOption options;
size_t msize;
unsigned int get_length;
@@ -2333,52 +2593,70 @@
return GNUNET_YES;
}
- get = (struct PeerGetMessage *) message;
current_destination = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
memcpy (current_destination, &(get->current_destination), sizeof (struct
GNUNET_PeerIdentity));
memcpy (&key_value, &(get->key), sizeof (uint64_t));
- cuurent_dest_type = ntohl (get->current_dest_type);
+ current_dest_type = ntohl (get->current_dest_type);
+ block_type = ntohl (get->block_type);
+ options = ntohl (get->options);
- if (cuurent_dest_type == FRIEND)
+ if (current_dest_type == FRIEND)
{
- next_hop = find_successor (key_value, current_destination,
&cuurent_dest_type);
+ next_hop = find_successor (key_value, current_destination,
¤t_dest_type);
}
- else if (cuurent_dest_type == FINGER)
+ else if (current_dest_type == FINGER)
{
- next_hop = GDS_ROUTING_search (&(get->source_peer), current_destination,
peer);
+ if (0 == GNUNET_CRYPTO_cmp_peer_identity (&my_identity,
current_destination))
+ {
+ next_hop = find_successor (key_value, current_destination,
¤t_dest_type);
+ }
+ else
+ {
+ next_hop = GDS_ROUTING_search (&(get->current_source),
current_destination, peer);
+ current_dest_type = FRIEND;
+ }
}
- if (cuurent_dest_type == MY_ID)
+ /* Add sender to get path */
+ struct GNUNET_PeerIdentity gp[get_length + 1];
+ memcpy (gp, get_path, get_length * sizeof (struct GNUNET_PeerIdentity));
+ gp[get_length + 1] = *peer;
+ get_length = get_length + 1;
+
+ if (current_dest_type == MY_ID)
{
- struct GNUNET_PeerIdentity *destination_peer;
- //struct GNUNET_PeerIdentity *next_hop;
- //int current_path_index;
-
- /* Add yourself to the get path, increment the get length. */
- destination_peer = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
- memcpy (destination_peer, &(get->source_peer), sizeof (struct
GNUNET_PeerIdentity));
- //current_path_index = get_length - 1;
-
- /* I am the final destination. Call GDS_NEIGHBOURS_send_get_result.
- * FIXME: Last parameters are data and data size. First implement
datacache get
- * and get the result and send the data. Also seach for the next friend to
pass
- * this message to. */
-#if 0
- /* FIXME: Here we should call GDS_CLIENT_handle_reply. */
- GDS_NEIGHBOURS_send_get_result (get->request_id, &my_identity, get_path,
- get_length,&(get->key), destination_peer,
current_path_index,
- NULL, 0, next_hop);
-#endif
+ struct GNUNET_PeerIdentity final_get_path[get_length+1];
+ memcpy (final_get_path, get_path, get_length * sizeof (struct
GNUNET_PeerIdentity));
+ memcpy (final_get_path, &my_identity, sizeof (struct GNUNET_PeerIdentity));
+ get_length = get_length + 1;
+ struct GNUNET_PeerIdentity *next_hop;
+ next_hop = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ /* FIXME: Check if we need to have a check on get length. */
+ memcpy (next_hop, &final_get_path[get_length-2], sizeof (struct
GNUNET_PeerIdentity));
+#if 0
+ GDS_DATACACHE_handle_get (&(get->key),(get->block_type),
+ final_get_path, get_length,get_length -
1,next_hop);
+#endif
return GNUNET_YES;
}
else
{
- /* FIXME: Add your self to the get path and increment the get length. */
+ struct GNUNET_PeerIdentity *current_source;
+ current_source = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ if (current_dest_type == FINGER)
+ {
+ memcpy (current_source, &my_identity, sizeof (struct
GNUNET_PeerIdentity));
+ }
+ else
+ /* FIXME: Is this correct? */
+ {
+ /* how to handle the case when we don't have any value for current
source.*/
+ }
- /* FIXME: Does it matter if the dest_type is friend or finger. */
- GDS_NEIGHBOURS_handle_get (&(get->source_peer), get_path,
+ GDS_NEIGHBOURS_handle_get (block_type, options,
get->desired_replication_level,
+ get->hop_count, gp,
get_length, &(get->key),next_hop,
- current_destination,&cuurent_dest_type);
+ current_destination,
&(get->current_source),¤t_dest_type);
return GNUNET_YES;
}
@@ -2386,6 +2664,57 @@
}
+
+/**
+ * Send tral rejection message
+ * @param source_peer Source peer which wants to set up the trail.
+ * @param finger_identity Finger identity to which it want to setup the trail.
+ * @param congested_peer Peer which has send trail rejection message
+ * @param next_hop Peer to which this message should be forwarded.
+ * @param finger_map_index
+ * @param trail_peer_list
+ * @param trail_length
+ */
+void
+GDS_NEIGHBOURS_send_trail_rejection_message(struct GNUNET_PeerIdentity
*source_peer,
+ uint64_t finger_identity,
+ struct GNUNET_PeerIdentity
*congested_peer,
+ const struct GNUNET_PeerIdentity
*next_hop,
+ unsigned int finger_map_index,
+ struct GNUNET_PeerIdentity
*trail_peer_list,
+ unsigned int trail_length)
+{
+ struct PeerTrailRejectionMessage *trail_rejection;
+ struct GNUNET_PeerIdentity *trail_list;
+ struct P2PPendingMessage *pending;
+ struct FriendInfo *target_friend;
+ size_t msize;
+
+ msize = sizeof (struct PeerTrailRejectionMessage);
+
+ pending = GNUNET_malloc (sizeof (struct P2PPendingMessage) + msize);
+ pending->importance = 0; /* FIXME */
+ pending->timeout = GNUNET_TIME_relative_to_absolute (GET_TIMEOUT);
+ trail_rejection = (struct PeerTrailRejectionMessage *) &pending[1];
+ pending->msg = &trail_rejection->header;
+ trail_rejection->header.size = htons (msize);
+ trail_rejection->header.type = htons
(GNUNET_MESSAGE_TYPE_DHT_P2P_TRAIL_SETUP);
+ memcpy (&(trail_rejection->source_peer), source_peer, sizeof (struct
GNUNET_PeerIdentity));
+ memcpy (&(trail_rejection->congested_peer), congested_peer, sizeof (struct
GNUNET_PeerIdentity));
+ memcpy (&(trail_rejection->finger_identity), &finger_identity, sizeof
(uint64_t));
+ trail_rejection->finger_map_index = htonl(finger_map_index);
+ trail_rejection->trail_length = htonl (trail_length);
+
+ trail_list = (struct GNUNET_PeerIdentity *)&trail_rejection[1];
+ memcpy (trail_list, trail_peer_list, trail_length * sizeof (struct
GNUNET_PeerIdentity));
+
+ target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap, next_hop);
+ GNUNET_CONTAINER_DLL_insert_tail (target_friend->head, target_friend->tail,
pending);
+ target_friend->pending_count++;
+ process_friend_queue (target_friend);
+}
+
+
/**
* Handle a PeerTrailSetupMessage.
* @param cls closure
@@ -2436,6 +2765,20 @@
current_destination = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
memcpy (current_destination, &(trail_setup->current_destination), sizeof
(struct GNUNET_PeerIdentity));
+ /* TODO:
+ each peer maintains a list of trail fail list. there it stores an entry with
+ source, finger identity it was trying, hop which rejected. it again call
+ select_random_friend but does not consider me. and starts trail setup
+ again. */
+ if (GDS_ROUTING_size() > 1)
+ {
+ /* Setup the trail rejection message and send the message to peer. */
+ /* FIXME: you need to pass the trail, trail length and finger map index. */
+ GDS_NEIGHBOURS_send_trail_rejection_message (&(trail_setup->source_peer),
+
trail_setup->destination_finger,
+ &my_identity, peer,
finger_map_index,
+ trail_peer_list,
trail_length);
+ }
/* Find the next hop to send the packet to. */
if (current_dest_type == FRIEND)
{
@@ -2452,7 +2795,7 @@
if (0 != (GNUNET_CRYPTO_cmp_peer_identity
(&(trail_setup->current_destination),
&my_identity)))
{
- next_hop = GDS_ROUTING_search (&(trail_setup->source_peer),
+ next_hop = GDS_ROUTING_search (&(trail_setup->current_source),
&(trail_setup->current_destination),
peer);
/* As an optimization, find the successor from the find successor and
compare both the ids to find the closest peer. */
@@ -2509,37 +2852,28 @@
return GNUNET_YES;
}
- else if (next_hop == NULL)
- {
- return GNUNET_SYSERR;
- }
else
{
- target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
next_hop);
- if(current_dest_type == FINGER)
+ struct GNUNET_PeerIdentity *current_source;
+ current_source = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ if (current_dest_type == FINGER)
{
- /* FIXME: Here it can even return err if routing entries have crossed the
- threshold. In such a case, you should send back a trail setup fail message
- to node just before your. THen its the responsiblity of node before you
- to find an alternate path to reach to the current_desintation which
doesnot
- involve you.*/
-
- if ( GNUNET_SYSERR == GDS_ROUTING_add (&(trail_setup->source_peer),
-
&(trail_setup->current_destination),
- next_hop, peer))
- {
- //trail_setup_rejection()--> add to a list of fail trails and start
- // a new search rejecting this peer.
- }
+ memcpy (current_source, &my_identity, sizeof (struct
GNUNET_PeerIdentity));
}
-
+ else
+ current_source = NULL;
+
+ target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
next_hop);
+ /* FiXME: Is it correct to use null value for current source. */
GDS_NEIGHBOURS_send_trail_setup (&(trail_setup->source_peer),
trail_setup->destination_finger,
- current_destination, target_friend,
trail_length,
- peer_list, finger_map_index,
current_dest_type);
+ current_destination,current_source,
+ target_friend, trail_length, peer_list,
+ finger_map_index, current_dest_type);
return GNUNET_YES;
}
+
return GNUNET_SYSERR;
}
@@ -2592,25 +2926,11 @@
if ( 0 == (GNUNET_CRYPTO_cmp_peer_identity
(&(trail_result->destination_peer),
&my_identity)))
{
-#if 0
- /* I don't remember why I have written this code. */
- if (finger_map_index == 1)
- {
- struct GNUNET_PeerIdentity *new_trail_list;
- new_trail_list = invert_trail_list (&(trail_result->finger_identity),
- trail_peer_list, trail_length);
- finger_table_add (&(trail_result->finger_identity), new_trail_list,
trail_length,
- finger_map_index);
- return GNUNET_YES;
- }
- else
- {
-#endif
finger_table_add (&(trail_result->finger_identity), trail_peer_list,
trail_length,
finger_map_index);
return GNUNET_YES;
- //}
+
}
else
{
@@ -2625,7 +2945,13 @@
{
memcpy (next_hop, &(trail_peer_list[current_trail_index-1]),sizeof
(struct GNUNET_PeerIdentity));
}
-
+
+
+ /* If trail length = 2, it means that destination and source peer are
friends
+ Then don't add an entry. */
+ if (trail_length != 2)
+ GDS_ROUTING_add (&(trail_result->destination_peer),
&(trail_result->finger_identity),
+ peer, next_hop);
target_friend = GNUNET_CONTAINER_multipeermap_get (friend_peermap,
next_hop);
GNUNET_free (next_hop);
@@ -2936,6 +3262,64 @@
/**
+ * FIXME: Does it matter if the packet was going to a finger or friend?
+ * Core handle for p2p trail rejection messages.
+ * @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_trail_rejection(void *cls, const struct GNUNET_PeerIdentity
*peer,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct PeerTrailRejectionMessage *trail_rejection;
+ struct FailedTrail *trail_fail;
+ struct FriendInfo *target_friend;
+ struct GNUNET_PeerIdentity *trail_peer_list;
+ unsigned int finger_map_index;
+ size_t msize;
+
+ msize = ntohs (message->size);
+ if (msize < sizeof (struct PeerTrailRejectionMessage))
+ {
+ GNUNET_break_op (0);
+ return GNUNET_YES;
+ }
+
+ trail_rejection = (struct PeerTrailRejectionMessage *) message;
+ trail_peer_list = (struct GNUNET_PeerIdentity *)&trail_rejection[1];
+ finger_map_index = ntohl (trail_rejection->finger_map_index);
+ trail_fail = GNUNET_malloc (sizeof (struct FailedTrail));
+ memcpy (&(trail_fail->source_peer), &(trail_rejection->source_peer), sizeof
(struct GNUNET_PeerIdentity));
+ memcpy (&(trail_fail->congested_peer), &(trail_rejection->congested_peer),
sizeof (struct GNUNET_PeerIdentity));
+ memcpy (&(trail_fail->destination_finger_value),
&(trail_rejection->finger_identity), sizeof (uint64_t));
+
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_multipeermap_put (failed_trail_list,
&(trail_fail->source_peer),
+ trail_fail,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+
+ /* FIXME: Is it okay if I pass the struct as parameter. */
+ target_friend = select_random_friend (&(trail_fail->congested_peer));
+
+ if(NULL != target_friend)
+ {
+ /* FIXME: Here I am passing NULL for current source, is it correct?
+ also, we set the current source only if current_destination_type
+ is finger. */
+ GDS_NEIGHBOURS_send_trail_setup (&(trail_fail->source_peer),
+ trail_fail->destination_finger_value,
+ &(target_friend->id),
+ NULL, target_friend, ntohl
(trail_rejection->trail_length),
+ trail_peer_list,
+ finger_map_index, FRIEND);
+ return GNUNET_YES;
+ }
+ return GNUNET_SYSERR;
+}
+
+
+/**
* Initialize neighbours subsystem.
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
@@ -2951,6 +3335,7 @@
{&handle_dht_p2p_verify_successor,
GNUNET_MESSAGE_TYPE_DHT_P2P_VERIFY_SUCCESSOR, 0},
{&handle_dht_p2p_verify_successor_result,
GNUNET_MESSAGE_TYPE_DHT_P2P_VERIFY_SUCCESSOR_RESULT, 0},
{&handle_dht_p2p_notify_new_successor,
GNUNET_MESSAGE_TYPE_DHT_P2P_NOTIFY_NEW_SUCCESSOR, 0},
+ {&handle_dht_p2p_trail_rejection,
GNUNET_MESSAGE_TYPE_DHT_P2P_TRAIL_REJECTION, 0},
{NULL, 0, 0}
};
@@ -2962,8 +3347,9 @@
return GNUNET_SYSERR;
friend_peermap = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_NO);
- finger_peermap = GNUNET_CONTAINER_multipeermap_create (MAX_FINGERS,
GNUNET_NO);
-
+ finger_peermap = GNUNET_CONTAINER_multipeermap_create (MAX_FINGERS,
GNUNET_NO);
+ /* FIXME: Not sure if this value is correct for this data structure. */
+ failed_trail_list = GNUNET_CONTAINER_multipeermap_create (LINK_THRESHOLD,
GNUNET_NO);
return GNUNET_OK;
}
Modified: gnunet/src/dht/gnunet-service-xdht_neighbours.h
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_neighbours.h 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_neighbours.h 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -73,6 +73,7 @@
struct GNUNET_PeerIdentity *put_path,
const void *data, size_t data_size,
struct GNUNET_PeerIdentity *current_destination,
+ struct GNUNET_PeerIdentity *current_source,
enum current_destination_type dest_type,
struct GNUNET_PeerIdentity *target_peer_id);
@@ -85,36 +86,73 @@
* @param key
*/
void
-GDS_NEIGHBOURS_handle_get (struct GNUNET_PeerIdentity *source_peer,
- struct GNUNET_PeerIdentity *get_path,
+GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type block_type,
+ enum GNUNET_DHT_RouteOption options,
+ uint32_t desired_replication_level,
+ uint32_t hop_count,
+ struct GNUNET_PeerIdentity *get_peer_path,
unsigned int get_path_length,
struct GNUNET_HashCode *key,
struct GNUNET_PeerIdentity *target_peer,
struct GNUNET_PeerIdentity *current_destination,
- enum current_destination_type *type);
+ struct GNUNET_PeerIdentity *current_source,
+ enum current_destination_type *current_dest_type);
+
/**
- * Send get result back to requesting client.
- * @param source_peer
+ * FIXME: I am removing source peer as the first element in the trail
+ * is source identity.
+ * Send get result back to requesting client.
+ * @param expiration when will the reply expire
+ * @param key the query this reply is for
+ * @param get_path_length number of peers in @a get_path
+ * @param get_path path the reply took on get
+ * @param put_path_length number of peers in @a put_path
+ * @param put_path path the reply took on put
+ * @param type type of the reply
+ * @param data_size number of bytes in @a data
+ * @param data application payload data
* @param get_path
* @param get_path_length
- * @param key
- * @param destination_peer
- * @param current_path_index
- * @param data
- * @param data_size
*/
void
-GDS_NEIGHBOURS_send_get_result (struct GNUNET_PeerIdentity *source_peer,
+GDS_NEIGHBOURS_send_get_result (struct GNUNET_TIME_Absolute expiration,
+ const struct GNUNET_HashCode *key,
+ unsigned int put_path_length,
+ const struct GNUNET_PeerIdentity *put_path,
+ enum GNUNET_BLOCK_Type type, size_t data_size,
+ const void *data,
struct GNUNET_PeerIdentity *get_path,
unsigned int get_path_length,
- struct GNUNET_HashCode *key,
- struct GNUNET_PeerIdentity *destination_peer,
- unsigned int current_path_index,
- const void *data, size_t data_size,
- struct GNUNET_PeerIdentity *next_peer);
+ unsigned int current_trail_index,
+ struct GNUNET_PeerIdentity *next_hop);
+/**
+ * FIXME: Here you should update the fields of struct PeerGetResultMessage.
+ * At the end of this message you should add the data and get path and send
+ * to the original requesting client. and there you should call
GDS_CLIENT_handle_reply
+ * with correct parameter.
+ * @param expiration
+ * @param key
+ * @param get_path_length
+ * @param get_path
+ * @param put_path_length
+ * @param put_path
+ * @param type
+ * @param data_size
+ * @param data
+ */
+void
+GDS_NEIGHBOURS_datacache_get (struct GNUNET_TIME_Absolute expiration,
+ const struct GNUNET_HashCode *key,
+ unsigned int get_path_length,
+ const struct GNUNET_PeerIdentity *get_path,
+ unsigned int put_path_length,
+ const struct GNUNET_PeerIdentity *put_path,
+ enum GNUNET_BLOCK_Type type, size_t data_size,
+ const void *data);
+
/**
* Initialize neighbours subsystem.
*
Modified: gnunet/src/dht/gnunet-service-xdht_routing.c
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_routing.c 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_routing.c 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -84,8 +84,8 @@
int
GDS_ROUTING_add (struct GNUNET_PeerIdentity *source,
struct GNUNET_PeerIdentity *dest,
- struct GNUNET_PeerIdentity *next_hop,
- const struct GNUNET_PeerIdentity *prev_hop)
+ const struct GNUNET_PeerIdentity *next_hop,
+ struct GNUNET_PeerIdentity *prev_hop)
{
struct RoutingTrail *new_routing_entry;
@@ -102,6 +102,33 @@
GNUNET_CONTAINER_multipeermap_put (routing_table,
dest, new_routing_entry,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+
+ /* SUPU TEST CODE */
+ /* Here I want to see if routing table is correct or not. */
+ int test_index;
+ struct GNUNET_CONTAINER_MultiPeerMapIterator *test_iter;
+ struct GNUNET_PeerIdentity *print_peer;
+ print_peer = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ struct RoutingTrail *test_trail;
+ test_iter = GNUNET_CONTAINER_multipeermap_iterator_create (routing_table);
+ for (test_index = 0; test_index < GNUNET_CONTAINER_multipeermap_size
(routing_table); test_index++)
+ {
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, entry[%d]"),__FILE__,
__func__,__LINE__,test_index);
+ if(GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (test_iter,
NULL,
+ (const void
**)&test_trail))
+ {
+ memcpy (print_peer, &(test_trail->source),sizeof (struct
GNUNET_PeerIdentity));
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, test_trail->source =%s"),__FILE__,
__func__,__LINE__,GNUNET_i2s (print_peer));
+ memcpy (print_peer, &(test_trail->destination),sizeof (struct
GNUNET_PeerIdentity));
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, test_trail->destination
=%s"),__FILE__, __func__,__LINE__,GNUNET_i2s(print_peer));
+ memcpy (print_peer, &(test_trail->prev_hop),sizeof (struct
GNUNET_PeerIdentity));
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, test_trail->prev_hop
=%s"),__FILE__, __func__,__LINE__,GNUNET_i2s(print_peer));
+ memcpy (print_peer, &(test_trail->next_hop),sizeof (struct
GNUNET_PeerIdentity));
+ FPRINTF (stderr,_("\nSUPU %s, %s, %d, test_trail->next_hop
=%s"),__FILE__, __func__,__LINE__,GNUNET_i2s(print_peer));
+
+ }
+ }
+ /* SUPU TEST CODE ENDS*/
return GNUNET_YES;
}
@@ -191,7 +218,19 @@
return;
}
+/**
+ * Check if the size of routing table has crossed threshold.
+ * @return
+ */
+int
+GDS_ROUTING_size ()
+{
+ int ret;
+ ret = (GNUNET_CONTAINER_multipeermap_size(routing_table) >
ROUTING_TABLE_THRESHOLD) ? 0:1;
+ return ret;
+}
+
/**
* Initialize routing subsystem.
*/
Modified: gnunet/src/dht/gnunet-service-xdht_routing.h
===================================================================
--- gnunet/src/dht/gnunet-service-xdht_routing.h 2014-04-11 17:01:28 UTC
(rev 33049)
+++ gnunet/src/dht/gnunet-service-xdht_routing.h 2014-04-13 11:54:17 UTC
(rev 33050)
@@ -37,8 +37,8 @@
int
GDS_ROUTING_add (struct GNUNET_PeerIdentity *source,
struct GNUNET_PeerIdentity *destination_peer,
- struct GNUNET_PeerIdentity *next_hop,
- const struct GNUNET_PeerIdentity *prev_hop);
+ const struct GNUNET_PeerIdentity *next_hop,
+ struct GNUNET_PeerIdentity *prev_hop);
/**
@@ -77,6 +77,12 @@
const void *data, size_t data_size);
/**
+ * Check if size of routing table is greater than threshold or not.
+ */
+int
+GDS_ROUTING_size (void);
+
+/**
* Initialize routing subsystem.
*/
void
Modified: gnunet/src/include/gnunet_protocols.h
===================================================================
--- gnunet/src/include/gnunet_protocols.h 2014-04-11 17:01:28 UTC (rev
33049)
+++ gnunet/src/include/gnunet_protocols.h 2014-04-13 11:54:17 UTC (rev
33050)
@@ -634,6 +634,11 @@
* Message which contains the get result.
*/
#define GNUNET_MESSAGE_TYPE_DHT_P2P_GET_RESULT 162
+
+/**
+ * Trail Rejection Message.
+ */
+#define GNUNET_MESSAGE_TYPE_DHT_P2P_TRAIL_REJECTION 163
/*******************************************************************************
* HOSTLIST message types
******************************************************************************/
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r33050 - in gnunet/src: dht include,
gnunet <=