#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

time_t	GetModTime () 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 94 of file XrdClHttpUtil.hh.

Constructor & Destructor Documentation

◆ HeaderParser()

XrdClHttp::HeaderParser::HeaderParser ( )

inline

Definition at line 96 of file XrdClHttpUtil.hh.

96{}

Member Function Documentation

◆ Base64Decode()

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

static

Definition at line 344 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 677 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 617 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 "";
    }
}

References ChecksumTypeToDigestName(), XrdClHttp::kADLER32, XrdClHttp::kAll, XrdClHttp::kCRC32, XrdClHttp::kCRC32C, XrdClHttp::kMD5, XrdClHttp::kSHA1, and XrdClHttp::kSHA256.

Referenced by ChecksumTypeToDigestName(), and XrdClHttp::CurlChecksumOp::Setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAllowedVerbs()

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

inline

Definition at line 136 of file XrdClHttpUtil.hh.

    {
        return VerbsCache::HttpVerbs(m_allow_verbs);
    }

◆ GetCacheControl()

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

inline

Definition at line 145 of file XrdClHttpUtil.hh.

145{return m_cache_control;}

◆ GetChecksums()

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

inline

Definition at line 148 of file XrdClHttpUtil.hh.

148{return m_checksums;}

◆ GetContentLength()

int64_t XrdClHttp::HeaderParser::GetContentLength ( ) const

inline

Definition at line 100 of file XrdClHttpUtil.hh.

100{return m_content_length;}

◆ GetETag()

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

inline

Definition at line 144 of file XrdClHttpUtil.hh.

144{return m_etag;}

◆ GetLocation()

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

inline

Definition at line 143 of file XrdClHttpUtil.hh.

143{return m_location;}

◆ GetModTime()

time_t XrdClHttp::HeaderParser::GetModTime ( ) const

inline

Definition at line 103 of file XrdClHttpUtil.hh.

103{return m_modtime;}

◆ GetOffset()

uint64_t XrdClHttp::HeaderParser::GetOffset ( ) const

inline

Definition at line 105 of file XrdClHttpUtil.hh.

105{return m_response_offset;}

◆ GetStatusCode()

int XrdClHttp::HeaderParser::GetStatusCode ( ) const

inline

Definition at line 116 of file XrdClHttpUtil.hh.

116{return m_status_code;}

◆ GetStatusMessage()

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

inline

Definition at line 141 of file XrdClHttpUtil.hh.

141{return m_resp_message;}

◆ HeadersDone()

bool XrdClHttp::HeaderParser::HeadersDone ( ) const

inline

Definition at line 109 of file XrdClHttpUtil.hh.

109{return m_recv_all_headers;}

◆ IsMultipartByterange()

bool XrdClHttp::HeaderParser::IsMultipartByterange ( ) const

inline

Definition at line 123 of file XrdClHttpUtil.hh.

123{return m_multipart_byteranges;}

◆ MoveHeaders()

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

inline

Definition at line 114 of file XrdClHttpUtil.hh.

114{return std::move(m_headers);}

◆ MultipartSeparator()

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

inline

Definition at line 127 of file XrdClHttpUtil.hh.

127{return m_multipart_sep;}

◆ Parse()

bool HeaderParser::Parse ( const std::string & headers )

Definition at line 379 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 == "Last-Modified") {
        struct tm tm;
        if (strptime(header_value.c_str(), "%a, %d %b %Y %H:%M:%S", &tm) != nullptr) {
            m_modtime = timegm(&tm);
        }
    } 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(), 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 543 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") {
            // Accept padded base64 alongside the existing hexadecimal form.
            // Require "==" to distinguish a four-byte base64 checksum from
            // short hexadecimal values, which may also be valid unpadded base64.
            if (value.size() == 8 && value[6] == '=' && value[7] == '=') {
                setBase64(ChecksumType::kCRC32);
                continue;
            }
            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::kADLER32, XrdClHttp::kCRC32, XrdClHttp::kCRC32C, XrdClHttp::kMD5, XrdClHttp::kSHA1, XrdClHttp::kSHA256, XrdCksData::Set(), XrdClHttp::ChecksumInfo::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 131 of file XrdClHttpUtil.hh.

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

Referenced by Parse().

Here is the caller graph for this function:

◆ SetStatusCode()

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

inline

Definition at line 120 of file XrdClHttpUtil.hh.

120{m_status_code = sc;}

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ HeaderParser()

Member Function Documentation

◆ Base64Decode()

◆ Canonicalize()

◆ ChecksumTypeToDigestName()

◆ GetAllowedVerbs()

◆ GetCacheControl()

◆ GetChecksums()

◆ GetContentLength()

◆ GetETag()

◆ GetLocation()

◆ GetModTime()

◆ GetOffset()

◆ GetStatusCode()

◆ GetStatusMessage()

◆ HeadersDone()

◆ IsMultipartByterange()

◆ MoveHeaders()

◆ MultipartSeparator()

◆ Parse()

◆ ParseDigest()

◆ SetMultipartSeparator()

◆ SetStatusCode()