react-native-windows 0.67.6 → 0.67.9

package/Shared/WinRTHttpResource.cpp

@@ -0,0 +1,317 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "WinRTHttpResource.h"
+
+#include <Utils/CppWinrtLessExceptions.h>
+#include <Utils/WinRTConversions.h>
+#include <utilities.h>
+
+// Windows API
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.Web.Http.Headers.h>
+
+using std::function;
+using std::scoped_lock;
+using std::shared_ptr;
+using std::string;
+
+using winrt::fire_and_forget;
+using winrt::hresult_error;
+using winrt::to_hstring;
+using winrt::to_string;
+using winrt::Windows::Foundation::Uri;
+using winrt::Windows::Security::Cryptography::CryptographicBuffer;
+using winrt::Windows::Storage::StorageFile;
+using winrt::Windows::Storage::Streams::DataReader;
+using winrt::Windows::Storage::Streams::UnicodeEncoding;
+using winrt::Windows::Web::Http::HttpBufferContent;
+using winrt::Windows::Web::Http::HttpMethod;
+using winrt::Windows::Web::Http::HttpRequestMessage;
+using winrt::Windows::Web::Http::HttpStreamContent;
+using winrt::Windows::Web::Http::HttpStringContent;
+using winrt::Windows::Web::Http::IHttpClient;
+using winrt::Windows::Web::Http::IHttpContent;
+using winrt::Windows::Web::Http::Headers::HttpMediaTypeHeaderValue;
+
+namespace Microsoft::React {
+
+#pragma region WinRTHttpResource
+
+// TODO: Check for multi-thread issues if there are multiple instances.
+/*static*/ int64_t WinRTHttpResource::s_lastRequestId = 0;
+
+WinRTHttpResource::WinRTHttpResource(IHttpClient &&client) noexcept : m_client{std::move(client)} {}
+
+WinRTHttpResource::WinRTHttpResource() noexcept : WinRTHttpResource(winrt::Windows::Web::Http::HttpClient()) {}
+
+#pragma region IHttpResource
+
+void WinRTHttpResource::SendRequest(
+    string &&method,
+    string &&url,
+    Headers &&headers,
+    BodyData &&bodyData,
+    string &&responseType,
+    bool useIncrementalUpdates,
+    int64_t timeout,
+    bool withCredentials,
+    std::function<void(int64_t)> &&callback) noexcept /*override*/ {
+  auto requestId = ++s_lastRequestId;
+
+  // Enforce supported args
+  assert(responseType == "text" || responseType == "base64");
+
+  if (callback) {
+    callback(requestId);
+  }
+
+  try {
+    HttpMethod httpMethod{to_hstring(std::move(method))};
+    Uri uri{to_hstring(std::move(url))};
+    HttpRequestMessage request{httpMethod, uri};
+    HttpMediaTypeHeaderValue contentType{nullptr};
+    string contentEncoding;
+    string contentLength;
+
+    // Headers are generally case-insensitive
+    // https://www.ietf.org/rfc/rfc2616.txt section 4.2
+    for (auto &header : headers) {
+      if (_stricmp(header.first.c_str(), "content-type") == 0) {
+        bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), contentType);
+        if (!success && m_onError) {
+          return m_onError(requestId, "Failed to parse Content-Type");
+        }
+      } else if (_stricmp(header.first.c_str(), "content-encoding") == 0) {
+        contentEncoding = header.second;
+      } else if (_stricmp(header.first.c_str(), "content-length") == 0) {
+        contentLength = header.second;
+      } else if (_stricmp(header.first.c_str(), "authorization") == 0) {
+        bool success =
+            request.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
+        if (!success && m_onError) {
+          return m_onError(requestId, "Failed to append Authorization");
+        }
+      } else {
+        request.Headers().Append(to_hstring(header.first), to_hstring(header.second));
+      }
+    }
+
+    IHttpContent content{nullptr};
+    if (BodyData::Type::String == bodyData.Type) {
+      content = HttpStringContent{to_hstring(bodyData.Data)};
+    } else if (BodyData::Type::Base64 == bodyData.Type) {
+      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(bodyData.Data));
+      content = HttpBufferContent{buffer};
+    } else if (BodyData::Type::Uri == bodyData.Type) {
+      auto file = StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(bodyData.Data)}).get();
+      auto stream = file.OpenReadAsync().get();
+      content = HttpStreamContent{stream};
+    } else if (BodyData::Type::Form == bodyData.Type) {
+      // TODO: Add support
+    } else {
+      // BodyData::Type::Empty
+      // TODO: Error 'cause unsupported??
+    }
+
+    if (content != nullptr) {
+      // Attach content headers
+      if (contentType) {
+        content.Headers().ContentType(contentType);
+      }
+      if (!contentEncoding.empty()) {
+        if (!content.Headers().ContentEncoding().TryParseAdd(to_hstring(contentEncoding))) {
+          if (m_onError) {
+            m_onError(requestId, "Failed to parse Content-Encoding");
+          }
+          return;
+        }
+      }
+      if (!contentLength.empty()) {
+        const auto contentLengthHeader = _atoi64(contentLength.c_str()); // TODO: Alternatives to _atoi64?
+        content.Headers().ContentLength(contentLengthHeader);
+      }
+
+      request.Content(content);
+    }
+
+    PerformSendRequest(requestId, std::move(request), responseType == "text");
+  } catch (std::exception const &e) {
+    if (m_onError) {
+      m_onError(requestId, e.what());
+    }
+  } catch (hresult_error const &e) {
+    if (m_onError) {
+      m_onError(requestId, Utilities::HResultToString(e));
+    }
+  } catch (...) {
+    m_onError(requestId, "Unidentified error sending HTTP request");
+  }
+}
+
+void WinRTHttpResource::AbortRequest(int64_t requestId) noexcept /*override*/ {
+  ResponseType request{nullptr};
+
+  {
+    scoped_lock lock{m_mutex};
+    auto iter = m_responses.find(requestId);
+    if (iter == std::end(m_responses)) {
+      return;
+    }
+    request = iter->second;
+  }
+
+  try {
+    request.Cancel();
+  } catch (hresult_error const &e) {
+    m_onError(requestId, Utilities::HResultToString(e));
+  }
+}
+
+void WinRTHttpResource::ClearCookies() noexcept /*override*/ {
+  assert(false);
+  // NOT IMPLEMENTED
+}
+
+void WinRTHttpResource::SetOnRequest(function<void(int64_t requestId)> &&handler) noexcept /*override*/ {
+  m_onRequest = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnResponse(function<void(int64_t requestId, Response &&response)> &&handler) noexcept
+/*override*/ {
+  m_onResponse = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnData(function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept
+/*override*/ {
+  m_onData = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnError(function<void(int64_t requestId, string &&errorMessage)> &&handler) noexcept
+/*override*/ {
+  m_onError = std::move(handler);
+}
+
+#pragma endregion IHttpResource
+
+void WinRTHttpResource::TrackResponse(int64_t requestId, ResponseType response) noexcept {
+  scoped_lock lock{m_mutex};
+  m_responses[requestId] = response;
+}
+
+void WinRTHttpResource::UntrackResponse(int64_t requestId) noexcept {
+  scoped_lock lock{m_mutex};
+  m_responses.erase(requestId);
+}
+
+fire_and_forget
+WinRTHttpResource::PerformSendRequest(int64_t requestId, HttpRequestMessage &&request, bool textResponse) noexcept {
+  // Keep references after coroutine suspension.
+  auto self = shared_from_this();
+  auto coRequest = std::move(request);
+
+  // Ensure background thread
+  co_await winrt::resume_background();
+
+  try {
+    auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
+
+    self->TrackResponse(requestId, sendRequestOp);
+
+    co_await lessthrow_await_adapter<ResponseType>{sendRequestOp};
+    auto result = sendRequestOp.ErrorCode();
+    if (result < 0) {
+      if (self->m_onError) {
+        self->m_onError(requestId, Utilities::HResultToString(std::move(result)));
+      }
+      self->UntrackResponse(requestId);
+      co_return;
+    }
+
+    auto response = sendRequestOp.GetResults();
+    if (response) {
+      if (self->m_onResponse) {
+        Headers headers;
+
+        // Gather headers for both the response content and the response itself
+        // See Invoke-WebRequest PowerShell cmdlet or Chromium response handling
+        for (auto header : response.Headers()) {
+          headers.emplace(to_string(header.Key()), to_string(header.Value()));
+        }
+        for (auto header : response.Content().Headers()) {
+          headers.emplace(to_string(header.Key()), to_string(header.Value()));
+        }
+        string url = to_string(response.RequestMessage().RequestUri().AbsoluteUri());
+        self->m_onResponse(
+            requestId, {static_cast<int32_t>(response.StatusCode()), std::move(headers), std::move(url)});
+      }
+    }
+
+    // TODO: Incremental updates?
+    if (response && response.Content()) {
+      auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
+      auto reader = DataReader{inputStream};
+
+      if (textResponse) {
+        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+      }
+
+      // Only support response sizes up to 10MB.
+      // TODO: WHY????
+      co_await reader.LoadAsync(10 * 1024 * 1024);
+      auto length = reader.UnconsumedBufferLength();
+
+      if (textResponse) {
+        std::vector<uint8_t> data(length);
+        reader.ReadBytes(data);
+        string responseData = string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+
+        if (self->m_onData) {
+          self->m_onData(requestId, std::move(responseData));
+        }
+      } else {
+        auto buffer = reader.ReadBuffer(length);
+        auto data = CryptographicBuffer::EncodeToBase64String(buffer);
+        auto responseData = to_string(std::wstring_view(data));
+
+        if (self->m_onData) {
+          self->m_onData(requestId, std::move(responseData));
+        }
+      }
+    } else {
+      if (self->m_onError) {
+        self->m_onError(requestId, response == nullptr ? "request failed" : "No response content");
+      }
+    }
+  } catch (std::exception const &e) {
+    if (self->m_onError) {
+      self->m_onError(requestId, e.what());
+    }
+  } catch (hresult_error const &e) {
+    if (self->m_onError) {
+      self->m_onError(requestId, Utilities::HResultToString(e));
+    }
+  } catch (...) {
+    if (self->m_onError) {
+      self->m_onError(requestId, "Unhandled exception during request");
+    }
+  }
+
+  self->UntrackResponse(requestId);
+
+  // TODO: keep? See https://devblogs.microsoft.com/oldnewthing/?p=106160
+  co_return;
+}
+
+#pragma endregion WinRTHttpResource
+
+#pragma region IHttpResource
+
+/*static*/ shared_ptr<IHttpResource> IHttpResource::Make() noexcept {
+  return std::make_shared<WinRTHttpResource>();
+}
+
+#pragma endregion IHttpResource
+
+} // namespace Microsoft::React

package/Shared/WinRTHttpResource.h

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <IHttpResource.h>
+
+// Windows API
+#include <winrt/Windows.Web.Http.h>
+
+// Standard Library
+#include <mutex>
+
+namespace Microsoft::React {
+
+class WinRTHttpResource : public IHttpResource, public std::enable_shared_from_this<WinRTHttpResource> {
+  typedef winrt::Windows::Foundation::IAsyncOperationWithProgress<
+      winrt::Windows::Web::Http::HttpResponseMessage,
+      winrt::Windows::Web::Http::HttpProgress>
+      ResponseType;
+
+  static int64_t s_lastRequestId;
+
+  winrt::Windows::Web::Http::IHttpClient m_client;
+  std::mutex m_mutex;
+  std::unordered_map<int64_t, ResponseType> m_responses;
+
+  std::function<void(int64_t requestId)> m_onRequest;
+  std::function<void(int64_t requestId, Response &&response)> m_onResponse;
+  std::function<void(int64_t requestId, std::string &&responseData)> m_onData;
+  std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)> m_onError;
+
+  void TrackResponse(int64_t requestId, ResponseType response) noexcept;
+
+  void UntrackResponse(int64_t requestId) noexcept;
+
+  winrt::fire_and_forget PerformSendRequest(
+      int64_t requestId,
+      winrt::Windows::Web::Http::HttpRequestMessage &&request,
+      bool textResponse) noexcept;
+
+ public:
+  WinRTHttpResource() noexcept;
+
+  WinRTHttpResource(winrt::Windows::Web::Http::IHttpClient &&client) noexcept;
+
+#pragma region IHttpResource
+
+  void SendRequest(
+      std::string &&method,
+      std::string &&url,
+      Headers &&headers,
+      BodyData &&bodyData,
+      std::string &&responseType,
+      bool useIncrementalUpdates,
+      int64_t timeout,
+      bool withCredentials,
+      std::function<void(int64_t)> &&callback) noexcept override;
+  void AbortRequest(int64_t requestId) noexcept override;
+  void ClearCookies() noexcept override;
+
+#pragma endregion IHttpResource
+
+  void SetOnRequest(std::function<void(int64_t requestId)> &&handler) noexcept override;
+  void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept override;
+  void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept override;
+  void SetOnError(std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)>
+                      &&handler) noexcept override;
+};
+
+} // namespace Microsoft::React

package/Shared/WinRTWebSocketResource.cpp

@@ -5,6 +5,10 @@
 
 #include <Utilities.h>
 #include <Utils/CppWinrtLessExceptions.h>
+#include <Utils/WinRTConversions.h>
+
+// MSO
+#include <dispatchQueue/dispatchQueue.h>
 
 // Windows API
 #include <winrt/Windows.Foundation.Collections.h>
@@ -44,6 +48,7 @@ using winrt::Windows::Storage::Streams::IDataWriter;
 using winrt::Windows::Storage::Streams::UnicodeEncoding;
 
 namespace {
+
 ///
 /// Implements an awaiter for Mso::DispatchQueue
 ///
@@ -72,17 +77,6 @@ auto resume_in_queue(const Mso::DispatchQueue &queue) noexcept {
   return awaitable{queue};
 } // resume_in_queue
 
-string HResultToString(hresult_error const &e) {
-  std::stringstream stream;
-  stream << "[0x" << std::hex << e.code() << "] " << winrt::to_string(e.message());
-
-  return stream.str();
-}
-
-string HResultToString(hresult &&result) {
-  return HResultToString(hresult_error(std::move(result), hresult_error::from_abi));
-}
-
 } // namespace
 
 namespace Microsoft::React {
@@ -134,12 +128,12 @@ IAsyncAction WinRTWebSocketResource::PerformConnect(Uri &&uri) noexcept {
       }
     } else {
       if (self->m_errorHandler) {
-        self->m_errorHandler({HResultToString(std::move(result)), ErrorType::Connection});
+        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Connection});
       }
     }
   } catch (hresult_error const &e) {
     if (self->m_errorHandler) {
-      self->m_errorHandler({HResultToString(e), ErrorType::Connection});
+      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Connection});
     }
   }
 
@@ -180,12 +174,12 @@ fire_and_forget WinRTWebSocketResource::PerformPing() noexcept {
       }
     } else {
       if (self->m_errorHandler) {
-        self->m_errorHandler({HResultToString(std::move(result)), ErrorType::Ping});
+        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Ping});
       }
     }
   } catch (hresult_error const &e) {
     if (self->m_errorHandler) {
-      self->m_errorHandler({HResultToString(e), ErrorType::Ping});
+      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Ping});
     }
   }
 }
@@ -246,7 +240,7 @@ fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBi
       }
     } else {
       if (self->m_errorHandler) {
-        self->m_errorHandler({HResultToString(std::move(result)), ErrorType::Send});
+        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Send});
       }
     }
   } catch (std::exception const &e) {
@@ -256,7 +250,7 @@ fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBi
   } catch (hresult_error const &e) {
     // TODO: Remove after fixing unit tests exceptions.
     if (self->m_errorHandler) {
-      self->m_errorHandler({HResultToString(e), ErrorType::Ping});
+      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Ping});
     }
   }
 }
@@ -278,7 +272,7 @@ fire_and_forget WinRTWebSocketResource::PerformClose() noexcept {
     }
   } catch (hresult_error const &e) {
     if (m_errorHandler) {
-      m_errorHandler({HResultToString(e), ErrorType::Close});
+      m_errorHandler({Utilities::HResultToString(e), ErrorType::Close});
     }
   }
 
@@ -322,7 +316,22 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
           }
         } catch (hresult_error const &e) {
           if (self->m_errorHandler) {
-            self->m_errorHandler({HResultToString(e), ErrorType::Receive});
+            string errorMessage;
+            ErrorType errorType;
+            // See
+            // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-19041#remarks
+            if (e.code() == WININET_E_CONNECTION_ABORTED) {
+              errorMessage = "[0x80072EFE] Underlying TCP connection suddenly terminated";
+              errorType = ErrorType::Connection;
+              self->m_errorHandler({errorMessage, errorType});
+
+              // Note: We are not clear whether all read-related errors should close the socket.
+              self->Close(CloseCode::BadPayload, std::move(errorMessage));
+            } else {
+              errorMessage = Utilities::HResultToString(e);
+              errorType = ErrorType::Receive;
+              self->m_errorHandler({errorMessage, errorType});
+            }
           }
         }
       });
@@ -346,7 +355,7 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
     uri = Uri{winrt::to_hstring(url)};
   } catch (hresult_error const &e) {
     if (m_errorHandler) {
-      m_errorHandler({HResultToString(e), ErrorType::Connection});
+      m_errorHandler({Utilities::HResultToString(e), ErrorType::Connection});
     }
 
     // Abort - Mark connection as concluded.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.67.6",
+  "version": "0.67.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
     "@react-native-community/cli": "^6.0.0",
     "@react-native-community/cli-platform-android": "^6.0.0",
     "@react-native-community/cli-platform-ios": "^6.0.0",
-    "@react-native-windows/cli": "0.67.1",
-    "@react-native-windows/virtualized-list": "0.67.0",
+    "@react-native-windows/cli": "0.67.2",
+    "@react-native-windows/virtualized-list": "0.67.1",
     "@react-native/assets": "1.0.0",
     "@react-native/normalize-color": "2.0.0",
     "@react-native/polyfills": "2.0.0",
@@ -57,7 +57,7 @@
     "ws": "^6.1.4"
   },
   "devDependencies": {
-    "@react-native-windows/codegen": "0.67.0",
+    "@react-native-windows/codegen": "0.67.1",
     "@rnw-scripts/eslint-config": "1.1.8",
     "@rnw-scripts/jest-out-of-tree-snapshot-resolver": "^1.0.2",
     "@rnx-kit/jest-preset": "^0.1.0",
@@ -83,7 +83,7 @@
     "react-native": "^0.67.0"
   },
   "beachball": {
-    "defaultNpmTag": "latest",
+    "defaultNpmTag": "v0.67-stable",
     "gitTags": true,
     "disallowedChangeTypes": [
       "major",