#include <XrdClS3Factory.hh>

Inheritance diagram for XrdClS3::Factory:

Collaboration diagram for XrdClS3::Factory:

Public Member Functions
	Factory ()

	Factory (const Factory &)=delete

virtual	~Factory ()

virtual XrdCl::FilePlugIn *	CreateFile (const std::string &url) override
	Create a file plug-in for the given URL. More...

virtual XrdCl::FileSystemPlugIn *	CreateFileSystem (const std::string &url) override
	Create a file system plug-in for the given URL. More...

Public Member Functions inherited from XrdCl::PlugInFactory
virtual	~PlugInFactory ()
	Destructor. More...

Static Public Member Functions
static std::string	CleanObjectName (const std::string &object)

static std::string_view	ExtractHostname (const std::string_view url)

static bool	GenerateHttpUrl (const std::string &s3_url, std::string &https_url, std::string *obj_result, std::string &err_msg)

static bool	GenerateV4Signature (const std::string &url, const std::string &verb, std::vector< std::pair< std::string, std::string >> &headers, std::string &auth_token, std::string &err_msg)

static std::string	GetBucketFromHttpsUrl (const std::string &url)

static std::tuple< std::string, std::string, bool >	GetCredentialsForBucket (const std::string &bucket, std::string &err_msg)

static const std::string &	GetMkdirSentinel ()

static std::string	PathEncode (const std::string_view url)

static void	ResetCredCache ()

static void	SetBucketCredentials (const std::string &bucket, const std::string &access_key, const std::string &secret_key)

static void	SetDefaultCredentials (const std::string &access_key, const std::string &secret_key)

static void	SetEndpoint (const std::string &endpoint)

static void	SetRegion (const std::string &region)

static void	SetService (const std::string &service)

static void	SetUrlStyle (const std::string &url_style)

static std::string_view	TrimView (const std::string_view str)

Detailed Description

Definition at line 39 of file XrdClS3Factory.hh.

Constructor & Destructor Documentation

◆ Factory() [1/2]

Factory::Factory ( )

Definition at line 83 of file XrdClS3Factory.cc.

                  {
     std::call_once(m_init_once, [&] {
         m_log = XrdCl::DefaultEnv::GetLog();
         if (!m_log) {
             return;
         }
         m_log->SetTopicName(kLogXrdClS3, "XrdClS3");
  
         auto env = XrdCl::DefaultEnv::GetEnv();
         if (!env) {
             return;
         }
         InitS3Config();
         m_initialized = true;
     });
 }

References XrdCl::DefaultEnv::GetEnv(), XrdCl::DefaultEnv::GetLog(), XrdClS3::kLogXrdClS3, and XrdCl::Log::SetTopicName().

Here is the call graph for this function:

◆ ~Factory()

virtual XrdClS3::Factory::~Factory ( )

inlinevirtual

Definition at line 42 of file XrdClS3Factory.hh.

42 {}

◆ Factory() [2/2]

XrdClS3::Factory::Factory ( const Factory & )

delete

Member Function Documentation

◆ CleanObjectName()

std::string Factory::CleanObjectName ( const std::string & object )

static

Definition at line 291 of file XrdClS3Factory.cc.

                                                     {
     std::string obj = input_obj;
     auto loc = input_obj.find('?');
     if (loc != std::string::npos) {
         auto query = std::string_view(input_obj).substr(loc + 1);
         obj = obj.substr(0, loc);
         bool added_query = false;
         while (!query.empty()) {
             auto next_query_loc = query.find('&');
             auto current_query = (next_query_loc == std::string::npos) ? query : query.substr(0, next_query_loc);
             query = (next_query_loc == std::string::npos) ? "" : query.substr(next_query_loc + 1);
             if (current_query.empty()) {
                 continue;
             }
             auto equal_loc = current_query.find('=');
             if (equal_loc != std::string::npos) {
                 auto key = current_query.substr(0, equal_loc);
                 if (key != "authz") {
                     obj += (added_query ? "&" : "?") + std::string(current_query);
                     added_query = true;
                 }
             } else if (current_query != "authz") {
                 obj += (added_query ? "&" : "?") + std::string(current_query);
                 added_query = true;
             }
         }
     } else {
         obj = input_obj;
     }
     return obj;
 }

Referenced by GenerateHttpUrl(), XrdClS3::Filesystem::Locate(), XrdClS3::Filesystem::Query(), XrdClS3::Filesystem::Rm(), and XrdClS3::Filesystem::Stat().

Here is the caller graph for this function:

◆ CreateFile()

virtual XrdCl::FilePlugIn* XrdClS3::Factory::CreateFile ( const std::string & url )

overridevirtual

Create a file plug-in for the given URL.

Implements XrdCl::PlugInFactory.

◆ CreateFileSystem()

virtual XrdCl::FileSystemPlugIn* XrdClS3::Factory::CreateFileSystem ( const std::string & url )

overridevirtual

Create a file system plug-in for the given URL.

Implements XrdCl::PlugInFactory.

◆ ExtractHostname()

std::string_view Factory::ExtractHostname ( const std::string_view url )

static

Definition at line 324 of file XrdClS3Factory.cc.

                                                  {
     auto loc = url.find("://");
     if (loc == std::string_view::npos) {
         return {};
     }
     loc += 3; // Move past "://"
     auto slash_loc = url.find('/', loc);
     auto query_loc = url.find('?', loc);
     if (query_loc != std::string_view::npos && (slash_loc == std::string_view::npos || query_loc < slash_loc)) {
         slash_loc = query_loc; // If there's a query, we stop at it
     }
     auto authority = url.substr(loc, slash_loc - loc);
     if (authority.empty()) {
         return {};
     }
     auto at_loc = authority.find('@');
     if (at_loc != std::string_view::npos) {
         // If there's an '@', we have user info, so we skip it
         authority = authority.substr(at_loc + 1);
     }
     // If the authority contains a port, we need to strip it
     auto colon_loc = authority.find(':');
     if (colon_loc != std::string_view::npos) {
         authority = authority.substr(0, colon_loc);
     }
     return authority;
 }

Referenced by GenerateHttpUrl(), GenerateV4Signature(), and GetBucketFromHttpsUrl().

Here is the caller graph for this function:

◆ GenerateHttpUrl()

bool Factory::GenerateHttpUrl	(	const std::string &	s3_url,
		std::string &	https_url,
		std::string *	obj_result,
		std::string &	err_msg
	)

static

Definition at line 411 of file XrdClS3Factory.cc.

                                                                                                                  {
     if (s3_url.substr(0, 5) != "s3://") {
         err_msg = "Provided URL does not start with s3://";
         return false;
     }
     auto loc = s3_url.find('/', 5);
     auto bucket = s3_url.substr(5, loc - 5);
     auto at_loc = bucket.find('@');
     if (at_loc != std::string::npos) {
         std::string login = "";
         login = bucket.substr(0, at_loc);
         bucket = bucket.substr(at_loc + 1);
     }
     std::string endpoint = m_endpoint;
     std::string region = m_region;
     if ((bucket == m_endpoint) || m_endpoint.empty()) {
         endpoint = bucket;
         auto old_loc = loc + 1;
         loc = s3_url.find('/', loc + 1);
         if (loc == std::string::npos) {
             err_msg = "Provided S3 URL does not contain a bucket in path";
             return false;
         }
         bucket = s3_url.substr(old_loc, loc - old_loc);
     } else {
         auto authority = ExtractHostname(s3_url);
         std::string test_endpoint = "." + endpoint;
         if (!m_region.empty()) {
             auto bucket_loc = authority.rfind("." + m_region + test_endpoint);
             if (bucket_loc != std::string::npos) {
                 bucket = authority.substr(0, bucket_loc);
             } else {
                 auto bucket_loc = authority.rfind(test_endpoint);
                 if (bucket_loc != std::string::npos) {
                     bucket = authority.substr(0, bucket_loc);
                 }
             }
         } else {
             auto bucket_loc = authority.rfind(test_endpoint);
             if (bucket_loc != std::string::npos) {
                 bucket = authority.substr(0, bucket_loc);
             }
         }
     }
     std::string obj;
     if (loc != std::string::npos) {
         obj = s3_url.substr(loc + 1);
     }
     // Strip out "authz" query parameters; those are internal to XRootD.
     obj = CleanObjectName(obj);
     if (obj_result) {
         *obj_result = obj;
     }
     if (m_url_style == "virtual" || m_url_style.empty()) {
         https_url = "https://" + bucket + "." + m_region + "." + endpoint + (obj_result ? "" : ("/" + obj));
         return true;
     } else if (m_url_style == "path") {
         if (!m_region.empty()) {
             https_url = "https://" + m_region + "." + endpoint + "/" + bucket + (obj_result ? "" : ("/" + obj));
         } else {
             https_url = "https://" + endpoint + "/" + bucket + (obj_result ? "" : ("/" + obj));
         }
         return true;
     } else {
         err_msg = "Server configuration has invalid setting for URL style";
         return false;
     }
 }

References CleanObjectName(), and ExtractHostname().

Referenced by XrdClS3::Filesystem::DirList(), and XrdClS3::Filesystem::MkDir().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateV4Signature()

bool Factory::GenerateV4Signature	(	const std::string &	url,
		const std::string &	verb,
		std::vector< std::pair< std::string, std::string >> &	headers,
		std::string &	auth_token,
		std::string &	err_msg
	)

static

Definition at line 481 of file XrdClS3Factory.cc.

                                                                                                                                                                       {
     auto bucket = GetBucketFromHttpsUrl(url);
  
     // If we're using temporary credentials, we need to add the token
     // header here as well.  We set saKey and keyID here (well before
     // necessary) since we'll get them for free when we get the token.
     auto [keyId, secretKey, ok] = GetCredentialsForBucket(bucket, err_msg);
     if (!ok) {
         return false;
     }
  
     if (secretKey.empty()) {
         auth_token = "";
         return true;
     }
  
     //
     // Create task 1's inputs.
     //
  
     auto canonicalURI = PathEncode(url);
  
     // The canonical query string is the alphabetically sorted list of
     // URI-encoded parameter names '=' values, separated by '&'s.
     auto canonicalQueryString = CanonicalizeQueryString(url);
  
     // The canonical headers must include the Host header, so add that
     // now if we don't have it.
     if (std::find_if(headers.begin(), headers.end(), 
                         [](const auto &pair) { return pair.first == "Host"; }) == headers.end()) {
         auto host = ExtractHostname(url);
         if (host.empty()) {
             err_msg = "Unable to extract hostname from URL: " + url;
             return false;
         }
         headers.emplace_back("Host", host);
     }
  
     // S3 complains if x-amz-date isn't signed, so do this early.
     auto iter = std::find_if(headers.begin(), headers.end(),
         [](const auto &pair) { return !strcasecmp(pair.first.c_str(), "X-Amz-Date"); });
     std::string date_time;
     char date_char[] = "YYYYMMDD";
     if (iter == headers.end()) {
         time_t now;
         time(&now);
         struct tm brokenDownTime;
         gmtime_r(&now, &brokenDownTime);
  
         date_time =  "YYYYMMDDThhmmssZ";
         strftime(date_time.data(), date_time.size(), "%Y%m%dT%H%M%SZ", &brokenDownTime);
         headers.emplace_back("X-Amz-Date", date_time);
         strftime(date_char, sizeof(date_char), "%Y%m%d", &brokenDownTime);
     } else {
         date_time = iter->second;
         auto loc = date_time.find('T', 0);
         if (loc != 8) {
             err_msg = "Invalid value for X-Amz-Date";
             return false;
         }
         memcpy(date_char, date_time.c_str(), 8);
     }
  
     // The canonical payload hash is the lowercase hexadecimal string of the
     // (SHA256) hash value of the payload or "UNSIGNED-PAYLOAD" if
     // we are not signing the payload.
     std::string payload_hash = "UNSIGNED-PAYLOAD";
     iter = std::find_if(headers.begin(), headers.end(),
         [](const auto &pair) { return !strcasecmp(pair.first.c_str(), "X-Amz-Content-Sha256"); });
     if (iter == headers.end()) {
         headers.emplace_back("X-Amz-Content-Sha256", payload_hash);
     } else {
         payload_hash = iter->second;
     }
  
     // The canonical list of headers is a sorted list of lowercase header
     // names paired via ':' with the trimmed header value, each pair
     // terminated with a newline.
     std::vector<std::pair<std::string, std::string>> transformed_headers;
     transformed_headers.reserve(headers.size());
     for (const auto &info : headers) {
         std::string header = info.first;
         std::transform(header.begin(), header.end(), header.begin(), &tolower);
  
         std::string value = info.second;
         if (value.empty()) {
             continue;
         }
         auto value_trimmed = std::string(TrimView(value));
  
         // Convert internal runs of spaces into single spaces.
         unsigned left = 1;
         unsigned right = 1;
         bool inSpaces = false;
         while (right < value_trimmed.length()) {
             if (!inSpaces) {
                 if (value_trimmed[right] == ' ') {
                     inSpaces = true;
                     left = right;
                     ++right;
                 } else {
                     ++right;
                 }
             } else {
                 if (value_trimmed[right] == ' ') {
                     ++right;
                 } else {
                     inSpaces = false;
                     value_trimmed.erase(left, right - left - 1);
                     right = left + 1;
                 }
             }
         }
  
         transformed_headers.emplace_back(header, value);
     }
     std::sort(transformed_headers.begin(), transformed_headers.end(),
                 [](const auto &a, const auto &b) { return a.first < b.first; });
  
     // The canonical list of signed headers is trivial to generate while
     // generating the list of headers.
     std::string signedHeaders, canonicalHeaders;
     for (const auto &info : transformed_headers) {
         canonicalHeaders += info.first + ":" + info.second + "\n";
         signedHeaders += info.first + ";";
     }
     signedHeaders.erase(signedHeaders.end() - 1);
  
     // Task 1: create the canonical request.
     auto canonicalRequest =
         verb + "\n" + canonicalURI + "\n" + canonicalQueryString + "\n" +
         canonicalHeaders + "\n" + signedHeaders + "\n" + payload_hash;
  
     //
     // Create task 2's inputs.
     //
  
     // Hash the canonical request the way we did the payload.
     std::string canonicalRequestHash;
     std::vector<unsigned char> messageDigest;
     messageDigest.resize(EVP_MAX_MD_SIZE);
     if (!ComputeSHA256(canonicalRequest, messageDigest)) {
         err_msg = "Unable to hash canonical request.";
         return false;
     }
     MessageDigestAsHex(messageDigest, canonicalRequestHash);
  
     // Task 2: create the string to sign.
     auto credentialScope = std::string(date_char) + "/" + m_region + "/" + m_service + "/aws4_request";
     auto stringToSign = std::string("AWS4-HMAC-SHA256\n") + date_time + "\n" + credentialScope + "\n" + canonicalRequestHash;
  
     //
     // Creating task 3's inputs was done when we checked to see if we needed
     // to get the security token, since they come along for free when we do.
     //
  
     // Task 3: calculate the signature.
     auto saKey = std::string("AWS4") + secretKey;
     unsigned int mdLength = 0;
     const unsigned char *hmac =
         HMAC(EVP_sha256(), saKey.c_str(), saKey.length(), (unsigned char *)date_char,
                 sizeof(date_char) - 1, messageDigest.data(), &mdLength);
     if (hmac == NULL) {
         err_msg = "Unable to calculate HMAC for date.";
         return false;
     }
  
     unsigned int md2Length = 0;
     unsigned char messageDigest2[EVP_MAX_MD_SIZE];
     hmac = HMAC(EVP_sha256(), messageDigest.data(), mdLength,
                 reinterpret_cast<unsigned char *>(m_region.data()), m_region.size(), messageDigest2,
                 &md2Length);
     if (hmac == NULL) {
         err_msg = "Unable to calculate HMAC for region.";
         return false;
     }
  
     hmac = HMAC(EVP_sha256(), messageDigest2, md2Length,
                 reinterpret_cast<unsigned char *>(m_service.data()), m_service.size(), messageDigest.data(),
                 &mdLength);
     if (hmac == NULL) {
         err_msg = "Unable to calculate HMAC for service.";
         return false;
     }
  
     const char request_char[] = "aws4_request";
     hmac = HMAC(EVP_sha256(), messageDigest.data(), messageDigest.size(), reinterpret_cast<const unsigned char *>(request_char),
                 sizeof(request_char) - 1, messageDigest2, &md2Length);
     if (hmac == NULL) {
         err_msg = "Unable to calculate HMAC for request.";
         return false;
     }
  
     hmac = HMAC(EVP_sha256(), messageDigest2, md2Length,
                 reinterpret_cast<unsigned char *>(stringToSign.data()),
                 stringToSign.size(), messageDigest.data(), &mdLength);
     if (hmac == NULL) {
         err_msg = "Unable to calculate HMAC for request string.";
         return false;
     }
  
     std::string signature;
     MessageDigestAsHex(messageDigest, signature);
  
     auth_token =
                 std::string("AWS4-HMAC-SHA256 Credential=") + keyId + "/" + credentialScope +
                 ",SignedHeaders=" + signedHeaders + ",Signature=" + signature;
     return true;
 }

References ExtractHostname(), GetBucketFromHttpsUrl(), GetCredentialsForBucket(), PathEncode(), and TrimView().

Here is the call graph for this function:

◆ GetBucketFromHttpsUrl()

std::string Factory::GetBucketFromHttpsUrl ( const std::string & url )

static

Definition at line 692 of file XrdClS3Factory.cc.

                                                    {
     if (m_url_style == "virtual" || m_url_style.empty()) {
         // Virtual-hosted-style URLs are of the form https://bucket.region.endpoint/object
         auto hostname = ExtractHostname(url);
         if (hostname.empty()) {
             return {};
         }
         auto test_endpoint = "." + m_endpoint;
         if (!m_region.empty()) test_endpoint = "." + m_region + test_endpoint;
         auto loc = hostname.rfind(test_endpoint);
         if (loc == std::string::npos) {
             if (!m_region.empty()) {
                 loc = hostname.rfind("." + m_endpoint);
                 if (loc != std::string::npos) {
                     return std::string(hostname.substr(0, loc));
                 }
             }
             return {};
         }
         return std::string(hostname.substr(0, loc));
     } else if (m_url_style == "path") {
         // Path style URLs are of the form https://region.endpoint/bucket/object
         auto loc = url.find("://");
         if (loc == std::string::npos) {
             return {};
         }
         loc += 3; // Move past "://"
         auto slash_loc = url.find('/', loc);
         if (slash_loc == std::string::npos) {
             return {};
         }
         auto bucket_start = slash_loc + 1;
         auto bucket_end = url.find('/', bucket_start);
         if (bucket_end == std::string::npos) {
             return url.substr(bucket_start);
         }
         return url.substr(bucket_start, bucket_end - bucket_start);
     } else {
         // Invalid URL style
         return {};
     }
 }

References ExtractHostname().

Referenced by GenerateV4Signature().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCredentialsForBucket()

std::tuple< std::string, std::string, bool > Factory::GetCredentialsForBucket	(	const std::string &	bucket,
		std::string &	err_msg
	)

static

Definition at line 736 of file XrdClS3Factory.cc.

 {
     auto now = std::chrono::steady_clock::now();
     {
         std::shared_lock lock(m_bucket_auth_map_mutex);
         auto iter = m_bucket_auth_map.find(bucket);
         if (iter != m_bucket_auth_map.end()) {
             // If we have credentials for this bucket, check if they are still valid.
             auto &creds = iter->second.first;
             auto &expiration = iter->second.second;
             if (now < expiration) {
                 // Credentials are still valid, return them.
                 return {creds.m_accesskey, creds.m_secretkey, true};
             }
         }
     }
  
     std::unique_lock lock(m_bucket_auth_map_mutex);
     auto iter = m_bucket_location_map.find(bucket);
     std::string access_key_location, secret_key_location;
     if (iter == m_bucket_location_map.end()) {
         // If we don't have credentials for this bucket, use the default.
         if (m_default_creds.m_accesskey.empty() || m_default_creds.m_secretkey.empty()) {
             // No credentials at all, so we assume public access.
             m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::minutes(1)};
             return {"", "", true};
         }
         access_key_location = m_default_creds.m_accesskey;
         secret_key_location = m_default_creds.m_secretkey;
     } else {
         access_key_location = iter->second.m_accesskey;
         secret_key_location = iter->second.m_secretkey;
     }
     if (access_key_location.empty() && secret_key_location.empty()) {
         // If both are empty, we assume public access.
         m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::minutes(1)};
         return {"", "", true};
     }
     if (access_key_location.empty() || secret_key_location.empty()) {
         err_msg = "No credentials available for bucket: " + bucket;
         m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
         return {"", "", false};
     }
  
     std::string access_key, secret_key;
     if (!ReadShortFile(access_key_location, access_key, err_msg)) {
         m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
         return {"", "", false};
     }
     access_key = TrimView(access_key);
  
     if (!ReadShortFile(secret_key_location, secret_key, err_msg)) {
         m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
         return {"", "", false};
     }
     secret_key = TrimView(secret_key);
  
     if (access_key.empty() || secret_key.empty()) {
         err_msg = "Credentials for bucket '" + bucket + "' are empty.";
         m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
         return {"", "", false};
     }
     m_bucket_auth_map[bucket] = {{access_key, secret_key}, now + std::chrono::minutes(1)};
     return {access_key, secret_key, true};
 }

References TrimView().

Referenced by GenerateV4Signature().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMkdirSentinel()

static const std::string& XrdClS3::Factory::GetMkdirSentinel ( )

inlinestatic

Definition at line 81 of file XrdClS3Factory.hh.

81 {return m_mkdir_sentinel;}

Referenced by XrdClS3::Filesystem::MkDir(), and XrdClS3::Filesystem::RmDir().

Here is the caller graph for this function:

◆ PathEncode()

std::string Factory::PathEncode ( const std::string_view url )

static

Definition at line 803 of file XrdClS3Factory.cc.

                                             {
     auto loc = url.find("://");
     if (loc == std::string_view::npos) {
         return "";
     }
     auto path_loc = url.find("/", loc + 3);
     auto query_loc = url.find("?", loc + 3);
     if (query_loc != std::string_view::npos && (path_loc == std::string_view::npos || query_loc < path_loc)) {
         // No path, just a query string
         return "/";
     }
     auto path = url.substr(path_loc, query_loc - path_loc);
     std::string segment;
         std::string encoded;
         
         size_t next = 0;
         size_t offset = 0;
         const auto length = path.size();
         while (offset < length) {
                 next = strcspn(path.data() + offset, "/");
                 if (next == 0) {
                         encoded += "/";
                         offset += 1;
                         continue;
                 }
         if (offset + next >= length) {
             next = length - offset;
         }
  
                 segment = std::string(path.data() + offset, next);
                 encoded += AmazonURLEncode(segment);
  
                 offset += next;
         }
         return encoded;
 }

Referenced by GenerateV4Signature().

Here is the caller graph for this function:

◆ ResetCredCache()

static void XrdClS3::Factory::ResetCredCache ( )

inlinestatic

Definition at line 96 of file XrdClS3Factory.hh.

                                  {
         std::unique_lock lock(m_bucket_auth_map_mutex);
         m_bucket_auth_map.clear();
     }

◆ SetBucketCredentials()

static void XrdClS3::Factory::SetBucketCredentials	(	const std::string &	bucket,
		const std::string &	access_key,
		const std::string &	secret_key
	)

inlinestatic

Definition at line 93 of file XrdClS3Factory.hh.

                                                                                                                         {
         m_bucket_location_map[bucket] = {access_key, secret_key};
     }

◆ SetDefaultCredentials()

static void XrdClS3::Factory::SetDefaultCredentials	(	const std::string &	access_key,
		const std::string &	secret_key
	)

inlinestatic

Definition at line 89 of file XrdClS3Factory.hh.

                                                                                                 {
         m_default_creds.m_accesskey = access_key;
         m_default_creds.m_secretkey = secret_key;
     }

◆ SetEndpoint()

static void XrdClS3::Factory::SetEndpoint ( const std::string & endpoint )

inlinestatic

Definition at line 85 of file XrdClS3Factory.hh.

85 { m_endpoint = endpoint; }

◆ SetRegion()

static void XrdClS3::Factory::SetRegion ( const std::string & region )

inlinestatic

Definition at line 87 of file XrdClS3Factory.hh.

87 { m_region = region; }

◆ SetService()

static void XrdClS3::Factory::SetService ( const std::string & service )

inlinestatic

Definition at line 86 of file XrdClS3Factory.hh.

86 { m_service = service; }

◆ SetUrlStyle()

static void XrdClS3::Factory::SetUrlStyle ( const std::string & url_style )

inlinestatic

Definition at line 88 of file XrdClS3Factory.hh.

88 { m_url_style = url_style; }

◆ TrimView()

std::string_view Factory::TrimView ( const std::string_view str )

static

Definition at line 842 of file XrdClS3Factory.cc.

                                                  {
     auto view = 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 XrdClHttp::ltrim_view().

Referenced by GenerateV4Signature(), and GetCredentialsForBucket().

Here is the call graph for this function:

Here is the caller graph for this function:

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Factory() [1/2]

◆ ~Factory()

◆ Factory() [2/2]

Member Function Documentation

◆ CleanObjectName()

◆ CreateFile()

◆ CreateFileSystem()

◆ ExtractHostname()

◆ GenerateHttpUrl()

◆ GenerateV4Signature()

◆ GetBucketFromHttpsUrl()

◆ GetCredentialsForBucket()

◆ GetMkdirSentinel()

◆ PathEncode()

◆ ResetCredCache()

◆ SetBucketCredentials()

◆ SetDefaultCredentials()

◆ SetEndpoint()

◆ SetRegion()

◆ SetService()

◆ SetUrlStyle()

◆ TrimView()