XrdClHttp::HeaderParser Class Reference

#include <XrdClHttpUtil.hh>

Collaboration diagram for XrdClHttp::HeaderParser:

Public Member Functions
	HeaderParser ()
VerbsCache::HttpVerbs	GetAllowedVerbs () const
const std::string &	GetCacheControl () const
const XrdClHttp::ChecksumInfo &	GetChecksums () const
int64_t	GetContentLength () const
const std::string &	GetETag () const
const std::string &	GetLocation () const
uint64_t	GetOffset () const
int	GetStatusCode () const
std::string	GetStatusMessage () const
bool	HeadersDone () const
bool	IsMultipartByterange () const
ResponseInfo::HeaderMap &&	MoveHeaders ()
const std::string &	MultipartSeparator () const
bool	Parse (const std::string &headers)
void	SetMultipartSeparator (const std::string_view &sep)
void	SetStatusCode (int sc)

Static Public Member Functions
static bool	Base64Decode (std::string_view input, std::array< unsigned char, g_max_checksum_length > &output)
static bool	Canonicalize (std::string &headerName)
static std::string	ChecksumTypeToDigestName (XrdClHttp::ChecksumType type)
static void	ParseDigest (const std::string &digest, XrdClHttp::ChecksumInfo &info)

Detailed Description

Definition at line 93 of file XrdClHttpUtil.hh.

Constructor & Destructor Documentation

HeaderParser()

XrdClHttp::HeaderParser::HeaderParser ( )

inline

Definition at line 95 of file XrdClHttpUtil.hh.

{}

Member Function Documentation

Base64Decode()

bool HeaderParser::Base64Decode ( std::string_view  input, std::array< unsigned char, g_max_checksum_length > &  output  )

static

Definition at line 343 of file XrdClHttpUtil.cc.

                                                            {
    if (input.size() > 4 * ((output.size() + 2) / 3)
        || input.size() % 4 != 0)
        return false;
    if (input.size() == 0) return true;
 
    std::unique_ptr<BIO, decltype(&BIO_free_all)> b64(BIO_new(BIO_f_base64()), &BIO_free_all);
    BIO_set_flags(b64.get(), BIO_FLAGS_BASE64_NO_NL);
    std::unique_ptr<BIO, decltype(&BIO_free_all)> bmem(
        BIO_new_mem_buf(const_cast<char *>(input.data()), input.size()), &BIO_free_all);
    bmem.reset(BIO_push(b64.release(), bmem.release()));
 
    // Compute expected length of output; used to verify BIO_read consumes all input
    size_t expectedLen = static_cast<size_t>(input.size() * 0.75);
    if (input[input.size() - 1] == '=') {
        expectedLen -= 1;
        if (input[input.size() - 2] == '=') {
            expectedLen -= 1;
        }
    }
 
    auto len = BIO_read(bmem.get(), &output[0], output.size());
 
    if (len == -1 || static_cast<size_t>(len) != expectedLen) return false;
 
    return true;
}

Referenced by ParseDigest().

Here is the caller graph for this function:

Canonicalize()

bool HeaderParser::Canonicalize ( std::string &  headerName )

static

Definition at line 664 of file XrdClHttpUtil.cc.

{
    auto upper = true;
    const static int toLower = 'a' - 'A';
    for (size_t idx=0; idx<headerName.size(); idx++) {
        char c = headerName[idx];
        if (!validHeaderByte(c)) {
            return false;
        }
        if (upper && 'a' <= c && c <= 'z') {
            c -= toLower;
        } else if (!upper && 'A' <= c && c <= 'Z') {
            c += toLower;
        }
        headerName[idx] = c;
        upper = c == '-';
    }
    return true;
}

Referenced by Parse().

Here is the caller graph for this function:

ChecksumTypeToDigestName()

std::string HeaderParser::ChecksumTypeToDigestName ( XrdClHttp::ChecksumType  type )

static

Definition at line 604 of file XrdClHttpUtil.cc.

                                                                           {
    switch (type) {
        case XrdClHttp::ChecksumType::kADLER32:
            return "adler32";
        case XrdClHttp::ChecksumType::kCRC32:
            return "crc32";
        case XrdClHttp::ChecksumType::kMD5:
            return "MD5";
        case XrdClHttp::ChecksumType::kCRC32C:
            return "CRC32c";
        case XrdClHttp::ChecksumType::kSHA1:
            return "SHA";
        case XrdClHttp::ChecksumType::kSHA256:
            return "SHA-256";
        case XrdClHttp::ChecksumType::kAll: {
            std::string result;
            for (int value = 0;
                 value < static_cast<int>(XrdClHttp::ChecksumType::kAll);
                 ++value) {
                if (!result.empty()) result += ',';
                result += ChecksumTypeToDigestName(
                    static_cast<XrdClHttp::ChecksumType>(value));
            }
            return result;
        }
        default:
            return "";
    }
}

Referenced by XrdClHttp::CurlChecksumOp::Setup().

Here is the caller graph for this function:

GetAllowedVerbs()

VerbsCache::HttpVerbs XrdClHttp::HeaderParser::GetAllowedVerbs ( ) const

inline

Definition at line 132 of file XrdClHttpUtil.hh.

    {
        return VerbsCache::HttpVerbs(m_allow_verbs);
    }

Referenced by XrdClHttp::CurlOptionsOp::Success().

Here is the caller graph for this function:

GetCacheControl()

const std::string& XrdClHttp::HeaderParser::GetCacheControl ( ) const

inline

Definition at line 141 of file XrdClHttpUtil.hh.

{return m_cache_control;}

Referenced by XrdClHttp::CurlPrefetchOpenOp::Pause().

Here is the caller graph for this function:

GetChecksums()

const XrdClHttp::ChecksumInfo& XrdClHttp::HeaderParser::GetChecksums ( ) const

inline

Definition at line 144 of file XrdClHttpUtil.hh.

{return m_checksums;}

Referenced by XrdClHttp::CurlChecksumOp::Success().

Here is the caller graph for this function:

GetContentLength()

int64_t XrdClHttp::HeaderParser::GetContentLength ( ) const

inline

Definition at line 99 of file XrdClHttpUtil.hh.

{return m_content_length;}

Referenced by XrdClHttp::CurlStatOp::GetStatInfo(), and XrdClHttp::CurlPrefetchOpenOp::Pause().

Here is the caller graph for this function:

GetETag()

const std::string& XrdClHttp::HeaderParser::GetETag ( ) const

inline

Definition at line 140 of file XrdClHttpUtil.hh.

{return m_etag;}

Referenced by XrdClHttp::CurlPrefetchOpenOp::Pause(), and XrdClHttp::CurlQueryOp::Success().

Here is the caller graph for this function:

GetLocation()

const std::string& XrdClHttp::HeaderParser::GetLocation ( ) const

inline

Definition at line 139 of file XrdClHttpUtil.hh.

{return m_location;}

Referenced by XrdClHttp::CurlStatOp::OptionsDone().

Here is the caller graph for this function:

GetOffset()

uint64_t XrdClHttp::HeaderParser::GetOffset ( ) const

inline

Definition at line 101 of file XrdClHttpUtil.hh.

{return m_response_offset;}

Referenced by XrdClHttp::CurlVectorReadOp::Write().

Here is the caller graph for this function:

GetStatusCode()

int XrdClHttp::HeaderParser::GetStatusCode ( ) const

inline

Definition at line 112 of file XrdClHttpUtil.hh.

{return m_status_code;}

Referenced by XrdClHttp::CurlOperation::GetStatusCode(), and XrdClHttp::CurlOperation::IsRedirect().

Here is the caller graph for this function:

GetStatusMessage()

std::string XrdClHttp::HeaderParser::GetStatusMessage ( ) const

inline

Definition at line 137 of file XrdClHttpUtil.hh.

{return m_resp_message;}

Referenced by XrdClHttp::CurlOperation::GetStatusMessage().

Here is the caller graph for this function:

HeadersDone()

bool XrdClHttp::HeaderParser::HeadersDone ( ) const

inline

Definition at line 105 of file XrdClHttpUtil.hh.

{return m_recv_all_headers;}

IsMultipartByterange()

bool XrdClHttp::HeaderParser::IsMultipartByterange ( ) const

inline

Definition at line 119 of file XrdClHttpUtil.hh.

{return m_multipart_byteranges;}

Referenced by XrdClHttp::CurlVectorReadOp::Write().

Here is the caller graph for this function:

MoveHeaders()

ResponseInfo::HeaderMap&& XrdClHttp::HeaderParser::MoveHeaders ( )

inline

Definition at line 110 of file XrdClHttpUtil.hh.

{return std::move(m_headers);}

MultipartSeparator()

const std::string& XrdClHttp::HeaderParser::MultipartSeparator ( ) const

inline

Definition at line 123 of file XrdClHttpUtil.hh.

{return m_multipart_sep;}

Referenced by XrdClHttp::CurlVectorReadOp::Write().

Here is the caller graph for this function:

Parse()

bool HeaderParser::Parse

(

const std::string &

headers

)

Definition at line 378 of file XrdClHttpUtil.cc.

{
    if (m_recv_all_headers) {
        m_recv_all_headers = false;
        m_recv_status_line = false;
    }
 
    if (!m_recv_status_line) {
        m_recv_status_line = true;
 
        std::stringstream ss(header_line);
        std::string item;
        if (!std::getline(ss, item, ' ')) return false;
        m_resp_protocol = item;
        if (!std::getline(ss, item, ' ')) return false;
        try {
            m_status_code = std::stol(item);
        } catch (...) {
            return false;
        }
        if (m_status_code < 100 || m_status_code >= 600) {
            return false;
        }
        if (!std::getline(ss, item, '\n')) return false;
        auto cr_loc = item.find('\r');
        if (cr_loc != std::string::npos) {
            m_resp_message = item.substr(0, cr_loc);
        } else {
            m_resp_message = item;
        }
        return true;
    }
 
    if (header_line.empty() || header_line == "\n" || header_line == "\r\n") {
        m_recv_all_headers = true;
        return true;
    }
 
    auto found = header_line.find(":");
    if (found == std::string::npos) {
        return false;
    }
 
    std::string header_name = header_line.substr(0, found);
    if (!Canonicalize(header_name)) {
        return false;
    }
 
    found += 1;
    while (found < header_line.size()) {
        if (header_line[found] != ' ') {break;}
        found += 1;
    }
    std::string header_value = header_line.substr(found);
    // Note: ignoring the fact headers are only supposed to contain ASCII.
    // We should trim out UTF-8.
    header_value.erase(header_value.find_last_not_of(" \r\n\t") + 1);
 
    // Record the line in our header structure.  Will be returned as part
    // of the response info object.
    auto iter = m_headers.find(header_name);
    if (iter == m_headers.end()) {
        m_headers.insert(iter, {header_name, {header_value}});
    } else {
        iter->second.push_back(header_value);
    }
 
    if (header_name == "Allow") {
        std::string_view val(header_value);
        while (!val.empty()) {
            auto found = val.find(',');
            auto method = val.substr(0, found);
            if (method == "PROPFIND") {
                auto new_verbs = static_cast<unsigned>(m_allow_verbs) | static_cast<unsigned>(VerbsCache::HttpVerb::kPROPFIND);
                m_allow_verbs = static_cast<VerbsCache::HttpVerb>(new_verbs);
            }
            if (found == std::string_view::npos) break;
            val = val.substr(found + 1);
        }
        if (static_cast<unsigned>(m_allow_verbs) & ~static_cast<unsigned>(VerbsCache::HttpVerb::kUnknown)) {
            m_allow_verbs = static_cast<VerbsCache::HttpVerb>(static_cast<unsigned>(m_allow_verbs) & ~static_cast<unsigned>(VerbsCache::HttpVerb::kUnknown));
        }
    } else if (header_name == "Content-Length") {
         try {
             m_content_length = std::stoll(header_value);
         } catch (...) {
             return false;
         }
    }
    else if (header_name == "Content-Type") {
        std::string_view val(header_value);
        auto found = val.find(";");
        auto first_type = val.substr(0, found);
        m_multipart_byteranges = first_type == "multipart/byteranges";
        if (m_multipart_byteranges) {
            auto remainder = val.substr(found + 1);
            found = remainder.find("boundary=");
            if (found != std::string_view::npos) {
                SetMultipartSeparator(remainder.substr(found + 9));
            }
        }
    }
    else if (header_name == "Content-Range") {
        auto found = header_value.find(" ");
        if (found == std::string::npos) {
            return false;
        }
        std::string range_unit = header_value.substr(0, found);
        if (range_unit != "bytes") {
            return false;
        }
        auto range_resp = header_value.substr(found + 1);
        found = range_resp.find("/");
        if (found == std::string::npos) {
            return false;
        }
        auto incl_range = range_resp.substr(0, found);
        found = incl_range.find("-");
        if (found == std::string::npos) {
            return false;
        }
        auto first_pos = incl_range.substr(0, found);
        try {
            m_response_offset = std::stoll(first_pos);
        } catch (...) {
           return false;
        }
        auto last_pos = incl_range.substr(found + 1);
        size_t last_byte;
        try {
           last_byte = std::stoll(last_pos);
        } catch (...) {
           return false;
        }
        m_content_length = last_byte - m_response_offset + 1;
    }
    else if (header_name == "Location") {
        m_location = header_value;
    } else if (header_name == "Digest") {
        ParseDigest(header_value, m_checksums);
    }
    else if (header_name == "Etag")
    {
        // Note, the original hader name is ETag, renamed to Etag in parsing
        // remove additional quotes
        m_etag = header_value;
        m_etag.erase(remove(m_etag.begin(), m_etag.end(), '\"'), m_etag.end());
    }
    else if (header_name == "Cache-Control")
    {
        m_cache_control = header_value;
    }
 
    return true;
}

References Canonicalize(), getline(), XrdClHttp::VerbsCache::kPROPFIND, XrdClHttp::VerbsCache::kUnknown, ParseDigest(), and SetMultipartSeparator().

Here is the call graph for this function:

ParseDigest()

void HeaderParser::ParseDigest ( const std::string &  digest, XrdClHttp::ChecksumInfo &  info  )

static

Definition at line 537 of file XrdClHttpUtil.cc.

                                                                                   {
    std::string_view view(digest);
    std::array<unsigned char, g_max_checksum_length> checksum_value{};
    std::string digest_lower;
    while (!view.empty()) {
        auto nextsep = view.find(',');
        auto entry = view.substr(0, nextsep);
        if (nextsep == std::string_view::npos) {
            view = "";
        } else {
            view = view.substr(nextsep + 1);
        }
        nextsep = entry.find('=');
        if (nextsep == std::string_view::npos) continue;
        auto name = trim_view(entry.substr(0, nextsep));
        auto value = trim_view(entry.substr(nextsep + 1));
        digest_lower.clear();
        digest_lower.resize(name.size());
        std::transform(name.begin(), name.end(), digest_lower.begin(), [](unsigned char c) {
            return std::tolower(c);
        });
        const auto setHex32 = [&](ChecksumType type) {
            if (value.empty() || value.size() > 8) return;
            std::string padded(8 - value.size(), '0');
            padded.append(value.data(), value.size());
            XrdCksData checksum;
            if (!checksum.Set(padded.c_str(), padded.size())) return;
            std::copy_n(
                reinterpret_cast<const unsigned char *>(checksum.Value),
                GetChecksumLength(type), checksum_value.begin());
            info.Set(type, checksum_value);
        };
        const auto setBase64 = [&](ChecksumType type) {
            const size_t decodedSize = GetChecksumLength(type);
            const size_t encodedSize = 4 * ((decodedSize + 2) / 3);
            if (value.size() == encodedSize
                && Base64Decode(value, checksum_value))
            {
                info.Set(type, checksum_value);
            }
        };
        if (digest_lower == "adler" || digest_lower == "adler32") {
            setHex32(ChecksumType::kADLER32);
        } else if (digest_lower == "crc32") {
            setHex32(ChecksumType::kCRC32);
        } else if (digest_lower == "md5") {
            setBase64(ChecksumType::kMD5);
        } else if (digest_lower == "sha" || digest_lower == "sha1") {
            setBase64(ChecksumType::kSHA1);
        } else if (digest_lower == "sha-256" || digest_lower == "sha256") {
            setBase64(ChecksumType::kSHA256);
        } else if (digest_lower == "crc32c") {
            // XRootD currently incorrectly base64-encodes crc32c checksums; see
            // https://github.com/xrootd/xrootd/issues/2456
            // For backward comaptibility, if this looks like base64 encoded (8
            // bytes long and last two bytes are padding), then we base64 decode.
            if (value.size() == 8 && value[6] == '=' && value[7] == '=') {
                setBase64(ChecksumType::kCRC32C);
                continue;
            }
            setHex32(ChecksumType::kCRC32C);
        }
    }
}

References Base64Decode(), XrdClHttp::GetChecksumLength(), XrdClHttp::ChecksumInfo::Set(), XrdCksData::Set(), XrdClHttp::trim_view(), and XrdCksData::Value.

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

SetMultipartSeparator()

void XrdClHttp::HeaderParser::SetMultipartSeparator ( const std::string_view &  sep )

inline

Definition at line 127 of file XrdClHttpUtil.hh.

                                                          {
        m_multipart_sep = "--" + std::string(sep);
        m_multipart_byteranges = true;
    }

Referenced by Parse(), and XrdClHttp::CurlVectorReadOp::SetSeparator().

Here is the caller graph for this function:

SetStatusCode()

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

inline

Definition at line 116 of file XrdClHttpUtil.hh.

{m_status_code = sc;}

Referenced by XrdClHttp::CurlVectorReadOp::SetStatusCode().

Here is the caller graph for this function:

---

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

• XrdClHttpUtil.hh
• XrdClHttpUtil.cc