XrdClHttp::HeaderBuilder Namespace Reference

Typedefs
using	HeaderList = std::vector< std::pair< std::string, std::string > >

Functions
void	AppendMissing (const HeaderList &extra, HeaderList &headers)
bool	Build (const std::string_view spec, HeaderList &headers)
bool	CompareIgnoreCase (const std::string_view lhs, const std::string_view rhs)
bool	IsForbiddenHeader (const std::string_view name)

Typedef Documentation

HeaderList

using XrdClHttp::HeaderBuilder::HeaderList = typedef std::vector<std::pair<std::string, std::string> >

Definition at line 16 of file XrdClHttpHeaderBuilder.hh.

Function Documentation

AppendMissing()

void XrdClHttp::HeaderBuilder::AppendMissing	(	const HeaderList &	extra,
		HeaderList &	headers
	)

Definition at line 101 of file XrdClHttpHeaderBuilder.cc.

{
    for (const auto &header : extra) {
        const auto present = std::any_of(headers.cbegin(), headers.cend(),
            [&header](const auto &existing) {
                return CompareIgnoreCase(existing.first, header.first);
            });
        if (!present) {
            headers.emplace_back(header);
        }
    }
}

References extra.

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

Here is the caller graph for this function:

Build()

bool XrdClHttp::HeaderBuilder::Build	(	const std::string_view	spec,
		HeaderList &	headers
	)

Definition at line 115 of file XrdClHttpHeaderBuilder.cc.

{
    XrdCl::Log *const log = XrdCl::DefaultEnv::GetLog();
 
    headers.clear();
 
    // Walk the newline separated entries, reporting every unusable one so a user
    // who wrote several mistakes sees them all at once.
    // An empty specification simply yields no headers.
    HeaderList requested;
    bool usable = true;
    for (auto pos = spec.begin(); pos != spec.end(); ) {
        const auto eol = std::find(pos, spec.end(), '\n');
 
        // A CRLF separator leaves the CR behind; drop it along with any padding.
        const auto entry = trim(spec.substr(pos - spec.begin(), eol - pos), " \t\r");
        pos = (eol == spec.end() ? eol : std::next(eol));
 
        // Tolerate blank entries so a trailing newline is not an error.
        if (entry.empty()) {
            continue;
        }
 
        // The value may itself contain colons, so split on the first one only.
        // Without a colon the entry carries no value, so the log can show the
        // whole entry without showing a value the user keeps private.
        const auto colon = entry.find(':');
        if (colon == std::string_view::npos) {
            log->Error(kLogXrdClHttp, "Requested header %s holds no colon; each header must read \"<name>: <value>\"",
                obfuscateAuth(std::string(entry)).c_str());
            usable = false;
            continue;
        }
 
        // The name must be a non-empty RFC 7230 token.
        const std::string name(trim(entry.substr(0, colon), ows));
        if (name.empty()) {
            log->Error(kLogXrdClHttp, "Requested header holds no name before its colon");
            usable = false;
            continue;
        }
        if (!std::all_of(name.begin(), name.end(), [](const char c) {
                return tchar.find(c) != std::string_view::npos;
            }))
        {
            log->Error(kLogXrdClHttp, "Requested header %s holds a name that is not an HTTP token", name.c_str());
            usable = false;
            continue;
        }
        if (IsForbiddenHeader(name)) {
            log->Error(kLogXrdClHttp, "Requested header %s must not be set by the client", name.c_str());
            usable = false;
            continue;
        }
 
        // A newline separates entries and so cannot occur in a value, but an
        // embedded carriage return would let one forge part of the request.
        const auto value = trim(entry.substr(colon + 1), ows);
        if (value.empty()) {
            log->Error(kLogXrdClHttp, "Requested header %s holds no value", name.c_str());
            usable = false;
            continue;
        }
        if (value.find('\r') != std::string_view::npos) {
            log->Error(kLogXrdClHttp, "Requested header %s holds a carriage return in its value", name.c_str());
            usable = false;
            continue;
        }
 
        requested.emplace_back(name, value);
    }
 
    if (!usable) {
        return false;
    }
 
    if (requested.empty()) {
        return true;
    }
 
    // Name the headers but never their values, which the user fills with whatever
    // the endpoint understands.
    std::string names;
    for (const auto &header : requested) {
        if (!names.empty()) names += ", ";
        names += header.first;
    }
    log->Debug(kLogXrdClHttp, "Requested headers %s", names.c_str());
 
    headers = std::move(requested);
    return true;
}

References XrdCl::Log::Debug(), XrdCl::Log::Error(), XrdCl::DefaultEnv::GetLog(), IsForbiddenHeader(), XrdClHttp::kLogXrdClHttp, obfuscateAuth(), and trim().

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

Here is the call graph for this function:

Here is the caller graph for this function:

CompareIgnoreCase()

bool XrdClHttp::HeaderBuilder::CompareIgnoreCase	(	const std::string_view	lhs,
		const std::string_view	rhs
	)

Definition at line 88 of file XrdClHttpHeaderBuilder.cc.

{
    const auto to_ascii_lower = [](const unsigned char c) {
        return (c >= 'A' && c <= 'Z') ? static_cast<unsigned char>(c - 'A' + 'a') : c;
    };
    
    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
        [to_ascii_lower](const unsigned char a, const unsigned char b) {
            return to_ascii_lower(a) == to_ascii_lower(b);
        });
}

Referenced by XrdClHttp::CurlOperation::FinishSetup(), and IsForbiddenHeader().

Here is the caller graph for this function:

IsForbiddenHeader()

bool XrdClHttp::HeaderBuilder::IsForbiddenHeader

(

const std::string_view

name

)

Definition at line 72 of file XrdClHttpHeaderBuilder.cc.

{
    // A forbidden header stays forbidden when the TransferHeader prefix aims it
    // at the far server of a third party copy, however often the prefix repeats.
    std::string_view bare(name);
    while (CompareIgnoreCase(bare.substr(0, transfer_header_prefix.size()), transfer_header_prefix)) {
        bare.remove_prefix(transfer_header_prefix.size());
    }
 
    return std::find_if(forbidden_headers.begin(), forbidden_headers.end(), [bare](auto _sv) {
        return CompareIgnoreCase(bare, _sv);
    })
        != forbidden_headers.end();
}

References CompareIgnoreCase().

Referenced by Build().

Here is the call graph for this function:

Here is the caller graph for this function: