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, 32 > &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 71 of file XrdClHttpUtil.hh.

Constructor & Destructor Documentation

HeaderParser()

XrdClHttp::HeaderParser::HeaderParser ( )

inline

Definition at line 73 of file XrdClHttpUtil.hh.

{}

Member Function Documentation

Base64Decode()

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

static

Definition at line 246 of file XrdClHttpUtil.cc.

                                                                                         {
    if (input.size() > 44 || 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 539 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 494 of file XrdClHttpUtil.cc.

                                                                           {
    switch (type) {
        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";
        default:
            return "";
    }
}

References XrdClHttp::kCRC32C, XrdClHttp::kMD5, XrdClHttp::kSHA1, and XrdClHttp::kSHA256.

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

Here is the caller graph for this function:

GetAllowedVerbs()

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

inline

Definition at line 110 of file XrdClHttpUtil.hh.

    {
        return VerbsCache::HttpVerbs(m_allow_verbs);
    }

GetCacheControl()

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

inline

Definition at line 119 of file XrdClHttpUtil.hh.

{return m_cache_control;}

GetChecksums()

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

inline

Definition at line 122 of file XrdClHttpUtil.hh.

{return m_checksums;}

GetContentLength()

int64_t XrdClHttp::HeaderParser::GetContentLength ( ) const

inline

Definition at line 77 of file XrdClHttpUtil.hh.

{return m_content_length;}

GetETag()

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

inline

Definition at line 118 of file XrdClHttpUtil.hh.

{return m_etag;}

GetLocation()

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

inline

Definition at line 117 of file XrdClHttpUtil.hh.

{return m_location;}

GetOffset()

uint64_t XrdClHttp::HeaderParser::GetOffset ( ) const

inline

Definition at line 79 of file XrdClHttpUtil.hh.

{return m_response_offset;}

GetStatusCode()

int XrdClHttp::HeaderParser::GetStatusCode ( ) const

inline

Definition at line 90 of file XrdClHttpUtil.hh.

{return m_status_code;}

GetStatusMessage()

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

inline

Definition at line 115 of file XrdClHttpUtil.hh.

{return m_resp_message;}

HeadersDone()

bool XrdClHttp::HeaderParser::HeadersDone ( ) const

inline

Definition at line 83 of file XrdClHttpUtil.hh.

{return m_recv_all_headers;}

IsMultipartByterange()

bool XrdClHttp::HeaderParser::IsMultipartByterange ( ) const

inline

Definition at line 97 of file XrdClHttpUtil.hh.

{return m_multipart_byteranges;}

MoveHeaders()

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

inline

Definition at line 88 of file XrdClHttpUtil.hh.

{return std::move(m_headers);}

MultipartSeparator()

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

inline

Definition at line 101 of file XrdClHttpUtil.hh.

{return m_multipart_sep;}

Parse()

bool HeaderParser::Parse

(

const std::string &

headers

)

Definition at line 277 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(), 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 436 of file XrdClHttpUtil.cc.

                                                                                   {
    std::string_view view(digest);
    std::array<unsigned char, 32> 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('=');
        auto name = entry.substr(0, nextsep);
        auto value = 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);
        });
        if (digest_lower == "md5") {
            if (value.size() != 24) {
                continue;
            }
            if (Base64Decode(value, checksum_value)) {
                info.Set(XrdClHttp::ChecksumType::kMD5, checksum_value);
            }
        } 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] == '=') {
                if (Base64Decode(value, checksum_value)) {
                    info.Set(XrdClHttp::ChecksumType::kCRC32C, checksum_value);
                }
                continue;
            }
            std::size_t pos{0};
            unsigned long val;
            try {
                val = std::stoul(value.data(), &pos, 16);
            } catch (...) {
                continue;
            }
            if (pos == value.size()) {
                checksum_value[0] = (val >> 24) & 0xFF;
                checksum_value[1] = (val >> 16) & 0xFF;
                checksum_value[2] = (val >> 8) & 0xFF;
                checksum_value[3] = val & 0xFF;
                info.Set(XrdClHttp::ChecksumType::kCRC32C, checksum_value);
            }
        }
    }
}

References Base64Decode(), XrdClHttp::kCRC32C, XrdClHttp::kMD5, and XrdClHttp::ChecksumInfo::Set().

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 105 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 94 of file XrdClHttpUtil.hh.

{m_status_code = sc;}

---

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

• XrdClHttpUtil.hh
• XrdClHttpUtil.cc