win_http_request.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
// cspell:words PCCERT HCERTSTORE
 
#pragma once
 
#include "azure/core/http/win_http_transport.hpp"
#include "azure/core/url.hpp"
 
#if !defined(WIN32_LEAN_AND_MEAN)
#define WIN32_LEAN_AND_MEAN
#endif
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
 
#include <windows.h>
 
#include <memory>
#include <mutex>
#pragma warning(push)
#pragma warning(disable : 6553)
#pragma warning(disable : 6387) // An argument in result_macros.h may be '0', for the function
                                // 'GetProcAddress'.
#include <wincrypt.h>
 
#include <wil\resource.h>
#pragma warning(pop)
#include <winhttp.h>
 
namespace Azure { namespace Core { namespace Http { namespace _detail {
 
  class WinHttpRequest;
  class WinHttpAction final {
 
    // Containing HTTP request, used during the status operation callback.
    WinHttpRequest* const m_httpRequest{};
    wil::unique_event m_actionCompleteEvent;
    // Mutex protecting all mutable members of the class.
    std::mutex m_actionCompleteMutex;
    DWORD m_expectedStatus{};
    DWORD m_stowedError{};
    DWORD_PTR m_stowedErrorInformation{};
    DWORD m_bytesAvailable{};
 
    /*
     * Callback from WinHTTP called after the TLS certificates are received when the caller sets
     * expected TLS root certificates.
     */
    static void CALLBACK StatusCallback(
        HINTERNET hInternet,
        DWORD_PTR dwContext,
        DWORD dwInternetStatus,
        LPVOID lpvStatusInformation,
        DWORD dwStatusInformationLength);
 
    /*
     * Callback from WinHTTP called after the TLS certificates are received when the caller sets
     * expected TLS root certificates.
     */
    void OnHttpStatusOperation(
        HINTERNET hInternet,
        DWORD internetStatus,
        LPVOID statusInformation,
        DWORD statusInformationLength);
 
  public:
    WinHttpAction(WinHttpRequest* request)
        // Create a non-inheritable anonymous manual reset event initialized as unset.
        : m_httpRequest(request), m_actionCompleteEvent(CreateEvent(nullptr, TRUE, FALSE, nullptr))
    {
      if (!m_actionCompleteEvent)
      {
        throw std::runtime_error("Error creating Action Complete Event.");
      }
    }
 
    bool RegisterWinHttpStatusCallback(
        Azure::Core::_internal::UniqueHandle<HINTERNET> const& internetHandle);
 
    bool WaitForAction(
        std::function<void()> initiateAction,
        DWORD expectedCallbackStatus,
        Azure::Core::Context const& context,
        Azure::DateTime::duration const& pollDuration = std::chrono::milliseconds(800));
 
    void CompleteAction();
 
    void CompleteActionWithData(DWORD bytesAvailable);
 
    void CompleteActionWithError(DWORD_PTR stowedErrorInformation, DWORD stowedError);
    DWORD GetStowedError();
    DWORD_PTR GetStowedErrorInformation();
    DWORD GetBytesAvailable();
  };
 
  class WinHttpRequest final {
    bool m_requestHandleClosed{false};
    Azure::Core::_internal::UniqueHandle<HINTERNET> m_requestHandle;
    std::unique_ptr<WinHttpAction> m_httpAction;
    std::vector<std::string> m_expectedTlsRootCertificates;
    wil::unique_cert_context m_tlsClientCertificate;
 
    /*
     * Adds the specified trusted certificates to the specified certificate store.
     */
    bool AddCertificatesToStore(
        std::vector<std::string> const& trustedCertificates,
        HCERTSTORE const hCertStore) const;
    /*
     * Verifies that the certificate context is in the trustedCertificates set of certificates.
     */
    bool VerifyCertificatesInChain(
        std::vector<std::string> const& trustedCertificates,
        PCCERT_CONTEXT serverCertificate) const;
 
  public:
    WinHttpRequest(
        Azure::Core::_internal::UniqueHandle<HINTERNET> const& connectionHandle,
        Azure::Core::Url const& url,
        Azure::Core::Http::HttpMethod const& method,
        PCCERT_CONTEXT tlsClientCertificate,
        WinHttpTransportOptions const& options);
 
    ~WinHttpRequest();
    void MarkRequestHandleClosed() { m_requestHandleClosed = true; };
    void Upload(Azure::Core::Http::Request& request, Azure::Core::Context const& context);
    void SendRequest(Azure::Core::Http::Request& request, Azure::Core::Context const& context);
    void ReceiveResponse(Azure::Core::Context const& context);
    int64_t GetContentLength(HttpMethod requestMethod, HttpStatusCode responseStatusCode);
    std::unique_ptr<RawResponse> SendRequestAndGetResponse(HttpMethod requestMethod);
    size_t ReadData(uint8_t* buffer, size_t bufferSize, Azure::Core::Context const& context);
    void EnableWebSocketsSupport();
    void HandleExpectedTlsRootCertificates(HINTERNET hInternet);
  };
 
  class WinHttpStream final : public Azure::Core::IO::BodyStream {
  private:
    std::unique_ptr<_detail::WinHttpRequest> m_requestHandle;
    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<_detail::WinHttpRequest>& requestHandle, int64_t contentLength)
        : m_requestHandle(std::move(requestHandle)), m_contentLength(contentLength), m_isEOF(false),
          m_streamTotalRead(0)
    {
    }
 
    int64_t Length() const override { return this->m_contentLength; }
  };
 
}}}} // namespace Azure::Core::Http::_detail