/*
This file is part of GNUnet.
- (C) 2012-2014 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2012-2014 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
GNUNET_MQ_NotifyCallback sent_cb;
/**
- * Closure for send_cb
+ * Closure for @e send_cb
*/
void *sent_cls;
};
/**
* Task scheduled during #GNUNET_MQ_impl_send_continue.
*/
- GNUNET_SCHEDULER_TaskIdentifier continue_task;
+ struct GNUNET_SCHEDULER_Task * continue_task;
/**
- * Next id that should be used for the assoc_map,
+ * Next id that should be used for the @e assoc_map,
* initialized lazily to a random value together with
- * assoc_map
+ * @e assoc_map
*/
uint32_t assoc_id;
};
const struct GNUNET_MQ_MessageHandler *handler;
int handled = GNUNET_NO;
- handler = mq->handlers;
- if (NULL == handler)
+ if (NULL == mq->handlers)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"No handler for message of type %d\n",
ntohs (mh->type));
return;
}
- for (; NULL != handler->cb; handler++)
+ for (handler = mq->handlers; NULL != handler->cb; handler++)
{
if (handler->type == ntohs (mh->type))
{
handler->cb (mq->handlers_cls, mh);
handled = GNUNET_YES;
+ break;
}
}
-
if (GNUNET_NO == handled)
LOG (GNUNET_ERROR_TYPE_WARNING,
"No handler for message of type %d\n",
* results in undefined behavior if not used carefully.
*
* @param cls message queue to send the next message with
- * @param tc scheduler context
*/
static void
-impl_send_continue (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+impl_send_continue (void *cls)
{
struct GNUNET_MQ_Handle *mq = cls;
struct GNUNET_MQ_Envelope *current_envelope;
- if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
- return;
-
- mq->continue_task = GNUNET_SCHEDULER_NO_TASK;
+ mq->continue_task = NULL;
/* call is only valid if we're actually currently sending
* a message */
current_envelope = mq->current_envelope;
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
mq->envelope_tail,
mq->current_envelope);
- mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
+ mq->send_impl (mq,
+ mq->current_envelope->mh,
+ mq->impl_state);
}
if (NULL != current_envelope->sent_cb)
current_envelope->sent_cb (current_envelope->sent_cls);
/**
- * Call the send implementation for the next queued message,
- * if any.
- * Only useful for implementing message queues,
- * results in undefined behavior if not used carefully.
+ * Call the send implementation for the next queued message, if any.
+ * Only useful for implementing message queues, results in undefined
+ * behavior if not used carefully.
*
* @param mq message queue to send the next message with
*/
void
GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)
{
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == mq->continue_task);
+ GNUNET_assert (NULL == mq->continue_task);
mq->continue_task = GNUNET_SCHEDULER_add_now (&impl_send_continue,
mq);
}
GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq)
{
if (NULL == mq->current_envelope)
- GNUNET_abort ();
+ GNUNET_assert (0);
if (NULL == mq->current_envelope->mh)
- GNUNET_abort ();
+ GNUNET_assert (0);
return mq->current_envelope->mh;
}
return NULL;
mqm = GNUNET_MQ_msg_ (mhp, size, type);
- memcpy ((char *) mqm->mh + base_size, nested_mh, ntohs (nested_mh->size));
+ memcpy ((char *) mqm->mh + base_size,
+ nested_mh,
+ ntohs (nested_mh->size));
return mqm;
}
* Transmit a queued message to the session's client.
*
* @param cls consensus session
- * @param size number of bytes available in buf
+ * @param size number of bytes available in @a buf
* @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
transmit_queued (void *cls, size_t size,
GNUNET_assert (NULL != mq);
GNUNET_assert (NULL != state);
- state->th =
- GNUNET_SERVER_notify_transmit_ready (state->client, ntohs (msg->size),
- GNUNET_TIME_UNIT_FOREVER_REL,
- &transmit_queued, mq);
+ state->th = GNUNET_SERVER_notify_transmit_ready (state->client,
+ ntohs (msg->size),
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &transmit_queued, mq);
}
GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_READ);
return;
}
-
- GNUNET_CLIENT_receive (state->connection, handle_client_message, mq,
+ GNUNET_CLIENT_receive (state->connection,
+ &handle_client_message,
+ mq,
GNUNET_TIME_UNIT_FOREVER_REL);
-
GNUNET_MQ_inject_message (mq, msg);
}
GNUNET_assert (NULL != state);
GNUNET_assert (NULL == state->th);
state->th =
- GNUNET_CLIENT_notify_transmit_ready (state->connection, ntohs (msg->size),
+ GNUNET_CLIENT_notify_transmit_ready (state->connection,
+ ntohs (msg->size),
GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_NO,
&connection_client_transmit_queued, mq);
GNUNET_assert (NULL != state->th);
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;
}
{
mq->destroy_impl (mq, mq->impl_state);
}
- if (GNUNET_SCHEDULER_NO_TASK != mq->continue_task)
+ if (NULL != mq->continue_task)
{
GNUNET_SCHEDULER_cancel (mq->continue_task);
- mq->continue_task = GNUNET_SCHEDULER_NO_TASK;
+ mq->continue_task = NULL;
}
while (NULL != mq->envelope_head)
{
struct GNUNET_MQ_Envelope *ev;
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_MQ_discard (ev);
}
-
if (NULL != mq->current_envelope)
{
/* we can only discard envelopes that
GNUNET_MQ_discard (mq->current_envelope);
mq->current_envelope = NULL;
}
-
if (NULL != mq->assoc_map)
{
GNUNET_CONTAINER_multihashmap32_destroy (mq->assoc_map);
GNUNET_assert (NULL != mq);
GNUNET_assert (NULL != mq->cancel_impl);
- if (mq->current_envelope == ev) {
+ if (mq->current_envelope == ev)
+ {
// complex case, we already started with transmitting
// the message
- mq->cancel_impl (mq, mq->impl_state);
+ mq->cancel_impl (mq,
+ mq->impl_state);
// continue sending the next message, if any
if (NULL == mq->envelope_head)
{
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
mq->envelope_tail,
mq->current_envelope);
- mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
+ mq->send_impl (mq,
+ mq->current_envelope->mh,
+ mq->impl_state);
}
- } else {
+ }
+ 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);
}
ev->parent_queue = NULL;
projects / oweals / gnunet.git / blobdiff