XrdClHttp Namespace Reference

Namespaces
	HeaderBuilder
	ThirdPartyCopyOpTypes

Classes
struct	ChecksumEntry
class	ChecksumInfo
class	ConnectionCallout
class	Factory
class	VerbsCache

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)

---

Class Documentation

XrdClHttp::ChecksumEntry

struct XrdClHttp::ChecksumEntry

Definition at line 103 of file XrdClHttpChecksum.hh.

Collaboration diagram for XrdClHttp::ChecksumEntry:

Class Members
ChecksumType	type
array< unsigned char, g_max_checksum_length >	value

Function Documentation

ConfigureHandle()

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

Definition at line 763 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 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 116 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(), getline(), 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;
}

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

Here is the caller graph for this function:

GetHandle()

CURL* XrdClHttp::GetHandle

(

bool

verbose

)

Referenced by XrdClHttp::HandlerQueue::GetHandle().

Here is the caller 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;
}

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";
}

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

Here is the caller graph for this function:

HTTPStatusConvert()

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

(

unsigned

status

)

Definition at line 207 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 112 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 164 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 753 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(), and XrdClS3::Factory::TrimView().

Here is the caller graph for this function:

MarshalDuration()

std::string XrdClHttp::MarshalDuration

(

const struct timespec &

timeout

)

ParseTimeout()

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

ParseTokenFile()

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

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

Here is the caller graph for this function:

ShouldUseBearerToken()

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

Definition at line 145 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()

static 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, 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:

TapeProblemResponse()

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

Definition at line 1123 of file XrdClHttpTape.cc.

  {
    return FormatProblemResponse(statusCode, body);
  }

Referenced by XrdClHttp::CurlTapeOp::Fail().

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 742 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: