#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().