/*
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;
+
+ /**
+ * Flags that were set for this envelope by
+ * #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;
+
+ /**
+ * Did the application call #GNUNET_MQ_env_set_options()?
+ */
+ int have_custom_options;
+
};
/**
* Handlers array, or NULL if the queue should not receive messages
*/
- const struct GNUNET_MQ_MessageHandler *handlers;
-
- /**
- * Closure for the handler callbacks,
- * as well as for the error handler.
- */
- void *handlers_cls;
+ struct GNUNET_MQ_MessageHandler *handlers;
/**
* Actual implementation of message sending,
*/
GNUNET_MQ_ErrorHandler error_handler;
+ /**
+ * Closure for the error handler.
+ */
+ void *error_handler_cls;
+
/**
* Linked list of messages pending to be sent
*/
/**
* Task scheduled during #GNUNET_MQ_impl_send_continue.
*/
- GNUNET_SCHEDULER_TaskIdentifier continue_task;
+ struct GNUNET_SCHEDULER_Task *continue_task;
+
+ /**
+ * 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;
/**
- * 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;
+
+ /**
+ * Number of entries we have in the envelope-DLL.
+ */
+ unsigned int queue_length;
};
/**
* Active transmission request to the client.
*/
- struct GNUNET_SERVER_TransmitHandle* th;
+ struct GNUNET_SERVER_TransmitHandle *th;
};
{
const struct GNUNET_MQ_MessageHandler *handler;
int handled = GNUNET_NO;
+ uint16_t ms = ntohs (mh->size);
- handler = mq->handlers;
- if (NULL == handler)
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "No handler for message of type %d\n",
- ntohs (mh->type));
- return;
- }
- for (; NULL != handler->cb; handler++)
+ if (NULL == mq->handlers)
+ goto done;
+ for (handler = mq->handlers; NULL != handler->cb; handler++)
{
if (handler->type == ntohs (mh->type))
{
- handler->cb (mq->handlers_cls, mh);
handled = GNUNET_YES;
+ if ( (handler->expected_size > ms) ||
+ ( (handler->expected_size != ms) &&
+ (NULL == handler->mv) ) )
+ {
+ /* Too small, or not an exact size and
+ no 'mv' handler to check rest */
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Received malformed message of type %u\n",
+ (unsigned int) handler->type);
+ GNUNET_MQ_inject_error (mq,
+ GNUNET_MQ_ERROR_MALFORMED);
+ break;
+ }
+ if ( (NULL == handler->mv) ||
+ (GNUNET_OK ==
+ handler->mv (handler->cls, mh)) )
+ {
+ /* message well-formed, pass to handler */
+ handler->cb (handler->cls, mh);
+ }
+ else
+ {
+ /* Message rejected by check routine */
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Received malformed message of type %u\n",
+ (unsigned int) handler->type);
+ GNUNET_MQ_inject_error (mq,
+ GNUNET_MQ_ERROR_MALFORMED);
+ }
+ break;
}
}
-
+ done:
if (GNUNET_NO == handled)
- LOG (GNUNET_ERROR_TYPE_WARNING,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"No handler for message of type %d\n",
ntohs (mh->type));
}
{
if (NULL == mq->error_handler)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "mq: got error %d, but no handler installed\n",
- (int) error);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Got error %d, but no handler installed\n",
+ (int) error);
return;
}
- mq->error_handler (mq->handlers_cls, error);
+ mq->error_handler (mq->error_handler_cls,
+ error);
}
+/**
+ * Discard the message queue message, free all
+ * allocated resources. Must be called in the event
+ * that a message is created but should not actually be sent.
+ *
+ * @param mqm the message to discard
+ */
void
GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *mqm)
{
/**
- * Send a message with the give message queue.
+ * Obtain the current length of the message queue.
+ *
+ * @param mq queue to inspect
+ * @return number of queued, non-transmitted messages
+ */
+unsigned int
+GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq)
+{
+ return mq->queue_length;
+}
+
+
+/**
+ * Send a message with the given message queue.
* May only be called once per message.
*
* @param mq message queue
GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head,
mq->envelope_tail,
ev);
+ mq->queue_length++;
return;
}
mq->current_envelope = ev;
}
+/**
+ * Send a copy of a message with the given message queue.
+ * Can be called repeatedly on the same envelope.
+ *
+ * @param mq message queue
+ * @param ev the envelope with the message to send.
+ */
+void
+GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq,
+ const struct GNUNET_MQ_Envelope *ev)
+{
+ struct GNUNET_MQ_Envelope *env;
+ uint16_t msize;
+
+ msize = ntohs (ev->mh->size);
+ 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);
+}
+
+
+
/**
* Task run to 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 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->queue_length--;
+ 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);
}
* @param impl_state for the queue, passed to 'send' and 'destroy'
* @param handlers array of message handlers
* @param error_handler handler for read and write errors
- * @param cls closure for message handlers and error handler
+ * @param error_handler_cls closure for @a error_handler
* @return a new message queue
*/
struct GNUNET_MQ_Handle *
void *impl_state,
const struct GNUNET_MQ_MessageHandler *handlers,
GNUNET_MQ_ErrorHandler error_handler,
- void *cls)
+ void *error_handler_cls)
{
struct GNUNET_MQ_Handle *mq;
+ unsigned int i;
mq = GNUNET_new (struct GNUNET_MQ_Handle);
mq->send_impl = send;
mq->destroy_impl = destroy;
mq->cancel_impl = cancel;
- mq->handlers = handlers;
- mq->handlers_cls = cls;
+ if (NULL != handlers)
+ {
+ for (i=0;NULL != handlers[i].cb; i++) ;
+ mq->handlers = GNUNET_new_array (i + 1,
+ struct GNUNET_MQ_MessageHandler);
+ GNUNET_memcpy (mq->handlers,
+ handlers,
+ i * sizeof (struct GNUNET_MQ_MessageHandler));
+ }
+ mq->error_handler = error_handler;
+ mq->error_handler_cls = error_handler_cls;
mq->impl_state = impl_state;
return mq;
}
+/**
+ * Change the closure argument in all of the `handlers` of the
+ * @a mq.
+ *
+ * @param mq to modify
+ * @param handlers_cls new closure to use
+ */
+void
+GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq,
+ void *handlers_cls)
+{
+ unsigned int i;
+
+ if (NULL == mq->handlers)
+ return;
+ for (i=0;NULL != mq->handlers[i].cb; i++)
+ mq->handlers[i].cls = handlers_cls;
+}
+
+
/**
* Get the message that should currently be sent.
* Fails if there is no current message.
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;
}
/**
- * Implementation of the GNUNET_MQ_msg_nested_mh macro.
+ * Create a new envelope by copying an existing message.
+ *
+ * @param hdr header of the message to copy
+ * @return envelope containing @a hdr
+ */
+struct GNUNET_MQ_Envelope *
+GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr)
+{
+ struct GNUNET_MQ_Envelope *mqm;
+ uint16_t size = ntohs (hdr->size);
+
+ mqm = GNUNET_malloc (sizeof (*mqm) + size);
+ mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
+ GNUNET_memcpy (mqm->mh,
+ hdr,
+ size);
+ return mqm;
+}
+
+
+/**
+ * Implementation of the #GNUNET_MQ_msg_nested_mh macro.
*
* @param mhp pointer to the message header pointer that will be changed to allocate at
* the newly allocated space for the message.
return NULL;
mqm = GNUNET_MQ_msg_ (mhp, size, type);
- memcpy ((char *) mqm->mh + base_size, nested_mh, ntohs (nested_mh->size));
+ GNUNET_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,
+transmit_queued (void *cls,
+ size_t size,
void *buf)
{
struct GNUNET_MQ_Handle *mq = cls;
size_t msg_size;
GNUNET_assert (NULL != buf);
-
msg_size = ntohs (msg->size);
GNUNET_assert (size >= msg_size);
- memcpy (buf, msg, msg_size);
+ GNUNET_memcpy (buf, msg, msg_size);
state->th = NULL;
GNUNET_MQ_impl_send_continue (mq);
struct ServerClientSocketState *state = impl_state;
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);
}
mq->impl_state = scss;
scss->client = client;
GNUNET_SERVER_client_keep (client);
- mq->send_impl = server_client_send_impl;
- mq->destroy_impl = server_client_destroy_impl;
+ mq->send_impl = &server_client_send_impl;
+ mq->destroy_impl = &server_client_destroy_impl;
return mq;
}
struct ClientConnectionState *state;
state = mq->impl_state;
-
if (NULL == msg)
{
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);
}
size_t msg_size;
GNUNET_assert (NULL != mq);
+ state->th = NULL;
msg = GNUNET_MQ_impl_current (mq);
if (NULL == buf)
(GNUNET_NO == state->receive_active) )
{
state->receive_active = GNUNET_YES;
- GNUNET_CLIENT_receive (state->connection, handle_client_message, mq,
+ GNUNET_CLIENT_receive (state->connection,
+ &handle_client_message,
+ mq,
GNUNET_TIME_UNIT_FOREVER_REL);
}
msg_size = ntohs (msg->size);
GNUNET_assert (size >= msg_size);
- memcpy (buf, msg, msg_size);
+ GNUNET_memcpy (buf, msg, msg_size);
state->th = NULL;
GNUNET_MQ_impl_send_continue (mq);
connection_client_destroy_impl (struct GNUNET_MQ_Handle *mq,
void *impl_state)
{
+ struct ClientConnectionState *state = impl_state;
+
+ if (NULL != state->th)
+ {
+ GNUNET_CLIENT_notify_transmit_ready_cancel (state->th);
+ state->th = NULL;
+ }
+ GNUNET_CLIENT_disconnect (state->connection);
GNUNET_free (impl_state);
}
GNUNET_assert (NULL != state);
GNUNET_assert (NULL == state->th);
state->th =
- GNUNET_CLIENT_notify_transmit_ready (state->connection, ntohs (msg->size),
- GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_NO,
- &connection_client_transmit_queued, mq);
+ 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);
}
void *impl_state)
{
struct ClientConnectionState *state = impl_state;
- GNUNET_assert (NULL != state->th);
- GNUNET_CLIENT_notify_transmit_ready_cancel (state->th);
- state->th = NULL;
+
+ if (NULL != state->th)
+ {
+ GNUNET_CLIENT_notify_transmit_ready_cancel (state->th);
+ state->th = NULL;
+ }
+ else if (NULL != mq->continue_task)
+ {
+ GNUNET_SCHEDULER_cancel (mq->continue_task);
+ mq->continue_task = NULL;
+ }
+ else
+ GNUNET_assert (0);
}
GNUNET_MQ_queue_for_connection_client (struct GNUNET_CLIENT_Connection *connection,
const struct GNUNET_MQ_MessageHandler *handlers,
GNUNET_MQ_ErrorHandler error_handler,
- void *cls)
+ void *error_handler_cls)
{
struct GNUNET_MQ_Handle *mq;
struct ClientConnectionState *state;
-
- GNUNET_assert (NULL != connection);
+ unsigned int i;
mq = GNUNET_new (struct GNUNET_MQ_Handle);
- mq->handlers = handlers;
+ if (NULL != handlers)
+ {
+ for (i=0;NULL != handlers[i].cb; i++) ;
+ mq->handlers = GNUNET_new_array (i + 1,
+ struct GNUNET_MQ_MessageHandler);
+ GNUNET_memcpy (mq->handlers,
+ handlers,
+ i * sizeof (struct GNUNET_MQ_MessageHandler));
+ }
mq->error_handler = error_handler;
- mq->handlers_cls = cls;
+ mq->error_handler_cls = error_handler_cls;
state = GNUNET_new (struct ClientConnectionState);
state->connection = connection;
mq->impl_state = state;
- mq->send_impl = connection_client_send_impl;
- mq->destroy_impl = connection_client_destroy_impl;
- mq->cancel_impl = connection_client_cancel_impl;
+ mq->send_impl = &connection_client_send_impl;
+ mq->destroy_impl = &connection_client_destroy_impl;
+ mq->cancel_impl = &connection_client_cancel_impl;
if (NULL != handlers)
state->receive_requested = GNUNET_YES;
}
-void
-GNUNET_MQ_replace_handlers (struct GNUNET_MQ_Handle *mq,
- const struct GNUNET_MQ_MessageHandler *new_handlers,
- void *cls)
-{
- /* FIXME: notify implementation? */
- /* FIXME: what about NULL handlers? abort receive? */
- mq->handlers = new_handlers;
- mq->handlers_cls = cls;
-}
-
-
/**
* Associate the assoc_data in mq with a unique request id.
*
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);
+ mq->queue_length--;
GNUNET_MQ_discard (ev);
}
-
+ GNUNET_assert (0 == mq->queue_length);
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);
mq->assoc_map = NULL;
}
-
+ GNUNET_free_non_null (mq->handlers);
GNUNET_free (mq);
}
-struct GNUNET_MessageHeader *
+const struct GNUNET_MessageHeader *
GNUNET_MQ_extract_nested_mh_ (const struct GNUNET_MessageHeader *mh,
uint16_t base_size)
{
uint16_t whole_size;
uint16_t nested_size;
- struct GNUNET_MessageHeader *nested_msg;
+ const struct GNUNET_MessageHeader *nested_msg;
whole_size = ntohs (mh->size);
GNUNET_assert (whole_size >= base_size);
-
nested_size = whole_size - base_size;
-
if (0 == nested_size)
return NULL;
-
if (nested_size < sizeof (struct GNUNET_MessageHeader))
{
GNUNET_break_op (0);
return NULL;
}
-
- nested_msg = (struct GNUNET_MessageHeader *) ((char *) mh + base_size);
-
+ nested_msg = (const struct GNUNET_MessageHeader *) ((char *) mh + base_size);
if (ntohs (nested_msg->size) != nested_size)
{
GNUNET_break_op (0);
- nested_msg->size = htons (nested_size);
+ return NULL;
}
-
return nested_msg;
}
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->queue_length--;
+ 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);
+ mq->queue_length--;
}
ev->parent_queue = NULL;
GNUNET_free (ev);
}
+
+/**
+ * Function to obtain the current envelope
+ * from within #GNUNET_MQ_SendImpl implementations.
+ *
+ * @param mq message queue to interrogate
+ * @return the current envelope
+ */
+struct GNUNET_MQ_Envelope *
+GNUNET_MQ_get_current_envelope (struct GNUNET_MQ_Handle *mq)
+{
+ return mq->current_envelope;
+}
+
+
+/**
+ * Function to obtain the last envelope in the queue.
+ *
+ * @param mq message queue to interrogate
+ * @return the last envelope in the queue
+ */
+struct GNUNET_MQ_Envelope *
+GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq)
+{
+ if (NULL != mq->envelope_tail)
+ return mq->envelope_tail;
+
+ return mq->current_envelope;
+}
+
+
+/**
+ * Set application-specific options 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)
+ */
+void
+GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env,
+ uint64_t flags,
+ const void *extra)
+{
+ env->flags = flags;
+ env->extra = extra;
+ env->have_custom_options = GNUNET_YES;
+}
+
+
+/**
+ * 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)
+ */
+const void *
+GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env,
+ uint64_t *flags)
+{
+ struct GNUNET_MQ_Handle *mq = env->parent_queue;
+
+ if (GNUNET_YES == env->have_custom_options)
+ {
+ *flags = env->flags;
+ return env->extra;
+ }
+ if (NULL == mq)
+ {
+ *flags = 0;
+ return NULL;
+ }
+ *flags = mq->default_flags;
+ return mq->default_extra;
+}
+
+
+/**
+ * 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)
+ */
+void
+GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq,
+ uint64_t flags,
+ const void *extra)
+{
+ mq->default_flags = flags;
+ mq->default_extra = extra;
+}
+
+
/* end of mq.c */
projects / oweals / gnunet.git / blobdiff