react-native-windows 0.68.1 → 0.69.0-preview.1

package/Shared/Networking/OriginPolicyHttpFilter.h

@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "OriginPolicy.h"
+
+// Windows API
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Web.Http.Filters.h>
+#include <winrt/Windows.Web.Http.h>
+
+// Standard Library
+#include <set>
+
+namespace Microsoft::React::Networking {
+
+class OriginPolicyHttpFilter
+    : public winrt::implements<OriginPolicyHttpFilter, winrt::Windows::Web::Http::Filters::IHttpFilter> {
+ public:
+  struct ConstWcharComparer {
+    bool operator()(const wchar_t *, const wchar_t *) const;
+  };
+
+ private:
+  static std::set<const wchar_t *, ConstWcharComparer> s_forbiddenMethods;
+  static std::set<const wchar_t *, ConstWcharComparer> s_simpleCorsMethods;
+  static std::set<const wchar_t *, ConstWcharComparer> s_simpleCorsRequestHeaderNames;
+  static std::set<const wchar_t *, ConstWcharComparer> s_simpleCorsResponseHeaderNames;
+  static std::set<const wchar_t *, ConstWcharComparer> s_simpleCorsContentTypeValues;
+  static std::set<const wchar_t *, ConstWcharComparer> s_corsForbiddenRequestHeaderNames;
+  static std::set<const wchar_t *, ConstWcharComparer> s_corsForbiddenRequestHeaderNamePrefixes;
+  static std::set<const wchar_t *, ConstWcharComparer> s_cookieSettingResponseHeaders;
+
+  // NOTE: Assumes static origin through owning client/resource/module/(React) instance's lifetime.
+  static winrt::Windows::Foundation::Uri s_origin;
+
+  struct AccessControlValues {
+    winrt::hstring AllowedOrigin;
+    winrt::hstring AllowedCredentials;
+    std::set<std::wstring> AllowedHeaders;
+    std::set<std::wstring> AllowedMethods;
+    std::set<std::wstring> ExposedHeaders;
+    size_t MaxAge;
+  };
+
+  winrt::Windows::Web::Http::Filters::IHttpFilter m_innerFilter;
+
+ public:
+  static void SetStaticOrigin(std::string &&url);
+
+  static bool IsSameOrigin(
+      winrt::Windows::Foundation::Uri const &u1,
+      winrt::Windows::Foundation::Uri const &u2) noexcept;
+
+  static winrt::Windows::Foundation::Uri GetOrigin(winrt::Windows::Foundation::Uri const &uri) noexcept;
+
+  static bool IsSimpleCorsRequest(winrt::Windows::Web::Http::HttpRequestMessage const &request) noexcept;
+
+  static bool AreSafeRequestHeaders(
+      winrt::Windows::Web::Http::Headers::HttpRequestHeaderCollection const &headers) noexcept;
+
+  static std::set<const wchar_t *> CorsUnsafeNotForbiddenRequestHeaderNames(
+      winrt::Windows::Web::Http::Headers::HttpRequestHeaderCollection const &headers) noexcept;
+
+  static AccessControlValues ExtractAccessControlValues(
+      winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::hstring> const &headers);
+
+  static bool IsCorsSafelistedRequestHeader(winrt::hstring const &name, winrt::hstring const &value) noexcept;
+
+  static bool IsCorsUnsafeRequestHeaderByte(wchar_t c) noexcept;
+
+  // Filter out Http-Only cookies from response headers to prevent malicious code from being sent to a malicious server
+  static void RemoveHttpOnlyCookiesFromResponseHeaders(
+      winrt::Windows::Web::Http::HttpResponseMessage const &response,
+      bool removeAll);
+
+  OriginPolicyHttpFilter(winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilter);
+
+  OriginPolicyHttpFilter();
+
+  OriginPolicy ValidateRequest(winrt::Windows::Web::Http::HttpRequestMessage const &request);
+
+  void ValidatePreflightResponse(
+      winrt::Windows::Web::Http::HttpRequestMessage const &request,
+      winrt::Windows::Web::Http::HttpResponseMessage const &response) const;
+
+  void ValidateResponse(
+      winrt::Windows::Web::Http::HttpResponseMessage const &response,
+      const OriginPolicy effectivePolicy) const;
+
+  void ValidateAllowOrigin(
+      winrt::hstring const &allowedOrigin,
+      winrt::hstring const &allowCredentials,
+      winrt::Windows::Foundation::IInspectable const &iArgs) const;
+
+  winrt::Windows::Foundation::IAsyncOperationWithProgress<
+      winrt::Windows::Web::Http::HttpResponseMessage,
+      winrt::Windows::Web::Http::HttpProgress>
+  SendPreflightAsync(winrt::Windows::Web::Http::HttpRequestMessage const &request) const;
+
+#pragma region IHttpFilter
+
+  winrt::Windows::Foundation::IAsyncOperationWithProgress<
+      winrt::Windows::Web::Http::HttpResponseMessage,
+      winrt::Windows::Web::Http::HttpProgress>
+  SendRequestAsync(winrt::Windows::Web::Http::HttpRequestMessage const &request);
+
+#pragma endregion IHttpFilter
+};
+
+} // namespace Microsoft::React::Networking

package/Shared/Networking/WinRTHttpResource.cpp

@@ -0,0 +1,347 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "WinRTHttpResource.h"
+
+#include <CppRuntimeOptions.h>
+#include <Utils/CppWinrtLessExceptions.h>
+#include <Utils/WinRTConversions.h>
+#include <utilities.h>
+#include "OriginPolicyHttpFilter.h"
+
+// Boost Libraries
+#include <boost/algorithm/string.hpp>
+
+// 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::IInspectable;
+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::Networking {
+
+#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};
+
+    auto args = winrt::make<RequestArgs>();
+    auto concreteArgs = args.as<RequestArgs>();
+    concreteArgs->RequestId = requestId;
+    concreteArgs->Headers = std::move(headers);
+    concreteArgs->Body = std::move(bodyData);
+    concreteArgs->IncrementalUpdates = useIncrementalUpdates;
+    concreteArgs->WithCredentials = withCredentials;
+    concreteArgs->IsText = responseType == "text";
+    concreteArgs->Timeout = timeout;
+
+    PerformSendRequest(std::move(request), args);
+  } 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*/ {
+  ResponseOperation 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, 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, ResponseOperation 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(HttpRequestMessage &&request, IInspectable const &args) noexcept {
+  // Keep references after coroutine suspension.
+  auto self = shared_from_this();
+  auto coRequest = std::move(request);
+  auto coArgs = args;
+  auto coReqArgs = coArgs.as<RequestArgs>();
+
+  // Ensure background thread
+  co_await winrt::resume_background();
+
+  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 : coReqArgs->Headers) {
+    if (boost::iequals(header.first.c_str(), "Content-Type")) {
+      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), contentType);
+      if (!success && m_onError) {
+        co_return m_onError(coReqArgs->RequestId, "Failed to parse Content-Type");
+      }
+    } else if (boost::iequals(header.first.c_str(), "Content-Encoding")) {
+      contentEncoding = header.second;
+    } else if (boost::iequals(header.first.c_str(), "Content-Length")) {
+      contentLength = header.second;
+    } else if (boost::iequals(header.first.c_str(), "Authorization")) {
+      bool success =
+          coRequest.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
+      if (!success && m_onError) {
+        co_return m_onError(coReqArgs->RequestId, "Failed to append Authorization");
+      }
+    } else {
+      try {
+        coRequest.Headers().Append(to_hstring(header.first), to_hstring(header.second));
+      } catch (hresult_error const &e) {
+        if (self->m_onError) {
+          co_return self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(e));
+        }
+      }
+    }
+  }
+
+  IHttpContent content{nullptr};
+  if (BodyData::Type::String == coReqArgs->Body.Type) {
+    content = HttpStringContent{to_hstring(coReqArgs->Body.Data)};
+  } else if (BodyData::Type::Base64 == coReqArgs->Body.Type) {
+    auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(coReqArgs->Body.Data));
+    content = HttpBufferContent{buffer};
+  } else if (BodyData::Type::Uri == coReqArgs->Body.Type) {
+    auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(coReqArgs->Body.Data)});
+    auto stream = co_await file.OpenReadAsync();
+    content = HttpStreamContent{stream};
+  } else if (BodyData::Type::Form == coReqArgs->Body.Type) {
+    // #9535 - HTTP form data support
+  } else {
+    // BodyData::Type::Empty
+    // TODO: Error => 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(coReqArgs->RequestId, "Failed to parse Content-Encoding");
+        }
+        co_return;
+      }
+    }
+    if (!contentLength.empty()) {
+      const auto contentLengthHeader = _atoi64(contentLength.c_str());
+      content.Headers().ContentLength(contentLengthHeader);
+    }
+
+    coRequest.Content(content);
+  }
+
+  try {
+    coRequest.Properties().Insert(L"RequestArgs", coArgs);
+    auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
+    self->TrackResponse(coReqArgs->RequestId, sendRequestOp);
+
+    co_await lessthrow_await_adapter<ResponseOperation>{sendRequestOp};
+    auto result = sendRequestOp.ErrorCode();
+    if (result < 0) {
+      if (self->m_onError) {
+        self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(std::move(result)));
+      }
+      co_return self->UntrackResponse(coReqArgs->RequestId);
+    }
+
+    auto response = sendRequestOp.GetResults();
+    if (response) {
+      if (self->m_onResponse) {
+        string url = to_string(response.RequestMessage().RequestUri().AbsoluteUri());
+
+        // Gather headers for both the response content and the response itself
+        // See Invoke-WebRequest PowerShell cmdlet or Chromium response handling
+        Headers responseHeaders;
+        for (auto header : response.Headers()) {
+          responseHeaders.emplace(to_string(header.Key()), to_string(header.Value()));
+        }
+        for (auto header : response.Content().Headers()) {
+          responseHeaders.emplace(to_string(header.Key()), to_string(header.Value()));
+        }
+
+        self->m_onResponse(
+            coReqArgs->RequestId,
+            {static_cast<int32_t>(response.StatusCode()), std::move(url), std::move(responseHeaders)});
+      }
+    }
+
+    // #9534 - Support HTTP incremental updates
+    if (response && response.Content()) {
+      auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
+      auto reader = DataReader{inputStream};
+
+      if (coReqArgs->IsText) {
+        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+      }
+
+      // #9510 - 10mb limit on fetch
+      co_await reader.LoadAsync(10 * 1024 * 1024);
+      auto length = reader.UnconsumedBufferLength();
+
+      if (coReqArgs->IsText) {
+        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(coReqArgs->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(coReqArgs->RequestId, std::move(responseData));
+        }
+      }
+    } else {
+      if (self->m_onError) {
+        self->m_onError(coReqArgs->RequestId, response == nullptr ? "request failed" : "No response content");
+      }
+    }
+  } catch (std::exception const &e) {
+    if (self->m_onError) {
+      self->m_onError(coReqArgs->RequestId, e.what());
+    }
+  } catch (hresult_error const &e) {
+    if (self->m_onError) {
+      self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(e));
+    }
+  } catch (...) {
+    if (self->m_onError) {
+      self->m_onError(coReqArgs->RequestId, "Unhandled exception during request");
+    }
+  }
+
+  self->UntrackResponse(coReqArgs->RequestId);
+}
+
+#pragma endregion WinRTHttpResource
+
+#pragma region IHttpResource
+
+/*static*/ shared_ptr<IHttpResource> IHttpResource::Make() noexcept {
+  if (static_cast<OriginPolicy>(GetRuntimeOptionInt("Http.OriginPolicy")) == OriginPolicy::None) {
+    return std::make_shared<WinRTHttpResource>();
+  } else {
+    auto globalOrigin = GetRuntimeOptionString("Http.GlobalOrigin");
+    OriginPolicyHttpFilter::SetStaticOrigin(std::move(globalOrigin));
+    auto opFilter = winrt::make<OriginPolicyHttpFilter>();
+    auto client = winrt::Windows::Web::Http::HttpClient{opFilter};
+
+    return std::make_shared<WinRTHttpResource>(std::move(client));
+  }
+}
+
+#pragma endregion IHttpResource
+
+} // namespace Microsoft::React::Networking

package/Shared/Networking/WinRTHttpResource.h

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IHttpResource.h"
+
+#include "WinRTTypes.h"
+
+// Windows API
+#include <winrt/Windows.Web.Http.h>
+
+// Standard Library
+#include <mutex>
+
+namespace Microsoft::React::Networking {
+
+class WinRTHttpResource : public IHttpResource, public std::enable_shared_from_this<WinRTHttpResource> {
+  static int64_t s_lastRequestId;
+
+  winrt::Windows::Web::Http::IHttpClient m_client;
+  std::mutex m_mutex;
+  std::unordered_map<int64_t, ResponseOperation> 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, ResponseOperation response) noexcept;
+
+  void UntrackResponse(int64_t requestId) noexcept;
+
+  winrt::fire_and_forget PerformSendRequest(
+      winrt::Windows::Web::Http::HttpRequestMessage &&request,
+      winrt::Windows::Foundation::IInspectable const &args) 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::Networking

package/Shared/Networking/WinRTTypes.h

@@ -0,0 +1,30 @@
+// 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::Networking {
+
+struct RequestArgs : public winrt::implements<RequestArgs, winrt::Windows::Foundation::IInspectable> {
+  int64_t RequestId;
+  IHttpResource::Headers Headers;
+  IHttpResource::BodyData Body;
+  bool IncrementalUpdates;
+  bool WithCredentials;
+  bool IsText;
+  int64_t Timeout;
+};
+
+typedef winrt::Windows::Foundation::
+    IAsyncOperationWithProgress<winrt::Windows::Web::Http::HttpResponseMessage, winrt::Windows::Web::Http::HttpProgress>
+        ResponseOperation;
+
+} // namespace Microsoft::React::Networking

package/Shared/{WinRTWebSocketResource.cpp → Networking/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,20 +77,9 @@ 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 {
+namespace Microsoft::React::Networking {
 
 // private
 WinRTWebSocketResource::WinRTWebSocketResource(
@@ -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.
@@ -414,4 +423,4 @@ void WinRTWebSocketResource::SetOnError(function<void(Error &&)> &&handler) noex
 
 #pragma endregion IWebSocketResource
 
-} // namespace Microsoft::React
+} // namespace Microsoft::React::Networking