[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] branch master updated (3d2a951fa -> c3cba3c67)
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] branch master updated (3d2a951fa -> c3cba3c67) |
|
Date: |
Sat, 04 May 2019 22:19:00 +0200 |
This is an automated email from the git hooks/post-receive script.
grothoff pushed a change to branch master
in repository gnunet.
from 3d2a951fa only use mono time in TNG HELLOs
new 80f480c75 simplify MQ logic to always carry the same kinds of flags,
and extend transport API to pass them to (TNG) service
new c3cba3c67 note on ChannelOption deprecation
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
src/core/core.h | 33 +-
src/core/core_api.c | 266 ++++--------
src/core/gnunet-service-core.c | 527 ++++++++++------------
src/core/gnunet-service-core.h | 21 +-
src/core/gnunet-service-core_sessions.c | 285 +++++-------
src/core/gnunet-service-core_sessions.h | 7 +-
src/core/test_core_api.c | 207 ++++-----
src/hostlist/gnunet-daemon-hostlist_server.c | 268 ++++++------
src/include/gnunet_cadet_service.h | 84 ++--
src/include/gnunet_core_service.h | 90 +---
src/include/gnunet_mq_lib.h | 288 +++++++-----
src/nse/gnunet-service-nse.c | 627 +++++++++++----------------
src/topology/gnunet-daemon-topology.c | 377 ++++++----------
src/transport/gnunet-service-tng.c | 3 +
src/transport/transport.h | 4 +-
src/transport/transport_api2_core.c | 7 +-
src/transport/transport_api_core.c | 7 +-
src/util/mq.c | 277 +++++-------
18 files changed, 1455 insertions(+), 1923 deletions(-)
diff --git a/src/core/core.h b/src/core/core.h
index bc9638706..95d506fbd 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -42,23 +42,23 @@
* for handlers that were specifically registered are always
* transmitted to the client.
*/
-#define GNUNET_CORE_OPTION_NOTHING 0
+#define GNUNET_CORE_OPTION_NOTHING 0
/**
* Client cares about connectivity changes.
*/
-#define GNUNET_CORE_OPTION_SEND_STATUS_CHANGE 4
+#define GNUNET_CORE_OPTION_SEND_STATUS_CHANGE 4
/**
* Client wants all inbound messages in full.
*/
-#define GNUNET_CORE_OPTION_SEND_FULL_INBOUND 8
+#define GNUNET_CORE_OPTION_SEND_FULL_INBOUND 8
/**
* Client just wants the 4-byte message headers of
* all inbound messages.
*/
-#define GNUNET_CORE_OPTION_SEND_HDR_INBOUND 16
+#define GNUNET_CORE_OPTION_SEND_HDR_INBOUND 16
/**
* Client wants all outbound messages in full.
@@ -69,7 +69,7 @@
* Client just wants the 4-byte message headers of
* all outbound messages.
*/
-#define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND 64
+#define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND 64
GNUNET_NETWORK_STRUCT_BEGIN
@@ -92,7 +92,6 @@ struct InitMessage
* Options, see GNUNET_CORE_OPTION_ values.
*/
uint32_t options GNUNET_PACKED;
-
};
@@ -117,7 +116,6 @@ struct InitReplyMessage
* Public key of the local peer.
*/
struct GNUNET_PeerIdentity my_identity;
-
};
@@ -141,7 +139,6 @@ struct ConnectNotifyMessage
* Identity of the connecting peer.
*/
struct GNUNET_PeerIdentity peer;
-
};
@@ -165,7 +162,6 @@ struct DisconnectNotifyMessage
* Identity of the connecting peer.
*/
struct GNUNET_PeerIdentity peer;
-
};
@@ -236,7 +232,6 @@ struct SendMessageRequest
* Counter for this peer to match SMRs to replies.
*/
uint16_t smr_id GNUNET_PACKED;
-
};
@@ -269,7 +264,6 @@ struct SendMessageReady
* Identity of the intended target.
*/
struct GNUNET_PeerIdentity peer;
-
};
@@ -285,7 +279,8 @@ struct SendMessage
struct GNUNET_MessageHeader header;
/**
- * How important is this message?
+ * How important is this message? Contains a
+ * `enum GNUNET_MQ_PriorityPreferences` in NBO.
*/
uint32_t priority GNUNET_PACKED;
@@ -299,17 +294,6 @@ struct SendMessage
* Identity of the intended receiver.
*/
struct GNUNET_PeerIdentity peer;
-
- /**
- * #GNUNET_YES if corking is allowed, #GNUNET_NO if not.
- */
- uint32_t cork GNUNET_PACKED;
-
- /**
- * Always 0.
- */
- uint32_t reserved GNUNET_PACKED;
-
};
@@ -338,7 +322,6 @@ struct MonitorNotifyMessage
* How long will we stay in this state (if nothing else happens)?
*/
struct GNUNET_TIME_AbsoluteNBO timeout;
-
};
diff --git a/src/core/core_api.c b/src/core/core_api.c
index 6adaadabf..6381d9097 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -29,7 +29,7 @@
#include "gnunet_core_service.h"
#include "core.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "core-api",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "core-api", __VA_ARGS__)
/**
@@ -69,7 +69,6 @@ struct PeerRecord
* SendMessageRequest ID generator for this peer.
*/
uint16_t smr_id_gen;
-
};
@@ -144,7 +143,6 @@ struct GNUNET_CORE_Handle
* Did we ever get INIT?
*/
int have_init;
-
};
@@ -170,8 +168,7 @@ reconnect_task (void *cls)
struct GNUNET_CORE_Handle *h = cls;
h->reconnect_task = NULL;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting to CORE service after delay\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service after delay\n");
reconnect (h);
}
@@ -187,7 +184,7 @@ reconnect_task (void *cls)
*/
static int
disconnect_and_free_peer_entry (void *cls,
- const struct GNUNET_PeerIdentity *key,
+ const struct GNUNET_PeerIdentity *key,
void *value)
{
struct GNUNET_CORE_Handle *h = cls;
@@ -195,13 +192,9 @@ disconnect_and_free_peer_entry (void *cls,
GNUNET_assert (pr->h == h);
if (NULL != h->disconnects)
- h->disconnects (h->cls,
- &pr->peer,
- pr->client_cls);
+ h->disconnects (h->cls, &pr->peer, pr->client_cls);
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (h->peers,
- key,
- pr));
+ GNUNET_CONTAINER_multipeermap_remove (h->peers, key, pr));
GNUNET_MQ_destroy (pr->mq);
GNUNET_assert (NULL == pr->mq);
if (NULL != pr->env)
@@ -231,9 +224,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
}
GNUNET_assert (NULL == h->reconnect_task);
h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
- &reconnect_task,
- h);
+ GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_task, h);
GNUNET_CONTAINER_multipeermap_iterate (h->peers,
&disconnect_and_free_peer_entry,
h);
@@ -249,38 +240,15 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
* @param error error code
*/
static void
-handle_mq_error (void *cls,
- enum GNUNET_MQ_Error error)
+handle_mq_error (void *cls, enum GNUNET_MQ_Error error)
{
struct GNUNET_CORE_Handle *h = cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "MQ ERROR: %d\n",
- error);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %d\n", error);
reconnect_later (h);
}
-/**
- * Inquire with CORE what options should be set for a message
- * so that it is transmitted with the given @a priority and
- * the given @a cork value.
- *
- * @param cork desired corking
- * @param priority desired message priority
- * @param[out] flags set to `flags` value for #GNUNET_MQ_set_options()
- * @return `extra` argument to give to #GNUNET_MQ_set_options()
- */
-const void *
-GNUNET_CORE_get_mq_options (int cork,
- enum GNUNET_CORE_Priority priority,
- uint64_t *flags)
-{
- *flags = ((uint64_t) priority) + (((uint64_t) cork) << 32);
- return NULL;
-}
-
-
/**
* Implement sending functionality of a message queue for
* us sending messages to a peer.
@@ -291,8 +259,8 @@ GNUNET_CORE_get_mq_options (int cork,
*/
static void
core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
- const struct GNUNET_MessageHeader *msg,
- void *impl_state)
+ const struct GNUNET_MessageHeader *msg,
+ void *impl_state)
{
struct PeerRecord *pr = impl_state;
struct GNUNET_CORE_Handle *h = pr->h;
@@ -300,9 +268,7 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
struct SendMessage *sm;
struct GNUNET_MQ_Envelope *env;
uint16_t msize;
- uint64_t flags;
- int cork;
- enum GNUNET_CORE_Priority priority;
+ enum GNUNET_MQ_PriorityPreferences flags;
if (NULL == h->mq)
{
@@ -313,11 +279,7 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
GNUNET_assert (NULL == pr->env);
/* extract options from envelope */
env = GNUNET_MQ_get_current_envelope (mq);
- GNUNET_break (NULL ==
- GNUNET_MQ_env_get_options (env,
- &flags));
- cork = (int) (flags >> 32);
- priority = (uint32_t) flags;
+ flags = GNUNET_MQ_env_get_options (env);
/* check message size for sanity */
msize = ntohs (msg->size);
@@ -333,28 +295,20 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
"Asking core for transmission of %u bytes to `%s'\n",
(unsigned int) msize,
GNUNET_i2s (&pr->peer));
- env = GNUNET_MQ_msg (smr,
- GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
- smr->priority = htonl ((uint32_t) priority);
+ env = GNUNET_MQ_msg (smr, GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
+ smr->priority = htonl ((uint32_t) flags);
smr->peer = pr->peer;
- smr->reserved = htonl (0);
smr->size = htons (msize);
smr->smr_id = htons (++pr->smr_id_gen);
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
/* prepare message with actual transmission data */
- pr->env = GNUNET_MQ_msg_nested_mh (sm,
- GNUNET_MESSAGE_TYPE_CORE_SEND,
- msg);
- sm->priority = htonl ((uint32_t) priority);
+ pr->env = GNUNET_MQ_msg_nested_mh (sm, GNUNET_MESSAGE_TYPE_CORE_SEND, msg);
+ sm->priority = htonl ((uint32_t) flags);
sm->peer = pr->peer;
- sm->cork = htonl ((uint32_t) cork);
- sm->reserved = htonl (0);
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Calling get_message with buffer of %u bytes (%s)\n",
- (unsigned int) msize,
- cork ? "corked" : "uncorked");
+ "Calling get_message with buffer of %u bytes\n",
+ (unsigned int) msize);
}
@@ -366,8 +320,7 @@ core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
* @param impl_state state of the implementation
*/
static void
-core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
+core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct PeerRecord *pr = impl_state;
@@ -384,8 +337,7 @@ core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
* @param impl_state state specific to the implementation
*/
static void
-core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
+core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct PeerRecord *pr = impl_state;
@@ -404,8 +356,7 @@ core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
* @param error error code
*/
static void
-core_mq_error_handler (void *cls,
- enum GNUNET_MQ_Error error)
+core_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
/* struct PeerRecord *pr = cls; */
@@ -423,41 +374,30 @@ core_mq_error_handler (void *cls,
*/
static void
connect_peer (struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *peer)
+ const struct GNUNET_PeerIdentity *peer)
{
struct PeerRecord *pr;
- uint64_t flags;
- const void *extra;
pr = GNUNET_new (struct PeerRecord);
pr->peer = *peer;
pr->h = h;
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (h->peers,
- &pr->peer,
- pr,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ h->peers,
+ &pr->peer,
+ pr,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
pr->mq = GNUNET_MQ_queue_for_callbacks (&core_mq_send_impl,
- &core_mq_destroy_impl,
- &core_mq_cancel_impl,
- pr,
- h->handlers,
- &core_mq_error_handler,
- pr);
- /* get our default options */
- extra = GNUNET_CORE_get_mq_options (GNUNET_NO,
- GNUNET_CORE_PRIO_BEST_EFFORT,
- &flags);
- GNUNET_MQ_set_options (pr->mq,
- flags,
- extra);
+ &core_mq_destroy_impl,
+ &core_mq_cancel_impl,
+ pr,
+ h->handlers,
+ &core_mq_error_handler,
+ pr);
if (NULL != h->connects)
{
- pr->client_cls = h->connects (h->cls,
- &pr->peer,
- pr->mq);
- GNUNET_MQ_set_handlers_closure (pr->mq,
- pr->client_cls);
+ pr->client_cls = h->connects (h->cls, &pr->peer, pr->mq);
+ GNUNET_MQ_set_handlers_closure (pr->mq, pr->client_cls);
}
}
@@ -471,8 +411,7 @@ connect_peer (struct GNUNET_CORE_Handle *h,
* @param m the init reply
*/
static void
-handle_init_reply (void *cls,
- const struct InitReplyMessage *m)
+handle_init_reply (void *cls, const struct InitReplyMessage *m)
{
struct GNUNET_CORE_Handle *h = cls;
GNUNET_CORE_StartupCallback init;
@@ -488,8 +427,7 @@ handle_init_reply (void *cls,
"Connected to core service of peer `%s'.\n",
GNUNET_i2s (&h->me));
h->have_init = GNUNET_YES;
- init (h->cls,
- &h->me);
+ init (h->cls, &h->me);
}
else
{
@@ -508,8 +446,7 @@ handle_init_reply (void *cls,
}
}
/* fake 'connect to self' */
- connect_peer (h,
- &h->me);
+ connect_peer (h, &h->me);
}
@@ -521,8 +458,7 @@ handle_init_reply (void *cls,
* @param cnm the connect message
*/
static void
-handle_connect_notify (void *cls,
- const struct ConnectNotifyMessage *cnm)
+handle_connect_notify (void *cls, const struct ConnectNotifyMessage *cnm)
{
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
@@ -530,24 +466,20 @@ handle_connect_notify (void *cls,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received notification about connection from `%s'.\n",
GNUNET_i2s (&cnm->peer));
- if (0 == memcmp (&h->me,
- &cnm->peer,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&h->me, &cnm->peer, sizeof (struct GNUNET_PeerIdentity)))
{
/* connect to self!? */
GNUNET_break (0);
return;
}
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &cnm->peer);
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &cnm->peer);
if (NULL != pr)
{
GNUNET_break (0);
reconnect_later (h);
return;
}
- connect_peer (h,
- &cnm->peer);
+ connect_peer (h, &cnm->peer);
}
@@ -559,15 +491,12 @@ handle_connect_notify (void *cls,
* @param dnm message about the disconnect event
*/
static void
-handle_disconnect_notify (void *cls,
- const struct DisconnectNotifyMessage *dnm)
+handle_disconnect_notify (void *cls, const struct DisconnectNotifyMessage *dnm)
{
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
- if (0 == memcmp (&h->me,
- &dnm->peer,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&h->me, &dnm->peer, sizeof (struct GNUNET_PeerIdentity)))
{
/* disconnect from self!? */
GNUNET_break (0);
@@ -577,17 +506,14 @@ handle_disconnect_notify (void *cls,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received notification about disconnect from `%s'.\n",
GNUNET_i2s (&dnm->peer));
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &dnm->peer);
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &dnm->peer);
if (NULL == pr)
{
GNUNET_break (0);
reconnect_later (h);
return;
}
- disconnect_and_free_peer_entry (h,
- &pr->peer,
- pr);
+ disconnect_and_free_peer_entry (h, &pr->peer, pr);
}
@@ -599,8 +525,7 @@ handle_disconnect_notify (void *cls,
* @return #GNUNET_OK if the message is well-formed
*/
static int
-check_notify_inbound (void *cls,
- const struct NotifyTrafficMessage *ntm)
+check_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm)
{
uint16_t msize;
const struct GNUNET_MessageHeader *em;
@@ -629,8 +554,7 @@ check_notify_inbound (void *cls,
* @param ntm the message we got from CORE.
*/
static void
-handle_notify_inbound (void *cls,
- const struct NotifyTrafficMessage *ntm)
+handle_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm)
{
struct GNUNET_CORE_Handle *h = cls;
const struct GNUNET_MessageHeader *em;
@@ -640,16 +564,14 @@ handle_notify_inbound (void *cls,
"Received inbound message from `%s'.\n",
GNUNET_i2s (&ntm->peer));
em = (const struct GNUNET_MessageHeader *) &ntm[1];
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &ntm->peer);
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &ntm->peer);
if (NULL == pr)
{
GNUNET_break (0);
reconnect_later (h);
return;
}
- GNUNET_MQ_inject_message (pr->mq,
- em);
+ GNUNET_MQ_inject_message (pr->mq, em);
}
@@ -662,14 +584,12 @@ handle_notify_inbound (void *cls,
* @param smr the message we got
*/
static void
-handle_send_ready (void *cls,
- const struct SendMessageReady *smr)
+handle_send_ready (void *cls, const struct SendMessageReady *smr)
{
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &smr->peer);
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &smr->peer);
if (NULL == pr)
{
GNUNET_break (0);
@@ -693,8 +613,7 @@ handle_send_ready (void *cls,
}
/* ok, all good, send message out! */
- GNUNET_MQ_send (h->mq,
- pr->env);
+ GNUNET_MQ_send (h->mq, pr->env);
pr->env = NULL;
GNUNET_MQ_impl_send_continue (pr->mq);
}
@@ -709,39 +628,34 @@ handle_send_ready (void *cls,
static void
reconnect (struct GNUNET_CORE_Handle *h)
{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_fixed_size (init_reply,
- GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY,
- struct InitReplyMessage,
- h),
- GNUNET_MQ_hd_fixed_size (connect_notify,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT,
- struct ConnectNotifyMessage,
- h),
- GNUNET_MQ_hd_fixed_size (disconnect_notify,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT,
- struct DisconnectNotifyMessage,
- h),
- GNUNET_MQ_hd_var_size (notify_inbound,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND,
- struct NotifyTrafficMessage,
- h),
- GNUNET_MQ_hd_fixed_size (send_ready,
- GNUNET_MESSAGE_TYPE_CORE_SEND_READY,
- struct SendMessageReady,
- h),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_fixed_size (init_reply,
+ GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY,
+ struct InitReplyMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (connect_notify,
+ GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT,
+ struct ConnectNotifyMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (disconnect_notify,
+ GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT,
+ struct DisconnectNotifyMessage,
+ h),
+ GNUNET_MQ_hd_var_size (notify_inbound,
+ GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND,
+ struct NotifyTrafficMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (send_ready,
+ GNUNET_MESSAGE_TYPE_CORE_SEND_READY,
+ struct SendMessageReady,
+ h),
+ GNUNET_MQ_handler_end ()};
struct InitMessage *init;
struct GNUNET_MQ_Envelope *env;
uint16_t *ts;
GNUNET_assert (NULL == h->mq);
- h->mq = GNUNET_CLIENT_connect (h->cfg,
- "core",
- handlers,
- &handle_mq_error,
- h);
+ h->mq = GNUNET_CLIENT_connect (h->cfg, "core", handlers, &handle_mq_error,
h);
if (NULL == h->mq)
{
reconnect_later (h);
@@ -750,14 +664,12 @@ reconnect (struct GNUNET_CORE_Handle *h)
env = GNUNET_MQ_msg_extra (init,
sizeof (uint16_t) * h->hcnt,
GNUNET_MESSAGE_TYPE_CORE_INIT);
- LOG (GNUNET_ERROR_TYPE_INFO,
- "(Re)connecting to CORE service\n");
+ LOG (GNUNET_ERROR_TYPE_INFO, "(Re)connecting to CORE service\n");
init->options = htonl (0);
ts = (uint16_t *) &init[1];
for (unsigned int hpos = 0; hpos < h->hcnt; hpos++)
ts[hpos] = htons (h->handlers[hpos].type);
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
}
@@ -791,15 +703,13 @@ GNUNET_CORE_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
h->init = init;
h->connects = connects;
h->disconnects = disconnects;
- h->peers = GNUNET_CONTAINER_multipeermap_create (128,
- GNUNET_NO);
+ h->peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
h->handlers = GNUNET_MQ_copy_handlers (handlers);
h->hcnt = GNUNET_MQ_count_handlers (handlers);
GNUNET_assert (h->hcnt <
- (GNUNET_MAX_MESSAGE_SIZE -
- sizeof (struct InitMessage)) / sizeof (uint16_t));
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting to CORE service\n");
+ (GNUNET_MAX_MESSAGE_SIZE - sizeof (struct InitMessage)) /
+ sizeof (uint16_t));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service\n");
reconnect (h);
if (NULL == h->mq)
{
@@ -818,8 +728,7 @@ GNUNET_CORE_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
void
GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Disconnecting from CORE service\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from CORE service\n");
GNUNET_CONTAINER_multipeermap_iterate (handle->peers,
&disconnect_and_free_peer_entry,
handle);
@@ -849,12 +758,11 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
*/
struct GNUNET_MQ_Handle *
GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *pid)
+ const struct GNUNET_PeerIdentity *pid)
{
struct PeerRecord *pr;
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- pid);
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers, pid);
if (NULL == pr)
return NULL;
return pr->mq;
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index e26bb4d5c..740707ce1 100644
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -107,7 +107,6 @@ struct GSC_Client
* specifically cares about. Size of the @e types array.
*/
unsigned int tcnt;
-
};
@@ -150,12 +149,10 @@ static struct GSC_Client *client_tail;
* @return #GNUNET_YES if @a c is interested, #GNUNET_NO if not.
*/
static int
-type_match (uint16_t type,
- struct GSC_Client *c)
+type_match (uint16_t type, struct GSC_Client *c)
{
- if ( (0 == c->tcnt) &&
- (0 != c->options) )
- return GNUNET_YES; /* peer without handlers and inbound/outbond
+ if ((0 == c->tcnt) && (0 != c->options))
+ return GNUNET_YES; /* peer without handlers and inbound/outbond
callbacks matches ALL */
if (NULL == c->types)
return GNUNET_NO;
@@ -174,8 +171,7 @@ type_match (uint16_t type,
* @return #GNUNET_OK if @a im is well-formed
*/
static int
-check_client_init (void *cls,
- const struct InitMessage *im)
+check_client_init (void *cls, const struct InitMessage *im)
{
return GNUNET_OK;
}
@@ -188,8 +184,7 @@ check_client_init (void *cls,
* @param im the `struct InitMessage`
*/
static void
-handle_client_init (void *cls,
- const struct InitMessage *im)
+handle_client_init (void *cls, const struct InitMessage *im)
{
struct GSC_Client *c = cls;
struct GNUNET_MQ_Envelope *env;
@@ -206,24 +201,23 @@ handle_client_init (void *cls,
all_client_options |= c->options;
c->types = GNUNET_malloc (msize);
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (c->connectmap,
- &GSC_my_identity,
- NULL,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ c->connectmap,
+ &GSC_my_identity,
+ NULL,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
for (unsigned int i = 0; i < c->tcnt; i++)
c->types[i] = ntohs (types[i]);
- GSC_TYPEMAP_add (c->types,
- c->tcnt);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client connecting to core service is interested in %u message
types\n",
- (unsigned int) c->tcnt);
+ GSC_TYPEMAP_add (c->types, c->tcnt);
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Client connecting to core service is interested in %u message types\n",
+ (unsigned int) c->tcnt);
/* send init reply message */
- env = GNUNET_MQ_msg (irm,
- GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY);
+ env = GNUNET_MQ_msg (irm, GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY);
irm->reserved = htonl (0);
irm->my_identity = GSC_my_identity;
- GNUNET_MQ_send (c->mq,
- env);
+ GNUNET_MQ_send (c->mq, env);
GSC_SESSIONS_notify_client_about_sessions (c);
GNUNET_SERVICE_client_continue (c->client);
}
@@ -245,11 +239,11 @@ void
GSC_CLIENTS_reject_request (struct GSC_ClientActiveRequest *car,
int drop_client)
{
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (car->
- client_handle->requests,
- &car->target,
- car));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (car->client_handle->requests,
+ &car->target,
+ car));
if (GNUNET_YES == drop_client)
GNUNET_SERVICE_client_drop (car->client_handle->client);
GNUNET_free (car);
@@ -274,38 +268,31 @@ GSC_CLIENTS_solicit_request (struct
GSC_ClientActiveRequest *car)
c = car->client_handle;
if (GNUNET_YES !=
- GNUNET_CONTAINER_multipeermap_contains (c->connectmap,
- &car->target))
+ GNUNET_CONTAINER_multipeermap_contains (c->connectmap, &car->target))
{
/* connection has gone down since, drop request */
- GNUNET_assert (0 !=
- memcmp (&car->target,
- &GSC_my_identity,
- sizeof (struct GNUNET_PeerIdentity)));
+ GNUNET_assert (0 != memcmp (&car->target,
+ &GSC_my_identity,
+ sizeof (struct GNUNET_PeerIdentity)));
GSC_SESSIONS_dequeue_request (car);
- GSC_CLIENTS_reject_request (car,
- GNUNET_NO);
+ GSC_CLIENTS_reject_request (car, GNUNET_NO);
return;
}
delay = GNUNET_TIME_absolute_get_duration (car->received_time);
left = GNUNET_TIME_absolute_get_duration (car->deadline);
if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Client waited %s for permission to transmit to `%s'%s
(priority %u)\n",
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
- GNUNET_i2s (&car->target),
- (0 == left.rel_value_us)
- ? " (past deadline)"
- : "",
- car->priority);
- env = GNUNET_MQ_msg (smr,
- GNUNET_MESSAGE_TYPE_CORE_SEND_READY);
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ "Client waited %s for permission to transmit to `%s'%s (priority %u)\n",
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
+ GNUNET_i2s (&car->target),
+ (0 == left.rel_value_us) ? " (past deadline)" : "",
+ car->priority);
+ env = GNUNET_MQ_msg (smr, GNUNET_MESSAGE_TYPE_CORE_SEND_READY);
smr->size = htons (car->msize);
smr->smr_id = car->smr_id;
smr->peer = car->target;
- GNUNET_MQ_send (c->mq,
- env);
+ GNUNET_MQ_send (c->mq, env);
}
@@ -316,51 +303,47 @@ GSC_CLIENTS_solicit_request (struct
GSC_ClientActiveRequest *car)
* @param req the `struct SendMessageRequest`
*/
static void
-handle_client_send_request (void *cls,
- const struct SendMessageRequest *req)
+handle_client_send_request (void *cls, const struct SendMessageRequest *req)
{
struct GSC_Client *c = cls;
struct GSC_ClientActiveRequest *car;
int is_loopback;
if (NULL == c->requests)
- c->requests = GNUNET_CONTAINER_multipeermap_create (16,
- GNUNET_NO);
+ c->requests = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client asked for transmission to `%s'\n",
GNUNET_i2s (&req->peer));
- is_loopback =
- (0 ==
- memcmp (&req->peer,
- &GSC_my_identity,
- sizeof (struct GNUNET_PeerIdentity)));
+ is_loopback = (0 == memcmp (&req->peer,
+ &GSC_my_identity,
+ sizeof (struct GNUNET_PeerIdentity)));
if ((! is_loopback) &&
(GNUNET_YES !=
- GNUNET_CONTAINER_multipeermap_contains (c->connectmap,
- &req->peer)))
+ GNUNET_CONTAINER_multipeermap_contains (c->connectmap, &req->peer)))
{
/* neighbour must have disconnected since request was issued,
* ignore (client will realize it once it processes the
* disconnect notification) */
GNUNET_STATISTICS_update (GSC_stats,
- gettext_noop
- ("# send requests dropped (disconnected)"), 1,
+ gettext_noop (
+ "# send requests dropped (disconnected)"),
+ 1,
GNUNET_NO);
GNUNET_SERVICE_client_continue (c->client);
return;
}
- car = GNUNET_CONTAINER_multipeermap_get (c->requests,
- &req->peer);
+ car = GNUNET_CONTAINER_multipeermap_get (c->requests, &req->peer);
if (NULL == car)
{
/* create new entry */
car = GNUNET_new (struct GSC_ClientActiveRequest);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (c->requests,
- &req->peer,
- car,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+ GNUNET_CONTAINER_multipeermap_put (
+ c->requests,
+ &req->peer,
+ car,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
car->client_handle = c;
}
else
@@ -368,8 +351,9 @@ handle_client_send_request (void *cls,
/* dequeue and recycle memory from pending request, there can only
be at most one per client and peer */
GNUNET_STATISTICS_update (GSC_stats,
- gettext_noop ("# dequeuing CAR (duplicate
request)"),
- 1,
+ gettext_noop (
+ "# dequeuing CAR (duplicate request)"),
+ 1,
GNUNET_NO);
GSC_SESSIONS_dequeue_request (car);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -379,7 +363,7 @@ handle_client_send_request (void *cls,
car->target = req->peer;
car->received_time = GNUNET_TIME_absolute_get ();
car->deadline = GNUNET_TIME_absolute_ntoh (req->deadline);
- car->priority = (enum GNUNET_CORE_Priority) ntohl (req->priority);
+ car->priority = (enum GNUNET_MQ_PriorityPreferences) ntohl (req->priority);
car->msize = ntohs (req->size);
car->smr_id = req->smr_id;
car->was_solicited = GNUNET_NO;
@@ -408,13 +392,7 @@ struct TokenizerContext
/**
* How important is this message.
*/
- enum GNUNET_CORE_Priority priority;
-
- /**
- * Is corking allowed (set only once we have the real message).
- */
- int cork;
-
+ enum GNUNET_MQ_PriorityPreferences priority;
};
@@ -431,65 +409,57 @@ struct TokenizerContext
* #GNUNET_SYSERR to stop further processing with error
*/
static int
-tokenized_cb (void *cls,
- const struct GNUNET_MessageHeader *message)
+tokenized_cb (void *cls, const struct GNUNET_MessageHeader *message)
{
struct TokenizerContext *tc = cls;
struct GSC_ClientActiveRequest *car = tc->car;
char buf[92];
GNUNET_snprintf (buf,
- sizeof (buf),
- gettext_noop ("# bytes of messages of type %u received"),
- (unsigned int) ntohs (message->type));
- GNUNET_STATISTICS_update (GSC_stats,
- buf,
- ntohs (message->size),
- GNUNET_NO);
- if (0 ==
- memcmp (&car->target,
- &GSC_my_identity,
- sizeof (struct GNUNET_PeerIdentity)))
+ sizeof (buf),
+ gettext_noop ("# bytes of messages of type %u received"),
+ (unsigned int) ntohs (message->type));
+ GNUNET_STATISTICS_update (GSC_stats, buf, ntohs (message->size), GNUNET_NO);
+ if (0 == memcmp (&car->target,
+ &GSC_my_identity,
+ sizeof (struct GNUNET_PeerIdentity)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Delivering message of type %u to myself\n",
ntohs (message->type));
GSC_CLIENTS_deliver_message (&GSC_my_identity,
- message,
- ntohs (message->size),
- GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
+ message,
+ ntohs (message->size),
+ GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
GSC_CLIENTS_deliver_message (&GSC_my_identity,
- message,
- sizeof (struct GNUNET_MessageHeader),
- GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
+ message,
+ sizeof (struct GNUNET_MessageHeader),
+ GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
GSC_CLIENTS_deliver_message (&GSC_my_identity,
- message,
- ntohs (message->size),
- GNUNET_CORE_OPTION_SEND_FULL_INBOUND);
+ message,
+ ntohs (message->size),
+ GNUNET_CORE_OPTION_SEND_FULL_INBOUND);
GSC_CLIENTS_deliver_message (&GSC_my_identity,
- message,
- sizeof (struct GNUNET_MessageHeader),
- GNUNET_CORE_OPTION_SEND_HDR_INBOUND);
+ message,
+ sizeof (struct GNUNET_MessageHeader),
+ GNUNET_CORE_OPTION_SEND_HDR_INBOUND);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Delivering message of type %u and size %u to %s\n",
ntohs (message->type),
- ntohs (message->size),
+ ntohs (message->size),
GNUNET_i2s (&car->target));
GSC_CLIENTS_deliver_message (&car->target,
- message,
- ntohs (message->size),
- GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
+ message,
+ ntohs (message->size),
+ GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
GSC_CLIENTS_deliver_message (&car->target,
- message,
- sizeof (struct GNUNET_MessageHeader),
- GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
- GSC_SESSIONS_transmit (car,
- message,
- tc->cork,
- tc->priority);
+ message,
+ sizeof (struct GNUNET_MessageHeader),
+ GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
+ GSC_SESSIONS_transmit (car, message, tc->priority);
}
return GNUNET_OK;
}
@@ -503,8 +473,7 @@ tokenized_cb (void *cls,
* @return #GNUNET_OK if @a sm is well-formed
*/
static int
-check_client_send (void *cls,
- const struct SendMessage *sm)
+check_client_send (void *cls, const struct SendMessage *sm)
{
return GNUNET_OK;
}
@@ -517,8 +486,7 @@ check_client_send (void *cls,
* @param sm the `struct SendMessage`
*/
static void
-handle_client_send (void *cls,
- const struct SendMessage *sm)
+handle_client_send (void *cls, const struct SendMessage *sm)
{
struct GSC_Client *c = cls;
struct TokenizerContext tc;
@@ -527,9 +495,7 @@ handle_client_send (void *cls,
struct GNUNET_MessageStreamTokenizer *mst;
msize = ntohs (sm->header.size) - sizeof (struct SendMessage);
- GNUNET_break (0 == ntohl (sm->reserved));
- tc.car = GNUNET_CONTAINER_multipeermap_get (c->requests,
- &sm->peer);
+ tc.car = GNUNET_CONTAINER_multipeermap_get (c->requests, &sm->peer);
if (NULL == tc.car)
{
/* Must have been that we first approved the request, then got disconnected
@@ -538,43 +504,37 @@ handle_client_send (void *cls,
* might also now be *again* connected. So this can happen (but should be
* rare). If it does happen, the message is discarded. */
GNUNET_STATISTICS_update (GSC_stats,
- gettext_noop ("# messages discarded (session
disconnected)"),
+ gettext_noop (
+ "# messages discarded (session disconnected)"),
1,
- GNUNET_NO);
+ GNUNET_NO);
GNUNET_SERVICE_client_continue (c->client);
return;
}
delay = GNUNET_TIME_absolute_get_duration (tc.car->received_time);
- tc.cork = ntohl (sm->cork);
- tc.priority = (enum GNUNET_CORE_Priority) ntohl (sm->priority);
+ tc.priority = (enum GNUNET_MQ_PriorityPreferences) ntohl (sm->priority);
if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Client waited %s for transmission of %u bytes to `%s'%s\n",
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
+ "Client waited %s for transmission of %u bytes to `%s'\n",
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
msize,
- GNUNET_i2s (&sm->peer),
- tc.cork ? " (cork)" : " (uncorked)");
+ GNUNET_i2s (&sm->peer));
else
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Client waited %s for transmission of %u bytes to `%s'%s\n",
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
+ "Client waited %s for transmission of %u bytes to `%s'\n",
+ GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES),
msize,
- GNUNET_i2s (&sm->peer),
- tc.cork ? " (cork)" : " (uncorked)");
+ GNUNET_i2s (&sm->peer));
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (c->requests,
- &sm->peer,
- tc.car));
- mst = GNUNET_MST_create (&tokenized_cb,
- &tc);
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (c->requests, &sm->peer, tc.car));
+ mst = GNUNET_MST_create (&tokenized_cb, &tc);
GNUNET_MST_from_buffer (mst,
- (const char *) &sm[1],
- msize,
- GNUNET_YES,
- GNUNET_NO);
+ (const char *) &sm[1],
+ msize,
+ GNUNET_YES,
+ GNUNET_NO);
GNUNET_MST_destroy (mst);
GSC_SESSIONS_dequeue_request (tc.car);
GNUNET_free (tc.car);
@@ -592,16 +552,16 @@ handle_client_send (void *cls,
*/
static int
destroy_active_client_request (void *cls,
- const struct GNUNET_PeerIdentity *key,
+ const struct GNUNET_PeerIdentity *key,
void *value)
{
struct GSC_ClientActiveRequest *car = value;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (car->
- client_handle->requests,
- &car->target,
- car));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (car->client_handle->requests,
+ &car->target,
+ car));
GSC_SESSIONS_dequeue_request (car);
GNUNET_free (car);
return GNUNET_YES;
@@ -618,19 +578,16 @@ destroy_active_client_request (void *cls,
*/
static void *
client_connect_cb (void *cls,
- struct GNUNET_SERVICE_Client *client,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_SERVICE_Client *client,
+ struct GNUNET_MQ_Handle *mq)
{
struct GSC_Client *c;
c = GNUNET_new (struct GSC_Client);
c->client = client;
c->mq = mq;
- c->connectmap = GNUNET_CONTAINER_multipeermap_create (16,
- GNUNET_NO);
- GNUNET_CONTAINER_DLL_insert (client_head,
- client_tail,
- c);
+ c->connectmap = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
+ GNUNET_CONTAINER_DLL_insert (client_head, client_tail, c);
return c;
}
@@ -644,17 +601,15 @@ client_connect_cb (void *cls,
*/
static void
client_disconnect_cb (void *cls,
- struct GNUNET_SERVICE_Client *client,
- void *app_ctx)
+ struct GNUNET_SERVICE_Client *client,
+ void *app_ctx)
{
struct GSC_Client *c = app_ctx;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client %p has disconnected from core service.\n",
client);
- GNUNET_CONTAINER_DLL_remove (client_head,
- client_tail,
- c);
+ GNUNET_CONTAINER_DLL_remove (client_head, client_tail, c);
if (NULL != c->requests)
{
GNUNET_CONTAINER_multipeermap_iterate (c->requests,
@@ -666,15 +621,14 @@ client_disconnect_cb (void *cls,
c->connectmap = NULL;
if (NULL != c->types)
{
- GSC_TYPEMAP_remove (c->types,
- c->tcnt);
+ GSC_TYPEMAP_remove (c->types, c->tcnt);
GNUNET_free (c->types);
}
GNUNET_free (c);
/* recalculate 'all_client_options' */
all_client_options = 0;
- for (c = client_head; NULL != c ; c = c->next)
+ for (c = client_head; NULL != c; c = c->next)
all_client_options |= c->options;
}
@@ -690,10 +644,11 @@ client_disconnect_cb (void *cls,
* @param tmap_new updated type map for the neighbour, NULL for disconnect
*/
void
-GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client,
- const struct GNUNET_PeerIdentity
*neighbour,
- const struct GSC_TypeMap *tmap_old,
- const struct GSC_TypeMap *tmap_new)
+GSC_CLIENTS_notify_client_about_neighbour (
+ struct GSC_Client *client,
+ const struct GNUNET_PeerIdentity *neighbour,
+ const struct GSC_TypeMap *tmap_old,
+ const struct GSC_TypeMap *tmap_new)
{
struct GNUNET_MQ_Envelope *env;
int old_match;
@@ -701,12 +656,8 @@ GSC_CLIENTS_notify_client_about_neighbour (struct
GSC_Client *client,
if (GNUNET_YES != client->got_init)
return;
- old_match = GSC_TYPEMAP_test_match (tmap_old,
- client->types,
- client->tcnt);
- new_match = GSC_TYPEMAP_test_match (tmap_new,
- client->types,
- client->tcnt);
+ old_match = GSC_TYPEMAP_test_match (tmap_old, client->types, client->tcnt);
+ new_match = GSC_TYPEMAP_test_match (tmap_new, client->types, client->tcnt);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Notifying client about neighbour %s (%d/%d)\n",
GNUNET_i2s (neighbour),
@@ -714,55 +665,52 @@ GSC_CLIENTS_notify_client_about_neighbour (struct
GSC_Client *client,
new_match);
if (old_match == new_match)
{
- GNUNET_assert (old_match ==
- GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
- neighbour));
- return; /* no change */
+ GNUNET_assert (
+ old_match ==
+ GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour));
+ return; /* no change */
}
if (GNUNET_NO == old_match)
{
struct ConnectNotifyMessage *cnm;
/* send connect */
- GNUNET_assert (GNUNET_NO ==
- GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
- neighbour));
+ GNUNET_assert (
+ GNUNET_NO ==
+ GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour));
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (client->connectmap,
- neighbour,
- NULL,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- env = GNUNET_MQ_msg (cnm,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
+ GNUNET_CONTAINER_multipeermap_put (
+ client->connectmap,
+ neighbour,
+ NULL,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ env = GNUNET_MQ_msg (cnm, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
cnm->reserved = htonl (0);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending NOTIFY_CONNECT message about peer %s to client.\n",
GNUNET_i2s (neighbour));
cnm->peer = *neighbour;
- GNUNET_MQ_send (client->mq,
- env);
+ GNUNET_MQ_send (client->mq, env);
}
else
{
struct DisconnectNotifyMessage *dcm;
/* send disconnect */
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
- neighbour));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_contains (client->connectmap, neighbour));
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (client->connectmap,
neighbour,
NULL));
- env = GNUNET_MQ_msg (dcm,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
+ env = GNUNET_MQ_msg (dcm, GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
dcm->reserved = htonl (0);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending NOTIFY_DISCONNECT message about peer %s to client.\n",
GNUNET_i2s (neighbour));
dcm->peer = *neighbour;
- GNUNET_MQ_send (client->mq,
- env);
+ GNUNET_MQ_send (client->mq, env);
}
}
@@ -777,17 +725,18 @@ GSC_CLIENTS_notify_client_about_neighbour (struct
GSC_Client *client,
* @param tmap_new updated type map for the neighbour, NULL for disconnect
*/
void
-GSC_CLIENTS_notify_clients_about_neighbour (const struct GNUNET_PeerIdentity
*neighbour,
- const struct GSC_TypeMap *tmap_old,
- const struct GSC_TypeMap *tmap_new)
+GSC_CLIENTS_notify_clients_about_neighbour (
+ const struct GNUNET_PeerIdentity *neighbour,
+ const struct GSC_TypeMap *tmap_old,
+ const struct GSC_TypeMap *tmap_new)
{
struct GSC_Client *c;
for (c = client_head; NULL != c; c = c->next)
GSC_CLIENTS_notify_client_about_neighbour (c,
- neighbour,
+ neighbour,
tmap_old,
- tmap_new);
+ tmap_new);
}
@@ -815,15 +764,14 @@ GSC_CLIENTS_deliver_message (const struct
GNUNET_PeerIdentity *sender,
GNUNET_break (0);
return;
}
- if (! ( (0 != (all_client_options & options)) ||
- (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ))
+ if (! ((0 != (all_client_options & options)) ||
+ (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))))
return; /* no client cares about this message notification */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Core service passes message from `%s' of type %u to client.\n",
GNUNET_i2s (sender),
(unsigned int) ntohs (msg->type));
- GSC_SESSIONS_add_to_typemap (sender,
- ntohs (msg->type));
+ GSC_SESSIONS_add_to_typemap (sender, ntohs (msg->type));
for (struct GSC_Client *c = client_head; NULL != c; c = c->next)
{
@@ -833,18 +781,17 @@ GSC_CLIENTS_deliver_message (const struct
GNUNET_PeerIdentity *sender,
unsigned int qlen;
int tm;
- tm = type_match (ntohs (msg->type),
- c);
- if (! ( (0 != (c->options & options)) ||
- ( (0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) &&
- (GNUNET_YES == tm) ) ) )
- continue; /* neither options nor type match permit the message */
- if ( (0 != (options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)) &&
- ( (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
- (GNUNET_YES == tm) ) )
+ tm = type_match (ntohs (msg->type), c);
+ if (! ((0 != (c->options & options)) ||
+ ((0 != (options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) &&
+ (GNUNET_YES == tm))))
+ continue; /* neither options nor type match permit the message */
+ if ((0 != (options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)) &&
+ ((0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
+ (GNUNET_YES == tm)))
continue;
- if ( (0 != (options & GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND)) &&
- (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)) )
+ if ((0 != (options & GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND)) &&
+ (0 != (c->options & GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND)))
continue;
/* Drop messages if:
@@ -862,54 +809,50 @@ GSC_CLIENTS_deliver_message (const struct
GNUNET_PeerIdentity *sender,
(ACK, queries) which may be cummulative or highly redundant,
and cheap to drop than data traffic. */
qlen = GNUNET_MQ_get_length (c->mq);
- if ( (qlen >= HARD_MAX_QUEUE) ||
- ( (qlen > SOFT_MAX_QUEUE) &&
- ( (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
- ntohs (msg->size)) ) <
- (qlen - SOFT_MAX_QUEUE) * 0x8000 /
- (HARD_MAX_QUEUE - SOFT_MAX_QUEUE) ) ) )
+ if ((qlen >= HARD_MAX_QUEUE) ||
+ ((qlen > SOFT_MAX_QUEUE) &&
+ ((GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+ ntohs (msg->size))) <
+ (qlen - SOFT_MAX_QUEUE) * 0x8000 /
+ (HARD_MAX_QUEUE - SOFT_MAX_QUEUE))))
{
char buf[1024];
- GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
- "Dropping decrypted message of type %u as client is too busy
(queue full)\n",
- (unsigned int) ntohs (msg->type));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
+ "Dropping decrypted message of type %u as client is too busy (queue
full)\n",
+ (unsigned int) ntohs (msg->type));
GNUNET_snprintf (buf,
sizeof (buf),
- gettext_noop ("# messages of type %u discarded (client
busy)"),
+ gettext_noop (
+ "# messages of type %u discarded (client busy)"),
(unsigned int) ntohs (msg->type));
- GNUNET_STATISTICS_update (GSC_stats,
- buf,
- 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (GSC_stats, buf, 1, GNUNET_NO);
continue;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending %u message with %u bytes to client interested in
messages of type %u.\n",
- options,
- ntohs (msg->size),
- (unsigned int) ntohs (msg->type));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Sending %u message with %u bytes to client interested in messages of
type %u.\n",
+ options,
+ ntohs (msg->size),
+ (unsigned int) ntohs (msg->type));
- if (0 != (options & (GNUNET_CORE_OPTION_SEND_FULL_INBOUND |
GNUNET_CORE_OPTION_SEND_HDR_INBOUND)))
+ if (0 != (options & (GNUNET_CORE_OPTION_SEND_FULL_INBOUND |
+ GNUNET_CORE_OPTION_SEND_HDR_INBOUND)))
mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND;
else
mtype = GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND;
- env = GNUNET_MQ_msg_extra (ntm,
- msize,
- mtype);
+ env = GNUNET_MQ_msg_extra (ntm, msize, mtype);
ntm->peer = *sender;
- GNUNET_memcpy (&ntm[1],
- msg,
- msize);
-
- GNUNET_assert ( (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
||
- (GNUNET_YES != tm) ||
- (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_contains (c->connectmap,
- sender)) );
- GNUNET_MQ_send (c->mq,
- env);
+ GNUNET_memcpy (&ntm[1], msg, msize);
+
+ GNUNET_assert (
+ (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
+ (GNUNET_YES != tm) ||
+ (GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_contains (c->connectmap, sender)));
+ GNUNET_MQ_send (c->mq, env);
}
}
@@ -925,8 +868,7 @@ shutdown_task (void *cls)
{
struct GSC_Client *c;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Core service shutting down.\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core service shutting down.\n");
while (NULL != (c = client_head))
GNUNET_SERVICE_client_drop (c->client);
GSC_SESSIONS_done ();
@@ -934,8 +876,7 @@ shutdown_task (void *cls)
GSC_TYPEMAP_done ();
if (NULL != GSC_stats)
{
- GNUNET_STATISTICS_destroy (GSC_stats,
- GNUNET_NO);
+ GNUNET_STATISTICS_destroy (GSC_stats, GNUNET_NO);
GSC_stats = NULL;
}
GSC_cfg = NULL;
@@ -953,7 +894,7 @@ shutdown_task (void *cls)
*/
static void
handle_client_monitor_peers (void *cls,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_MessageHeader *message)
{
struct GSC_Client *c = cls;
@@ -978,21 +919,19 @@ run (void *cls,
char *keyfile;
GSC_cfg = c;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (GSC_cfg,
- "PEER",
- "PRIVATE_KEY",
- &keyfile))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (GSC_cfg,
+ "PEER",
+ "PRIVATE_KEY",
+ &keyfile))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Core service is lacking HOSTKEY configuration setting.
Exiting.\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_ERROR,
+ _ ("Core service is lacking HOSTKEY configuration setting.
Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
- GSC_stats = GNUNET_STATISTICS_create ("core",
- GSC_cfg);
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
+ GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
GNUNET_SERVICE_suspend (service);
GSC_TYPEMAP_init ();
pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
@@ -1006,7 +945,7 @@ run (void *cls,
GSC_SESSIONS_init ();
GNUNET_SERVICE_resume (service);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Core service of `%s' ready.\n"),
+ _ ("Core service of `%s' ready.\n"),
GNUNET_i2s (&GSC_my_identity));
}
@@ -1014,30 +953,30 @@ run (void *cls,
/**
* Define "main" method using service macro.
*/
-GNUNET_SERVICE_MAIN
-("core",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_var_size (client_init,
- GNUNET_MESSAGE_TYPE_CORE_INIT,
- struct InitMessage,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_monitor_peers,
- GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_hd_fixed_size (client_send_request,
- GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST,
- struct SendMessageRequest,
- NULL),
- GNUNET_MQ_hd_var_size (client_send,
- GNUNET_MESSAGE_TYPE_CORE_SEND,
- struct SendMessage,
- NULL),
- GNUNET_MQ_handler_end ());
+GNUNET_SERVICE_MAIN (
+ "core",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ GNUNET_MQ_hd_var_size (client_init,
+ GNUNET_MESSAGE_TYPE_CORE_INIT,
+ struct InitMessage,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_monitor_peers,
+ GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_hd_fixed_size (client_send_request,
+ GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST,
+ struct SendMessageRequest,
+ NULL),
+ GNUNET_MQ_hd_var_size (client_send,
+ GNUNET_MESSAGE_TYPE_CORE_SEND,
+ struct SendMessage,
+ NULL),
+ GNUNET_MQ_handler_end ());
/* end of gnunet-service-core.c */
diff --git a/src/core/gnunet-service-core.h b/src/core/gnunet-service-core.h
index 00461c5ab..154596933 100644
--- a/src/core/gnunet-service-core.h
+++ b/src/core/gnunet-service-core.h
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -81,7 +81,7 @@ struct GSC_ClientActiveRequest
/**
* How important is this request.
*/
- enum GNUNET_CORE_Priority priority;
+ enum GNUNET_MQ_PriorityPreferences priority;
/**
* Has this request been solicited yet?
@@ -97,7 +97,6 @@ struct GSC_ClientActiveRequest
* Unique request ID (in big endian).
*/
uint16_t smr_id;
-
};
@@ -140,10 +139,11 @@ GSC_CLIENTS_reject_request (struct
GSC_ClientActiveRequest *car,
* @param tmap_new updated type map for the neighbour, NULL for disconnect
*/
void
-GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client,
- const struct GNUNET_PeerIdentity
*neighbour,
- const struct GSC_TypeMap *tmap_old,
- const struct GSC_TypeMap *tmap_new);
+GSC_CLIENTS_notify_client_about_neighbour (
+ struct GSC_Client *client,
+ const struct GNUNET_PeerIdentity *neighbour,
+ const struct GSC_TypeMap *tmap_old,
+ const struct GSC_TypeMap *tmap_new);
/**
@@ -174,9 +174,10 @@ GSC_CLIENTS_deliver_message (const struct
GNUNET_PeerIdentity *sender,
* @param tmap_new updated type map for the neighbour, NULL for disconnect
*/
void
-GSC_CLIENTS_notify_clients_about_neighbour (const struct GNUNET_PeerIdentity
*neighbour,
- const struct GSC_TypeMap *tmap_old,
- const struct GSC_TypeMap
*tmap_new);
+GSC_CLIENTS_notify_clients_about_neighbour (
+ const struct GNUNET_PeerIdentity *neighbour,
+ const struct GSC_TypeMap *tmap_old,
+ const struct GSC_TypeMap *tmap_new);
/**
diff --git a/src/core/gnunet-service-core_sessions.c
b/src/core/gnunet-service-core_sessions.c
index 4f678c784..8ff61ec20 100644
--- a/src/core/gnunet-service-core_sessions.c
+++ b/src/core/gnunet-service-core_sessions.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -59,7 +59,7 @@ struct SessionMessageEntry
/**
* How important is this message.
*/
- enum GNUNET_CORE_Priority priority;
+ enum GNUNET_MQ_PriorityPreferences priority;
/**
* Flag set to #GNUNET_YES if this is a typemap message.
@@ -84,7 +84,6 @@ struct SessionMessageEntry
* MessageEntry` itself!)
*/
size_t size;
-
};
@@ -177,7 +176,6 @@ struct TypeMapConfirmationMessage
* Hash of the (decompressed) type map that was received.
*/
struct GNUNET_HashCode tm_hash;
-
};
GNUNET_NETWORK_STRUCT_END
@@ -201,8 +199,7 @@ find_session (const struct GNUNET_PeerIdentity *peer)
{
if (NULL == sessions)
return NULL;
- return GNUNET_CONTAINER_multipeermap_get (sessions,
- peer);
+ return GNUNET_CONTAINER_multipeermap_get (sessions, peer);
}
@@ -233,15 +230,13 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid)
while (NULL != (car = session->active_client_request_head))
{
GNUNET_CONTAINER_DLL_remove (session->active_client_request_head,
- session->active_client_request_tail, car);
- GSC_CLIENTS_reject_request (car,
- GNUNET_NO);
+ session->active_client_request_tail,
+ car);
+ GSC_CLIENTS_reject_request (car, GNUNET_NO);
}
while (NULL != (sme = session->sme_head))
{
- GNUNET_CONTAINER_DLL_remove (session->sme_head,
- session->sme_tail,
- sme);
+ GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme);
GNUNET_free (sme);
}
if (NULL != session->typemap_task)
@@ -251,13 +246,12 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid)
}
GSC_CLIENTS_notify_clients_about_neighbour (session->peer,
session->tmap,
- NULL);
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (sessions,
- session->peer,
- session));
+ NULL);
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (sessions, session->peer, session));
GNUNET_STATISTICS_set (GSC_stats,
- gettext_noop ("# peers connected"),
+ gettext_noop ("# peers connected"),
GNUNET_CONTAINER_multipeermap_size (sessions),
GNUNET_NO);
GSC_TYPEMAP_destroy (session->tmap);
@@ -286,20 +280,15 @@ transmit_typemap_task (void *cls)
delay = session->typemap_delay;
/* randomize a bit to avoid spont. sync */
delay.rel_value_us +=
- GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
- 1000 * 1000);
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000 * 1000);
session->typemap_task =
- GNUNET_SCHEDULER_add_delayed (delay,
- &transmit_typemap_task,
- session);
+ GNUNET_SCHEDULER_add_delayed (delay, &transmit_typemap_task, session);
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop ("# type map refreshes sent"),
1,
GNUNET_NO);
hdr = GSC_TYPEMAP_compute_type_map_message ();
- GSC_KX_encrypt_and_transmit (session->kx,
- hdr,
- ntohs (hdr->size));
+ GSC_KX_encrypt_and_transmit (session->kx, hdr, ntohs (hdr->size));
GNUNET_free (hdr);
}
@@ -315,10 +304,9 @@ start_typemap_task (struct Session *session)
if (NULL != session->typemap_task)
GNUNET_SCHEDULER_cancel (session->typemap_task);
session->typemap_delay = GNUNET_TIME_UNIT_SECONDS;
- session->typemap_task =
- GNUNET_SCHEDULER_add_delayed (session->typemap_delay,
- &transmit_typemap_task,
- session);
+ session->typemap_task = GNUNET_SCHEDULER_add_delayed (session->typemap_delay,
+ &transmit_typemap_task,
+ session);
}
@@ -342,17 +330,16 @@ GSC_SESSIONS_create (const struct GNUNET_PeerIdentity
*peer,
session->peer = peer;
session->kx = kx;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (sessions,
- session->peer,
- session,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ sessions,
+ session->peer,
+ session,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
GNUNET_STATISTICS_set (GSC_stats,
- gettext_noop ("# peers connected"),
+ gettext_noop ("# peers connected"),
GNUNET_CONTAINER_multipeermap_size (sessions),
GNUNET_NO);
- GSC_CLIENTS_notify_clients_about_neighbour (peer,
- NULL,
- session->tmap);
+ GSC_CLIENTS_notify_clients_about_neighbour (peer, NULL, session->tmap);
start_typemap_task (session);
}
@@ -406,15 +393,15 @@ GSC_SESSIONS_confirm_typemap (const struct
GNUNET_PeerIdentity *peer,
return;
}
cmsg = (const struct TypeMapConfirmationMessage *) msg;
- if (GNUNET_YES !=
- GSC_TYPEMAP_check_hash (&cmsg->tm_hash))
+ if (GNUNET_YES != GSC_TYPEMAP_check_hash (&cmsg->tm_hash))
{
/* our typemap has changed in the meantime, do not
accept confirmation */
GNUNET_STATISTICS_update (GSC_stats,
- gettext_noop
- ("# outdated typemap confirmations received"),
- 1, GNUNET_NO);
+ gettext_noop (
+ "# outdated typemap confirmations received"),
+ 1,
+ GNUNET_NO);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Got outdated typemap confirmated from peer `%s'\n",
GNUNET_i2s (session->peer));
@@ -429,9 +416,10 @@ GSC_SESSIONS_confirm_typemap (const struct
GNUNET_PeerIdentity *peer,
session->typemap_task = NULL;
}
GNUNET_STATISTICS_update (GSC_stats,
- gettext_noop
- ("# valid typemap confirmations received"),
- 1, GNUNET_NO);
+ gettext_noop (
+ "# valid typemap confirmations received"),
+ 1,
+ GNUNET_NO);
}
@@ -453,7 +441,7 @@ notify_client_about_session (void *cls,
GSC_CLIENTS_notify_client_about_neighbour (client,
session->peer,
- NULL, /* old TMAP: none */
+ NULL, /* old TMAP: none */
session->tmap);
return GNUNET_OK;
}
@@ -503,16 +491,14 @@ GSC_SESSIONS_queue_request (struct
GSC_ClientActiveRequest *car)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Dropped client request for transmission (am disconnected)\n");
- GNUNET_break (0); /* should have been rejected earlier */
- GSC_CLIENTS_reject_request (car,
- GNUNET_NO);
+ GNUNET_break (0); /* should have been rejected earlier */
+ GSC_CLIENTS_reject_request (car, GNUNET_NO);
return;
}
if (car->msize > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
{
GNUNET_break (0);
- GSC_CLIENTS_reject_request (car,
- GNUNET_YES);
+ GSC_CLIENTS_reject_request (car, GNUNET_YES);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -535,10 +521,9 @@ GSC_SESSIONS_dequeue_request (struct
GSC_ClientActiveRequest *car)
{
struct Session *session;
- if (0 ==
- memcmp (&car->target,
- &GSC_my_identity,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&car->target,
+ &GSC_my_identity,
+ sizeof (struct GNUNET_PeerIdentity)))
return;
session = find_session (&car->target);
GNUNET_assert (NULL != session);
@@ -560,21 +545,20 @@ GSC_SESSIONS_dequeue_request (struct
GSC_ClientActiveRequest *car)
* @param msize how many bytes do we have already
*/
static void
-solicit_messages (struct Session *session,
- size_t msize)
+solicit_messages (struct Session *session, size_t msize)
{
struct GSC_ClientActiveRequest *car;
struct GSC_ClientActiveRequest *nxt;
size_t so_size;
- enum GNUNET_CORE_Priority pmax;
+ enum GNUNET_MQ_PriorityPreferences pmax;
so_size = msize;
- pmax = GNUNET_CORE_PRIO_BACKGROUND;
+ pmax = GNUNET_MQ_PRIO_BACKGROUND;
for (car = session->active_client_request_head; NULL != car; car = car->next)
{
if (GNUNET_YES == car->was_solicited)
continue;
- pmax = GNUNET_MAX (pmax, car->priority);
+ pmax = GNUNET_MAX (pmax, car->priority & GNUNET_MQ_PRIORITY_MASK);
}
nxt = session->active_client_request_head;
while (NULL != (car = nxt))
@@ -631,11 +615,11 @@ try_transmission (struct Session *session)
size_t msize;
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Absolute min_deadline;
- enum GNUNET_CORE_Priority maxp;
- enum GNUNET_CORE_Priority maxpc;
+ enum GNUNET_MQ_PriorityPreferences maxp;
+ enum GNUNET_MQ_PriorityPreferences maxpc;
struct GSC_ClientActiveRequest *car;
int excess;
-
+
msize = 0;
min_deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
/* if the peer has excess bandwidth, background traffic is allowed,
@@ -649,9 +633,9 @@ try_transmission (struct Session *session)
}
excess = GSC_NEIGHBOURS_check_excess_bandwidth (session->kx);
if (GNUNET_YES == excess)
- maxp = GNUNET_CORE_PRIO_BACKGROUND;
+ maxp = GNUNET_MQ_PRIO_BACKGROUND;
else
- maxp = GNUNET_CORE_PRIO_BEST_EFFORT;
+ maxp = GNUNET_MQ_PRIO_BEST_EFFORT;
/* determine highest priority of 'ready' messages we already solicited from
clients */
pos = session->sme_head;
while ((NULL != pos) &&
@@ -659,32 +643,33 @@ try_transmission (struct Session *session)
{
GNUNET_assert (pos->size < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE);
msize += pos->size;
- maxp = GNUNET_MAX (maxp, pos->priority);
- min_deadline = GNUNET_TIME_absolute_min (min_deadline,
- pos->deadline);
+ maxp = GNUNET_MAX (maxp, pos->priority & GNUNET_MQ_PRIORITY_MASK);
+ min_deadline = GNUNET_TIME_absolute_min (min_deadline, pos->deadline);
pos = pos->next;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Calculating transmission set with %u priority (%s) and %s
earliest deadline\n",
- maxp,
- (GNUNET_YES == excess) ? "excess bandwidth" : "limited
bandwidth",
- GNUNET_STRINGS_relative_time_to_string
(GNUNET_TIME_absolute_get_remaining (min_deadline),
- GNUNET_YES));
-
- if (maxp < GNUNET_CORE_PRIO_CRITICAL_CONTROL)
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Calculating transmission set with %u priority (%s) and %s earliest
deadline\n",
+ maxp,
+ (GNUNET_YES == excess) ? "excess bandwidth" : "limited bandwidth",
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining
(
+ min_deadline),
+ GNUNET_YES));
+
+ if (maxp < GNUNET_MQ_PRIO_CRITICAL_CONTROL)
{
/* if highest already solicited priority from clients is not critical,
check if there are higher-priority messages to be solicited from
clients */
if (GNUNET_YES == excess)
- maxpc = GNUNET_CORE_PRIO_BACKGROUND;
+ maxpc = GNUNET_MQ_PRIO_BACKGROUND;
else
- maxpc = GNUNET_CORE_PRIO_BEST_EFFORT;
- for (car = session->active_client_request_head; NULL != car; car =
car->next)
+ maxpc = GNUNET_MQ_PRIO_BEST_EFFORT;
+ for (car = session->active_client_request_head; NULL != car;
+ car = car->next)
{
if (GNUNET_YES == car->was_solicited)
continue;
- maxpc = GNUNET_MAX (maxpc,
- car->priority);
+ maxpc = GNUNET_MAX (maxpc, car->priority & GNUNET_MQ_PRIORITY_MASK);
}
if (maxpc > maxp)
{
@@ -703,41 +688,40 @@ try_transmission (struct Session *session)
{
/* never solicit more, we have critical messages to process */
excess = GNUNET_NO;
- maxpc = GNUNET_CORE_PRIO_BACKGROUND;
+ maxpc = GNUNET_MQ_PRIO_BACKGROUND;
}
now = GNUNET_TIME_absolute_get ();
- if ( ( (GNUNET_YES == excess) ||
- (maxpc >= GNUNET_CORE_PRIO_BEST_EFFORT) ) &&
- ( (0 == msize) ||
- ( (msize < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / 2) &&
- (min_deadline.abs_value_us > now.abs_value_us))) )
+ if (((GNUNET_YES == excess) || (maxpc >= GNUNET_MQ_PRIO_BEST_EFFORT)) &&
+ ((0 == msize) ||
+ ((msize < GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE / 2) &&
+ (min_deadline.abs_value_us > now.abs_value_us))))
{
/* not enough ready yet (tiny message & cork possible), or no messages at
all,
and either excess bandwidth or best-effort or higher message waiting at
client; in this case, we try to solicit more */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Soliciting messages (excess %d, maxpc %d, message size %u,
deadline %s)\n",
- excess,
- maxpc,
- (unsigned int) msize,
- GNUNET_STRINGS_relative_time_to_string
(GNUNET_TIME_absolute_get_remaining (min_deadline),
- GNUNET_YES));
- solicit_messages (session,
- msize);
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Soliciting messages (excess %d, maxpc %d, message size %u, deadline
%s)\n",
+ excess,
+ maxpc,
+ (unsigned int) msize,
+ GNUNET_STRINGS_relative_time_to_string
(GNUNET_TIME_absolute_get_remaining (
+ min_deadline),
+ GNUNET_YES));
+ solicit_messages (session, msize);
if (msize > 0)
{
/* if there is data to send, just not yet, make sure we do transmit
* it once the deadline is reached */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Corking until %s\n",
- GNUNET_STRINGS_relative_time_to_string
(GNUNET_TIME_absolute_get_remaining (min_deadline),
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (
+ GNUNET_TIME_absolute_get_remaining (min_deadline),
+ GNUNET_YES));
if (NULL != session->cork_task)
GNUNET_SCHEDULER_cancel (session->cork_task);
- session->cork_task
- = GNUNET_SCHEDULER_add_at (min_deadline,
- &pop_cork_task,
- session);
+ session->cork_task =
+ GNUNET_SCHEDULER_add_at (min_deadline, &pop_cork_task, session);
}
else
{
@@ -753,26 +737,21 @@ try_transmission (struct Session *session)
{
static unsigned long long total_bytes;
static unsigned int total_msgs;
- char pbuf[msize]; /* plaintext */
+ char pbuf[msize]; /* plaintext */
size_t used;
used = 0;
- while ( (NULL != (pos = session->sme_head)) &&
- (used + pos->size <= msize) )
+ while ((NULL != (pos = session->sme_head)) && (used + pos->size <= msize))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Adding message of type %d (%d/%d) to payload for %s\n",
- ntohs (((const struct GNUNET_MessageHeader *)&pos[1])->type),
+ ntohs (((const struct GNUNET_MessageHeader *)
&pos[1])->type),
pos->is_typemap,
pos->is_typemap_confirm,
GNUNET_i2s (session->peer));
- GNUNET_memcpy (&pbuf[used],
- &pos[1],
- pos->size);
+ GNUNET_memcpy (&pbuf[used], &pos[1], pos->size);
used += pos->size;
- GNUNET_CONTAINER_DLL_remove (session->sme_head,
- session->sme_tail,
- pos);
+ GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, pos);
GNUNET_free (pos);
}
/* compute average payload size */
@@ -789,9 +768,7 @@ try_transmission (struct Session *session)
total_bytes / total_msgs,
GNUNET_NO);
/* now actually transmit... */
- GSC_KX_encrypt_and_transmit (session->kx,
- pbuf,
- used);
+ GSC_KX_encrypt_and_transmit (session->kx, pbuf, used);
}
}
@@ -823,23 +800,17 @@ do_restart_typemap_message (void *cls,
{
if (GNUNET_YES == sme->is_typemap)
{
- GNUNET_CONTAINER_DLL_remove (session->sme_head,
- session->sme_tail,
- sme);
+ GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme);
GNUNET_free (sme);
break;
}
}
sme = GNUNET_malloc (sizeof (struct SessionMessageEntry) + size);
sme->is_typemap = GNUNET_YES;
- GNUNET_memcpy (&sme[1],
- hdr,
- size);
+ GNUNET_memcpy (&sme[1], hdr, size);
sme->size = size;
- sme->priority = GNUNET_CORE_PRIO_CRITICAL_CONTROL;
- GNUNET_CONTAINER_DLL_insert (session->sme_head,
- session->sme_tail,
- sme);
+ sme->priority = GNUNET_MQ_PRIO_CRITICAL_CONTROL;
+ GNUNET_CONTAINER_DLL_insert (session->sme_head, session->sme_tail, sme);
try_transmission (session);
start_typemap_task (session);
return GNUNET_OK;
@@ -876,8 +847,8 @@ GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity *pid)
struct Session *session;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transport solicits for %s\n",
- GNUNET_i2s (pid));
+ "Transport solicits for %s\n",
+ GNUNET_i2s (pid));
session = find_session (pid);
if (NULL == session)
return;
@@ -891,14 +862,12 @@ GSC_SESSIONS_solicit (const struct GNUNET_PeerIdentity
*pid)
* @param car original request that was queued and then solicited;
* this handle will now be 'owned' by the SESSIONS subsystem
* @param msg message to transmit
- * @param cork is corking allowed?
* @param priority how important is this message
*/
void
GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car,
const struct GNUNET_MessageHeader *msg,
- int cork,
- enum GNUNET_CORE_Priority priority)
+ enum GNUNET_MQ_PriorityPreferences priority)
{
struct Session *session;
struct SessionMessageEntry *sme;
@@ -910,21 +879,18 @@ GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest
*car,
return;
msize = ntohs (msg->size);
sme = GNUNET_malloc (sizeof (struct SessionMessageEntry) + msize);
- GNUNET_memcpy (&sme[1],
- msg,
- msize);
+ GNUNET_memcpy (&sme[1], msg, msize);
sme->size = msize;
sme->priority = priority;
- if (GNUNET_YES == cork)
+ if (0 != (GNUNET_MQ_PREF_CORK_ALLOWED & priority))
{
sme->deadline =
- GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY);
+ GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Mesage corked, delaying transmission\n");
+ "Mesage corked, delaying transmission\n");
}
pos = session->sme_head;
- while ( (NULL != pos) &&
- (pos->priority >= sme->priority) )
+ while ((NULL != pos) && (pos->priority >= sme->priority))
pos = pos->next;
if (NULL == pos)
GNUNET_CONTAINER_DLL_insert_tail (session->sme_head,
@@ -959,7 +925,7 @@ GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity
*peer,
if (NULL == nmap)
{
GNUNET_break_op (0);
- return; /* malformed */
+ return; /* malformed */
}
session = find_session (peer);
if (NULL == session)
@@ -975,9 +941,7 @@ GSC_SESSIONS_set_typemap (const struct GNUNET_PeerIdentity
*peer,
{
if (GNUNET_YES == sme->is_typemap_confirm)
{
- GNUNET_CONTAINER_DLL_remove (session->sme_head,
- session->sme_tail,
- sme);
+ GNUNET_CONTAINER_DLL_remove (session->sme_head, session->sme_tail, sme);
GNUNET_free (sme);
break;
}
@@ -986,21 +950,16 @@ GSC_SESSIONS_set_typemap (const struct
GNUNET_PeerIdentity *peer,
sizeof (struct TypeMapConfirmationMessage));
sme->deadline = GNUNET_TIME_absolute_get ();
sme->size = sizeof (struct TypeMapConfirmationMessage);
- sme->priority = GNUNET_CORE_PRIO_CRITICAL_CONTROL;
+ sme->priority = GNUNET_MQ_PRIO_CRITICAL_CONTROL;
sme->is_typemap_confirm = GNUNET_YES;
tmc = (struct TypeMapConfirmationMessage *) &sme[1];
tmc->header.size = htons (sizeof (struct TypeMapConfirmationMessage));
tmc->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP);
tmc->reserved = htonl (0);
- GSC_TYPEMAP_hash (nmap,
- &tmc->tm_hash);
- GNUNET_CONTAINER_DLL_insert (session->sme_head,
- session->sme_tail,
- sme);
+ GSC_TYPEMAP_hash (nmap, &tmc->tm_hash);
+ GNUNET_CONTAINER_DLL_insert (session->sme_head, session->sme_tail, sme);
try_transmission (session);
- GSC_CLIENTS_notify_clients_about_neighbour (peer,
- session->tmap,
- nmap);
+ GSC_CLIENTS_notify_clients_about_neighbour (peer, session->tmap, nmap);
GSC_TYPEMAP_destroy (session->tmap);
session->tmap = nmap;
}
@@ -1021,21 +980,14 @@ GSC_SESSIONS_add_to_typemap (const struct
GNUNET_PeerIdentity *peer,
struct Session *session;
struct GSC_TypeMap *nmap;
- if (0 == memcmp (peer,
- &GSC_my_identity,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (peer, &GSC_my_identity, sizeof (struct
GNUNET_PeerIdentity)))
return;
session = find_session (peer);
GNUNET_assert (NULL != session);
- if (GNUNET_YES == GSC_TYPEMAP_test_match (session->tmap,
- &type, 1))
- return; /* already in it */
- nmap = GSC_TYPEMAP_extend (session->tmap,
- &type,
- 1);
- GSC_CLIENTS_notify_clients_about_neighbour (peer,
- session->tmap,
- nmap);
+ if (GNUNET_YES == GSC_TYPEMAP_test_match (session->tmap, &type, 1))
+ return; /* already in it */
+ nmap = GSC_TYPEMAP_extend (session->tmap, &type, 1);
+ GSC_CLIENTS_notify_clients_about_neighbour (peer, session->tmap, nmap);
GSC_TYPEMAP_destroy (session->tmap);
session->tmap = nmap;
}
@@ -1047,8 +999,7 @@ GSC_SESSIONS_add_to_typemap (const struct
GNUNET_PeerIdentity *peer,
void
GSC_SESSIONS_init ()
{
- sessions = GNUNET_CONTAINER_multipeermap_create (128,
- GNUNET_YES);
+ sessions = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
}
@@ -1083,7 +1034,7 @@ GSC_SESSIONS_done ()
{
GNUNET_CONTAINER_multipeermap_iterate (sessions,
&free_session_helper,
- NULL);
+ NULL);
GNUNET_CONTAINER_multipeermap_destroy (sessions);
sessions = NULL;
}
diff --git a/src/core/gnunet-service-core_sessions.h
b/src/core/gnunet-service-core_sessions.h
index 9f5070d57..e92ce0962 100644
--- a/src/core/gnunet-service-core_sessions.h
+++ b/src/core/gnunet-service-core_sessions.h
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -114,14 +114,12 @@ GSC_SESSIONS_dequeue_request (struct
GSC_ClientActiveRequest *car);
* @param car original request that was queued and then solicited,
* ownership does not change (dequeue will be called soon).
* @param msg message to transmit
- * @param cork is corking allowed?
* @param priority how important is this message
*/
void
GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car,
const struct GNUNET_MessageHeader *msg,
- int cork,
- enum GNUNET_CORE_Priority priority);
+ enum GNUNET_MQ_PriorityPreferences priority);
/**
@@ -182,5 +180,4 @@ void
GSC_SESSIONS_done (void);
-
#endif
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c
index 0cf88a324..1e268c3a6 100644
--- a/src/core/test_core_api.c
+++ b/src/core/test_core_api.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -54,7 +54,16 @@ static struct GNUNET_SCHEDULER_Task *err_task;
static int ok;
-#define OKPP do { ok++; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Now at stage %u
at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
+#define OKPP \
+ do \
+ { \
+ ok++; \
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, \
+ "Now at stage %u at %s:%u\n", \
+ ok, \
+ __FILE__, \
+ __LINE__); \
+ } while (0)
static void
@@ -67,8 +76,7 @@ offer_hello_done (void *cls)
static void
-process_hello (void *cls,
- const struct GNUNET_MessageHeader *message)
+process_hello (void *cls, const struct GNUNET_MessageHeader *message)
{
struct PeerContext *p = cls;
@@ -76,14 +84,11 @@ process_hello (void *cls,
"Received (my) HELLO from transport service\n");
GNUNET_assert (message != NULL);
if ((p == &p1) && (NULL == p2.oh))
- p2.oh = GNUNET_TRANSPORT_offer_hello (p2.cfg, message,
- &offer_hello_done,
- &p2);
+ p2.oh =
+ GNUNET_TRANSPORT_offer_hello (p2.cfg, message, &offer_hello_done, &p2);
if ((p == &p2) && (NULL == p1.oh))
- p1.oh = GNUNET_TRANSPORT_offer_hello (p1.cfg,
- message,
- &offer_hello_done,
- &p1);
+ p1.oh =
+ GNUNET_TRANSPORT_offer_hello (p1.cfg, message, &offer_hello_done, &p1);
}
@@ -131,9 +136,7 @@ terminate_task (void *cls)
static void
terminate_task_error (void *cls)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ENDING ANGRILY %u\n",
- ok);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ENDING ANGRILY %u\n", ok);
GNUNET_break (0);
terminate_peer (&p1);
terminate_peer (&p2);
@@ -144,15 +147,13 @@ terminate_task_error (void *cls)
static void *
connect_notify (void *cls,
const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_MQ_Handle *mq)
{
struct PeerContext *pc = cls;
struct GNUNET_MQ_Envelope *env;
struct GNUNET_MessageHeader *msg;
- if (0 == memcmp (&pc->id,
- peer,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
return (void *) peer;
GNUNET_assert (pc->connect_status == 0);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -161,26 +162,18 @@ connect_notify (void *cls,
pc->connect_status = 1;
if (pc == &p1)
{
- uint64_t flags;
- const void *extra;
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Asking core (1) for transmission to peer `%s'\n",
GNUNET_i2s (&p2.id));
- env = GNUNET_MQ_msg (msg,
- MTYPE);
+ env = GNUNET_MQ_msg (msg, MTYPE);
/* enable corking for this test */
- extra = GNUNET_CORE_get_mq_options (GNUNET_YES,
- GNUNET_CORE_PRIO_BEST_EFFORT,
- &flags);
GNUNET_MQ_env_set_options (env,
- flags,
- extra);
+ GNUNET_MQ_PRIO_BEST_EFFORT |
+ GNUNET_MQ_PREF_CORK_ALLOWED);
/* now actually transmit message */
GNUNET_assert (ok == 4);
OKPP;
- GNUNET_MQ_send (mq,
- env);
+ GNUNET_MQ_send (mq, env);
}
return (void *) peer;
}
@@ -188,25 +181,22 @@ connect_notify (void *cls,
static void
disconnect_notify (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *internal_cls)
+ const struct GNUNET_PeerIdentity *peer,
+ void *internal_cls)
{
struct PeerContext *pc = cls;
- if (0 == memcmp (&pc->id,
- peer,
- sizeof (struct GNUNET_PeerIdentity)))
+ if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
return;
pc->connect_status = 0;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Encrypted connection to `%s' cut\n",
+ "Encrypted connection to `%s' cut\n",
GNUNET_i2s (peer));
}
static void
-handle_test (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_test (void *cls, const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_PeerIdentity *peer = cls;
@@ -216,23 +206,17 @@ handle_test (void *cls,
GNUNET_assert (ok == 5);
OKPP;
GNUNET_SCHEDULER_cancel (err_task);
- err_task = GNUNET_SCHEDULER_add_now (&terminate_task,
- NULL);
+ err_task = GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
}
static void
-init_notify (void *cls,
- const struct GNUNET_PeerIdentity *my_identity)
+init_notify (void *cls, const struct GNUNET_PeerIdentity *my_identity)
{
struct PeerContext *p = cls;
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_fixed_size (test,
- MTYPE,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_fixed_size (test, MTYPE, struct GNUNET_MessageHeader, NULL),
+ GNUNET_MQ_handler_end ()};
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Core connection to `%s' established\n",
@@ -244,50 +228,46 @@ init_notify (void *cls,
OKPP;
/* connect p2 */
p2.ch = GNUNET_CORE_connect (p2.cfg,
- &p2,
- &init_notify,
- &connect_notify,
- &disconnect_notify,
- handlers);
+ &p2,
+ &init_notify,
+ &connect_notify,
+ &disconnect_notify,
+ handlers);
}
else
{
GNUNET_assert (ok == 3);
OKPP;
GNUNET_assert (cls == &p2);
- p1.ats_sh = GNUNET_ATS_connectivity_suggest (p1.ats,
- &p2.id,
- 1);
+ p1.ats_sh = GNUNET_ATS_connectivity_suggest (p1.ats, &p2.id, 1);
}
}
static void
-setup_peer (struct PeerContext *p,
- const char *cfgname)
+setup_peer (struct PeerContext *p, const char *cfgname)
{
char *binary;
binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
p->cfg = GNUNET_CONFIGURATION_create ();
- p->arm_proc =
- GNUNET_OS_start_process (GNUNET_YES,
- GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
- NULL, NULL, NULL,
- binary,
- "gnunet-service-arm",
- "-c",
- cfgname,
- NULL);
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CONFIGURATION_load (p->cfg,
- cfgname));
+ p->arm_proc = GNUNET_OS_start_process (GNUNET_YES,
+ GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+ NULL,
+ NULL,
+ NULL,
+ binary,
+ "gnunet-service-arm",
+ "-c",
+ cfgname,
+ NULL);
+ GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
p->ats = GNUNET_ATS_connectivity_init (p->cfg);
GNUNET_assert (NULL != p->ats);
p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
- GNUNET_TRANSPORT_AC_ANY,
- &process_hello,
- p);
+ GNUNET_TRANSPORT_AC_ANY,
+ &process_hello,
+ p);
GNUNET_free (binary);
}
@@ -298,47 +278,36 @@ run (void *cls,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_fixed_size (test,
- MTYPE,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_fixed_size (test, MTYPE, struct GNUNET_MessageHeader, NULL),
+ GNUNET_MQ_handler_end ()};
GNUNET_assert (ok == 1);
OKPP;
- setup_peer (&p1,
- "test_core_api_peer1.conf");
- setup_peer (&p2,
- "test_core_api_peer2.conf");
- err_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 300),
- &terminate_task_error, NULL);
- p1.ch =
- GNUNET_CORE_connect (p1.cfg,
- &p1,
- &init_notify,
- &connect_notify,
- &disconnect_notify,
- handlers);
+ setup_peer (&p1, "test_core_api_peer1.conf");
+ setup_peer (&p2, "test_core_api_peer2.conf");
+ err_task = GNUNET_SCHEDULER_add_delayed (
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300),
+ &terminate_task_error,
+ NULL);
+ p1.ch = GNUNET_CORE_connect (p1.cfg,
+ &p1,
+ &init_notify,
+ &connect_notify,
+ &disconnect_notify,
+ handlers);
}
static void
stop_arm (struct PeerContext *p)
{
- if (0 != GNUNET_OS_process_kill (p->arm_proc,
- GNUNET_TERM_SIG))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
- "kill");
- if (GNUNET_OK !=
- GNUNET_OS_process_wait (p->arm_proc))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
- "waitpid");
+ if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+ if (GNUNET_OK != GNUNET_OS_process_wait (p->arm_proc))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ARM process %u stopped\n",
+ "ARM process %u stopped\n",
GNUNET_OS_process_get_pid (p->arm_proc));
GNUNET_OS_process_destroy (p->arm_proc);
p->arm_proc = NULL;
@@ -347,29 +316,19 @@ stop_arm (struct PeerContext *p)
int
-main (int argc,
- char *argv1[])
+main (int argc, char *argv1[])
{
- char *const argv[] = {
- "test-core-api",
- "-c",
- "test_core_api_data.conf",
- NULL
- };
- struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_OPTION_END
- };
+ char *const argv[] = {"test-core-api", "-c", "test_core_api_data.conf",
NULL};
+ struct GNUNET_GETOPT_CommandLineOption options[] =
{GNUNET_GETOPT_OPTION_END};
ok = 1;
- GNUNET_log_setup ("test-core-api",
- "WARNING",
- NULL);
+ GNUNET_log_setup ("test-core-api", "WARNING", NULL);
GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
- argv,
+ argv,
"test-core-api",
- "nohelp",
- options,
- &run,
- &ok);
+ "nohelp",
+ options,
+ &run,
+ &ok);
stop_arm (&p1);
stop_arm (&p2);
GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
diff --git a/src/hostlist/gnunet-daemon-hostlist_server.c
b/src/hostlist/gnunet-daemon-hostlist_server.c
index 529fe4e62..8764586d6 100644
--- a/src/hostlist/gnunet-daemon-hostlist_server.c
+++ b/src/hostlist/gnunet-daemon-hostlist_server.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -38,7 +38,8 @@
* How long until our hostlist advertisment transmission via CORE should
* time out?
*/
-#define GNUNET_ADV_TIMEOUT GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5)
+#define GNUNET_ADV_TIMEOUT \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
/**
@@ -121,7 +122,6 @@ struct HostSet
* Number of bytes in @e data.
*/
unsigned int size;
-
};
@@ -140,15 +140,11 @@ static struct HostSet *builder;
static void
add_cors_headers (struct MHD_Response *response)
{
- MHD_add_response_header (response,
- "Access-Control-Allow-Origin",
- "*");
+ MHD_add_response_header (response, "Access-Control-Allow-Origin", "*");
MHD_add_response_header (response,
"Access-Control-Allow-Methods",
"GET, OPTIONS");
- MHD_add_response_header (response,
- "Access-Control-Max-Age",
- "86400");
+ MHD_add_response_header (response, "Access-Control-Max-Age", "86400");
}
@@ -163,18 +159,19 @@ finish_response ()
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Creating hostlist response with %u bytes\n",
(unsigned int) builder->size);
- response =
- MHD_create_response_from_buffer (builder->size,
- builder->data,
- MHD_RESPMEM_MUST_FREE);
+ response = MHD_create_response_from_buffer (builder->size,
+ builder->data,
+ MHD_RESPMEM_MUST_FREE);
add_cors_headers (response);
if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6))
{
MHD_destroy_response (response);
response = NULL;
}
- GNUNET_STATISTICS_set (stats, gettext_noop ("bytes in hostlist"),
- builder->size, GNUNET_YES);
+ GNUNET_STATISTICS_set (stats,
+ gettext_noop ("bytes in hostlist"),
+ builder->size,
+ GNUNET_YES);
GNUNET_free (builder);
builder = NULL;
}
@@ -198,9 +195,10 @@ check_has_addr (void *cls,
if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
{
GNUNET_STATISTICS_update (stats,
- gettext_noop ("expired addresses encountered"),
1,
+ gettext_noop ("expired addresses encountered"),
+ 1,
GNUNET_YES);
- return GNUNET_YES; /* ignore this address */
+ return GNUNET_YES; /* ignore this address */
}
*arg = GNUNET_YES;
return GNUNET_SYSERR;
@@ -234,7 +232,7 @@ host_processor (void *cls,
GNUNET_free (builder);
builder = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Error in communication with PEERINFO service: %s\n"),
+ _ ("Error in communication with PEERINFO service: %s\n"),
err_msg);
return;
}
@@ -247,19 +245,17 @@ host_processor (void *cls,
if (NULL == hello)
return;
has_addr = GNUNET_NO;
- GNUNET_HELLO_iterate_addresses (hello,
- GNUNET_NO,
- &check_has_addr,
- &has_addr);
+ GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_has_addr,
&has_addr);
if (GNUNET_NO == has_addr)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"HELLO for peer `%4s' has no address, not suitable for
hostlist!\n",
GNUNET_i2s (peer));
GNUNET_STATISTICS_update (stats,
- gettext_noop
- ("HELLOs without addresses encountered
(ignored)"),
- 1, GNUNET_NO);
+ gettext_noop (
+ "HELLOs without addresses encountered
(ignored)"),
+ 1,
+ GNUNET_NO);
return;
}
old = builder->size;
@@ -269,26 +265,23 @@ host_processor (void *cls,
(unsigned int) s,
"HELLO",
GNUNET_i2s (peer));
- if ( (old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
- (old + s >= MAX_BYTES_PER_HOSTLISTS) )
+ if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) ||
+ (old + s >= MAX_BYTES_PER_HOSTLISTS))
{
/* too large, skip! */
GNUNET_STATISTICS_update (stats,
- gettext_noop
- ("bytes not included in hostlist (size limit)"),
- s, GNUNET_NO);
+ gettext_noop (
+ "bytes not included in hostlist (size limit)"),
+ s,
+ GNUNET_NO);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Adding peer `%s' to hostlist (%u bytes)\n",
GNUNET_i2s (peer),
(unsigned int) s);
- GNUNET_array_grow (builder->data,
- builder->size,
- old + s);
- GNUNET_memcpy (&builder->data[old],
- hello,
- s);
+ GNUNET_array_grow (builder->data, builder->size, old + s);
+ GNUNET_memcpy (&builder->data[old], hello, s);
}
@@ -308,11 +301,12 @@ accept_policy_callback (void *cls,
{
if (NULL == response)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received request for hostlist, but I am not yet ready;
rejecting!\n");
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Received request for hostlist, but I am not yet ready; rejecting!\n");
return MHD_NO;
}
- return MHD_YES; /* accept all */
+ return MHD_YES; /* accept all */
}
@@ -369,9 +363,9 @@ access_handler_callback (void *cls,
struct MHD_Response *options_response;
int rc;
- options_response = MHD_create_response_from_buffer (0, NULL,
-
MHD_RESPMEM_PERSISTENT);
- add_cors_headers(options_response);
+ options_response =
+ MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT);
+ add_cors_headers (options_response);
rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response);
MHD_destroy_response (options_response);
return rc;
@@ -379,10 +373,12 @@ access_handler_callback (void *cls,
if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Refusing `%s' request to hostlist server\n"), method);
+ _ ("Refusing `%s' request to hostlist server\n"),
+ method);
GNUNET_STATISTICS_update (stats,
- gettext_noop
- ("hostlist requests refused (not HTTP GET)"), 1,
+ gettext_noop (
+ "hostlist requests refused (not HTTP GET)"),
+ 1,
GNUNET_YES);
return MHD_NO;
}
@@ -394,29 +390,35 @@ access_handler_callback (void *cls,
if (0 != *upload_data_size)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Refusing `%s' request with %llu bytes of upload data\n"),
- method, (unsigned long long) *upload_data_size);
+ _ ("Refusing `%s' request with %llu bytes of upload data\n"),
+ method,
+ (unsigned long long) *upload_data_size);
GNUNET_STATISTICS_update (stats,
- gettext_noop
- ("hostlist requests refused (upload data)"), 1,
+ gettext_noop (
+ "hostlist requests refused (upload data)"),
+ 1,
GNUNET_YES);
- return MHD_NO; /* do not support upload data */
+ return MHD_NO; /* do not support upload data */
}
if (NULL == response)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Could not handle hostlist request since I do not have a
response yet\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ _ (
+ "Could not handle hostlist request since I do not have a response
yet\n"));
GNUNET_STATISTICS_update (stats,
- gettext_noop
- ("hostlist requests refused (not ready)"), 1,
+ gettext_noop (
+ "hostlist requests refused (not ready)"),
+ 1,
GNUNET_YES);
- return MHD_NO; /* internal error, no response yet */
+ return MHD_NO; /* internal error, no response yet */
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Received request for our hostlist\n"));
+ _ ("Received request for our hostlist\n"));
GNUNET_STATISTICS_update (stats,
gettext_noop ("hostlist requests processed"),
- 1, GNUNET_YES);
+ 1,
+ GNUNET_YES);
return MHD_queue_response (connection, MHD_HTTP_OK, response);
}
@@ -434,27 +436,19 @@ static void
adv_transmit (struct GNUNET_MQ_Handle *mq)
{
static uint64_t hostlist_adv_count;
- const void *extra;
- uint64_t flags;
- size_t uri_size; /* Including \0 termination! */
+ size_t uri_size; /* Including \0 termination! */
struct GNUNET_MessageHeader *header;
struct GNUNET_MQ_Envelope *env;
- extra = GNUNET_CORE_get_mq_options (GNUNET_YES,
- GNUNET_CORE_PRIO_BEST_EFFORT,
- &flags);
uri_size = strlen (hostlist_uri) + 1;
env = GNUNET_MQ_msg_extra (header,
- uri_size,
- GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
- GNUNET_memcpy (&header[1],
- hostlist_uri,
- uri_size);
+ uri_size,
+ GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT);
+ GNUNET_memcpy (&header[1], hostlist_uri, uri_size);
GNUNET_MQ_env_set_options (env,
- flags,
- extra);
- GNUNET_MQ_send (mq,
- env);
+ GNUNET_MQ_PREF_CORK_ALLOWED |
+ GNUNET_MQ_PREF_UNRELIABLE);
+ GNUNET_MQ_send (mq, env);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sent advertisement message: Copied %u bytes into buffer!\n",
(unsigned int) uri_size);
@@ -463,7 +457,8 @@ adv_transmit (struct GNUNET_MQ_Handle *mq)
" # Sent advertisement message: %llu\n",
(unsigned long long) hostlist_adv_count);
GNUNET_STATISTICS_update (stats,
- gettext_noop ("# hostlist advertisements send"), 1,
+ gettext_noop ("# hostlist advertisements send"),
+ 1,
GNUNET_NO);
}
@@ -479,7 +474,7 @@ adv_transmit (struct GNUNET_MQ_Handle *mq)
static void *
connect_handler (void *cls,
const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_MQ_Handle *mq)
{
size_t size;
@@ -488,8 +483,7 @@ connect_handler (void *cls,
if (NULL == hostlist_uri)
return NULL;
size = strlen (hostlist_uri) + 1;
- if (size + sizeof (struct GNUNET_MessageHeader) >=
- GNUNET_MAX_MESSAGE_SIZE)
+ if (size + sizeof (struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE)
{
GNUNET_break (0);
return NULL;
@@ -500,10 +494,11 @@ connect_handler (void *cls,
GNUNET_break (0);
return NULL;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Asked CORE to transmit advertisement message with a size of %u
bytes to peer `%s'\n",
- (unsigned int) size,
- GNUNET_i2s (peer));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_DEBUG,
+ "Asked CORE to transmit advertisement message with a size of %u bytes to
peer `%s'\n",
+ (unsigned int) size,
+ GNUNET_i2s (peer));
adv_transmit (mq);
return NULL;
}
@@ -528,8 +523,8 @@ process_notify (void *cls,
"Peerinfo is notifying us to rebuild our hostlist\n");
if (NULL != err_msg)
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Error in communication with PEERINFO service: %s\n"),
- err_msg);
+ _ ("Error in communication with PEERINFO service: %s\n"),
+ err_msg);
if (NULL != builder)
{
/* restart re-build already in progress ... */
@@ -547,10 +542,8 @@ process_notify (void *cls,
builder = GNUNET_new (struct HostSet);
}
GNUNET_assert (NULL != peerinfo);
- builder->pitr
- = GNUNET_PEERINFO_iterate (peerinfo,
- GNUNET_NO, NULL,
- &host_processor, NULL);
+ builder->pitr =
+ GNUNET_PEERINFO_iterate (peerinfo, GNUNET_NO, NULL, &host_processor, NULL);
}
@@ -594,7 +587,7 @@ run_daemon (void *cls)
static struct GNUNET_SCHEDULER_Task *
prepare_daemon (struct MHD_Daemon *daemon_handle)
{
- struct GNUNET_SCHEDULER_Task * ret;
+ struct GNUNET_SCHEDULER_Task *ret;
fd_set rs;
fd_set ws;
fd_set es;
@@ -611,9 +604,7 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
wrs = GNUNET_NETWORK_fdset_create ();
wws = GNUNET_NETWORK_fdset_create ();
max = -1;
- GNUNET_assert (MHD_YES ==
- MHD_get_fdset (daemon_handle,
- &rs, &ws, &es, &max));
+ GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es,
&max));
haveto = MHD_get_timeout (daemon_handle, &timeout);
if (haveto == MHD_YES)
tv.rel_value_us = (uint64_t) timeout * 1000LL;
@@ -622,8 +613,11 @@ prepare_daemon (struct MHD_Daemon *daemon_handle)
GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
- tv, wrs, wws,
- &run_daemon, daemon_handle);
+ tv,
+ wrs,
+ wws,
+ &run_daemon,
+ daemon_handle);
GNUNET_NETWORK_fdset_destroy (wrs);
GNUNET_NETWORK_fdset_destroy (wws);
return ret;
@@ -676,19 +670,18 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
if (NULL == peerinfo)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not access PEERINFO service. Exiting.\n"));
+ _ ("Could not access PEERINFO service. Exiting.\n"));
return GNUNET_SYSERR;
}
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (cfg,
- "HOSTLIST",
- "HTTPPORT",
- &port))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+ "HOSTLIST",
+ "HTTPPORT",
+ &port))
return GNUNET_SYSERR;
if ((0 == port) || (port > UINT16_MAX))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Invalid port number %llu. Exiting.\n"),
+ _ ("Invalid port number %llu. Exiting.\n"),
port);
return GNUNET_SYSERR;
}
@@ -700,8 +693,9 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
&hostname))
hostname = GNUNET_RESOLVER_local_fqdn_get ();
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Hostlist service starts on %s:%llu\n"),
- hostname, port);
+ _ ("Hostlist service starts on %s:%llu\n"),
+ hostname,
+ port);
if (NULL != hostname)
{
size = strlen (hostname);
@@ -712,10 +706,11 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
else
{
GNUNET_asprintf (&hostlist_uri,
- "http://%s:%u/";, hostname,
+ "http://%s:%u/";,
+ hostname,
(unsigned int) port);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Address to obtain hostlist: `%s'\n"),
+ _ ("Address to obtain hostlist: `%s'\n"),
hostlist_uri);
}
GNUNET_free (hostname);
@@ -723,29 +718,28 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4"))
{
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST",
- "BINDTOIP", &ipv4))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+ "HOSTLIST",
+ "BINDTOIP",
+ &ipv4))
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("BINDTOIP does not a valid IPv4 address! Ignoring
BINDTOIPV4.\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
}
-
}
else
ipv4 = NULL;
- if (GNUNET_CONFIGURATION_have_value (cfg,
- "HOSTLIST",
- "BINDTOIPV6"))
- {
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "HOSTLIST",
- "BINDTOIP",
- &ipv6))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
+ if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6"))
+ {
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+ "HOSTLIST",
+ "BINDTOIP",
+ &ipv6))
+ {
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
}
}
else
@@ -766,7 +760,8 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
}
else
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' is not a valid IPv4 address! Ignoring
BINDTOIPV4.\n"),
+ _ (
+ "`%s' is not a valid IPv4 address! Ignoring
BINDTOIPV4.\n"),
ipv4);
GNUNET_free (ipv4);
}
@@ -786,15 +781,18 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
}
else
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' is not a valid IPv6 address! Ignoring
BINDTOIPV6.\n"),
+ _ (
+ "`%s' is not a valid IPv6 address! Ignoring
BINDTOIPV6.\n"),
ipv6);
GNUNET_free (ipv6);
}
daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG,
(uint16_t) port,
- &accept_policy_callback, NULL,
- &access_handler_callback, NULL,
+ &accept_policy_callback,
+ NULL,
+ &access_handler_callback,
+ NULL,
MHD_OPTION_CONNECTION_LIMIT,
(unsigned int) 128,
MHD_OPTION_PER_IP_CONNECTION_LIMIT,
@@ -807,9 +805,11 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
sa6,
MHD_OPTION_END);
daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG,
- (uint16_t) port,
- &accept_policy_callback, NULL,
- &access_handler_callback, NULL,
+ (uint16_t) port,
+ &accept_policy_callback,
+ NULL,
+ &access_handler_callback,
+ NULL,
MHD_OPTION_CONNECTION_LIMIT,
(unsigned int) 128,
MHD_OPTION_PER_IP_CONNECTION_LIMIT,
@@ -822,11 +822,10 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
sa4,
MHD_OPTION_END);
- if ( (NULL == daemon_handle_v6) &&
- (NULL == daemon_handle_v4) )
+ if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not start hostlist HTTP server on port %u\n"),
+ _ ("Could not start hostlist HTTP server on port %u\n"),
(unsigned short) port);
return GNUNET_SYSERR;
}
@@ -837,9 +836,7 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
hostlist_task_v4 = prepare_daemon (daemon_handle_v4);
if (NULL != daemon_handle_v6)
hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
- notify = GNUNET_PEERINFO_notify (cfg,
- GNUNET_NO,
- &process_notify, NULL);
+ notify = GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_notify, NULL);
return GNUNET_OK;
}
@@ -850,8 +847,7 @@ GNUNET_HOSTLIST_server_start (const struct
GNUNET_CONFIGURATION_Handle *c,
void
GNUNET_HOSTLIST_server_stop ()
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Hostlist server shutdown\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n");
if (NULL != hostlist_task_v6)
{
GNUNET_SCHEDULER_cancel (hostlist_task_v6);
diff --git a/src/include/gnunet_cadet_service.h
b/src/include/gnunet_cadet_service.h
index da914ac9e..a11c5f3cb 100644
--- a/src/include/gnunet_cadet_service.h
+++ b/src/include/gnunet_cadet_service.h
@@ -36,9 +36,8 @@
#define GNUNET_CADET_SERVICE_H
#ifdef __cplusplus
-extern "C"
-{
-#if 0 /* keep Emacsens' auto-indent happy */
+extern "C" {
+#if 0 /* keep Emacsens' auto-indent happy */
}
#endif
#endif
@@ -98,25 +97,28 @@ struct GNUNET_CADET_ChannelTunnelNumber
/**
* Channel options. Second line indicates filed in the
* CadetChannelInfo union carrying the answer.
+ *
+ * @deprecated we should replace channel options with per-envelope
+ * options, and then re-use the options from `enum
GNUNET_MQ_PriorityPreferences`.
*/
enum GNUNET_CADET_ChannelOption
{
/**
* Default options: unreliable, default buffering, not out of order.
*/
- GNUNET_CADET_OPTION_DEFAULT = 0x0,
+ GNUNET_CADET_OPTION_DEFAULT = 0x0,
/**
* Disable buffering on intermediate nodes (for minimum latency).
* Yes/No.
*/
- GNUNET_CADET_OPTION_NOBUFFER = 0x1,
+ GNUNET_CADET_OPTION_NOBUFFER = 0x1,
/**
* Enable channel reliability, lost messages will be retransmitted.
* Yes/No.
*/
- GNUNET_CADET_OPTION_RELIABLE = 0x2,
+ GNUNET_CADET_OPTION_RELIABLE = 0x2,
/**
* Enable out of order delivery of messages.
@@ -129,7 +131,7 @@ enum GNUNET_CADET_ChannelOption
* Only for use in @c GNUNET_CADET_channel_get_info
* struct GNUNET_PeerIdentity *peer
*/
- GNUNET_CADET_OPTION_PEER = 0x8
+ GNUNET_CADET_OPTION_PEER = 0x8
};
@@ -146,10 +148,10 @@ enum GNUNET_CADET_ChannelOption
* - Each the #GNUNET_MQ_MessageCallback handlers for each message
* received on the @a channel.
*/
-typedef void *
-(*GNUNET_CADET_ConnectEventHandler) (void *cls,
- struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *source);
+typedef void *(*GNUNET_CADET_ConnectEventHandler) (
+ void *cls,
+ struct GNUNET_CADET_Channel *channel,
+ const struct GNUNET_PeerIdentity *source);
/**
@@ -163,9 +165,9 @@ typedef void *
* @param cls Channel closure.
* @param channel Connection to the other end (henceforth invalid).
*/
-typedef void
-(*GNUNET_CADET_DisconnectEventHandler) (void *cls,
- const struct GNUNET_CADET_Channel
*channel);
+typedef void (*GNUNET_CADET_DisconnectEventHandler) (
+ void *cls,
+ const struct GNUNET_CADET_Channel *channel);
/**
@@ -182,10 +184,10 @@ typedef void
* @param window_size New window size. If the is more messages than buffer size
* this value will be negative. -- FIXME: make unsigned, we
never call negative?
*/
-typedef void
-(*GNUNET_CADET_WindowSizeEventHandler) (void *cls,
- const struct GNUNET_CADET_Channel
*channel,
- int window_size);
+typedef void (*GNUNET_CADET_WindowSizeEventHandler) (
+ void *cls,
+ const struct GNUNET_CADET_Channel *channel,
+ int window_size);
/**
@@ -323,7 +325,6 @@ const struct GNUNET_HashCode *
GC_u2h (uint32_t port);
-
/**
* Union to retrieve info about a channel.
*/
@@ -352,7 +353,7 @@ union GNUNET_CADET_ChannelInfo
*/
const union GNUNET_CADET_ChannelInfo *
GNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel,
- enum GNUNET_CADET_ChannelOption option,
+ enum GNUNET_CADET_ChannelOption option,
...);
@@ -393,9 +394,9 @@ struct GNUNET_CADET_ChannelInternals
* @param cls Closure.
* @param info internal details, NULL for end of list
*/
-typedef void
-(*GNUNET_CADET_ChannelCB) (void *cls,
- const struct GNUNET_CADET_ChannelInternals *info);
+typedef void (*GNUNET_CADET_ChannelCB) (
+ void *cls,
+ const struct GNUNET_CADET_ChannelInternals *info);
/**
@@ -465,9 +466,9 @@ struct GNUNET_CADET_PeerListEntry
* @param cls Closure.
* @param ple information about a peer, or NULL on "EOF".
*/
-typedef void
-(*GNUNET_CADET_PeersCB) (void *cls,
- const struct GNUNET_CADET_PeerListEntry *ple);
+typedef void (*GNUNET_CADET_PeersCB) (
+ void *cls,
+ const struct GNUNET_CADET_PeerListEntry *ple);
/**
@@ -488,8 +489,8 @@ struct GNUNET_CADET_PeersLister;
*/
struct GNUNET_CADET_PeersLister *
GNUNET_CADET_list_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
- GNUNET_CADET_PeersCB callback,
- void *callback_cls);
+ GNUNET_CADET_PeersCB callback,
+ void *callback_cls);
/**
@@ -528,7 +529,6 @@ struct GNUNET_CADET_PeerPathDetail
* path ends with the destination peer (given in @e peer).
*/
const struct GNUNET_PeerIdentity *path;
-
};
@@ -539,9 +539,9 @@ struct GNUNET_CADET_PeerPathDetail
* @param cls Closure.
* @param ppd details about a path to the peer, NULL for end of information
*/
-typedef void
-(*GNUNET_CADET_PathCB) (void *cls,
- const struct GNUNET_CADET_PeerPathDetail *ppd);
+typedef void (*GNUNET_CADET_PathCB) (
+ void *cls,
+ const struct GNUNET_CADET_PeerPathDetail *ppd);
/**
@@ -561,9 +561,9 @@ struct GNUNET_CADET_GetPath;
*/
struct GNUNET_CADET_GetPath *
GNUNET_CADET_get_path (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *id,
- GNUNET_CADET_PathCB callback,
- void *callback_cls);
+ const struct GNUNET_PeerIdentity *id,
+ GNUNET_CADET_PathCB callback,
+ void *callback_cls);
/**
@@ -617,9 +617,9 @@ struct GNUNET_CADET_TunnelDetails
* @param cls Closure.
* @param td tunnel details, NULL for end of list
*/
-typedef void
-(*GNUNET_CADET_TunnelsCB) (void *cls,
- const struct GNUNET_CADET_TunnelDetails *td);
+typedef void (*GNUNET_CADET_TunnelsCB) (
+ void *cls,
+ const struct GNUNET_CADET_TunnelDetails *td);
/**
@@ -640,8 +640,8 @@ struct GNUNET_CADET_ListTunnels;
*/
struct GNUNET_CADET_ListTunnels *
GNUNET_CADET_list_tunnels (const struct GNUNET_CONFIGURATION_Handle *cfg,
- GNUNET_CADET_TunnelsCB callback,
- void *callback_cls);
+ GNUNET_CADET_TunnelsCB callback,
+ void *callback_cls);
/**
@@ -654,7 +654,7 @@ void *
GNUNET_CADET_list_tunnels_cancel (struct GNUNET_CADET_ListTunnels *lt);
-#if 0 /* keep Emacsens' auto-indent happy */
+#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
@@ -664,6 +664,6 @@ GNUNET_CADET_list_tunnels_cancel (struct
GNUNET_CADET_ListTunnels *lt);
/* ifndef GNUNET_CADET_SERVICE_H */
#endif
-/** @} */ /* end of group */
+/** @} */ /* end of group */
/* end of gnunet_cadet_service.h */
diff --git a/src/include/gnunet_core_service.h
b/src/include/gnunet_core_service.h
index f10ddee75..111eb529d 100644
--- a/src/include/gnunet_core_service.h
+++ b/src/include/gnunet_core_service.h
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -34,9 +34,8 @@
#define GNUNET_CORE_SERVICE_H
#ifdef __cplusplus
-extern "C"
-{
-#if 0 /* keep Emacsens' auto-indent happy */
+extern "C" {
+#if 0 /* keep Emacsens' auto-indent happy */
}
#endif
#endif
@@ -49,35 +48,6 @@ extern "C"
*/
#define GNUNET_CORE_VERSION 0x00000001
-/**
- * Traffic priorities.
- */
-enum GNUNET_CORE_Priority
-{
-
- /**
- * Lowest priority, i.e. background traffic (i.e. fs)
- */
- GNUNET_CORE_PRIO_BACKGROUND = 0,
-
- /**
- * Normal traffic (i.e. cadet/dv relay, DHT)
- */
- GNUNET_CORE_PRIO_BEST_EFFORT = 1,
-
- /**
- * Urgent traffic (local peer, i.e. conversation).
- */
- GNUNET_CORE_PRIO_URGENT = 2,
-
- /**
- * Highest priority, control traffic (i.e. NSE, Core/Cadet KX).
- */
- GNUNET_CORE_PRIO_CRITICAL_CONTROL = 3
-
-
-};
-
/**
* Opaque handle to the service.
@@ -93,10 +63,10 @@ struct GNUNET_CORE_Handle;
* @return closure associated with @a peer. given to mq callbacks and
* #GNUNET_CORE_DisconnectEventHandler
*/
-typedef void *
-(*GNUNET_CORE_ConnectEventHandler) (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Handle *mq);
+typedef void *(*GNUNET_CORE_ConnectEventHandler) (
+ void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_MQ_Handle *mq);
/**
@@ -107,10 +77,10 @@ typedef void *
* @param peer_cls closure associated with peer. given in
* #GNUNET_CORE_ConnectEventHandler
*/
-typedef void
-(*GNUNET_CORE_DisconnectEventHandler) (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *peer_cls);
+typedef void (*GNUNET_CORE_DisconnectEventHandler) (
+ void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ void *peer_cls);
/**
@@ -125,9 +95,9 @@ typedef void
* @param cls closure
* @param my_identity ID of this peer, NULL if we failed
*/
-typedef void
-(*GNUNET_CORE_StartupCallback) (void *cls,
- const struct GNUNET_PeerIdentity *my_identity);
+typedef void (*GNUNET_CORE_StartupCallback) (
+ void *cls,
+ const struct GNUNET_PeerIdentity *my_identity);
/**
@@ -172,22 +142,6 @@ void
GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle);
-/**
- * Inquire with CORE what options should be set for a message
- * so that it is transmitted with the given @a priority and
- * the given @a cork value.
- *
- * @param cork desired corking
- * @param priority desired message priority
- * @param[out] flags set to `flags` value for #GNUNET_MQ_set_options()
- * @return `extra` argument to give to #GNUNET_MQ_set_options()
- */
-const void *
-GNUNET_CORE_get_mq_options (int cork,
- enum GNUNET_CORE_Priority priority,
- uint64_t *flags);
-
-
/**
* Obtain the message queue for a connected peer.
*
@@ -197,7 +151,7 @@ GNUNET_CORE_get_mq_options (int cork,
*/
struct GNUNET_MQ_Handle *
GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *pid);
+ const struct GNUNET_PeerIdentity *pid);
/**
@@ -287,11 +241,11 @@ enum GNUNET_CORE_KxState
* @param state current key exchange state of the peer
* @param timeout when does the current state expire
*/
-typedef void
-(*GNUNET_CORE_MonitorCallback)(void *cls,
- const struct GNUNET_PeerIdentity *pid,
- enum GNUNET_CORE_KxState state,
- struct GNUNET_TIME_Absolute timeout);
+typedef void (*GNUNET_CORE_MonitorCallback) (
+ void *cls,
+ const struct GNUNET_PeerIdentity *pid,
+ enum GNUNET_CORE_KxState state,
+ struct GNUNET_TIME_Absolute timeout);
/**
@@ -360,7 +314,7 @@ GNUNET_CORE_mq_create (struct GNUNET_CORE_Handle *h,
const struct GNUNET_PeerIdentity *target);
-#if 0 /* keep Emacsens' auto-indent happy */
+#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
@@ -370,6 +324,6 @@ GNUNET_CORE_mq_create (struct GNUNET_CORE_Handle *h,
/* ifndef GNUNET_CORE_SERVICE_H */
#endif
-/** @} */ /* end of group core */
+/** @} */ /* end of group core */
/* end of gnunet_core_service.h */
diff --git a/src/include/gnunet_mq_lib.h b/src/include/gnunet_mq_lib.h
index 2a459636a..498567ec2 100644
--- a/src/include/gnunet_mq_lib.h
+++ b/src/include/gnunet_mq_lib.h
@@ -49,7 +49,10 @@
* @param type type of the message
* @return the MQ message
*/
-#define GNUNET_MQ_msg_extra(mvar, esize, type) GNUNET_MQ_msg_(((struct
GNUNET_MessageHeader**) &(mvar)), (esize) + sizeof *(mvar), (type))
+#define GNUNET_MQ_msg_extra(mvar, esize, type) \
+ GNUNET_MQ_msg_ (((struct GNUNET_MessageHeader **) &(mvar)), \
+ (esize) + sizeof *(mvar), \
+ (type))
/**
* Allocate a GNUNET_MQ_Envelope.
@@ -61,7 +64,7 @@
* @param type type of the message
* @return the allocated envelope
*/
-#define GNUNET_MQ_msg(mvar, type) GNUNET_MQ_msg_extra(mvar, 0, type)
+#define GNUNET_MQ_msg(mvar, type) GNUNET_MQ_msg_extra (mvar, 0, type)
/**
@@ -70,7 +73,8 @@
*
* @param type type of the message
*/
-#define GNUNET_MQ_msg_header(type) GNUNET_MQ_msg_ (NULL, sizeof (struct
GNUNET_MessageHeader), type)
+#define GNUNET_MQ_msg_header(type) \
+ GNUNET_MQ_msg_ (NULL, sizeof (struct GNUNET_MessageHeader), type)
/**
@@ -81,7 +85,8 @@
* @param esize extra space to allocate after the message header
* @param type type of the message
*/
-#define GNUNET_MQ_msg_header_extra(mh, esize, type) GNUNET_MQ_msg_ (&mh,
(esize) + sizeof (struct GNUNET_MessageHeader), type)
+#define GNUNET_MQ_msg_header_extra(mh, esize, type) \
+ GNUNET_MQ_msg_ (&mh, (esize) + sizeof (struct GNUNET_MessageHeader), type)
/**
@@ -94,14 +99,16 @@
* @param mh message to nest
* @return a newly allocated 'struct GNUNET_MQ_Envelope *'
*/
-#define GNUNET_MQ_msg_nested_mh(mvar, type, mh) \
- ({struct GNUNET_MQ_Envelope *_ev;\
- _ev = GNUNET_MQ_msg_nested_mh_((struct GNUNET_MessageHeader**) &(mvar),\
- sizeof (*(mvar)),\
- (type),\
- (mh));\
- (void)(mvar)->header; /* type check */\
- _ev;})
+#define GNUNET_MQ_msg_nested_mh(mvar, type, mh) \
+ ({ \
+ struct GNUNET_MQ_Envelope *_ev; \
+ _ev = GNUNET_MQ_msg_nested_mh_ ((struct GNUNET_MessageHeader **) &(mvar), \
+ sizeof (*(mvar)), \
+ (type), \
+ (mh)); \
+ (void) (mvar)->header; /* type check */ \
+ _ev; \
+ })
/**
@@ -112,7 +119,9 @@
* @return a 'struct GNUNET_MessageHeader *' that points at the nested message
of the given message,
* or NULL if the given message in @a var does not have any space
after the message struct
*/
-#define GNUNET_MQ_extract_nested_mh(var) GNUNET_MQ_extract_nested_mh_ ((struct
GNUNET_MessageHeader *) (var), sizeof (*(var)))
+#define GNUNET_MQ_extract_nested_mh(var) \
+ GNUNET_MQ_extract_nested_mh_ ((struct GNUNET_MessageHeader *) (var), \
+ sizeof (*(var)))
/**
@@ -212,15 +221,90 @@ enum GNUNET_MQ_Error
};
+/**
+ * Per envelope preferences and priorities.
+ */
+enum GNUNET_MQ_PriorityPreferences
+{
+
+ /**
+ * Lowest priority, i.e. background traffic (i.e. NSE, FS).
+ * This is the default!
+ */
+ GNUNET_MQ_PRIO_BACKGROUND = 0,
+
+ /**
+ * Best-effort traffic (i.e. CADET relay, DHT)
+ */
+ GNUNET_MQ_PRIO_BEST_EFFORT = 1,
+
+ /**
+ * Urgent traffic (local peer, i.e. Conversation).
+ */
+ GNUNET_MQ_PRIO_URGENT = 2,
+
+ /**
+ * Highest priority, control traffic (i.e. CORE/CADET KX).
+ */
+ GNUNET_MQ_PRIO_CRITICAL_CONTROL = 3,
+
+ /**
+ * Bit mask to apply to extract the priority bits.
+ */
+ GNUNET_MQ_PRIORITY_MASK = 3,
+
+ /**
+ * Flag to indicate that unreliable delivery is acceptable. This
+ * means TRANSPORT will not attempt to receive an
+ * acknowledgment. CORE will just pass this flag through. CADET
+ * will use unreliable delivery if this flag is set.
+ *
+ * Note that even without this flag, messages may be lost by
+ * TRANSPORT and CORE.
+ *
+ * Thus, how "strong" the semantics of reliable delivery are depends
+ * on the layer!
+ */
+ GNUNET_MQ_PREF_UNRELIABLE = 16,
+
+ /**
+ * Flag to indicate that low latency is important. This flag must
+ * generally not be used in combination with
+ * #GNUNET_MQ_PREF_CORKING_ALLOWED as it would be a contradiction.
+ * When this flags is set, the envelope may skip forward in the
+ * queue (depending on priority) and also TRANSPORT should attempt
+ * to pick a communicator with particularly low latency.
+ */
+ GNUNET_MQ_PREF_LOW_LATENCY = 32,
+
+ /**
+ * Flag to indicate that CORKing is acceptable. This allows the
+ * receiver to delay transmission in hope of combining this message
+ * with other messages into a larger transmission with less
+ * per-message overhead.
+ */
+ GNUNET_MQ_PREF_CORK_ALLOWED = 64,
+
+ /**
+ * Flag to indicate that high bandwidth is desired. This flag
+ * indicates that the method chosen for transmission should focus on
+ * overall goodput. It rarely makes sense to combine this flag with
+ * #GNUNET_MQ_PREF_LOW_LATENCY.
+ */
+ GNUNET_MQ_PREF_GOODPUT = 128
+
+};
+
+
/**
* Called when a message has been received.
*
* @param cls closure
* @param msg the received message
*/
-typedef void
-(*GNUNET_MQ_MessageCallback) (void *cls,
- const struct GNUNET_MessageHeader *msg);
+typedef void (*GNUNET_MQ_MessageCallback) (
+ void *cls,
+ const struct GNUNET_MessageHeader *msg);
/**
@@ -231,9 +315,9 @@ typedef void
* @return #GNUNET_OK if the message is well-formed,
* #GNUNET_SYSERR if not
*/
-typedef int
-(*GNUNET_MQ_MessageValidationCallback) (void *cls,
- const struct GNUNET_MessageHeader *msg);
+typedef int (*GNUNET_MQ_MessageValidationCallback) (
+ void *cls,
+ const struct GNUNET_MessageHeader *msg);
/**
@@ -244,10 +328,9 @@ typedef int
* @param msg the message to send
* @param impl_state state of the implementation
*/
-typedef void
-(*GNUNET_MQ_SendImpl) (struct GNUNET_MQ_Handle *mq,
- const struct GNUNET_MessageHeader *msg,
- void *impl_state);
+typedef void (*GNUNET_MQ_SendImpl) (struct GNUNET_MQ_Handle *mq,
+ const struct GNUNET_MessageHeader *msg,
+ void *impl_state);
/**
@@ -259,9 +342,8 @@ typedef void
* @param mq the message queue to destroy
* @param impl_state state of the implementation
*/
-typedef void
-(*GNUNET_MQ_DestroyImpl) (struct GNUNET_MQ_Handle *mq,
- void *impl_state);
+typedef void (*GNUNET_MQ_DestroyImpl) (struct GNUNET_MQ_Handle *mq,
+ void *impl_state);
/**
@@ -270,9 +352,8 @@ typedef void
* @param mq message queue
* @param impl_state state specific to the implementation
*/
-typedef void
-(*GNUNET_MQ_CancelImpl) (struct GNUNET_MQ_Handle *mq,
- void *impl_state);
+typedef void (*GNUNET_MQ_CancelImpl) (struct GNUNET_MQ_Handle *mq,
+ void *impl_state);
/**
@@ -284,9 +365,7 @@ typedef void
* @param cls closure
* @param error error code
*/
-typedef void
-(*GNUNET_MQ_ErrorHandler) (void *cls,
- enum GNUNET_MQ_Error error);
+typedef void (*GNUNET_MQ_ErrorHandler) (void *cls, enum GNUNET_MQ_Error error);
/**
@@ -411,7 +490,10 @@ struct GNUNET_MQ_MessageHandler
/**
* End-marker for the handlers array
*/
-#define GNUNET_MQ_handler_end() { NULL, NULL, NULL, 0, 0 }
+#define GNUNET_MQ_handler_end() \
+ { \
+ NULL, NULL, NULL, 0, 0 \
+ }
/**
@@ -442,12 +524,14 @@ struct GNUNET_MQ_MessageHandler
* @param str type of the message (a struct)
* @param ctx context for the callbacks
*/
-#define GNUNET_MQ_hd_fixed_size(name,code,str,ctx) \
- ({ \
- void (*_cb)(void *cls, const str *msg) = &handle_##name; \
- ((struct GNUNET_MQ_MessageHandler) { \
- NULL, (GNUNET_MQ_MessageCallback) _cb, \
- (ctx), (code), sizeof (str) }); \
+#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx) \
+ ({ \
+ void (*_cb) (void *cls, const str *msg) = &handle_##name; \
+ ((struct GNUNET_MQ_MessageHandler){NULL, \
+ (GNUNET_MQ_MessageCallback) _cb, \
+ (ctx), \
+ (code), \
+ sizeof (str)}); \
})
@@ -491,14 +575,16 @@ struct GNUNET_MQ_MessageHandler
* @param str type of the message (a struct)
* @param ctx context for the callbacks
*/
-#define GNUNET_MQ_hd_var_size(name,code,str,ctx) \
- __extension__ ({ \
- int (*_mv)(void *cls, const str *msg) = &check_##name; \
- void (*_cb)(void *cls, const str *msg) = &handle_##name; \
- ((struct GNUNET_MQ_MessageHandler) \
- { (GNUNET_MQ_MessageValidationCallback) _mv, \
- (GNUNET_MQ_MessageCallback) _cb, \
- (ctx), (code), sizeof (str) }); \
+#define GNUNET_MQ_hd_var_size(name, code, str, ctx) \
+ __extension__({ \
+ int (*_mv) (void *cls, const str *msg) = &check_##name; \
+ void (*_cb) (void *cls, const str *msg) = &handle_##name; \
+ ((struct GNUNET_MQ_MessageHandler){(GNUNET_MQ_MessageValidationCallback) \
+ _mv, \
+ (GNUNET_MQ_MessageCallback) _cb, \
+ (ctx), \
+ (code), \
+ sizeof (str)}); \
})
@@ -512,18 +598,17 @@ struct GNUNET_MQ_MessageHandler
* @param an IPC message with proper type to determine
* the size, starting with a `struct GNUNET_MessageHeader`
*/
-#define GNUNET_MQ_check_zero_termination(m) \
- { \
- const char *str = (const char *) &m[1]; \
- const struct GNUNET_MessageHeader *hdr = \
- (const struct GNUNET_MessageHeader *) m; \
- uint16_t slen = ntohs (hdr->size) - sizeof (*m); \
- if ( (0 == slen) || \
- (memchr (str, 0, slen) != &str[slen - 1]) ) \
- { \
- GNUNET_break (0); \
- return GNUNET_NO; \
- } \
+#define GNUNET_MQ_check_zero_termination(m) \
+ { \
+ const char *str = (const char *) &m[1]; \
+ const struct GNUNET_MessageHeader *hdr = \
+ (const struct GNUNET_MessageHeader *) m; \
+ uint16_t slen = ntohs (hdr->size) - sizeof (*m); \
+ if ((0 == slen) || (memchr (str, 0, slen) != &str[slen - 1])) \
+ { \
+ GNUNET_break (0); \
+ return GNUNET_NO; \
+ } \
}
@@ -539,19 +624,19 @@ struct GNUNET_MQ_MessageHandler
* @param an IPC message with proper type to determine
* the size, starting with a `struct GNUNET_MessageHeader`
*/
-#define GNUNET_MQ_check_boxed_message(m) \
- { \
- const struct GNUNET_MessageHeader *inbox = \
- (const struct GNUNET_MessageHeader *) &m[1]; \
- const struct GNUNET_MessageHeader *hdr = \
- (const struct GNUNET_MessageHeader *) m; \
- uint16_t slen = ntohs (hdr->size) - sizeof (*m); \
- if ( (slen < sizeof (struct GNUNET_MessageHeader))||\
- (slen != ntohs (inbox->size)) ) \
- { \
- GNUNET_break (0); \
- return GNUNET_NO; \
- } \
+#define GNUNET_MQ_check_boxed_message(m) \
+ { \
+ const struct GNUNET_MessageHeader *inbox = \
+ (const struct GNUNET_MessageHeader *) &m[1]; \
+ const struct GNUNET_MessageHeader *hdr = \
+ (const struct GNUNET_MessageHeader *) m; \
+ uint16_t slen = ntohs (hdr->size) - sizeof (*m); \
+ if ((slen < sizeof (struct GNUNET_MessageHeader)) || \
+ (slen != ntohs (inbox->size))) \
+ { \
+ GNUNET_break (0); \
+ return GNUNET_NO; \
+ } \
}
@@ -645,25 +730,34 @@ GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq);
* #GNUNET_MQ_set_options() for this message only.
*
* @param env message to set options for
- * @param flags flags to use (meaning is queue-specific)
- * @param extra additional buffer for further data (also queue-specific)
+ * @param pp priority and preferences to set for @a env
*/
void
GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env,
- uint64_t flags,
- const void *extra);
+ enum GNUNET_MQ_PriorityPreferences pp);
/**
- * Get application-specific options for this envelope.
+ * Get performance preferences set for this envelope.
*
* @param env message to set options for
- * @param[out] flags set to flags to use (meaning is queue-specific)
- * @return extra additional buffer for further data (also queue-specific)
+ * @return priority and preferences to use
+ */
+enum GNUNET_MQ_PriorityPreferences
+GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env);
+
+
+/**
+ * Combine performance preferences set for different
+ * envelopes that are being combined into one larger envelope.
+ *
+ * @param p1 one set of preferences
+ * @param p2 second set of preferences
+ * @return combined priority and preferences to use
*/
-const void *
-GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env,
- uint64_t *flags);
+enum GNUNET_MQ_PriorityPreferences
+GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1,
+ enum GNUNET_MQ_PriorityPreferences p2);
/**
@@ -681,13 +775,11 @@ GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq);
* Set application-specific options for this queue.
*
* @param mq message queue to set options for
- * @param flags flags to use (meaning is queue-specific)
- * @param extra additional buffer for further data (also queue-specific)
+ * @param pp priority and preferences to use by default
*/
void
GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq,
- uint64_t flags,
- const void *extra);
+ enum GNUNET_MQ_PriorityPreferences pp);
/**
@@ -708,8 +800,7 @@ GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq);
* @param ev the envelope with the message to send.
*/
void
-GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
- struct GNUNET_MQ_Envelope *ev);
+GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev);
/**
@@ -742,8 +833,7 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev);
* @param assoc_data to associate
*/
uint32_t
-GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq,
- void *assoc_data);
+GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data);
/**
@@ -754,8 +844,7 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq,
* @return the associated data
*/
void *
-GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq,
- uint32_t request_id);
+GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id);
/**
@@ -766,8 +855,7 @@ GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq,
* @return the associated data
*/
void *
-GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq,
- uint32_t request_id);
+GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id);
/**
@@ -846,8 +934,8 @@ struct GNUNET_MQ_DestroyNotificationHandle;
*/
struct GNUNET_MQ_DestroyNotificationHandle *
GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
- GNUNET_SCHEDULER_TaskCallback cb,
- void *cb_cls);
+ GNUNET_SCHEDULER_TaskCallback cb,
+ void *cb_cls);
/**
* Cancel registration from #GNUNET_MQ_destroy_notify().
@@ -855,7 +943,8 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
* @param dnh handle for registration to cancel
*/
void
-GNUNET_MQ_destroy_notify_cancel (struct GNUNET_MQ_DestroyNotificationHandle
*dnh);
+GNUNET_MQ_destroy_notify_cancel (
+ struct GNUNET_MQ_DestroyNotificationHandle *dnh);
/**
@@ -947,7 +1036,6 @@ const struct GNUNET_MessageHeader *
GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq);
-
/**
* Enum defining all known preference categories.
*/
@@ -977,7 +1065,7 @@ enum GNUNET_MQ_PreferenceKind
*/
GNUNET_MQ_PREFERENCE_RELIABILITY = 3
- /**
+/**
* Number of preference values allowed.
*/
#define GNUNET_MQ_PREFERENCE_COUNT 4
@@ -995,8 +1083,6 @@ const char *
GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type);
-
-
#endif
/** @} */ /* end of group mq */
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index 5b12c4b98..09316dbcf 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -51,7 +51,6 @@
#include <gcrypt.h>
-
/**
* Should messages be delayed randomly? This option should be set to
* #GNUNET_NO only for experiments, not in production.
@@ -69,12 +68,15 @@
#define HISTORY_SIZE 64
/**
- * Message priority to use.
+ * Message priority to use. No real rush, reliability not
+ * required. Corking OK.
*/
-#define NSE_PRIORITY GNUNET_CORE_PRIO_CRITICAL_CONTROL
+#define NSE_PRIORITY \
+ (GNUNET_MQ_PRIO_BACKGROUND | GNUNET_MQ_PREF_UNRELIABLE | \
+ GNUNET_MQ_PREF_CORK_ALLOWED)
#if FREEBSD
-#define log2(a) (log(a)/log(2))
+#define log2(a) (log (a) / log (2))
#endif
/**
@@ -158,7 +160,6 @@ struct NSEPeerEntry
unsigned int last_transmitted_size;
#endif
-
};
@@ -380,13 +381,14 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage
*em)
if (0 != estimate_count)
{
mean = sum / estimate_count;
- variance = (vsq - mean * sum) / (estimate_count - 1.0); // terrible
for numerical stability...
+ variance = (vsq - mean * sum) /
+ (estimate_count - 1.0); // terrible for numerical stability...
}
#endif
if (variance >= 0)
std_dev = sqrt (variance);
else
- std_dev = variance; /* must be infinity due to estimate_count == 0
*/
+ std_dev = variance; /* must be infinity due to estimate_count == 0 */
current_std_dev = std_dev;
current_size_estimate = mean;
@@ -401,14 +403,12 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage
*em)
j = 1; /* Avoid log2(0); can only happen if CORE didn't report
connection to self yet */
nsize = log2 (j);
- em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se,
- nsize));
+ em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
em->std_deviation = GNUNET_hton_double (std_dev);
GNUNET_STATISTICS_set (stats,
- "# nodes in the network (estimate)",
- (uint64_t) pow (2, GNUNET_MAX (se,
- nsize)),
- GNUNET_NO);
+ "# nodes in the network (estimate)",
+ (uint64_t) pow (2, GNUNET_MAX (se, nsize)),
+ GNUNET_NO);
}
}
@@ -423,23 +423,19 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage
*em)
* @param message the message received
*/
static void
-handle_start (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_start (void *cls, const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SERVICE_Client *client = cls;
struct GNUNET_MQ_Handle *mq;
struct GNUNET_NSE_ClientMessage em;
struct GNUNET_MQ_Envelope *env;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received START message from client\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
mq = GNUNET_SERVICE_client_get_mq (client);
- GNUNET_notification_context_add (nc,
- mq);
+ GNUNET_notification_context_add (nc, mq);
setup_estimate_message (&em);
env = GNUNET_MQ_msg_copy (&em.header);
- GNUNET_MQ_send (mq,
- env);
+ GNUNET_MQ_send (mq, env);
GNUNET_SERVICE_client_continue (client);
}
@@ -459,8 +455,8 @@ get_matching_bits_delay (uint32_t matching_bits)
// x is matching_bits
// p' is current_size_estimate
return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0) -
- ((gnunet_nse_interval.rel_value_us / M_PI) *
- atan (matching_bits - current_size_estimate));
+ ((gnunet_nse_interval.rel_value_us / M_PI) *
+ atan (matching_bits - current_size_estimate));
}
@@ -482,10 +478,10 @@ get_delay_randomization (uint32_t matching_bits)
i = (uint32_t) (d / (double) (hop_count_max + 1));
ret.rel_value_us = i;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Randomizing flood using latencies up to %s\n",
- GNUNET_STRINGS_relative_time_to_string (ret,
- GNUNET_YES));
- ret.rel_value_us = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i +
1);
+ "Randomizing flood using latencies up to %s\n",
+ GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
+ ret.rel_value_us =
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
return ret;
#else
return GNUNET_TIME_UNIT_ZERO;
@@ -501,19 +497,18 @@ get_delay_randomization (uint32_t matching_bits)
* @param result where to write the resulting hash
*/
static void
-pow_hash (const void *buf,
- size_t buf_len,
- struct GNUNET_HashCode *result)
+pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
{
- GNUNET_break (0 ==
- gcry_kdf_derive (buf, buf_len,
- GCRY_KDF_SCRYPT,
- 1 /* subalgo */,
- "gnunet-proof-of-work",
- strlen ("gnunet-proof-of-work"),
- 2 /* iterations; keep cost of individual op
small */,
- sizeof (struct GNUNET_HashCode),
- result));
+ GNUNET_break (
+ 0 == gcry_kdf_derive (buf,
+ buf_len,
+ GCRY_KDF_SCRYPT,
+ 1 /* subalgo */,
+ "gnunet-proof-of-work",
+ strlen ("gnunet-proof-of-work"),
+ 2 /* iterations; keep cost of individual op small */,
+ sizeof (struct GNUNET_HashCode),
+ result));
}
@@ -534,11 +529,8 @@ get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
GNUNET_CRYPTO_hash (×tamp.abs_value_us,
sizeof (timestamp.abs_value_us),
×tamp_hash);
- GNUNET_CRYPTO_hash (id,
- sizeof (struct GNUNET_PeerIdentity),
- &pid_hash);
- return GNUNET_CRYPTO_hash_matching_bits (×tamp_hash,
- &pid_hash);
+ GNUNET_CRYPTO_hash (id, sizeof (struct GNUNET_PeerIdentity), &pid_hash);
+ return GNUNET_CRYPTO_hash_matching_bits (×tamp_hash, &pid_hash);
}
@@ -563,20 +555,19 @@ get_transmit_delay (int round_offset)
case -1:
/* previous round is randomized between 0 and 50 ms */
#if USE_RANDOM_DELAYS
- ret.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
- 50);
+ ret.rel_value_us =
+ GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50);
#else
ret = GNUNET_TIME_UNIT_ZERO;
#endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmitting previous round behind schedule in %s\n",
- GNUNET_STRINGS_relative_time_to_string (ret,
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
return ret;
case 0:
/* current round is based on best-known matching_bits */
matching_bits =
- ntohl (size_estimate_messages[estimate_index].matching_bits);
+ ntohl (size_estimate_messages[estimate_index].matching_bits);
dist_delay = get_matching_bits_delay (matching_bits);
dist_delay += get_delay_randomization (matching_bits).rel_value_us;
ret.rel_value_us = (uint64_t) dist_delay;
@@ -584,11 +575,9 @@ get_transmit_delay (int round_offset)
"For round %s, delay for %u matching bits is %s\n",
GNUNET_STRINGS_absolute_time_to_string (current_timestamp),
(unsigned int) matching_bits,
- GNUNET_STRINGS_relative_time_to_string (ret,
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
/* now consider round start time and add delay to it */
- tgt = GNUNET_TIME_absolute_add (current_timestamp,
- ret);
+ tgt = GNUNET_TIME_absolute_add (current_timestamp, ret);
return GNUNET_TIME_absolute_get_remaining (tgt);
}
GNUNET_break (0);
@@ -614,10 +603,10 @@ transmit_task_cb (void *cls)
{
idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
peer_entry->previous_round = GNUNET_YES;
- peer_entry->transmit_task
- = GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
- &transmit_task_cb,
- peer_entry);
+ peer_entry->transmit_task =
+ GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
+ &transmit_task_cb,
+ peer_entry);
}
if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
(NULL != proof_task))
@@ -625,7 +614,7 @@ transmit_task_cb (void *cls)
GNUNET_STATISTICS_update (stats,
"# flood messages not generated (no proof yet)",
1,
- GNUNET_NO);
+ GNUNET_NO);
return;
}
if (0 == ntohs (size_estimate_messages[idx].header.size))
@@ -633,31 +622,29 @@ transmit_task_cb (void *cls)
GNUNET_STATISTICS_update (stats,
"# flood messages not generated (lack of
history)",
1,
- GNUNET_NO);
+ GNUNET_NO);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"In round %s, sending to `%s' estimate with %u bits\n",
- GNUNET_STRINGS_absolute_time_to_string
(GNUNET_TIME_absolute_ntoh (size_estimate_messages[idx].timestamp)),
+ GNUNET_STRINGS_absolute_time_to_string (
+ GNUNET_TIME_absolute_ntoh (
+ size_estimate_messages[idx].timestamp)),
GNUNET_i2s (peer_entry->id),
(unsigned int) ntohl
(size_estimate_messages[idx].matching_bits));
if (0 == ntohl (size_estimate_messages[idx].hop_count))
- GNUNET_STATISTICS_update (stats,
- "# flood messages started",
- 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
GNUNET_STATISTICS_update (stats,
- "# flood messages transmitted",
- 1,
+ "# flood messages transmitted",
+ 1,
GNUNET_NO);
#if ENABLE_NSE_HISTOGRAM
peer_entry->transmitted_messages++;
- peer_entry->last_transmitted_size
- = ntohl(size_estimate_messages[idx].matching_bits);
+ peer_entry->last_transmitted_size =
+ ntohl (size_estimate_messages[idx].matching_bits);
#endif
env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header);
- GNUNET_MQ_send (peer_entry->mq,
- env);
+ GNUNET_MQ_send (peer_entry->mq, env);
}
@@ -673,9 +660,7 @@ update_network_size_estimate ()
struct GNUNET_NSE_ClientMessage em;
setup_estimate_message (&em);
- GNUNET_notification_context_broadcast (nc,
- &em.header,
- GNUNET_YES);
+ GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES);
}
@@ -687,36 +672,31 @@ update_network_size_estimate ()
* @param ts timestamp to use
*/
static void
-setup_flood_message (unsigned int slot,
- struct GNUNET_TIME_Absolute ts)
+setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
{
struct GNUNET_NSE_FloodMessage *fm;
uint32_t matching_bits;
- matching_bits = get_matching_bits (ts,
- &my_identity);
+ matching_bits = get_matching_bits (ts, &my_identity);
fm = &size_estimate_messages[slot];
fm->header.size = htons (sizeof (struct GNUNET_NSE_FloodMessage));
fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
fm->hop_count = htonl (0);
fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
fm->purpose.size =
- htonl (sizeof (struct GNUNET_NSE_FloodMessage) -
- sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) -
- sizeof (struct GNUNET_CRYPTO_EddsaSignature));
+ htonl (sizeof (struct GNUNET_NSE_FloodMessage) -
+ sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) -
+ sizeof (struct GNUNET_CRYPTO_EddsaSignature));
fm->matching_bits = htonl (matching_bits);
fm->timestamp = GNUNET_TIME_absolute_hton (ts);
fm->origin = my_identity;
fm->proof_of_work = my_proof;
if (nse_work_required > 0)
- GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_eddsa_sign (my_private_key,
- &fm->purpose,
- &fm->signature));
+ GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
+ &fm->purpose,
+ &fm->signature));
else
- memset (&fm->signature,
- 0,
- sizeof (fm->signature));
+ memset (&fm->signature, 0, sizeof (fm->signature));
}
@@ -731,8 +711,8 @@ setup_flood_message (unsigned int slot,
*/
static int
schedule_current_round (void *cls,
- const struct GNUNET_PeerIdentity * key,
- void *value)
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct NSEPeerEntry *peer_entry = value;
struct GNUNET_TIME_Relative delay;
@@ -744,20 +724,18 @@ schedule_current_round (void *cls,
}
#if ENABLE_NSE_HISTOGRAM
if (peer_entry->received_messages > 1)
- GNUNET_STATISTICS_update(stats,
- "# extra messages",
- peer_entry->received_messages - 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (stats,
+ "# extra messages",
+ peer_entry->received_messages - 1,
+ GNUNET_NO);
peer_entry->transmitted_messages = 0;
peer_entry->last_transmitted_size = 0;
peer_entry->received_messages = 0;
#endif
delay =
- get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
+ get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
peer_entry->transmit_task =
- GNUNET_SCHEDULER_add_delayed (delay,
- &transmit_task_cb,
- peer_entry);
+ GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
return GNUNET_OK;
}
@@ -779,9 +757,7 @@ update_flood_message (void *cls)
{
/* somehow run early, delay more */
flood_task =
- GNUNET_SCHEDULER_add_delayed (offset,
- &update_flood_message,
- NULL);
+ GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL);
return;
}
estimate_index = (estimate_index + 1) % HISTORY_SIZE;
@@ -789,32 +765,27 @@ update_flood_message (void *cls)
estimate_count++;
current_timestamp = next_timestamp;
next_timestamp =
- GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
- if ( (current_timestamp.abs_value_us ==
- GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
- (get_matching_bits (current_timestamp, &my_identity) <
- ntohl(next_message.matching_bits)) )
+ GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
+ if ((current_timestamp.abs_value_us ==
+ GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
+ (get_matching_bits (current_timestamp, &my_identity) <
+ ntohl (next_message.matching_bits)))
{
/* we received a message for this round way early, use it! */
size_estimate_messages[estimate_index] = next_message;
size_estimate_messages[estimate_index].hop_count =
- htonl (1 + ntohl (next_message.hop_count));
+ htonl (1 + ntohl (next_message.hop_count));
}
else
- setup_flood_message (estimate_index,
- current_timestamp);
- next_message.matching_bits = htonl (0); /* reset for 'next' round */
+ setup_flood_message (estimate_index, current_timestamp);
+ next_message.matching_bits = htonl (0); /* reset for 'next' round */
hop_count_max = 0;
for (i = 0; i < HISTORY_SIZE; i++)
- hop_count_max = GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count),
- hop_count_max);
- GNUNET_CONTAINER_multipeermap_iterate (peers,
- &schedule_current_round,
- NULL);
- flood_task
- = GNUNET_SCHEDULER_add_at (next_timestamp,
- &update_flood_message,
- NULL);
+ hop_count_max =
+ GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL);
+ flood_task =
+ GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
}
@@ -830,8 +801,7 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash)
unsigned int hash_count;
hash_count = 0;
- while (0 == GNUNET_CRYPTO_hash_get_bit (hash,
- hash_count))
+ while (0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count))
hash_count++;
return hash_count;
}
@@ -853,17 +823,13 @@ check_proof_of_work (const struct
GNUNET_CRYPTO_EddsaPublicKey *pkey,
sizeof (val)] GNUNET_ALIGN;
struct GNUNET_HashCode result;
- GNUNET_memcpy (buf,
- &val,
- sizeof (val));
+ GNUNET_memcpy (buf, &val, sizeof (val));
GNUNET_memcpy (&buf[sizeof (val)],
- pkey,
- sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
- pow_hash (buf,
- sizeof (buf),
- &result);
- return (count_leading_zeroes (&result) >=
- nse_work_required) ? GNUNET_YES : GNUNET_NO;
+ pkey,
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+ pow_hash (buf, sizeof (buf), &result);
+ return (count_leading_zeroes (&result) >= nse_work_required) ? GNUNET_YES
+ : GNUNET_NO;
}
@@ -876,20 +842,14 @@ write_proof ()
char *proof;
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg,
- "NSE",
- "PROOFFILE",
- &proof))
+ GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE",
&proof))
return;
- if (sizeof (my_proof) !=
- GNUNET_DISK_fn_write (proof,
- &my_proof,
- sizeof (my_proof),
- GNUNET_DISK_PERM_USER_READ |
- GNUNET_DISK_PERM_USER_WRITE))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "write",
- proof);
+ if (sizeof (my_proof) != GNUNET_DISK_fn_write (proof,
+ &my_proof,
+ sizeof (my_proof),
+ GNUNET_DISK_PERM_USER_READ |
+
GNUNET_DISK_PERM_USER_WRITE))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof);
GNUNET_free (proof);
}
@@ -910,8 +870,9 @@ find_proof (void *cls)
unsigned int i;
proof_task = NULL;
- GNUNET_memcpy (&buf[sizeof (uint64_t)], &my_identity,
- sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_memcpy (&buf[sizeof (uint64_t)],
+ &my_identity,
+ sizeof (struct GNUNET_PeerIdentity));
i = 0;
counter = my_proof;
while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
@@ -921,7 +882,8 @@ find_proof (void *cls)
if (nse_work_required <= count_leading_zeroes (&result))
{
my_proof = counter;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work found: %llu!\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Proof of work found: %llu!\n",
(unsigned long long) GNUNET_ntohll (counter));
write_proof ();
setup_flood_message (estimate_index, current_timestamp);
@@ -944,9 +906,10 @@ find_proof (void *cls)
my_proof = counter;
}
proof_task =
- GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
-
GNUNET_SCHEDULER_PRIORITY_IDLE,
- &find_proof, NULL);
+ GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ &find_proof,
+ NULL);
}
@@ -962,23 +925,22 @@ find_proof (void *cls)
static int
verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
{
- if (GNUNET_YES !=
- check_proof_of_work (&incoming_flood->origin.public_key,
- incoming_flood->proof_of_work))
+ if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key,
+ incoming_flood->proof_of_work))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Proof of work invalid: %llu!\n",
- (unsigned long long)
- GNUNET_ntohll (incoming_flood->proof_of_work));
+ (unsigned long long) GNUNET_ntohll (
+ incoming_flood->proof_of_work));
GNUNET_break_op (0);
return GNUNET_NO;
}
if ((nse_work_required > 0) &&
(GNUNET_OK !=
GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
- &incoming_flood->purpose,
- &incoming_flood->signature,
- &incoming_flood->origin.public_key)))
+ &incoming_flood->purpose,
+ &incoming_flood->signature,
+ &incoming_flood->origin.public_key)))
{
GNUNET_break_op (0);
return GNUNET_NO;
@@ -998,15 +960,15 @@ verify_message_crypto (const struct
GNUNET_NSE_FloodMessage *incoming_flood)
*/
static int
update_flood_times (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+ const struct GNUNET_PeerIdentity *key,
+ void *value)
{
struct NSEPeerEntry *exclude = cls;
struct NSEPeerEntry *peer_entry = value;
struct GNUNET_TIME_Relative delay;
if (peer_entry == exclude)
- return GNUNET_OK; /* trigger of the update */
+ return GNUNET_OK; /* trigger of the update */
if (GNUNET_NO == peer_entry->previous_round)
{
/* still stuck in previous round, no point to update, check that
@@ -1024,8 +986,7 @@ update_flood_times (void *cls,
}
delay = get_transmit_delay (0);
peer_entry->transmit_task =
- GNUNET_SCHEDULER_add_delayed (delay,
- &transmit_task_cb, peer_entry);
+ GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
return GNUNET_OK;
}
@@ -1038,7 +999,7 @@ update_flood_times (void *cls,
*/
static void
handle_p2p_estimate (void *cls,
- const struct GNUNET_NSE_FloodMessage *incoming_flood)
+ const struct GNUNET_NSE_FloodMessage *incoming_flood)
{
struct NSEPeerEntry *peer_entry = cls;
struct GNUNET_TIME_Absolute ts;
@@ -1049,17 +1010,14 @@ handle_p2p_estimate (void *cls,
{
uint64_t t;
- t = GNUNET_TIME_absolute_get().abs_value_us;
+ t = GNUNET_TIME_absolute_get ().abs_value_us;
if (NULL != lh)
GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t));
if (NULL != histogram)
GNUNET_BIO_write_int64 (histogram, t);
}
#endif
- GNUNET_STATISTICS_update (stats,
- "# flood messages received",
- 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
matching_bits = ntohl (incoming_flood->matching_bits);
#if DEBUG_NSE
{
@@ -1068,19 +1026,17 @@ handle_p2p_estimate (void *cls,
struct GNUNET_PeerIdentity os;
GNUNET_snprintf (origin,
- sizeof (origin),
- "%s",
- GNUNET_i2s (&incoming_flood->origin));
- GNUNET_snprintf (pred,
- sizeof (pred),
- "%s",
- GNUNET_i2s (peer_entry->id));
+ sizeof (origin),
+ "%s",
+ GNUNET_i2s (&incoming_flood->origin));
+ GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer_entry->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
- GNUNET_STRINGS_absolute_time_to_string
(GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
+ GNUNET_STRINGS_absolute_time_to_string (
+ GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
origin,
- pred,
- GNUNET_i2s (&my_identity),
+ pred,
+ GNUNET_i2s (&my_identity),
(unsigned int) matching_bits);
}
#endif
@@ -1089,10 +1045,7 @@ handle_p2p_estimate (void *cls,
peer_entry->received_messages++;
if (peer_entry->transmitted_messages > 0 &&
peer_entry->last_transmitted_size >= matching_bits)
- GNUNET_STATISTICS_update(stats,
- "# cross messages",
- 1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO);
#endif
ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
@@ -1104,9 +1057,8 @@ handle_p2p_estimate (void *cls,
else if (ts.abs_value_us == next_timestamp.abs_value_us)
{
if (matching_bits <= ntohl (next_message.matching_bits))
- return; /* ignore, simply too early/late */
- if (GNUNET_YES !=
- verify_message_crypto (incoming_flood))
+ return; /* ignore, simply too early/late */
+ if (GNUNET_YES != verify_message_crypto (incoming_flood))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Peer %s is likely ill-configured!\n",
@@ -1121,21 +1073,18 @@ handle_p2p_estimate (void *cls,
{
GNUNET_STATISTICS_update (stats,
"# flood messages discarded (clock skew too
large)",
- 1, GNUNET_NO);
+ 1,
+ GNUNET_NO);
return;
}
- if (0 == (GNUNET_memcmp (peer_entry->id,
- &my_identity)))
+ if (0 == (GNUNET_memcmp (peer_entry->id, &my_identity)))
{
/* send to self, update our own estimate IF this also comes from us! */
- if (0 ==
- GNUNET_memcmp (&incoming_flood->origin,
- &my_identity))
+ if (0 == GNUNET_memcmp (&incoming_flood->origin, &my_identity))
update_network_size_estimate ();
return;
}
- if (matching_bits ==
- ntohl (size_estimate_messages[idx].matching_bits))
+ if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
{
/* Cancel transmission in the other direction, as this peer clearly has
up-to-date information already. Even if we didn't talk to this peer in
@@ -1159,26 +1108,23 @@ handle_p2p_estimate (void *cls,
}
if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
{
- if ( (idx < estimate_index) &&
- (peer_entry->previous_round == GNUNET_YES))
+ if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
{
peer_entry->previous_round = GNUNET_NO;
}
/* push back our result now, that peer is spreading bad information... */
if (NULL != peer_entry->transmit_task)
GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
- peer_entry->transmit_task
- = GNUNET_SCHEDULER_add_now (&transmit_task_cb,
- peer_entry);
+ peer_entry->transmit_task =
+ GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry);
/* Not closer than our most recent message, no need to do work here */
GNUNET_STATISTICS_update (stats,
"# flood messages ignored (had closer already)",
1,
- GNUNET_NO);
+ GNUNET_NO);
return;
}
- if (GNUNET_YES !=
- verify_message_crypto (incoming_flood))
+ if (GNUNET_YES != verify_message_crypto (incoming_flood))
{
GNUNET_break_op (0);
return;
@@ -1200,20 +1146,20 @@ handle_p2p_estimate (void *cls,
}
size_estimate_messages[idx] = *incoming_flood;
size_estimate_messages[idx].hop_count =
- htonl (ntohl (incoming_flood->hop_count) + 1);
+ htonl (ntohl (incoming_flood->hop_count) + 1);
hop_count_max =
- GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1,
- hop_count_max);
+ GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
GNUNET_STATISTICS_set (stats,
- "# estimated network diameter",
- hop_count_max, GNUNET_NO);
+ "# estimated network diameter",
+ hop_count_max,
+ GNUNET_NO);
/* have a new, better size estimate, inform clients */
update_network_size_estimate ();
/* flood to rest */
GNUNET_CONTAINER_multipeermap_iterate (peers,
- &update_flood_times,
+ &update_flood_times,
peer_entry);
}
@@ -1227,40 +1173,31 @@ handle_p2p_estimate (void *cls,
*/
static void *
handle_core_connect (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Handle *mq)
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_MQ_Handle *mq)
{
struct NSEPeerEntry *peer_entry;
- uint64_t flags;
- const void *extra;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Peer `%s' connected to us\n",
GNUNET_i2s (peer));
/* set our default transmission options */
- extra = GNUNET_CORE_get_mq_options (GNUNET_NO,
- NSE_PRIORITY,
- &flags);
- GNUNET_MQ_set_options (mq,
- flags,
- extra);
+ GNUNET_MQ_set_options (mq, NSE_PRIORITY);
/* create our peer entry for this peer */
peer_entry = GNUNET_new (struct NSEPeerEntry);
peer_entry->id = peer;
peer_entry->mq = mq;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (peers,
- peer_entry->id,
- peer_entry,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ peers,
+ peer_entry->id,
+ peer_entry,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
peer_entry->transmit_task =
- GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1),
- &transmit_task_cb,
- peer_entry);
- GNUNET_STATISTICS_update (stats,
- "# peers connected",
- 1,
- GNUNET_NO);
+ GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1),
+ &transmit_task_cb,
+ peer_entry);
+ GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
return peer_entry;
}
@@ -1275,28 +1212,23 @@ handle_core_connect (void *cls,
*/
static void
handle_core_disconnect (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- void *internal_cls)
+ const struct GNUNET_PeerIdentity *peer,
+ void *internal_cls)
{
struct NSEPeerEntry *pos = internal_cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Peer `%s' disconnected from us\n",
+ "Peer `%s' disconnected from us\n",
GNUNET_i2s (peer));
GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (peers,
- peer,
- pos));
+ GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos));
if (NULL != pos->transmit_task)
{
GNUNET_SCHEDULER_cancel (pos->transmit_task);
pos->transmit_task = NULL;
}
GNUNET_free (pos);
- GNUNET_STATISTICS_update (stats,
- "# peers connected",
- -1,
- GNUNET_NO);
+ GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
}
@@ -1309,8 +1241,7 @@ handle_core_disconnect (void *cls,
* @param size the amount of data sent (ignored)
*/
static void
-flush_comp_cb (void *cls,
- size_t size)
+flush_comp_cb (void *cls, size_t size)
{
GNUNET_TESTBED_LOGGER_disconnect (lh);
lh = NULL;
@@ -1335,7 +1266,7 @@ shutdown_task (void *cls)
{
GNUNET_SCHEDULER_cancel (proof_task);
proof_task = NULL;
- write_proof (); /* remember progress */
+ write_proof (); /* remember progress */
}
if (NULL != nc)
{
@@ -1370,9 +1301,7 @@ shutdown_task (void *cls)
}
if (NULL != lh)
{
- GNUNET_TESTBED_LOGGER_flush (lh,
- &flush_comp_cb,
- NULL);
+ GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL);
}
if (NULL != histogram)
{
@@ -1390,48 +1319,37 @@ shutdown_task (void *cls)
* @param identity the public identity of this peer
*/
static void
-core_init (void *cls,
- const struct GNUNET_PeerIdentity *identity)
+core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
{
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Absolute prev_time;
if (NULL == identity)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Connection to core FAILED!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
- GNUNET_assert (0 ==
- GNUNET_memcmp (&my_identity,
- identity));
+ GNUNET_assert (0 == GNUNET_memcmp (&my_identity, identity));
now = GNUNET_TIME_absolute_get ();
current_timestamp.abs_value_us =
- (now.abs_value_us / gnunet_nse_interval.rel_value_us) *
- gnunet_nse_interval.rel_value_us;
+ (now.abs_value_us / gnunet_nse_interval.rel_value_us) *
+ gnunet_nse_interval.rel_value_us;
next_timestamp =
- GNUNET_TIME_absolute_add (current_timestamp,
- gnunet_nse_interval);
+ GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
estimate_index = HISTORY_SIZE - 1;
estimate_count = 0;
- if (GNUNET_YES ==
- check_proof_of_work (&my_identity.public_key,
- my_proof))
+ if (GNUNET_YES == check_proof_of_work (&my_identity.public_key, my_proof))
{
int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
prev_time.abs_value_us =
- current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
- setup_flood_message (idx,
- prev_time);
- setup_flood_message (estimate_index,
- current_timestamp);
+ current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
+ setup_flood_message (idx, prev_time);
+ setup_flood_message (estimate_index, current_timestamp);
estimate_count++;
}
- flood_task
- = GNUNET_SCHEDULER_add_at (next_timestamp,
- &update_flood_message,
- NULL);
+ flood_task =
+ GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
}
@@ -1445,14 +1363,12 @@ core_init (void *cls,
* #GNUNET_SYSERR if the configuration is invalid
*/
static void
-status_cb (void *cls,
- int status)
+status_cb (void *cls, int status)
{
logger_test = NULL;
if (GNUNET_YES != status)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Testbed logger not running\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
return;
}
if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
@@ -1477,59 +1393,49 @@ run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *service)
{
- struct GNUNET_MQ_MessageHandler core_handlers[] = {
- GNUNET_MQ_hd_fixed_size (p2p_estimate,
- GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
- struct GNUNET_NSE_FloodMessage,
- NULL),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_MQ_MessageHandler core_handlers[] =
+ {GNUNET_MQ_hd_fixed_size (p2p_estimate,
+ GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
+ struct GNUNET_NSE_FloodMessage,
+ NULL),
+ GNUNET_MQ_handler_end ()};
char *proof;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
cfg = c;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_time (cfg,
- "NSE",
- "INTERVAL",
- &gnunet_nse_interval))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
+ "NSE",
+ "INTERVAL",
+ &gnunet_nse_interval))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "NSE",
- "INTERVAL");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
GNUNET_SCHEDULER_shutdown ();
return;
}
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_time (cfg,
- "NSE",
- "WORKDELAY",
- &proof_find_delay))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
+ "NSE",
+ "WORKDELAY",
+ &proof_find_delay))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "NSE",
- "WORKDELAY");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
GNUNET_SCHEDULER_shutdown ();
return;
}
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (cfg,
- "NSE",
- "WORKBITS",
- &nse_work_required))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+ "NSE",
+ "WORKBITS",
+ &nse_work_required))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "NSE",
- "WORKBITS");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
- "NSE",
- "WORKBITS",
- _("Value is too large.\n"));
+ "NSE",
+ "WORKBITS",
+ _ ("Value is too large.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
@@ -1539,49 +1445,38 @@ run (void *cls,
char *histogram_dir;
char *histogram_fn;
- if (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (cfg,
- "NSE",
- "HISTOGRAM_DIR",
- &histogram_dir))
+ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
+ "NSE",
+ "HISTOGRAM_DIR",
+ &histogram_dir))
{
- GNUNET_assert (0 < GNUNET_asprintf (&histogram_fn,
- "%s/timestamps",
- histogram_dir));
+ GNUNET_assert (
+ 0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir));
GNUNET_free (histogram_dir);
histogram = GNUNET_BIO_write_open (histogram_fn);
if (NULL == histogram)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Unable to open histogram file `%s'\n",
- histogram_fn);
+ "Unable to open histogram file `%s'\n",
+ histogram_fn);
GNUNET_free (histogram_fn);
}
- logger_test =
- GNUNET_CLIENT_service_test ("testbed-logger",
- cfg,
- GNUNET_TIME_UNIT_SECONDS,
- &status_cb,
- NULL);
-
+ logger_test = GNUNET_CLIENT_service_test ("testbed-logger",
+ cfg,
+ GNUNET_TIME_UNIT_SECONDS,
+ &status_cb,
+ NULL);
}
#endif
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
GNUNET_assert (NULL != pk);
my_private_key = pk;
- GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
- &my_identity.public_key);
+ GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg,
- "NSE",
- "PROOFFILE",
- &proof))
+ GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE",
&proof))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "NSE",
- "PROOFFILE");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
GNUNET_free (my_private_key);
my_private_key = NULL;
GNUNET_SCHEDULER_shutdown ();
@@ -1589,33 +1484,30 @@ run (void *cls,
}
if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
(sizeof (my_proof) !=
- GNUNET_DISK_fn_read (proof,
- &my_proof,
- sizeof (my_proof))))
+ GNUNET_DISK_fn_read (proof, &my_proof, sizeof (my_proof))))
my_proof = 0;
GNUNET_free (proof);
proof_task =
- GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
- &find_proof,
- NULL);
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+ &find_proof,
+ NULL);
- peers = GNUNET_CONTAINER_multipeermap_create (128,
- GNUNET_YES);
+ peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
nc = GNUNET_notification_context_create (1);
/* Connect to core service and register core handlers */
- core_api = GNUNET_CORE_connect (cfg, /* Main configuration */
- NULL, /* Closure passed to functions */
- &core_init, /* Call core_init once
connected */
- &handle_core_connect, /* Handle connects */
- &handle_core_disconnect, /* Handle
disconnects */
- core_handlers); /* Register these
handlers */
+ core_api =
+ GNUNET_CORE_connect (cfg, /* Main configuration */
+ NULL, /* Closure passed to functions */
+ &core_init, /* Call core_init once connected */
+ &handle_core_connect, /* Handle connects */
+ &handle_core_disconnect, /* Handle disconnects */
+ core_handlers); /* Register these handlers */
if (NULL == core_api)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
- stats = GNUNET_STATISTICS_create ("nse",
- cfg);
+ stats = GNUNET_STATISTICS_create ("nse", cfg);
}
@@ -1629,8 +1521,8 @@ run (void *cls,
*/
static void *
client_connect_cb (void *cls,
- struct GNUNET_SERVICE_Client *c,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_SERVICE_Client *c,
+ struct GNUNET_MQ_Handle *mq)
{
return c;
}
@@ -1645,8 +1537,8 @@ client_connect_cb (void *cls,
*/
static void
client_disconnect_cb (void *cls,
- struct GNUNET_SERVICE_Client *c,
- void *internal_cls)
+ struct GNUNET_SERVICE_Client *c,
+ void *internal_cls)
{
GNUNET_assert (c == internal_cls);
}
@@ -1655,18 +1547,17 @@ client_disconnect_cb (void *cls,
/**
* Define "main" method using service macro.
*/
-GNUNET_SERVICE_MAIN
-("nse",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_fixed_size (start,
- GNUNET_MESSAGE_TYPE_NSE_START,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ());
+GNUNET_SERVICE_MAIN ("nse",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ GNUNET_MQ_hd_fixed_size (start,
+ GNUNET_MESSAGE_TYPE_NSE_START,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_handler_end ());
#if defined(LINUX) && defined(__GLIBC__)
@@ -1675,8 +1566,7 @@ GNUNET_SERVICE_MAIN
/**
* MINIMIZE heap size (way below 128k) since this process doesn't need much.
*/
-void __attribute__ ((constructor))
-GNUNET_ARM_memory_init ()
+void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
{
mallopt (M_TRIM_THRESHOLD, 4 * 1024);
mallopt (M_TOP_PAD, 1 * 1024);
@@ -1685,5 +1575,4 @@ GNUNET_ARM_memory_init ()
#endif
-
/* end of gnunet-service-nse.c */
diff --git a/src/topology/gnunet-daemon-topology.c
b/src/topology/gnunet-daemon-topology.c
index e5734abb4..5a22ee0d2 100644
--- a/src/topology/gnunet-daemon-topology.c
+++ b/src/topology/gnunet-daemon-topology.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -51,12 +51,14 @@
/**
* At what frequency do we sent HELLOs to a peer?
*/
-#define HELLO_ADVERTISEMENT_MIN_FREQUENCY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5)
+#define HELLO_ADVERTISEMENT_MIN_FREQUENCY \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
/**
* After what time period do we expire the HELLO Bloom filter?
*/
-#define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_HOURS, 4)
+#define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
/**
@@ -116,7 +118,6 @@ struct Peer
* Is this peer listed here because it is a friend?
*/
int is_friend;
-
};
@@ -216,15 +217,12 @@ static unsigned int friend_count;
* @return #GNUNET_OK if the connection is allowed
*/
static int
-blacklist_check (void *cls,
- const struct GNUNET_PeerIdentity *pid)
+blacklist_check (void *cls, const struct GNUNET_PeerIdentity *pid)
{
struct Peer *pos;
- pos = GNUNET_CONTAINER_multipeermap_get (peers,
- pid);
- if ( (NULL != pos) &&
- (GNUNET_YES == pos->is_friend))
+ pos = GNUNET_CONTAINER_multipeermap_get (peers, pid);
+ if ((NULL != pos) && (GNUNET_YES == pos->is_friend))
return GNUNET_OK;
GNUNET_STATISTICS_update (stats,
gettext_noop ("# peers blacklisted"),
@@ -258,17 +256,13 @@ whitelist_peers ()
* @return #GNUNET_YES (always: continue to iterate)
*/
static int
-free_peer (void *cls,
- const struct GNUNET_PeerIdentity * pid,
- void *value)
+free_peer (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
{
struct Peer *pos = value;
GNUNET_break (NULL == pos->mq);
GNUNET_break (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_remove (peers,
- pid,
- pos));
+ GNUNET_CONTAINER_multipeermap_remove (peers, pid, pos));
if (NULL != pos->hello_delay_task)
{
GNUNET_SCHEDULER_cancel (pos->hello_delay_task);
@@ -305,16 +299,13 @@ attempt_connect (struct Peer *pos)
{
uint32_t strength;
- if (0 ==
- GNUNET_memcmp (&my_identity,
- &pos->pid))
+ if (0 == GNUNET_memcmp (&my_identity, &pos->pid))
return; /* This is myself, nothing to do. */
if (connection_count < target_connection_count)
strength = 1;
else
strength = 0;
- if ( (friend_count < minimum_friend_count) ||
- (GNUNET_YES == friends_only) )
+ if ((friend_count < minimum_friend_count) || (GNUNET_YES == friends_only))
{
if (pos->is_friend)
strength += 10; /* urgently needed */
@@ -343,9 +334,7 @@ attempt_connect (struct Peer *pos)
gettext_noop ("# connect requests issued to
ATS"),
1,
GNUNET_NO);
- pos->sh = GNUNET_ATS_connectivity_suggest (ats,
- &pos->pid,
- strength);
+ pos->sh = GNUNET_ATS_connectivity_suggest (ats, &pos->pid, strength);
}
}
@@ -371,15 +360,14 @@ make_peer (const struct GNUNET_PeerIdentity *peer,
if (NULL != hello)
{
ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
- GNUNET_memcpy (ret->hello,
- hello,
- GNUNET_HELLO_size (hello));
+ GNUNET_memcpy (ret->hello, hello, GNUNET_HELLO_size (hello));
}
GNUNET_break (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (peers,
- peer,
- ret,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ peers,
+ peer,
+ ret,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
return ret;
}
@@ -403,12 +391,9 @@ setup_filter (struct Peer *peer)
* any case; hence 64, 5 as bloomfilter parameters. */
peer->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, 64, 5);
peer->filter_expiration =
- GNUNET_TIME_relative_to_absolute
- (HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY);
+ GNUNET_TIME_relative_to_absolute
(HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY);
/* never send a peer its own HELLO */
- GNUNET_CRYPTO_hash (&peer->pid,
- sizeof (struct GNUNET_PeerIdentity),
- &hc);
+ GNUNET_CRYPTO_hash (&peer->pid, sizeof (struct GNUNET_PeerIdentity), &hc);
GNUNET_CONTAINER_bloomfilter_add (peer->filter, &hc);
}
@@ -473,10 +458,9 @@ find_advertisable_hello (void *cls,
if (hs > fah->max_size)
return GNUNET_YES;
GNUNET_CRYPTO_hash (&fah->peer->pid,
- sizeof (struct GNUNET_PeerIdentity), &hc);
- if (GNUNET_NO ==
- GNUNET_CONTAINER_bloomfilter_test (pos->filter,
- &hc))
+ sizeof (struct GNUNET_PeerIdentity),
+ &hc);
+ if (GNUNET_NO == GNUNET_CONTAINER_bloomfilter_test (pos->filter, &hc))
fah->result = pos;
return GNUNET_YES;
}
@@ -505,13 +489,9 @@ schedule_next_hello (void *cls)
fah.result = NULL;
fah.max_size = GNUNET_MAX_MESSAGE_SIZE - 1;
fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;
- GNUNET_CONTAINER_multipeermap_iterate (peers,
- &find_advertisable_hello,
- &fah);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &find_advertisable_hello,
&fah);
pl->hello_delay_task =
- GNUNET_SCHEDULER_add_delayed (fah.next_adv,
- &schedule_next_hello,
- pl);
+ GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl);
if (NULL == fah.result)
return;
delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
@@ -520,31 +500,25 @@ schedule_next_hello (void *cls)
want = GNUNET_HELLO_size (fah.result->hello);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending HELLO with %u bytes",
- (unsigned int) want);
+ "Sending HELLO with %u bytes",
+ (unsigned int) want);
env = GNUNET_MQ_msg_copy (&fah.result->hello->header);
- GNUNET_MQ_send (pl->mq,
- env);
+ GNUNET_MQ_send (pl->mq, env);
/* avoid sending this one again soon */
- GNUNET_CRYPTO_hash (&pl->pid,
- sizeof (struct GNUNET_PeerIdentity),
- &hc);
- GNUNET_CONTAINER_bloomfilter_add (fah.result->filter,
- &hc);
+ GNUNET_CRYPTO_hash (&pl->pid, sizeof (struct GNUNET_PeerIdentity), &hc);
+ GNUNET_CONTAINER_bloomfilter_add (fah.result->filter, &hc);
GNUNET_STATISTICS_update (stats,
- gettext_noop ("# HELLO messages gossipped"),
- 1,
- GNUNET_NO);
+ gettext_noop ("# HELLO messages gossipped"),
+ 1,
+ GNUNET_NO);
/* prepare to send the next one */
- pl->next_hello_allowed
- = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
+ pl->next_hello_allowed =
+ GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
if (NULL != pl->hello_delay_task)
GNUNET_SCHEDULER_cancel (pl->hello_delay_task);
- pl->hello_delay_task
- = GNUNET_SCHEDULER_add_now (&schedule_next_hello,
- pl);
+ pl->hello_delay_task = GNUNET_SCHEDULER_add_now (&schedule_next_hello, pl);
}
@@ -576,7 +550,7 @@ reschedule_hellos (void *cls,
peer->hello_delay_task = NULL;
}
peer->hello_delay_task =
- GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer);
+ GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer);
return GNUNET_YES;
}
@@ -592,36 +566,25 @@ reschedule_hellos (void *cls,
static void *
connect_notify (void *cls,
const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_MQ_Handle *mq)
{
struct Peer *pos;
- uint64_t flags;
- const void *extra;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Core told us that we are connecting to `%s'\n",
GNUNET_i2s (peer));
- if (0 == GNUNET_memcmp (&my_identity,
- peer))
+ if (0 == GNUNET_memcmp (&my_identity, peer))
return NULL;
- extra = GNUNET_CORE_get_mq_options (GNUNET_YES,
- GNUNET_CORE_PRIO_BEST_EFFORT,
- &flags);
- GNUNET_MQ_set_options (mq,
- flags,
- extra);
+ GNUNET_MQ_set_options (mq, GNUNET_MQ_PRIO_BEST_EFFORT);
connection_count++;
GNUNET_STATISTICS_set (stats,
gettext_noop ("# peers connected"),
connection_count,
GNUNET_NO);
- pos = GNUNET_CONTAINER_multipeermap_get (peers,
- peer);
+ pos = GNUNET_CONTAINER_multipeermap_get (peers, peer);
if (NULL == pos)
{
- pos = make_peer (peer,
- NULL,
- GNUNET_NO);
+ pos = make_peer (peer, NULL, GNUNET_NO);
}
else
{
@@ -631,17 +594,14 @@ connect_notify (void *cls,
if (pos->is_friend)
{
friend_count++;
- if ( (friend_count == minimum_friend_count) &&
- (GNUNET_YES != friends_only) )
+ if ((friend_count == minimum_friend_count) && (GNUNET_YES != friends_only))
whitelist_peers ();
GNUNET_STATISTICS_set (stats,
gettext_noop ("# friends connected"),
friend_count,
GNUNET_NO);
}
- reschedule_hellos (NULL,
- peer,
- pos);
+ reschedule_hellos (NULL, peer, pos);
return pos;
}
@@ -655,9 +615,7 @@ connect_notify (void *cls,
* @return #GNUNET_YES (continue to iterate)
*/
static int
-try_add_peers (void *cls,
- const struct GNUNET_PeerIdentity *pid,
- void *value)
+try_add_peers (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
{
struct Peer *pos = value;
@@ -676,9 +634,7 @@ add_peer_task (void *cls)
{
add_task = NULL;
- GNUNET_CONTAINER_multipeermap_iterate (peers,
- &try_add_peers,
- NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &try_add_peers, NULL);
}
@@ -692,7 +648,7 @@ add_peer_task (void *cls)
static void
disconnect_notify (void *cls,
const struct GNUNET_PeerIdentity *peer,
- void *internal_cls)
+ void *internal_cls)
{
struct Peer *pos = internal_cls;
@@ -725,16 +681,12 @@ disconnect_notify (void *cls,
friend_count,
GNUNET_NO);
}
- if ( ( (connection_count < target_connection_count) ||
- (friend_count < minimum_friend_count)) &&
- (NULL == add_task) )
- add_task = GNUNET_SCHEDULER_add_now (&add_peer_task,
- NULL);
- if ( (friend_count < minimum_friend_count) &&
- (NULL == blacklist))
- blacklist = GNUNET_TRANSPORT_blacklist (cfg,
- &blacklist_check,
- NULL);
+ if (((connection_count < target_connection_count) ||
+ (friend_count < minimum_friend_count)) &&
+ (NULL == add_task))
+ add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL);
+ if ((friend_count < minimum_friend_count) && (NULL == blacklist))
+ blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);
}
@@ -779,38 +731,32 @@ consider_for_advertising (const struct
GNUNET_HELLO_Message *hello)
GNUNET_break (0);
return;
}
- if (0 == GNUNET_memcmp (&pid,
- &my_identity))
- return; /* that's me! */
+ if (0 == GNUNET_memcmp (&pid, &my_identity))
+ return; /* that's me! */
have_address = GNUNET_NO;
GNUNET_HELLO_iterate_addresses (hello,
GNUNET_NO,
&address_iterator,
&have_address);
if (GNUNET_NO == have_address)
- return; /* no point in advertising this one... */
+ return; /* no point in advertising this one... */
peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid);
if (NULL == peer)
{
- peer = make_peer (&pid,
- hello,
- GNUNET_NO);
+ peer = make_peer (&pid, hello, GNUNET_NO);
}
else if (NULL != peer->hello)
{
- dt = GNUNET_HELLO_equals (peer->hello,
- hello,
- GNUNET_TIME_absolute_get ());
+ dt = GNUNET_HELLO_equals (peer->hello, hello, GNUNET_TIME_absolute_get ());
if (dt.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
- return; /* nothing new here */
+ return; /* nothing new here */
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Found HELLO from peer `%s' for advertising\n",
GNUNET_i2s (&pid));
if (NULL != peer->hello)
{
- nh = GNUNET_HELLO_merge (peer->hello,
- hello);
+ nh = GNUNET_HELLO_merge (peer->hello, hello);
GNUNET_free (peer->hello);
peer->hello = nh;
}
@@ -818,9 +764,7 @@ consider_for_advertising (const struct GNUNET_HELLO_Message
*hello)
{
size = GNUNET_HELLO_size (hello);
peer->hello = GNUNET_malloc (size);
- GNUNET_memcpy (peer->hello,
- hello,
- size);
+ GNUNET_memcpy (peer->hello, hello, size);
}
if (NULL != peer->filter)
{
@@ -830,9 +774,7 @@ consider_for_advertising (const struct GNUNET_HELLO_Message
*hello)
setup_filter (peer);
/* since we have a new HELLO to pick from, re-schedule all
* HELLO requests that are not bound by the HELLO send rate! */
- GNUNET_CONTAINER_multipeermap_iterate (peers,
- &reschedule_hellos,
- peer);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &reschedule_hellos, peer);
}
@@ -856,24 +798,20 @@ process_peer (void *cls,
if (NULL != err_msg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Error in communication with PEERINFO service: %s\n"),
+ _ ("Error in communication with PEERINFO service: %s\n"),
err_msg);
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
- peerinfo_notify = GNUNET_PEERINFO_notify (cfg,
- GNUNET_NO,
- &process_peer,
- NULL);
+ peerinfo_notify =
+ GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_peer, NULL);
return;
}
GNUNET_assert (NULL != peer);
- if (0 == GNUNET_memcmp (&my_identity,
- peer))
- return; /* that's me! */
+ if (0 == GNUNET_memcmp (&my_identity, peer))
+ return; /* that's me! */
if (NULL == hello)
{
/* free existing HELLO, if any */
- pos = GNUNET_CONTAINER_multipeermap_get (peers,
- peer);
+ pos = GNUNET_CONTAINER_multipeermap_get (peers, peer);
if (NULL != pos)
{
GNUNET_free_non_null (pos->hello);
@@ -883,21 +821,15 @@ process_peer (void *cls,
GNUNET_CONTAINER_bloomfilter_free (pos->filter);
pos->filter = NULL;
}
- if ( (NULL == pos->mq) &&
- (GNUNET_NO == pos->is_friend) )
- free_peer (NULL,
- &pos->pid,
- pos);
+ if ((NULL == pos->mq) && (GNUNET_NO == pos->is_friend))
+ free_peer (NULL, &pos->pid, pos);
}
return;
}
consider_for_advertising (hello);
- pos = GNUNET_CONTAINER_multipeermap_get (peers,
- peer);
+ pos = GNUNET_CONTAINER_multipeermap_get (peers, peer);
if (NULL == pos)
- pos = make_peer (peer,
- hello,
- GNUNET_NO);
+ pos = make_peer (peer, hello, GNUNET_NO);
attempt_connect (pos);
}
@@ -910,24 +842,20 @@ process_peer (void *cls,
* @param my_id ID of this peer, NULL if we failed
*/
static void
-core_init (void *cls,
- const struct GNUNET_PeerIdentity *my_id)
+core_init (void *cls, const struct GNUNET_PeerIdentity *my_id)
{
if (NULL == my_id)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to connect to core service, can not manage
topology!\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_ERROR,
+ _ ("Failed to connect to core service, can not manage topology!\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
my_identity = *my_id;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "I am peer `%s'\n",
- GNUNET_i2s (my_id));
- peerinfo_notify = GNUNET_PEERINFO_notify (cfg,
- GNUNET_NO,
- &process_peer,
- NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am peer `%s'\n", GNUNET_i2s (my_id));
+ peerinfo_notify =
+ GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_peer, NULL);
}
@@ -938,24 +866,22 @@ core_init (void *cls,
* @param pid identity of the friend
*/
static void
-handle_friend (void *cls,
- const struct GNUNET_PeerIdentity *pid)
+handle_friend (void *cls, const struct GNUNET_PeerIdentity *pid)
{
unsigned int *entries_found = cls;
struct Peer *fl;
- if (0 == GNUNET_memcmp (pid,
- &my_identity))
+ if (0 == GNUNET_memcmp (pid, &my_identity))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Found myself `%s' in friend list (useless, ignored)\n"),
+ _ ("Found myself `%s' in friend list (useless, ignored)\n"),
GNUNET_i2s (pid));
return;
}
(*entries_found)++;
fl = make_peer (pid, NULL, GNUNET_YES);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Found friend `%s' in configuration\n"),
+ _ ("Found friend `%s' in configuration\n"),
GNUNET_i2s (&fl->pid));
}
@@ -969,31 +895,30 @@ read_friends_file (const struct
GNUNET_CONFIGURATION_Handle *cfg)
unsigned int entries_found;
entries_found = 0;
- if (GNUNET_OK !=
- GNUNET_FRIENDS_parse (cfg,
- &handle_friend,
- &entries_found))
+ if (GNUNET_OK != GNUNET_FRIENDS_parse (cfg, &handle_friend, &entries_found))
{
- if ( (GNUNET_YES == friends_only) ||
- (minimum_friend_count > 0))
+ if ((GNUNET_YES == friends_only) || (minimum_friend_count > 0))
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Encountered errors parsing friends list!\n"));
+ _ ("Encountered errors parsing friends list!\n"));
}
GNUNET_STATISTICS_update (stats,
gettext_noop ("# friends in configuration"),
entries_found,
GNUNET_NO);
- if ( (minimum_friend_count > entries_found) &&
- (GNUNET_NO == friends_only) )
+ if ((minimum_friend_count > entries_found) && (GNUNET_NO == friends_only))
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Fewer friends specified than required by minimum friend
count. Will only connect to friends.\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ _ (
+ "Fewer friends specified than required by minimum friend count. Will
only connect to friends.\n"));
}
- if ( (minimum_friend_count > target_connection_count) &&
- (GNUNET_NO == friends_only))
+ if ((minimum_friend_count > target_connection_count) &&
+ (GNUNET_NO == friends_only))
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("More friendly connections required than target total number
of connections.\n"));
+ GNUNET_log (
+ GNUNET_ERROR_TYPE_WARNING,
+ _ (
+ "More friendly connections required than target total number of
connections.\n"));
}
}
@@ -1008,14 +933,11 @@ read_friends_file (const struct
GNUNET_CONFIGURATION_Handle *cfg)
* #GNUNET_SYSERR if @a message is invalid
*/
static int
-check_hello (void *cls,
- const struct GNUNET_HELLO_Message *message)
+check_hello (void *cls, const struct GNUNET_HELLO_Message *message)
{
struct GNUNET_PeerIdentity pid;
- if (GNUNET_OK !=
- GNUNET_HELLO_get_id (message,
- &pid))
+ if (GNUNET_OK != GNUNET_HELLO_get_id (message, &pid))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
@@ -1032,8 +954,7 @@ check_hello (void *cls,
* @param message the actual HELLO message
*/
static void
-handle_hello (void *cls,
- const struct GNUNET_HELLO_Message *message)
+handle_hello (void *cls, const struct GNUNET_HELLO_Message *message)
{
const struct GNUNET_PeerIdentity *other = cls;
struct Peer *peer;
@@ -1042,34 +963,26 @@ handle_hello (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received encrypted HELLO from peer `%s'",
GNUNET_i2s (other));
- GNUNET_assert (GNUNET_OK ==
- GNUNET_HELLO_get_id (message,
- &pid));
+ GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (message, &pid));
GNUNET_STATISTICS_update (stats,
gettext_noop ("# HELLO messages received"),
1,
GNUNET_NO);
- peer = GNUNET_CONTAINER_multipeermap_get (peers,
- &pid);
+ peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid);
if (NULL == peer)
{
- if ( (GNUNET_YES == friends_only) ||
- (friend_count < minimum_friend_count) )
+ if ((GNUNET_YES == friends_only) || (friend_count < minimum_friend_count))
return;
}
else
{
- if ( (GNUNET_YES != peer->is_friend) &&
- (GNUNET_YES == friends_only) )
+ if ((GNUNET_YES != peer->is_friend) && (GNUNET_YES == friends_only))
return;
if ((GNUNET_YES != peer->is_friend) &&
(friend_count < minimum_friend_count))
return;
}
- (void) GNUNET_PEERINFO_add_peer (pi,
- message,
- NULL,
- NULL);
+ (void) GNUNET_PEERINFO_add_peer (pi, message, NULL, NULL);
}
@@ -1103,9 +1016,7 @@ cleaning_task (void *cls)
GNUNET_TRANSPORT_offer_hello_cancel (oh);
oh = NULL;
}
- GNUNET_CONTAINER_multipeermap_iterate (peers,
- &free_peer,
- NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (peers, &free_peer, NULL);
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
if (NULL != ats)
@@ -1140,26 +1051,22 @@ run (void *cls,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (hello,
- GNUNET_MESSAGE_TYPE_HELLO,
- struct GNUNET_HELLO_Message,
- NULL),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_var_size (hello,
+ GNUNET_MESSAGE_TYPE_HELLO,
+ struct GNUNET_HELLO_Message,
+ NULL),
+ GNUNET_MQ_handler_end ()};
unsigned long long opt;
cfg = c;
stats = GNUNET_STATISTICS_create ("topology", cfg);
friends_only =
- GNUNET_CONFIGURATION_get_value_yesno (cfg,
- "TOPOLOGY",
- "FRIENDS-ONLY");
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (cfg,
- "TOPOLOGY",
- "MINIMUM-FRIENDS",
- &opt))
+ GNUNET_CONFIGURATION_get_value_yesno (cfg, "TOPOLOGY", "FRIENDS-ONLY");
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+ "TOPOLOGY",
+ "MINIMUM-FRIENDS",
+ &opt))
opt = 0;
minimum_friend_count = (unsigned int) opt;
if (GNUNET_OK !=
@@ -1176,25 +1083,21 @@ run (void *cls,
"Topology would like %u connections with at least %u friends\n",
target_connection_count,
minimum_friend_count);
- if ( (GNUNET_YES == friends_only) ||
- (minimum_friend_count > 0))
- blacklist = GNUNET_TRANSPORT_blacklist (cfg,
- &blacklist_check,
- NULL);
+ if ((GNUNET_YES == friends_only) || (minimum_friend_count > 0))
+ blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);
ats = GNUNET_ATS_connectivity_init (cfg);
pi = GNUNET_PEERINFO_connect (cfg);
handle = GNUNET_CORE_connect (cfg,
- NULL,
- &core_init,
- &connect_notify,
- &disconnect_notify,
- handlers);
- GNUNET_SCHEDULER_add_shutdown (&cleaning_task,
- NULL);
+ NULL,
+ &core_init,
+ &connect_notify,
+ &disconnect_notify,
+ handlers);
+ GNUNET_SCHEDULER_add_shutdown (&cleaning_task, NULL);
if (NULL == handle)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to connect to `%s' service.\n"),
+ _ ("Failed to connect to `%s' service.\n"),
"core");
GNUNET_SCHEDULER_shutdown ();
return;
@@ -1210,24 +1113,25 @@ run (void *cls,
* @return 0 ok, 1 on error
*/
int
-main (int argc,
- char *const *argv)
+main (int argc, char *const *argv)
{
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_OPTION_END
- };
+ GNUNET_GETOPT_OPTION_END};
int ret;
if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
return 2;
- ret =
- (GNUNET_OK ==
- GNUNET_PROGRAM_run (argc, argv,
- "gnunet-daemon-topology",
- _("GNUnet topology control"),
- options, &run, NULL)) ? 0 : 1;
- GNUNET_free ((void*) argv);
+ ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
+ argv,
+ "gnunet-daemon-topology",
+ _ ("GNUnet topology control"),
+ options,
+ &run,
+ NULL))
+ ? 0
+ : 1;
+ GNUNET_free ((void *) argv);
return ret;
}
@@ -1238,8 +1142,7 @@ main (int argc,
/**
* MINIMIZE heap size (way below 128k) since this process doesn't need much.
*/
-void __attribute__ ((constructor))
-GNUNET_ARM_memory_init ()
+void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
{
mallopt (M_TRIM_THRESHOLD, 4 * 1024);
mallopt (M_TOP_PAD, 1 * 1024);
diff --git a/src/transport/gnunet-service-tng.c
b/src/transport/gnunet-service-tng.c
index 95ea102df..b217c8aa9 100644
--- a/src/transport/gnunet-service-tng.c
+++ b/src/transport/gnunet-service-tng.c
@@ -3743,10 +3743,13 @@ handle_client_send (void *cls, const struct
OutboundMessage *obm)
size_t payload_size;
struct TransportDVBoxMessage *dvb;
struct VirtualLink *vl;
+ enum GNUNET_MQ_PriorityPreferences pp;
GNUNET_assert (CT_CORE == tc->type);
obmm = (const struct GNUNET_MessageHeader *) &obm[1];
bytes_msg = ntohs (obmm->size);
+ pp = (enum GNUNET_MQ_PriorityPreferences) ntohl (obm->priority);
+ /* FIXME: actually make use of pp */ (void) pp;
vl = GNUNET_CONTAINER_multipeermap_get (links, &obm->peer);
if (NULL == vl)
{
diff --git a/src/transport/transport.h b/src/transport/transport.h
index 4ba628112..7fe869fa8 100644
--- a/src/transport/transport.h
+++ b/src/transport/transport.h
@@ -302,9 +302,9 @@ struct OutboundMessage
struct GNUNET_MessageHeader header;
/**
- * Always zero.
+ * An `enum GNUNET_MQ_PriorityPreferences` in NBO.
*/
- uint32_t reserved GNUNET_PACKED;
+ uint32_t priority GNUNET_PACKED;
#if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
defined(GNUNET_TRANSPORT_CORE_VERSION))
diff --git a/src/transport/transport_api2_core.c
b/src/transport/transport_api2_core.c
index a3c49e94f..20bbf2994 100644
--- a/src/transport/transport_api2_core.c
+++ b/src/transport/transport_api2_core.c
@@ -329,7 +329,12 @@ mq_send_impl (struct GNUNET_MQ_Handle *mq,
n->env =
GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
n->env_size = ntohs (msg->size);
- obm->reserved = htonl (0);
+ {
+ struct GNUNET_MQ_Envelope *env;
+
+ env = GNUNET_MQ_get_current_envelope (mq);
+ obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
+ }
obm->peer = n->id;
if (0 == n->ready_window)
{
diff --git a/src/transport/transport_api_core.c
b/src/transport/transport_api_core.c
index a163d7ccf..54dc7f4c3 100644
--- a/src/transport/transport_api_core.c
+++ b/src/transport/transport_api_core.c
@@ -418,7 +418,12 @@ mq_send_impl (struct GNUNET_MQ_Handle *mq,
GNUNET_assert (NULL == n->env);
n->env =
GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
- obm->reserved = htonl (0);
+ {
+ struct GNUNET_MQ_Envelope *env;
+
+ env = GNUNET_MQ_get_current_envelope (mq);
+ obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
+ }
obm->timeout = GNUNET_TIME_relative_hton (
GNUNET_TIME_UNIT_MINUTES); /* FIXME: to be removed */
obm->peer = n->id;
diff --git a/src/util/mq.c b/src/util/mq.c
index 513c008ee..2f9e650b6 100644
--- a/src/util/mq.c
+++ b/src/util/mq.c
@@ -26,7 +26,7 @@
#include "platform.h"
#include "gnunet_util_lib.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "util-mq",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "util-mq", __VA_ARGS__)
struct GNUNET_MQ_Envelope
@@ -70,14 +70,7 @@ struct GNUNET_MQ_Envelope
* #GNUNET_MQ_env_set_options(). Only valid if
* @e have_custom_options is set.
*/
- uint64_t flags;
-
- /**
- * Additional options buffer set for this envelope by
- * #GNUNET_MQ_env_set_options(). Only valid if
- * @e have_custom_options is set.
- */
- const void *extra;
+ enum GNUNET_MQ_PriorityPreferences priority;
/**
* Did the application call #GNUNET_MQ_env_set_options()?
@@ -164,17 +157,11 @@ struct GNUNET_MQ_Handle
*/
struct GNUNET_MQ_DestroyNotificationHandle *dnh_tail;
- /**
- * Additional options buffer set for this queue by
- * #GNUNET_MQ_set_options(). Default is 0.
- */
- const void *default_extra;
-
/**
* Flags that were set for this queue by
* #GNUNET_MQ_set_options(). Default is 0.
*/
- uint64_t default_flags;
+ enum GNUNET_MQ_PriorityPreferences priority;
/**
* Next id that should be used for the @e assoc_map,
@@ -217,12 +204,10 @@ GNUNET_MQ_inject_message (struct GNUNET_MQ_Handle *mq,
{
int ret;
- ret = GNUNET_MQ_handle_message (mq->handlers,
- mh);
+ ret = GNUNET_MQ_handle_message (mq->handlers, mh);
if (GNUNET_SYSERR == ret)
{
- GNUNET_MQ_inject_error (mq,
- GNUNET_MQ_ERROR_MALFORMED);
+ GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_MALFORMED);
return;
}
}
@@ -251,7 +236,8 @@ GNUNET_MQ_handle_message (const struct
GNUNET_MQ_MessageHandler *handlers,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received message of type %u and size %u\n",
- mtype, msize);
+ mtype,
+ msize);
if (NULL == handlers)
goto done;
@@ -260,41 +246,40 @@ GNUNET_MQ_handle_message (const struct
GNUNET_MQ_MessageHandler *handlers,
if (handler->type == mtype)
{
handled = GNUNET_YES;
- if ( (handler->expected_size > msize) ||
- ( (handler->expected_size != msize) &&
- (NULL == handler->mv) ) )
+ if ((handler->expected_size > msize) ||
+ ((handler->expected_size != msize) && (NULL == handler->mv)))
{
- /* Too small, or not an exact size and
+ /* Too small, or not an exact size and
no 'mv' handler to check rest */
LOG (GNUNET_ERROR_TYPE_ERROR,
"Received malformed message of type %u\n",
(unsigned int) handler->type);
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
}
- if ( (NULL == handler->mv) ||
- (GNUNET_OK ==
- handler->mv (handler->cls, mh)) )
+ if ((NULL == handler->mv) ||
+ (GNUNET_OK == handler->mv (handler->cls, mh)))
{
- /* message well-formed, pass to handler */
- handler->cb (handler->cls, mh);
+ /* message well-formed, pass to handler */
+ handler->cb (handler->cls, mh);
}
else
{
- /* Message rejected by check routine */
+ /* Message rejected by check routine */
LOG (GNUNET_ERROR_TYPE_ERROR,
"Received malformed message of type %u\n",
(unsigned int) handler->type);
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
}
break;
}
}
- done:
+done:
if (GNUNET_NO == handled)
{
LOG (GNUNET_ERROR_TYPE_INFO,
"No handler for message of type %u and size %u\n",
- mtype, msize);
+ mtype,
+ msize);
return GNUNET_NO;
}
return GNUNET_OK;
@@ -312,8 +297,7 @@ GNUNET_MQ_handle_message (const struct
GNUNET_MQ_MessageHandler *handlers,
* @param error the error type
*/
void
-GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq,
- enum GNUNET_MQ_Error error)
+GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error
error)
{
if (NULL == mq->error_handler)
{
@@ -322,8 +306,7 @@ GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq,
(int) error);
return;
}
- mq->error_handler (mq->error_handler_cls,
- error);
+ mq->error_handler (mq->error_handler_cls, error);
}
@@ -367,8 +350,7 @@ GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq)
* @param ev the envelope with the message to send.
*/
void
-GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
- struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
{
GNUNET_assert (NULL != mq);
GNUNET_assert (NULL == ev->parent_queue);
@@ -378,18 +360,15 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
{
/* This would seem like a bug... */
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "MQ with %u entries extended by message of type %u (FC
broken?)\n",
- (unsigned int) mq->queue_length,
- (unsigned int) ntohs (ev->mh->type));
+ "MQ with %u entries extended by message of type %u (FC
broken?)\n",
+ (unsigned int) mq->queue_length,
+ (unsigned int) ntohs (ev->mh->type));
}
ev->parent_queue = mq;
/* is the implementation busy? queue it! */
- if ( (NULL != mq->current_envelope) ||
- (NULL != mq->send_task) )
+ if ((NULL != mq->current_envelope) || (NULL != mq->send_task))
{
- GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head,
- mq->envelope_tail,
- ev);
+ GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head, mq->envelope_tail,
ev);
return;
}
GNUNET_assert (NULL == mq->envelope_head);
@@ -397,12 +376,10 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"sending message of type %u, queue empty (MQ: %p)\n",
- ntohs(ev->mh->type),
+ ntohs (ev->mh->type),
mq);
- mq->send_impl (mq,
- ev->mh,
- mq->impl_state);
+ mq->send_impl (mq, ev->mh, mq->impl_state);
}
@@ -419,9 +396,7 @@ GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq)
struct GNUNET_MQ_Envelope *env;
env = mq->envelope_head;
- GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
- mq->envelope_tail,
- env);
+ GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, env);
mq->queue_length--;
env->parent_queue = NULL;
return env;
@@ -461,16 +436,12 @@ GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq,
uint16_t msize;
msize = ntohs (ev->mh->size);
- env = GNUNET_malloc (sizeof (struct GNUNET_MQ_Envelope) +
- msize);
+ env = GNUNET_malloc (sizeof (struct GNUNET_MQ_Envelope) + msize);
env->mh = (struct GNUNET_MessageHeader *) &env[1];
env->sent_cb = ev->sent_cb;
env->sent_cls = ev->sent_cls;
- GNUNET_memcpy (&env[1],
- ev->mh,
- msize);
- GNUNET_MQ_send (mq,
- env);
+ GNUNET_memcpy (&env[1], ev->mh, msize);
+ GNUNET_MQ_send (mq, env);
}
@@ -493,16 +464,14 @@ impl_send_continue (void *cls)
return;
mq->current_envelope = mq->envelope_head;
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
- mq->envelope_tail,
- mq->current_envelope);
+ mq->envelope_tail,
+ mq->current_envelope);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"sending message of type %u from queue\n",
- ntohs(mq->current_envelope->mh->type));
+ ntohs (mq->current_envelope->mh->type));
- mq->send_impl (mq,
- mq->current_envelope->mh,
- mq->impl_state);
+ mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
}
@@ -526,8 +495,7 @@ GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)
current_envelope->parent_queue = NULL;
mq->current_envelope = NULL;
GNUNET_assert (NULL == mq->send_task);
- mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue,
- mq);
+ mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue, mq);
if (NULL != (cb = current_envelope->sent_cb))
{
current_envelope->sent_cb = NULL;
@@ -612,12 +580,11 @@ GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send,
* @param handlers_cls new closure to use
*/
void
-GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq,
- void *handlers_cls)
+GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, void
*handlers_cls)
{
if (NULL == mq->handlers)
return;
- for (unsigned int i=0;NULL != mq->handlers[i].cb; i++)
+ for (unsigned int i = 0; NULL != mq->handlers[i].cb; i++)
mq->handlers[i].cls = handlers_cls;
}
@@ -662,9 +629,7 @@ GNUNET_MQ_impl_state (struct GNUNET_MQ_Handle *mq)
struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp,
- uint16_t size,
- uint16_t type)
+GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t
type)
{
struct GNUNET_MQ_Envelope *ev;
@@ -692,9 +657,7 @@ GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr)
mqm = GNUNET_malloc (sizeof (*mqm) + size);
mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
- GNUNET_memcpy (mqm->mh,
- hdr,
- size);
+ GNUNET_memcpy (mqm->mh, hdr, size);
return mqm;
}
@@ -728,8 +691,8 @@ GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp,
mqm = GNUNET_MQ_msg_ (mhp, size, type);
GNUNET_memcpy ((char *) mqm->mh + base_size,
- nested_mh,
- ntohs (nested_mh->size));
+ nested_mh,
+ ntohs (nested_mh->size));
return mqm;
}
@@ -742,8 +705,7 @@ GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp,
* @param assoc_data to associate
*/
uint32_t
-GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq,
- void *assoc_data)
+GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data)
{
uint32_t id;
@@ -754,10 +716,11 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq,
}
id = mq->assoc_id++;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap32_put (mq->assoc_map,
- id,
- assoc_data,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multihashmap32_put (
+ mq->assoc_map,
+ id,
+ assoc_data,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
return id;
}
@@ -770,13 +733,11 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq,
* @return the associated data
*/
void *
-GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq,
- uint32_t request_id)
+GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
{
if (NULL == mq->assoc_map)
return NULL;
- return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map,
- request_id);
+ return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
}
@@ -788,17 +749,14 @@ GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq,
* @return the associated data
*/
void *
-GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq,
- uint32_t request_id)
+GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
{
void *val;
if (NULL == mq->assoc_map)
return NULL;
- val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map,
- request_id);
- GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map,
- request_id);
+ val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
+ GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map, request_id);
return val;
}
@@ -818,8 +776,7 @@ GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *ev,
void *cb_cls)
{
/* allow setting *OR* clearing callback */
- GNUNET_assert ( (NULL == ev->sent_cb) ||
- (NULL == cb) );
+ GNUNET_assert ((NULL == ev->sent_cb) || (NULL == cb));
ev->sent_cb = cb;
ev->sent_cls = cb_cls;
}
@@ -883,9 +840,7 @@ GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)
ev = mq->envelope_head;
ev->parent_queue = NULL;
- GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
- mq->envelope_tail,
- ev);
+ GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
GNUNET_assert (0 < mq->queue_length);
mq->queue_length--;
LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -974,8 +929,7 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)
GNUNET_assert (GNUNET_NO == mq->in_flight);
GNUNET_assert (0 < mq->queue_length);
mq->queue_length--;
- mq->cancel_impl (mq,
- mq->impl_state);
+ mq->cancel_impl (mq, mq->impl_state);
/* continue sending the next message, if any */
mq->current_envelope = mq->envelope_head;
if (NULL != mq->current_envelope)
@@ -986,19 +940,15 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)
LOG (GNUNET_ERROR_TYPE_DEBUG,
"sending canceled message of type %u queue\n",
- ntohs(ev->mh->type));
+ ntohs (ev->mh->type));
- mq->send_impl (mq,
- mq->current_envelope->mh,
- mq->impl_state);
+ mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
}
}
else
{
/* simple case, message is still waiting in the queue */
- GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
- mq->envelope_tail,
- ev);
+ GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
GNUNET_assert (0 < mq->queue_length);
mq->queue_length--;
}
@@ -1044,21 +994,18 @@ GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq)
/**
- * Set application-specific options for this envelope.
+ * Set application-specific preferences for this envelope.
* Overrides the options set for the queue with
* #GNUNET_MQ_set_options() for this message only.
*
* @param env message to set options for
- * @param flags flags to use (meaning is queue-specific)
- * @param extra additional buffer for further data (also queue-specific)
+ * @param pp priorities and preferences to apply
*/
void
GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env,
- uint64_t flags,
- const void *extra)
+ enum GNUNET_MQ_PriorityPreferences pp)
{
- env->flags = flags;
- env->extra = extra;
+ env->priority = pp;
env->have_custom_options = GNUNET_YES;
}
@@ -1067,44 +1014,57 @@ GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope
*env,
* Get application-specific options for this envelope.
*
* @param env message to set options for
- * @param[out] flags set to flags to use (meaning is queue-specific)
- * @return extra additional buffer for further data (also queue-specific)
+ * @return priorities and preferences to apply for @a env
*/
-const void *
-GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env,
- uint64_t *flags)
+enum GNUNET_MQ_PriorityPreferences
+GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env)
{
struct GNUNET_MQ_Handle *mq = env->parent_queue;
if (GNUNET_YES == env->have_custom_options)
- {
- *flags = env->flags;
- return env->extra;
- }
+ return env->priority;
if (NULL == mq)
- {
- *flags = 0;
- return NULL;
- }
- *flags = mq->default_flags;
- return mq->default_extra;
+ return 0;
+ return mq->priority;
+}
+
+
+/**
+ * Combine performance preferences set for different
+ * envelopes that are being combined into one larger envelope.
+ *
+ * @param p1 one set of preferences
+ * @param p2 second set of preferences
+ * @return combined priority and preferences to use
+ */
+enum GNUNET_MQ_PriorityPreferences
+GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1,
+ enum GNUNET_MQ_PriorityPreferences p2)
+{
+ enum GNUNET_MQ_PriorityPreferences ret;
+
+ ret = GNUNET_MAX (p1 & GNUNET_MQ_PRIORITY_MASK, p2 &
GNUNET_MQ_PRIORITY_MASK);
+ ret |= ((p1 & GNUNET_MQ_PREF_UNRELIABLE) & (p2 & GNUNET_MQ_PREF_UNRELIABLE));
+ ret |=
+ ((p1 & GNUNET_MQ_PREF_LOW_LATENCY) | (p2 & GNUNET_MQ_PREF_LOW_LATENCY));
+ ret |=
+ ((p1 & GNUNET_MQ_PREF_CORK_ALLOWED) & (p2 & GNUNET_MQ_PREF_CORK_ALLOWED));
+ ret |= ((p1 & GNUNET_MQ_PREF_GOODPUT) & (p2 & GNUNET_MQ_PREF_GOODPUT));
+ return ret;
}
/**
- * Set application-specific options for this queue.
+ * Set application-specific default options for this queue.
*
* @param mq message queue to set options for
- * @param flags flags to use (meaning is queue-specific)
- * @param extra additional buffer for further data (also queue-specific)
+ * @param pp priorities and preferences to apply
*/
void
GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq,
- uint64_t flags,
- const void *extra)
+ enum GNUNET_MQ_PriorityPreferences pp)
{
- mq->default_flags = flags;
- mq->default_extra = extra;
+ mq->priority = pp;
}
@@ -1145,8 +1105,8 @@ GNUNET_MQ_env_next (const struct GNUNET_MQ_Envelope *env)
*/
struct GNUNET_MQ_DestroyNotificationHandle *
GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
- GNUNET_SCHEDULER_TaskCallback cb,
- void *cb_cls)
+ GNUNET_SCHEDULER_TaskCallback cb,
+ void *cb_cls)
{
struct GNUNET_MQ_DestroyNotificationHandle *dnh;
@@ -1154,9 +1114,7 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
dnh->mq = mq;
dnh->cb = cb;
dnh->cb_cls = cb_cls;
- GNUNET_CONTAINER_DLL_insert (mq->dnh_head,
- mq->dnh_tail,
- dnh);
+ GNUNET_CONTAINER_DLL_insert (mq->dnh_head, mq->dnh_tail, dnh);
return dnh;
}
@@ -1167,13 +1125,12 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
* @param dnh handle for registration to cancel
*/
void
-GNUNET_MQ_destroy_notify_cancel (struct GNUNET_MQ_DestroyNotificationHandle
*dnh)
+GNUNET_MQ_destroy_notify_cancel (
+ struct GNUNET_MQ_DestroyNotificationHandle *dnh)
{
struct GNUNET_MQ_Handle *mq = dnh->mq;
- GNUNET_CONTAINER_DLL_remove (mq->dnh_head,
- mq->dnh_tail,
- dnh);
+ GNUNET_CONTAINER_DLL_remove (mq->dnh_head, mq->dnh_tail, dnh);
GNUNET_free (dnh);
}
@@ -1195,9 +1152,7 @@ GNUNET_MQ_dll_insert_tail (struct GNUNET_MQ_Envelope
**env_head,
struct GNUNET_MQ_Envelope **env_tail,
struct GNUNET_MQ_Envelope *env)
{
- GNUNET_CONTAINER_DLL_insert_tail (*env_head,
- *env_tail,
- env);
+ GNUNET_CONTAINER_DLL_insert_tail (*env_head, *env_tail, env);
}
@@ -1218,9 +1173,7 @@ GNUNET_MQ_dll_remove (struct GNUNET_MQ_Envelope
**env_head,
struct GNUNET_MQ_Envelope **env_tail,
struct GNUNET_MQ_Envelope *env)
{
- GNUNET_CONTAINER_DLL_remove (*env_head,
- *env_tail,
- env);
+ GNUNET_CONTAINER_DLL_remove (*env_head, *env_tail, env);
}
@@ -1244,8 +1197,7 @@ GNUNET_MQ_copy_handlers (const struct
GNUNET_MQ_MessageHandler *handlers)
return NULL;
count = GNUNET_MQ_count_handlers (handlers);
- copy = GNUNET_new_array (count + 1,
- struct GNUNET_MQ_MessageHandler);
+ copy = GNUNET_new_array (count + 1, struct GNUNET_MQ_MessageHandler);
GNUNET_memcpy (copy,
handlers,
count * sizeof (struct GNUNET_MQ_MessageHandler));
@@ -1276,8 +1228,7 @@ GNUNET_MQ_copy_handlers2 (const struct
GNUNET_MQ_MessageHandler *handlers,
if (NULL == handlers)
return NULL;
count = GNUNET_MQ_count_handlers (handlers);
- copy = GNUNET_new_array (count + 2,
- struct GNUNET_MQ_MessageHandler);
+ copy = GNUNET_new_array (count + 2, struct GNUNET_MQ_MessageHandler);
GNUNET_memcpy (copy,
handlers,
count * sizeof (struct GNUNET_MQ_MessageHandler));
@@ -1304,7 +1255,8 @@ GNUNET_MQ_count_handlers (const struct
GNUNET_MQ_MessageHandler *handlers)
if (NULL == handlers)
return 0;
- for (i=0; NULL != handlers[i].cb; i++) ;
+ for (i = 0; NULL != handlers[i].cb; i++)
+ ;
return i;
}
@@ -1319,7 +1271,8 @@ GNUNET_MQ_count_handlers (const struct
GNUNET_MQ_MessageHandler *handlers)
const char *
GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type)
{
- switch (type) {
+ switch (type)
+ {
case GNUNET_MQ_PREFERENCE_NONE:
return "NONE";
case GNUNET_MQ_PREFERENCE_BANDWIDTH:
--
To stop receiving notification emails like this one, please contact
address@hidden
- [GNUnet-SVN] [gnunet] branch master updated (3d2a951fa -> c3cba3c67),
gnunet <=