struct GNUNET_MQ_Envelope *prev;
/**
- * Actual allocated message header,
- * usually points to the end of the containing GNUNET_MQ_Envelope
+ * Actual allocated message header.
+ * The GNUNET_MQ_Envelope header is allocated at
+ * the end of the message.
*/
struct GNUNET_MessageHeader *mh;
* 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;
};
*/
struct GNUNET_MQ_Envelope *current_envelope;
+ /**
+ * GNUNET_YES if the sent notification was called
+ * for the current envelope.
+ */
+ int send_notification_called;
+
/**
* Map of associations, lazily allocated
*/
struct GNUNET_CONTAINER_MultiHashMap32 *assoc_map;
/**
- * Task scheduled during #GNUNET_MQ_impl_send_continue.
+ * Task scheduled during #GNUNET_MQ_impl_send_continue
+ * or #GNUNET_MQ_impl_send_in_flight
+ */
+ struct GNUNET_SCHEDULER_Task *send_task;
+
+ /**
+ * Functions to call on queue destruction; kept in a DLL.
+ */
+ struct GNUNET_MQ_DestroyNotificationHandle *dnh_head;
+
+ /**
+ * Functions to call on queue destruction; kept in a DLL.
+ */
+ 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.
*/
- struct GNUNET_SCHEDULER_Task *continue_task;
+ uint64_t default_flags;
/**
* Next id that should be used for the @e assoc_map,
* Number of entries we have in the envelope-DLL.
*/
unsigned int queue_length;
+
+ /**
+ * GNUNET_YES if GNUNET_MQ_impl_evacuate was called.
+ */
+ int evacuate_called;
};
}
done:
if (GNUNET_NO == handled)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "No handler for message of type %d\n",
- ntohs (mh->type));
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "No handler for message of type %d and size %d\n",
+ ntohs (mh->type),
+ ntohs (mh->size));
}
* @param mqm the message to discard
*/
void
-GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *mqm)
+GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *ev)
{
- GNUNET_assert (NULL == mqm->parent_queue);
- GNUNET_free (mqm);
+ GNUNET_assert (NULL == ev->parent_queue);
+ GNUNET_free (ev);
}
GNUNET_assert (NULL != mq);
GNUNET_assert (NULL == ev->parent_queue);
+ mq->queue_length++;
ev->parent_queue = mq;
/* is the implementation busy? queue it! */
if (NULL != mq->current_envelope)
GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head,
mq->envelope_tail,
ev);
- mq->queue_length++;
return;
}
mq->current_envelope = ev;
- mq->send_impl (mq, ev->mh, mq->impl_state);
+ mq->send_impl (mq,
+ ev->mh,
+ mq->impl_state);
}
env->mh = (struct GNUNET_MessageHeader *) &env[1];
env->sent_cb = ev->sent_cb;
env->sent_cls = ev->sent_cls;
- memcpy (&env[1],
+ GNUNET_memcpy (&env[1],
ev->mh,
msize);
GNUNET_MQ_send (mq,
}
+/**
+ * Task run to call the send notification 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
+ */
+static void
+impl_send_in_flight (void *cls)
+{
+ struct GNUNET_MQ_Handle *mq = cls;
+ struct GNUNET_MQ_Envelope *current_envelope;
+
+ mq->send_task = NULL;
+ /* call is only valid if we're actually currently sending
+ * a message */
+ current_envelope = mq->current_envelope;
+ GNUNET_assert (NULL != current_envelope);
+ /* can't call cancel from now on anymore */
+ current_envelope->parent_queue = NULL;
+ if ( (GNUNET_NO == mq->send_notification_called) &&
+ (NULL != current_envelope->sent_cb) )
+ {
+ current_envelope->sent_cb (current_envelope->sent_cls);
+ }
+ mq->send_notification_called = GNUNET_YES;
+}
+
/**
* Task run to call the send implementation for the next queued
struct GNUNET_MQ_Handle *mq = cls;
struct GNUNET_MQ_Envelope *current_envelope;
- mq->continue_task = NULL;
+ mq->send_task = NULL;
/* call is only valid if we're actually currently sending
* a message */
current_envelope = mq->current_envelope;
GNUNET_assert (NULL != current_envelope);
- current_envelope->parent_queue = NULL;
+ impl_send_in_flight (mq);
+ GNUNET_assert (0 < mq->queue_length);
+ mq->queue_length--;
if (NULL == mq->envelope_head)
{
mq->current_envelope = NULL;
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
mq->envelope_tail,
mq->current_envelope);
- mq->queue_length--;
+ mq->send_notification_called = GNUNET_NO;
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);
GNUNET_free (current_envelope);
}
void
GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)
{
- GNUNET_assert (NULL == mq->continue_task);
- mq->continue_task = GNUNET_SCHEDULER_add_now (&impl_send_continue,
- mq);
+ /* maybe #GNUNET_MQ_impl_send_in_flight was called? */
+ if (NULL != mq->send_task)
+ {
+ GNUNET_SCHEDULER_cancel (mq->send_task);
+ }
+ mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue,
+ mq);
+}
+
+
+/**
+ * Call the send notification for the current message, but do not
+ * try to send the message until #gnunet_mq_impl_send_continue
+ * is called.
+ *
+ * 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_in_flight (struct GNUNET_MQ_Handle *mq)
+{
+ GNUNET_assert (NULL == mq->send_task);
+ mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_in_flight,
+ mq);
}
for (i=0;NULL != handlers[i].cb; i++) ;
mq->handlers = GNUNET_new_array (i + 1,
struct GNUNET_MQ_MessageHandler);
- memcpy (mq->handlers,
+ GNUNET_memcpy (mq->handlers,
handlers,
i * sizeof (struct GNUNET_MQ_MessageHandler));
}
uint16_t size,
uint16_t type)
{
- struct GNUNET_MQ_Envelope *mqm;
+ struct GNUNET_MQ_Envelope *ev;
- mqm = GNUNET_malloc (sizeof *mqm + size);
- mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
- mqm->mh->size = htons (size);
- mqm->mh->type = htons (type);
+ ev = GNUNET_malloc (size + sizeof (struct GNUNET_MQ_Envelope));
+ ev->mh = (struct GNUNET_MessageHeader *) &ev[1];
+ ev->mh->size = htons (size);
+ ev->mh->type = htons (type);
if (NULL != mhp)
- *mhp = mqm->mh;
- return mqm;
+ *mhp = ev->mh;
+ return ev;
}
mqm = GNUNET_malloc (sizeof (*mqm) + size);
mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
- memcpy (mqm->mh,
+ GNUNET_memcpy (mqm->mh,
hdr,
size);
return mqm;
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;
}
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);
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 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->send_task)
+ {
+ GNUNET_SCHEDULER_cancel (mq->send_task);
+ mq->send_task = NULL;
+ }
+ else
+ GNUNET_assert (0);
}
if (NULL != handlers)
{
for (i=0;NULL != handlers[i].cb; i++) ;
- mq->handlers = GNUNET_new_array (i,
+ mq->handlers = GNUNET_new_array (i + 1,
struct GNUNET_MQ_MessageHandler);
- memcpy (mq->handlers,
- handlers,
- i * sizeof (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;
}
+/**
+ * Call a callback once the envelope has been sent, that is,
+ * sending it can not be canceled anymore.
+ * There can be only one notify sent callback per envelope.
+ *
+ * @param ev message to call the notify callback for
+ * @param cb the notify callback
+ * @param cb_cls closure for the callback
+ */
void
GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *mqm,
GNUNET_MQ_NotifyCallback cb,
- void *cls)
+ void *cb_cls)
{
mqm->sent_cb = cb;
- mqm->sent_cls = cls;
+ mqm->sent_cls = cb_cls;
}
+/**
+ * Handle we return for callbacks registered to be
+ * notified when #GNUNET_MQ_destroy() is called on a queue.
+ */
+struct GNUNET_MQ_DestroyNotificationHandle
+{
+ /**
+ * Kept in a DLL.
+ */
+ struct GNUNET_MQ_DestroyNotificationHandle *prev;
+
+ /**
+ * Kept in a DLL.
+ */
+ struct GNUNET_MQ_DestroyNotificationHandle *next;
+
+ /**
+ * Queue to notify about.
+ */
+ struct GNUNET_MQ_Handle *mq;
+
+ /**
+ * Function to call.
+ */
+ GNUNET_SCHEDULER_TaskCallback cb;
+
+ /**
+ * Closure for @e cb.
+ */
+ void *cb_cls;
+};
+
+
+/**
+ * Destroy the message queue.
+ *
+ * @param mq message queue to destroy
+ */
void
GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)
{
+ struct GNUNET_MQ_DestroyNotificationHandle *dnh;
+
if (NULL != mq->destroy_impl)
{
mq->destroy_impl (mq, mq->impl_state);
}
- if (NULL != mq->continue_task)
+ if (NULL != mq->send_task)
{
- GNUNET_SCHEDULER_cancel (mq->continue_task);
- mq->continue_task = NULL;
+ GNUNET_SCHEDULER_cancel (mq->send_task);
+ mq->send_task = NULL;
}
while (NULL != mq->envelope_head)
{
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
mq->envelope_tail,
ev);
+ GNUNET_assert (0 < mq->queue_length);
mq->queue_length--;
GNUNET_MQ_discard (ev);
}
- GNUNET_assert (0 == mq->queue_length);
if (NULL != mq->current_envelope)
{
/* we can only discard envelopes that
mq->current_envelope->parent_queue = NULL;
GNUNET_MQ_discard (mq->current_envelope);
mq->current_envelope = NULL;
+ GNUNET_assert (0 < mq->queue_length);
+ mq->queue_length--;
+ }
+ GNUNET_assert (0 == mq->queue_length);
+ while (NULL != (dnh = mq->dnh_head))
+ {
+ dnh->cb (dnh->cb_cls);
+ GNUNET_MQ_destroy_notify_cancel (dnh);
}
if (NULL != mq->assoc_map)
{
GNUNET_assert (NULL != mq);
GNUNET_assert (NULL != mq->cancel_impl);
+
+ mq->evacuate_called = GNUNET_NO;
if (mq->current_envelope == ev)
{
// complex case, we already started with transmitting
// the message
+ GNUNET_assert (0 < mq->queue_length);
+ mq->queue_length--;
mq->cancel_impl (mq,
mq->impl_state);
// continue sending the next message, if any
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
mq->envelope_tail,
mq->current_envelope);
- mq->queue_length--;
+ mq->send_notification_called = GNUNET_NO;
mq->send_impl (mq,
mq->current_envelope->mh,
mq->impl_state);
GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
mq->envelope_tail,
ev);
+ GNUNET_assert (0 < mq->queue_length);
mq->queue_length--;
}
- ev->parent_queue = NULL;
- ev->mh = NULL;
- GNUNET_free (ev);
+ if (GNUNET_YES != mq->evacuate_called)
+ {
+ ev->parent_queue = NULL;
+ ev->mh = NULL;
+ /* also frees ev */
+ 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;
+}
+
+
+/**
+ * Register function to be called whenever @a mq is being
+ * destroyed.
+ *
+ * @param mq message queue to watch
+ * @param cb function to call on @a mq destruction
+ * @param cb_cls closure for @a cb
+ * @return handle for #GNUNET_MQ_destroy_notify_cancel().
+ */
+struct GNUNET_MQ_DestroyNotificationHandle *
+GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
+ GNUNET_SCHEDULER_TaskCallback cb,
+ void *cb_cls)
+{
+ struct GNUNET_MQ_DestroyNotificationHandle *dnh;
+
+ dnh = GNUNET_new (struct GNUNET_MQ_DestroyNotificationHandle);
+ dnh->mq = mq;
+ dnh->cb = cb;
+ dnh->cb_cls = cb_cls;
+ GNUNET_CONTAINER_DLL_insert (mq->dnh_head,
+ mq->dnh_tail,
+ dnh);
+ return dnh;
+}
+
+
+/**
+ * Cancel registration from #GNUNET_MQ_destroy_notify().
+ *
+ * @param dnh handle for registration to cancel
+ */
+void
+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_free (dnh);
+}
+
+
/* end of mq.c */