From 3d7ad7b324c98bd070ee98c35fb4f8413cbdd86b Mon Sep 17 00:00:00 2001 From: Vikram Dattu Date: Tue, 13 May 2025 10:46:24 +0530 Subject: [PATCH] Prefer dynamic allocations over large STATIC arrays - Use dynamically allocated WSS URL - Use dynamic allocations for singaling payload - Use required only allocations in LwsApiCalls instead large static arrays --- CMakeLists.txt | 5 + samples/Common.c | 36 ++- .../kinesis/video/webrtcclient/Include.h | 19 ++ src/source/Signaling/LwsApiCalls.c | 220 +++++++++++++++--- tst/SignalingApiFunctionalityTest.cpp | 169 ++++++++++++++ tst/SignalingApiTest.cpp | 32 +++ 6 files changed, 451 insertions(+), 30 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d10611856f..aefc5199b1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,6 +23,7 @@ option(INSTRUMENTED_ALLOCATORS "Enable memory instrumentation" OFF) option(ENABLE_AWS_SDK_IN_TESTS "Enable support for compiling AWS SDKs for tests" ON) option(ENABLE_STATS_CALCULATION_CONTROL "Enable support for runtime control of ice agent stat calculations." OFF) option(BUILD_OLD_MBEDTLS_VERSION "Use MbedTLS version 2.28.8." OFF) +option(PREFER_DYNAMIC_ALLOCS "Prefer dynamic allocations for signalingpayloads and URLs" OFF) # Developer Flags option(BUILD_TEST "Build the testing tree." OFF) @@ -147,6 +148,10 @@ if (ENABLE_STATS_CALCULATION_CONTROL) add_definitions(-DENABLE_STATS_CALCULATION_CONTROL) endif() +if (PREFER_DYNAMIC_ALLOCS) + add_definitions(-DPREFER_DYNAMIC_ALLOCS=1) +endif() + if(USE_OPENSSL) add_definitions(-DKVS_USE_OPENSSL) elseif(USE_MBEDTLS) diff --git a/samples/Common.c b/samples/Common.c index b371f30779..bafcfb6517 100644 --- a/samples/Common.c +++ b/samples/Common.c @@ -280,6 +280,10 @@ STATUS respondWithAnswer(PSampleStreamingSession pSampleStreamingSession) SignalingMessage message; UINT32 buffLen = MAX_SIGNALING_MESSAGE_LEN; +#ifdef DYNAMIC_SIGNALING_PAYLOAD + message.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + CHK(message.payload != NULL, STATUS_NOT_ENOUGH_MEMORY); +#endif CHK_STATUS(serializeSessionDescriptionInit(&pSampleStreamingSession->answerSessionDescriptionInit, message.payload, &buffLen)); message.version = SIGNALING_MESSAGE_CURRENT_VERSION; @@ -293,6 +297,10 @@ STATUS respondWithAnswer(PSampleStreamingSession pSampleStreamingSession) CleanUp: +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(message.payload); +#endif + CHK_LOG_ERR(retStatus); return retStatus; } @@ -312,7 +320,7 @@ VOID onIceCandidateHandler(UINT64 customData, PCHAR candidateJson) { STATUS retStatus = STATUS_SUCCESS; PSampleStreamingSession pSampleStreamingSession = (PSampleStreamingSession) customData; - SignalingMessage message; + SignalingMessage message = {0}; CHK(pSampleStreamingSession != NULL, STATUS_NULL_ARG); @@ -335,6 +343,10 @@ VOID onIceCandidateHandler(UINT64 customData, PCHAR candidateJson) message.messageType = SIGNALING_MESSAGE_TYPE_ICE_CANDIDATE; STRNCPY(message.peerClientId, pSampleStreamingSession->peerId, MAX_SIGNALING_CLIENT_ID_LEN); message.payloadLen = (UINT32) STRNLEN(candidateJson, MAX_SIGNALING_MESSAGE_LEN); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + message.payload = (PCHAR) MEMALLOC(message.payloadLen + 1); + CHK(message.payload != NULL, STATUS_NOT_ENOUGH_MEMORY); +#endif STRNCPY(message.payload, candidateJson, message.payloadLen); message.correlationId[0] = '\0'; CHK_STATUS(sendSignalingMessage(pSampleStreamingSession, &message)); @@ -342,6 +354,10 @@ VOID onIceCandidateHandler(UINT64 customData, PCHAR candidateJson) CleanUp: +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(message.payload); +#endif + CHK_LOG_ERR(retStatus); } @@ -1410,6 +1426,9 @@ STATUS submitPendingIceCandidate(PPendingMessageQueue pPendingMessageQueue, PSam if (pReceivedSignalingMessage->signalingMessage.messageType == SIGNALING_MESSAGE_TYPE_ICE_CANDIDATE) { CHK_STATUS(handleRemoteCandidate(pSampleStreamingSession, &pReceivedSignalingMessage->signalingMessage)); } +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(pReceivedSignalingMessage->signalingMessage.payload); +#endif SAFE_MEMFREE(pReceivedSignalingMessage); } } while (!noPendingSignalingMessageForClient); @@ -1418,6 +1437,11 @@ STATUS submitPendingIceCandidate(PPendingMessageQueue pPendingMessageQueue, PSam CleanUp: +#ifdef DYNAMIC_SIGNALING_PAYLOAD + if (pReceivedSignalingMessage != NULL) { + SAFE_MEMFREE(pReceivedSignalingMessage->signalingMessage.payload); + } +#endif SAFE_MEMFREE(pReceivedSignalingMessage); CHK_LOG_ERR(retStatus); return retStatus; @@ -1538,6 +1562,11 @@ STATUS signalingMessageReceived(UINT64 customData, PReceivedSignalingMessage pRe pReceivedSignalingMessageCopy = (PReceivedSignalingMessage) MEMCALLOC(1, SIZEOF(ReceivedSignalingMessage)); *pReceivedSignalingMessageCopy = *pReceivedSignalingMessage; +#ifdef DYNAMIC_SIGNALING_PAYLOAD + pReceivedSignalingMessageCopy->signalingMessage.payload = (PCHAR) MEMALLOC(pReceivedSignalingMessage->signalingMessage.payloadLen + 1); + CHK(pReceivedSignalingMessageCopy->signalingMessage.payload != NULL, STATUS_NOT_ENOUGH_MEMORY); + STRNCPY(pReceivedSignalingMessageCopy->signalingMessage.payload, pReceivedSignalingMessage->signalingMessage.payload, pReceivedSignalingMessage->signalingMessage.payloadLen + 1); +#endif CHK_STATUS(stackQueueEnqueue(pPendingMessageQueue->messageQueue, (UINT64) pReceivedSignalingMessageCopy)); @@ -1571,6 +1600,11 @@ STATUS signalingMessageReceived(UINT64 customData, PReceivedSignalingMessage pRe CleanUp: +#ifdef DYNAMIC_SIGNALING_PAYLOAD + if (pReceivedSignalingMessage != NULL) { + SAFE_MEMFREE(pReceivedSignalingMessage->signalingMessage.payload); + } +#endif SAFE_MEMFREE(pReceivedSignalingMessageCopy); if (pPendingMessageQueue != NULL) { freeMessageQueue(pPendingMessageQueue); diff --git a/src/include/com/amazonaws/kinesis/video/webrtcclient/Include.h b/src/include/com/amazonaws/kinesis/video/webrtcclient/Include.h index 3fd3a3711f..2981bb8759 100644 --- a/src/include/com/amazonaws/kinesis/video/webrtcclient/Include.h +++ b/src/include/com/amazonaws/kinesis/video/webrtcclient/Include.h @@ -1279,6 +1279,21 @@ typedef struct { //!< } RtcIceCandidateInit, *PRtcIceCandidateInit; +/** + * @brief Define this macro to use dynamically allocated payload in SignalingMessage + * This can be useful for platforms with limited memory as it avoids allocating + * MAX_SIGNALING_MESSAGE_LEN for each message when only a small payload is needed + */ + +/** + * @brief If PREFER_DYNAMIC_ALLOCS is set to 1, use dynamic allocation for signaling payload + * Otherwise, use the existing DYNAMIC_SIGNALING_PAYLOAD setting + */ +#if PREFER_DYNAMIC_ALLOCS +#define DYNAMIC_SIGNALING_PAYLOAD 1 +#define USE_DYNAMIC_URL 1 +#endif + /** * @brief Structure defining the basic signaling message */ @@ -1293,7 +1308,11 @@ typedef struct { UINT32 payloadLen; //!< Optional payload length. If 0, the length will be calculated +#ifdef DYNAMIC_SIGNALING_PAYLOAD + PCHAR payload; //!< Actual signaling message payload - dynamically allocated +#else CHAR payload[MAX_SIGNALING_MESSAGE_LEN + 1]; //!< Actual signaling message payload +#endif } SignalingMessage, *PSignalingMessage; /** diff --git a/src/source/Signaling/LwsApiCalls.c b/src/source/Signaling/LwsApiCalls.c index 1f20118be8..4eba0137ae 100644 --- a/src/source/Signaling/LwsApiCalls.c +++ b/src/source/Signaling/LwsApiCalls.c @@ -750,8 +750,9 @@ STATUS describeChannelLws(PSignalingClient pSignalingClient, UINT64 time) UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; - CHAR paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + UINT32 paramsJsonLen = 0; + PCHAR url = NULL; + PCHAR paramsJson = NULL; PLwsCallInfo pLwsCallInfo = NULL; PCHAR pResponseStr; jsmn_parser parser; @@ -763,12 +764,24 @@ STATUS describeChannelLws(PSignalingClient pSignalingClient, UINT64 time) CHK(pSignalingClient != NULL, STATUS_NULL_ARG); + // Allocate memory for url + UINT32 urlLen = STRNLEN(pSignalingClient->pChannelInfo->pControlPlaneUrl, MAX_ARN_LEN) + STRLEN(DESCRIBE_SIGNALING_CHANNEL_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + + // Allocate memory for paramsJson + paramsJsonLen = SNPRINTF(NULL, 0, DESCRIBE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->pChannelInfo->pChannelName); + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Create the API url STRCPY(url, pSignalingClient->pChannelInfo->pControlPlaneUrl); STRCAT(url, DESCRIBE_SIGNALING_CHANNEL_API_POSTFIX); // Prepare the json params for the call - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), DESCRIBE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->pChannelInfo->pChannelName); + SNPRINTF(paramsJson, paramsJsonLen, DESCRIBE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->pChannelInfo->pChannelName); // Create the request info with the body CHK_STATUS(createRequestInfo(url, paramsJson, pSignalingClient->pChannelInfo->pRegion, pSignalingClient->pChannelInfo->pCertPath, NULL, NULL, SSL_CERTIFICATE_TYPE_NOT_SPECIFIED, pSignalingClient->pChannelInfo->pUserAgent, @@ -871,6 +884,9 @@ STATUS describeChannelLws(PSignalingClient pSignalingClient, UINT64 time) DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -884,8 +900,9 @@ STATUS createChannelLws(PSignalingClient pSignalingClient, UINT64 time) UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; - CHAR paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + UINT32 paramsJsonLen = 0; + PCHAR url = NULL; + PCHAR paramsJson = NULL; CHAR tagsJson[2 * MAX_JSON_PARAMETER_STRING_LEN]; PCHAR pCurPtr, pTagsStart, pResponseStr; UINT32 i, strLen, resultLen; @@ -897,6 +914,12 @@ STATUS createChannelLws(PSignalingClient pSignalingClient, UINT64 time) CHK(pSignalingClient != NULL, STATUS_NULL_ARG); + // Allocate memory for url + UINT32 urlLen = STRNLEN(pSignalingClient->pChannelInfo->pControlPlaneUrl, MAX_ARN_LEN) + STRLEN(CREATE_SIGNALING_CHANNEL_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Create the API url STRCPY(url, pSignalingClient->pChannelInfo->pControlPlaneUrl); STRCAT(url, CREATE_SIGNALING_CHANNEL_API_POSTFIX); @@ -920,8 +943,16 @@ STATUS createChannelLws(PSignalingClient pSignalingClient, UINT64 time) SNPRINTF(tagsJson, MAX_JSON_PARAMETER_STRING_LEN, TAGS_PARAM_JSON_TEMPLATE, tagsJson + MAX_JSON_PARAMETER_STRING_LEN); } + // Allocate memory for paramsJson + paramsJsonLen = SNPRINTF(NULL, 0, CREATE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->pChannelInfo->pChannelName, + getStringFromChannelType(pSignalingClient->pChannelInfo->channelType), + pSignalingClient->pChannelInfo->messageTtl / HUNDREDS_OF_NANOS_IN_A_SECOND, tagsJson); + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Prepare the json params for the call - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), CREATE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->pChannelInfo->pChannelName, + SNPRINTF(paramsJson, paramsJsonLen, CREATE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->pChannelInfo->pChannelName, getStringFromChannelType(pSignalingClient->pChannelInfo->channelType), pSignalingClient->pChannelInfo->messageTtl / HUNDREDS_OF_NANOS_IN_A_SECOND, tagsJson); @@ -978,6 +1009,9 @@ STATUS createChannelLws(PSignalingClient pSignalingClient, UINT64 time) DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -991,8 +1025,9 @@ STATUS getChannelEndpointLws(PSignalingClient pSignalingClient, UINT64 time) UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; - CHAR paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + UINT32 paramsJsonLen = 0; + PCHAR url = NULL; + PCHAR paramsJson = NULL; UINT32 i, resultLen, strLen, protocolLen = 0, endpointLen = 0; PCHAR pResponseStr, pProtocol = NULL, pEndpoint = NULL; PLwsCallInfo pLwsCallInfo = NULL; @@ -1003,16 +1038,29 @@ STATUS getChannelEndpointLws(PSignalingClient pSignalingClient, UINT64 time) CHK(pSignalingClient != NULL, STATUS_NULL_ARG); + // Allocate memory for url + UINT32 urlLen = STRNLEN(pSignalingClient->pChannelInfo->pControlPlaneUrl, MAX_ARN_LEN) + STRLEN(GET_SIGNALING_CHANNEL_ENDPOINT_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + + // Allocate memory for paramsJson + paramsJsonLen = SNPRINTF(NULL, 0, GET_CHANNEL_ENDPOINT_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + SIGNALING_CHANNEL_PROTOCOL, getStringFromChannelRoleType(pSignalingClient->pChannelInfo->channelRoleType)); + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Create the API url STRCPY(url, pSignalingClient->pChannelInfo->pControlPlaneUrl); STRCAT(url, GET_SIGNALING_CHANNEL_ENDPOINT_API_POSTFIX); // Prepare the json params for the call if (pSignalingClient->mediaStorageConfig.storageStatus == FALSE) { - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), GET_CHANNEL_ENDPOINT_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + SNPRINTF(paramsJson, paramsJsonLen, GET_CHANNEL_ENDPOINT_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, SIGNALING_CHANNEL_PROTOCOL, getStringFromChannelRoleType(pSignalingClient->pChannelInfo->channelRoleType)); } else { - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), GET_CHANNEL_ENDPOINT_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + SNPRINTF(paramsJson, paramsJsonLen, GET_CHANNEL_ENDPOINT_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, SIGNALING_CHANNEL_PROTOCOL_W_MEDIA_STORAGE, getStringFromChannelRoleType(pSignalingClient->pChannelInfo->channelRoleType)); } @@ -1127,6 +1175,9 @@ STATUS getChannelEndpointLws(PSignalingClient pSignalingClient, UINT64 time) DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -1140,7 +1191,9 @@ STATUS getIceConfigLws(PSignalingClient pSignalingClient, UINT64 time) UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1], paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + UINT32 paramsJsonLen = 0; + PCHAR url = NULL; + PCHAR paramsJson = NULL; PLwsCallInfo pLwsCallInfo = NULL; PCHAR pResponseStr; UINT32 resultLen; @@ -1148,6 +1201,19 @@ STATUS getIceConfigLws(PSignalingClient pSignalingClient, UINT64 time) CHK(pSignalingClient != NULL, STATUS_NULL_ARG); CHK(pSignalingClient->channelEndpointHttps[0] != '\0', STATUS_INTERNAL_ERROR); + // Allocate memory for url + UINT32 urlLen = STRNLEN(pSignalingClient->channelEndpointHttps, MAX_SIGNALING_ENDPOINT_URI_LEN) + STRLEN(GET_ICE_CONFIG_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + + // Allocate memory for paramsJson + paramsJsonLen = SNPRINTF(NULL, 0, GET_ICE_CONFIG_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + pSignalingClient->clientInfo.signalingClientInfo.clientId); + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Update the diagnostics info on the number of ICE refresh calls ATOMIC_INCREMENT(&pSignalingClient->diagnostics.iceRefreshCount); @@ -1156,7 +1222,7 @@ STATUS getIceConfigLws(PSignalingClient pSignalingClient, UINT64 time) STRCAT(url, GET_ICE_CONFIG_API_POSTFIX); // Prepare the json params for the call - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), GET_ICE_CONFIG_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + SNPRINTF(paramsJson, paramsJsonLen, GET_ICE_CONFIG_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, pSignalingClient->clientInfo.signalingClientInfo.clientId); // Create the request info with the body @@ -1198,6 +1264,9 @@ STATUS getIceConfigLws(PSignalingClient pSignalingClient, UINT64 time) DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -1305,8 +1374,10 @@ STATUS deleteChannelLws(PSignalingClient pSignalingClient, UINT64 time) UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; - CHAR paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + PCHAR url = NULL; + UINT32 urlLen = 0; + PCHAR paramsJson = NULL; + UINT32 paramsJsonLen = 0; PLwsCallInfo pLwsCallInfo = NULL; SIZE_T result; @@ -1319,12 +1390,25 @@ STATUS deleteChannelLws(PSignalingClient pSignalingClient, UINT64 time) terminateConnectionWithStatus(pSignalingClient, SERVICE_CALL_RESULT_OK); } + // Allocate memory for url + urlLen = STRNLEN(pSignalingClient->pChannelInfo->pControlPlaneUrl, MAX_ARN_LEN) + STRLEN(DELETE_SIGNALING_CHANNEL_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + + // Allocate memory for paramsJson + paramsJsonLen = SNPRINTF(NULL, 0, DELETE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + pSignalingClient->channelDescription.updateVersion); + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Create the API url STRCPY(url, pSignalingClient->pChannelInfo->pControlPlaneUrl); STRCAT(url, DELETE_SIGNALING_CHANNEL_API_POSTFIX); // Prepare the json params for the call - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), DELETE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, + SNPRINTF(paramsJson, paramsJsonLen, DELETE_CHANNEL_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, pSignalingClient->channelDescription.updateVersion); // Create the request info with the body @@ -1362,6 +1446,9 @@ STATUS deleteChannelLws(PSignalingClient pSignalingClient, UINT64 time) DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -1429,7 +1516,7 @@ STATUS connectSignalingChannelLws(PSignalingClient pSignalingClient, UINT64 time UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; + PCHAR url = NULL; PLwsCallInfo pLwsCallInfo = NULL; BOOL locked = FALSE; SERVICE_CALL_RESULT callResult = SERVICE_CALL_RESULT_NOT_SET; @@ -1438,13 +1525,28 @@ STATUS connectSignalingChannelLws(PSignalingClient pSignalingClient, UINT64 time CHK(pSignalingClient != NULL, STATUS_NULL_ARG); CHK(pSignalingClient->channelEndpointWss[0] != '\0', STATUS_INTERNAL_ERROR); + UINT32 urlLen = 0; + if (pSignalingClient->pChannelInfo->channelRoleType == SIGNALING_CHANNEL_ROLE_TYPE_VIEWER) { + // Allocate memory for url + urlLen = SNPRINTF(NULL, 0, SIGNALING_ENDPOINT_VIEWER_URL_WSS_TEMPLATE, pSignalingClient->channelEndpointWss, + SIGNALING_CHANNEL_ARN_PARAM_NAME, pSignalingClient->channelDescription.channelArn, SIGNALING_CLIENT_ID_PARAM_NAME, + pSignalingClient->clientInfo.signalingClientInfo.clientId); + } else { + // Allocate memory for url + urlLen = SNPRINTF(NULL, 0, SIGNALING_ENDPOINT_MASTER_URL_WSS_TEMPLATE, pSignalingClient->channelEndpointWss, + SIGNALING_CHANNEL_ARN_PARAM_NAME, pSignalingClient->channelDescription.channelArn); + } + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Prepare the json params for the call if (pSignalingClient->pChannelInfo->channelRoleType == SIGNALING_CHANNEL_ROLE_TYPE_VIEWER) { - SNPRINTF(url, ARRAY_SIZE(url), SIGNALING_ENDPOINT_VIEWER_URL_WSS_TEMPLATE, pSignalingClient->channelEndpointWss, + SNPRINTF(url, urlLen, SIGNALING_ENDPOINT_VIEWER_URL_WSS_TEMPLATE, pSignalingClient->channelEndpointWss, SIGNALING_CHANNEL_ARN_PARAM_NAME, pSignalingClient->channelDescription.channelArn, SIGNALING_CLIENT_ID_PARAM_NAME, pSignalingClient->clientInfo.signalingClientInfo.clientId); } else { - SNPRINTF(url, ARRAY_SIZE(url), SIGNALING_ENDPOINT_MASTER_URL_WSS_TEMPLATE, pSignalingClient->channelEndpointWss, + SNPRINTF(url, urlLen, SIGNALING_ENDPOINT_MASTER_URL_WSS_TEMPLATE, pSignalingClient->channelEndpointWss, SIGNALING_CHANNEL_ARN_PARAM_NAME, pSignalingClient->channelDescription.channelArn); } @@ -1493,6 +1595,8 @@ STATUS connectSignalingChannelLws(PSignalingClient pSignalingClient, UINT64 time CHK_LOG_ERR(retStatus); + SAFE_MEMFREE(url); + if (STATUS_FAILED(retStatus) && pSignalingClient != NULL) { // Fix-up the timeout case SERVICE_CALL_RESULT serviceCallResult = @@ -1521,8 +1625,9 @@ STATUS joinStorageSessionLws(PSignalingClient pSignalingClient, UINT64 time) UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; - CHAR paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + UINT32 paramsJsonLen = 0; + PCHAR url = NULL; + PCHAR paramsJson = NULL; PLwsCallInfo pLwsCallInfo = NULL; PCHAR pResponseStr; UINT32 resultLen; @@ -1533,16 +1638,35 @@ STATUS joinStorageSessionLws(PSignalingClient pSignalingClient, UINT64 time) CHK(pSignalingClient != NULL, STATUS_NULL_ARG); CHK(pSignalingClient->channelEndpointWebrtc[0] != '\0', STATUS_INTERNAL_ERROR); + // Allocate memory for url + UINT32 urlLen = STRNLEN(pSignalingClient->channelEndpointWebrtc, MAX_SIGNALING_ENDPOINT_URI_LEN) + STRLEN(JOIN_STORAGE_SESSION_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + + // Allocate memory for paramsJson + if (pSignalingClient->pChannelInfo->channelRoleType == SIGNALING_CHANNEL_ROLE_TYPE_VIEWER) { + paramsJsonLen = SNPRINTF(NULL, 0, SIGNALING_JOIN_STORAGE_SESSION_VIEWER_PARAM_JSON_TEMPLATE, + pSignalingClient->channelDescription.channelArn, + pSignalingClient->clientInfo.signalingClientInfo.clientId); + } else { + paramsJsonLen = SNPRINTF(NULL, 0, SIGNALING_JOIN_STORAGE_SESSION_MASTER_PARAM_JSON_TEMPLATE, + pSignalingClient->channelDescription.channelArn); + } + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Create the API url STRCPY(url, pSignalingClient->channelEndpointWebrtc); STRCAT(url, JOIN_STORAGE_SESSION_API_POSTFIX); // Prepare the json params for the call if (pSignalingClient->pChannelInfo->channelRoleType == SIGNALING_CHANNEL_ROLE_TYPE_VIEWER) { - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), SIGNALING_JOIN_STORAGE_SESSION_VIEWER_PARAM_JSON_TEMPLATE, + SNPRINTF(paramsJson, paramsJsonLen, SIGNALING_JOIN_STORAGE_SESSION_VIEWER_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn, pSignalingClient->clientInfo.signalingClientInfo.clientId); } else { - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), SIGNALING_JOIN_STORAGE_SESSION_MASTER_PARAM_JSON_TEMPLATE, + SNPRINTF(paramsJson, paramsJsonLen, SIGNALING_JOIN_STORAGE_SESSION_MASTER_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn); } @@ -1586,6 +1710,9 @@ STATUS joinStorageSessionLws(PSignalingClient pSignalingClient, UINT64 time) DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -1599,8 +1726,9 @@ STATUS describeMediaStorageConfLws(PSignalingClient pSignalingClient, UINT64 tim UNUSED_PARAM(time); PRequestInfo pRequestInfo = NULL; - CHAR url[MAX_URI_CHAR_LEN + 1]; - CHAR paramsJson[MAX_JSON_PARAMETER_STRING_LEN]; + UINT32 paramsJsonLen = 0; + PCHAR url = NULL; + PCHAR paramsJson = NULL; PLwsCallInfo pLwsCallInfo = NULL; PCHAR pResponseStr; jsmn_parser parser; @@ -1611,13 +1739,25 @@ STATUS describeMediaStorageConfLws(PSignalingClient pSignalingClient, UINT64 tim CHK(pSignalingClient != NULL, STATUS_NULL_ARG); + // Allocate memory for url + UINT32 urlLen = STRNLEN(pSignalingClient->pChannelInfo->pControlPlaneUrl, MAX_ARN_LEN) + STRLEN(DESCRIBE_MEDIA_STORAGE_CONF_API_POSTFIX); + urlLen += 1; // +1 for the NULL terminator + url = (PCHAR) MEMALLOC(urlLen); + CHK(url != NULL, STATUS_NOT_ENOUGH_MEMORY); + + // Allocate memory for paramsJson + paramsJsonLen = SNPRINTF(NULL, 0, DESCRIBE_MEDIA_STORAGE_CONF_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn); + paramsJsonLen += 1; // +1 for the NULL terminator + paramsJson = (PCHAR) MEMALLOC(paramsJsonLen); + CHK(paramsJson != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Create the API url STRCPY(url, pSignalingClient->pChannelInfo->pControlPlaneUrl); STRCAT(url, DESCRIBE_MEDIA_STORAGE_CONF_API_POSTFIX); // Prepare the json params for the call CHK(pSignalingClient->channelDescription.channelArn[0] != '\0', STATUS_NULL_ARG); - SNPRINTF(paramsJson, ARRAY_SIZE(paramsJson), DESCRIBE_MEDIA_STORAGE_CONF_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn); + SNPRINTF(paramsJson, paramsJsonLen, DESCRIBE_MEDIA_STORAGE_CONF_PARAM_JSON_TEMPLATE, pSignalingClient->channelDescription.channelArn); // Create the request info with the body CHK_STATUS(createRequestInfo(url, paramsJson, pSignalingClient->pChannelInfo->pRegion, pSignalingClient->pChannelInfo->pCertPath, NULL, NULL, SSL_CERTIFICATE_TYPE_NOT_SPECIFIED, pSignalingClient->pChannelInfo->pUserAgent, @@ -1691,6 +1831,9 @@ STATUS describeMediaStorageConfLws(PSignalingClient pSignalingClient, UINT64 tim DLOGE("Call Failed with Status: 0x%08x", retStatus); } + SAFE_MEMFREE(url); + SAFE_MEMFREE(paramsJson); + freeLwsCallInfo(&pLwsCallInfo); LEAVES(); @@ -1807,7 +1950,8 @@ STATUS sendLwsMessage(PSignalingClient pSignalingClient, SIGNALING_MESSAGE_TYPE { ENTERS(); STATUS retStatus = STATUS_SUCCESS; - CHAR encodedMessage[MAX_SESSION_DESCRIPTION_INIT_SDP_LEN + 1]; + UINT32 encodedMessageLen = 0; + PCHAR encodedMessage = NULL; CHAR encodedIceConfig[MAX_ENCODED_ICE_SERVER_INFOS_STR_LEN + 1]; CHAR encodedUris[MAX_ICE_SERVER_URI_STR_LEN + 1]; UINT32 size, writtenSize, correlationLen, iceCount, uriCount, urisLen, iceConfigLen; @@ -1849,8 +1993,14 @@ STATUS sendLwsMessage(PSignalingClient pSignalingClient, SIGNALING_MESSAGE_TYPE correlationLen = correlationIdLen; } + // Allocate memory for encodedMessage + encodedMessageLen = ((size + 2) / 3) * 4 + 1; // +1 for null terminator + CHK(encodedMessageLen <= MAX_SESSION_DESCRIPTION_INIT_SDP_LEN + 1, STATUS_INVALID_ARG); + encodedMessage = (PCHAR) MEMALLOC(encodedMessageLen); + CHK(encodedMessage != NULL, STATUS_NOT_ENOUGH_MEMORY); + // Base64 encode the message - writtenSize = ARRAY_SIZE(encodedMessage); + writtenSize = encodedMessageLen; CHK_STATUS(base64Encode(pMessage, size, encodedMessage, &writtenSize)); // Account for the template expansion + Action string + max recipient id @@ -1932,6 +2082,8 @@ STATUS sendLwsMessage(PSignalingClient pSignalingClient, SIGNALING_MESSAGE_TYPE CleanUp: CHK_LOG_ERR(retStatus); + SAFE_MEMFREE(encodedMessage); + LEAVES(); return retStatus; } @@ -2050,7 +2202,12 @@ STATUS parseSignalingMessage(PCHAR pMessage, UINT32 messageLen, PReceivedSignali } else if (compareJsonString(pMessage, &tokens[i], JSMN_STRING, (PCHAR) "messagePayload")) { strLen = (UINT32) (tokens[i + 1].end - tokens[i + 1].start); CHK(strLen <= MAX_SIGNALING_MESSAGE_LEN, STATUS_INVALID_API_CALL_RETURN_JSON); - outLen = SIZEOF(pReceivedSignalingMessage->signalingMessage.payload); + outLen = (strLen + 3) / 4 * 3 + 1; +#ifdef DYNAMIC_SIGNALING_PAYLOAD + pReceivedSignalingMessage->signalingMessage.payload = (PCHAR) MEMCALLOC(1, outLen); + CHK(pReceivedSignalingMessage->signalingMessage.payload != NULL, STATUS_NOT_ENOUGH_MEMORY); +#endif + // Base64 method will set outLen <= original input outLen CHK_STATUS(base64Decode(pMessage + tokens[i + 1].start, strLen, (PBYTE) (pReceivedSignalingMessage->signalingMessage.payload), &outLen)); @@ -2232,7 +2389,9 @@ STATUS receiveLwsMessage(PSignalingClient pSignalingClient, PCHAR pMessage, UINT if (IS_VALID_TID_VALUE(receivedTid)) { THREAD_CANCEL(receivedTid); } - +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(pSignalingMessageWrapper->receivedSignalingMessage.signalingMessage.payload); +#endif SAFE_MEMFREE(pSignalingMessageWrapper); } @@ -2399,6 +2558,9 @@ PVOID receiveLwsMessageWrapper(PVOID args) CleanUp: CHK_LOG_ERR(retStatus); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(pSignalingMessageWrapper->receivedSignalingMessage.signalingMessage.payload); +#endif SAFE_MEMFREE(pSignalingMessageWrapper); return (PVOID) (ULONG_PTR) retStatus; diff --git a/tst/SignalingApiFunctionalityTest.cpp b/tst/SignalingApiFunctionalityTest.cpp index d70e01847c..c3bd53e734 100644 --- a/tst/SignalingApiFunctionalityTest.cpp +++ b/tst/SignalingApiFunctionalityTest.cpp @@ -59,6 +59,10 @@ STATUS masterMessageReceived(UINT64 customData, PReceivedSignalingMessage pRecei message.version = SIGNALING_MESSAGE_CURRENT_VERSION; message.messageType = SIGNALING_MESSAGE_TYPE_ANSWER; STRCPY(message.peerClientId, TEST_SIGNALING_VIEWER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + message.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(message.payload != NULL); +#endif MEMSET(message.payload, 'B', 200); message.payload[200] = '\0'; message.payloadLen = 0; @@ -66,6 +70,9 @@ STATUS masterMessageReceived(UINT64 customData, PReceivedSignalingMessage pRecei status = signalingSendMessageSync(pTest->pActiveClient, &message); CHK_LOG_ERR(status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(message.payload); +#endif // Return success to continue return STATUS_SUCCESS; } @@ -383,6 +390,10 @@ TEST_F(SignalingApiFunctionalityTest, mockMaster) message.payloadLen = 0; message.correlationId[0] = '\0'; message.messageType = SIGNALING_MESSAGE_TYPE_ANSWER; +#ifdef DYNAMIC_SIGNALING_PAYLOAD + message.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(message.payload != NULL); +#endif MEMSET(message.payload, 'B', MAX_SIGNALING_MESSAGE_LEN); message.payload[MAX_SIGNALING_MESSAGE_LEN] = '\0'; @@ -432,6 +443,9 @@ TEST_F(SignalingApiFunctionalityTest, mockMaster) // Free again EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); EXPECT_FALSE(IS_VALID_SIGNALING_CLIENT_HANDLE(signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(message.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, mockViewer) @@ -519,6 +533,10 @@ TEST_F(SignalingApiFunctionalityTest, mockViewer) message.version = SIGNALING_MESSAGE_CURRENT_VERSION; message.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(message.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + message.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(message.payload != NULL); +#endif MEMSET(message.payload, 'A', 100); message.payload[100] = '\0'; message.payloadLen = 0; @@ -546,6 +564,9 @@ TEST_F(SignalingApiFunctionalityTest, mockViewer) // Free again EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); EXPECT_FALSE(IS_VALID_SIGNALING_CLIENT_HANDLE(signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(message.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, invalidChannelInfoInput) @@ -888,6 +909,10 @@ TEST_F(SignalingApiFunctionalityTest, iceReconnectEmulation) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -898,6 +923,9 @@ TEST_F(SignalingApiFunctionalityTest, iceReconnectEmulation) deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedVariations) @@ -1151,6 +1179,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedVariatio signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -1161,6 +1193,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedVariatio deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedVariations) @@ -1416,6 +1451,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedVariations) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -1426,6 +1465,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedVariations) deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedAuthExpiration) @@ -1777,6 +1819,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithFaul signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -1787,6 +1833,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithFaul deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithFaultInjectionRecovered) @@ -1893,6 +1942,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithFaultIn signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -1903,6 +1956,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithFaultIn deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithFaultInjectionNotRecovered) @@ -2006,6 +2062,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithFaul signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2016,6 +2076,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithFaul deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithFaultInjectionNot1669) @@ -2122,6 +2185,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithFaultIn signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2132,6 +2199,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithFaultIn deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithBadAuth) @@ -2242,6 +2312,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithBadA signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2252,6 +2326,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshNotConnectedWithBadA deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithBadAuth) @@ -2365,6 +2442,10 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithBadAuth signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2375,6 +2456,9 @@ TEST_F(SignalingApiFunctionalityTest, iceServerConfigRefreshConnectedWithBadAuth deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, goAwayEmulation) @@ -2449,6 +2533,10 @@ TEST_F(SignalingApiFunctionalityTest, goAwayEmulation) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2459,6 +2547,9 @@ TEST_F(SignalingApiFunctionalityTest, goAwayEmulation) deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, unknownMessageTypeEmulation) @@ -2537,6 +2628,10 @@ TEST_F(SignalingApiFunctionalityTest, unknownMessageTypeEmulation) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2547,6 +2642,9 @@ TEST_F(SignalingApiFunctionalityTest, unknownMessageTypeEmulation) deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, connectTimeoutEmulation) @@ -2658,6 +2756,10 @@ TEST_F(SignalingApiFunctionalityTest, connectTimeoutEmulation) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2668,6 +2770,9 @@ TEST_F(SignalingApiFunctionalityTest, connectTimeoutEmulation) deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, channelInfoArnSkipDescribe) @@ -2741,6 +2846,10 @@ TEST_F(SignalingApiFunctionalityTest, channelInfoArnSkipDescribe) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2800,6 +2909,9 @@ TEST_F(SignalingApiFunctionalityTest, channelInfoArnSkipDescribe) deleteChannelLws(FROM_SIGNALING_CLIENT_HANDLE(signalingHandle), 0); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, deleteChannelCreatedWithArn) @@ -2873,6 +2985,10 @@ TEST_F(SignalingApiFunctionalityTest, deleteChannelCreatedWithArn) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -2932,6 +3048,9 @@ TEST_F(SignalingApiFunctionalityTest, deleteChannelCreatedWithArn) EXPECT_EQ(STATUS_SUCCESS, signalingClientDeleteSync(signalingHandle)); EXPECT_EQ(STATUS_SUCCESS, freeSignalingClient(&signalingHandle)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, deleteChannelCreatedAuthExpiration) @@ -3066,6 +3185,10 @@ TEST_F(SignalingApiFunctionalityTest, signalingClientDisconnectSyncVariations) message.version = SIGNALING_MESSAGE_CURRENT_VERSION; message.messageType = SIGNALING_MESSAGE_TYPE_ANSWER; STRCPY(message.peerClientId, TEST_SIGNALING_VIEWER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + message.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(message.payload != NULL); +#endif MEMSET(message.payload, 'A', 200); message.payload[200] = '\0'; message.payloadLen = 0; @@ -3086,6 +3209,10 @@ TEST_F(SignalingApiFunctionalityTest, signalingClientDisconnectSyncVariations) EXPECT_EQ(STATUS_SUCCESS, signalingClientConnectSync(mSignalingClientHandle)); EXPECT_EQ(STATUS_SUCCESS, signalingClientSendMessageSync(mSignalingClientHandle, &message)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(message.payload); +#endif + deinitializeSignalingClient(); } @@ -3519,6 +3646,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_ParseOfferSuccess) EXPECT_STREQ("Hello", receivedMessage.signalingMessage.payload); EXPECT_EQ(5, receivedMessage.signalingMessage.payloadLen); EXPECT_EQ(SIGNALING_MESSAGE_TYPE_OFFER, receivedMessage.signalingMessage.messageType); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_ParseStatusResponseSuccess) { @@ -3546,6 +3676,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_ParseStatusRespons EXPECT_STREQ("", receivedMessage.signalingMessage.peerClientId); EXPECT_STREQ("", receivedMessage.signalingMessage.payload); EXPECT_EQ(0, receivedMessage.signalingMessage.payloadLen); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_InvalidArgs) { @@ -3561,6 +3694,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_InvalidArgs) { // Validate that the jsonMessage is OK STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_SUCCESS, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif // NULL parameter EXPECT_EQ(STATUS_NULL_ARG, parseSignalingMessage(NULL, jsonMessage.length(), &receivedMessage)); @@ -3575,6 +3711,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_messageTooLong) { STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_senderClientIdIsTooLong) { @@ -3592,6 +3731,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_senderClientIdIsTo STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_messageTypeIsTooLong) { @@ -3609,6 +3751,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_messageTypeIsTooLo STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_messagePayloadIsTooLong) { @@ -3626,6 +3771,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_messagePayloadIsTo STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_correlationIdIsTooLong) { @@ -3647,6 +3795,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_correlationIdIsToo STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_errorTypeIsTooLong) { @@ -3668,6 +3819,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_errorTypeIsTooLong STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_statusCodeIsTooLong) { @@ -3689,6 +3843,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_statusCodeIsTooLon STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_descriptionIsTooLong) { @@ -3710,6 +3867,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_descriptionIsTooLo STATUS status = parseSignalingMessage((PCHAR) jsonMessage.c_str(), jsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } @@ -3719,6 +3879,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_emptyJson) { STATUS status = parseSignalingMessage((PCHAR) emptyJsonMessage.c_str(), emptyJsonMessage.length(), &receivedMessage); EXPECT_EQ(STATUS_INVALID_API_CALL_RETURN_JSON, status); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_ignoreExtraFields) { @@ -3742,6 +3905,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_ignoreExtraFields) EXPECT_STREQ("Hello", receivedMessage.signalingMessage.payload); EXPECT_EQ(5, receivedMessage.signalingMessage.payloadLen); EXPECT_EQ(SIGNALING_MESSAGE_TYPE_OFFER, receivedMessage.signalingMessage.messageType); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_InvalidJson) { @@ -3761,6 +3927,9 @@ TEST_F(SignalingApiFunctionalityTest, SignalingMessageParsing_InvalidJson) { EXPECT_STREQ("", receivedMessage.signalingMessage.payload); EXPECT_EQ(0, receivedMessage.signalingMessage.payloadLen); EXPECT_EQ(SIGNALING_MESSAGE_TYPE_UNKNOWN, receivedMessage.signalingMessage.messageType); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(receivedMessage.signalingMessage.payload); +#endif } } // namespace webrtcclient diff --git a/tst/SignalingApiTest.cpp b/tst/SignalingApiTest.cpp index c6d687240f..71864005dc 100644 --- a/tst/SignalingApiTest.cpp +++ b/tst/SignalingApiTest.cpp @@ -208,6 +208,10 @@ TEST_F(SignalingApiTest, signalingSendMessageSync) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -238,6 +242,10 @@ TEST_F(SignalingApiTest, signalingSendMessageSync) signalingMessage.correlationId[0] = '\0'; EXPECT_EQ(expectedStatus, signalingClientSendMessageSync(mSignalingClientHandle, &signalingMessage)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif + deinitializeSignalingClient(); //wait for threads of threadpool to close THREAD_SLEEP(100 * HUNDREDS_OF_NANOS_IN_A_MILLISECOND); @@ -273,6 +281,10 @@ TEST_F(SignalingApiTest, signalingSendMessageSyncFileCredsProvider) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -293,6 +305,10 @@ TEST_F(SignalingApiTest, signalingSendMessageSyncFileCredsProvider) signalingMessage.correlationId[0] = '\0'; EXPECT_EQ(STATUS_SUCCESS, signalingClientSendMessageSync(mSignalingClientHandle, &signalingMessage)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif + deinitializeSignalingClient(); EXPECT_EQ(STATUS_SUCCESS, freeFileCredentialProvider(&pAwsCredentialProvider)); @@ -339,12 +355,20 @@ TEST_F(SignalingApiTest, signalingClientDeleteSync) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; signalingMessage.correlationId[0] = '\0'; EXPECT_EQ(expectedStatus, signalingClientSendMessageSync(mSignalingClientHandle, &signalingMessage)); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif + deinitializeSignalingClient(); //wait for threads of threadpool to close THREAD_SLEEP(100 * HUNDREDS_OF_NANOS_IN_A_MILLISECOND); @@ -501,6 +525,10 @@ TEST_F(SignalingApiTest, signalingClientGetMetrics) signalingMessage.version = SIGNALING_MESSAGE_CURRENT_VERSION; signalingMessage.messageType = SIGNALING_MESSAGE_TYPE_OFFER; STRCPY(signalingMessage.peerClientId, TEST_SIGNALING_MASTER_CLIENT_ID); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + signalingMessage.payload = (PCHAR) MEMALLOC(MAX_SIGNALING_MESSAGE_LEN + 1); + EXPECT_TRUE(signalingMessage.payload != NULL); +#endif MEMSET(signalingMessage.payload, 'A', 100); signalingMessage.payload[100] = '\0'; signalingMessage.payloadLen = 0; @@ -538,6 +566,10 @@ TEST_F(SignalingApiTest, signalingClientGetMetrics) EXPECT_NE(0, metrics.signalingClientStats.cpApiCallLatency); EXPECT_NE(0, metrics.signalingClientStats.dpApiCallLatency); +#ifdef DYNAMIC_SIGNALING_PAYLOAD + SAFE_MEMFREE(signalingMessage.payload); +#endif + deinitializeSignalingClient(); }