atsi++;
if (ntohl (atsi->type) == GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR)
{
- GNUNET_break (0);
+ static int once;
+
+ if (!once)
+ {
+ once = 1;
+ GNUNET_break (0);
+ }
/* how can we not have latency data? */
return GNUNET_TIME_UNIT_SECONDS;
}
/**
* Return the performance data record for the given peer
- *
+ *
* @param cp peer to query
* @return performance data record for the peer
*/
* @param buf where to copy the message
* @return number of bytes copied to buf
*/
-static size_t peer_transmit_ready_cb (void *cls, size_t size, void *buf);
+static size_t
+peer_transmit_ready_cb (void *cls, size_t size, void *buf);
* @param preference current traffic preference for the given peer
*/
static void
-core_reserve_callback (void *cls,
- const struct GNUNET_PeerIdentity *peer,
+core_reserve_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
- int32_t amount,
- struct GNUNET_TIME_Relative res_delay,
+ int32_t amount, struct GNUNET_TIME_Relative res_delay,
uint64_t preference);
pth->was_reserved = GNUNET_YES;
ip = cp->inc_preference;
cp->inc_preference = 0;
- cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
- &target,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_BANDWIDTH_VALUE_MAX,
- DBLOCK_SIZE,
- ip,
- &core_reserve_callback, cp);
+ cp->irc =
+ GNUNET_CORE_peer_change_preference (GSF_core, &target,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_BANDWIDTH_VALUE_MAX,
+ DBLOCK_SIZE, ip,
+ &core_reserve_callback, cp);
}
GNUNET_assert (pth->cth == NULL);
pth->cth_in_progress++;
- pth->cth = GNUNET_CORE_notify_transmit_ready (GSF_core,
- GNUNET_YES,
- pth->priority,
- GNUNET_TIME_absolute_get_remaining
- (pth->timeout), &target,
- pth->size,
- &peer_transmit_ready_cb, pth);
+ pth->cth =
+ GNUNET_CORE_notify_transmit_ready (GSF_core, GNUNET_YES, pth->priority,
+ GNUNET_TIME_absolute_get_remaining
+ (pth->timeout), &target, pth->size,
+ &peer_transmit_ready_cb, pth);
GNUNET_assert (0 < pth->cth_in_progress--);
}
cp->irc_delay_task = GNUNET_SCHEDULER_NO_TASK;
ip = cp->inc_preference;
cp->inc_preference = 0;
- cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
- &target,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_BANDWIDTH_VALUE_MAX,
- DBLOCK_SIZE,
- ip, &core_reserve_callback, cp);
+ cp->irc =
+ GNUNET_CORE_peer_change_preference (GSF_core, &target,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_BANDWIDTH_VALUE_MAX,
+ DBLOCK_SIZE, ip,
+ &core_reserve_callback, cp);
}
* @param preference current traffic preference for the given peer
*/
static void
-core_reserve_callback (void *cls,
- const struct GNUNET_PeerIdentity *peer,
+core_reserve_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
- int32_t amount,
- struct GNUNET_TIME_Relative res_delay,
+ int32_t amount, struct GNUNET_TIME_Relative res_delay,
uint64_t preference)
{
struct GSF_ConnectedPeer *cp = cls;
cp->irc = NULL;
if (0 == amount)
{
- cp->irc_delay_task = GNUNET_SCHEDULER_add_delayed (res_delay,
- &retry_reservation, cp);
+ cp->irc_delay_task =
+ GNUNET_SCHEDULER_add_delayed (res_delay, &retry_reservation, cp);
return;
}
cp->did_reserve = GNUNET_YES;
{
/* reservation success, try transmission now! */
pth->cth_in_progress++;
- pth->cth = GNUNET_CORE_notify_transmit_ready (GSF_core,
- GNUNET_YES,
- pth->priority,
- GNUNET_TIME_absolute_get_remaining
- (pth->timeout), peer,
- pth->size,
- &peer_transmit_ready_cb, pth);
+ pth->cth =
+ GNUNET_CORE_notify_transmit_ready (GSF_core, GNUNET_YES, pth->priority,
+ GNUNET_TIME_absolute_get_remaining
+ (pth->timeout), peer, pth->size,
+ &peer_transmit_ready_cb, pth);
GNUNET_assert (0 < pth->cth_in_progress--);
}
}
cp = GNUNET_malloc (sizeof (struct GSF_ConnectedPeer));
cp->ppd.pid = GNUNET_PEER_intern (peer);
cp->ppd.transmission_delay = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_ZERO);
- cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
- peer,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_BANDWIDTH_VALUE_MAX,
- DBLOCK_SIZE,
- 0, &core_reserve_callback, cp);
+ cp->irc =
+ GNUNET_CORE_peer_change_preference (GSF_core, peer,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_BANDWIDTH_VALUE_MAX,
+ DBLOCK_SIZE, 0,
+ &core_reserve_callback, cp);
fn = get_trust_filename (peer);
if ((GNUNET_DISK_file_test (fn) == GNUNET_YES) &&
(sizeof (trust) == GNUNET_DISK_fn_read (fn, &trust, sizeof (trust))))
GNUNET_free (fn);
cp->request_map = GNUNET_CONTAINER_multihashmap_create (128);
GNUNET_break (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap_put (cp_map,
- &peer->hashPubKey,
+ GNUNET_CONTAINER_multihashmap_put (cp_map, &peer->hashPubKey,
cp,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
update_atsi (cp, atsi);
if (0 != bt.rel_value)
{
/* still time left... */
- cp->mig_revive_task
- = GNUNET_SCHEDULER_add_delayed (bt, &revive_migration, cp);
+ cp->mig_revive_task =
+ GNUNET_SCHEDULER_add_delayed (bt, &revive_migration, cp);
return;
}
GSF_push_start_ (cp);
if (cp->mig_revive_task == GNUNET_SCHEDULER_NO_TASK)
{
GSF_push_stop_ (cp);
- cp->mig_revive_task
- = GNUNET_SCHEDULER_add_delayed (bt, &revive_migration, cp);
+ cp->mig_revive_task =
+ GNUNET_SCHEDULER_add_delayed (bt, &revive_migration, cp);
}
update_atsi (cp, atsi);
return GNUNET_OK;
else
{
size = 0;
- GNUNET_STATISTICS_update (GSF_stats,
- gettext_noop ("# replies dropped"), 1, GNUNET_NO);
+ GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# replies dropped"), 1,
+ GNUNET_NO);
}
GNUNET_free (pm);
return size;
GNUNET_SCHEDULER_cancel (peerreq->kill_task);
peerreq->kill_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_STATISTICS_update (GSF_stats,
- gettext_noop ("# P2P searches active"),
+ GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# P2P searches active"),
-1, GNUNET_NO);
prd = GSF_pending_request_get_data_ (pr);
GNUNET_break (GNUNET_YES ==
GNUNET_free (dh);
return;
}
- (void) GSF_peer_transmit_ (cp, GNUNET_NO,
- UINT32_MAX,
- REPLY_TIMEOUT, dh->msize, ©_reply, dh->pm);
+ (void) GSF_peer_transmit_ (cp, GNUNET_NO, UINT32_MAX, REPLY_TIMEOUT,
+ dh->msize, ©_reply, dh->pm);
GNUNET_free (dh);
}
/**
* Get the randomized delay a response should be subjected to.
- *
+ *
* @return desired delay
*/
static struct GNUNET_TIME_Relative
struct GNUNET_TIME_Relative ret;
/* FIXME: replace 5000 with something relating to current observed P2P message latency */
- ret = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
- GNUNET_CRYPTO_random_u32
- (GNUNET_CRYPTO_QUALITY_WEAK, 5000));
+ ret =
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+ GNUNET_CRYPTO_random_u32
+ (GNUNET_CRYPTO_QUALITY_WEAK, 5000));
GNUNET_STATISTICS_update (GSF_stats,
gettext_noop
("# artificial delays introduced (ms)"),
* Handle a reply to a pending request. Also called if a request
* expires (then with data == NULL). The handler may be called
* many times (depending on the request type), but will not be
- * called during or after a call to GSF_pending_request_cancel
+ * called during or after a call to GSF_pending_request_cancel
* and will also not be called anymore after a call signalling
* expiration.
*
* @param data_len number of bytes in data
*/
static void
-handle_p2p_reply (void *cls,
- enum GNUNET_BLOCK_EvaluationResult eval,
- struct GSF_PendingRequest *pr,
- uint32_t reply_anonymity_level,
+handle_p2p_reply (void *cls, enum GNUNET_BLOCK_EvaluationResult eval,
+ struct GSF_PendingRequest *pr, uint32_t reply_anonymity_level,
struct GNUNET_TIME_Absolute expiration,
- enum GNUNET_BLOCK_Type type,
- const void *data, size_t data_len)
+ enum GNUNET_BLOCK_Type type, const void *data,
+ size_t data_len)
{
struct PeerRequest *peerreq = cls;
struct GSF_ConnectedPeer *cp = peerreq->cp;
prd = GSF_pending_request_get_data_ (pr);
if (NULL == data)
{
- GNUNET_STATISTICS_update (GSF_stats,
- gettext_noop ("# P2P searches active"),
+ GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# P2P searches active"),
-1, GNUNET_NO);
GNUNET_break (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (cp->request_map,
pm->type = htonl (type);
pm->expiration = GNUNET_TIME_absolute_hton (expiration);
memcpy (&pm[1], data, data_len);
- if ((reply_anonymity_level != UINT32_MAX) &&
- (reply_anonymity_level != 0) &&
+ if ((reply_anonymity_level != UINT32_MAX) && (reply_anonymity_level != 0) &&
(GSF_enable_randomized_delays == GNUNET_YES))
{
struct GSF_DelayedHandle *dh;
dh->pm = pm;
dh->msize = msize;
GNUNET_CONTAINER_DLL_insert (cp->delayed_head, cp->delayed_tail, dh);
- dh->delay_task = GNUNET_SCHEDULER_add_delayed (get_randomized_delay (),
- &transmit_delayed_now, dh);
+ dh->delay_task =
+ GNUNET_SCHEDULER_add_delayed (get_randomized_delay (),
+ &transmit_delayed_now, dh);
}
else
{
- (void) GSF_peer_transmit_ (cp, GNUNET_NO,
- UINT32_MAX,
- REPLY_TIMEOUT, msize, ©_reply, pm);
+ (void) GSF_peer_transmit_ (cp, GNUNET_NO, UINT32_MAX, REPLY_TIMEOUT, msize,
+ ©_reply, pm);
}
if (eval != GNUNET_BLOCK_EVALUATION_OK_LAST)
return;
/**
* We've received a request with the specified priority. Bound it
* according to how much we trust the given peer.
- *
+ *
* @param prio_in requested priority
* @param cp the peer making the request
* @return effective priority
#if DEBUG_FS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received request for `%s' of type %u from peer `%4s' with flags %u\n",
- GNUNET_h2s (&gm->query),
- (unsigned int) type, GNUNET_i2s (other), (unsigned int) bm);
+ GNUNET_h2s (&gm->query), (unsigned int) type, GNUNET_i2s (other),
+ (unsigned int) bm);
#endif
namespace = (0 != (bm & GET_MESSAGE_BIT_SKS_NAMESPACE)) ? &opt[bits++] : NULL;
if ((type == GNUNET_BLOCK_TYPE_FS_SBLOCK) && (namespace == NULL))
}
ttl = bound_ttl (ntohl (gm->ttl), priority);
/* decrement ttl (always) */
- ttl_decrement = 2 * TTL_DECREMENT +
- GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, TTL_DECREMENT);
+ ttl_decrement =
+ 2 * TTL_DECREMENT + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ TTL_DECREMENT);
if ((ttl < 0) && (((int32_t) (ttl - ttl_decrement)) > 0))
{
#if DEBUG_FS
}
/* existing request has lower TTL, drop old one! */
GNUNET_STATISTICS_update (GSF_stats,
- gettext_noop ("# P2P searches active"),
- -1, GNUNET_NO);
+ gettext_noop ("# P2P searches active"), -1,
+ GNUNET_NO);
priority += prd->priority;
GSF_pending_request_cancel_ (pr, GNUNET_YES);
GNUNET_assert (GNUNET_YES ==
peerreq = GNUNET_malloc (sizeof (struct PeerRequest));
peerreq->cp = cp;
- pr = GSF_pending_request_create_ (options,
- type,
- &gm->query,
- namespace,
+ pr = GSF_pending_request_create_ (options, type, &gm->query, namespace,
target,
(bfsize >
0) ? (const char *) &opt[bits] : NULL,
GNUNET_assert (NULL != pr);
peerreq->pr = pr;
GNUNET_break (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap_put (cp->request_map,
- &gm->query,
+ GNUNET_CONTAINER_multihashmap_put (cp->request_map, &gm->query,
peerreq,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
GNUNET_STATISTICS_update (GSF_stats,
* Function called if there has been a timeout trying to satisfy
* a transmission request.
*
- * @param cls the 'struct GSF_PeerTransmitHandle' of the request
+ * @param cls the 'struct GSF_PeerTransmitHandle' of the request
* @param tc scheduler context
*/
static void
* @return handle to cancel request
*/
struct GSF_PeerTransmitHandle *
-GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
- int is_query,
- uint32_t priority,
- struct GNUNET_TIME_Relative timeout,
+GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp, int is_query,
+ uint32_t priority, struct GNUNET_TIME_Relative timeout,
size_t size, GSF_GetMessageCallback gmc, void *gmc_cls)
{
struct GSF_PeerTransmitHandle *pth;
cp->ppd.pending_queries++;
else if (GNUNET_NO == is_query)
cp->ppd.pending_replies++;
- pth->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
- &peer_transmit_timeout,
- pth);
+ pth->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (timeout, &peer_transmit_timeout, pth);
schedule_transmission (pth);
return pth;
}
* @param atsi status information
*/
void
-GSF_peer_status_handler_ (void *cls,
- const struct GNUNET_PeerIdentity *peer,
+GSF_peer_status_handler_ (void *cls, const struct GNUNET_PeerIdentity *peer,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
struct GNUNET_TIME_Absolute timeout,
/**
* Ask a peer to stop migrating data to us until the given point
* in time.
- *
+ *
* @param cp peer to ask
* @param block_time until when to block
*/
return; /* already blocked */
}
#if DEBUG_FS && 0
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Asking to stop migration for %llu ms\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %llu ms\n",
(unsigned long long) block_time.rel_value);
#endif
cp->last_migration_block = GNUNET_TIME_relative_to_absolute (block_time);
if (cp->migration_pth != NULL)
GSF_peer_transmit_cancel_ (cp->migration_pth);
- cp->migration_pth
- = GSF_peer_transmit_ (cp,
- GNUNET_SYSERR,
- UINT32_MAX,
- GNUNET_TIME_UNIT_FOREVER_REL,
- sizeof (struct MigrationStopMessage),
- &create_migration_stop_message, cp);
+ cp->migration_pth =
+ GSF_peer_transmit_ (cp, GNUNET_SYSERR, UINT32_MAX,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ sizeof (struct MigrationStopMessage),
+ &create_migration_stop_message, cp);
}
else
{
trust = htonl (cp->ppd.trust);
- if (sizeof (uint32_t) == GNUNET_DISK_fn_write (fn, &trust,
- sizeof (uint32_t),
- GNUNET_DISK_PERM_USER_READ |
- GNUNET_DISK_PERM_USER_WRITE |
- GNUNET_DISK_PERM_GROUP_READ |
- GNUNET_DISK_PERM_OTHER_READ))
+ if (sizeof (uint32_t) ==
+ GNUNET_DISK_fn_write (fn, &trust, sizeof (uint32_t),
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE |
+ GNUNET_DISK_PERM_GROUP_READ |
+ GNUNET_DISK_PERM_OTHER_READ))
cp->disk_trust = cp->ppd.trust;
}
GNUNET_free (fn);
{
cp_map = GNUNET_CONTAINER_multihashmap_create (128);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (GSF_cfg,
- "fs",
+ GNUNET_CONFIGURATION_get_value_filename (GSF_cfg, "fs",
"TRUST",
&trustDirectory));
GNUNET_DISK_directory_create (trustDirectory);
{
if (NULL == cp_map)
return; /* already cleaned up */
- GNUNET_CONTAINER_multihashmap_iterate (cp_map,
- &clean_local_client, (void *) lc);
+ GNUNET_CONTAINER_multihashmap_iterate (cp_map, &clean_local_client,
+ (void *) lc);
}
projects / oweals / gnunet.git / blobdiff