LSMessageHandlerResult
_LSCustomMessageHandler(_LSTransportMessage *message, void *context)
{
/* add the messages to our internal queue */
LSHandle *sh = (LSHandle*)context;
_LSTransportMessageRef(message);
LSCustomMessageQueuePush(sh->custom_message_queue, message);
return LSMessageHandlerResultHandled;
}
/**
*******************************************************************************
* @brief Allocate a new serial list item.
*
* @param serial IN serial (token)
*
* @retval item on success
* @retval NULL on failure
*******************************************************************************
*/
_LSTransportSerialListItem*
_LSTransportSerialListItemNew(LSMessageToken serial, _LSTransportMessage *message)
{
_LSTransportSerialListItem *item = g_slice_new0(_LSTransportSerialListItem);
item->serial = serial;
_LSTransportMessageRef(message);
item->message = message;
return item;
}
static void
test_LSTransportIncoming_execute(int number_of_messages)
{
_LSTransportIncoming *inqueue = _LSTransportIncomingNew();
/* Is incoming message queue constructed? */
g_assert(NULL != inqueue);
g_assert(NULL != inqueue->complete_messages);
/* The mutex should be initialized. */
g_assert_cmpint(pthread_mutex_trylock(&inqueue->lock), !=, EINVAL);
pthread_mutex_unlock(&inqueue->lock);
_LSTransportMessage *messages[number_of_messages];
int i;
/* Fill queue with (possible) test data. */
for(i = 0; i < number_of_messages; i++)
{
_LSTransportMessage *message = _LSTransportMessageNewRef(LS_TRANSPORT_MESSAGE_DEFAULT_PAYLOAD_SIZE);
/* Increment ref count (possible to check message ref count after _LSTransportIncomingFree) */
_LSTransportMessageRef(message);
g_assert_cmpint(message->ref, ==, 2);
messages[i] = message;
g_queue_push_head(inqueue->complete_messages, message);
}
/* Simulate the message are processed */
while (!g_queue_is_empty(inqueue->complete_messages))
{
_LSTransportMessage *message = g_queue_pop_head(inqueue->complete_messages);
_LSTransportMessageUnref(message);
}
/* Free the struct. */
_LSTransportIncomingFree(inqueue);
/* The mutex should be destroyed. */
g_assert_cmpint(pthread_mutex_trylock(&inqueue->lock), ==, EINVAL);
/* See if the messages in the queue were unreferenced. */
for(i = 0; i < number_of_messages; i++)
{
g_assert_cmpint(messages[i]->ref, ==, 1);
}
/* Cleanup. All testing is now over. */
for(i = 0; i < number_of_messages; i++)
{
_LSTransportMessageUnref(messages[i]);
}
}
void
LSCustomMessageQueuePush(LSCustomMessageQueue *q, _LSTransportMessage *message)
{
_LSTransportMessageRef(message);
/* lock queue */
pthread_mutex_lock(&q->lock);
g_queue_push_tail(q->queue, message);
/* unlock queue */
pthread_mutex_unlock(&q->lock);
}
/**
* @brief Allocate LSMessage from _LSTransportMessage with a refcount of 1.
*
* @param transport_msg
*
* @retval
*/
LSMessage *
_LSMessageNewRef(_LSTransportMessage *transport_msg, LSHandle *sh)
{
LSMessage *message = g_new0(LSMessage, 1);
if (message)
{
if (transport_msg)
message->transport_msg = _LSTransportMessageRef(transport_msg);
message->sh = sh;
message->ref = 1;
//g_debug("%s(%p)", __FUNCTION__, message);
}
return message;
}
/**
*******************************************************************************
* @brief Pops a message from the serial queue and removes it from the serial map.
*
* @attention locks the serial info lock
*
* @param serial_info IN serial info
*
* @retval message on success
* @retval NULL on empty serial queue
*******************************************************************************
*/
_LSTransportMessage*
_LSTransportSerialPopHead(_LSTransportSerial *serial_info)
{
_LSTransportMessage *message = NULL;
SERIAL_INFO_LOCK(&serial_info->lock);
_LSTransportSerialListItem *item = g_queue_pop_head(serial_info->queue);
if (item)
{
message = item->message;
_LSTransportMessageRef(message);
g_hash_table_remove(serial_info->map, &item->serial);
_LSTransportSerialListItemFree(item);
}
SERIAL_INFO_UNLOCK(&serial_info->lock);
return message;
}
