/*
This file is part of GNUnet.
- (C) 2009-2014 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2014 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
#include "gnunet-service-xdht_datacache.h"
#include "gnunet-service-xdht_neighbours.h"
#include "gnunet-service-xdht_routing.h"
-#include <fenv.h>
#include "dht.h"
/**
/**
* When does the content expire?
*/
- struct GNUNET_TIME_Absolute expiration_time;
+ struct GNUNET_TIME_AbsoluteNBO expiration_time;
/**
* The key of the corresponding GET request.
* 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 GNUNET_SCHEDULER_TaskIdentifier send_verify_successor_task;
+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 GNUNET_SCHEDULER_TaskIdentifier send_verify_successor_retry_task;
+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_notify_new_successor_retry_task;
+static struct GNUNET_SCHEDULER_Task * send_notify_new_successor_retry_task;
/**
* Identity of this peer.
void
GDS_NEIGHBOURS_send_put (const struct GNUNET_HashCode *key,
enum GNUNET_BLOCK_Type block_type,
- enum GNUNET_DHT_RouteOption options,
- uint32_t desired_replication_level,
- struct GNUNET_PeerIdentity best_known_dest,
- struct GNUNET_HashCode intermediate_trail_id,
- struct GNUNET_PeerIdentity *target_peer,
+ enum GNUNET_DHT_RouteOption options,
+ uint32_t desired_replication_level,
+ struct GNUNET_PeerIdentity best_known_dest,
+ struct GNUNET_HashCode intermediate_trail_id,
+ struct GNUNET_PeerIdentity *target_peer,
uint32_t hop_count,
uint32_t put_path_length,
struct GNUNET_PeerIdentity *put_path,
get_result->header.type = htons (GNUNET_MESSAGE_TYPE_XDHT_P2P_GET_RESULT);
get_result->key = *key;
get_result->querying_peer = *source_peer;
- get_result->expiration_time = expiration;
+ get_result->expiration_time = GNUNET_TIME_absolute_hton (expiration);
get_result->get_path_length = htonl (get_path_length);
get_result->put_path_length = htonl (put_path_length);
paths = (struct GNUNET_PeerIdentity *)&get_result[1];
* finger identity through this random friend.
*
* @param cls closure for this task
- * @param tc the context under which the task is running
*/
static void
-send_find_finger_trail_message (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_find_finger_trail_message (void *cls)
{
struct FriendInfo *target_friend;
struct GNUNET_HashCode trail_id;
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++)
{
* Periodic task to verify current successor. There can be multiple trails to reach
* to successor, choose the shortest one and send verify successor message
* across that trail.
+ *
* @param cls closure for this task
- * @param tc the context under which the task is running
*/
static void
-send_verify_successor_message (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_verify_successor_message (void *cls)
{
struct FriendInfo *target_friend;
struct GNUNET_HashCode trail_id;
successor = &finger_table[0];
/* This task will be scheduled when the result for Verify Successor is received. */
- send_verify_successor_task = GNUNET_SCHEDULER_NO_TASK;
+ 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
* --> Waiting for notify confirmation. again don't wait for it. notify
* confirmation will not succeded.
*/
- if (send_verify_successor_retry_task != GNUNET_SCHEDULER_NO_TASK)
+ 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
trail_id = trail->trail_id;
if (NULL == GDS_ROUTING_get_next_hop(trail_id,GDS_ROUTING_SRC_TO_DEST))
{
- DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line",
- GNUNET_i2s(&my_identity), GNUNET_h2s(&trail->trail_id), __LINE__);
+ DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line %u",
+ GNUNET_i2s (&my_identity),
+ GNUNET_h2s (&trail->trail_id),
+ __LINE__);
GNUNET_break(0);
return;
}
current_search_finger_index = PREDECESSOR_FINGER_ID;
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 =
GNUNET_SCHEDULER_add_now (&send_verify_successor_message, NULL);
{
switch (GNUNET_BLOCK_evaluate (GDS_block_context,
ntohl (put->block_type),
+ GNUNET_BLOCK_EO_NONE,
NULL, /* query */
NULL, 0, /* bloom filer */
NULL, 0, /* xquery */
if (0 == (GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &(get_path[0]))))
{
- GDS_CLIENTS_handle_reply (get_result->expiration_time, &(get_result->key),
+ GDS_CLIENTS_handle_reply (GNUNET_TIME_absolute_ntoh (get_result->expiration_time),
+ &(get_result->key),
getlen, get_path, putlen,
put_path, get_result->type, payload_size, payload);
return GNUNET_YES;
GDS_NEIGHBOURS_send_get_result (&(get_result->key), get_result->type,
&get_path[current_path_index - 1],
&(get_result->querying_peer), putlen, put_path,
- getlen, get_path, get_result->expiration_time,
+ getlen, get_path,
+ GNUNET_TIME_absolute_ntoh (get_result->expiration_time),
payload, payload_size);
return GNUNET_YES;
}
unsigned int num_retries_scheduled;
};
+
void
-send_notify_new_successor (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext
- * tc);
+send_notify_new_successor (void *cls);
+
/**
* Check if the peer which sent us verify successor result message is still ours
GNUNET_STATISTICS_set (GDS_stats, key, succ, 0);
GNUNET_free (key);
}
- if (send_verify_successor_task == GNUNET_SCHEDULER_NO_TASK)
+ if (send_verify_successor_task == NULL)
send_verify_successor_task =
GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
&send_verify_successor_message,
successor_times--;
- if (send_verify_successor_task == GNUNET_SCHEDULER_NO_TASK)
+ if (send_verify_successor_task == NULL)
send_verify_successor_task =
GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
&send_verify_successor_message,
void
-send_notify_new_successor (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext
- * tc)
+send_notify_new_successor (void *cls)
{
- struct SendNotifyContext *ctx = (struct SendNotifyContext *) cls;
+ struct SendNotifyContext *ctx = cls;
GDS_NEIGHBOURS_send_notify_new_successor (ctx->source_peer,
ctx->successor,
ctx->target_friend);
if (0 == ctx->num_retries_scheduled &&
- send_notify_new_successor_retry_task != GNUNET_SCHEDULER_NO_TASK)
+ 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.
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 = GNUNET_SCHEDULER_NO_TASK;
+ send_notify_new_successor_retry_task = NULL;
}
ctx->num_retries_scheduled++;
if(0 == (GNUNET_CRYPTO_cmp_peer_identity (&querying_peer, &my_identity)))
{
/* Cancel Retry Task */
- if (GNUNET_SCHEDULER_NO_TASK != send_verify_successor_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 = GNUNET_SCHEDULER_NO_TASK;
+ send_verify_successor_retry_task = NULL;
}
compare_and_update_successor (current_successor,
probable_successor, trail, trail_length);
{
/* 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__);
+ DEBUG (" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line %u",
+ GNUNET_i2s (&my_identity),
+ GNUNET_h2s (&trail_id),
+ __LINE__);
GNUNET_break_op(0);
return GNUNET_OK;
}
*/
// TODO: cancel schedule of notify_successor_retry_task
- if (send_notify_new_successor_retry_task != GNUNET_SCHEDULER_NO_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 = GNUNET_SCHEDULER_NO_TASK;
+ send_notify_new_successor_retry_task = NULL;
}
- if (send_verify_successor_task == GNUNET_SCHEDULER_NO_TASK)
+ if (send_verify_successor_task == NULL)
{
verify_successor_next_send_time.rel_value_us =
DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us +
next_hop = GDS_ROUTING_get_next_hop (trail_id, trail_direction);
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__);
+ DEBUG(" NO ENTRY FOUND IN %s ROUTING TABLE for trail id %s, line %u",
+ GNUNET_i2s (&my_identity),
+ GNUNET_h2s(&trail_id),
+ __LINE__);
GNUNET_break (0);
return GNUNET_SYSERR;
}
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);
* 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)
+ if (NULL == find_finger_trail_task)
{
find_finger_trail_task = GNUNET_SCHEDULER_add_now (&send_find_finger_trail_message, NULL);
}
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_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 (GNUNET_SCHEDULER_NO_TASK != send_verify_successor_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 = GNUNET_SCHEDULER_NO_TASK;
+ send_verify_successor_retry_task = NULL;
}
- if (send_notify_new_successor_retry_task != GNUNET_SCHEDULER_NO_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 = GNUNET_SCHEDULER_NO_TASK;
+ send_notify_new_successor_retry_task = NULL;
}
}
projects / oweals / gnunet.git / blobdiff