refactor out chunk framing

Author: kai-ion

src/aws-cpp-sdk-core/include/aws/core/client/ClientConfiguration.h

@@ -78,6 +78,16 @@ namespace Aws
           WHEN_REQUIRED,
         };
 
+        /**
+         * Control whether ChunkingInterceptor applies aws-chunked encoding.
+         * ENABLE: Apply aws-chunked encoding for requests with checksums (default)
+         * DISABLE: Skip ChunkingInterceptor, rely on signer for chunking
+         */
+        enum class UseAwsChunkedEncoding {
+          ENABLE,
+          DISABLE,
+        };
+
         struct RequestCompressionConfig {
           UseRequestCompression useRequestCompression=UseRequestCompression::ENABLE;
           size_t requestMinCompressionSizeBytes = 10240;
@@ -493,6 +503,12 @@ namespace Aws
            * https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html
            */
           Aws::String accountIdEndpointMode = "preferred";
+
+          /**
+           * Control whether ChunkingInterceptor applies aws-chunked encoding.
+           * Default ENABLE for backward compatibility.
+           */
+          UseAwsChunkedEncoding useAwsChunkedEncoding = UseAwsChunkedEncoding::ENABLE;
           /**
           * Configuration structure for credential providers in the AWS SDK.
           * This structure allows passing configuration options to credential providers

src/aws-cpp-sdk-core/include/aws/core/http/interceptor/ChunkingInterceptor.h

@@ -19,14 +19,16 @@ namespace Aws
  */
 class ChunkingInterceptor : public smithy::interceptor::Interceptor {
 public:
-    ChunkingInterceptor() = default;
+    explicit ChunkingInterceptor(Aws::Client::UseAwsChunkedEncoding useAwsChunkedEncoding = Aws::Client::UseAwsChunkedEncoding::ENABLE)
+        : m_useAwsChunkedEncoding(useAwsChunkedEncoding) {}
     ~ChunkingInterceptor() override = default;
 
     ModifyRequestOutcome ModifyBeforeSigning(smithy::interceptor::InterceptorContext& context) override;
     ModifyResponseOutcome ModifyBeforeDeserialization(smithy::interceptor::InterceptorContext& context) override;
 
 private:
     bool ShouldApplyAwsChunking(const std::shared_ptr<Aws::Http::HttpRequest>& request) const;
+    Aws::Client::UseAwsChunkedEncoding m_useAwsChunkedEncoding;
 };
 
     } // namespace Http

src/aws-cpp-sdk-core/source/auth/signer/AWSAuthV4Signer.cpp

@@ -229,9 +229,14 @@ bool AWSAuthV4Signer::SignRequestWithCreds(Aws::Http::HttpRequest& request, cons
         request.DeleteHeader(checksumHeaderValue.c_str());
         request.SetHeaderValue(Http::AWS_TRAILER_HEADER, checksumHeaderValue);
         request.SetTransferEncoding(CHUNKED_VALUE);
-        request.HasContentEncoding()
-                ? request.SetContentEncoding(Aws::String{Http::AWS_CHUNKED_VALUE} + "," + request.GetContentEncoding())
-                : request.SetContentEncoding(Http::AWS_CHUNKED_VALUE);
+        if (!request.HasContentEncoding()) {
+            request.SetContentEncoding(Http::AWS_CHUNKED_VALUE);
+        } else {
+            Aws::String currentEncoding = request.GetContentEncoding();
+            if (currentEncoding.find(Http::AWS_CHUNKED_VALUE) == Aws::String::npos) {
+                request.SetContentEncoding(Aws::String{Http::AWS_CHUNKED_VALUE} + "," + currentEncoding);
+            }
+        }
 
         if (request.HasHeader(Http::CONTENT_LENGTH_HEADER)) {
           request.SetHeaderValue(Http::DECODED_CONTENT_LENGTH_HEADER, request.GetHeaderValue(Http::CONTENT_LENGTH_HEADER));

src/aws-cpp-sdk-core/source/client/UserAgent.cpp

@@ -182,6 +182,15 @@ Aws::String UserAgent::SerializeWithFeatures(const Aws::Set<UserAgentFeature>& f
     SerializeMetadata(METADATA, m_compilerMetadata);
   }
 
+  // Add HTTP client metadata
+#if AWS_SDK_USE_CRT_HTTP
+  SerializeMetadata(METADATA, "http#crt");
+#elif ENABLE_CURL_CLIENT
+  SerializeMetadata(METADATA, "http#curl");
+#elif ENABLE_WINDOWS_CLIENT
+  SerializeMetadata(METADATA, "http#winhttp");
+#endif
+
   // metrics
   Aws::Vector<Aws::String> encodedMetrics{};
 
@@ -217,7 +226,9 @@ Aws::String UserAgent::SerializeWithFeatures(const Aws::Set<UserAgentFeature>& f
                                       });
   }
 
-  return userAgentValue.str();
+  auto finalUserAgent = userAgentValue.str();
+  AWS_LOGSTREAM_DEBUG(LOG_TAG, "Generated User-Agent: " << finalUserAgent);
+  return finalUserAgent;
 }
 
 namespace {

src/aws-cpp-sdk-core/source/http/interceptor/ChunkingInterceptor.cpp

@@ -51,6 +51,11 @@ class AwsChunkedIOStream : public Aws::IOStream {
 ChunkingInterceptor::ModifyRequestOutcome ChunkingInterceptor::ModifyBeforeSigning(
     smithy::interceptor::InterceptorContext& context) {
     auto request = context.GetTransmitRequest();
+
+    if (m_useAwsChunkedEncoding == Aws::Client::UseAwsChunkedEncoding::DISABLE) {
+        return request;
+    }
+    
     if (!ShouldApplyAwsChunking(request)) {
         return request;
     }

src/aws-cpp-sdk-core/source/http/windows/WinSyncHttpClient.cpp

@@ -141,15 +141,23 @@ bool WinSyncHttpClient::StreamPayloadToRequest(const std::shared_ptr<HttpRequest
             success = success && ContinueRequest(*request) && IsRequestProcessingEnabled();
         }
 
+        if (success && isChunked)
+        {
+            bytesWritten = FinalizeWriteData(hHttpRequest);
+            if (!bytesWritten)
+            {
+                success = false;
+            }
+            else if (writeLimiter)
+            {
+                writeLimiter->ApplyAndPayForCost(bytesWritten);
+            }
+        }
+
         payloadStream->clear();
         payloadStream->seekg(startingPos, payloadStream->beg);
     }
 
-    if (success && isChunked)
-    {
-      FinalizeWriteData(hHttpRequest);
-    }
-
     if(success)
     {
         success = DoReceiveResponse(hHttpRequest);