win_http_transport.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "azure/core/context.hpp"
#include "azure/core/http/http.hpp"
#include "azure/core/http/policies/policy.hpp"
#include "azure/core/http/transport.hpp"
#include "azure/core/internal/unique_handle.hpp"
#include "azure/core/platform.hpp"
 
#if defined(AZ_PLATFORM_WINDOWS)
#if !defined(WIN32_LEAN_AND_MEAN)
#define WIN32_LEAN_AND_MEAN
#endif
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#include <windows.h>
#endif
 
#include <memory>
#include <type_traits>
#include <vector>
#include <wincrypt.h>
#include <winhttp.h>
 
namespace Azure { namespace Core {
  namespace _internal {
    template <> struct UniqueHandleHelper<HINTERNET>
    {
      static void FreeHandle(HINTERNET obj) { WinHttpCloseHandle(obj); }
 
      using type = BasicUniqueHandle<void, FreeHandle>;
    };
  } // namespace _internal
 
  namespace Http {
 
    namespace _detail {
 
      constexpr static size_t DefaultUploadChunkSize = 1024 * 64;
      constexpr static size_t MaximumUploadChunkSize = 1024 * 1024;
 
      // Forward declaration for WinHttpRequest.
      class WinHttpRequest;
    } // namespace _detail
 
    struct WinHttpTransportOptions final
    {
      bool IgnoreUnknownCertificateAuthority{false};
 
      bool EnableSystemDefaultProxy{false};
 
      bool EnableCertificateRevocationListCheck{false};
 
      std::string ProxyInformation;
 
      Azure::Nullable<std::string> ProxyUserName;
 
      Azure::Nullable<std::string> ProxyPassword;
 
      std::vector<std::string> ExpectedTlsRootCertificates;
    };
 
    class WinHttpTransport : public HttpTransport {
    private:
      WinHttpTransportOptions m_options;
      // m_sessionhandle is const to ensure immutability.
      const Azure::Core::_internal::UniqueHandle<HINTERNET> m_sessionHandle;
 
      Azure::Core::_internal::UniqueHandle<HINTERNET> CreateSessionHandle();
      Azure::Core::_internal::UniqueHandle<HINTERNET> CreateConnectionHandle(
          Azure::Core::Url const& url,
          Azure::Core::Context const& context);
      std::unique_ptr<_detail::WinHttpRequest> CreateRequestHandle(
          Azure::Core::_internal::UniqueHandle<HINTERNET> const& connectionHandle,
          Azure::Core::Url const& url,
          Azure::Core::Http::HttpMethod const& method);
 
      // Callback to allow a derived transport to extract the request handle. Used for WebSocket
      // transports.
      virtual void OnUpgradedConnection(std::unique_ptr<_detail::WinHttpRequest> const&){};
 
      void GetErrorAndThrow(const std::string& exceptionMessage, DWORD error = GetLastError());
 
    public:
      WinHttpTransport(WinHttpTransportOptions const& options = WinHttpTransportOptions());
 
      WinHttpTransport(Azure::Core::Http::Policies::TransportOptions const& options);
 
      virtual std::unique_ptr<RawResponse> Send(Request& request, Context const& context) override;
 
      // See also:
      // [Core Guidelines C.35: "A base class destructor should be either public
      // and virtual or protected and
      // non-virtual"](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c35-a-base-class-destructor-should-be-either-public-and-virtual-or-protected-and-non-virtual)
      virtual ~WinHttpTransport();
    };
 
  } // namespace Http
}} // namespace Azure::Core