revert changes

Author: kai-ion

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

@@ -627,19 +627,52 @@ void WinHttpSyncHttpClient::DoAddHeaders(void* hHttpRequest, Aws::String& header
 
 uint64_t WinHttpSyncHttpClient::DoWriteData(void* hHttpRequest, char* streamBuffer, uint64_t bytesRead, bool isChunked) const
 {
-    AWS_UNREFERENCED_PARAM(isChunked);
     DWORD bytesWritten = 0;
-    if (!AzCallWinHttp("WinHttpWriteData", WinHttpWriteData, hHttpRequest, streamBuffer, (DWORD)bytesRead, &bytesWritten))
+    uint64_t totalBytesWritten = 0;
+    const char CRLF[] = "\r\n";
+
+    if (isChunked)
     {
-        return 0;
+        Aws::String chunkSizeHexString = StringUtils::ToHexString(bytesRead) + CRLF;
+
+        if (!AzCallWinHttp("WinHttpWriteData", WinHttpWriteData, hHttpRequest, chunkSizeHexString.c_str(), (DWORD)chunkSizeHexString.size(), &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
+        if (!AzCallWinHttp("WinHttpWriteData", WinHttpWriteData, hHttpRequest, streamBuffer, (DWORD)bytesRead, &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
+        if (!AzCallWinHttp("WinHttpWriteData", WinHttpWriteData, hHttpRequest, CRLF, (DWORD)(sizeof(CRLF) - 1), &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
     }
-    return bytesWritten;
+    else
+    {
+        if (!AzCallWinHttp("WinHttpWriteData", WinHttpWriteData, hHttpRequest, streamBuffer, (DWORD)bytesRead, &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
+    }
+
+    return totalBytesWritten;
 }
 
 uint64_t WinHttpSyncHttpClient::FinalizeWriteData(void* hHttpRequest) const
 {
-    AWS_UNREFERENCED_PARAM(hHttpRequest);
-    return 0;
+    DWORD bytesWritten = 0;
+    const char trailingCRLF[] = "0\r\n\r\n";
+    if (!AzCallWinHttp("WinHttpWriteData", WinHttpWriteData, hHttpRequest, trailingCRLF, (DWORD)(sizeof(trailingCRLF) - 1), &bytesWritten))
+    {
+        return 0;
+    }
+
+    return bytesWritten;
 }
 
 bool WinHttpSyncHttpClient::DoReceiveResponse(void* httpRequest) const

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

@@ -161,19 +161,52 @@ void WinINetSyncHttpClient::DoAddHeaders(void* hHttpRequest, Aws::String& header
 
 uint64_t WinINetSyncHttpClient::DoWriteData(void* hHttpRequest, char* streamBuffer, uint64_t bytesRead, bool isChunked) const
 {
-    AWS_UNREFERENCED_PARAM(isChunked);
     DWORD bytesWritten = 0;
-    if (!InternetWriteFile(hHttpRequest, streamBuffer, (DWORD)bytesRead, &bytesWritten))
+    uint64_t totalBytesWritten = 0;
+    const char CRLF[] = "\r\n";
+
+    if (isChunked)
     {
-        return 0;
+        Aws::String chunkSizeHexString = StringUtils::ToHexString(bytesRead) + CRLF;
+
+        if (!InternetWriteFile(hHttpRequest, chunkSizeHexString.c_str(), (DWORD)chunkSizeHexString.size(), &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
+        if (!InternetWriteFile(hHttpRequest, streamBuffer, (DWORD)bytesRead, &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
+        if (!InternetWriteFile(hHttpRequest, CRLF, (DWORD)(sizeof(CRLF) - 1), &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
     }
-    return bytesWritten;
+    else
+    {
+        if (!InternetWriteFile(hHttpRequest, streamBuffer, (DWORD)bytesRead, &bytesWritten))
+        {
+            return totalBytesWritten;
+        }
+        totalBytesWritten += bytesWritten;
+    }
+
+    return totalBytesWritten;
 }
 
 uint64_t WinINetSyncHttpClient::FinalizeWriteData(void* hHttpRequest) const
 {
-    AWS_UNREFERENCED_PARAM(hHttpRequest);
-    return 0;
+    DWORD bytesWritten = 0;
+    const char trailingCRLF[] = "0\r\n\r\n";
+    if (!InternetWriteFile(hHttpRequest, trailingCRLF, (DWORD)(sizeof(trailingCRLF) - 1), &bytesWritten))
+    {
+        return 0;
+    }
+
+    return bytesWritten;
 }
 
 bool WinINetSyncHttpClient::DoReceiveResponse(void* hHttpRequest) const

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

@@ -7,6 +7,7 @@
 #include <aws/core/http/HttpRequest.h>
 #include <aws/core/http/standard/StandardHttpResponse.h>
 #include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/HashingUtils.h>
 #include <aws/core/utils/logging/LogMacros.h>
 #include <aws/core/utils/stream/StreamBufProtectedWriter.h>
 #include <aws/core/client/ClientConfiguration.h>
@@ -98,14 +99,22 @@ void WinSyncHttpClient::AddHeadersToRequest(const std::shared_ptr<HttpRequest>&
 bool WinSyncHttpClient::StreamPayloadToRequest(const std::shared_ptr<HttpRequest>& request, void* hHttpRequest, Aws::Utils::RateLimits::RateLimiterInterface* writeLimiter) const
 {
     bool success = true;
+    bool isChunked = request->HasTransferEncoding() && request->GetTransferEncoding() == Aws::Http::CHUNKED_VALUE;
+    bool isAwsChunked = request->HasHeader(Aws::Http::CONTENT_ENCODING_HEADER) &&
+                        request->GetHeaderValue(Aws::Http::CONTENT_ENCODING_HEADER).find(Aws::Http::AWS_CHUNKED_VALUE) != Aws::String::npos;
     auto payloadStream = request->GetContentBody();
+    const char CRLF[] = "\r\n";
     if(payloadStream)
     {
         uint64_t bytesWritten;
         uint64_t bytesToRead = HTTP_REQUEST_WRITE_BUFFER_LENGTH;
         auto startingPos = payloadStream->tellg();
         bool done = false;
-        char streamBuffer[HTTP_REQUEST_WRITE_BUFFER_LENGTH];
+        // aws-chunk = hex(chunk-size) + CRLF + chunk-data + CRLF
+        // Length of hex(HTTP_REQUEST_WRITE_BUFFER_LENGTH) is 4;
+        // Length of each CRLF is 2.
+        // Reserve 8 bytes in total, should the request be aws-chunked.
+        char streamBuffer[ HTTP_REQUEST_WRITE_BUFFER_LENGTH + 8 ];
         while(success && !done)
         {
             payloadStream->read(streamBuffer, bytesToRead);
@@ -115,7 +124,22 @@ bool WinSyncHttpClient::StreamPayloadToRequest(const std::shared_ptr<HttpRequest
             bytesWritten = 0;
             if (bytesRead > 0)
             {
-                bytesWritten = DoWriteData(hHttpRequest, streamBuffer, bytesRead, false);
+                if (isAwsChunked)
+                {
+                    if (request->GetRequestHash().second != nullptr)
+                    {
+                        request->GetRequestHash().second->Update(reinterpret_cast<unsigned char*>(streamBuffer), static_cast<size_t>(bytesRead));
+                    }
+
+                    Aws::String hex = Aws::Utils::StringUtils::ToHexString(static_cast<uint64_t>(bytesRead));
+                    memcpy(streamBuffer + hex.size() + 2, streamBuffer, static_cast<size_t>(bytesRead));
+                    memcpy(streamBuffer + hex.size() + 2 + bytesRead, CRLF, 2);
+                    memcpy(streamBuffer, hex.c_str(), hex.size());
+                    memcpy(streamBuffer + hex.size(), CRLF, 2);
+                    bytesRead += hex.size() + 4;
+                }
+
+                bytesWritten = DoWriteData(hHttpRequest, streamBuffer, bytesRead, isChunked);
                 if (!bytesWritten)
                 {
                     success = false;
@@ -140,6 +164,40 @@ bool WinSyncHttpClient::StreamPayloadToRequest(const std::shared_ptr<HttpRequest
             success = success && ContinueRequest(*request) && IsRequestProcessingEnabled();
         }
 
+        if (success && isAwsChunked)
+        {
+            Aws::StringStream chunkedTrailer;
+            chunkedTrailer << "0" << CRLF;
+            if (request->GetRequestHash().second != nullptr)
+            {
+                chunkedTrailer << "x-amz-checksum-" << request->GetRequestHash().first << ":"
+                    << Aws::Utils::HashingUtils::Base64Encode(request->GetRequestHash().second->GetHash().GetResult()) << CRLF;
+            }
+            chunkedTrailer << CRLF;
+            bytesWritten = DoWriteData(hHttpRequest, const_cast<char*>(chunkedTrailer.str().c_str()), chunkedTrailer.str().size(), isChunked);
+            if (!bytesWritten)
+            {
+                success = false;
+            }
+            else if(writeLimiter)
+            {
+                writeLimiter->ApplyAndPayForCost(bytesWritten);
+            }
+        }
+
+        if (success && isChunked)
+        {
+            bytesWritten = FinalizeWriteData(hHttpRequest);
+            if (!bytesWritten)
+            {
+                success = false;
+            }
+            else if (writeLimiter)
+            {
+                writeLimiter->ApplyAndPayForCost(bytesWritten);
+            }
+        }
+
         payloadStream->clear();
         payloadStream->seekg(startingPos, payloadStream->beg);
     }