Endpoint flexibilty

CMake/Dependencies/libkvspic-CMakeLists.txt

@@ -7,7 +7,7 @@ include(ExternalProject)
 # clone repo only
 ExternalProject_Add(libkvspic-download
 	GIT_REPOSITORY    https://github.com/awslabs/amazon-kinesis-video-streams-pic.git
-	GIT_TAG           develop
+	GIT_TAG           ip_versions_clientinfo
    	SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/kvspic-src"
 	BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/kvspic-build"
 	CMAKE_ARGS

samples/KvsAudioVideoStreamingSample.c

@@ -286,6 +286,7 @@ INT32 main(INT32 argc, CHAR* argv[])
     CHK_STATUS(createDefaultDeviceInfo(&pDeviceInfo));
     // adjust members of pDeviceInfo here if needed
     pDeviceInfo->clientInfo.loggerLogLevel = LOG_LEVEL_DEBUG;
+    pDeviceInfo->clientInfo.dualStackEnabled = TRUE;
 
     // generate audio cpd
     if (!STRCMP(audioCodec, AUDIO_CODEC_NAME_ALAW)) {
@@ -328,8 +329,8 @@ INT32 main(INT32 argc, CHAR* argv[])
     CHK_STATUS(createDefaultCallbacksProviderWithIotCertificate(pIotCoreCredentialEndpoint, pIotCoreCert, pIotCorePrivateKey, cacertPath,
                                                                 pIotCoreRoleAlias, pIotCoreThingName, region, NULL, NULL, &pClientCallbacks));
 #else
-    CHK_STATUS(createDefaultCallbacksProviderWithAwsCredentials(accessKey, secretKey, sessionToken, MAX_UINT64, region, cacertPath, NULL, NULL,
-                                                                &pClientCallbacks));
+    CHK_STATUS(createDualStackCallbacksProviderWithAwsCredentials(accessKey, secretKey, sessionToken, MAX_UINT64, region, cacertPath, NULL, NULL,
+                                                                pDeviceInfo->clientInfo.dualStackEnabled, &pClientCallbacks));
 #endif
 
     if (NULL != GETENV(ENABLE_FILE_LOGGING)) {

src/include/com/amazonaws/kinesis/video/common/Include.h

@@ -327,6 +327,14 @@ extern "C" {
 
 #define CONTROL_PLANE_URI_POSTFIX_ISO_B ".sc2s.sgov.gov"
 
+#define CONTROL_PLANE_URI_POSTFIX_DUAL_STACK ".api.aws"
+
+#define CONTROL_PLANE_URI_POSTFIX_CN_DUAL_STACK ".api.amazonwebservices.com.cn"
+
+#define CONTROL_PLANE_URI_POSTFIX_ISO_DUAL_STACK ".api.aws.ic.gov"
+
+#define CONTROL_PLANE_URI_POSTFIX_ISO_B_DUAL_STACK ".api.aws.scloud"
+
 #define AWS_ISO_B_REGION_PREFIX "us-isob-"
 
 #define AWS_ISO_REGION_PREFIX "us-iso-"
@@ -512,6 +520,7 @@ struct __RequestInfo {
     UINT64 lowSpeedTimeLimit;                 //!< Low-time limit
     PAwsCredentials pAwsCredentials;          //!< AWS Credentials
     PSingleList pRequestHeaders;              //!< Request headers
+    BOOL dualStackEnabled;
 };
 typedef struct __RequestInfo* PRequestInfo;
 

src/include/com/amazonaws/kinesis/video/cproducer/Include.h

@@ -321,6 +321,28 @@ typedef enum {
  */
 PUBLIC_API STATUS createDefaultCallbacksProviderWithAwsCredentials(PCHAR, PCHAR, PCHAR, UINT64, PCHAR, PCHAR, PCHAR, PCHAR, PClientCallbacks*);
 
+/**
+ * Creates a default callbacks provider based on static AWS credentials
+ *
+ * NOTE: The caller is responsible for releasing the structure by calling
+ * the corresponding {@link freeCallbackProvider} API.
+ *
+ * @param[in] PCHAR Access Key Id
+ * @param[in] PCHAR Secret Key
+ * @param[in,opt] PCHAR Session Token
+ * @param[in] UINT64 Expiration of the token. MAX_UINT64 if non-expiring
+ * @param[in,opt] PCHAR AWS region
+ * @param[in,opt] PCHAR CA Cert Path
+ * @param[in,opt] PCHAR User agent name (Use NULL)
+ * @param[in,out] PCHAR Custom user agent to be used in the API calls
+ * @param[in] BOOL set to true for using dualstack endpoints
+ * @param[out] PClientCallbacks* Returned pointer to callbacks provider
+ *
+ * @return STATUS code of the execution
+ */
+PUBLIC_API STATUS createDualStackCallbacksProviderWithAwsCredentials(PCHAR, PCHAR, PCHAR, UINT64, PCHAR, PCHAR, PCHAR, PCHAR, BOOL, PClientCallbacks*);
+
+
 /**
  * Creates a default callbacks provider that uses iot certificate as auth method.
  *
@@ -880,6 +902,24 @@ PUBLIC_API STATUS freeContinuousRetryStreamCallbacks(PStreamCallbacks*);
  */
 PUBLIC_API STATUS createAbstractDefaultCallbacksProvider(UINT32, API_CALL_CACHE_TYPE, UINT64, PCHAR, PCHAR, PCHAR, PCHAR, PCHAR, PClientCallbacks*);
 
+/**
+ * Create abstract callback provider that can hook with other callbacks
+ *
+ * @param[in] UINT32 Length of callback provider calling chain
+ * @param[in] API_CALL_CACHE_TYPE Backend API call caching mode
+ * @param[in] UINT64 Cached endpoint update period
+ * @param[in,opt] PCHAR AWS region
+ * @param[in] PCHAR Specific Control Plane Uri as endpoint to be called
+ * @param[in,opt] PCHAR CA Cert path
+ * @param[in,opt] PCHAR User agent name (Use NULL)
+ * @param[in,opt] PCHAR Custom user agent to be used in the API calls
+ * @param[in] BOOL set to true for using dualstack endpoints
+ * @param[out] PClientCallbacks* Returned pointer to callbacks provider
+ *
+ * @return STATUS code of the execution
+ */
+PUBLIC_API STATUS createAbstractDualStackCallbacksProvider(UINT32, API_CALL_CACHE_TYPE, UINT64, PCHAR, PCHAR, PCHAR, PCHAR, PCHAR, BOOL, PClientCallbacks*);
+
 /**
  * Use file logger instead of default logger which log to stdout. The underlying objects are automatically freed
  * when PClientCallbacks is freed.

src/source/CallbacksProvider.c

@@ -66,16 +66,25 @@ STATUS createDefaultCallbacksProvider(UINT32 callbackChainCount, PCHAR accessKey
 STATUS createDefaultCallbacksProviderWithAwsCredentials(PCHAR accessKeyId, PCHAR secretKey, PCHAR sessionToken, UINT64 expiration, PCHAR region,
                                                         PCHAR caCertPath, PCHAR userAgentPostfix, PCHAR customUserAgent,
                                                         PClientCallbacks* ppClientCallbacks)
+{
+    // Call the dual-stack variant with isDualStack set to FALSE
+    return createDualStackCallbacksProviderWithAwsCredentials(accessKeyId, secretKey, sessionToken, expiration, region, caCertPath,
+                                                                          userAgentPostfix, customUserAgent, FALSE, ppClientCallbacks);
+}
+
+STATUS createDualStackCallbacksProviderWithAwsCredentials(PCHAR accessKeyId, PCHAR secretKey, PCHAR sessionToken, UINT64 expiration, PCHAR region,
+                                                        PCHAR caCertPath, PCHAR userAgentPostfix, PCHAR customUserAgent, BOOL isDualStack,
+                                                        PClientCallbacks* ppClientCallbacks)
 {
     ENTERS();
     STATUS retStatus = STATUS_SUCCESS;
     PCallbacksProvider pCallbacksProvider = NULL;
     PAuthCallbacks pAuthCallbacks = NULL;
     PStreamCallbacks pStreamCallbacks = NULL;
 
-    CHK_STATUS(createAbstractDefaultCallbacksProvider(DEFAULT_CALLBACK_CHAIN_COUNT, API_CALL_CACHE_TYPE_ALL, ENDPOINT_UPDATE_PERIOD_SENTINEL_VALUE,
-                                                      region, EMPTY_STRING, caCertPath, userAgentPostfix, customUserAgent, ppClientCallbacks));
-
+    CHK_STATUS(createAbstractDualStackCallbacksProvider(DEFAULT_CALLBACK_CHAIN_COUNT, API_CALL_CACHE_TYPE_ALL, ENDPOINT_UPDATE_PERIOD_SENTINEL_VALUE,
+                                                      region, EMPTY_STRING, caCertPath, userAgentPostfix, customUserAgent, isDualStack, ppClientCallbacks));
+    
     pCallbacksProvider = (PCallbacksProvider) *ppClientCallbacks;
 
     CHK_STATUS(createStaticAuthCallbacks((PClientCallbacks) pCallbacksProvider, accessKeyId, secretKey, sessionToken, expiration, &pAuthCallbacks));
@@ -289,6 +298,16 @@ STATUS createDefaultCallbacksProviderWithAuthCallbacks(PAuthCallbacks pAuthCallb
 STATUS createAbstractDefaultCallbacksProvider(UINT32 callbackChainCount, API_CALL_CACHE_TYPE cacheType, UINT64 endpointCachingPeriod, PCHAR region,
                                               PCHAR controlPlaneUrl, PCHAR certPath, PCHAR userAgentName, PCHAR customUserAgent,
                                               PClientCallbacks* ppClientCallbacks)
+{
+    // Call the dual-stack variant with isDualStack set to FALSE
+    return createAbstractDualStackCallbacksProvider(callbackChainCount, cacheType, endpointCachingPeriod, region,
+                                                                       controlPlaneUrl, certPath, userAgentName, customUserAgent,
+                                                                       FALSE, ppClientCallbacks);
+}
+
+STATUS createAbstractDualStackCallbacksProvider(UINT32 callbackChainCount, API_CALL_CACHE_TYPE cacheType, UINT64 endpointCachingPeriod, PCHAR region,
+                                              PCHAR controlPlaneUrl, PCHAR certPath, PCHAR userAgentName, PCHAR customUserAgent, BOOL isDualStack,
+                                              PClientCallbacks* ppClientCallbacks)
 {
     ENTERS();
     STATUS retStatus = STATUS_SUCCESS;
@@ -327,7 +346,7 @@ STATUS createAbstractDefaultCallbacksProvider(UINT32 callbackChainCount, API_CAL
 
     // Create the default Curl API callbacks
     CHK_STATUS(createCurlApiCallbacks(pCallbacksProvider, region, cacheType, endpointCachingPeriod, controlPlaneUrl, certPath, userAgentName,
-                                      customUserAgent, &pCurlApiCallbacks));
+                                      customUserAgent, isDualStack, &pCurlApiCallbacks));
 
 CleanUp:
 

src/source/CurlApiCallbacks.c

@@ -8,7 +8,7 @@
  * Creates CURL based API callbacks provider
  */
 STATUS createCurlApiCallbacks(PCallbacksProvider pCallbacksProvider, PCHAR region, API_CALL_CACHE_TYPE cacheType, UINT64 endpointCachingPeriod,
-                              PCHAR controlPlaneUrl, PCHAR certPath, PCHAR userAgentNamePostfix, PCHAR customUserAgent,
+                              PCHAR controlPlaneUrl, PCHAR certPath, PCHAR userAgentNamePostfix, PCHAR customUserAgent, BOOL isDualStack,
                               PCurlApiCallbacks* ppCurlApiCallbacks)
 {
     ENTERS();
@@ -79,23 +79,44 @@ STATUS createCurlApiCallbacks(PCallbacksProvider pCallbacksProvider, PCHAR regio
 
     // Set the control plane URL
     if (controlPlaneUrl == NULL || controlPlaneUrl[0] == '\0') {
-        if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_ISO_B_REGION_PREFIX, STRLEN(AWS_ISO_B_REGION_PREFIX))) {
+        if (!isDualStack) {
+            if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_ISO_B_REGION_PREFIX, STRLEN(AWS_ISO_B_REGION_PREFIX))) {
             SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
                      AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_ISO_B);
             // Region is in "aws-iso" partition
-        } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_ISO_REGION_PREFIX, STRLEN(AWS_ISO_REGION_PREFIX))) {
-            SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
-                     AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_ISO);
-        } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_GOV_CLOUD_REGION_PREFIX, STRLEN(AWS_GOV_CLOUD_REGION_PREFIX))) {
-            SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
-                     AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX);
-        } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_CN_REGION_PREFIX, STRLEN(AWS_CN_REGION_PREFIX))) {
-            SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
-                     pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_CN);
+            } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_ISO_REGION_PREFIX, STRLEN(AWS_ISO_REGION_PREFIX))) {
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_ISO);
+            } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_GOV_CLOUD_REGION_PREFIX, STRLEN(AWS_GOV_CLOUD_REGION_PREFIX))) {
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX);
+            } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_CN_REGION_PREFIX, STRLEN(AWS_CN_REGION_PREFIX))) {
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_CN);
+            } else {
+                // Create a fully qualified URI
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX);
+            }
         } else {
-            // Create a fully qualified URI
-            SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
-                     pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX);
+            if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_ISO_B_REGION_PREFIX, STRLEN(AWS_ISO_B_REGION_PREFIX))) {
+            SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                     AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_ISO_B_DUAL_STACK);
+            // Region is in "aws-iso" partition
+            } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_ISO_REGION_PREFIX, STRLEN(AWS_ISO_REGION_PREFIX))) {
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_ISO_DUAL_STACK);
+            } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_GOV_CLOUD_REGION_PREFIX, STRLEN(AWS_GOV_CLOUD_REGION_PREFIX))) {
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        AWS_KVS_FIPS_ENDPOINT_POSTFIX, pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_DUAL_STACK);
+            } else if (0 == STRNCMP(pCurlApiCallbacks->region, AWS_CN_REGION_PREFIX, STRLEN(AWS_CN_REGION_PREFIX))) {
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_CN_DUAL_STACK);
+            } else {
+                // Create a fully qualified URI
+                SNPRINTF(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, "%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME,
+                        pCurlApiCallbacks->region, CONTROL_PLANE_URI_POSTFIX_DUAL_STACK);
+            }
         }
     } else {
         STRNCPY(pCurlApiCallbacks->controlPlaneUrl, controlPlaneUrl, MAX_URI_CHAR_LEN);
@@ -973,7 +994,7 @@ STATUS createStreamCurl(UINT64 customData, PCHAR deviceName, PCHAR streamName, P
     currentTime = pCallbacksProvider->clientCallbacks.getCurrentTimeFn(pCallbacksProvider->clientCallbacks.customData);
     CHK_STATUS(createCurlRequest(HTTP_REQUEST_VERB_POST, url, paramsJson, streamHandle, pCurlApiCallbacks->region, currentTime,
                                  pServiceCallContext->connectionTimeout, pServiceCallContext->timeout, pServiceCallContext->callAfter,
-                                 pCurlApiCallbacks->certPath, pCredentials, pCurlApiCallbacks, &pCurlRequest));
+                                 pCurlApiCallbacks->certPath, pCredentials, pServiceCallContext->dualStackEnabled, pCurlApiCallbacks, &pCurlRequest));
 
     // Set the necessary headers
     CHK_STATUS(setRequestHeader(&pCurlRequest->requestInfo, (PCHAR) "user-agent", 0, pCurlApiCallbacks->userAgent, 0));
@@ -1208,7 +1229,7 @@ STATUS describeStreamCurl(UINT64 customData, PCHAR streamName, PServiceCallConte
     currentTime = pCallbacksProvider->clientCallbacks.getCurrentTimeFn(pCallbacksProvider->clientCallbacks.customData);
     CHK_STATUS(createCurlRequest(HTTP_REQUEST_VERB_POST, url, paramsJson, streamHandle, pCurlApiCallbacks->region, currentTime,
                                  pServiceCallContext->connectionTimeout, pServiceCallContext->timeout, pServiceCallContext->callAfter,
-                                 pCurlApiCallbacks->certPath, pCredentials, pCurlApiCallbacks, &pCurlRequest));
+                                 pCurlApiCallbacks->certPath, pCredentials, pServiceCallContext->dualStackEnabled, pCurlApiCallbacks, &pCurlRequest));
 
     // Set the necessary headers
     CHK_STATUS(setRequestHeader(&pCurlRequest->requestInfo, (PCHAR) "user-agent", 0, pCurlApiCallbacks->userAgent, 0));
@@ -1521,7 +1542,7 @@ STATUS getStreamingEndpointCurl(UINT64 customData, PCHAR streamName, PCHAR apiNa
     currentTime = pCallbacksProvider->clientCallbacks.getCurrentTimeFn(pCallbacksProvider->clientCallbacks.customData);
     CHK_STATUS(createCurlRequest(HTTP_REQUEST_VERB_POST, url, paramsJson, streamHandle, pCurlApiCallbacks->region, currentTime,
                                  pServiceCallContext->connectionTimeout, pServiceCallContext->timeout, pServiceCallContext->callAfter,
-                                 pCurlApiCallbacks->certPath, pCredentials, pCurlApiCallbacks, &pCurlRequest));
+                                 pCurlApiCallbacks->certPath, pCredentials, pServiceCallContext->dualStackEnabled, pCurlApiCallbacks, &pCurlRequest));
 
     // Set the necessary headers
     CHK_STATUS(setRequestHeader(&pCurlRequest->requestInfo, (PCHAR) "user-agent", 0, pCurlApiCallbacks->userAgent, 0));
@@ -1853,7 +1874,7 @@ STATUS tagResourceCurl(UINT64 customData, PCHAR streamArn, UINT32 tagCount, PTag
     currentTime = pCallbacksProvider->clientCallbacks.getCurrentTimeFn(pCallbacksProvider->clientCallbacks.customData);
     CHK_STATUS(createCurlRequest(HTTP_REQUEST_VERB_POST, url, paramsJson, streamHandle, pCurlApiCallbacks->region, currentTime,
                                  pServiceCallContext->connectionTimeout, pServiceCallContext->timeout, pServiceCallContext->callAfter,
-                                 pCurlApiCallbacks->certPath, pCredentials, pCurlApiCallbacks, &pCurlRequest));
+                                 pCurlApiCallbacks->certPath, pCredentials, pServiceCallContext->dualStackEnabled, pCurlApiCallbacks, &pCurlRequest));
 
     // Set the necessary headers
     CHK_STATUS(setRequestHeader(&pCurlRequest->requestInfo, (PCHAR) "user-agent", 0, pCurlApiCallbacks->userAgent, 0));
@@ -2069,7 +2090,7 @@ STATUS putStreamCurl(UINT64 customData, PCHAR streamName, PCHAR containerType, U
     currentTime = pCallbacksProvider->clientCallbacks.getCurrentTimeFn(pCallbacksProvider->clientCallbacks.customData);
     CHK_STATUS(createCurlRequest(HTTP_REQUEST_VERB_POST, url, NULL, (STREAM_HANDLE) pServiceCallContext->customData, pCurlApiCallbacks->region,
                                  currentTime, pServiceCallContext->connectionTimeout, pServiceCallContext->timeout, pServiceCallContext->callAfter,
-                                 pCurlApiCallbacks->certPath, pCredentials, pCurlApiCallbacks, &pCurlRequest));
+                                 pCurlApiCallbacks->certPath, pCredentials, pServiceCallContext->dualStackEnabled, pCurlApiCallbacks, &pCurlRequest));
 
     // Set the necessary headers
     CHK_STATUS(setRequestHeader(&pCurlRequest->requestInfo, (PCHAR) "user-agent", 0, pCurlApiCallbacks->userAgent, 0));