#include <XrdClHttpOps.hh>

Inheritance diagram for XrdClHttp::CurlVectorReadOp:

Collaboration diagram for XrdClHttp::CurlVectorReadOp:

Public Member Functions
	CurlVectorReadOp (XrdCl::ResponseHandler handler, const std::string &url, struct timespec timeout, const XrdCl::ChunkList &op_list, XrdCl::Log logger, CreateConnCalloutType callout, HeaderCallout *header_callout)

virtual	~CurlVectorReadOp ()

void	Fail (uint16_t errCode, uint32_t errNum, const std::string &msg) override

virtual HttpVerb	GetVerb () const override

void	ReleaseHandle () override

void	SetSeparator (const std::string &sep)

void	SetStatusCode (int sc)

bool	Setup (CURL *curl, CurlWorker &) override

void	Success () override

size_t	Write (char *buffer, size_t size)

Public Member Functions inherited from XrdClHttp::CurlOperation
	CurlOperation (const CurlOperation &)=delete

	CurlOperation (XrdCl::ResponseHandler handler, const std::string &url, std::chrono::steady_clock::time_point expiry, XrdCl::Log log, CreateConnCalloutType, HeaderCallout *header_callout)

	CurlOperation (XrdCl::ResponseHandler handler, const std::string &url, struct timespec timeout, XrdCl::Log log, CreateConnCalloutType, HeaderCallout *header_callout)

virtual	~CurlOperation ()

virtual bool	ContinueHandle ()

bool	FinishSetup (CURL *curl)

std::pair< XErrorCode, std::string >	GetCallbackError () const

CreateConnCalloutType	GetConnCalloutFunc () const

std::string	GetCurlErrorMessage () const

CURL *	GetCurlHandle () const

OpError	GetError () const

std::chrono::steady_clock::time_point	GetHeaderExpiry () const

std::chrono::steady_clock::time_point	GetOperationExpiry ()

std::unique_ptr< ResponseInfo >	GetResponseInfo ()

int	GetStatusCode () const

std::string	GetStatusMessage () const

bool	GetTriedBoker () const

const std::string &	GetUrl () const

bool	HasFailed () const

bool	HeaderTimeoutExpired (const std::chrono::steady_clock::time_point &now)

bool	IsDone () const

bool	IsPaused () const

bool	IsRedirect () const

std::unique_ptr< ResponseInfo >	MoveResponseInfo ()

bool	OperationTimeoutExpired (const std::chrono::steady_clock::time_point &now)

virtual void	OptionsDone ()

virtual RedirectAction	Redirect (std::string &target)

virtual bool	RequiresOptions () const

virtual void	SetContinueQueue (std::shared_ptr< XrdClHttp::HandlerQueue > queue)

void	SetTriedBoker ()

bool	StartConnectionCallout (std::string &err)

std::tuple< uint64_t, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration, std::chrono::steady_clock::duration >	StatisticsReset ()

bool	TransferStalled (uint64_t xfer_bytes, const std::chrono::steady_clock::time_point &now)

bool	UseConnectionCallout ()

virtual int	WaitSocket ()

virtual int	WaitSocketCallback (std::string &err)

Protected Attributes
off_t	m_bytes_consumed {0}

off_t	m_chunk_buffer_idx {0}

XrdCl::ChunkList	m_chunk_list

std::pair< off_t, off_t >	m_current_op {-1, -1}

std::string	m_header_line

std::string	m_response_headers

size_t	m_response_idx {0}

uint64_t	m_skip_bytes {0}

std::unique_ptr< XrdCl::VectorReadInfo >	m_vr

Protected Attributes inherited from XrdClHttp::CurlOperation
std::unique_ptr< CURL, void()(CURL )>	m_curl

XrdCl::ResponseHandler *	m_handler {nullptr}

HeaderCallout *	m_header_callout

std::chrono::steady_clock::time_point	m_header_expiry

HeaderParser	m_headers

std::vector< std::pair< std::string, std::string > >	m_headers_list

XrdCl::Log *	m_logger

int	m_minimum_rate {m_minimum_transfer_rate}

std::chrono::steady_clock::time_point	m_operation_expiry

const std::string	m_url

Additional Inherited Members
Public Types inherited from XrdClHttp::CurlOperation
using	HeaderList = std::vector< std::pair< std::string, std::string > >

enum class	HttpVerb { COPY , DELETE , HEAD , GET , MKCOL , OPTIONS , PROPFIND , PUT , Count }

enum	OpError { ErrNone , ErrHeaderTimeout , ErrCallback , ErrOperationTimeout , ErrTransferClientStall , ErrTransferStall , ErrTransferSlow }

enum class	RedirectAction { Fail , Reinvoke , ReinvokeAfterAllow }

Static Public Member Functions inherited from XrdClHttp::CurlOperation
static void	CleanupDnsCache ()

static int	GetDefaultSlowRateBytesSec ()

static int	GetDefaultStallTimeout ()

static const std::string	GetVerbString (HttpVerb)

static void	SetSlowRateBytesSec (int rate)

static void	SetStallTimeout (const std::chrono::steady_clock::duration &stall_interval)

static void	SetStallTimeout (int stall_interval)

Protected Member Functions inherited from XrdClHttp::CurlOperation
int	FailCallback (XErrorCode ecode, const std::string &emsg)

void	SetDone (bool has_failed)

void	SetPaused (bool paused)

void	UpdateBytes (uint64_t bytes)

Static Protected Attributes inherited from XrdClHttp::CurlOperation
static constexpr int	m_default_minimum_rate {1024 * 256}

static int	m_minimum_transfer_rate {CurlOperation::m_default_minimum_rate}

Detailed Description

Definition at line 698 of file XrdClHttpOps.hh.

Constructor & Destructor Documentation

◆ CurlVectorReadOp()

CurlVectorReadOp::CurlVectorReadOp	(	XrdCl::ResponseHandler *	handler,
		const std::string &	url,
		struct timespec	timeout,
		const XrdCl::ChunkList &	op_list,
		XrdCl::Log *	logger,
		CreateConnCalloutType	callout,
		HeaderCallout *	header_callout
	)

Definition at line 30 of file XrdClHttpOpReadV.cc.

                                    :
         CurlOperation(handler, url, timeout, logger, callout, header_callout),
         m_vr(new XrdCl::VectorReadInfo()),
         m_chunk_list(op_list)
     {}

◆ ~CurlVectorReadOp()

virtual XrdClHttp::CurlVectorReadOp::~CurlVectorReadOp ( )

inlinevirtual

Definition at line 704 of file XrdClHttpOps.hh.

704 {}

Member Function Documentation

◆ Fail()

void CurlVectorReadOp::Fail	(	uint16_t	errCode,
		uint32_t	errNum,
		const std::string &	msg
	)

overridevirtual

Reimplemented from XrdClHttp::CurlOperation.

Definition at line 61 of file XrdClHttpOpReadV.cc.

 {
     std::string custom_msg = msg;
     SetDone(true);
     if (m_handler == nullptr) {return;}
     std::string offset = "(unknown)";
     std::string length = "(unknown)";
     if (!m_chunk_list.empty()) {
         offset = std::to_string(m_chunk_list[0].GetOffset());
         length = std::to_string(m_chunk_list[0].GetLength());
     }
     if (!custom_msg.empty()) {
         m_logger->Debug(kLogXrdClHttp, "curl operation with vector starting offset %s / length %s failed with message: %s", offset.c_str(), length.c_str(), custom_msg.c_str());
         custom_msg += " (vector read operation starting at offset " + offset + " / length " + length + ")";
     } else {
         m_logger->Debug(kLogXrdClHttp, "curl vector operation starting at offset %s / length %s failed with status code %d", offset.c_str(), length.c_str(), errNum);
     }
     auto status = new XrdCl::XRootDStatus(XrdCl::stError, errCode, errNum, custom_msg);
     auto handle = m_handler;
     m_handler = nullptr;
     handle->HandleResponse(status, nullptr);
 }

References XrdCl::Log::Debug(), XrdCl::ResponseHandler::HandleResponse(), XrdClHttp::kLogXrdClHttp, m_chunk_list, XrdClHttp::CurlOperation::m_handler, XrdClHttp::CurlOperation::m_logger, XrdClHttp::CurlOperation::SetDone(), and XrdCl::stError.

Here is the call graph for this function:

◆ GetVerb()

virtual HttpVerb XrdClHttp::CurlVectorReadOp::GetVerb ( ) const

inlineoverridevirtual

Implements XrdClHttp::CurlOperation.

Definition at line 725 of file XrdClHttpOps.hh.

725 {return HttpVerb::GET;}

◆ ReleaseHandle()

void CurlVectorReadOp::ReleaseHandle ( )

overridevirtual

Reimplemented from XrdClHttp::CurlOperation.

Definition at line 107 of file XrdClHttpOpReadV.cc.

 {
     if (m_curl == nullptr) return;
     curl_easy_setopt(m_curl.get(), CURLOPT_WRITEFUNCTION, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_WRITEDATA, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_HTTPHEADER, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETFUNCTION, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_OPENSOCKETDATA, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTFUNCTION, nullptr);
     curl_easy_setopt(m_curl.get(), CURLOPT_SOCKOPTDATA, nullptr);
     CurlOperation::ReleaseHandle();
 }

References XrdClHttp::CurlOperation::m_curl, and XrdClHttp::CurlOperation::ReleaseHandle().

Here is the call graph for this function:

◆ SetSeparator()

void XrdClHttp::CurlVectorReadOp::SetSeparator ( const std::string & sep )

inline

Definition at line 713 of file XrdClHttpOps.hh.

                                                 {
             m_headers.SetMultipartSeparator(sep);
         }

References XrdClHttp::CurlOperation::m_headers, and XrdClHttp::HeaderParser::SetMultipartSeparator().

Here is the call graph for this function:

◆ SetStatusCode()

void XrdClHttp::CurlVectorReadOp::SetStatusCode ( int sc )

inline

Definition at line 718 of file XrdClHttpOps.hh.

718 {m_headers.SetStatusCode(sc);}

XrdClHttp::HeaderParser::SetStatusCode

void SetStatusCode(int sc)

Definition: XrdClHttpUtil.hh:94

References XrdClHttp::CurlOperation::m_headers, and XrdClHttp::HeaderParser::SetStatusCode().

Here is the call graph for this function:

◆ Setup()

bool CurlVectorReadOp::Setup	(	CURL *	curl,
		CurlWorker &	worker
	)

overridevirtual

Reimplemented from XrdClHttp::CurlOperation.

Definition at line 39 of file XrdClHttpOpReadV.cc.

 {
     if (!CurlOperation::Setup(curl, worker)) return false;
     curl_easy_setopt(m_curl.get(), CURLOPT_WRITEFUNCTION, CurlVectorReadOp::WriteCallback);
     curl_easy_setopt(m_curl.get(), CURLOPT_WRITEDATA, this);
  
     std::stringstream ss;
     auto multiple = false;
     for (const auto &chunk : m_chunk_list) {
         if (!chunk.GetLength()) continue;
         if (multiple) {ss << ",";}
         ss << chunk.GetOffset() << "-" << chunk.GetOffset() + chunk.GetLength() - 1;
         multiple = true;
     }
     auto byte_range_val = ss.str();
     if (byte_range_val.size()) {
         m_headers_list.emplace_back("Range", "bytes=" + byte_range_val);
     }
     return true;
 }

References m_chunk_list, XrdClHttp::CurlOperation::m_curl, XrdClHttp::CurlOperation::m_headers_list, and XrdClHttp::CurlOperation::Setup().

Here is the call graph for this function:

◆ Success()

void CurlVectorReadOp::Success ( )

overridevirtual

Implements XrdClHttp::CurlOperation.

Definition at line 85 of file XrdClHttpOpReadV.cc.

 {
     SetDone(false);
     if (m_handler == nullptr) {return;}
  
     // If there's a partial last response, give it to the client.
     if (m_chunk_buffer_idx) {
         auto &chunk = m_chunk_list[m_response_idx];
         m_vr->GetChunks().emplace_back(chunk.GetOffset(), m_chunk_buffer_idx, chunk.GetBuffer());
         m_bytes_consumed += m_chunk_buffer_idx;
     }
  
     auto status = new XrdCl::XRootDStatus();
     m_vr->SetSize(m_bytes_consumed);
     auto obj = new XrdCl::AnyObject();
     obj->Set(m_vr.release());
     auto handle = m_handler;
     m_handler = nullptr;
     handle->HandleResponse(status, obj);
 }

References XrdCl::ResponseHandler::HandleResponse(), m_bytes_consumed, m_chunk_buffer_idx, m_chunk_list, XrdClHttp::CurlOperation::m_handler, m_response_idx, m_vr, and XrdClHttp::CurlOperation::SetDone().

Here is the call graph for this function:

◆ Write()

size_t CurlVectorReadOp::Write	(	char *	buffer,
		size_t	size
	)

Definition at line 128 of file XrdClHttpOpReadV.cc.

 {
     UpdateBytes(orig_length);
     //m_logger->Debug(kLogXrdClHttp, "Received a write of size %ld with contents:\n%s", static_cast<long>(orig_length), std::string(orig_buffer, orig_length).c_str());
  
     // Handle the (hopefully uncommon) cases where the server responds to a vector read op
     // with a single response.  We set the length of the response to the max as we
     // don't care how many bytes the server actually sends.
     if (GetStatusCode() == 200) {
         m_current_op.first = 0;
         m_current_op.second = std::numeric_limits<off_t>::max();
     } else if (HTTPStatusIsError(GetStatusCode())) {
         return orig_length;
     } else if (!m_headers.IsMultipartByterange()) {
         m_current_op.first = m_headers.GetOffset();
         m_current_op.second = std::numeric_limits<off_t>::max();
     }
  
     auto buffer = orig_buffer;
     auto length = orig_length;
  
     while (length) {
         // If we're in the middle of a response chunk, copy as much data as possible.
         if (m_current_op.first != -1 && m_current_op.second != -1) {
             //m_logger->Debug(kLogXrdClHttp, "Processing response buffer of (%lld, %lld)", static_cast<long long>(m_current_op.first), static_cast<long long>(m_current_op.second));
             if (m_skip_bytes) {
                 //m_logger->Debug(kLogXrdClHttp, "Skipping %lld bytes", static_cast<long long>(m_skip_bytes));
                 auto to_skip = (m_skip_bytes < length) ? m_skip_bytes : length;
                 buffer += to_skip;
                 length -= to_skip;
                 m_skip_bytes -= to_skip;
                 continue;
             } else {
                 auto &chunk = m_chunk_list[m_response_idx];
                 auto remaining = static_cast<off_t>(chunk.GetLength()) - m_chunk_buffer_idx;
                 if (remaining < 0) {
                     return FailCallback(kXR_ServerError, "Invalid chunk framing");
                 }
                 auto to_copy = (static_cast<size_t>(remaining) < length) ? static_cast<size_t>(remaining) : length;
                 //m_logger->Debug(kLogXrdClHttp, "Copying %lld bytes to request buffer %ld at offset %lld", static_cast<long long>(to_copy), m_response_idx, static_cast<long long>(m_chunk_buffer_idx));
                 memcpy(static_cast<char *>(chunk.GetBuffer()) + m_chunk_buffer_idx, buffer, to_copy);
                 m_chunk_buffer_idx += to_copy;
                 buffer += to_copy;
                 length -= to_copy;
                 // Handle cases where the requested or response chunk is complete
                 if (chunk.GetLength() == m_chunk_buffer_idx) {
                     m_vr->GetChunks().emplace_back(chunk.GetOffset(), m_chunk_buffer_idx, chunk.GetBuffer());
                     m_bytes_consumed += m_chunk_buffer_idx;
                     m_chunk_buffer_idx = 0;
                     m_response_idx++;
                     if (m_current_op.second == chunk.GetLength()) {
                         m_current_op.first = m_current_op.second = -1;
                         m_multipart_boundary = true;
                     } else {
                         // We may need to skip the remaining bytes or, potentially, the server
                         // coalesced two adjacent requests into one larger response.
                         m_current_op.first += chunk.GetLength();
                         m_current_op.second -= chunk.GetLength();
                         CalculateNextBuffer();
                         continue;
                     }
                 } else if (m_current_op.second == m_chunk_buffer_idx) {
                     // There are no more bytes in the response but the requested chunk hasn't finished.
                     // Add what we have to the results and create a new chunk on the request list from the remainder; perhaps
                     // the server will send it in the future.
                     m_chunk_list.emplace_back(chunk.GetOffset() + m_chunk_buffer_idx, chunk.GetLength() - m_chunk_buffer_idx, static_cast<char*>(chunk.GetBuffer()) + m_chunk_buffer_idx);
                     m_vr->GetChunks().emplace_back(chunk.GetOffset(), m_chunk_buffer_idx, chunk.GetBuffer());
                     m_bytes_consumed += m_chunk_buffer_idx;
                     m_chunk_buffer_idx = 0;
                     m_current_op.first = m_current_op.second = -1;
                     m_multipart_boundary = true;
                     m_response_idx++;
                 }
             }
         }
         if (m_skip_bytes) {
             continue;
         }
  
         // We are at the boundary between chunks; we must parse header lines to understand the
         // next thing to do.
  
         // The following lambda function returns a string view to the next complete header line,
         // potentially partially from the previous buffer from curl.  If the second item in
         // the returned pair is false, then we ran out of buffer from curl before finding a
         // complete line.
         auto get_next_line = [&]() {
             std::string_view chunk_header(buffer, length);
             auto pos = chunk_header.find("\r\n");
             if (pos == std::string_view::npos) {
                 m_response_headers += chunk_header;
                 length = 0;
                 return std::make_pair(std::string_view(), false);
             } else {
                 auto line_part = chunk_header.substr(0, pos);
                 if (!m_response_headers.empty()) {
                     m_response_headers += line_part;
                     m_header_line = std::move(m_response_headers);
                 } else {
                     m_header_line.assign(line_part);
                 }
                 buffer += pos + 2;
                 length -= pos + 2;
                 return std::make_pair(std::string_view(m_header_line), true);
             }
         };
  
         // Consume the boundary line.
         bool last_segment = false;
         if (m_multipart_boundary) {
         while (true) {
             auto [line, ok] = get_next_line();
             if (!ok) {
                 return orig_length;
             }
             // Per RFC7233, Appendix A, Implementation note 1, multiple CRLF might precede the
             // first boundary string in the body.  However, the XRootD server appears to have an
             // extra CRLF in front of every boundary string.
             if (line.empty()) {continue;}
             if (line == m_headers.MultipartSeparator()) {
                 break;
             }
             if (line == m_headers.MultipartSeparator() + "--") {
                 last_segment = true;
                 break;
             }
             std::stringstream ss;
             ss << "Server has responded with an invalid boundary line: '" << line << "' (expected '" << m_headers.MultipartSeparator() << "')";
             return FailCallback(kXR_ServerError, ss.str());
         }
         }
         if (last_segment) {
             length = 0;
             break;
         }
         // Consume the header lines
         while (true) {
             auto [line, ok] = get_next_line();
             if (!ok) {
                 m_multipart_boundary = false;
                 return orig_length;
             }
             if (line.empty()) {
                 break;
             }
             auto header_name_end = line.find(':');
             if (header_name_end == std::string_view::npos) {
                 std::stringstream ss; ss << "Invalid header line in response from server: " << line;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             auto header_name = line.substr(0, header_name_end);
             // Cannot use strcasecmp here as a string_view's data is not necessarily nul-terminated.
             // len("content-type") == 13
             if (header_name.size() != 13 || strncasecmp(header_name.data(), "content-range", 13)) {
                 continue;
             }
             // We are parsing a Content-Range value.
             // Example: Content-Range: bytes 7000-7999/8000
             auto value = line.substr(header_name_end + 1);
         
             // Advance whitespace
             while (!value.empty() && value[0] == ' ') {
                 value = value.substr(1);
             }
  
             if (value.substr(0, 5) != "bytes") {
                 std::stringstream ss; ss << "Invalid Content-Range value (no 'bytes' unit): " << value;
                 return FailCallback(kXR_ServerError, ss.str());
             }
  
             value = value.substr(5);
             while (!value.empty() && value[0] == ' ') {
                 value = value.substr(1);
             }
  
             // Example: 500-999/8000
             size_t count;
             long long bytes_val;
             try {
                 // It may seem strange to see the string_view data being passed to std::stoll here
                 // as it's not guaranteed to be null-terminated.  However, by this point, we do know
                 // there's a CRLF in the buffer -- that is sufficient to guarantee the stoll search
                 // terminates before it goes out-of-bounds. 
                 bytes_val = std::stoll(value.data(), &count);
             } catch (std::invalid_argument &) {
                 std::stringstream ss; ss << "Invalid Content-Range value (no integer in range start): " << value;
                 return FailCallback(kXR_ServerError, ss.str());
             } catch (std::out_of_range &) {
                 std::stringstream ss; ss << "Invalid Content-Range value (out of range): " << value;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             if (value.size() <= count || value[count] != '-') {
                 std::stringstream ss; ss << "Invalid Content-Range value (no dash in range): " << value;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             m_current_op.first = bytes_val;
             value = value.substr(count + 1);
             try {
                 bytes_val = std::stoll(value.data(), &count);
             } catch (std::invalid_argument &) {
                 std::stringstream ss; ss << "Invalid Content-Range value (no integer in range end): " << value;
                 return FailCallback(kXR_ServerError, ss.str());
             } catch (std::out_of_range &) {
                 std::stringstream ss; ss << "Invalid Content-Range value (out of range in range end): " << value;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             if (value.size() <= count || value[count] != '/') {
                 std::stringstream ss; ss << "Invalid Content-Range value (no trailing /): "  << value;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             auto length = bytes_val + 1 - m_current_op.first;
             if (length < 0) {
                 std::stringstream ss; ss << "Invalid Content-Range value (negative length): " << line;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             if (length > std::numeric_limits<decltype(m_current_op.second)>::max()) {
                 std::stringstream ss; ss << "Invalid Content-Range value (length too long): " << line;
                 return FailCallback(kXR_ServerError, ss.str());
             }
             m_current_op.second = length;
  
             // We now have a valid response range; locate a buffer where we will copy the bytes into.
             CalculateNextBuffer();
         }
         m_multipart_boundary = true;
  
         // Check to see if the Content-Range was missing.
         if (!last_segment && (m_current_op.first == -1 || m_current_op.second == -1)) {
             return FailCallback(kXR_ServerError, "Response segment is missing a Content-Range header");
         }
     }
     return orig_length;
 }

References XrdClHttp::CurlOperation::FailCallback(), XrdClHttp::HeaderParser::GetOffset(), XrdClHttp::CurlOperation::GetStatusCode(), XrdClHttp::HTTPStatusIsError(), XrdClHttp::HeaderParser::IsMultipartByterange(), kXR_ServerError, m_bytes_consumed, m_chunk_buffer_idx, m_chunk_list, m_current_op, m_header_line, XrdClHttp::CurlOperation::m_headers, m_response_headers, m_response_idx, m_skip_bytes, m_vr, XrdClHttp::HeaderParser::MultipartSeparator(), and XrdClHttp::CurlOperation::UpdateBytes().

Here is the call graph for this function:

Member Data Documentation

◆ m_bytes_consumed

off_t XrdClHttp::CurlVectorReadOp::m_bytes_consumed {0}

protected

Definition at line 739 of file XrdClHttpOps.hh.

Referenced by Success(), and Write().

◆ m_chunk_buffer_idx

off_t XrdClHttp::CurlVectorReadOp::m_chunk_buffer_idx {0}

protected

Definition at line 738 of file XrdClHttpOps.hh.

Referenced by Success(), and Write().

◆ m_chunk_list

XrdCl::ChunkList XrdClHttp::CurlVectorReadOp::m_chunk_list

protected

Definition at line 745 of file XrdClHttpOps.hh.

Referenced by Fail(), Setup(), Success(), and Write().

◆ m_current_op

std::pair<off_t, off_t> XrdClHttp::CurlVectorReadOp::m_current_op {-1, -1}

protected

Definition at line 743 of file XrdClHttpOps.hh.

Referenced by Write().

◆ m_header_line

std::string XrdClHttp::CurlVectorReadOp::m_header_line

protected

Definition at line 742 of file XrdClHttpOps.hh.

Referenced by Write().

◆ m_response_headers

std::string XrdClHttp::CurlVectorReadOp::m_response_headers

protected

Definition at line 741 of file XrdClHttpOps.hh.

Referenced by Write().

◆ m_response_idx

size_t XrdClHttp::CurlVectorReadOp::m_response_idx {0}

protected

Definition at line 737 of file XrdClHttpOps.hh.

Referenced by Success(), and Write().

◆ m_skip_bytes

uint64_t XrdClHttp::CurlVectorReadOp::m_skip_bytes {0}

protected

Definition at line 740 of file XrdClHttpOps.hh.

Referenced by Write().

◆ m_vr

std::unique_ptr<XrdCl::VectorReadInfo> XrdClHttp::CurlVectorReadOp::m_vr

protected

Definition at line 744 of file XrdClHttpOps.hh.

Referenced by Success(), and Write().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CurlVectorReadOp()

◆ ~CurlVectorReadOp()

Member Function Documentation

◆ Fail()

◆ GetVerb()

◆ ReleaseHandle()

◆ SetSeparator()

◆ SetStatusCode()

◆ Setup()

◆ Success()

◆ Write()

Member Data Documentation

◆ m_bytes_consumed

◆ m_chunk_buffer_idx

◆ m_chunk_list

◆ m_current_op

◆ m_header_line

◆ m_response_headers

◆ m_response_idx

◆ m_skip_bytes

◆ m_vr