XrdHttpReq Class Reference

#include <XrdHttpReq.hh>

Inheritance diagram for XrdHttpReq:

Collaboration diagram for XrdHttpReq:

Public Types
enum	ReqType : int {   rtUnset = -1 ,   rtUnknown = 0 ,   rtMalformed ,   rtGET ,   rtHEAD ,   rtPUT ,   rtOPTIONS ,   rtPATCH ,   rtDELETE ,   rtPROPFIND ,   rtMKCOL ,   rtMOVE ,   rtPOST ,   rtCOPY ,   rtCount }
	These are the HTTP/DAV requests that we support. More...

Public Member Functions
	XrdHttpReq (XrdHttpProtocol *protinstance, const XrdHttpReadRangeHandler::Configuration &rcfg)
virtual	~XrdHttpReq ()
void	addCgi (const std::string &key, const std::string &value)
void	appendOpaque (XrdOucString &s, XrdSecEntity *secent, char *hash, time_t tnow)
std::string	buildPartialHdr (long long bytestart, long long byteend, long long filesize, char *token)
	Build a partial header for a multipart response.
std::string	buildPartialHdrEnd (char *token)
	Build the closing part for a multipart response.
virtual bool	Data (XrdXrootd::Bridge::Context &info, const struct iovec *iovP, int iovN, int iovL, bool final)
virtual bool	Done (XrdXrootd::Bridge::Context &info)
	the result context
virtual bool	Error (XrdXrootd::Bridge::Context &info, int ecode, const char *etext)
virtual int	File (XrdXrootd::Bridge::Context &info, int dlen)
int	getHttpStatusCode ()
int	getInitialStatusCode ()
int	parseBody (char *body, long long len)
	Parse the body of a request, assuming that it's XML and that it's entirely in memory.
int	parseFirstLine (char *line, int len)
	Parse the first line of the header.
int	parseLine (char *line, int len)
	Parse the header.
int	ProcessHTTPReq ()
virtual bool	Redir (XrdXrootd::Bridge::Context &info, int port, const char *hname)
int	ReqReadV (const XrdHttpIOList &cl)
	Prepare the buffers for sending a readv request.
virtual void	reset ()
void	setHttpStatusCode (int code)
void	setTransferStatusHeader (std::string &header)
const std::string &	userAgent () const
Public Member Functions inherited from XrdXrootd::Bridge::Result
	Result ()
	Constructor & Destructor.
virtual	~Result ()
virtual void	Free (Bridge::Context &info, char *buffP, int buffL)
virtual bool	Wait (Bridge::Context &info, int wtime, const char *wtext)
virtual Bridge::Result *	WaitResp (Bridge::Context &info, int wtime, const char *wtext)

Public Attributes
std::map< std::string, std::string >	allheaders
bool	closeAfterError
int	depth
std::string	destination
	The destination field specified in the req.
long long	etagval
std::string	etext
char	fhandle [4]
long	filectime
long	fileflags
long	filemodtime
long long	filesize
bool	final
	true -> final result
bool	fopened
std::string	hdr2cgistr
	Additional opaque info that may come from the hdr2cgi directive.
bool	headerok
	Tells if we have finished reading the header.
std::string	host
	The host field specified in the req.
int	iovL
	byte count
int	iovN
	array count
const struct iovec *	iovP
	The latest data chunks got from the xrd layer. These are valid only inside the callbacks!
bool	keepalive
ssize_t	length
bool	length_seen {false}
bool	m_appended_asize {false}
	Track whether we already appended the oss.asize argument for PUTs.
bool	m_appended_hdr2cgistr
std::string	m_digest_header
	The computed digest for the HTTP response header.
std::string	m_origin
std::map< std::string, std::string >	m_repr_digest
	Repr-Digest map where the key is the digest name and the value is the base64 encoded digest value.
XrdHttpChecksumHandler::XrdHttpChecksumRawPtr	m_req_cksum = nullptr
	The checksum that was ran for this request.
XrdOucString	m_resource_with_digest
std::string	m_want_digest
	The requested digest type.
std::map< std::string, uint8_t >	m_want_repr_digest
XrdHttpMonState	monState
int	mScitag
XrdOucEnv *	opaque
	The opaque data, after parsing.
std::vector< readahead_list >	ralist
bool	readClosing
XrdHttpReadRangeHandler	readRangeHandler
	Tracking the next ranges of data to read during GET.
XrdOucString	redirdest
int	reqstate
	State machine to talk to the bridge.
ReqType	request
	The request we got.
std::string	requestverb
XrdOucString	resource
	The resource specified by the request, stripped of opaque data.
XrdOucString	resourceplusopaque
	The resource specified by the request, including all the opaque data.
unsigned int	rwOpDone
	To coordinate multipart responses across multiple calls.
unsigned int	rwOpPartialDone
bool	sendcontinue
std::chrono::steady_clock::time_point	startTime = std::chrono::steady_clock::time_point::min()
std::string	stringresp
	If we want to give a string as a response, we compose it here.
long long	writtenbytes
	In a long write, we track where we have arrived.
XErrorCode	xrderrcode
ClientRequest	xrdreq
	The last issued xrd request, often pending.
XResponseType	xrdresp
	The last response data we got.

Detailed Description

Definition at line 66 of file XrdHttpReq.hh.

Member Enumeration Documentation

ReqType

enum XrdHttpReq::ReqType : int

These are the HTTP/DAV requests that we support.

Enumerator
rtUnset
rtUnknown
rtMalformed
rtGET
rtHEAD
rtPUT
rtOPTIONS
rtPATCH
rtDELETE
rtPROPFIND
rtMKCOL
rtMOVE
rtPOST
rtCOPY
rtCount

Definition at line 77 of file XrdHttpReq.hh.

               : int {
    rtUnset = -1,
    rtUnknown = 0,
    rtMalformed,
    rtGET,
    rtHEAD,
    rtPUT,
    rtOPTIONS,
    rtPATCH,
    rtDELETE,
    rtPROPFIND,
    rtMKCOL,
    rtMOVE,
    rtPOST,
    rtCOPY,
    rtCount
  };

Constructor & Destructor Documentation

XrdHttpReq()

XrdHttpReq::XrdHttpReq ( XrdHttpProtocol * protinstance, const XrdHttpReadRangeHandler::Configuration & rcfg )

inline

Definition at line 208 of file XrdHttpReq.hh.

                                                                                              :
      readRangeHandler(rcfg), closeAfterError(false), keepalive(true) {
 
    prot = protinstance;
    length = 0;
    //xmlbody = 0;
    depth = 0;
    opaque = 0;
    writtenbytes = 0;
    fopened = false;
    headerok = false;
    mScitag = -1;
  };

References closeAfterError, depth, fopened, headerok, keepalive, length, mScitag, opaque, readRangeHandler, and writtenbytes.

~XrdHttpReq()

XrdHttpReq::~XrdHttpReq ( )

virtual

Definition at line 112 of file XrdHttpReq.cc.

                        {
  //if (xmlbody) xmlFreeDoc(xmlbody);
 
  reset();
}

References reset().

Here is the call graph for this function:

Member Function Documentation

addCgi()

void XrdHttpReq::addCgi	(	const std::string &	key,
		const std::string &	value )

Definition at line 823 of file XrdHttpReq.cc.

                                                                    {
  if (hdr2cgistr.length() > 0) {
    hdr2cgistr.append("&");
  }
  hdr2cgistr.append(key);
  hdr2cgistr.append("=");
  hdr2cgistr.append(value);
}

References hdr2cgistr.

Referenced by parseLine().

Here is the caller graph for this function:

appendOpaque()

void XrdHttpReq::appendOpaque	(	XrdOucString &	s,
		XrdSecEntity *	secent,
		char *	hash,
		time_t	tnow )

Definition at line 715 of file XrdHttpReq.cc.

                                                                                            {
 
  int l = 0;
  char * p = 0;
  if (opaque)
    p = opaque->Env(l);
 
  if (hdr2cgistr.empty() && (l < 2) && !hash) return;
 
  // this works in most cases, except if the url already contains the xrdhttp tokens
  s = s + "?";
  if (!hdr2cgistr.empty()) {
    s += encode_opaque(hdr2cgistr).c_str();
  }
  if (p && (l > 1)) {
    if (!hdr2cgistr.empty()) {
      s = s + "&";
    }
    s = s + encode_opaque(p + 1).c_str();
  }
 
  if (hash) {
    if (l > 1) s += "&";
    s += "xrdhttptk=";
    s += hash;
 
    s += "&xrdhttptime=";
    char buf[256];
    sprintf(buf, "%lld", (long long) tnow);
    s += buf;
 
    if (secent) {
      if (secent->name) {
        s += "&xrdhttpname=";
        s += encode_str(secent->name).c_str();
        }
      }
 
      if (secent->vorg) {
        s += "&xrdhttpvorg=";
        s += encode_str(secent->vorg).c_str();
      }
 
      if (secent->host) {
        s += "&xrdhttphost=";
        s += encode_str(secent->host).c_str();
      }
 
      if (secent->moninfo) {
        s += "&xrdhttpdn=";
        s += encode_str(secent->moninfo).c_str();
      }
 
      if (secent->role) {
        s += "&xrdhttprole=";
        s += encode_str(secent->role).c_str();
      }
 
      if (secent->grps) {
        s += "&xrdhttpgrps=";
        s += encode_str(secent->grps).c_str();
      }
 
      if (secent->endorsements) {
        s += "&xrdhttpendorsements=";
        s += encode_str(secent->endorsements).c_str();
      }
 
      if (secent->credslen) {
        s += "&xrdhttpcredslen=";
        char buf[16];
        sprintf(buf, "%d", secent->credslen);
        s += encode_str(buf).c_str();
      }
 
      if (secent->credslen) {
        if (secent->creds) {
          s += "&xrdhttpcreds=";
          // Apparently this string might be not 0-terminated (!)
          char *zerocreds = strndup(secent->creds, secent->credslen);
          if (zerocreds) {
            s += encode_str(zerocreds).c_str();
            free(zerocreds);
          }
        }
      }
    }
  }

References XrdSecEntity::creds, XrdSecEntity::credslen, encode_opaque(), encode_str(), XrdSecEntity::endorsements, XrdOucEnv::Env(), XrdSecEntity::grps, hdr2cgistr, XrdSecEntity::host, XrdSecEntity::moninfo, XrdSecEntity::name, opaque, XrdSecEntity::role, and XrdSecEntity::vorg.

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

Here is the call graph for this function:

Here is the caller graph for this function:

buildPartialHdr()

std::string XrdHttpReq::buildPartialHdr	(	long long	bytestart,
		long long	byteend,
		long long	filesize,
		char *	token )

Build a partial header for a multipart response.

Definition at line 488 of file XrdHttpReq.cc.

                                                                                                        {
  std::ostringstream s;
 
  s << "\r\n--" << token << "\r\n";
  s << "Content-type: text/plain; charset=UTF-8\r\n";
  s << "Content-range: bytes " << bytestart << "-" << byteend << "/" << fsz << "\r\n\r\n";
 
  return s.str();
}

buildPartialHdrEnd()

std::string XrdHttpReq::buildPartialHdrEnd

(

char *

token

)

Build the closing part for a multipart response.

Definition at line 498 of file XrdHttpReq.cc.

                                                    {
  std::ostringstream s;
 
  s << "\r\n--" << token << "--\r\n";
 
  return s.str();
}

Data()

bool XrdHttpReq::Data ( XrdXrootd::Bridge::Context & info, const struct iovec * iovP, int iovN, int iovL, bool final )

virtual

Effect a client data response.

The Data() method is called when Run() resulted in a successful data response. The method should rewrite the data and send it to the client using the associated XrdLink object. As an example, 1) Result::Data(info, iovP, iovN, iovL) is called. 2) Inspect iovP, rewrite the data. 3) Send the response: info->linkP->Send(new_iovP, new_iovN, new_iovL); 4) Handle send errors and cleanup(e.g. deallocate storage). 5) Return, the exchange is now complete.

Parameters

info	the context associated with the result.
iovP	a pointer to the iovec structure containing the xrootd data response about to be sent to the client. The request header is not included in the iovec structure. The elements of this structure must not be modified by the method.
iovN	the number of elements in the iovec structure array.
iovL	total number of data bytes that would be sent to the client. This is simply the sum of all the lengths in the iovec.
final	True is this is the final result. Otherwise, this is a partial result (i.e. kXR_oksofar) and more data will result causing additional callbacks.

Returns

true continue normal processing. false terminate the bridge and close the link.

Parameters

info	the result context
iovP	pointer to data array
iovN	array count
iovL	byte count
final	true -> final result

Implements XrdXrootd::Bridge::Result.

Definition at line 506 of file XrdHttpReq.cc.

          {
 
  TRACE(REQ, " XrdHttpReq::Data! final=" << final);
 
  this->xrdresp = kXR_ok;
  this->iovP = iovP_;
  this->iovN = iovN_;
  this->iovL = iovL_;
  this->final = final_;
 
  if (PostProcessHTTPReq(final_)) reset();
 
  return true;
 
};

References iovL, iovN, iovP, kXR_ok, reset(), TRACE, and xrdresp.

Here is the call graph for this function:

Done()

bool XrdHttpReq::Done ( XrdXrootd::Bridge::Context & info )

virtual

the result context

Effect a client acknowledgement.

The Done() method is called when Run() resulted in success and there is no associated data for the client (equivalent to a simple kXR_ok response).

Parameters

info	the context associated with the result.

Returns

true continue normal processing. false terminate the bridge and close the link.

Implements XrdXrootd::Bridge::Result.

Definition at line 552 of file XrdHttpReq.cc.

                                                   {
 
  TRACE(REQ, " XrdHttpReq::Done");
 
  xrdresp = kXR_ok;
 
  this->iovN = 0;
 
  int r = PostProcessHTTPReq(true);
  // Beware, we don't have to reset() if the result is 0
  if (r) reset();
  if (r < 0) return false;
 
 
  return true;
};

References iovN, kXR_ok, reset(), TRACE, and xrdresp.

Here is the call graph for this function:

Error()

bool XrdHttpReq::Error ( XrdXrootd::Bridge::Context & info, int ecode, const char * etext )

virtual

Effect a client error response.

The Error() method is called when an error was encountered while processing the Run() request. The error should be reflected to the client.

Parameters

info	the context associated with the result.
ecode	the "kXR" error code describing the nature of the error. The code is in host byte format.
etext	a null terminated string describing the error in human terms

Returns

true continue normal processing. false terminate the bridge and close the link.

Parameters

info	the result context
ecode	the "kXR" error code
etext	associated error message

Implements XrdXrootd::Bridge::Result.

Definition at line 569 of file XrdHttpReq.cc.

          {
 
  TRACE(REQ, " XrdHttpReq::Error");
 
  xrdresp = kXR_error;
  xrderrcode = (XErrorCode) ecode;
 
  if (etext_) {
    char *s = escapeXML(etext_);
    this->etext = s;
    free(s);
  }
 
  auto rc = PostProcessHTTPReq();
  if (rc) {
    reset();
  }
 
  // If we are servicing a GET on a directory, it'll generate an error for the default
  // OSS (we don't assume this is always true).  Catch and suppress the error so we can instead
  // generate a directory listing (if configured).
  if ((request == rtGET) && (xrdreq.header.requestid == ntohs(kXR_open)) && (xrderrcode == kXR_isDirectory))
    return true;
 
  return rc == 0;
};

References escapeXML(), etext, ClientRequest::header, kXR_error, kXR_isDirectory, kXR_open, request, ClientRequestHdr::requestid, reset(), rtGET, TRACE, xrderrcode, xrdreq, and xrdresp.

Here is the call graph for this function:

File()

int XrdHttpReq::File ( XrdXrootd::Bridge::Context & info, int dlen )

virtual

Notify callback that a sendfile() request is pending.

The File() method is called when Run() resulted in a sendfile response (i.e. sendfile() would have been used to send data to the client). This allows the callback to reframe the sendfile() data using the Send() method in the passed context object (see class Context above).

Parameters

info	the context associated with the result.
dlen	total number of data bytes that would be sent to the client.

Returns

true continue normal processing. false terminate the bridge and close the link.

Parameters

info	the result context
dlen	byte count

Implements XrdXrootd::Bridge::Result.

Definition at line 528 of file XrdHttpReq.cc.

          {
 
  // sendfile about to be sent by bridge for fetching data for GET:
  // no https, no chunked+trailer, no multirange
 
  //prot->SendSimpleResp(200, NULL, NULL, NULL, dlen);
  int rc = info.Send(0, 0, 0, 0);
  TRACE(REQ, " XrdHttpReq::File dlen:" << dlen << " send rc:" << rc);
  bool start, finish;
  // short read will be classed as error
  if (rc) {
    readRangeHandler.NotifyError();
    return false;
  }
 
  if (readRangeHandler.NotifyReadResult(dlen, nullptr, start, finish) < 0)
    return false;
 
 
  return true;
};

References XrdHttpReadRangeHandler::NotifyError(), XrdHttpReadRangeHandler::NotifyReadResult(), readRangeHandler, XrdXrootd::Bridge::Context::Send(), and TRACE.

Here is the call graph for this function:

getHttpStatusCode()

int XrdHttpReq::getHttpStatusCode ( )

inline

Definition at line 227 of file XrdHttpReq.hh.

{ return httpStatusCode;}

getInitialStatusCode()

int XrdHttpReq::getInitialStatusCode ( )

inline

Definition at line 226 of file XrdHttpReq.hh.

{ return initialStatusCode;}

parseBody()

int XrdHttpReq::parseBody	(	char *	body,
		long long	len )

Parse the body of a request, assuming that it's XML and that it's entirely in memory.

Definition at line 96 of file XrdHttpReq.cc.

                                                   {
  /*
   * The document being in memory, it has no base per RFC 2396,
   * and the "noname.xml" argument will serve as its base.
   */
  //xmlbody = xmlReadMemory(body, len, "noname.xml", NULL, 0);
  //if (xmlbody == NULL) {
  //  fprintf(stderr, "Failed to parse document\n");
  //  return 1;
  //}
 
 
 
  return 1;
}

Referenced by ProcessHTTPReq().

Here is the caller graph for this function:

parseFirstLine()

int XrdHttpReq::parseFirstLine	(	char *	line,
		int	len )

Parse the first line of the header.

Definition at line 319 of file XrdHttpReq.cc.

                                                  {
 
  char *key = line;
 
  int pos;
 
  // Do the naive parsing
  if (!line) return -1;
 
  // Look for the first space-delimited token
  char *p = strchr((char *) line, (int) ' ');
  if (!p) {
    request = rtMalformed;
    return -1;
  }
 
 
  pos = p - line;
  // The first token cannot be too long
  if (pos > MAX_TK_LEN - 1) {
    request = rtMalformed;
    return -2;
  }
 
  // The first space-delimited char cannot be the first one
  // this allows to deal with the case when a client sends a first line that starts with a space " GET / HTTP/1.1"
  if(pos == 0) {
      request = rtMalformed;
      return -4;
  }
 
  // the first token must be non empty
  if (pos > 0) {
    line[pos] = 0;
    char *val = line + pos + 1;
 
    // Here we are supposed to initialize whatever flag or variable that is needed
    // by looking at the first token of the line
 
    // The token is key
    // The remainder is val, look for the resource
    p = strchr((char *) val, (int) ' ');
 
    if (!p) {
      request = rtMalformed;
      line[pos] = ' ';
      return -3;
    }
 
    *p = '\0';
    parseResource(val);
 
    *p = ' ';
 
    // Xlate the known header lines
    if (!strcmp(key, "GET")) {
      request = rtGET;
    } else if (!strcmp(key, "HEAD")) {
      request = rtHEAD;
    } else if (!strcmp(key, "PUT")) {
      request = rtPUT;
    } else if (!strcmp(key, "POST")) {
      request = rtPOST;
    } else if (!strcmp(key, "PATCH")) {
      request = rtPATCH;
    } else if (!strcmp(key, "OPTIONS")) {
      request = rtOPTIONS;
    } else if (!strcmp(key, "DELETE")) {
      request = rtDELETE;
    } else if (!strcmp(key, "PROPFIND")) {
      request = rtPROPFIND;
    } else if (!strcmp(key, "MKCOL")) {
      request = rtMKCOL;
    } else if (!strcmp(key, "MOVE")) {
      request = rtMOVE;
    } else if (!strcmp(key, "COPY")) {
      request = rtCOPY;
    } else {
      request = rtUnknown;
    }
 
    requestverb = key;
 
    // The last token should be the protocol.  If it is HTTP/1.0, then
    // keepalive is disabled by default.
    if (!strcmp(p+1, "HTTP/1.0\r\n")) {
      keepalive = false;
    }
    line[pos] = ' ';
  }
 
  return 0;
}

References keepalive, MAX_TK_LEN, request, requestverb, rtCOPY, rtDELETE, rtGET, rtHEAD, rtMalformed, rtMKCOL, rtMOVE, rtOPTIONS, rtPATCH, rtPOST, rtPROPFIND, rtPUT, and rtUnknown.

Referenced by XrdHttpProtocol::Process().

Here is the caller graph for this function:

parseLine()

int XrdHttpReq::parseLine	(	char *	line,
		int	len )

Parse the header.

Definition at line 118 of file XrdHttpReq.cc.

                                             {
 
  char *key = line;
  int pos;
 
  // Do the parsing
  if (!line) return -1;
 
 
  char *p = strchr((char *) line, (int) ':');
  if (!p) {
 
    request = rtMalformed;
    return -1;
  }
 
  pos = (p - line);
  if (pos > (MAX_TK_LEN - 1)) {
 
    request = rtMalformed;
    return -2;
  }
 
  if (pos > 0) {
    line[pos] = 0;
    char *val = line + pos + 1;
 
    // Trim left
    while ( (!isgraph(*val) || (!*val)) && (val < line+len)) val++;
 
    // We memorize the headers also as a string
    // because external plugins may need to process it differently
    std::string ss = val;
    if(ss.length() >= 2 && ss.substr(ss.length() - 2, 2) != "\r\n") {
      request = rtMalformed;
      return -3;
    }
    trim(ss);
    allheaders[key] = ss;
        
    // Here we are supposed to initialize whatever flag or variable that is needed
    // by looking at the first token of the line
    // The token is key
    // The value is val
 
    // Screen out the needed header lines
    if (!strcasecmp(key, "connection")) {
 
      if (!strcasecmp(val, "Keep-Alive\r\n")) {
        keepalive = true;
      } else if (!strcasecmp(val, "close\r\n")) {
        keepalive = false;
      }
 
    } else if (!strcasecmp(key, "host")) {
      parseHost(val);
    } else if (!strcasecmp(key, "range")) {
      // (rfc2616 14.35.1) says if Range header contains any range
      // which is syntactically invalid the Range header should be ignored.
      // Therefore no need for the range handler to report an error.
      readRangeHandler.ParseContentRange(val);
    } else if (!strcasecmp(key, "content-length")) {
      // Parse and validate the Content-Length value (one-or-more digits,
      // no sign, no embedded garbage, no overflow). Anything malformed
      // gives the server an ambiguous body length and is an HTTP request
      // smuggling primitive — reject with HTTP 400.
      // Reference: RFC 9112 §6.2, RFC 7230 §3.3.3 rule 4.
      ssize_t parsed = XrdHttpHeaderUtils::parseContentLength(val);
      if (parsed < 0) {
        request = rtMalformed;
        return -6;
      }
      if (m_transfer_encoding_chunked) {
        // A request that already declared Transfer-Encoding: chunked and
        // now also sends Content-Length is the classic smuggling vector
        // (the frontend and backend may disagree on which header wins).
        // Reference: RFC 9112 §6.1.
        request = rtMalformed;
        return -8;
      }
      if (length_seen && parsed != length) {
        // Two Content-Length headers with different values. The body
        // length is ambiguous; reject.
        // Reference: RFC 7230 §3.3.3 rule 4.
        request = rtMalformed;
        return -7;
      }
      length = parsed;
      length_seen = true;
 
    } else if (!strcasecmp(key, "destination")) {
      destination.assign(val, line+len-val);
      trim(destination);
    } else if (!strcasecmp(key, "want-digest")) {
      // Discard Want-Repr-Digest in favor of Want-Digest
      m_want_repr_digest.clear();
      m_want_digest.assign(val, line + len - val);
      trim(m_want_digest);
      //Transform the user requests' want-digest to lowercase
      std::transform(m_want_digest.begin(), m_want_digest.end(), m_want_digest.begin(), ::tolower);
    } else if (!strcasecmp(key, "depth")) {
      depth = -1;
      if (strcmp(val, "infinity"))
        depth = atoll(val);
 
    } else if (!strcasecmp(key, "expect") && strstr(val, "100-continue")) {
      sendcontinue = true;
    } else if (!strcasecmp(key, "te") && strstr(val, "trailers")) {
      m_trailer_headers = true;
    } else if (!strcasecmp(key, "transfer-encoding")) {
      // Tokenize the Transfer-Encoding list and verify that "chunked"
      // is present AND is the final encoding. Anything else (substring
      // matches like "chunkedX", a non-final "chunked", or only unknown
      // codings) is rejected so a frontend proxy cannot disagree with us
      // about how the body is framed.
      // Reference: RFC 9112 §6.1, RFC 7230 §3.3.1.
      if (XrdHttpHeaderUtils::parseTransferEncoding(val) != 0) {
        request = rtMalformed;
        return -4;
      }
      if (length_seen) {
        // Content-Length was already accepted and now Transfer-Encoding:
        // chunked arrives. Reject (see the matching check in the
        // Content-Length branch above).
        // Reference: RFC 9112 §6.1.
        request = rtMalformed;
        return -8;
      }
      m_transfer_encoding_chunked = true;
    } else if (!strcasecmp(key, "x-transfer-status") && strstr(val, "true")) {
      m_transfer_encoding_chunked = true;
      m_status_trailer = true;
    } else if (!strcasecmp(key, "scitag")) {
      if(prot->pmarkHandle != nullptr) {
        parseScitag(val);
      }
    } else if (!strcasecmp(key, "user-agent")) {
      m_user_agent = val;
      trim(m_user_agent);
    } else if (!strcasecmp(key,"origin")) {
      m_origin = val;
      trim(m_origin);
    } else if (!strcasecmp(key,"repr-digest")) {
      XrdHttpHeaderUtils::parseReprDigest(val, m_repr_digest);
    } else if (!strcasecmp(key,"want-repr-digest")) {
      if(m_want_digest.empty()) {
        // If Want-Digest was set, don't parse want-repr-digest
        XrdHttpHeaderUtils::parseWantReprDigest(val, m_want_repr_digest);
      }
    } else {
      // Some headers need to be translated into "local" cgi info.
      auto it = std::find_if(prot->hdr2cgimap.begin(), prot->hdr2cgimap.end(),[key](const auto & item) {
        return !strcasecmp(key,item.first.c_str());
      });
      if (it != prot->hdr2cgimap.end() && (opaque ? (0 == opaque->Get(it->second.c_str())) : true)) {
        std::string s;
        s.assign(val, line+len-val);
        trim(s);
        addCgi(it->second,s);
      }
    }
 
 
    line[pos] = ':';
  }
 
  return 0;
}

References addCgi(), allheaders, depth, destination, XrdOucEnv::Get(), keepalive, length, length_seen, m_origin, m_repr_digest, m_want_digest, m_want_repr_digest, MAX_TK_LEN, opaque, XrdHttpHeaderUtils::parseContentLength(), XrdHttpReadRangeHandler::ParseContentRange(), XrdHttpHeaderUtils::parseReprDigest(), XrdHttpHeaderUtils::parseTransferEncoding(), XrdHttpHeaderUtils::parseWantReprDigest(), readRangeHandler, request, rtMalformed, sendcontinue, and trim().

Referenced by XrdHttpProtocol::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessHTTPReq()

int XrdHttpReq::ProcessHTTPReq

(

)

Crunch an http request. Return values: 0->call Process again 1->request processed -1->error

If we have to add extra header information, add it here.

Definition at line 927 of file XrdHttpReq.cc.

                               {
 
  kXR_int32 l;
  if (startTime == std::chrono::steady_clock::time_point::min()) startTime = std::chrono::steady_clock::now();
 
  // State variable for tracking the query parameter search
  // - 0: Indicates we've not yet searched the URL for '?'
  // - 1: Indicates we have a '?' and hence query parameters
  // - 2: Indicates we do *not* have '?' present -- no query parameters
  int query_param_status = 0;
  if (!m_appended_asize) {
    m_appended_asize = true;
    if (request == rtPUT && length) {
      if (query_param_status == 0) {
        query_param_status = strchr(resourceplusopaque.c_str(), '?') ? 1 : 2;
      }
      resourceplusopaque.append((query_param_status == 1) ? '&' : '?');
      query_param_status = 1;
      auto length_str = std::to_string(length);
      resourceplusopaque.append("oss.asize=");
      resourceplusopaque.append(length_str.c_str());
      if (!opaque) {
        opaque = new XrdOucEnv();
      }
      opaque->Put("oss.asize", length_str.c_str());
    }
  }

  if (!m_appended_hdr2cgistr && !hdr2cgistr.empty()) {
    if (query_param_status == 0) {
      query_param_status = strchr(resourceplusopaque.c_str(), '?') ? 1 : 2;
    }
    resourceplusopaque.append((query_param_status == 1) ? '&' : '?');
 
    std::string hdr2cgistrEncoded = encode_opaque(hdr2cgistr);
    resourceplusopaque.append(hdr2cgistrEncoded.c_str());
    if (TRACING(TRACE_DEBUG)) {
      // The obfuscation of "authz" will only be done if the server http.header2cgi config contains something that maps a header to this "authz" cgi.
      // Unfortunately the obfuscation code will be called no matter what is configured in http.header2cgi.
      std::string header2cgistrObf = obfuscateAuth(hdr2cgistr);
 
      TRACEI(DEBUG, "Appended header fields to opaque info: '"
        << header2cgistrObf.c_str() << "'");
 
    }
 
    m_appended_hdr2cgistr = true;
    }
 
  // Verify if we have an external handler for this request
  if (reqstate == 0) {
    XrdHttpExtHandler *exthandler = prot->FindMatchingExtHandler(*this);
    if (exthandler) {
      XrdHttpExtReq xreq(this, prot);
      int r = exthandler->ProcessReq(xreq);
      reset();
      if (!r) return 1; // All went fine, response sent
      if (r < 0) return -1; // There was a hard error... close the connection
 
      return 1; // There was an error and a response was sent
    }
  }
 
  //
  // Here we process the request locally
  //
 
  switch (request) {
    case XrdHttpReq::rtUnset:
      return -1;
    case XrdHttpReq::rtUnknown:
    case XrdHttpReq::rtMalformed: {
      generateWebdavErrMsg();
      prot->SendSimpleResp(400, NULL, NULL, httpErrorBody.c_str(), httpErrorBody.length(), false);
      reset();
      return -1;
    }
    case XrdHttpReq::rtHEAD:
    {
      if (reqstate == 0) {
        // Always start with Stat; in the case of a checksum request, we'll have a follow-up query
        if (prot->doStat((char *) resourceplusopaque.c_str())) {
          prot->SendSimpleResp(404, NULL, NULL, (char *) "Could not run request.", 0, false);
          return -1;
        }
        return 0;
      } else {
        // Note that doChksum requires that the memory stays alive until the callback is invoked.
        int prepareCksum = prepareChecksumQuery(m_req_cksum, m_resource_with_digest);
        if(prepareCksum < 0) {
          return -1;
        }
        if (prot->doChksum(m_resource_with_digest) < 0) {
          // In this case, the Want-Digest header was set and PostProcess gave the go-ahead to do a checksum.
          prot->SendSimpleResp(500, NULL, NULL, (char *) "Failed to create initial checksum request.", 0, false);
          return -1;
        }
        return 1;
      }
    }
    case XrdHttpReq::rtGET:
    {
        int retval = keepalive ? 1 : -1; // reset() clears keepalive
 
        if (resource.beginswith("/static/")) {
 
            // This is a request for a /static resource
            // If we have to use the embedded ones then we return the ones in memory as constants
 
            // The sysadmin can always redirect the request to another host that
            // contains his static resources
 
            // We also allow xrootd to preread from the local disk all the files
            // that have to be served as static resources.
 
            if (prot->embeddedstatic) {
 
                // Default case: the icon and the css of the HTML rendering of XrdHttp
                if (resource == "/static/css/xrdhttp.css") {
                    prot->SendSimpleResp(200, NULL, NULL, (char *) static_css_xrdhttp_css, static_css_xrdhttp_css_len, keepalive);
                    reset();
                    return retval;
                  }
                if (resource == "/static/icons/xrdhttp.ico") {
                    prot->SendSimpleResp(200, NULL, NULL, (char *) favicon_ico, favicon_ico_len, keepalive);
                    reset();
                    return retval;
                  }
 
              }
 
              // If we are here then none of the embedded resources match (or they are disabled)
              // We may have to redirect to a host that is supposed to serve the static resources
              if (prot->staticredir) {
 
                  XrdOucString s = "Location: ";
                  s.append(prot->staticredir);
 
                  if (s.endswith('/'))
                    s.erasefromend(1);
 
                  s.append(encode_str(std::string(resource.c_str())).c_str());
                  appendOpaque(s, 0, 0, 0);
 
                  prot->SendSimpleResp(302, NULL, (char *) s.c_str(), 0, 0, false);
                  return -1;
 
 
                } else {
 
                  // We lookup the requested path in a hash containing the preread files
                  if (prot->staticpreload) {
                    XrdHttpProtocol::StaticPreloadInfo *mydata = prot->staticpreload->Find(resource.c_str());
                    if (mydata) {
                      prot->SendSimpleResp(200, NULL, NULL, (char *) mydata->data, mydata->len, keepalive);
                      reset();
                      return retval;
                    }
                  }
 
                }
 
 
          }
 
      // The reqstate parameter basically moves us through a simple state machine.
      // To optimize things, we start off by opening the file; if it turns out to be a directory, then
      // we close the file handle and switch to doing a HTML-based rendering of the directory.  This
      // avoids needing to always to do "stat" first to determine the next step (since the file-open also
      // does a "stat").
      // - 0: Perform an open on the resource
      // - 1: Perform a checksum request on the resource (only if requested in header; otherwise skipped)
      // - 2: Perform a close (for dirlist only)
      // - 3: Perform a dirlist.
      // - 4+: Reads from file; if at end, perform a close.
      switch (reqstate) {
        case 0: // Open the path for reading.
        {
          memset(&xrdreq, 0, sizeof (ClientRequest));
          xrdreq.open.requestid = htons(kXR_open);
          l = resourceplusopaque.length() + 1;
          xrdreq.open.dlen = htonl(l);
          xrdreq.open.mode = 0;
          xrdreq.open.options = htons(kXR_retstat | kXR_open_read | ((readRangeHandler.getMaxRanges() <= 1) ? kXR_seqio : 0));
 
          if (!prot->Bridge->Run((char *) &xrdreq, (char *) resourceplusopaque.c_str(), l)) {
            prot->SendSimpleResp(404, NULL, NULL, (char *) "Could not run request.", 0, false);
            return -1;
          }
 
          // Prepare to chunk up the request
          writtenbytes = 0;
 
          // We want to be invoked again after this request is finished
          return 0;
        }
        case 1: // Checksum request
          if (!(fileflags & kXR_isDir) && (!m_want_digest.empty() || !m_want_repr_digest.empty())) {
            // In this case, the Want-Digest or then Want-Repr-Digest header was set.
            int prepareCksum = prepareChecksumQuery(m_req_cksum, m_resource_with_digest);
            if(prepareCksum < 0) {
              return -1;
            }
            if (prot->doChksum(m_resource_with_digest) < 0) {
              prot->SendSimpleResp(500, NULL, NULL, (char *) "Failed to start internal checksum request to satisfy Want-Digest or Want-Repr-Digest header.", 0, false);
              return -1;
            }
            return 0;
          } else {
            TRACEI(DEBUG, "No checksum requested; skipping to request state 2");
            reqstate += 1;
          }
        // fallthrough
        case 2: // Close file handle for directory
          if ((fileflags & kXR_isDir) && fopened) {
            memset(&xrdreq, 0, sizeof (ClientRequest));
            xrdreq.close.requestid = htons(kXR_close);
            memcpy(xrdreq.close.fhandle, fhandle, 4);
 
            if (!prot->Bridge->Run((char *) &xrdreq, 0, 0)) {
              generateWebdavErrMsg();
              return sendFooterError("Could not run close request on the bridge");
            }
            return 0;
          } else {
            reqstate += 1;
          }
        // fallthrough
        case 3: // List directory
          if (fileflags & kXR_isDir) {
            if (prot->listdeny) {
              // Return 403 as the administrator forbid the directory listing
              prot->SendSimpleResp(403, NULL, NULL, (char *) "Listings are disabled.", 0, false);
              return -1;
            }
 
            if (prot->listredir) {
              XrdOucString s = "Location: ";
              s.append(prot->listredir);
 
              if (s.endswith('/'))
                s.erasefromend(1);
 
              s.append(encode_str(std::string(resource.c_str())).c_str());
              appendOpaque(s, 0, 0, 0);
 
              prot->SendSimpleResp(302, NULL, (char *) s.c_str(), 0, 0, false);
              return -1;
            }
 
            std::string res;
            res = resourceplusopaque.c_str();
 
            // --------- DIRLIST
            memset(&xrdreq, 0, sizeof (ClientRequest));
            xrdreq.dirlist.requestid = htons(kXR_dirlist);
            xrdreq.dirlist.options[0] = kXR_dstat;
            l = res.length() + 1;
            xrdreq.dirlist.dlen = htonl(l);
 
            if (!prot->Bridge->Run((char *) &xrdreq, (char *) res.c_str(), l)) {
              generateWebdavErrMsg();
              prot->SendSimpleResp(httpStatusCode, NULL, NULL, httpErrorBody.c_str(), httpErrorBody.length(), false);
              sendFooterError("Could not run listing request on the bridge");
              return -1;
            }
 
            // We don't want to be invoked again after this request is finished
            return 1;
          }
          else {
            reqstate += 1;
          }
        // fallthrough
        case 4:
        {
          auto retval = ReturnGetHeaders();
          if (retval) {
            return retval;
          }
        }
        // fallthrough
        default: // Read() or Close(); reqstate is 4+
        {
          const XrdHttpIOList &readChunkList = readRangeHandler.NextReadList();
 
          // Close() if we have finished, otherwise read the next chunk
 
          // --------- CLOSE
          if ( closeAfterError || readChunkList.empty() )
          {
 
            memset(&xrdreq, 0, sizeof (ClientRequest));
            xrdreq.close.requestid = htons(kXR_close);
            memcpy(xrdreq.close.fhandle, fhandle, 4);
 
            if (!prot->Bridge->Run((char *) &xrdreq, 0, 0)) {
              TRACEI(REQ, " Failed to run close request on the bridge.");
              // Note: we have already completed the request and sent the data to the client.
              // Hence, there's no need to send an error.  However, since the bridge is potentially
              // in a bad state, we close the TCP socket to force the client to reconnect.
              return -1;
            }
 
            // We have finished
            readClosing = true;
            return 1;
 
          }
          // --------- READ or READV
 
          if ( readChunkList.size() == 1 ) {
            // Use a read request for single range
 
            long l;
            long long offs;
 
            // --------- READ
            memset(&xrdreq, 0, sizeof (xrdreq));
            xrdreq.read.requestid = htons(kXR_read);
            memcpy(xrdreq.read.fhandle, fhandle, 4);
            xrdreq.read.dlen = 0;
 
            offs = readChunkList[0].offset;
            l = readChunkList[0].size;
 
            xrdreq.read.offset = htonll(offs);
            xrdreq.read.rlen = htonl(l);
 
            // If we are using HTTPS or if the client requested trailers, or if the
            // read concerns a multirange reponse, disable sendfile
            // (in the latter two cases, the extra framing is only done in PostProcessHTTPReq)
            if (prot->ishttps || (m_transfer_encoding_chunked && m_trailer_headers) ||
                !readRangeHandler.isSingleRange()) {
              if (!prot->Bridge->setSF((kXR_char *) fhandle, false)) {
                TRACE(REQ, " XrdBridge::SetSF(false) failed.");
 
              }
            }
 
 
 
            if (l <= 0) {
              if (l < 0) {
                TRACE(ALL, " Data sizes mismatch.");
                return -1;
              }
              else {
                TRACE(ALL, " No more bytes to send.");
                reset();
                return 1;
              }
            }
 
            if ((offs >= filesize) || (offs+l > filesize)) {
              httpStatusCode = 416;
              httpErrorBody = "Range Not Satisfiable";
              std::stringstream ss;
              ss << "Requested range " << l << "@" << offs << " is past the end of file (" << filesize << ")";
              return sendFooterError(ss.str());
            }
 
            if (!prot->Bridge->Run((char *) &xrdreq, 0, 0)) {
              generateWebdavErrMsg();
              return sendFooterError("Could not run read request on the bridge");
            }
          } else {
            // --------- READV
 
            length = ReqReadV(readChunkList);
 
            if (!prot->Bridge->Run((char *) &xrdreq, (char *) &ralist[0], length)) {
              generateWebdavErrMsg();
              return sendFooterError("Could not run ReadV request on the bridge");
            }
 
          }
 
          // We want to be invoked again after this request is finished
          return 0;
        } // case 3+
 
      } // switch (reqstate)
 
 
    } // case XrdHttpReq::rtGET
 
    case XrdHttpReq::rtPUT:
    {
      //if (prot->ishttps) {
      //prot->SendSimpleResp(501, NULL, NULL, (char *) "HTTPS not supported yet for direct writing. Sorry.", 0);
      //return -1;
      //}
 
      if (!fopened) {
 
        // --------- OPEN for write!
        memset(&xrdreq, 0, sizeof (ClientRequest));
        xrdreq.open.requestid = htons(kXR_open);
        l = resourceplusopaque.length() + 1;
        xrdreq.open.dlen = htonl(l);
        xrdreq.open.mode = htons(kXR_ur | kXR_uw | kXR_gw | kXR_gr | kXR_or);
        // 'Overwrite: F' (e.g. forwarded by a TPC push) forbids replacing
        // an existing file; the open then fails with kXR_ItExists (409).
        auto overwrite = XrdOucTUtils::caseInsensitiveFind(allheaders, "overwrite");
        bool noOverwrite = overwrite != allheaders.end() && overwrite->second == "F";
        if (! XrdHttpProtocol::usingEC && ! noOverwrite)
          xrdreq.open.options = htons(kXR_mkpath | kXR_open_wrto | kXR_delete);
        else
          xrdreq.open.options = htons(kXR_mkpath | kXR_open_wrto | kXR_new);
 
        if (!prot->Bridge->Run((char *) &xrdreq, (char *) resourceplusopaque.c_str(), l)) {
          prot->SendSimpleResp(404, NULL, NULL, (char *) "Could not run request.", 0, keepalive);
          return -1;
        }
 
 
        // We want to be invoked again after this request is finished
        // Only if there is data to fetch from the socket or there will
        // never be more data
        if (prot->BuffUsed() > 0 || (length == 0 && !sendcontinue))
          return 0;
 
        return 1;
 
      } else {
 
        if (m_transfer_encoding_chunked) {
          if (m_current_chunk_size == m_current_chunk_offset) {
            // Chunk has been consumed; we now must process the CRLF.
            // Note that we don't support trailer headers.
            if (prot->BuffUsed() < 2) return 1;
            if (prot->myBuffStart[0] != '\r' || prot->myBuffStart[1] != '\n') {
              prot->SendSimpleResp(400, NULL, NULL, (char *) "Invalid trailing chunk encoding.", 0, keepalive);
              return -1;
            }
            prot->BuffConsume(2);
            if (m_current_chunk_size == 0) {
              // All data has been sent.  Turn off chunk processing and
              // set the bytes written and length appropriately; on next callback,
              // we will hit the close() block below.
              m_transfer_encoding_chunked = false;
              length = writtenbytes;
              return ProcessHTTPReq();
            }
            m_current_chunk_size = -1;
            m_current_chunk_offset = 0;
            // If there is more data, we try to process the next chunk; otherwise, return
            if (!prot->BuffUsed()) return 1;
          }
          if (-1 == m_current_chunk_size) {
 
              // Parse out the next chunk size.
            long long idx = 0;
            bool found_newline = false;
            // Set a maximum size of chunk we will allow
            // Nginx sets this to "NGX_MAX_OFF_T_VALUE", which is 9223372036854775807 (a some crazy number)
            // We set it to 1TB, which is 1099511627776
            // This is to prevent a malicious client from sending a very large chunk size
            // or a malformed chunk request.
            // 1TB in base-16 is 0x40000000000, so only allow 11 characters, plus the CRLF
            long long max_chunk_size_chars = std::min(static_cast<long long>(prot->BuffUsed()), static_cast<long long>(13));
            for (; idx < max_chunk_size_chars; idx++) {
              if (prot->myBuffStart[idx] == '\n') {
                found_newline = true;
                break;
              }
            }
            // If we found a new line, but it is the first character in the buffer (no chunk length)
            // or if the previous character is not a CR.
            if (found_newline && ((idx == 0) || prot->myBuffStart[idx-1] != '\r')) {
              prot->SendSimpleResp(400, NULL, NULL, (char *)"Invalid chunked encoding", 0, false);
              TRACE(REQ, "XrdHTTP PUT: Sending invalid chunk encoding.  Start of chunk should have had a length, followed by a CRLF.");
              return -1;
            }
            if (found_newline) {
              char *endptr = NULL;
              std::string line_contents(prot->myBuffStart, idx);
              long long chunk_contents = strtoll(line_contents.c_str(), &endptr, 16);
                // Chunk sizes can be followed by trailer information or CRLF
              if (*endptr != ';' && *endptr != '\r') {
                prot->SendSimpleResp(400, NULL, NULL, (char *)"Invalid chunked encoding", 0, false);
                TRACE(REQ, "XrdHTTP PUT: Sending invalid chunk encoding. Chunk size was not followed by a ';' or CR." << __LINE__);
                return -1;
              }
              m_current_chunk_size = chunk_contents;
              m_current_chunk_offset = 0;
              prot->BuffConsume(idx + 1);
              TRACE(REQ, "XrdHTTP PUT: next chunk from client will be " << m_current_chunk_size << " bytes");
            } else {
                // Need more data!
              return 1;
            }
          }
 
          if (m_current_chunk_size == 0) {
            // All data has been sent.  Invoke this routine again immediately to process CRLF
            return ProcessHTTPReq();
          } else {
            // At this point, we have a chunk size defined and should consume payload data
            memset(&xrdreq, 0, sizeof (xrdreq));
            xrdreq.write.requestid = htons(kXR_write);
            memcpy(xrdreq.write.fhandle, fhandle, 4);
 
            long long chunk_bytes_remaining = m_current_chunk_size - m_current_chunk_offset;
            long long bytes_to_write = std::min(static_cast<long long>(prot->BuffUsed()),
                                           chunk_bytes_remaining);
 
            xrdreq.write.offset = htonll(writtenbytes);
            xrdreq.write.dlen = htonl(bytes_to_write);
 
            TRACEI(REQ, "XrdHTTP PUT: Writing chunk of size " << bytes_to_write << " starting with '" << *(prot->myBuffStart) << "'" << " with " << chunk_bytes_remaining << " bytes remaining in the chunk");
            if (!prot->Bridge->Run((char *) &xrdreq, prot->myBuffStart, bytes_to_write)) {
              generateWebdavErrMsg();
              return sendFooterError("Could not run write request on the bridge");
            }
            // If there are more bytes in the buffer, then immediately call us after the
            // write is finished; otherwise, wait for data.
            return (prot->BuffUsed() > chunk_bytes_remaining) ? 0 : 1;
          }
        } else if (writtenbytes < length) {
 
 
          // --------- WRITE
          memset(&xrdreq, 0, sizeof (xrdreq));
          xrdreq.write.requestid = htons(kXR_write);
          memcpy(xrdreq.write.fhandle, fhandle, 4);
 
          long long bytes_to_read = std::min(static_cast<long long>(prot->BuffUsed()),
                                        length - writtenbytes);
 
          xrdreq.write.offset = htonll(writtenbytes);
          xrdreq.write.dlen = htonl(bytes_to_read);
 
          TRACEI(REQ, "Writing " << bytes_to_read);
          if (!prot->Bridge->Run((char *) &xrdreq, prot->myBuffStart, bytes_to_read)) {
            generateWebdavErrMsg();
            return sendFooterError("Could not run write request on the bridge");
          }
 
          if (writtenbytes + prot->BuffUsed() >= length)
            // Trigger an immediate recall after this request has finished
            return 0;
          else
            // We want to be invoked again after this request is finished
            // only if there is pending data
            return 1;
 
 
 
        } else {
 
          // --------- CLOSE
          memset(&xrdreq, 0, sizeof (ClientRequest));
          xrdreq.close.requestid = htons(kXR_close);
          memcpy(xrdreq.close.fhandle, fhandle, 4);
 
 
          if (!prot->Bridge->Run((char *) &xrdreq, 0, 0)) {
            generateWebdavErrMsg();
            return sendFooterError("Could not run close request on the bridge");
          }
 
          // We have finished
          return 1;
 
        }
 
      }
 
      break;
 
    }
    case XrdHttpReq::rtOPTIONS:
    {
      prot->SendSimpleResp(200, NULL, (char *) "DAV: 1\r\nDAV: <http://apache.org/dav/propset/fs/1>\r\nAllow: HEAD,GET,PUT,PROPFIND,DELETE,OPTIONS", NULL, 0, keepalive);
      bool ret_keepalive = keepalive; // reset() clears keepalive
      reset();
      return ret_keepalive ? 1 : -1;
    }
    case XrdHttpReq::rtDELETE:
    {
 
 
      switch (reqstate) {
 
        case 0: // Stat()
        {
 
 
          // --------- STAT is always the first step
          memset(&xrdreq, 0, sizeof (ClientRequest));
          xrdreq.stat.requestid = htons(kXR_stat);
          std::string s = resourceplusopaque.c_str();
 
 
          l = resourceplusopaque.length() + 1;
          xrdreq.stat.dlen = htonl(l);
 
          if (!prot->Bridge->Run((char *) &xrdreq, (char *) resourceplusopaque.c_str(), l)) {
            prot->SendSimpleResp(501, NULL, NULL, (char *) "Could not run request.", 0, false);
            return -1;
          }
 
          // We need to be invoked again to complete the request
          return 0;
        }
        default:
 
          if (fileflags & kXR_isDir) {
            // --------- RMDIR
            memset(&xrdreq, 0, sizeof (ClientRequest));
            xrdreq.rmdir.requestid = htons(kXR_rmdir);
 
            std::string s = resourceplusopaque.c_str();
 
            l = s.length() + 1;
            xrdreq.rmdir.dlen = htonl(l);
 
            if (!prot->Bridge->Run((char *) &xrdreq, (char *) s.c_str(), l)) {
              prot->SendSimpleResp(501, NULL, NULL, (char *) "Could not run rmdir request.", 0, false);
              return -1;
            }
          } else {
            // --------- DELETE
            memset(&xrdreq, 0, sizeof (ClientRequest));
            xrdreq.rm.requestid = htons(kXR_rm);
 
            std::string s = resourceplusopaque.c_str();
 
            l = s.length() + 1;
            xrdreq.rm.dlen = htonl(l);
 
            if (!prot->Bridge->Run((char *) &xrdreq, (char *) s.c_str(), l)) {
              prot->SendSimpleResp(501, NULL, NULL, (char *) "Could not run rm request.", 0, false);
              return -1;
            }
          }
 
 
          // We don't want to be invoked again after this request is finished
          return 1;
 
      }
 
 
 
    }
    case XrdHttpReq::rtPATCH:
    {
      prot->SendSimpleResp(501, NULL, NULL, (char *) "Request not supported yet.", 0, false);
 
      return -1;
    }
    case XrdHttpReq::rtPROPFIND:
    {
 
 
 
      switch (reqstate) {
 
        case 0: // Stat() and add the current item to the list of the things to send
        {
 
          if (length > 0) {
            TRACE(REQ, "Reading request body " << length << " bytes.");
            char *p = 0;
            // We have to specifically read all the request body
 
            if (prot->BuffgetData(length, &p, true) < length) {
              prot->SendSimpleResp(501, NULL, NULL, (char *) "Error in getting the PROPFIND request body.", 0, false);
              return -1;
            }
 
            if ((depth > 1) || (depth < 0)) {
              prot->SendSimpleResp(501, NULL, NULL, (char *) "Invalid depth value.", 0, false);
              return -1;
            }
 
 
            parseBody(p, length);
          }
 
 
          // --------- STAT is always the first step
          memset(&xrdreq, 0, sizeof (ClientRequest));
          xrdreq.stat.requestid = htons(kXR_stat);
          std::string s = resourceplusopaque.c_str();
 
 
          l = resourceplusopaque.length() + 1;
          xrdreq.stat.dlen = htonl(l);
 
          if (!prot->Bridge->Run((char *) &xrdreq, (char *) resourceplusopaque.c_str(), l)) {
            prot->SendSimpleResp(501, NULL, NULL, (char *) "Could not run request.", 0, false);
            return -1;
          }
 
 
          if (depth == 0) {
            // We don't need to be invoked again
            return 1;
          } else
            // We need to be invoked again to complete the request
            return 0;
 
 
 
          break;
        }
 
        default: // Dirlist()
        {
 
          // --------- DIRLIST
          memset(&xrdreq, 0, sizeof (ClientRequest));
          xrdreq.dirlist.requestid = htons(kXR_dirlist);
 
          std::string s = resourceplusopaque.c_str();
          xrdreq.dirlist.options[0] = kXR_dstat;
          //s += "?xrd.dirstat=1";
 
          l = s.length() + 1;
          xrdreq.dirlist.dlen = htonl(l);
 
          if (!prot->Bridge->Run((char *) &xrdreq, (char *) s.c_str(), l)) {
            prot->SendSimpleResp(501, NULL, NULL, (char *) "Could not run request.", 0, false);
            return -1;
          }
 
          // We don't want to be invoked again after this request is finished
          return 1;
        }
      }
 
 
      break;
    }
    case XrdHttpReq::rtMKCOL:
    {
 
      // --------- MKDIR
      memset(&xrdreq, 0, sizeof (ClientRequest));
      xrdreq.mkdir.requestid = htons(kXR_mkdir);
 
      std::string s = resourceplusopaque.c_str();
      xrdreq.mkdir.options[0] = (kXR_char) kXR_mkdirpath;
 
      l = s.length() + 1;
      xrdreq.mkdir.dlen = htonl(l);
 
      if (!prot->Bridge->Run((char *) &xrdreq, (char *) s.c_str(), l)) {
        prot->SendSimpleResp(501, NULL, NULL, (char *) "Could not run request.", 0, false);
        return -1;
      }
 
      // We don't want to be invoked again after this request is finished
      return 1;
    }
    case XrdHttpReq::rtMOVE:
    {
      // Skip the protocol part of destination URL
      size_t skip = destination.find("://");
      skip = (skip == std::string::npos) ? 0 : skip + 3;
 
      // If we have a manager role, enforce source and destination are on the same host
      if (prot->myRole == kXR_isManager && destination.compare(skip, host.size(), host) != 0) {
        prot->SendSimpleResp(501, NULL, NULL, (char *) "Only in-place renaming is supported for MOVE.", 0, false);
        return -1;
      }
 
      // If needed, append opaque info from source onto destination
      int pos = resourceplusopaque.find("?");
      if (pos != STR_NPOS) {
        destination.append((destination.find("?") == std::string::npos) ? "?" : "&");
        destination.append(resourceplusopaque.c_str() + pos + 1);
      }
 
      size_t path_pos = destination.find('/', skip + 1);
 
      if (path_pos == std::string::npos) {
        prot->SendSimpleResp(400, NULL, NULL, (char *) "Cannot determine destination path", 0, false);
        return -1;
      }
 
      // Construct args to kXR_mv request (i.e. <src> + " " + <dst>)
      std::string mv_args = std::string(resourceplusopaque.c_str()) + " " + destination.substr(path_pos);
 
      l = mv_args.length() + 1;
 
      // Prepare and run kXR_mv request
      memset(&xrdreq, 0, sizeof (ClientRequest));
      xrdreq.mv.requestid = htons(kXR_mv);
      xrdreq.mv.arg1len = htons(resourceplusopaque.length());
      xrdreq.mv.dlen = htonl(l);
 
      if (!prot->Bridge->Run((char *) &xrdreq, (char *) mv_args.c_str(), l)) {
        prot->SendSimpleResp(500, NULL, NULL, (char *) "Could not run request.", 0, false);
        return -1;
      }
 
      // We don't want to be invoked again after this request is finished
      return 1;
    }
    default:
    {
      prot->SendSimpleResp(501, NULL, NULL, (char *) "Request not supported.", 0, false);
      return -1;
    }
 
  }
 
  return 1;
}

References XrdOucEnv::XrdOucEnv(), allheaders, XrdOucString::append(), appendOpaque(), ClientMvRequest::arg1len, XrdOucString::beginswith(), XrdOucString::c_str(), XrdOucTUtils::caseInsensitiveFind(), ClientRequest::close, closeAfterError, XrdHttpProtocol::StaticPreloadInfo::data, DEBUG, depth, destination, ClientRequest::dirlist, ClientDirlistRequest::dlen, ClientMkdirRequest::dlen, ClientMvRequest::dlen, ClientOpenRequest::dlen, ClientReadRequest::dlen, ClientRmdirRequest::dlen, ClientRmRequest::dlen, ClientStatRequest::dlen, ClientWriteRequest::dlen, encode_opaque(), encode_str(), XrdOucString::endswith(), XrdOucString::erasefromend(), ClientCloseRequest::fhandle, ClientReadRequest::fhandle, ClientWriteRequest::fhandle, fhandle, fileflags, filesize, XrdOucString::find(), fopened, XrdHttpReadRangeHandler::getMaxRanges(), hdr2cgistr, host, XrdHttpReadRangeHandler::isSingleRange(), keepalive, kXR_close, kXR_delete, kXR_dirlist, kXR_dstat, kXR_gr, kXR_gw, kXR_isDir, kXR_isManager, kXR_mkdir, kXR_mkdirpath, kXR_mkpath, kXR_mv, kXR_new, kXR_open, kXR_open_read, kXR_open_wrto, kXR_or, kXR_read, kXR_retstat, kXR_rm, kXR_rmdir, kXR_seqio, kXR_stat, kXR_ur, kXR_uw, kXR_write, XrdHttpProtocol::StaticPreloadInfo::len, length, XrdOucString::length(), m_appended_asize, m_appended_hdr2cgistr, m_req_cksum, m_resource_with_digest, m_want_digest, m_want_repr_digest, ClientRequest::mkdir, ClientOpenRequest::mode, ClientRequest::mv, XrdHttpReadRangeHandler::NextReadList(), obfuscateAuth(), ClientReadRequest::offset, ClientWriteRequest::offset, opaque, ClientRequest::open, ClientDirlistRequest::options, ClientMkdirRequest::options, ClientOpenRequest::options, parseBody(), ProcessHTTPReq(), XrdHttpExtHandler::ProcessReq(), ralist, ClientRequest::read, readClosing, readRangeHandler, ReqReadV(), reqstate, request, ClientCloseRequest::requestid, ClientDirlistRequest::requestid, ClientMkdirRequest::requestid, ClientMvRequest::requestid, ClientOpenRequest::requestid, ClientReadRequest::requestid, ClientRmdirRequest::requestid, ClientRmRequest::requestid, ClientStatRequest::requestid, ClientWriteRequest::requestid, reset(), resource, resourceplusopaque, ClientReadRequest::rlen, ClientRequest::rm, ClientRequest::rmdir, rtDELETE, rtGET, rtHEAD, rtMalformed, rtMKCOL, rtMOVE, rtOPTIONS, rtPATCH, rtPROPFIND, rtPUT, rtUnknown, rtUnset, sendcontinue, startTime, ClientRequest::stat, STR_NPOS, TRACE, TRACE_DEBUG, TRACEI, TRACING, ClientRequest::write, writtenbytes, and xrdreq.

Referenced by XrdHttpProtocol::Process(), and ProcessHTTPReq().

Here is the call graph for this function:

Here is the caller graph for this function:

Redir()

bool XrdHttpReq::Redir ( XrdXrootd::Bridge::Context & info, int port, const char * hname )

virtual

Redirect the client to another host:port (or absolute URL).

The Redir() method is called when the client must be redirected to another host.

Parameters

info	the context associated with the result.
port	destination port in host byte order; when port < 0 and hname is an absolute URL (scheme://…), Location is that URL as-is (path included) and the original resource is not appended. Otherwise Location is built as http(s)://hname[:port]<resource>.
hname	DNS name / IP, or absolute URL when port < 0.

Returns

true continue normal processing. false terminate the bridge and close the link.

Parameters

info	the result context
port	the port number
hname	the destination host

Implements XrdXrootd::Bridge::Result.

Definition at line 599 of file XrdHttpReq.cc.

          {
 
 
 
  char hash[512];
  hash[0] = '\0';
 
  bool invalid_host = false;
 
  if (!hname) {
    invalid_host = true;
  } else {
    for (const char *c = hname; *c; ++c)
      if (*c == '\r' || *c == '\n')
        invalid_host = true;
  }
 
  if (invalid_host) {
    prot->SendSimpleResp(502, nullptr, nullptr, "Invalid redirect host", 0, false);
    return keepalive;
  }
 
  // port < 0 means XRootD URL-form redirect: hname is a full scheme://… URL
  // (host+port+path).
  // Do not prefix http(s):// and do not append the original resource
  // otherwise, that would produce https://https://…/pfn/lfn.
  const bool fullUrl = (port < 0);
  if (fullUrl) {
    TRACE(REQ, " XrdHttpReq::Redir using absolute URL: " << hname);
  }
 
  // Beware, certain Ofs implementations (e.g. EOS) add opaque data directly to the host name
  // This must be correctly treated here and appended to the opaque info
  // that we may already have
  char *pp = strchr((char *)hname, '?');
  char *vardata = 0;
  if (pp) {
    *pp = '\0';
    vardata = pp+1;
    int varlen = strlen(vardata);
 
    //Now extract the remaining, vardata points to it
    while(*vardata == '&' && varlen) {vardata++; varlen--;}
  }
 
  // If the destination speaks cleartext HTTP, it needs the
  // secret hash to reconstruct authorization info.
  const bool destHttpCleartext =
      fullUrl ? (strncmp(hname, "http://", 7) == 0) : (!prot->isdesthttps);
 
  std::string urlHashPath;
  {
    const std::string encodedResource =
        fullUrl ? std::string() : encode_str(resource.c_str());
    redirdest = httpBuildRedirectLocation(prot->isdesthttps, port, hname,
                                          encodedResource.c_str()).c_str();
 
    // Derive the token path while hname is still truncated at '?', so the CGI
    // stays out of the hash and both ends digest the same string.
    if (fullUrl && destHttpCleartext)
      urlHashPath = httpCollapseSlashes(decode_str(httpPathFromAbsoluteUrl(hname)));
  }
 
  // Restore '?' so later uses of hname see the original string.
  if (pp)
    *pp = '?';
 
  // Here we put back the opaque info, if any
  if (vardata) {
    redirdest += "?&";
    redirdest += encode_opaque(vardata).c_str();
  }
 
  // Shall we put also the opaque data of the request? Maybe not
  //int l;
  //if (opaque && opaque->Env(l))
  //  redirdest += opaque->Env(l);
 
 
  time_t timenow = 0;
  if (destHttpCleartext && prot->ishttps) {
    const char *hashPath = urlHashPath.empty() ? resource.c_str() : urlHashPath.c_str();
    // If the destination is not https, then we suppose that it
    // will need this token to fill its authorization info
    timenow = time(0);
    calcHashes(hash, hashPath, (kXR_int16) request,
            &prot->SecEntity,
            timenow,
            prot->secretkey);
  }
 
  if (hash[0]) {
    appendOpaque(redirdest, &prot->SecEntity, hash, timenow);
  } else
    appendOpaque(redirdest, 0, 0, 0);
 
  if (!prot->strp_cgi_params.empty()) {
    stripCgi(redirdest, prot->strp_cgi_params); /* appendOpaque() may have added credentials */
  }
 
  TRACE(REQ, " XrdHttpReq::Redir Redirecting to " << redirdest.c_str());
 
  if (request != rtGET)
    prot->SendSimpleResp(307, NULL, (char *) redirdest.c_str(), 0, 0, keepalive);
  else
    prot->SendSimpleResp(302, NULL, (char *) redirdest.c_str(), 0, 0, keepalive);
 
  bool ret_keepalive = keepalive; // reset() clears keepalive
  reset();
  return ret_keepalive;
};

References appendOpaque(), XrdOucString::c_str(), calcHashes(), decode_str(), encode_opaque(), encode_str(), httpBuildRedirectLocation(), httpCollapseSlashes(), httpPathFromAbsoluteUrl(), keepalive, redirdest, request, reset(), resource, rtGET, stripCgi(), and TRACE.

Here is the call graph for this function:

ReqReadV()

int XrdHttpReq::ReqReadV

(

const XrdHttpIOList &

cl

)

Prepare the buffers for sending a readv request.

Definition at line 451 of file XrdHttpReq.cc.

                                                {
 
 
  // Now we build the protocol-ready read ahead list
  //  and also put the correct placeholders inside the cache
  int n = cl.size();
  ralist.clear();
  ralist.reserve(n);
 
  int j = 0;
  for (const auto &c: cl) {
    ralist.emplace_back();
    auto &ra = ralist.back();
    memcpy(&ra.fhandle, this->fhandle, 4);
 
    ra.offset = c.offset;
    ra.rlen = c.size;
    j++;
  }
 
  if (j > 0) {
 
    // Prepare a request header
 
    memset(&xrdreq, 0, sizeof (xrdreq));
 
    xrdreq.header.requestid = htons(kXR_readv);
    xrdreq.readv.dlen = htonl(j * sizeof (struct readahead_list));
 
    clientMarshallReadAheadList(j);
 
 
  }
 
  return (j * sizeof (struct readahead_list));
}

References ClientReadVRequest::dlen, ClientRequest::header, kXR_readv, ralist, ClientRequest::readv, ClientRequestHdr::requestid, and xrdreq.

Referenced by ProcessHTTPReq().

Here is the caller graph for this function:

reset()

void XrdHttpReq::reset ( )

virtual

State machine to talk to the bridge

Definition at line 2762 of file XrdHttpReq.cc.

                       {
 
  TRACE(REQ, " XrdHttpReq request ended.");
 
  //if (xmlbody) xmlFreeDoc(xmlbody);
  readRangeHandler.reset();
  readClosing = false;
  closeAfterError = false;
  writtenbytes = 0;
  etext.clear();
  redirdest = "";
 
  //        // Here we should deallocate this
  //        const struct iovec *iovP //!< pointer to data array
  //                int iovN, //!< array count
  //                int iovL, //!< byte  count
  //                bool final //!< true -> final result
 
 
  //xmlbody = 0;
  depth = 0;
  xrdresp = kXR_noResponsesYet;
  xrderrcode = kXR_noErrorYet;
  ralist.clear();
  ralist.shrink_to_fit();
 
  request = rtUnset;
  resource = "";
  allheaders.clear();
 
  // Reset the state of the request's digest request.
  m_want_digest.clear();
  m_digest_header.clear();
  m_req_cksum = nullptr;
 
  m_user_agent = "";
  m_origin = "";
 
  httpStatusCode = -1;
  initialStatusCode= -1;
  httpErrorCode = "";
  httpErrorBody = "";
 
  headerok = false;
  keepalive = true;
  length = 0;
  length_seen = false;
  filesize = 0;
  depth = 0;
  sendcontinue = false;
 
  m_transfer_encoding_chunked = false;
  m_current_chunk_size = -1;
  m_current_chunk_offset = 0;
 
  m_trailer_headers = false;
  m_status_trailer = false;

  reqstate = 0;
 
  memset(&xrdreq, 0, sizeof (xrdreq));
  memset(&xrdresp, 0, sizeof (xrdresp));
  xrderrcode = kXR_noErrorYet;
 
  etext.clear();
  redirdest = "";
 
  stringresp = "";
 
  host = "";
  destination = "";
  hdr2cgistr = "";
  m_appended_hdr2cgistr = false;
  m_appended_asize = false;
 
  iovP = 0;
  iovN = 0;
  iovL = 0;
 
  if (opaque) delete(opaque);
  opaque = 0;
 
  fopened = false;
  final = false;
  mScitag = -1;
 
  m_repr_digest.clear();
  m_want_repr_digest.clear();
 
  monState = XrdHttpMonState::NEW;
  startTime = std::chrono::steady_clock::time_point::min();
}

References allheaders, closeAfterError, depth, destination, etext, filesize, fopened, hdr2cgistr, headerok, host, iovL, iovN, iovP, keepalive, kXR_noErrorYet, kXR_noResponsesYet, length, length_seen, m_appended_asize, m_appended_hdr2cgistr, m_digest_header, m_origin, m_repr_digest, m_req_cksum, m_want_digest, m_want_repr_digest, monState, mScitag, NEW, opaque, ralist, readClosing, readRangeHandler, redirdest, reqstate, request, XrdHttpReadRangeHandler::reset(), resource, rtUnset, sendcontinue, startTime, stringresp, TRACE, writtenbytes, xrderrcode, xrdreq, and xrdresp.

Referenced by ~XrdHttpReq(), Data(), Done(), Error(), XrdHttpProtocol::Process(), ProcessHTTPReq(), and Redir().

Here is the call graph for this function:

Here is the caller graph for this function:

setHttpStatusCode()

void XrdHttpReq::setHttpStatusCode ( int code )

inline

Definition at line 229 of file XrdHttpReq.hh.

                                   {
      httpStatusCode = code;
      if (initialStatusCode < 0 && code >= 200 ) { 
        initialStatusCode = code;
      }
  }

setTransferStatusHeader()

void XrdHttpReq::setTransferStatusHeader

(

std::string &

header

)

Definition at line 2081 of file XrdHttpReq.cc.

                                                          {
  if (m_status_trailer) {
    if (header.empty()) {
      header += "Trailer: X-Transfer-Status";
    } else {
      header += "\r\nTrailer: X-Transfer-Status";
    }
  }
}

userAgent()

const std::string & XrdHttpReq::userAgent ( ) const

inline

Definition at line 265 of file XrdHttpReq.hh.

{return m_user_agent;}

Referenced by XrdHttpProtocol::Process().

Here is the caller graph for this function:

Member Data Documentation

allheaders

std::map<std::string, std::string> XrdHttpReq::allheaders

Definition at line 274 of file XrdHttpReq.hh.

Referenced by parseLine(), ProcessHTTPReq(), and reset().

closeAfterError

bool XrdHttpReq::closeAfterError

Definition at line 293 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), ProcessHTTPReq(), and reset().

depth

int XrdHttpReq::depth

Definition at line 298 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), parseLine(), ProcessHTTPReq(), and reset().

destination

std::string XrdHttpReq::destination

The destination field specified in the req.

Definition at line 304 of file XrdHttpReq.hh.

Referenced by parseLine(), ProcessHTTPReq(), and reset().

etagval

long long XrdHttpReq::etagval

Definition at line 349 of file XrdHttpReq.hh.

etext

std::string XrdHttpReq::etext

Definition at line 339 of file XrdHttpReq.hh.

Referenced by Error(), and reset().

fhandle

char XrdHttpReq::fhandle[4]

Definition at line 354 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq().

filectime

long XrdHttpReq::filectime

Definition at line 353 of file XrdHttpReq.hh.

fileflags

long XrdHttpReq::fileflags

Definition at line 351 of file XrdHttpReq.hh.

Referenced by XrdHttpProtocol::doStat(), and ProcessHTTPReq().

filemodtime

long XrdHttpReq::filemodtime

Definition at line 352 of file XrdHttpReq.hh.

Referenced by XrdHttpProtocol::doStat().

filesize

long long XrdHttpReq::filesize

Definition at line 350 of file XrdHttpReq.hh.

Referenced by XrdHttpProtocol::doStat(), ProcessHTTPReq(), and reset().

final

bool XrdHttpReq::final

true -> final result

Definition at line 346 of file XrdHttpReq.hh.

fopened

bool XrdHttpReq::fopened

Definition at line 355 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), ProcessHTTPReq(), and reset().

hdr2cgistr

std::string XrdHttpReq::hdr2cgistr

Additional opaque info that may come from the hdr2cgi directive.

Definition at line 320 of file XrdHttpReq.hh.

Referenced by addCgi(), appendOpaque(), ProcessHTTPReq(), and reset().

headerok

bool XrdHttpReq::headerok

Tells if we have finished reading the header.

Definition at line 285 of file XrdHttpReq.hh.

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

host

std::string XrdHttpReq::host

The host field specified in the req.

Definition at line 302 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

iovL

int XrdHttpReq::iovL

byte count

Definition at line 345 of file XrdHttpReq.hh.

Referenced by Data(), and reset().

iovN

int XrdHttpReq::iovN

array count

Definition at line 344 of file XrdHttpReq.hh.

Referenced by Data(), Done(), and reset().

iovP

const struct iovec* XrdHttpReq::iovP

The latest data chunks got from the xrd layer. These are valid only inside the callbacks!

pointer to data array

Definition at line 343 of file XrdHttpReq.hh.

Referenced by Data(), and reset().

keepalive

bool XrdHttpReq::keepalive

Definition at line 295 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), parseFirstLine(), parseLine(), ProcessHTTPReq(), Redir(), and reset().

length

ssize_t XrdHttpReq::length

Definition at line 296 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), XrdHttpReq(), parseLine(), ProcessHTTPReq(), and reset().

length_seen

bool XrdHttpReq::length_seen {false}

Definition at line 297 of file XrdHttpReq.hh.

Referenced by parseLine(), and reset().

m_appended_asize

bool XrdHttpReq::m_appended_asize {false}

Track whether we already appended the oss.asize argument for PUTs.

Definition at line 323 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

m_appended_hdr2cgistr

bool XrdHttpReq::m_appended_hdr2cgistr

Definition at line 321 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

m_digest_header

std::string XrdHttpReq::m_digest_header

The computed digest for the HTTP response header.

Definition at line 317 of file XrdHttpReq.hh.

Referenced by reset().

m_origin

std::string XrdHttpReq::m_origin

Definition at line 368 of file XrdHttpReq.hh.

Referenced by parseLine(), and reset().

m_repr_digest

std::map<std::string,std::string> XrdHttpReq::m_repr_digest

Repr-Digest map where the key is the digest name and the value is the base64 encoded digest value.

Definition at line 373 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), parseLine(), and reset().

m_req_cksum

XrdHttpChecksumHandler::XrdHttpChecksumRawPtr XrdHttpReq::m_req_cksum = nullptr

The checksum that was ran for this request.

Definition at line 310 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

m_resource_with_digest

XrdOucString XrdHttpReq::m_resource_with_digest

The checksum algorithm is specified as part of the opaque data in the URL. Hence, when a digest is generated to satisfy a request, we cache the tweaked URL in this data member.

Definition at line 315 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq().

m_want_digest

std::string XrdHttpReq::m_want_digest

The requested digest type.

Definition at line 307 of file XrdHttpReq.hh.

Referenced by parseLine(), ProcessHTTPReq(), and reset().

m_want_repr_digest

std::map<std::string,uint8_t> XrdHttpReq::m_want_repr_digest

Want-Repr-Digest map where the key is the digest name and the value is the preference (between 0 and 9)

Definition at line 377 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), parseLine(), ProcessHTTPReq(), and reset().

monState

XrdHttpMonState XrdHttpReq::monState

Definition at line 379 of file XrdHttpReq.hh.

Referenced by XrdHttpMon::Record(), and reset().

mScitag

int XrdHttpReq::mScitag

Definition at line 366 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), XrdHttpReq(), and reset().

opaque

XrdOucEnv* XrdHttpReq::opaque

The opaque data, after parsing.

Definition at line 279 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), XrdHttpReq(), appendOpaque(), parseLine(), XrdHttpProtocol::Process(), ProcessHTTPReq(), and reset().

ralist

std::vector<readahead_list> XrdHttpReq::ralist

Definition at line 247 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), ReqReadV(), and reset().

readClosing

bool XrdHttpReq::readClosing

Definition at line 289 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

readRangeHandler

XrdHttpReadRangeHandler XrdHttpReq::readRangeHandler

Tracking the next ranges of data to read during GET.

Definition at line 288 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), File(), parseLine(), ProcessHTTPReq(), and reset().

redirdest

XrdOucString XrdHttpReq::redirdest

Definition at line 340 of file XrdHttpReq.hh.

Referenced by Redir(), and reset().

reqstate

int XrdHttpReq::reqstate

State machine to talk to the bridge.

Definition at line 361 of file XrdHttpReq.hh.

Referenced by XrdHttpProtocol::Process(), ProcessHTTPReq(), and reset().

request

ReqType XrdHttpReq::request

The request we got.

Definition at line 269 of file XrdHttpReq.hh.

Referenced by Error(), parseFirstLine(), parseLine(), XrdHttpProtocol::Process(), ProcessHTTPReq(), XrdHttpMon::Record(), Redir(), and reset().

requestverb

std::string XrdHttpReq::requestverb

Definition at line 270 of file XrdHttpReq.hh.

Referenced by parseFirstLine().

resource

XrdOucString XrdHttpReq::resource

The resource specified by the request, stripped of opaque data.

Definition at line 277 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), XrdHttpProtocol::Process(), ProcessHTTPReq(), Redir(), and reset().

resourceplusopaque

XrdOucString XrdHttpReq::resourceplusopaque

The resource specified by the request, including all the opaque data.

Definition at line 281 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), and ProcessHTTPReq().

rwOpDone

unsigned int XrdHttpReq::rwOpDone

To coordinate multipart responses across multiple calls.

Definition at line 331 of file XrdHttpReq.hh.

rwOpPartialDone

unsigned int XrdHttpReq::rwOpPartialDone

Definition at line 331 of file XrdHttpReq.hh.

sendcontinue

bool XrdHttpReq::sendcontinue

Definition at line 299 of file XrdHttpReq.hh.

Referenced by parseLine(), ProcessHTTPReq(), and reset().

startTime

std::chrono::steady_clock::time_point XrdHttpReq::startTime = std::chrono::steady_clock::time_point::min()

Definition at line 370 of file XrdHttpReq.hh.

Referenced by XrdHttpProtocol::Process(), ProcessHTTPReq(), XrdHttpMon::Record(), and reset().

stringresp

std::string XrdHttpReq::stringresp

If we want to give a string as a response, we compose it here.

Definition at line 358 of file XrdHttpReq.hh.

Referenced by reset().

writtenbytes

long long XrdHttpReq::writtenbytes

In a long write, we track where we have arrived.

Definition at line 364 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), ProcessHTTPReq(), and reset().

xrderrcode

XErrorCode XrdHttpReq::xrderrcode

Definition at line 338 of file XrdHttpReq.hh.

Referenced by Error(), and reset().

xrdreq

ClientRequest XrdHttpReq::xrdreq

The last issued xrd request, often pending.

Definition at line 334 of file XrdHttpReq.hh.

Referenced by XrdHttpProtocol::doChksum(), XrdHttpProtocol::doStat(), Error(), XrdHttpProtocol::Process(), ProcessHTTPReq(), ReqReadV(), and reset().

xrdresp

XResponseType XrdHttpReq::xrdresp

The last response data we got.

Definition at line 337 of file XrdHttpReq.hh.

Referenced by Data(), Done(), Error(), and reset().

---

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

• XrdHttpReq.hh
• XrdHttpReq.cc