Dual-stack support for KVS

Author: sirknightj

.github/workflows/ci.yml

@@ -471,11 +471,28 @@ jobs:
           cd build
           ./tst/producer_test --gtest_filter="ProducerClientBasicTest.*"
           TEST_EXIT_CODE=$?
-          
+
           # 128 (abnormal exit) + 11 (segmentation fault) = 139
           if [ $TEST_EXIT_CODE -ne 139 ]; then
             echo "Unexpected exit code: $TEST_EXIT_CODE"
             exit 1
           fi
           echo "Test exited as expected with code $TEST_EXIT_CODE."
         shell: bash
+
+  cmake-flags-test:
+    runs-on: ubuntu-22.04
+    container: public.ecr.aws/ubuntu/ubuntu:22.04_stable
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          apt-get update
+          apt-get install -y git cmake build-essential pkg-config libssl-dev libcurl4-openssl-dev
+
+      - name: Run CMake Flag Combination Test
+        run: |
+          ./tst/scripts/test_cmake_flags.sh >> $GITHUB_STEP_SUMMARY

CMakeLists.txt

@@ -23,6 +23,15 @@ option(BUILD_OPENSSL_PLATFORM "If buildng OpenSSL what is the target platform" O
 option(LOCAL_OPENSSL_BUILD "Whether or not to use local OpenSSL build" OFF)
 option(CONSTRAINED_DEVICE "Change pthread stack size" OFF)
 
+# Endpoint selection - mutually exclusive
+option(AWS_KVS_USE_LEGACY_ENDPOINT_ONLY "Use only legacy IPv4-only endpoints (ignores env vars)" OFF)
+option(AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY "Use only dual-stack endpoints (ignores env vars)" OFF)
+
+# DNS IP resolution modes - mutually exclusive
+option(AWS_KVS_IPV4_ONLY "Use only IPv4 addresses from DNS (ignores env vars)" OFF)
+option(AWS_KVS_IPV6_ONLY "Use only IPv6 addresses from DNS (ignores env vars)" OFF)
+option(AWS_KVS_DUAL_STACK_ONLY "Use both IPv4 and IPv6 addresses from DNS (ignores env vars)" OFF)
+
 # Developer Flags
 option(BUILD_TEST "Build the testing tree." OFF)
 option(CODE_COVERAGE "Enable coverage reporting" OFF)
@@ -64,6 +73,58 @@ if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
 endif()
 
+# Validate mutually exclusive endpoint options
+if(AWS_KVS_USE_LEGACY_ENDPOINT_ONLY AND AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY)
+    message(FATAL_ERROR "Cannot enable both AWS_KVS_USE_LEGACY_ENDPOINT_ONLY and AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY at the same time.")
+endif()
+
+# Validate mutually exclusive IP resolution options
+set(IPV4_ONLY_FLAG 0)
+set(IPV6_ONLY_FLAG 0)
+set(DUAL_STACK_ONLY_FLAG 0)
+
+if(AWS_KVS_IPV4_ONLY)
+    set(IPV4_ONLY_FLAG 1)
+endif()
+
+if(AWS_KVS_IPV6_ONLY)
+    set(IPV6_ONLY_FLAG 1)
+endif()
+
+if(AWS_KVS_DUAL_STACK_ONLY)
+    set(DUAL_STACK_ONLY_FLAG 1)
+endif()
+
+# Sum the enabled flags
+math(EXPR IPV_OPTIONS_ENABLED_COUNT
+        "${IPV4_ONLY_FLAG}+${IPV6_ONLY_FLAG}+${DUAL_STACK_ONLY_FLAG}")
+
+# Check for conflicts
+if(IPV_OPTIONS_ENABLED_COUNT GREATER 1)
+    message(FATAL_ERROR "Only one of AWS_KVS_IPV4_ONLY, AWS_KVS_IPV6_ONLY, or AWS_KVS_DUAL_STACK_ONLY can be enabled.")
+endif()
+
+# Translate the CMake flags to the pre-processor macros
+if(AWS_KVS_IPV4_ONLY)
+    add_definitions(-DAWS_KVS_IPV4_ONLY)
+endif()
+
+if(AWS_KVS_IPV6_ONLY)
+    add_definitions(-DAWS_KVS_IPV6_ONLY)
+endif()
+
+if(AWS_KVS_DUAL_STACK_ONLY)
+    add_definitions(-DAWS_KVS_DUAL_STACK_ONLY)
+endif()
+
+if(AWS_KVS_USE_LEGACY_ENDPOINT_ONLY)
+    add_definitions(-DAWS_KVS_USE_LEGACY_ENDPOINT_ONLY)
+endif()
+
+if(AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY)
+    add_definitions(-DAWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY)
+endif()
+
 if(BUILD_DEPENDENCIES)
   if (NOT OPEN_SRC_INSTALL_PREFIX)
     set(OPEN_SRC_INSTALL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/open-source)

README.md

@@ -59,6 +59,11 @@ You can pass the following options to `cmake ..`.
 * `-DALIGNED_MEMORY_MODEL` Build for aligned memory model only devices. Default is OFF.
 * `-DLOCAL_OPENSSL_BUILD` Whether or not to use local OpenSSL build. Default is OFF.
 * `-DCONSTRAINED_DEVICE` -- Change thread stack size to 0.5Mb, needed for Alpine.
+* `-DAWS_KVS_USE_LEGACY_ENDPOINT_ONLY` -- Use only legacy IPV4-only endpoints (ignores env vars). Default is OFF.
+* `-DAWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY` -- Use only dual-stack endpoints (ignores env vars). Default is OFF.
+* `-DAWS_KVS_IPV4_ONLY` -- Use only IPv4 addresses from DNS (ignores env vars). Default is OFF.
+* `-DAWS_KVS_IPV6_ONLY` -- Use only IPv6 addresses from DNS (ignores env vars). Default is OFF.
+* `-DAWS_KVS_DUAL_STACK_ONLY` -- Use both IPv4 and IPv6 addresses from DNS (ignores env vars). Default is OFF.
 
 
 DMEMORY_SANITIZER, DTHREAD_SANITIZER etc. flags works only with clang compiler 
@@ -197,6 +202,23 @@ For video and audio: `createOfflineAudioVideoStreamInfoProviderWithCodecs()`
 
 The 2 APIs are available in [this](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/412aab82c99a72f9dbde975f5fea81ffdc844ae5/src/include/com/amazonaws/kinesis/video/cproducer/Include.h) header file.
 
+### KVS Endpoints and DNS resolution
+The default endpoints and DNS resolution chain is implemented by the SDK. It sequentially checks each place where you can set the configuration for these parameters, and then selects the first one you set. The predefined sequence is as follows:
+
+#### Endpoint Configuration
+1. The `controlPlaneUrl` parameter for `createAbstractDefaultCallbacksProvider`.
+2. Endpoint configuration CMake parameters: (`-DAWS_KVS_USE_LEGACY_ENDPOINT_ONLY=TRUE`, `-DAWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY=TRUE`)
+3. Environment variables: (`export AWS_USE_DUALSTACK_ENDPOINT=TRUE`)
+  - If `AWS_USE_DUALSTACK_ENDPOINT` is `TRUE` (case-insensitive), the dual-stack endpoint will be used.
+4. Otherwise, the legacy endpoint will be constructed.
+
+With 2, 3, and 4, the endpoint will be constructed based on the region provided to `createAbstractDefaultCallbacksProvider`.
+
+#### DNS filtering
+1. DNS resolution CMake parameters: (`-DAWS_KVS_IPV4_ONLY=TRUE`, `-DAWS_KVS_IPV6_ONLY=TRUE`, `-DAWS_KVS_DUAL_STACK_ONLY=TRUE`)
+2. Environment variables (`export AWS_KVS_USE_IPV4=TRUE`, `export AWS_KVS_USE_IPV6=TRUE`)
+3. Otherwise, no filtering will take place. Both IPv4 and IPv6 IP addresses, if returned by DNS, may be used.
+
 ## DEBUG
 * When building OpenSSL during `cmake ..`, if you encounter an architecture error such as `ld: symbol(s) not found for architecture i386`, building with a local OpenSSL build may help. First install OpenSSL 1.1 (for Mac: `brew install [email protected]`). Next set `export PKG_CONFIG_PATH="<YOUR-PATH>/[email protected]/lib/pkgconfig"` (your path can be printed to terminal using `which openssl` on Linux/Mac). Now set the following flag to ON when building: `cmake .. -DLOCAL_OPENSSL_BUILD=ON`. If there are still errors regarding locating the local OpenSSL library:
     * The following environment variables may need to be set to export:

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

@@ -334,6 +334,14 @@ extern "C" {
 #define AWS_GOV_CLOUD_REGION_PREFIX "us-gov-"
 
 #define AWS_CN_REGION_PREFIX "cn-"
+
+#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"
 
 /**
  * Default user agent name

src/source/CurlApiCallbacks.c

@@ -14,6 +14,7 @@ STATUS createCurlApiCallbacks(PCallbacksProvider pCallbacksProvider, PCHAR regio
     ENTERS();
     STATUS retStatus = STATUS_SUCCESS, status;
     PCurlApiCallbacks pCurlApiCallbacks = NULL;
+    BOOL useDualStackEndpoint;
 
     CHK(pCallbacksProvider != NULL && ppCurlApiCallbacks != NULL, STATUS_NULL_ARG);
     CHK(certPath == NULL || STRNLEN(certPath, MAX_PATH_LEN + 1) <= MAX_PATH_LEN, STATUS_INVALID_CERT_PATH_LENGTH);
@@ -77,26 +78,20 @@ STATUS createCurlApiCallbacks(PCallbacksProvider pCallbacksProvider, PCHAR regio
         DLOGW("Failed to generate user agent string with error 0x%08x.", status);
     }
 
-    // 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))) {
-            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 {
-            // 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);
-        }
+    // Construct Control Plane URL
+    if (IS_NULL_OR_EMPTY_STRING(controlPlaneUrl)) {
+#if defined(AWS_KVS_USE_LEGACY_ENDPOINT_ONLY)
+        useDualStackEndpoint = FALSE;
+        DLOGI("Using legacy endpoint from AWS_KVS_USE_LEGACY_ENDPOINT_ONLY")
+#elif defined(AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY)
+        useDualStackEndpoint = TRUE;
+        DLOGI("Using dual stack endpoint from AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY")
+#else
+        useDualStackEndpoint = (GETENV(CONTROL_PLANE_USE_DUAL_STACK_ENDPOINT_ENV_VAR) != NULL) && (0 == STRNCMPI(GETENV(CONTROL_PLANE_USE_DUAL_STACK_ENDPOINT_ENV_VAR), "true", 4));
+        DLOGI("Using %s endpoint from environment", useDualStackEndpoint ? "dual stack" : "legacy");
+#endif
+
+        constructControlPlaneUrl(pCurlApiCallbacks->controlPlaneUrl, MAX_URI_CHAR_LEN, pCurlApiCallbacks->region, !useDualStackEndpoint);
     } else {
         STRNCPY(pCurlApiCallbacks->controlPlaneUrl, controlPlaneUrl, MAX_URI_CHAR_LEN);
     }
@@ -194,6 +189,46 @@ STATUS createCurlApiCallbacks(PCallbacksProvider pCallbacksProvider, PCHAR regio
     return retStatus;
 }
 
+STATUS constructControlPlaneUrl(const char* buffer, SIZE_T bufferSize, const char* region, BOOL useLegacyEndpoint)
+{
+    ENTERS();
+    STATUS retStatus = STATUS_SUCCESS;
+    const char* serviceNamePostfix = "";
+    const char* postfix;
+
+    CHK(buffer != NULL && region != NULL, STATUS_NULL_ARG);
+    CHK(bufferSize > 0, STATUS_INVALID_ARG_LEN);
+
+    if (0 == STRNCMP(region, AWS_ISO_B_REGION_PREFIX, STRLEN(AWS_ISO_B_REGION_PREFIX))) {
+        // Top Secret Cloud regions: https://kinesisvideo-fips.us-isob-east-1.sc2s.sgov.gov
+        serviceNamePostfix = AWS_KVS_FIPS_ENDPOINT_POSTFIX;
+        postfix = useLegacyEndpoint ? CONTROL_PLANE_URI_POSTFIX_ISO_B : CONTROL_PLANE_URI_POSTFIX_ISO_B_DUAL_STACK;
+    } else if (0 == STRNCMP(region, AWS_ISO_REGION_PREFIX, STRLEN(AWS_ISO_REGION_PREFIX))) {
+        // Secret Cloud regions: https://kinesisvideo-fips.us-iso-east-1.c2s.ic.gov
+        serviceNamePostfix = AWS_KVS_FIPS_ENDPOINT_POSTFIX;
+        postfix = useLegacyEndpoint ? CONTROL_PLANE_URI_POSTFIX_ISO : CONTROL_PLANE_URI_POSTFIX_ISO_DUAL_STACK;
+    } else if (0 == STRNCMP(region, AWS_GOV_CLOUD_REGION_PREFIX, STRLEN(AWS_GOV_CLOUD_REGION_PREFIX))) {
+        // US Govcloud regions: https://kinesisvideo-fips.us-gov-east-1.amazonaws.com
+        serviceNamePostfix = AWS_KVS_FIPS_ENDPOINT_POSTFIX;
+        postfix = useLegacyEndpoint ? CONTROL_PLANE_URI_POSTFIX : CONTROL_PLANE_URI_POSTFIX_DUAL_STACK;
+    } else if (0 == STRNCMP(region, AWS_CN_REGION_PREFIX, STRLEN(AWS_CN_REGION_PREFIX))) {
+        // China regions: https://kinesisvideo.cn-north-1.amazonaws.com.cn"
+        postfix = useLegacyEndpoint ? CONTROL_PLANE_URI_POSTFIX_CN : CONTROL_PLANE_URI_POSTFIX_CN_DUAL_STACK;
+    } else {
+        // Standard regions: https://kinesisvideo.us-west-2.amazonaws.com
+        postfix = useLegacyEndpoint ? CONTROL_PLANE_URI_POSTFIX : CONTROL_PLANE_URI_POSTFIX_DUAL_STACK;
+    }
+
+    // Create a fully qualified URI
+    SNPRINTF((PCHAR) buffer, bufferSize, "%s%s%s.%s%s", CONTROL_PLANE_URI_PREFIX, KINESIS_VIDEO_SERVICE_NAME, serviceNamePostfix, region, postfix);
+
+CleanUp:
+    CHK_LOG_ERR(retStatus);
+
+    LEAVES();
+    return retStatus;
+}
+
 /**
  * Frees the CURL API callbacks object
  *

src/source/CurlApiCallbacks.h

@@ -20,6 +20,12 @@ extern "C" {
 #define TAG_RESOURCE_API_POSTFIX      "/tagStream"
 #define PUT_MEDIA_API_POSTFIX         "/putMedia"
 
+#define CONTROL_PLANE_USE_DUAL_STACK_ENDPOINT_ENV_VAR "AWS_USE_DUALSTACK_ENDPOINT"
+
+#if defined(AWS_KVS_USE_LEGACY_ENDPOINT_ONLY) && defined(AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY)
+#error "Only one of AWS_KVS_USE_LEGACY_ENDPOINT_ONLY or AWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY can be defined"
+#endif
+
 // NOTE: THe longest string would be the tag resource where we get the maximal tag count and sizes plus some extra.
 #define MAX_TAGS_JSON_PARAMETER_STRING_LEN (MAX_JSON_PARAMETER_STRING_LEN + (MAX_TAG_COUNT * (MAX_TAG_NAME_LEN + MAX_TAG_VALUE_LEN)))
 
@@ -177,6 +183,7 @@ typedef struct __CurlApiCallbacks* PCurlApiCallbacks;
 // Curl API Callbacks main functionality
 //////////////////////////////////////////////////////////////////////
 STATUS createCurlApiCallbacks(struct __CallbacksProvider*, PCHAR, API_CALL_CACHE_TYPE, UINT64, PCHAR, PCHAR, PCHAR, PCHAR, PCurlApiCallbacks*);
+STATUS constructControlPlaneUrl(const char*, SIZE_T, const char*, BOOL);
 STATUS freeCurlApiCallbacks(PCurlApiCallbacks*);
 STATUS curlApiCallbacksShutdownActiveRequests(PCurlApiCallbacks, STREAM_HANDLE, UINT64, BOOL, BOOL);
 STATUS curlApiCallbacksShutdownCachedEndpoints(PCurlApiCallbacks, STREAM_HANDLE, BOOL);

src/source/Response.c

@@ -180,6 +180,35 @@ STATUS initializeCurlSession(PRequestInfo pRequestInfo, PCallInfo pCallInfo, CUR
         curl_easy_setopt(pCurl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
     }
 
+#if defined(AWS_KVS_IPV4_ONLY)
+    curl_easy_setopt(pCurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+    DLOGD("Curl resolving IPV4 through AWS_KVS_IPV4_ONLY");
+#elif defined(AWS_KVS_IPV6_ONLY)
+    curl_easy_setopt(pCurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
+    DLOGD("Curl resolving IPV6 through AWS_KVS_IPV6_ONLY");
+#elif defined(AWS_KVS_DUAL_STACK_ONLY)
+    curl_easy_setopt(pCurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
+    DLOGD("Curl resolving dual stack through AWS_KVS_DUAL_STACK_ONLY");
+#else
+    if (!IS_NULL_OR_EMPTY_STRING(GETENV(KVS_CURL_IPRESOLVE_V4_ENV_VAR))) {
+        curl_easy_setopt(pCurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+        DLOGD("Curl resolving IPV4 through environment variable");
+    } else if (!IS_NULL_OR_EMPTY_STRING(GETENV(KVS_CURL_IPRESOLVE_V6_ENV_VAR))) {
+        curl_easy_setopt(pCurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
+        DLOGD("Curl resolving IPV6 through environment variable");
+    } else {
+        curl_easy_setopt(pCurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
+        DLOGD("Curl resolving dual stack by default");
+    }
+#endif
+
+#ifndef NDEBUG
+    // Only available in debug build
+    if (!IS_NULL_OR_EMPTY_STRING(GETENV(KVS_CURL_DEBUG_ENV_VAR))) {
+        curl_easy_setopt(pCurl, CURLOPT_VERBOSE, 1L);
+    }
+#endif
+
     // set request completion timeout in milliseconds
     if (pRequestInfo->completionTimeout != SERVICE_CALL_INFINITE_TIMEOUT) {
         curl_easy_setopt(pCurl, CURLOPT_TIMEOUT_MS, pRequestInfo->completionTimeout / HUNDREDS_OF_NANOS_IN_A_MILLISECOND);

src/source/Response.h

@@ -25,6 +25,17 @@ extern "C" {
 // Debug dump data file environment variable
 #define KVS_DEBUG_DUMP_DATA_FILE_DIR_ENV_VAR "KVS_DEBUG_DUMP_DATA_FILE_DIR"
 
+// Curl settings
+#define KVS_CURL_IPRESOLVE_V4_ENV_VAR "AWS_KVS_USE_IPV4"
+#define KVS_CURL_IPRESOLVE_V6_ENV_VAR "AWS_KVS_USE_IPV6"
+#define KVS_CURL_DEBUG_ENV_VAR "KVS_CURL_DEBUG"
+
+#if (defined(AWS_KVS_IPV4_ONLY) && defined(AWS_KVS_IPV6_ONLY)) || \
+    (defined(AWS_KVS_IPV4_ONLY) && defined(AWS_KVS_DUAL_STACK_ONLY)) || \
+    (defined(AWS_KVS_IPV6_ONLY) && defined(AWS_KVS_DUAL_STACK_ONLY))
+#error "Only one of AWS_KVS_IPV4_ONLY, AWS_KVS_IPV6_ONLY, or AWS_KVS_DUAL_STACK_ONLY can be defined"
+#endif
+
 // this is used by postReadCallback to sleep before checking for more data
 #define MAX_GET_DATA_ITER 6