Refactor Signaling sources to make Include_i.h independent of libwebsockets

 - This way, one could write a new CMakeLists.txt, with ApiCalls using different websocket implementation
 - One should simply remove existing Signaling.c and LwsApiCalls.c from compilation and add their own

Author: vikramdattu

src/source/Include_i.h

@@ -52,8 +52,6 @@ extern "C" {
 #define INET6 1
 #include <usrsctp.h>
 
-#include <libwebsockets.h>
-
 #if !defined __WINDOWS_BUILD__
 #include <signal.h>
 #include <sys/types.h>
@@ -65,6 +63,7 @@ extern "C" {
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <netinet/tcp.h>
+#include <poll.h>
 #endif
 
 // Max uFrag and uPwd length as documented in https://tools.ietf.org/html/rfc5245#section-15.4

src/source/Signaling/LwsApiCalls.c

@@ -3,6 +3,11 @@
  */
 #define LOG_CLASS "LwsApiCalls"
 #include "../Include_i.h"
+
+#include <libwebsockets.h>
+#include "Signaling.h"
+#include "LwsApiCalls.h"
+
 #define WEBRTC_SCHEME_NAME "webrtc"
 
 static BOOL gInterruptedFlagBySignalHandler;
@@ -12,7 +17,7 @@ VOID lwsSignalHandler(INT32 signal)
     gInterruptedFlagBySignalHandler = TRUE;
 }
 
-INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason, PVOID user, PVOID pDataIn, size_t dataSize)
+INT32 lwsHttpCallbackRoutine(PVOID wsi, INT32 reason, PVOID user, PVOID pDataIn, size_t dataSize)
 {
     UNUSED_PARAM(user);
     STATUS retStatus = STATUS_SUCCESS;
@@ -53,12 +58,12 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
             CHK(FALSE, retStatus);
     }
 
-    customData = lws_get_opaque_user_data(wsi);
+    customData = lws_get_opaque_user_data((struct lws*) wsi);
     pLwsCallInfo = (PLwsCallInfo) customData;
 
     CHK_STATUS(configureLwsLogging(loggerGetLogLevel()));
 
-    CHK(pLwsCallInfo != NULL && pLwsCallInfo->pSignalingClient != NULL && pLwsCallInfo->pSignalingClient->pLwsContext != NULL &&
+    CHK(pLwsCallInfo != NULL && pLwsCallInfo->pSignalingClient != NULL && pLwsCallInfo->pSignalingClient->pWebsocketContext != NULL &&
             pLwsCallInfo->callInfo.pRequestInfo != NULL && pLwsCallInfo->protocolIndex == PROTOCOL_INDEX_HTTPS,
         retStatus);
 
@@ -98,13 +103,13 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
             break;
 
         case LWS_CALLBACK_ESTABLISHED_CLIENT_HTTP:
-            status = lws_http_client_http_response(wsi);
+            status = lws_http_client_http_response((struct lws*) wsi);
             getStateMachineCurrentState(pSignalingClient->pStateMachine, &pStateMachineState);
 
             DLOGD("Connected with server response: %d", status);
             pLwsCallInfo->callInfo.callResult = getServiceCallResultFromHttpStatus((UINT32) status);
 
-            len = (SIZE_T) lws_hdr_copy(wsi, &dateHdrBuffer[0], MAX_DATE_HEADER_BUFFER_LENGTH, WSI_TOKEN_HTTP_DATE);
+            len = (SIZE_T) lws_hdr_copy((struct lws*) wsi, &dateHdrBuffer[0], MAX_DATE_HEADER_BUFFER_LENGTH, WSI_TOKEN_HTTP_DATE);
 
             time(&td);
 
@@ -141,7 +146,7 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
             }
 
             // Store the Request ID header
-            if ((size = lws_hdr_custom_copy(wsi, pBuffer, LWS_SCRATCH_BUFFER_SIZE, SIGNALING_REQUEST_ID_HEADER_NAME,
+            if ((size = lws_hdr_custom_copy((struct lws*) wsi, pBuffer, LWS_SCRATCH_BUFFER_SIZE, SIGNALING_REQUEST_ID_HEADER_NAME,
                                             (SIZEOF(SIGNALING_REQUEST_ID_HEADER_NAME) - 1) * SIZEOF(CHAR))) > 0) {
                 pBuffer[size] = '\0';
                 DLOGI("Request ID: %s", pBuffer);
@@ -182,7 +187,7 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
             DLOGD("Received client http");
             size = LWS_SCRATCH_BUFFER_SIZE;
 
-            if (lws_http_client_read(wsi, &pBuffer, &size) < 0) {
+            if (lws_http_client_read((struct lws*) wsi, &pBuffer, &size) < 0) {
                 retValue = -1;
             }
 
@@ -217,8 +222,8 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
 
                 DLOGV("Appending header - %s %s", pRequestHeader->pName, pRequestHeader->pValue);
 
-                status = lws_add_http_header_by_name(wsi, (PBYTE) pRequestHeader->pName, (PBYTE) pRequestHeader->pValue, pRequestHeader->valueLen,
-                                                     ppStartPtr, pEndPtr);
+                status = lws_add_http_header_by_name((struct lws*) wsi, (PBYTE) pRequestHeader->pName, (PBYTE) pRequestHeader->pValue,
+                                                     pRequestHeader->valueLen, ppStartPtr, pEndPtr);
                 if (status != 0) {
                     retValue = 1;
                     CHK(FALSE, retStatus);
@@ -232,29 +237,29 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
                 headerCount--;
             }
 
-            lws_client_http_body_pending(wsi, 1);
-            lws_callback_on_writable(wsi);
+            lws_client_http_body_pending((struct lws*) wsi, 1);
+            lws_callback_on_writable((struct lws*) wsi);
 
             break;
 
         case LWS_CALLBACK_CLIENT_HTTP_WRITEABLE:
             DLOGD("Sending the body %.*s, size %d", pRequestInfo->bodySize, pRequestInfo->body, pRequestInfo->bodySize);
             MEMCPY(pBuffer, pRequestInfo->body, pRequestInfo->bodySize);
 
-            size = lws_write(wsi, (PBYTE) pBuffer, (SIZE_T) pRequestInfo->bodySize, LWS_WRITE_TEXT);
+            size = lws_write((struct lws*) wsi, (PBYTE) pBuffer, (SIZE_T) pRequestInfo->bodySize, LWS_WRITE_TEXT);
 
             if (size != (INT32) pRequestInfo->bodySize) {
                 DLOGW("Failed to write out the body of POST request entirely. Expected to write %d, wrote %d", pRequestInfo->bodySize, size);
                 if (size > 0) {
                     // Schedule again
-                    lws_client_http_body_pending(wsi, 1);
-                    lws_callback_on_writable(wsi);
+                    lws_client_http_body_pending((struct lws*) wsi, 1);
+                    lws_callback_on_writable((struct lws*) wsi);
                 } else {
                     // Quit
                     retValue = 1;
                 }
             } else {
-                lws_client_http_body_pending(wsi, 0);
+                lws_client_http_body_pending((struct lws*) wsi, 0);
             }
 
             break;
@@ -271,7 +276,7 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
             ATOMIC_STORE_BOOL(&pRequestInfo->terminating, TRUE);
         }
 
-        lws_cancel_service(lws_get_context(wsi));
+        lws_cancel_service(lws_get_context((struct lws*) wsi));
 
         retValue = -1;
     }
@@ -283,7 +288,7 @@ INT32 lwsHttpCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason,
     return retValue;
 }
 
-INT32 lwsWssCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason, PVOID user, PVOID pDataIn, size_t dataSize)
+INT32 lwsWssCallbackRoutine(PVOID wsi, INT32 reason, PVOID user, PVOID pDataIn, size_t dataSize)
 {
     UNUSED_PARAM(user);
     STATUS retStatus = STATUS_SUCCESS;
@@ -312,14 +317,14 @@ INT32 lwsWssCallbackRoutine(struct lws* wsi, enum lws_callback_reasons reason, P
             CHK(FALSE, retStatus);
     }
 
-    customData = lws_get_opaque_user_data(wsi);
+    customData = lws_get_opaque_user_data((struct lws*) wsi);
     pLwsCallInfo = (PLwsCallInfo) customData;
 
     CHK_STATUS(configureLwsLogging(loggerGetLogLevel()));
 
     CHK(pLwsCallInfo != NULL && pLwsCallInfo->pSignalingClient != NULL && pLwsCallInfo->pSignalingClient->pOngoingCallInfo != NULL &&
-            pLwsCallInfo->pSignalingClient->pLwsContext != NULL && pLwsCallInfo->pSignalingClient->pOngoingCallInfo->callInfo.pRequestInfo != NULL &&
-            pLwsCallInfo->protocolIndex == PROTOCOL_INDEX_WSS,
+            pLwsCallInfo->pSignalingClient->pWebsocketContext != NULL &&
+            pLwsCallInfo->pSignalingClient->pOngoingCallInfo->callInfo.pRequestInfo != NULL && pLwsCallInfo->protocolIndex == PROTOCOL_INDEX_WSS,
         retStatus);
     pSignalingClient = pLwsCallInfo->pSignalingClient;
     pLwsCallInfo = pSignalingClient->pOngoingCallInfo;
@@ -564,7 +569,7 @@ STATUS lwsCompleteSync(PLwsCallInfo pCallInfo)
         CHK_STATUS(removeRequestHeader(pCallInfo->callInfo.pRequestInfo, AWS_SIG_V4_HEADER_HOST));
     }
 
-    pContext = pCallInfo->pSignalingClient->pLwsContext;
+    pContext = (struct lws_context*) pCallInfo->pSignalingClient->pWebsocketContext;
 
     // Execute the LWS REST call
     MEMSET(&connectInfo, 0x00, SIZEOF(struct lws_client_connect_info));
@@ -596,7 +601,7 @@ STATUS lwsCompleteSync(PLwsCallInfo pCallInfo)
     connectInfo.path = path;
     connectInfo.host = connectInfo.address;
     connectInfo.method = pVerb;
-    connectInfo.protocol = pCallInfo->pSignalingClient->signalingProtocols[pCallInfo->protocolIndex].name;
+    connectInfo.protocol = ((struct lws_protocols*) pCallInfo->pSignalingClient->signalingProtocols[pCallInfo->protocolIndex])->name;
     connectInfo.pwsi = &clientLws;
 
     connectInfo.opaque_user_data = pCallInfo;
@@ -2413,7 +2418,7 @@ STATUS wakeLwsServiceEventLoop(PSignalingClient pSignalingClient, UINT32 protoco
     STATUS retStatus = STATUS_SUCCESS;
 
     // Early exit in case we don't need to do anything
-    CHK(pSignalingClient != NULL && pSignalingClient->pLwsContext != NULL, retStatus);
+    CHK(pSignalingClient != NULL && pSignalingClient->pWebsocketContext != NULL, retStatus);
 
     if (pSignalingClient->currentWsi[protocolIndex] != NULL) {
         lws_callback_on_writable(pSignalingClient->currentWsi[protocolIndex]);

src/source/Signaling/LwsApiCalls.h

@@ -167,11 +167,14 @@ extern "C" {
 // Encoded max ice server infos string len
 #define MAX_ENCODED_ICE_SERVER_INFOS_STR_LEN (MAX_ICE_SERVER_INFOS_STR_LEN + ICE_SERVER_INFO_TEMPLATE_BLOAT_SIZE)
 
+// Alignment bytes for libwebsockets (Internally, it might end up using lesser than 16)
+#define LWS_ALIGN_BYTES 16
+
 // Scratch buffer size
-#define LWS_SCRATCH_BUFFER_SIZE (MAX_JSON_PARAMETER_STRING_LEN + LWS_PRE)
+#define LWS_SCRATCH_BUFFER_SIZE (MAX_JSON_PARAMETER_STRING_LEN + LWS_ALIGN_BYTES)
 
 // Send and receive buffer size
-#define LWS_MESSAGE_BUFFER_SIZE (SIZEOF(CHAR) * (MAX_SIGNALING_MESSAGE_LEN + LWS_PRE))
+#define LWS_MESSAGE_BUFFER_SIZE (SIZEOF(CHAR) * (MAX_SIGNALING_MESSAGE_LEN + LWS_ALIGN_BYTES))
 
 #define AWS_SIG_V4_HEADER_HOST (PCHAR) "host"
 
@@ -251,8 +254,8 @@ PVOID lwsListenerHandler(PVOID);
 PVOID reconnectHandler(PVOID);
 
 // LWS callback routine
-INT32 lwsHttpCallbackRoutine(struct lws*, enum lws_callback_reasons, PVOID, PVOID, size_t);
-INT32 lwsWssCallbackRoutine(struct lws*, enum lws_callback_reasons, PVOID, PVOID, size_t);
+INT32 lwsHttpCallbackRoutine(PVOID, INT32, PVOID, PVOID, size_t);
+INT32 lwsWssCallbackRoutine(PVOID, INT32, PVOID, PVOID, size_t);
 
 BOOL isCallResultSignatureExpired(PCallInfo);
 BOOL isCallResultSignatureNotYetCurrent(PCallInfo);

src/source/Signaling/Signaling.c

@@ -1,5 +1,7 @@
 #define LOG_CLASS "Signaling"
 #include "../Include_i.h"
+#include <libwebsockets.h>
+#include "LwsApiCalls.h"
 
 extern StateMachineState SIGNALING_STATE_MACHINE_STATES[];
 extern UINT32 SIGNALING_STATE_MACHINE_STATE_COUNT;
@@ -21,6 +23,8 @@ STATUS createSignalingSync(PSignalingClientInfoInternal pClientInfo, PChannelInf
     BOOL cacheFound = FALSE;
     PSignalingFileCacheEntry pFileCacheEntry = NULL;
 
+    struct lws_protocols* pProtocols = NULL;
+
     CHK(pClientInfo != NULL && pChannelInfo != NULL && pCallbacks != NULL && pCredentialProvider != NULL && ppSignalingClient != NULL,
         STATUS_NULL_ARG);
     CHK(pChannelInfo->version <= CHANNEL_INFO_CURRENT_VERSION, STATUS_SIGNALING_INVALID_CHANNEL_INFO_VERSION);
@@ -33,6 +37,14 @@ STATUS createSignalingSync(PSignalingClientInfoInternal pClientInfo, PChannelInf
     CHK_STATUS(initializeThreadTracker(&pSignalingClient->listenerTracker));
     CHK_STATUS(initializeThreadTracker(&pSignalingClient->reconnecterTracker));
 
+    // Allocate memory for the protocols array (+ 1 for the null terminator protocol)
+    pProtocols = (struct lws_protocols*) MEMCALLOC(LWS_PROTOCOL_COUNT + 1, SIZEOF(struct lws_protocols));
+    CHK(pProtocols != NULL, STATUS_NOT_ENOUGH_MEMORY);
+
+    // Store the protocols pointer in the signalingProtocols array
+    pSignalingClient->signalingProtocols[PROTOCOL_INDEX_HTTPS] = pProtocols;
+    pSignalingClient->signalingProtocols[PROTOCOL_INDEX_WSS] = &pProtocols[PROTOCOL_INDEX_WSS];
+
     // Validate and store the input
     CHK_STATUS(createValidateChannelInfo(pChannelInfo, &pSignalingClient->pChannelInfo));
     CHK_STATUS(validateSignalingCallbacks(pSignalingClient, pCallbacks));
@@ -93,18 +105,19 @@ STATUS createSignalingSync(PSignalingClientInfoInternal pClientInfo, PChannelInf
                                           &pSignalingClient->pStateMachine));
 
     // Prepare the signaling channel protocols array
-    pSignalingClient->signalingProtocols[PROTOCOL_INDEX_HTTPS].name = HTTPS_SCHEME_NAME;
-    pSignalingClient->signalingProtocols[PROTOCOL_INDEX_HTTPS].callback = lwsHttpCallbackRoutine;
-    pSignalingClient->signalingProtocols[PROTOCOL_INDEX_WSS].name = WSS_SCHEME_NAME;
-    pSignalingClient->signalingProtocols[PROTOCOL_INDEX_WSS].callback = lwsWssCallbackRoutine;
+    pProtocols = (struct lws_protocols*) pSignalingClient->signalingProtocols[PROTOCOL_INDEX_HTTPS];
+    pProtocols[PROTOCOL_INDEX_HTTPS].name = HTTPS_SCHEME_NAME;
+    pProtocols[PROTOCOL_INDEX_HTTPS].callback = (lws_callback_function*) lwsHttpCallbackRoutine;
+    pProtocols[PROTOCOL_INDEX_WSS].name = WSS_SCHEME_NAME;
+    pProtocols[PROTOCOL_INDEX_WSS].callback = (lws_callback_function*) lwsWssCallbackRoutine;
 
     pSignalingClient->currentWsi[PROTOCOL_INDEX_HTTPS] = NULL;
     pSignalingClient->currentWsi[PROTOCOL_INDEX_WSS] = NULL;
 
     MEMSET(&creationInfo, 0x00, SIZEOF(struct lws_context_creation_info));
     creationInfo.options = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
     creationInfo.port = CONTEXT_PORT_NO_LISTEN;
-    creationInfo.protocols = pSignalingClient->signalingProtocols;
+    creationInfo.protocols = pProtocols;
     creationInfo.timeout_secs = SIGNALING_SERVICE_API_CALL_TIMEOUT_IN_SECONDS;
     creationInfo.gid = -1;
     creationInfo.uid = -1;
@@ -165,8 +178,8 @@ STATUS createSignalingSync(PSignalingClientInfoInternal pClientInfo, PChannelInf
 
     CHK_STATUS(configureLwsLogging(loggerGetLogLevel()));
 
-    pSignalingClient->pLwsContext = lws_create_context(&creationInfo);
-    CHK(pSignalingClient->pLwsContext != NULL, STATUS_SIGNALING_LWS_CREATE_CONTEXT_FAILED);
+    pSignalingClient->pWebsocketContext = lws_create_context(&creationInfo);
+    CHK(pSignalingClient->pWebsocketContext != NULL, STATUS_SIGNALING_LWS_CREATE_CONTEXT_FAILED);
 
     // Initializing the diagnostics mostly is taken care of by zero-mem in MEMCALLOC
     pSignalingClient->diagnostics.createTime = SIGNALING_GET_CURRENT_TIME(pSignalingClient);
@@ -223,13 +236,16 @@ STATUS freeSignaling(PSignalingClient* ppSignalingClient)
 
     terminateOngoingOperations(pSignalingClient);
 
-    if (pSignalingClient->pLwsContext != NULL) {
+    if (pSignalingClient->pWebsocketContext != NULL) {
         MUTEX_LOCK(pSignalingClient->lwsServiceLock);
-        lws_context_destroy(pSignalingClient->pLwsContext);
-        pSignalingClient->pLwsContext = NULL;
+        lws_context_destroy((struct lws_context*) pSignalingClient->pWebsocketContext);
+        pSignalingClient->pWebsocketContext = NULL;
         MUTEX_UNLOCK(pSignalingClient->lwsServiceLock);
     }
 
+    // Frees up the entire structure., both HTTPS and WSS protocols (it was allocated as single block)
+    SAFE_MEMFREE(pSignalingClient->signalingProtocols[PROTOCOL_INDEX_HTTPS]);
+
     freeStateMachine(pSignalingClient->pStateMachine);
 
     freeClientRetryStrategy(pSignalingClient);

src/source/Signaling/Signaling.h

@@ -337,14 +337,15 @@ typedef struct {
     // Restarted thread handler
     ThreadTracker reconnecterTracker;
 
-    // LWS context to use for Restful API
-    struct lws_context* pLwsContext;
+    // Generic websocket context - can be used by any implementation
+    PVOID pWebsocketContext;
 
-    // Signaling protocols - one more for the NULL terminator protocol
-    struct lws_protocols signalingProtocols[LWS_PROTOCOL_COUNT + 1];
+    // Generic websocket protocols array - can be used by any implementation
+    // + 1 for the null terminator protocol
+    PVOID signalingProtocols[LWS_PROTOCOL_COUNT + 1];
 
-    // Stored wsi objects
-    struct lws* currentWsi[LWS_PROTOCOL_COUNT];
+    // Generic websocket connection objects - can be used by any implementation
+    PVOID currentWsi[LWS_PROTOCOL_COUNT];
 
     // List of the ongoing messages
     PStackQueue pMessageQueue;