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/transport.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 <type_traits>
#include <vector>
#include <winhttp.h>
 
namespace Azure { namespace Core { namespace Http {
 
  namespace _detail {
 
    constexpr static size_t DefaultUploadChunkSize = 1024 * 64;
    constexpr static size_t MaximumUploadChunkSize = 1024 * 1024;
 
    struct HandleManager final
    {
      Context const& m_context;
      Request& m_request;
      HINTERNET m_connectionHandle;
      HINTERNET m_requestHandle;
 
      HandleManager(Request& request, Context const& context)
          : m_request(request), m_context(context)
      {
        m_connectionHandle = NULL;
        m_requestHandle = NULL;
      }
 
      ~HandleManager()
      {
        // Close the handles and set them to null to avoid multiple calls to WinHTTP to close the
        // handles.
        if (m_requestHandle)
        {
          WinHttpCloseHandle(m_requestHandle);
          m_requestHandle = NULL;
        }
 
        if (m_connectionHandle)
        {
          WinHttpCloseHandle(m_connectionHandle);
          m_connectionHandle = NULL;
        }
      }
    };
 
    class WinHttpStream final : public Azure::Core::IO::BodyStream {
    private:
      std::unique_ptr<HandleManager> m_handleManager;
      bool m_isEOF;
 
      int64_t m_contentLength;
 
      int64_t m_streamTotalRead;
 
      size_t OnRead(uint8_t* buffer, size_t count, Azure::Core::Context const& context) override;
 
    public:
      WinHttpStream(std::unique_ptr<HandleManager> handleManager, int64_t contentLength)
          : m_handleManager(std::move(handleManager)), m_contentLength(contentLength),
            m_isEOF(false), m_streamTotalRead(0)
      {
      }
 
      int64_t Length() const override { return this->m_contentLength; }
    };
  } // namespace _detail
 
  struct WinHttpTransportOptions final
  {
    bool IgnoreUnknownCertificateAuthority = false;
  };
 
  class WinHttpTransport final : public HttpTransport {
  private:
    WinHttpTransportOptions m_options;
 
    // This should remain immutable and not be modified after calling the ctor, to avoid threading
    // issues.
    HINTERNET m_sessionHandle = NULL;
 
    HINTERNET CreateSessionHandle();
    void CreateConnectionHandle(std::unique_ptr<_detail::HandleManager>& handleManager);
    void CreateRequestHandle(std::unique_ptr<_detail::HandleManager>& handleManager);
    void Upload(std::unique_ptr<_detail::HandleManager>& handleManager);
    void SendRequest(std::unique_ptr<_detail::HandleManager>& handleManager);
    void ReceiveResponse(std::unique_ptr<_detail::HandleManager>& handleManager);
    int64_t GetContentLength(
        std::unique_ptr<_detail::HandleManager>& handleManager,
        HttpMethod requestMethod,
        HttpStatusCode responseStatusCode);
    std::unique_ptr<RawResponse> SendRequestAndGetResponse(
        std::unique_ptr<_detail::HandleManager> handleManager,
        HttpMethod requestMethod);
 
  public:
    WinHttpTransport(WinHttpTransportOptions const& options = WinHttpTransportOptions());
 
    virtual std::unique_ptr<RawResponse> Send(Request& request, Context const& context) override;
 
    ~WinHttpTransport()
    {
      // Close the handles and set them to null to avoid multiple calls to WinHTTP to close the
      // handles.
      if (m_sessionHandle)
      {
        WinHttpCloseHandle(m_sessionHandle);
        m_sessionHandle = NULL;
      }
    }
  };
 
}}} // namespace Azure::Core::Http