XrdClHttp Namespace Reference

Namespaces
namespace	HeaderBuilder
namespace	ThirdPartyCopyOpTypes

Classes
struct	ChecksumEntry
class	ChecksumInfo
class	ConnectionCallout
class	CurlChecksumOp
class	CurlCopyOp
class	CurlDeleteOp
class	CurlListdirOp
class	CurlMkcolOp
class	CurlOpenOp
class	CurlOperation
class	CurlOptionsOp
class	CurlPgReadOp
class	CurlPrefetchOpenOp
class	CurlPutOp
class	CurlQueryOp
class	CurlReadOp
class	CurlStatOp
class	CurlTapeOp
class	CurlTapePrepareOp
class	CurlTapeQueryOp
class	CurlVectorReadOp
class	CurlWorker
class	DeleteResponseInfo
class	DirectoryListResponse
class	Factory
class	File
class	Filesystem
class	HandlerQueue
class	HeaderCallout
class	HeaderParser
class	MkdirResponseInfo
class	OpenResponseInfo
class	QueryResponse
class	ReadResponseInfo
class	ResponseInfo
class	StatResponse
struct	TapeHttpRequest
class	TapeOperation
class	VerbsCache

Typedefs
using	CreateConnCalloutType = ConnectionCallout *(*)(const std::string &, const ResponseInfo &)

Enumerations
enum class	ChecksumType {   kADLER32 ,   kCRC32 ,   kCRC32C ,   kMD5 ,   kSHA1 ,   kSHA256 ,   kAll ,   kUnknown }
enum class	HttpVerb {   COPY ,   DELETE ,   HEAD ,   GET ,   POST ,   MKCOL ,   OPTIONS ,   PROPFIND ,   PUT ,   Count }
enum class	TpcMode {   Pull ,   Push }

Functions
void	ConfigureHandle (CURL *curl, bool verbose)
std::string	GetBearerToken (XrdCl::Log *logger=nullptr)
size_t	GetChecksumLength (ChecksumType ctype)
CURL *	GetHandle (bool verbose)
ChecksumType	GetTypeFromString (const std::string &str)
const std::string	GetTypeString (ChecksumType ctype)
std::pair< uint16_t, uint32_t >	HTTPStatusConvert (unsigned status)
bool	HTTPStatusIsError (unsigned status)
void	InjectBearerToken (const XrdCl::URL &url, std::vector< std::pair< std::string, std::string > > &headers, XrdCl::Log *logger=nullptr)
std::string_view	ltrim_view (const std::string_view &input_view)
std::string	MarshalDuration (const struct timespec &timeout)
bool	ParseTimeout (const std::string &duration, struct timespec &, std::string &errmsg)
bool	ParseTokenFile (const std::string &token_file, CurlCopyOp::Headers &src_hdrs, CurlCopyOp::Headers &dst_hdrs)
bool	ShouldUseBearerToken (const std::string &protocols, bool hasX509Credential, bool hasBearerToken)
static std::optional< std::size_t >	stat_size (HandlerQueue &queue, const std::string &url, const CurlCopyOp::Headers &hdrs, time_t timeout, XrdCl::Log *log, const char *what)
std::string	TapeProblemResponse (long statusCode, const std::string &body)
std::string_view	trim_view (const std::string_view &input_view)

Variables
constexpr size_t	g_max_checksum_length = 32
const uint64_t	kLogXrdClHttp = 73173

---

Class Documentation

XrdClHttp::ChecksumEntry

struct XrdClHttp::ChecksumEntry

Definition at line 103 of file XrdClHttpChecksum.hh.

Collaboration diagram for XrdClHttp::ChecksumEntry:

Class Members
ChecksumType	type {ChecksumType::kUnknown}
array< unsigned char, g_max_checksum_length >	value

XrdClHttp::TapeHttpRequest

struct XrdClHttp::TapeHttpRequest

Definition at line 41 of file XrdClHttpTape.hh.

Collaboration diagram for XrdClHttp::TapeHttpRequest:

Class Members
string	body
HttpVerb	method = HttpVerb::GET
string	url

Typedef Documentation

CreateConnCalloutType

using XrdClHttp::CreateConnCalloutType = ConnectionCallout *(*)(const std::string &, const ResponseInfo &)

Definition at line 69 of file XrdClHttpConnectionCallout.hh.

Enumeration Type Documentation

ChecksumType

enum class XrdClHttp::ChecksumType

strong

Enumerator
kADLER32
kCRC32
kCRC32C
kMD5
kSHA1
kSHA256
kAll
kUnknown

Definition at line 33 of file XrdClHttpChecksum.hh.

                        {
    kADLER32,
    kCRC32,
    kCRC32C,
    kMD5,
    kSHA1,
    kSHA256,
    kAll,     // Select any supported checksum.
    kUnknown, // Indicates an unset value; `kUnknown - 1` is used in for-loops to iterate through all checksums.
};

HttpVerb

enum class XrdClHttp::HttpVerb

strong

Enumerator
COPY
DELETE
HEAD
GET
POST
MKCOL
OPTIONS
PROPFIND
PUT
Count

Definition at line 30 of file XrdClHttpVerb.hh.

  {
    COPY,
    DELETE,
    HEAD,
    GET,
    POST,
    MKCOL,
    OPTIONS,
    PROPFIND,
    PUT,
    Count
  };

TpcMode

enum class XrdClHttp::TpcMode

strong

Enumerator
Pull
Push

Definition at line 889 of file XrdClHttpOps.hh.

                   {
    Pull,
    Push
};

Function Documentation

ConfigureHandle()

void XrdClHttp::ConfigureHandle	(	CURL *	curl,
		bool	verbose )

Definition at line 776 of file XrdClHttpUtil.cc.

                                                   {
    curl_easy_setopt(curl, CURLOPT_USERAGENT, "xrdcl-http/" XrdVERSION);
    curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, DumpHeader);
    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, XrdCl::DefaultEnv::GetLog());
    if (verbose)
        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
    auto env = XrdCl::DefaultEnv::GetEnv();
    std::string ca_file;
    if (!env->GetString("HttpCertFile", ca_file) || ca_file.empty()) {
        char *x509_ca_file = getenv("X509_CERT_FILE");
        if (x509_ca_file) {
            ca_file = std::string(x509_ca_file);
        }
    }
    if (!ca_file.empty()) {
        curl_easy_setopt(curl, CURLOPT_CAINFO, ca_file.c_str());
    }
    std::string ca_dir;
    if (!env->GetString("HttpCertDir", ca_dir) || ca_dir.empty()) {
        char *x509_ca_dir = getenv("X509_CERT_DIR");
        if (x509_ca_dir) {
            ca_dir = std::string(x509_ca_dir);
        }
    }
    if (!ca_dir.empty()) {
        curl_easy_setopt(curl, CURLOPT_CAPATH, ca_dir.c_str());
    }
 
    curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 32*1024);
}

References XrdCl::DefaultEnv::GetEnv(), and XrdCl::DefaultEnv::GetLog().

Referenced by GetHandle(), and XrdClHttp::CurlOperation::SetupNextRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

GetBearerToken()

std::string XrdClHttp::GetBearerToken

(

XrdCl::Log *

logger = nullptr

)

Definition at line 117 of file XrdClHttpUtil.cc.

{
    auto env = XrdCl::DefaultEnv::GetEnv();
    if (!env) return {};
 
    std::string token;
    if (!env->GetString("BearerToken", token) || token.empty()) {
        env->ImportString("BearerToken", "BEARER_TOKEN");
        env->GetString("BearerToken", token);
    }
    if (!token.empty()) {
        XrdCl::Utils::Trim(token);
        return token;
    }
 
    std::string token_file;
    if (!env->GetString("BearerTokenFile", token_file) || token_file.empty()) {
        env->ImportString("BearerTokenFile", "BEARER_TOKEN_FILE");
        env->GetString("BearerTokenFile", token_file);
    }
    if (token_file.empty()) return {};
 
    std::ifstream input(token_file);
    if (!input) return {};
    std::getline(input, token);
    XrdCl::Utils::Trim(token);
    return token;
}

References XrdCl::DefaultEnv::GetEnv(), and XrdCl::Utils::Trim().

Referenced by InjectBearerToken().

Here is the call graph for this function:

Here is the caller graph for this function:

GetChecksumLength()

size_t XrdClHttp::GetChecksumLength ( ChecksumType ctype )

inline

Definition at line 65 of file XrdClHttpChecksum.hh.

                                                    {
    switch (ctype) {
        case ChecksumType::kADLER32:
        case ChecksumType::kCRC32:
        case ChecksumType::kCRC32C:
            return 4;
        case ChecksumType::kMD5:
            return 16;
        case ChecksumType::kSHA1:
            return 20;
        case ChecksumType::kSHA256:
            return 32;
        case ChecksumType::kAll: // fallthrough
        case ChecksumType::kUnknown:
            return 0;
    }
    return 0;
}

References GetChecksumLength(), kADLER32, kAll, kCRC32, kCRC32C, kMD5, kSHA1, kSHA256, and kUnknown.

Referenced by GetChecksumLength(), XrdClHttp::HeaderParser::ParseDigest(), and XrdClHttp::CurlChecksumOp::Success().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHandle()

CURL * XrdClHttp::GetHandle

(

bool

verbose

)

Definition at line 809 of file XrdClHttpUtil.cc.

                                 {
    auto result = curl_easy_init();
    if (result == nullptr) {
        return result;
    }
 
    XrdClHttp::ConfigureHandle(result, verbose);
 
    return result;
}

References ConfigureHandle().

Here is the call graph for this function:

GetTypeFromString()

ChecksumType XrdClHttp::GetTypeFromString ( const std::string & str )

inline

Definition at line 84 of file XrdClHttpChecksum.hh.

                                                            {
    if (str == "adler" || str == "adler32") {
        return ChecksumType::kADLER32;
    } else if (str == "crc32") {
        return ChecksumType::kCRC32;
    } else if (str == "crc32c") {
        return ChecksumType::kCRC32C;
    } else if (str == "md5") {
        return ChecksumType::kMD5;
    } else if (str == "sha1") {
        return ChecksumType::kSHA1;
    } else if (str == "sha256") {
        return ChecksumType::kSHA256;
    }
    return ChecksumType::kUnknown;
}

References GetTypeFromString(), kADLER32, kCRC32, kCRC32C, kMD5, kSHA1, kSHA256, and kUnknown.

Referenced by GetTypeFromString(), and XrdClHttp::Filesystem::Query().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTypeString()

const std::string XrdClHttp::GetTypeString ( ChecksumType ctype )

inline

Definition at line 44 of file XrdClHttpChecksum.hh.

                                                         {
    switch (ctype) {
        case ChecksumType::kADLER32:
            return "adler32";
        case ChecksumType::kCRC32:
            return "crc32";
        case ChecksumType::kCRC32C:
            return "crc32c";
        case ChecksumType::kMD5:
            return "md5";
        case ChecksumType::kSHA1:
            return "sha1";
        case ChecksumType::kSHA256:
            return "sha256";
        case ChecksumType::kAll: // fallthrough
        case ChecksumType::kUnknown:
            return "unknown";
    }
    return "unknown";
}

References GetTypeString(), kADLER32, kAll, kCRC32, kCRC32C, kMD5, kSHA1, kSHA256, and kUnknown.

Referenced by GetTypeString(), and XrdClHttp::CurlChecksumOp::Success().

Here is the call graph for this function:

Here is the caller graph for this function:

HTTPStatusConvert()

std::pair< uint16_t, uint32_t > XrdClHttp::HTTPStatusConvert

(

unsigned

status

)

Definition at line 208 of file XrdClHttpUtil.cc.

                                                                        {
    switch (status) {
        case 400: // Bad Request
            return std::make_pair(XrdCl::errErrorResponse, kXR_InvalidRequest);
        case 401: // Unauthorized (needs authentication)
            return std::make_pair(XrdCl::errErrorResponse, kXR_NotAuthorized);
        case 402: // Payment Required
        case 403: // Forbidden (failed authorization)
            return std::make_pair(XrdCl::errErrorResponse, kXR_NotAuthorized);
        case 404:
            return std::make_pair(XrdCl::errErrorResponse, kXR_NotFound);
        case 405: // Method not allowed
            return std::make_pair(XrdCl::errErrorResponse, kXR_Unsupported);
        case 406: // Not acceptable
            return std::make_pair(XrdCl::errErrorResponse, kXR_InvalidRequest);
        case 407: // Proxy Authentication Required
            return std::make_pair(XrdCl::errErrorResponse, kXR_NotAuthorized);
        case 408: // Request timeout
            return std::make_pair(XrdCl::errErrorResponse, kXR_ReqTimedOut);
        case 409: // Conflict
            return std::make_pair(XrdCl::errErrorResponse, kXR_Conflict);
        case 410: // Gone
            return std::make_pair(XrdCl::errErrorResponse, kXR_NotFound);
        case 411: // Length required
        case 412: // Precondition failed
        case 413: // Payload too large
        case 414: // URI too long
        case 415: // Unsupported Media Type
        case 416: // Range Not Satisfiable
        case 417: // Expectation Failed
        case 418: // I'm a teapot
                return std::make_pair(XrdCl::errErrorResponse, kXR_InvalidRequest);
        case 421: // Misdirected Request
        case 422: // Unprocessable Content
            return std::make_pair(XrdCl::errErrorResponse, kXR_InvalidRequest);
        case 423: // Locked
            return std::make_pair(XrdCl::errErrorResponse, kXR_FileLocked);
        case 424: // Failed Dependency
        case 425: // Too Early
        case 426: // Upgrade Required
        case 428: // Precondition Required
            return std::make_pair(XrdCl::errErrorResponse, kXR_InvalidRequest);
        case 429: // Too Many Requests
            return std::make_pair(XrdCl::errErrorResponse, kXR_Overloaded);
        case 431: // Request Header Fields Too Large
            return std::make_pair(XrdCl::errErrorResponse, kXR_InvalidRequest);
        case 451: // Unavailable For Legal Reasons
            return std::make_pair(XrdCl::errErrorResponse, kXR_Impossible);
        case 500: // Internal Server Error
            return std::make_pair(XrdCl::errErrorResponse, kXR_ServerError);
        case 501: // Not Implemented
            return std::make_pair(XrdCl::errErrorResponse, kXR_Unsupported);
        case 502: // Bad Gateway
            return std::make_pair(XrdCl::errErrorResponse, kXR_ServerError);
        case 503: // Service Unavailable
            return std::make_pair(XrdCl::errErrorResponse, kXR_Overloaded);
        case 504: // Gateway Timeout
            return std::make_pair(XrdCl::errErrorResponse, kXR_ReqTimedOut);
        case 507: // Insufficient Storage
            return std::make_pair(XrdCl::errErrorResponse, kXR_overQuota);
        case 508: // Loop Detected
        case 510: // Not Extended
        case 511: // Network Authentication Required
            return std::make_pair(XrdCl::errErrorResponse, kXR_ServerError);
    }
    return std::make_pair(XrdCl::errUnknown, status);
}

References XrdCl::errErrorResponse, XrdCl::errUnknown, kXR_Conflict, kXR_FileLocked, kXR_Impossible, kXR_InvalidRequest, kXR_NotAuthorized, kXR_NotFound, kXR_Overloaded, kXR_overQuota, kXR_ReqTimedOut, kXR_ServerError, and kXR_Unsupported.

Referenced by XrdClHttp::CurlWorker::Run().

Here is the caller graph for this function:

HTTPStatusIsError()

bool XrdClHttp::HTTPStatusIsError

(

unsigned

status

)

Definition at line 113 of file XrdClHttpUtil.cc.

                                                 {
     return (status < 100) || (status >= 400);
}

Referenced by XrdClHttp::CurlWorker::Run(), and XrdClHttp::CurlVectorReadOp::Write().

Here is the caller graph for this function:

InjectBearerToken()

void XrdClHttp::InjectBearerToken	(	const XrdCl::URL &	url,
		std::vector< std::pair< std::string, std::string > > &	headers,
		XrdCl::Log *	logger = nullptr )

Definition at line 165 of file XrdClHttpUtil.cc.

{
    if(url.GetParams().count("authz")) return;
    for(const auto &header : headers)
    {
        if(header.first == "Authorization") return;
    }
 
    const std::string token = GetBearerToken(logger);
    if(token.empty()) return;
 
    bool hasX509Credential = false;
    auto env = XrdCl::DefaultEnv::GetEnv();
    if(env)
    {
        int disableX509 = 0;
        std::string certificate;
        hasX509Credential =
            env->GetInt("HttpDisableX509", disableX509)
            && !disableX509
            && env->GetString("HttpClientCertFile", certificate)
            && !certificate.empty();
    }
 
    const char *configuredProtocols = std::getenv("XrdSecPROTOCOL");
    if(!ShouldUseBearerToken(configuredProtocols ? configuredProtocols : "",
                             hasX509Credential, true))
    {
        return;
    }
 
    if(logger)
    {
        logger->Debug(kLogXrdClHttp,
                      "Injecting bearer token from environment for %s",
                      url.GetURL().c_str());
    }
    headers.emplace_back("Authorization", "Bearer " + token);
}

References XrdCl::Log::Debug(), GetBearerToken(), XrdCl::DefaultEnv::GetEnv(), XrdCl::URL::GetParams(), XrdCl::URL::GetURL(), kLogXrdClHttp, and ShouldUseBearerToken().

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

Here is the call graph for this function:

Here is the caller graph for this function:

ltrim_view()

std::string_view XrdClHttp::ltrim_view

(

const std::string_view &

input_view

)

Definition at line 766 of file XrdClHttpUtil.cc.

                                                                     {
    for (size_t idx = 0; idx < input_view.size(); idx++) {
        if (!isspace(input_view[idx])) {
            return input_view.substr(idx);
        }
    }
    return "";
}

Referenced by trim_view().

Here is the caller graph for this function:

MarshalDuration()

std::string XrdClHttp::MarshalDuration

(

const struct timespec &

timeout

)

Definition at line 111 of file XrdClHttpParseTimeout.cc.

{
   if (duration.tv_sec == 0 && duration.tv_nsec == 0) {return "0s";}
 
   std::string result = duration.tv_sec != 0 ? std::to_string(duration.tv_sec) + "s" : "";
   if (duration.tv_nsec) {
       result += std::to_string(duration.tv_nsec / 1'000'000) + "ms";
   }
   return result;
}

Referenced by XrdClHttp::File::Open().

Here is the caller graph for this function:

ParseTimeout()

bool XrdClHttp::ParseTimeout	(	const std::string &	duration,
		struct timespec &	result,
		std::string &	errmsg )

Definition at line 26 of file XrdClHttpParseTimeout.cc.

                                                                                                  {
 
    if (duration.empty()) {
        errmsg = "cannot parse empty string as a time duration";
        return false;
    }
    if (duration == "0") {
        result = {0, 0};
        return true;
    }
    struct timespec ts = {0, 0};
    auto strValue = duration;
    while (!strValue.empty()) {
        std::size_t pos;
        double value;
        try {
            value = std::stod(strValue, &pos);
        } catch (std::invalid_argument const &exc) {
            errmsg = "Invalid number provided as timeout: " + strValue;
            return false;
        } catch (std::out_of_range const &exc) {
            errmsg = "Provided timeout out of representable range: " + std::string(exc.what());
            return false;
        }
        if (value < 0) {
            errmsg = "Provided timeout was negative";
            return false;
        }
        strValue = strValue.substr(pos);
        char unit[3] = {'\0', '\0', '\0'};
        if (!strValue.empty()) {
            unit[0] = strValue[0];
            if (unit[0] >= '0' && unit[0] <= '9') {unit[0] = '\0';}
        }
        if (strValue.size() > 1) {
            unit[1] = strValue[1];
            if (unit[1] >= '0' && unit[1] <= '9') {unit[1] = '\0';}
        }
        if (!strncmp(unit, "ns", 2)) {
            ts.tv_nsec += value;
        } else if (!strncmp(unit, "us", 2)) {
            auto value_s = (static_cast<long long>(value)) / 1'000'000;
            ts.tv_sec += value_s;
            value -= value_s * 1'000'000;
            ts.tv_nsec += value * 1'000'000;
        } else if (!strncmp(unit, "ms", 2)) {
            auto value_s = (static_cast<long long>(value)) / 1'000;
            ts.tv_sec += value_s;
            value -= value_s * 1'000;
            ts.tv_nsec += value * 1'000'000;
        } else if (!strncmp(unit, "s", 1)) {
            auto value_s = (static_cast<long long>(value));
            ts.tv_sec += value_s;
            value -= value_s;
            ts.tv_nsec += value * 1'000'000'000;
        } else if (!strncmp(unit, "m", 1)) {
            value *= 60;
            auto value_s = (static_cast<long long>(value));
            ts.tv_sec += value_s;
            value -= value_s;
            ts.tv_nsec += value * 1'000'000'000;
        } else if (!strncmp(unit, "h", 1)) {
            value *= 3600;
            auto value_s = (static_cast<long long>(value));
            ts.tv_sec += value_s;
            value -= value_s;
            ts.tv_nsec += value * 1'000'000'000;
        } else if (strlen(unit) > 0) {
            errmsg = "Unknown unit in duration: " + std::string(unit);
            return false;
        } else {
            errmsg = "Unit missing from duration: " + duration;
            return false;
        }
        if (ts.tv_nsec > 1'000'000'000) {
            ts.tv_sec += ts.tv_nsec / 1'000'000'000;
            ts.tv_nsec = ts.tv_nsec % 1'000'000'000;
        }
        strValue = strValue.substr(strlen(unit));
    }
    result.tv_nsec = ts.tv_nsec;
    result.tv_sec = ts.tv_sec;
    return true;
}

Referenced by XrdClHttp::File::ParseHeaderTimeout(), and XrdClHttp::File::SetProperty().

Here is the caller graph for this function:

ParseTokenFile()

bool XrdClHttp::ParseTokenFile	(	const std::string &	token_file,
		CurlCopyOp::Headers &	src_hdrs,
		CurlCopyOp::Headers &	dst_hdrs )

Definition at line 13 of file XrdClHttpTokenFileParser.cc.

{
    XrdCl::Log *const log = XrdCl::DefaultEnv::GetLog();
 
    std::ifstream file(token_file);
 
    if (!file.is_open())
    {
        log->Warning(kLogXrdClHttp, "Failed to open token file");
        return false;
    }
 
    constexpr std::streamsize max_token_file_size = 10 * 1024;
 
    std::string content(max_token_file_size, '\0');
    file.read(&content[0], max_token_file_size);
    content.resize(file.gcount());
 
    std::string src_token;
    std::string dst_token;
 
    if (const auto json = nlohmann::json::parse(content, nullptr, false); json.is_object())
    {
        const auto read_token = [&json, log] (const char *key, std::string &token)
        {
            if (const auto value = json.find(key); value != json.end() && value->is_string() && !value->get_ref<const std::string &>().empty())
                token = value->get_ref<const std::string &>();
            else
                log->Warning(kLogXrdClHttp, "Property '%s' of the token file is not a non-empty string", key);
        };
 
        read_token("src", src_token);
        read_token("dst", dst_token);
    }
    else
    {
        std::istringstream lines(content);
        std::getline(lines, src_token);
        std::getline(lines, dst_token);
    }
 
    if (src_token.empty() && dst_token.empty())
    {
        log->Warning(kLogXrdClHttp, "Token file holds neither a <src> nor a <dst> token");
        return false;
    }
 
    const auto add_token = [] (CurlCopyOp::Headers &headers, const std::string &token)
    {
        if (!token.empty())
            headers.emplace_back("Authorization"s, "Bearer "s + token);
    };
 
    add_token(src_hdrs, src_token);
    add_token(dst_hdrs, dst_token);
 
    return true;
}

References XrdCl::DefaultEnv::GetLog(), kLogXrdClHttp, and XrdCl::Log::Warning().

Referenced by XrdClHttp::Filesystem::ThirdPartyCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldUseBearerToken()

bool XrdClHttp::ShouldUseBearerToken	(	const std::string &	protocols,
		bool	hasX509Credential,
		bool	hasBearerToken )

Definition at line 146 of file XrdClHttpUtil.cc.

{
    if(protocols.empty()) return hasBearerToken;
 
    std::vector<std::string> requested;
    XrdCl::Utils::splitString(requested, protocols, ",");
    for(auto protocol : requested)
    {
        XrdCl::Utils::Trim(protocol);
        std::transform(protocol.begin(), protocol.end(), protocol.begin(),
            [](unsigned char c) { return std::tolower(c); });
        if(protocol == "gsi" && hasX509Credential) return false;
        if(protocol == "ztn" && hasBearerToken) return true;
    }
    return false;
}

References XrdCl::Utils::splitString(), and XrdCl::Utils::Trim().

Referenced by InjectBearerToken().

Here is the call graph for this function:

Here is the caller graph for this function:

stat_size()

std::optional< std::size_t > XrdClHttp::stat_size ( HandlerQueue & queue, const std::string & url, const CurlCopyOp::Headers & hdrs, time_t timeout, XrdCl::Log * log, const char * what )

static

Definition at line 430 of file XrdClHttpFilesystem.cc.

{
    try
    {
        const auto callout = std::make_shared<ExtraHeaderCallout>(hdrs);
        const auto rh = std::make_shared<SyncResponseHandler>();
        const auto op = std::make_shared<StatOp>(rh.get(), url, timespec{timeout, 0}, log, true, nullptr, callout.get());
 
        // The queue may run the operation after this function returns, thus
        // the operation keeps its handler and header callout alive.
        queue.Produce(std::shared_ptr<StatOp>(op.get(), [callout, rh, op](auto){}));
 
        if (!rh->wait(std::chrono::seconds(timeout)))
            log->Warning(kLogXrdClHttp, "Failed to stat the %s: Operation timed out", what);
        else if (!op->IsDone() || op->HasFailed())
            log->Debug(kLogXrdClHttp, "Failed to stat the %s", what);
        else
            return static_cast<std::size_t>(op->GetStatInfo().first);
    }
    catch (const std::exception &e) {
        log->Warning(kLogXrdClHttp, "Failed to stat the %s - %s", what, e.what());
    }
 
    return std::nullopt;
}

References XrdCl::Log::Debug(), kLogXrdClHttp, XrdClHttp::HandlerQueue::Produce(), stat_size(), and XrdCl::Log::Warning().

Referenced by stat_size(), and XrdClHttp::Filesystem::ThirdPartyCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

TapeProblemResponse()

std::string XrdClHttp::TapeProblemResponse	(	long	statusCode,
		const std::string &	body )

Definition at line 1123 of file XrdClHttpTape.cc.

  {
    return FormatProblemResponse(statusCode, body);
  }

References TapeProblemResponse().

Referenced by XrdClHttp::CurlTapeOp::Fail(), and TapeProblemResponse().

Here is the call graph for this function:

Here is the caller graph for this function:

trim_view()

std::string_view XrdClHttp::trim_view

(

const std::string_view &

input_view

)

Definition at line 755 of file XrdClHttpUtil.cc.

                                                                    {
    auto view = XrdClHttp::ltrim_view(input_view);
    for (size_t idx = 0; idx < input_view.size(); idx++) {
        if (!isspace(view[view.size() - 1 - idx])) {
            return view.substr(0, view.size() - idx);
        }
    }
    return "";
}

References ltrim_view().

Referenced by XrdClHttp::HeaderParser::ParseDigest().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_max_checksum_length

size_t XrdClHttp::g_max_checksum_length = 32

constexpr

Definition at line 30 of file XrdClHttpChecksum.hh.

kLogXrdClHttp

const uint64_t XrdClHttp::kLogXrdClHttp = 73173

Definition at line 54 of file XrdClHttpUtil.hh.

Referenced by XrdClHttp::Filesystem::Filesystem(), XrdClHttp::HeaderBuilder::Build(), XrdClHttp::File::Close(), XrdClHttp::CurlReadOp::Continue(), XrdClHttp::CurlPutOp::ContinueHandle(), XrdClHttp::CurlReadOp::ContinueHandle(), XrdClHttp::Filesystem::DirList(), XrdClHttp::CurlMkcolOp::Fail(), XrdClHttp::CurlOpenOp::Fail(), XrdClHttp::CurlOperation::Fail(), XrdClHttp::CurlPutOp::Fail(), XrdClHttp::CurlReadOp::Fail(), XrdClHttp::CurlVectorReadOp::Fail(), XrdClHttp::CurlOperation::FailCallback(), XrdClHttp::File::Fcntl(), XrdClHttp::CurlOperation::FinishSetup(), XrdClHttp::CurlStatOp::GetStatInfo(), InjectBearerToken(), XrdClHttp::Filesystem::MkDir(), XrdClHttp::File::Open(), XrdClHttp::File::ParseHeaderTimeout(), ParseTokenFile(), XrdClHttp::CurlPutOp::Pause(), XrdClHttp::CurlReadOp::Pause(), XrdClHttp::File::PgRead(), XrdClHttp::Filesystem::Query(), XrdClHttp::File::Read(), XrdClHttp::CurlOperation::Redirect(), XrdClHttp::Filesystem::Rm(), XrdClHttp::CurlWorker::Run(), XrdClHttp::CurlWorker::RunStatic(), XrdClHttp::File::SetProperty(), XrdClHttp::CurlOperation::Setup(), XrdClHttp::File::Stat(), XrdClHttp::Filesystem::Stat(), stat_size(), XrdClHttp::CurlChecksumOp::Success(), XrdClHttp::CurlDeleteOp::Success(), XrdClHttp::CurlListdirOp::Success(), XrdClHttp::CurlMkcolOp::Success(), XrdClHttp::CurlOpenOp::Success(), XrdClHttp::CurlPutOp::Success(), XrdClHttp::CurlQueryOp::Success(), XrdClHttp::CurlStatOp::SuccessImpl(), XrdClHttp::Filesystem::ThirdPartyCopy(), XrdClHttp::File::VectorRead(), XrdClHttp::CurlOperation::WaitSocketCallback(), XrdClHttp::File::Write(), and XrdClHttp::File::Write().