#include "cadet.h"
#include "cadet_protocol.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "cadet-api",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "cadet-api", __VA_ARGS__)
/**
* Opaque handle to the service.
* Time to the next reconnect in case one reconnect fails
*/
struct GNUNET_TIME_Relative reconnect_time;
-
};
* How many messages are we allowed to send to the service right now?
*/
unsigned int allow_send;
-
};
*/
static struct GNUNET_CADET_Port *
find_port (const struct GNUNET_CADET_Handle *h,
- const struct GNUNET_HashCode *hash)
+ const struct GNUNET_HashCode *hash)
{
- return GNUNET_CONTAINER_multihashmap_get (h->ports,
- hash);
+ return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
}
ch->cadet = h;
if (NULL == ccnp)
{
- while (NULL !=
- find_channel (h,
- h->next_ccn))
- h->next_ccn.channel_of_client
- = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI | (1 + ntohl (h->next_ccn.channel_of_client)));
+ while (NULL != find_channel (h, h->next_ccn))
+ h->next_ccn.channel_of_client =
+ htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI |
+ (1 + ntohl (h->next_ccn.channel_of_client)));
ccn = h->next_ccn;
}
else
}
ch->ccn = ccn;
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multihashmap32_put (h->channels,
- ntohl (ch->ccn.channel_of_client),
- ch,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multihashmap32_put (
+ h->channels,
+ ntohl (ch->ccn.channel_of_client),
+ ch,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
return ch;
}
"Destroying channel %X of %p\n",
htonl (ch->ccn.channel_of_client),
h);
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap32_remove (h->channels,
- ntohl (ch->ccn.channel_of_client),
- ch));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap32_remove (h->channels,
+ ntohl (ch->ccn.channel_of_client),
+ ch));
if (NULL != ch->mq_cont)
{
GNUNET_SCHEDULER_cancel (ch->mq_cont);
}
/* signal channel destruction */
if (NULL != ch->disconnects)
- ch->disconnects (ch->ctx,
- ch);
+ ch->disconnects (ch->ctx, ch);
if (NULL != ch->pending_env)
GNUNET_MQ_discard (ch->pending_env);
GNUNET_MQ_destroy (ch->mq);
* @return #GNUNET_OK (continue to iterate)
*/
static int
-open_port_cb (void *cls,
- const struct GNUNET_HashCode *id,
- void *value)
+open_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
{
struct GNUNET_CADET_Handle *h = cls;
struct GNUNET_CADET_Port *port = value;
struct GNUNET_MQ_Envelope *env;
(void) id;
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN);
msg->port = port->id;
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
return GNUNET_OK;
}
struct GNUNET_CADET_Handle *h = cls;
h->reconnect_task = NULL;
- h->reconnect_time
- = GNUNET_TIME_STD_BACKOFF (h->reconnect_time);
+ h->reconnect_time = GNUNET_TIME_STD_BACKOFF (h->reconnect_time);
reconnect (h);
- GNUNET_CONTAINER_multihashmap_iterate (h->ports,
- &open_port_cb,
- h);
+ GNUNET_CONTAINER_multihashmap_iterate (h->ports, &open_port_cb, h);
}
"Sending message on channel %s to CADET, new window size is %u\n",
GNUNET_i2s (&ch->peer),
ch->allow_send);
- GNUNET_MQ_send (ch->cadet->mq,
- env);
+ GNUNET_MQ_send (ch->cadet->mq, env);
GNUNET_MQ_impl_send_continue (ch->mq);
}
struct GNUNET_CADET_Channel *ch = impl_state;
struct GNUNET_CADET_Handle *h = ch->cadet;
uint16_t msize;
+ struct GNUNET_MQ_Envelope *orig_env;
struct GNUNET_MQ_Envelope *env;
- struct GNUNET_CADET_LocalData *cadet_msg = NULL;
+ struct GNUNET_CADET_LocalData *cadet_msg;
+ enum GNUNET_MQ_PriorityPreferences pp;
if (NULL == h->mq)
{
GNUNET_MQ_impl_send_continue (mq);
return;
}
+ orig_env = GNUNET_MQ_get_current_envelope (mq);
+ pp = GNUNET_MQ_env_get_options (orig_env);
/* check message size for sanity */
msize = ntohs (msg->size);
GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
msg);
cadet_msg->ccn = ch->ccn;
+ cadet_msg->pp = htonl ((uint32_t) pp);
GNUNET_assert (NULL == ch->pending_env);
ch->pending_env = env;
if (0 < ch->allow_send)
- ch->mq_cont
- = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now,
- ch);
+ ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch);
}
* @param impl_state state of the implementation
*/
static void
-cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
+cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct GNUNET_CADET_Channel *ch = impl_state;
* @param error error code
*/
static void
-cadet_mq_error_handler (void *cls,
- enum GNUNET_MQ_Error error)
+cadet_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
struct GNUNET_CADET_Channel *ch = cls;
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "MQ error in communication with CADET: %d\n",
- error);
+ "MQ error in communication with CADET: %d\n",
+ error);
if (NULL != ch->disconnects)
- ch->disconnects (ch->ctx,
- ch);
+ ch->disconnects (ch->ctx, ch);
GNUNET_CADET_channel_destroy (ch);
}
}
* @param impl_state state specific to the implementation
*/
static void
-cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
+cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct GNUNET_CADET_Channel *ch = impl_state;
* @param msg A message with the details of the new incoming channel
*/
static void
-handle_channel_created (void *cls,
- const struct GNUNET_CADET_LocalChannelCreateMessage *msg)
+handle_channel_created (
+ void *cls,
+ const struct GNUNET_CADET_LocalChannelCreateMessage *msg)
{
struct GNUNET_CADET_Handle *h = cls;
struct GNUNET_CADET_Channel *ch;
GNUNET_break (0);
return;
}
- port = find_port (h,
- port_number);
+ port = find_port (h, port_number);
if (NULL == port)
{
/* We could have closed the port but the service didn't know about it yet
"No handler for incoming channel %X (on port %s, recently closed?)\n",
ntohl (ccn.channel_of_client),
GNUNET_h2s (port_number));
- env = GNUNET_MQ_msg (d_msg,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
+ env =
+ GNUNET_MQ_msg (d_msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
d_msg->ccn = msg->ccn;
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
return;
}
- ch = create_channel (h,
- &ccn);
+ ch = create_channel (h, &ccn);
ch->peer = msg->peer;
ch->incoming_port = port;
ch->options = ntohl (msg->opt);
port->handlers,
&cadet_mq_error_handler,
ch);
- ch->ctx = port->connects (port->cls,
- ch,
- &msg->peer);
- GNUNET_MQ_set_handlers_closure (ch->mq,
- ch->ctx);
+ ch->ctx = port->connects (port->cls, ch, &msg->peer);
+ GNUNET_MQ_set_handlers_closure (ch->mq, ch->ctx);
}
* @param msg A message with the details of the channel being destroyed
*/
static void
-handle_channel_destroy (void *cls,
- const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
+handle_channel_destroy (
+ void *cls,
+ const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
{
struct GNUNET_CADET_Handle *h = cls;
struct GNUNET_CADET_Channel *ch;
- ch = find_channel (h,
- msg->ccn);
+ ch = find_channel (h, msg->ccn);
if (NULL == ch)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
* #GNUNET_SYSERR otherwise
*/
static int
-check_local_data (void *cls,
- const struct GNUNET_CADET_LocalData *message)
+check_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
{
uint16_t size;
* @param message A message encapsulating the data
*/
static void
-handle_local_data (void *cls,
- const struct GNUNET_CADET_LocalData *message)
+handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
{
struct GNUNET_CADET_Handle *h = cls;
const struct GNUNET_MessageHeader *payload;
uint16_t type;
int fwd;
- ch = find_channel (h,
- message->ccn);
+ ch = find_channel (h, message->ccn);
if (NULL == ch)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_i2s (&ch->peer),
ntohl (message->ccn.channel_of_client),
type);
- GNUNET_MQ_inject_message (ch->mq,
- payload);
+ GNUNET_MQ_inject_message (ch->mq, payload);
}
* @param message Message itself.
*/
static void
-handle_local_ack (void *cls,
- const struct GNUNET_CADET_LocalAck *message)
+handle_local_ack (void *cls, const struct GNUNET_CADET_LocalAck *message)
{
struct GNUNET_CADET_Handle *h = cls;
struct GNUNET_CADET_Channel *ch;
- ch = find_channel (h,
- message->ccn);
+ ch = find_channel (h, message->ccn);
if (NULL == ch)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
}
if (NULL != ch->mq_cont)
return; /* already working on it! */
- ch->mq_cont
- = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now,
- ch);
+ ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch);
}
* @return #GNUNET_OK (continue to iterate)
*/
static int
-destroy_channel_cb (void *cls,
- uint32_t cid,
- void *value)
+destroy_channel_cb (void *cls, uint32_t cid, void *value)
{
/* struct GNUNET_CADET_Handle *handle = cls; */
struct GNUNET_CADET_Channel *ch = value;
(void) cls;
(void) cid;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Destroying channel due to GNUNET_CADET_disconnect()\n");
+ "Destroying channel due to GNUNET_CADET_disconnect()\n");
destroy_channel (ch);
return GNUNET_OK;
}
* @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_CADET_Handle *h = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "MQ ERROR: %u\n",
- error);
- GNUNET_CONTAINER_multihashmap32_iterate (h->channels,
- &destroy_channel_cb,
- h);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
+ GNUNET_CONTAINER_multihashmap32_iterate (h->channels, &destroy_channel_cb, h);
GNUNET_MQ_destroy (h->mq);
h->mq = NULL;
GNUNET_assert (NULL == h->reconnect_task);
- h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->reconnect_time,
- &reconnect_cbk,
- h);
+ h->reconnect_task =
+ GNUNET_SCHEDULER_add_delayed (h->reconnect_time, &reconnect_cbk, h);
}
static void
reconnect (struct GNUNET_CADET_Handle *h)
{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_fixed_size (channel_created,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
- struct GNUNET_CADET_LocalChannelCreateMessage,
- h),
- GNUNET_MQ_hd_fixed_size (channel_destroy,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
- struct GNUNET_CADET_LocalChannelDestroyMessage,
- h),
- GNUNET_MQ_hd_var_size (local_data,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
- struct GNUNET_CADET_LocalData,
- h),
- GNUNET_MQ_hd_fixed_size (local_ack,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
- struct GNUNET_CADET_LocalAck,
- h),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_fixed_size (channel_created,
+ GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
+ struct GNUNET_CADET_LocalChannelCreateMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (channel_destroy,
+ GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
+ struct GNUNET_CADET_LocalChannelDestroyMessage,
+ h),
+ GNUNET_MQ_hd_var_size (local_data,
+ GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
+ struct GNUNET_CADET_LocalData,
+ h),
+ GNUNET_MQ_hd_fixed_size (local_ack,
+ GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
+ struct GNUNET_CADET_LocalAck,
+ h),
+ GNUNET_MQ_handler_end ()};
GNUNET_assert (NULL == h->mq);
- h->mq = GNUNET_CLIENT_connect (h->cfg,
- "cadet",
- handlers,
- &handle_mq_error,
- h);
+ h->mq =
+ GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
}
* @return #GNUNET_OK (continue to iterate)
*/
static int
-destroy_port_cb (void *cls,
- const struct GNUNET_HashCode *id,
- void *value)
+destroy_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
{
/* struct GNUNET_CADET_Handle *handle = cls; */
struct GNUNET_CADET_Port *port = value;
void
GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
{
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports,
- &p->id,
- p));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports, &p->id, p));
if (NULL != p->cadet->mq)
{
struct GNUNET_CADET_PortMessage *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE);
msg->port = p->id;
- GNUNET_MQ_send (p->cadet->mq,
- env);
+ GNUNET_MQ_send (p->cadet->mq, env);
}
GNUNET_free_non_null (p->handlers);
GNUNET_free (p);
if (NULL != h->mq)
{
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
msg->ccn = channel->ccn;
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
+ "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
channel->disconnects = NULL;
destroy_channel (channel);
}
switch (option)
{
- case GNUNET_CADET_OPTION_NOBUFFER:
- case GNUNET_CADET_OPTION_RELIABLE:
- case GNUNET_CADET_OPTION_OUT_OF_ORDER:
- if (0 != (option & channel->options))
- bool_flag = GNUNET_YES;
- else
- bool_flag = GNUNET_NO;
- return (const union GNUNET_CADET_ChannelInfo *) &bool_flag;
- break;
- case GNUNET_CADET_OPTION_PEER:
- return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
- break;
- default:
- GNUNET_break (0);
- return NULL;
+ case GNUNET_CADET_OPTION_NOBUFFER:
+ case GNUNET_CADET_OPTION_RELIABLE:
+ case GNUNET_CADET_OPTION_OUT_OF_ORDER:
+ if (0 != (option & channel->options))
+ bool_flag = GNUNET_YES;
+ else
+ bool_flag = GNUNET_NO;
+ return (const union GNUNET_CADET_ChannelInfo *) &bool_flag;
+ break;
+ case GNUNET_CADET_OPTION_PEER:
+ return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
+ break;
+ default:
+ GNUNET_break (0);
+ return NULL;
}
}
struct GNUNET_CADET_LocalAck *msg;
struct GNUNET_MQ_Envelope *env;
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Sending ACK on channel %X\n",
ntohl (channel->ccn.channel_of_client));
msg->ccn = channel->ccn;
- GNUNET_MQ_send (channel->cadet->mq,
- env);
+ GNUNET_MQ_send (channel->cadet->mq, env);
}
{
struct GNUNET_CADET_Handle *h;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "GNUNET_CADET_connect()\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
h = GNUNET_new (struct GNUNET_CADET_Handle);
h->cfg = cfg;
- h->ports = GNUNET_CONTAINER_multihashmap_create (4,
- GNUNET_YES);
+ h->ports = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_YES);
h->channels = GNUNET_CONTAINER_multihashmap32_create (4);
reconnect (h);
if (NULL == h->mq)
GNUNET_CADET_open_port (struct GNUNET_CADET_Handle *h,
const struct GNUNET_HashCode *port,
GNUNET_CADET_ConnectEventHandler connects,
- void * connects_cls,
+ void *connects_cls,
GNUNET_CADET_WindowSizeEventHandler window_changes,
GNUNET_CADET_DisconnectEventHandler disconnects,
const struct GNUNET_MQ_MessageHandler *handlers)
GNUNET_assert (NULL != connects);
GNUNET_assert (NULL != disconnects);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Listening to CADET port %s\n",
- GNUNET_h2s (port));
+ "Listening to CADET port %s\n",
+ GNUNET_h2s (port));
p = GNUNET_new (struct GNUNET_CADET_Port);
p->cadet = h;
p->id = *port;
- if (GNUNET_OK !=
- GNUNET_CONTAINER_multihashmap_put (h->ports,
- &p->id,
- p,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+ if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
+ h->ports,
+ &p->id,
+ p,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_free (p);
return NULL;
p->window_changes = window_changes;
p->disconnects = disconnects;
p->handlers = GNUNET_MQ_copy_handlers (handlers);
-
- GNUNET_assert (GNUNET_OK ==
- open_port_cb (h,
- &p->id,
- p));
+
+ GNUNET_assert (GNUNET_OK == open_port_cb (h, &p->id, p));
return p;
}
GNUNET_assert (NULL != disconnects);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Creating channel to peer %s at port %s\n",
- GNUNET_i2s (destination),
- GNUNET_h2s (port));
- ch = create_channel (h,
- NULL);
+ "Creating channel to peer %s at port %s\n",
+ GNUNET_i2s (destination),
+ GNUNET_h2s (port));
+ ch = create_channel (h, NULL);
ch->ctx = channel_cls;
ch->peer = *destination;
ch->options = options;
handlers,
&cadet_mq_error_handler,
ch);
- GNUNET_MQ_set_handlers_closure (ch->mq,
- channel_cls);
+ GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls);
/* Request channel creation to service */
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
msg->ccn = ch->ccn;
msg->port = *port;
msg->peer = *destination;
msg->opt = htonl (options);
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
return ch;
}
projects / oweals / gnunet.git / commitdiff