XrdHttpUtils.hh File Reference

Utility functions for XrdHTTP. More...

#include "XProtocol/XPtypes.hh"
#include "XProtocol/XProtocol.hh"
#include "XrdSec/XrdSecEntity.hh"
#include "XrdOuc/XrdOucIOVec.hh"
#include "XrdOuc/XrdOucTUtils.hh"
#include <string>
#include <cstring>
#include <vector>
#include <memory>
#include <sstream>
#include <cstdint>

Include dependency graph for XrdHttpUtils.hh:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef std::vector< XrdOucIOVec2 >	XrdHttpIOList

Enumerations
enum	: int {   HTTP_CONTINUE = 100 ,   HTTP_SWITCHING_PROTOCOLS = 101 ,   HTTP_PROCESSING = 102 ,   HTTP_EARLY_HINTS = 103 ,   HTTP_OK = 200 ,   HTTP_CREATED = 201 ,   HTTP_ACCEPTED = 202 ,   HTTP_NON_AUTHORITATIVE_INFORMATION = 203 ,   HTTP_NO_CONTENT = 204 ,   HTTP_RESET_CONTENT = 205 ,   HTTP_PARTIAL_CONTENT = 206 ,   HTTP_MULTI_STATUS = 207 ,   HTTP_ALREADY_REPORTED = 208 ,   HTTP_IM_USED = 226 ,   HTTP_MULTIPLE_CHOICES = 300 ,   HTTP_MOVED_PERMANENTLY = 301 ,   HTTP_FOUND = 302 ,   HTTP_SEE_OTHER = 303 ,   HTTP_NOT_MODIFIED = 304 ,   HTTP_USE_PROXY = 305 ,   HTTP_TEMPORARY_REDIRECT = 307 ,   HTTP_PERMANENT_REDIRECT = 308 ,   HTTP_BAD_REQUEST = 400 ,   HTTP_UNAUTHORIZED = 401 ,   HTTP_PAYMENT_REQUIRED = 402 ,   HTTP_FORBIDDEN = 403 ,   HTTP_NOT_FOUND = 404 ,   HTTP_METHOD_NOT_ALLOWED = 405 ,   HTTP_NOT_ACCEPTABLE = 406 ,   HTTP_PROXY_AUTHENTICATION_REQUIRED = 407 ,   HTTP_REQUEST_TIMEOUT = 408 ,   HTTP_CONFLICT = 409 ,   HTTP_GONE = 410 ,   HTTP_LENGTH_REQUIRED = 411 ,   HTTP_PRECONDITION_FAILED = 412 ,   HTTP_PAYLOAD_TOO_LARGE = 413 ,   HTTP_URI_TOO_LONG = 414 ,   HTTP_UNSUPPORTED_MEDIA_TYPE = 415 ,   HTTP_RANGE_NOT_SATISFIABLE = 416 ,   HTTP_EXPECTATION_FAILED = 417 ,   HTTP_IM_A_TEAPOT = 418 ,   HTTP_MISDIRECTED_REQUEST = 421 ,   HTTP_UNPROCESSABLE_ENTITY = 422 ,   HTTP_LOCKED = 423 ,   HTTP_FAILED_DEPENDENCY = 424 ,   HTTP_TOO_EARLY = 425 ,   HTTP_UPGRADE_REQUIRED = 426 ,   HTTP_PRECONDITION_REQUIRED = 428 ,   HTTP_TOO_MANY_REQUESTS = 429 ,   HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431 ,   HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451 ,   HTTP_INTERNAL_SERVER_ERROR = 500 ,   HTTP_NOT_IMPLEMENTED = 501 ,   HTTP_BAD_GATEWAY = 502 ,   HTTP_SERVICE_UNAVAILABLE = 503 ,   HTTP_GATEWAY_TIMEOUT = 504 ,   HTTP_HTTP_VERSION_NOT_SUPPORTED = 505 ,   HTTP_VARIANT_ALSO_NEGOTIATES = 506 ,   HTTP_INSUFFICIENT_STORAGE = 507 ,   HTTP_LOOP_DETECTED = 508 ,   HTTP_NOT_EXTENDED = 510 ,   HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511 }

Functions
void	base64DecodeHex (const std::string &base64, std::string &hexOutput)
void	base64ToBytes (const std::string &base64digest, std::vector< uint8_t > &outputBytes)
void	bytesToHex (const std::vector< uint8_t > &bytes, std::string &hexOutput)
void	calcHashes (char *hash, const char *fn, kXR_int16 req, XrdSecEntity *secent, time_t tim, const char *key)
int	compareHash (const char *h1, const char *h2)
char *	decode_raw (const std::string &str)
std::string	decode_str (const std::string &str)
std::string	encode_opaque (const std::string &opaque)
char *	encode_raw (const std::string &str)
std::string	encode_str (const std::string &str)
char *	escapeXML (const char *str)
bool	Fromhexdigest (const std::string &hex, std::vector< uint8_t > &outputBytes)
std::string	httpStatusToString (int status)
std::string	itos (long i)
int	mapErrNoToHttp (int err)
int	mapXrdErrToHttp (XErrorCode xrdError)
char *	mystrchrnul (const char *s, int c)
char *	quote (const char *str)
void	Tobase64 (const std::vector< uint8_t > &input, std::string &base64Output)
void	Tobase64 (const unsigned char *input, int length, char *out)
char *	unquote (char *str)

Detailed Description

Utility functions for XrdHTTP.

Author

Fabrizio Furano

Date

April 2013

Definition in file XrdHttpUtils.hh.

Typedef Documentation

XrdHttpIOList

typedef std::vector<XrdOucIOVec2> XrdHttpIOList

Definition at line 255 of file XrdHttpUtils.hh.

Enumeration Type Documentation

anonymous enum

anonymous enum : int

Enumerator
HTTP_CONTINUE
HTTP_SWITCHING_PROTOCOLS
HTTP_PROCESSING
HTTP_EARLY_HINTS
HTTP_OK
HTTP_CREATED
HTTP_ACCEPTED
HTTP_NON_AUTHORITATIVE_INFORMATION
HTTP_NO_CONTENT
HTTP_RESET_CONTENT
HTTP_PARTIAL_CONTENT
HTTP_MULTI_STATUS
HTTP_ALREADY_REPORTED
HTTP_IM_USED
HTTP_MULTIPLE_CHOICES
HTTP_MOVED_PERMANENTLY
HTTP_FOUND
HTTP_SEE_OTHER
HTTP_NOT_MODIFIED
HTTP_USE_PROXY
HTTP_TEMPORARY_REDIRECT
HTTP_PERMANENT_REDIRECT
HTTP_BAD_REQUEST
HTTP_UNAUTHORIZED
HTTP_PAYMENT_REQUIRED
HTTP_FORBIDDEN
HTTP_NOT_FOUND
HTTP_METHOD_NOT_ALLOWED
HTTP_NOT_ACCEPTABLE
HTTP_PROXY_AUTHENTICATION_REQUIRED
HTTP_REQUEST_TIMEOUT
HTTP_CONFLICT
HTTP_GONE
HTTP_LENGTH_REQUIRED
HTTP_PRECONDITION_FAILED
HTTP_PAYLOAD_TOO_LARGE
HTTP_URI_TOO_LONG
HTTP_UNSUPPORTED_MEDIA_TYPE
HTTP_RANGE_NOT_SATISFIABLE
HTTP_EXPECTATION_FAILED
HTTP_IM_A_TEAPOT
HTTP_MISDIRECTED_REQUEST
HTTP_UNPROCESSABLE_ENTITY
HTTP_LOCKED
HTTP_FAILED_DEPENDENCY
HTTP_TOO_EARLY
HTTP_UPGRADE_REQUIRED
HTTP_PRECONDITION_REQUIRED
HTTP_TOO_MANY_REQUESTS
HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
HTTP_UNAVAILABLE_FOR_LEGAL_REASONS
HTTP_INTERNAL_SERVER_ERROR
HTTP_NOT_IMPLEMENTED
HTTP_BAD_GATEWAY
HTTP_SERVICE_UNAVAILABLE
HTTP_GATEWAY_TIMEOUT
HTTP_HTTP_VERSION_NOT_SUPPORTED
HTTP_VARIANT_ALSO_NEGOTIATES
HTTP_INSUFFICIENT_STORAGE
HTTP_LOOP_DETECTED
HTTP_NOT_EXTENDED
HTTP_NETWORK_AUTHENTICATION_REQUIRED

Definition at line 52 of file XrdHttpUtils.hh.

     : int {
  HTTP_CONTINUE                        = 100,
  HTTP_SWITCHING_PROTOCOLS             = 101,
  HTTP_PROCESSING                      = 102,
  HTTP_EARLY_HINTS                     = 103,
 
  // 2xx Success
  HTTP_OK                              = 200,
  HTTP_CREATED                         = 201,
  HTTP_ACCEPTED                        = 202,
  HTTP_NON_AUTHORITATIVE_INFORMATION   = 203,
  HTTP_NO_CONTENT                      = 204,
  HTTP_RESET_CONTENT                   = 205,
  HTTP_PARTIAL_CONTENT                 = 206,
  HTTP_MULTI_STATUS                    = 207,
  HTTP_ALREADY_REPORTED                = 208,
  HTTP_IM_USED                         = 226,
 
  // 3xx Redirection
  HTTP_MULTIPLE_CHOICES                = 300,
  HTTP_MOVED_PERMANENTLY               = 301,
  HTTP_FOUND                           = 302,
  HTTP_SEE_OTHER                       = 303,
  HTTP_NOT_MODIFIED                    = 304,
  HTTP_USE_PROXY                       = 305,
  HTTP_TEMPORARY_REDIRECT              = 307,
  HTTP_PERMANENT_REDIRECT              = 308,
 
  // 4xx Client Errors
  HTTP_BAD_REQUEST                     = 400,
  HTTP_UNAUTHORIZED                    = 401,
  HTTP_PAYMENT_REQUIRED                = 402,
  HTTP_FORBIDDEN                       = 403,
  HTTP_NOT_FOUND                       = 404,
  HTTP_METHOD_NOT_ALLOWED              = 405,
  HTTP_NOT_ACCEPTABLE                  = 406,
  HTTP_PROXY_AUTHENTICATION_REQUIRED   = 407,
  HTTP_REQUEST_TIMEOUT                 = 408,
  HTTP_CONFLICT                        = 409,
  HTTP_GONE                            = 410,
  HTTP_LENGTH_REQUIRED                 = 411,
  HTTP_PRECONDITION_FAILED             = 412,
  HTTP_PAYLOAD_TOO_LARGE               = 413,
  HTTP_URI_TOO_LONG                    = 414,
  HTTP_UNSUPPORTED_MEDIA_TYPE          = 415,
  HTTP_RANGE_NOT_SATISFIABLE           = 416,
  HTTP_EXPECTATION_FAILED              = 417,
  HTTP_IM_A_TEAPOT                     = 418, // RFC 2324
  HTTP_MISDIRECTED_REQUEST             = 421,
  HTTP_UNPROCESSABLE_ENTITY            = 422,
  HTTP_LOCKED                          = 423,
  HTTP_FAILED_DEPENDENCY               = 424,
  HTTP_TOO_EARLY                       = 425,
  HTTP_UPGRADE_REQUIRED                = 426,
  HTTP_PRECONDITION_REQUIRED           = 428,
  HTTP_TOO_MANY_REQUESTS               = 429,
  HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
  HTTP_UNAVAILABLE_FOR_LEGAL_REASONS   = 451,
 
  // 5xx Server Errors
  HTTP_INTERNAL_SERVER_ERROR           = 500,
  HTTP_NOT_IMPLEMENTED                 = 501,
  HTTP_BAD_GATEWAY                     = 502,
  HTTP_SERVICE_UNAVAILABLE             = 503,
  HTTP_GATEWAY_TIMEOUT                 = 504,
  HTTP_HTTP_VERSION_NOT_SUPPORTED      = 505,
  HTTP_VARIANT_ALSO_NEGOTIATES         = 506,
  HTTP_INSUFFICIENT_STORAGE            = 507,
  HTTP_LOOP_DETECTED                   = 508,
  HTTP_NOT_EXTENDED                    = 510,
  HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511,
};

Function Documentation

base64DecodeHex()

void base64DecodeHex	(	const std::string &	base64,
		std::string &	hexOutput
	)

Definition at line 155 of file XrdHttpUtils.cc.

                                                                      {
  std::vector<uint8_t> bytes;
  base64ToBytes(base64,bytes);
  bytesToHex(bytes, hexOutput);
}

References base64ToBytes(), and bytesToHex().

Referenced by XrdHttpHeaderUtils::parseReprDigest().

Here is the call graph for this function:

Here is the caller graph for this function:

base64ToBytes()

void base64ToBytes	(	const std::string &	base64digest,
		std::vector< uint8_t > &	outputBytes
	)

Definition at line 118 of file XrdHttpUtils.cc.

                                                                                     {
  outputBytes.clear();
 
  if (base64digest.empty()) {
    return;
  }
 
  BIO *b64 = BIO_new(BIO_f_base64());
  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); // match your encoder
 
  BIO *bmem = BIO_new_mem_buf(base64digest.data(), static_cast<int>(base64digest.size()));
  bmem = BIO_push(b64, bmem);
 
  // Estimate maximum size (base64 expands data by ~33%)
  std::vector<uint8_t> buffer(base64digest.size());
 
  int decodedLen = BIO_read(bmem, buffer.data(), static_cast<int>(buffer.size()));
  if (decodedLen > 0) {
    buffer.resize(decodedLen);
    outputBytes.swap(buffer);
  } else {
    outputBytes.clear(); // decoding failed
  }
 
  BIO_free_all(bmem);
}

Referenced by base64DecodeHex().

Here is the caller graph for this function:

bytesToHex()

void bytesToHex	(	const std::vector< uint8_t > &	bytes,
		std::string &	hexOutput
	)

Definition at line 145 of file XrdHttpUtils.cc.

                                                                      {
  static const char* lut = "0123456789abcdef";
  output.clear();
  output.reserve(bytes.size() * 2);
  for (uint8_t b : bytes) {
    output.push_back(lut[b >> 4]);
    output.push_back(lut[b & 0x0F]);
  }
}

Referenced by base64DecodeHex().

Here is the caller graph for this function:

calcHashes()

void calcHashes	(	char *	hash,
		const char *	fn,
		kXR_int16	req,
		XrdSecEntity *	secent,
		time_t	tim,
		const char *	key
	)

Definition at line 231 of file XrdHttpUtils.cc.

                         {
 
 
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
  EVP_MAC *mac;
  EVP_MAC_CTX *ctx;
  size_t len;
#else
  HMAC_CTX *ctx;
  unsigned int len;
#endif
  unsigned char mdbuf[EVP_MAX_MD_SIZE];
  char buf[64];
  struct tm tms;
 
 
  if (!hash) {
    return;
  }
  hash[0] = '\0';
  
  if (!key) {
    return;
  }
 
  if (!fn || !secent) {
    return;
  }
 
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
 
  mac = EVP_MAC_fetch(0, "sha256", 0);
  ctx = EVP_MAC_CTX_new(mac);
 
  if (!ctx) {
     return;
  }
 
 
  EVP_MAC_init(ctx, (const unsigned char *) key, strlen(key), 0);
 
 
  if (fn)
    EVP_MAC_update(ctx, (const unsigned char *) fn,
          strlen(fn) + 1);
 
  EVP_MAC_update(ctx, (const unsigned char *) &request,
          sizeof (request));
 
  if (secent->name)
    EVP_MAC_update(ctx, (const unsigned char *) secent->name,
          strlen(secent->name) + 1);
 
  if (secent->vorg)
    EVP_MAC_update(ctx, (const unsigned char *) secent->vorg,
          strlen(secent->vorg) + 1);
 
  if (secent->host)
    EVP_MAC_update(ctx, (const unsigned char *) secent->host,
          strlen(secent->host) + 1);
 
  if (secent->moninfo)
    EVP_MAC_update(ctx, (const unsigned char *) secent->moninfo,
          strlen(secent->moninfo) + 1);
 
  localtime_r(&tim, &tms);
  strftime(buf, sizeof (buf), "%s", &tms);
  EVP_MAC_update(ctx, (const unsigned char *) buf,
          strlen(buf) + 1);
 
  EVP_MAC_final(ctx, mdbuf, &len, EVP_MAX_MD_SIZE);
 
  EVP_MAC_CTX_free(ctx);
  EVP_MAC_free(mac);
 
#else
 
  ctx = HMAC_CTX_new();
 
  if (!ctx) {
    return;
  }
 
 
 
  HMAC_Init_ex(ctx, (const void *) key, strlen(key), EVP_sha256(), 0);
 
 
  if (fn)
    HMAC_Update(ctx, (const unsigned char *) fn,
          strlen(fn) + 1);
 
  HMAC_Update(ctx, (const unsigned char *) &request,
          sizeof (request));
 
  if (secent->name)
    HMAC_Update(ctx, (const unsigned char *) secent->name,
          strlen(secent->name) + 1);
 
  if (secent->vorg)
    HMAC_Update(ctx, (const unsigned char *) secent->vorg,
          strlen(secent->vorg) + 1);
 
  if (secent->host)
    HMAC_Update(ctx, (const unsigned char *) secent->host,
          strlen(secent->host) + 1);
 
  if (secent->moninfo)
    HMAC_Update(ctx, (const unsigned char *) secent->moninfo,
          strlen(secent->moninfo) + 1);
 
  localtime_r(&tim, &tms);
  strftime(buf, sizeof (buf), "%s", &tms);
  HMAC_Update(ctx, (const unsigned char *) buf,
          strlen(buf) + 1);
 
  HMAC_Final(ctx, mdbuf, &len);
 
  HMAC_CTX_free(ctx);
 
#endif
 
  Tobase64(mdbuf, len / 2, hash);
}

References XrdSecEntity::host, XrdSecEntity::moninfo, XrdSecEntity::name, Tobase64(), and XrdSecEntity::vorg.

Referenced by XrdHttpProtocol::Process(), and XrdHttpReq::Redir().

Here is the call graph for this function:

Here is the caller graph for this function:

compareHash()

int compareHash	(	const char *	h1,
		const char *	h2
	)

Definition at line 367 of file XrdHttpUtils.cc.

                        {
 
  if (h1 == h2) return 0;
 
  if (!h1 || !h2)
    return 1;
 
  return strcmp(h1, h2);
 
}

Referenced by XrdHttpProtocol::Process().

Here is the caller graph for this function:

decode_raw()

char* decode_raw ( const std::string &  str )

inline

Creates a non-const copy of the string passed in parameter and calls unquote() on it before returning the pointer to the unquoted string

Parameters

str	the string to unquote

Returns

the malloc'd and unquoted string !!! IT MUST BE FREED AFTER USAGE USING free(...) !!!

Definition at line 175 of file XrdHttpUtils.hh.

                                                {
  size_t strLength = str.length();
  // uniquely own the temporary copy
  std::unique_ptr<char[]> buf(new char[strLength + 1]);
  std::memcpy(buf.get(), str.c_str(), strLength + 1);
  // unquote returns a fresh malloc()'d pointer
  return unquote(buf.get());
}

References unquote().

Referenced by decode_str().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_str()

std::string decode_str ( const std::string &  str )

inline

Decodes the string passed in parameter (converts all XX codes to their 8bit versions) Calls unquote() Returns the std::string containing the decoded string.

Definition at line 213 of file XrdHttpUtils.hh.

                                                   {
  char * decodedRaw = decode_raw(str);
  std::string decoded { decodedRaw };
  free(decodedRaw);
  return decoded;
}

References decode_raw().

Referenced by XrdHttpProtocol::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_opaque()

std::string encode_opaque ( const std::string &  opaque )

inline

Encodes opaque query string parameters example: authz=Bearer token --> authz=Bearer%20token

Parameters

opaque

the opaque query string to encode

Returns

the opaque query string with encoded values

Definition at line 226 of file XrdHttpUtils.hh.

                                                         {
  std::ostringstream output;
  std::vector<std::string> allKeyValues;
  XrdOucTUtils::splitString(allKeyValues,opaque,"&");
  bool first = true;
  for(auto & kv: allKeyValues) {
    size_t equal = kv.find('=');
    if(equal != std::string::npos) {
      std::string key = kv.substr(0, equal);
      std::string value = kv.substr(equal + 1);
      if(!first) {
        output << "&";
      }
      output << encode_str(key) << "=" << encode_str(value);
      first = false;
    }
  }
  return output.str();
}

References encode_str(), and XrdOucTUtils::splitString().

Referenced by XrdHttpReq::appendOpaque(), XrdHttpReq::ProcessHTTPReq(), and XrdHttpReq::Redir().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_raw()

char* encode_raw ( const std::string &  str )

inline

Calls quote() on the string passed in parameter

Parameters

str	the string to quote

Returns

the pointer to the quoted string !!! IT MUST BE FREED AFTER USAGE USING free(...) !!!

Definition at line 190 of file XrdHttpUtils.hh.

                                                {
  return quote(str.c_str());
}

References quote().

Referenced by encode_str().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_str()

std::string encode_str ( const std::string &  str )

inline

Encodes the URL passed in parameter (converts all letters consider illegal in URLs to their XX versions). Calls quote() Returns a std::string containing the encoded string

Definition at line 200 of file XrdHttpUtils.hh.

                                                   {
  char * encodedRaw = encode_raw(str);
  std::string encoded { encodedRaw };
  free(encodedRaw);
  return encoded;
}

References encode_raw().

Referenced by XrdHttpReq::appendOpaque(), encode_opaque(), and XrdHttpReq::Redir().

Here is the call graph for this function:

Here is the caller graph for this function:

escapeXML()

char* escapeXML

(

const char *

str

)

Definition at line 473 of file XrdHttpUtils.cc.

                                 {
  int l = strlen(str);
  char *r = (char *) malloc(l*6 + 1);
  r[0] = '\0';
  int i, j = 0;
  
  for (i = 0; i < l; i++) {
    char c = str[i];
    
    switch (c) {
      case '"':
        strcpy(r + j, "&quot;");
        j += 6;
        break;
      case '&':
        strcpy(r + j, "&amp;");
        j += 5;
        break;
      case '<':
        strcpy(r + j, "&lt;");
        j += 4;
        break;
      case '>':
        strcpy(r + j, "&gt;");
        j += 4;
        break;
      case '\'':
        strcpy(r + j, "&apos;");
        j += 6;
        break;
      
      default:
        r[j++] = c;
    }
  }
  
  r[j] = '\0';
  
  return r;
}

Referenced by XrdHttpReq::Error().

Here is the caller graph for this function:

Fromhexdigest()

bool Fromhexdigest	(	const std::string &	hex,
		std::vector< uint8_t > &	outputBytes
	)

Definition at line 177 of file XrdHttpUtils.cc.

                                                                            {
  if(hex.size() % 2 != 0) {
    return false;
  }
 
  outputBytes.reserve(hex.size() / 2);
 
  for(size_t i = 0; i < hex.size(); i += 2) {
    int upper = char_to_int(hex[i]);
    int lower = char_to_int(hex[i + 1]);
    if (upper < 0 || lower < 0) return false;
    outputBytes.push_back(static_cast<uint8_t>((upper << 4) + lower));
  }
  return true;
}

References char_to_int(), and Xrd::hex.

Here is the call graph for this function:

httpStatusToString()

std::string httpStatusToString

(

int

status

)

Definition at line 594 of file XrdHttpUtils.cc.

                                         {
  switch (status) {
    // 1xx Informational
    case 100: return "Continue";
    case 101: return "Switching Protocols";
    case 102: return "Processing";
    case 103: return "Early Hints";
 
    // 2xx Success
    case 200: return "OK";
    case 201: return "Created";
    case 202: return "Accepted";
    case 203: return "Non-Authoritative Information";
    case 204: return "No Content";
    case 205: return "Reset Content";
    case 206: return "Partial Content";
    case 207: return "Multi-Status";
    case 208: return "Already Reported";
    case 226: return "IM Used";
 
    // 3xx Redirection
    case 300: return "Multiple Choices";
    case 301: return "Moved Permanently";
    case 302: return "Found";
    case 303: return "See Other";
    case 304: return "Not Modified";
    case 305: return "Use Proxy";
    case 307: return "Temporary Redirect";
    case 308: return "Permanent Redirect";
 
    // 4xx Client Errors
    case 400: return "Bad Request";
    case 401: return "Unauthorized";
    case 402: return "Payment Required";
    case 403: return "Forbidden";
    case 404: return "Not Found";
    case 405: return "Method Not Allowed";
    case 406: return "Not Acceptable";
    case 407: return "Proxy Authentication Required";
    case 408: return "Request Timeout";
    case 409: return "Conflict";
    case 410: return "Gone";
    case 411: return "Length Required";
    case 412: return "Precondition Failed";
    case 413: return "Payload Too Large";
    case 414: return "URI Too Long";
    case 415: return "Unsupported Media Type";
    case 416: return "Range Not Satisfiable";
    case 417: return "Expectation Failed";
    case 418: return "I'm a teapot";
    case 421: return "Misdirected Request";
    case 422: return "Unprocessable Entity";
    case 423: return "Locked";
    case 424: return "Failed Dependency";
    case 425: return "Too Early";
    case 426: return "Upgrade Required";
    case 428: return "Precondition Required";
    case 429: return "Too Many Requests";
    case 431: return "Request Header Fields Too Large";
    case 451: return "Unavailable For Legal Reasons";
 
    // 5xx Server Errors
    case 500: return "Internal Server Error";
    case 501: return "Not Implemented";
    case 502: return "Bad Gateway";
    case 503: return "Service Unavailable";
    case 504: return "Gateway Timeout";
    case 505: return "HTTP Version Not Supported";
    case 506: return "Variant Also Negotiates";
    case 507: return "Insufficient Storage";
    case 508: return "Loop Detected";
    case 510: return "Not Extended";
    case 511: return "Network Authentication Required";
 
    default:
      switch (status) {
        case 100 ... 199: return "Informational";
        case 200 ... 299: return "Success";
        case 300 ... 399: return "Redirection";
        case 400 ... 499: return "Client Error";
        case 500 ... 599: return "Server Error";
        default: return "Unknown";
      }
  }
}

itos()

std::string itos

(

long

i

)

Definition at line 195 of file XrdHttpUtils.cc.

                       {
  char buf[128];
  sprintf(buf, "%ld", i);
 
  return buf;
}

mapErrNoToHttp()

int mapErrNoToHttp

(

int

err

)

Definition at line 521 of file XrdHttpUtils.cc.

                              {
 
  switch (errNo) {
 
    case EACCES:
    case EROFS:
    case EPERM:
      return HTTP_FORBIDDEN;
 
    case EAUTH:
      return HTTP_UNAUTHORIZED;
 
    case ENOENT:
      return HTTP_NOT_FOUND;
 
    case EEXIST:
    case EISDIR:
    case ENOTDIR:
    case ENOTEMPTY:
      return HTTP_CONFLICT;
 
    case EXDEV:
      return HTTP_UNPROCESSABLE_ENTITY;
 
    case ENAMETOOLONG:
      return HTTP_URI_TOO_LONG;
 
    case ELOOP:
      return HTTP_LOOP_DETECTED;
 
    case ENOSPC:
    case EDQUOT:
      return HTTP_INSUFFICIENT_STORAGE;
 
    case EFBIG:
      return HTTP_PAYLOAD_TOO_LARGE;
 
    case EINVAL:
    case EBADF:
    case EFAULT:
    case ENXIO:
    case ESPIPE:
    case EOVERFLOW:
      return HTTP_BAD_REQUEST;
 
    case ENOTSUP: // EOPNOTSUPP
      return HTTP_NOT_IMPLEMENTED;
 
    case EBUSY:
    case EAGAIN:
    case EINTR:
    case ENOMEM:
    case EMFILE:
    case ENFILE:
    case ETXTBSY:
      return HTTP_SERVICE_UNAVAILABLE;
 
    case ETIMEDOUT:
      return HTTP_GATEWAY_TIMEOUT;
 
    case ECONNREFUSED:
    case ECONNRESET:
    case ENETDOWN:
    case ENETUNREACH:
    case EHOSTUNREACH:
    case EPIPE:
      return HTTP_BAD_GATEWAY;
 
    default:
      return HTTP_INTERNAL_SERVER_ERROR;
  }
}

References EAUTH, HTTP_BAD_GATEWAY, HTTP_BAD_REQUEST, HTTP_CONFLICT, HTTP_FORBIDDEN, HTTP_GATEWAY_TIMEOUT, HTTP_INSUFFICIENT_STORAGE, HTTP_INTERNAL_SERVER_ERROR, HTTP_LOOP_DETECTED, HTTP_NOT_FOUND, HTTP_NOT_IMPLEMENTED, HTTP_PAYLOAD_TOO_LARGE, HTTP_SERVICE_UNAVAILABLE, HTTP_UNAUTHORIZED, HTTP_UNPROCESSABLE_ENTITY, and HTTP_URI_TOO_LONG.

Referenced by mapXrdErrToHttp().

Here is the caller graph for this function:

mapXrdErrToHttp()

int mapXrdErrToHttp

(

XErrorCode

xrdError

)

Definition at line 514 of file XrdHttpUtils.cc.

                                         {
 
  int errNo = XProtocol::toErrno(xrdError);
  return mapErrNoToHttp(errNo);
 
}

References mapErrNoToHttp(), and XProtocol::toErrno().

Here is the call graph for this function:

mystrchrnul()

char* mystrchrnul	(	const char *	s,
		int	c
	)

Definition at line 205 of file XrdHttpUtils.cc.

                                        {
  char *ptr = strchr((char *)s, c);
 
  if (!ptr)
    return strchr((char *)s, '\0');
 
  return ptr;
}

quote()

char* quote

(

const char *

str

)

Definition at line 414 of file XrdHttpUtils.cc.

                             {
  int l = strlen(str);
  char *r = (char *) malloc(l*3 + 1);
  r[0] = '\0';
  int i, j = 0;
 
  for (i = 0; i < l; i++) {
    char c = str[i];
 
    switch (c) {
      case ' ':
        strcpy(r + j, "%20");
        j += 3;
        break;
      case '[':
        strcpy(r + j, "%5B");
        j += 3;
        break;
      case ']':
        strcpy(r + j, "%5D");
        j += 3;
        break;
      case ':':
        strcpy(r + j, "%3A");
        j += 3;
        break;
      // case '/':
      //   strcpy(r + j, "%2F");
      //   j += 3;
      //   break;
      case '#':
         strcpy(r + j, "%23");
         j += 3;
         break;
      case '\n':
        strcpy(r + j, "%0A");
        j += 3;
        break;
      case '\r':
        strcpy(r + j, "%0D");
        j += 3;
        break;
      case '=':
        strcpy(r + j, "%3D");
        j += 3;
        break;
      default:
        r[j++] = c;
    }
  }
 
  r[j] = '\0';
 
  return r;
}

Referenced by encode_raw().

Here is the caller graph for this function:

Tobase64() [1/2]

void Tobase64	(	const std::vector< uint8_t > &	input,
		std::string &	base64Output
	)

Definition at line 90 of file XrdHttpUtils.cc.

                                                                          {
  BIO *bmem, *b64;
  BUF_MEM *bptr;
 
  base64Output.clear();
 
  if(input.empty()) {
    return;
  }
 
  b64 = BIO_new(BIO_f_base64());
  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
  bmem = BIO_new(BIO_s_mem());
  BIO_push(b64, bmem);
  BIO_write(b64, input.data(), input.size());
 
  if (BIO_flush(b64) <= 0) {
    BIO_free_all(b64);
    return;
  }
 
  BIO_get_mem_ptr(b64, &bptr);
 
  base64Output.assign(bptr->data,bptr->length);
 
  BIO_free_all(b64);
}

Tobase64() [2/2]

void Tobase64	(	const unsigned char *	input,
		int	length,
		char *	out
	)

Definition at line 60 of file XrdHttpUtils.cc.

                                                                 {
  BIO *bmem, *b64;
  BUF_MEM *bptr;
 
  if (!out) return;
 
  out[0] = '\0';
 
  b64 = BIO_new(BIO_f_base64());
  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
  bmem = BIO_new(BIO_s_mem());
  BIO_push(b64, bmem);
  BIO_write(b64, input, length);
 
  if (BIO_flush(b64) <= 0) {
    BIO_free_all(b64);
    return;
  }
 
  BIO_get_mem_ptr(b64, &bptr);
 
 
  memcpy(out, bptr->data, bptr->length);
  out[bptr->length] = '\0';
 
  BIO_free_all(b64);
 
  return;
}

Referenced by calcHashes().

Here is the caller graph for this function:

unquote()

char* unquote

(

char *

str

)

Definition at line 382 of file XrdHttpUtils.cc.

                         {
  int l = strlen(str);
  char *r = (char *) malloc(l + 1);
  r[0] = '\0';
  int i, j = 0;
 
  for (i = 0; i < l; i++) {
    if (str[i] == '%') {
      if (i + 3 > l) {
        r[j] = '\0';
        return r;
      }
      char savec = str[i + 3];
      str[i + 3] = '\0';
 
      r[j] = strtol(str + i + 1, 0, 16);
      str[i + 3] = savec;
 
      i += 2;
    } else r[j] = str[i];
 
    j++;
  }
 
  r[j] = '\0';
 
  return r;
 
}

Referenced by decode_raw().

Here is the caller graph for this function: