#include <XrdHttpHeaderUtils.hh>

Collaboration diagram for XrdHttpHeaderUtils:

Static Public Member Functions
static void	parseReprDigest (const std::string &value, std::map< std::string, std::string > &output)

static void	parseWantReprDigest (const std::string &value, std::map< std::string, uint8_t > &output)

Detailed Description

Definition at line 30 of file XrdHttpHeaderUtils.hh.

Member Function Documentation

◆ parseReprDigest()

void XrdHttpHeaderUtils::parseReprDigest	(	const std::string &	value,
		std::map< std::string, std::string > &	output
	)

static

Parses the 'Repr-Digest' header value received from the client Syntax: "Repr-Digest: adler=:base64EncodedValue:, crc32=:base64EncodedValue:

Parameters

value	contains the value of the header Repr-Digest
output	the map containing the digests and their associated base64 encoded values

Definition at line 31 of file XrdHttpHeaderUtils.cc.

                                                                                                      {
   // Expected format per entry: <cksumType>=:<digestValue>:
   std::vector<std::string> digestNameValuePairs;
   XrdOucTUtils::splitString(digestNameValuePairs, value, ",");
  
   for (const auto &digestNameValue : digestNameValuePairs) {
     std::string_view digestNameValueSV {digestNameValue};
     auto equalPos = digestNameValueSV.find('=');
     if (equalPos == std::string_view::npos || equalPos >= digestNameValueSV.size() - 1)
       continue;
  
     std::string_view cksumTypeSV = digestNameValueSV.substr(0, equalPos);
     XrdOucUtils::trim(cksumTypeSV);
     if (cksumTypeSV.empty())
       continue;
  
     std::string_view cksumValueInSV = digestNameValueSV.substr(equalPos + 1);
     size_t beginCksumPos = cksumValueInSV.find(':');
     size_t endCksumPos = cksumValueInSV.rfind(':');
  
     // Check that the string starts with ':' and contains two distinct colons
     if (beginCksumPos == 0 && endCksumPos > beginCksumPos + 1 && endCksumPos < cksumValueInSV.size()) {
       std::string_view cksumValue = cksumValueInSV.substr(beginCksumPos + 1, endCksumPos - beginCksumPos - 1);
       XrdOucUtils::trim(cksumValue);
       if (!cksumValue.empty()) {
         //What we get as checksum value is a base64-encoded hexadecimal bytes
         //Let's decode that.
         std::string chksumDecoded;
         base64DecodeHex(std::string(cksumValue), chksumDecoded);
         std::string cksumTypeLC {cksumTypeSV};
         std::transform(cksumTypeLC.begin(), cksumTypeLC.end(), cksumTypeLC.begin(), ::tolower);
         output[cksumTypeLC] = chksumDecoded;
       }
     }
     // Malformed entries are silently ignored
   }
 }

References base64DecodeHex(), XrdOucTUtils::splitString(), and XrdOucUtils::trim().

Referenced by XrdHttpReq::parseLine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseWantReprDigest()

void XrdHttpHeaderUtils::parseWantReprDigest	(	const std::string &	value,
		std::map< std::string, uint8_t > &	output
	)

static

Parses 'Want-Repr-Digest' header value received from the client Syntax: "Want-Repr-Digest: adler=1, crc32=2, sha-256=9 The values are integers representing the preference, comprised between 0 and 9.

Parameters

value	contains the value of the header Want-Repr-Digest
output	the map containing the lower-cased digest name and the associated preference

Definition at line 69 of file XrdHttpHeaderUtils.cc.

                                                                                                         {
   size_t pos = 0;
   std::string_view value_sv {value};
   while(pos <= value_sv.size()) {
     // find comma
     size_t comma = value.find(',',pos);
     // extract item, no comma means the item is the full string
     std::string_view item = (comma == std::string_view::npos) ? value_sv.substr(pos) : value_sv.substr(pos, comma - pos);
     // move current cursor to 'comma + 1' or after the string end
     pos = (comma == std::string_view::npos) ? value.size() + 1 : comma + 1;
     // trim the item
     XrdOucUtils::trim(item);
     if(item.empty()) continue;
  
     size_t eq = item.find('=');
     // If no '=' sign, we discard this entry as it is malformed
     if(eq == std::string_view::npos) continue;
     // We found the equal sign on the item
     std::string_view digestName {item.substr(0, eq)};
     XrdOucUtils::trim(digestName);
     std::string_view preference {item.substr(eq+1)};
     XrdOucUtils::trim(preference);
  
     std::string key_lower {digestName};
     std::transform(key_lower.begin(),key_lower.end(),key_lower.begin(),::tolower);
  
     try {
       uint8_t preference_us = XrdOucUtils::touint8_t(preference);
       // Max allowed value for Repr-Digest is 10
       preference_us = std::min(preference_us,(uint8_t)10);
       output[key_lower] = preference_us;
     } catch (...) {
       // discard invalid values
     }
   }
 }

References XrdOucUtils::touint8_t(), and XrdOucUtils::trim().