XrdClHttp::CurlVectorReadOp Class Reference

#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)
    {}

References XrdClHttp::CurlOperation::CurlOperation(), m_chunk_list, and m_vr.

Here is the call graph for this function:

~CurlVectorReadOp()

virtual XrdClHttp::CurlVectorReadOp::~CurlVectorReadOp ( )

inlinevirtual

Definition at line 704 of file XrdClHttpOps.hh.

{}

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 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.

{return HttpVerb::GET;}

References XrdClHttp::CurlOperation::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.

SetStatusCode()

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

inline

Definition at line 718 of file XrdClHttpOps.hh.

{m_headers.SetStatusCode(sc);}

References XrdClHttp::CurlOperation::m_headers.

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 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::CurlOperation::GetStatusCode(), XrdClHttp::HTTPStatusIsError(), 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, 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.

{0}; // Total number of bytes used for results serving the request.

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.

{0}; // Current offset in requested chunk where we are writing bytes.

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 CurlVectorReadOp(), 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.

{-1, -1}; // The (offset, length) of the current response chunk.

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.

{0}; // The offset in the m_chunk_list which the current response chunk will write into.

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.

{0}; // Count of bytes to skip in the next response (if response chunk contains unneeded bytes).

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 CurlVectorReadOp(), Success(), and Write().

---

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

• XrdClHttpOps.hh
• XrdClHttpOpReadV.cc