curl_connection_private.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/core/http/http.hpp"
#include "azure/core/internal/unique_handle.hpp"
 
#include <chrono>
#include <string>
 
#if defined(_MSC_VER)
// C6101 : Returning uninitialized memory '*Mtu'->libcurl calling WSAGetIPUserMtu from WS2tcpip.h
#pragma warning(push)
#pragma warning(disable : 6101)
#endif
 
#include <curl/curl.h>
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
 
typedef struct x509_store_ctx_st X509_STORE_CTX;
 
namespace Azure { namespace Core {
  namespace _detail {
    template <> struct UniqueHandleHelper<CURL>
    {
      using type = _internal::BasicUniqueHandle<CURL, curl_easy_cleanup>;
    };
  } // namespace _detail
 
  namespace Http {
    namespace _detail {
      // libcurl CURL_MAX_WRITE_SIZE is 64k. Using same value for default uploading chunk size.
      // This can be customizable in the HttpRequest
      constexpr static size_t DefaultUploadChunkSize = 1024 * 64;
      constexpr static size_t DefaultLibcurlReaderSize = 4 * 1024;
      // Run time error template
      constexpr static const char* DefaultFailedToGetNewConnectionTemplate
          = "Fail to get a new connection for: ";
      constexpr static int32_t DefaultMaxOpenNewConnectionIntentsAllowed = 10;
      // After 3 connections are received from the pool and failed to send a request, the next
      // connections would ask the pool to be clean and spawn new connection.
      constexpr static int32_t RequestPoolResetAfterConnectionFailed = 3;
      // 90 sec -> cleaner wait time before next clean routine
      constexpr static int32_t DefaultCleanerIntervalMilliseconds = 1000 * 90;
      // 60 sec -> expired connection is when it waits for 60 sec or more and it's not re-used
      constexpr static int32_t DefaultConnectionExpiredMilliseconds = 1000 * 60;
      // Define the maximum allowed connections per host-index in the pool. If this number is
      // reached for the host-index, next connections trying to be added to the pool will be
      // ignored.
      constexpr static int32_t MaxConnectionsPerIndex = 1024;
 
    } // namespace _detail
 
    class CurlNetworkConnection {
    private:
      bool m_isShutDown = false;
 
    public:
      virtual ~CurlNetworkConnection() = default;
 
      virtual std::string const& GetConnectionKey() const = 0;
 
      virtual void UpdateLastUsageTime() = 0;
 
      virtual bool IsExpired() = 0;
 
      virtual size_t ReadFromSocket(uint8_t* buffer, size_t bufferSize, Context const& context) = 0;
 
      virtual CURLcode SendBuffer(uint8_t const* buffer, size_t bufferSize, Context const& context)
          = 0;
 
      virtual void Shutdown() { m_isShutDown = true; }
 
      bool IsShutdown() const { return m_isShutDown; }
    };
 
    class CurlConnection final : public CurlNetworkConnection {
    private:
      Azure::Core::_internal::UniqueHandle<CURL> m_handle;
      curl_socket_t m_curlSocket;
      std::chrono::steady_clock::time_point m_lastUseTime;
      std::string m_connectionKey;
      // CRL validation is disabled by default to be consistent with WinHTTP behavior
      bool m_enableCrlValidation{false};
      // Allow the connection to proceed if retrieving the CRL failed.
      bool m_allowFailedCrlRetrieval{true};
 
      static int CurlLoggingCallback(
          CURL* handle,
          curl_infotype type,
          char* data,
          size_t size,
          void* userp);
 
      static int CurlSslCtxCallback(CURL* curl, void* sslctx, void* parm);
      int SslCtxCallback(CURL* curl, void* sslctx);
      int VerifyCertificateError(int ok, X509_STORE_CTX* storeContext);
 
    public:
      CurlConnection(
          Azure::Core::Http::Request& request,
          Azure::Core::Http::CurlTransportOptions const& options,
          std::string const& hostDisplayName,
          std::string const& connectionPropertiesKey);
 
      ~CurlConnection() override {}
 
      std::string const& GetConnectionKey() const override { return this->m_connectionKey; }
 
      void UpdateLastUsageTime() override
      {
        this->m_lastUseTime = std::chrono::steady_clock::now();
      }
 
      bool IsExpired() override
      {
        auto connectionOnWaitingTimeMs = std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::steady_clock::now() - this->m_lastUseTime);
        return connectionOnWaitingTimeMs.count() >= _detail::DefaultConnectionExpiredMilliseconds;
      }
 
      size_t ReadFromSocket(uint8_t* buffer, size_t bufferSize, Context const& context) override;
 
      CURLcode SendBuffer(uint8_t const* buffer, size_t bufferSize, Context const& context)
          override;
    };
  } // namespace Http
}} // namespace Azure::Core