void _LSTransportClientUnref(_LSTransportClient *client) { calls_to_clientunref++; client->ref--; g_assert_cmpint(client->ref, >=, 0); if(client->ref == 0) { if(client->incoming) { while (!g_queue_is_empty(client->incoming->complete_messages)) { _LSTransportMessage *message = g_queue_pop_head(client->incoming->complete_messages); _LSTransportMessageUnref(message); } g_queue_free(client->incoming->complete_messages); g_slice_free(_LSTransportIncoming, client->incoming); } if(client->outgoing) { while (!g_queue_is_empty(client->outgoing->queue)) { _LSTransportMessage *message = g_queue_pop_head(client->outgoing->queue); _LSTransportMessageUnref(message); } g_queue_free(client->outgoing->queue); g_slice_free(_LSTransportOutgoing, client->outgoing); } g_slice_free(_LSTransportClient, client); } }
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]); } }
/** ******************************************************************************* * @brief Send a signal registration message. * * @param transport IN transport * @param reg IN true to register, false to unregister * @param category IN category (required) * @param method IN method (optional, NULL means none) * @param token OUT message token * @param lserror OUT set on error * * @retval true on success * @retval false on failure ******************************************************************************* */ bool _LSTransportSignalRegistration(_LSTransport *transport, bool reg, const char *category, const char *method, LSMessageToken *token, LSError *lserror) { /* * format: * * category + NUL * method + NUL (if method is NULL, then we just have NUL) */ bool ret = true; int category_len = strlen_safe(category) + 1; int method_len = strlen_safe(method) + 1; LOG_LS_TRACE("%s: category: %s, method: %s\n", __func__, category, method); _LSTransportMessage *message = _LSTransportMessageNewRef(category_len + method_len); if (reg) { _LSTransportMessageSetType(message, _LSTransportMessageTypeSignalRegister); } else { _LSTransportMessageSetType(message, _LSTransportMessageTypeSignalUnregister); } char *message_body = _LSTransportMessageGetBody(message); LS_ASSERT(message_body != NULL); memcpy(message_body, category, category_len); message_body += category_len; if (method_len == 1) { char nul = '\0'; memcpy(message_body, &nul, sizeof(nul)); } else { memcpy(message_body, method, method_len); } LS_ASSERT(transport->hub != NULL); if (!_LSTransportSendMessage(message, transport->hub, token, lserror)) { ret = false; } _LSTransportMessageUnref(message); return ret; }
/** ******************************************************************************* * @brief Free a serial list item. * * @param list_item IN serial list item to free ******************************************************************************* */ void _LSTransportSerialListItemFree(_LSTransportSerialListItem *list_item) { LS_ASSERT(list_item != NULL); _LSTransportMessageUnref(list_item->message); #ifdef MEMCHECK memset(list_item, 0xFF, sizeof(_LSTransportSerialListItem)); #endif g_slice_free(_LSTransportSerialListItem, list_item); }
/** ******************************************************************************* * @brief Send a signal. * * @param transport IN transport * @param category IN category * @param method IN method (optional, NULL means none) * @param payload IN payload * @param lserror OUT set on error * * @retval true on success * @retval false on failure ******************************************************************************* */ bool LSTransportSendSignal(_LSTransport *transport, const char *category, const char *method, const char *payload, LSError *lserror) { bool ret = true; _LSTransportMessage *message = LSTransportMessageSignalNewRef(category, method, payload); LS_ASSERT(transport->hub != NULL); ret = _LSTransportSendMessage(message, transport->hub, NULL, lserror); _LSTransportMessageUnref(message); return ret; }
_LSTransportMessage* LSCustomMessageQueuePop(LSCustomMessageQueue *q) { /* lock queue */ pthread_mutex_lock(&q->lock); _LSTransportMessage *ret = g_queue_pop_head(q->queue); /* unlock queue */ pthread_mutex_unlock(&q->lock); if (ret) _LSTransportMessageUnref(ret); return ret; }
void _LSMessageFree(LSMessage *message) { if (message->transport_msg) _LSTransportMessageUnref(message->transport_msg); g_free(message->uniqueTokenAllocated); g_free(message->kindAllocated); g_free(message->methodAllocated); g_free(message->payloadAllocated); #ifdef MEMCHECK memset(message, 0xFF, sizeof(LSMessage)); #endif g_free(message); }
void LSCustomMessageQueueFree(LSCustomMessageQueue *q) { /* clean up any remaining messages on the queue */ while (!g_queue_is_empty(q->queue)) { _LSTransportMessage *message = g_queue_pop_head(q->queue); _LSTransportMessageUnref(message); } g_queue_free(q->queue); #ifdef MEMCHECK memset(q, 0xFF, sizeof(LSCustomMessageQueue)); #endif g_free(q); }
/** ******************************************************************************* * @brief Free an outgoing queue. * * @param outgoing IN outgoing queue ******************************************************************************* */ void _LSTransportOutgoingFree(_LSTransportOutgoing *outgoing) { LS_ASSERT(outgoing != NULL); LS_ASSERT(outgoing->queue != NULL); LS_ASSERT(outgoing->serial != NULL); while (!g_queue_is_empty(outgoing->queue)) { _LSTransportMessage *message = g_queue_pop_head(outgoing->queue); _LSTransportMessageUnref(message); } g_queue_free(outgoing->queue); _LSTransportSerialFree(outgoing->serial); #ifdef MEMCHECK memset(outgoing, 0xFF, sizeof(_LSTransportOutgoing)); #endif g_slice_free(_LSTransportOutgoing, outgoing); }