curl_session_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 "curl_connection_pool_private.hpp"
#include "curl_connection_private.hpp"
 
#include <memory>
#include <string>
 
#ifdef _azure_TESTING_BUILD
// Define the class name that reads from ConnectionPool private members
namespace Azure { namespace Core { namespace Test {
  class CurlConnectionPool_connectionPoolTest_Test;
  class SdkWithLibcurl_globalCleanUp_Test;
}}} // namespace Azure::Core::Test
#endif
 
namespace Azure { namespace Core { namespace Http {
 
  class CurlSession final : public Azure::Core::IO::BodyStream {
#ifdef _azure_TESTING_BUILD
    // Give access to private to this tests class
    friend class Azure::Core::Test::CurlConnectionPool_connectionPoolTest_Test;
    friend class Azure::Core::Test::SdkWithLibcurl_globalCleanUp_Test;
#endif
  private:
    void ReadExpected(uint8_t expected, Context const& context);
 
    void ReadCRLF(Context const& context);
 
    enum class SessionState
    {
      PERFORM,
      STREAMING
    };
 
    /*
     * Enum used by ResponseBufferParser to control the parsing internal state while building
     * the HTTP RawResponse
     *
     */
    enum class ResponseParserState
    {
      StatusLine,
      Headers,
      EndOfHeaders,
    };
 
    class ResponseBufferParser final {
    private:
      ResponseParserState state = ResponseParserState::StatusLine;
      std::unique_ptr<RawResponse> m_response;
      bool m_parseCompleted = false;
 
      bool m_delimiterStartInPrevPosition = false;
 
      std::string m_internalBuffer;
 
      size_t BuildStatusCode(uint8_t const* const buffer, size_t const bufferSize);
 
      size_t BuildHeader(uint8_t const* const buffer, size_t const bufferSize);
 
    public:
      ResponseBufferParser() {}
 
      size_t Parse(uint8_t const* const buffer, size_t const bufferSize);
 
      bool IsParseCompleted() const { return m_parseCompleted; }
 
      std::unique_ptr<RawResponse> ExtractResponse()
      {
        if (m_parseCompleted && m_response != nullptr)
        {
          return std::move(m_response);
        }
        return nullptr; // parse is not completed or response has been moved already.
      }
    };
 
    SessionState m_sessionState = SessionState::PERFORM;
 
    std::unique_ptr<CurlNetworkConnection> m_connection;
 
    std::unique_ptr<RawResponse> m_response;
 
    Request& m_request;
 
    size_t m_bodyStartInBuffer = _detail::DefaultLibcurlReaderSize;
 
    size_t m_innerBufferSize = _detail::DefaultLibcurlReaderSize;
 
    bool m_isChunkedResponseType = false;
 
    int64_t m_contentLength = 0;
 
    size_t m_chunkSize = 0;
 
    size_t m_sessionTotalRead = 0;
 
    bool m_connectionUpgraded = false;
 
    uint8_t m_readBuffer[_detail::DefaultLibcurlReaderSize]
        = {0}; // to work with libcurl custom read.
 
    CURLcode SendRawHttp(Context const& context);
 
    CURLcode UploadBody(Context const& context);
 
    CURLcode ReadStatusLineAndHeadersFromRawResponse(
        Context const& context,
        bool reuseInternalBuffer = false);
 
    void ParseChunkSize(Context const& context);
 
    Http::HttpStatusCode m_lastStatusCode = Http::HttpStatusCode::BadRequest;
 
    bool m_httpKeepAlive = false;
 
    bool IsEOF()
    {
      auto eof = m_isChunkedResponseType
          ? m_chunkSize == 0
          : static_cast<size_t>(m_contentLength) == m_sessionTotalRead;
 
      // `IsEOF` is called before trying to move a connection back to the connection pool.
      // If the session state is `PERFORM` it means the request could not complete an upload
      // operation (might have throw while uploading).
      // Connection should not be moved back to the connection pool on this scenario.
      return eof && m_sessionState != SessionState::PERFORM;
    }
 
    bool m_keepAlive = true;
 
    Azure::Nullable<std::string> m_httpProxy;
    Azure::Nullable<std::string> m_httpProxyUser;
    Azure::Nullable<std::string> m_httpProxyPassword;
 
    size_t OnRead(uint8_t* buffer, size_t count, Azure::Core::Context const& context) override;
 
    inline std::string GetHTTPMessagePreBody(Azure::Core::Http::Request const& request);
    inline std::string GetHeadersAsString(Azure::Core::Http::Request const& request);
    inline static void SetHeader(
        Azure::Core::Http::RawResponse& response,
        std::string const& header);
 
  public:
    CurlSession(
        Request& request,
        std::unique_ptr<CurlNetworkConnection> connection,
        CurlTransportOptions curlOptions)
        : m_connection(std::move(connection)), m_request(request),
          m_keepAlive(curlOptions.HttpKeepAlive), m_httpProxy(curlOptions.Proxy),
          m_httpProxyUser(curlOptions.ProxyUsername), m_httpProxyPassword(curlOptions.ProxyPassword)
    {
    }
 
    ~CurlSession() override
    {
      // mark connection as reusable only if entire response was read
      // If not, connection can't be reused because next Read will start from what it is currently
      // in the wire.
      // By not moving the connection back to the pool, it gets destroyed calling the connection
      // destructor to clean libcurl handle and close the connection.
      // IsEOF will also handle a connection that fail to complete an upload request.
      if (IsEOF() && m_keepAlive && !m_connectionUpgraded)
      {
        _detail::CurlConnectionPool::g_curlConnectionPool.MoveConnectionBackToPool(
            std::move(m_connection), m_httpKeepAlive);
      }
    }
 
    CURLcode Perform(Context const& context);
 
    std::unique_ptr<Azure::Core::Http::RawResponse> ExtractResponse();
 
    int64_t Length() const override { return m_contentLength; }
 
    std::unique_ptr<CurlNetworkConnection> ExtractConnection();
  };
 
}}} // namespace Azure::Core::Http