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 }
	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	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	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.
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
long long	length
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
XrdHttpChecksumHandler::XrdHttpChecksumRawPtr	m_req_cksum = nullptr
	The checksum that was ran for this request.
std::string	m_req_digest
	The requested digest type.
XrdOucString	m_resource_with_digest
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::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 71 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

Definition at line 81 of file XrdHttpReq.hh.

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

Constructor & Destructor Documentation

XrdHttpReq()

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

inline

Definition at line 207 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 111 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 747 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 639 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, XrdSecEntity::grps, hdr2cgistr, XrdSecEntity::host, XrdSecEntity::moninfo, XrdSecEntity::name, opaque, XrdSecEntity::role, and XrdSecEntity::vorg.

Referenced by 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 434 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 444 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 452 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 498 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 515 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, kXR_error, kXR_isDirectory, kXR_open, request, 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 474 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 readRangeHandler, XrdXrootd::Bridge::Context::Send(), and TRACE.

Here is the call graph for this function:

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 95 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 265 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 {
      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, rtDELETE, rtGET, rtHEAD, rtMalformed, rtMKCOL, rtMOVE, rtOPTIONS, rtPATCH, rtPOST, rtPROPFIND, rtPUT, and rtUnknown.

parseLine()

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

Parse the header.

Definition at line 117 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")) {
      length = atoll(val);
 
    } else if (!strcasecmp(key, "destination")) {
      destination.assign(val, line+len-val);
      trim(destination);
    } else if (!strcasecmp(key, "want-digest")) {
      m_req_digest.assign(val, line + len - val);
      trim(m_req_digest);
      //Transform the user requests' want-digest to lowercase
      std::transform(m_req_digest.begin(),m_req_digest.end(),m_req_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") && strstr(val, "chunked")) {
      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 {
      // 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, keepalive, length, m_origin, m_req_digest, MAX_TK_LEN, opaque, readRangeHandler, request, rtMalformed, sendcontinue, and trim().

Here is the call 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 839 of file XrdHttpReq.cc.

                               {
 
  kXR_int32 l;
 
  // 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:
    case XrdHttpReq::rtUnknown:
    case XrdHttpReq::rtMalformed: {
      generateWebdavErrMsg();
      prot->SendSimpleResp(httpStatusCode, 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 {
        const char *opaque = strchr(resourceplusopaque.c_str(), '?');
        // Note that doChksum requires that the memory stays alive until the callback is invoked.
        m_resource_with_digest = resourceplusopaque;
 
        m_req_cksum = prot->cksumHandler.getChecksumToRun(m_req_digest);
        if(!m_req_cksum) {
            // No HTTP IANA checksums have been configured by the server admin, return a "METHOD_NOT_ALLOWED" error
            // We should not send body in response to HEAD request
            prot->SendSimpleResp(HTTP_METHOD_NOT_ALLOWED, NULL, NULL, NULL, 0, false);
            return -1;
        }
        if (!opaque) {
          m_resource_with_digest += "?cks.type=";
          m_resource_with_digest += m_req_cksum->getXRootDConfigDigestName().c_str();
        } else {
          m_resource_with_digest += "&cks.type=";
          m_resource_with_digest += m_req_cksum->getXRootDConfigDigestName().c_str();
        }
        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(resource);
                  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_req_digest.empty()) {
            // In this case, the Want-Digest header was set.
            bool has_opaque = strchr(resourceplusopaque.c_str(), '?');
            // Note that doChksum requires that the memory stays alive until the callback is invoked.
            m_req_cksum = prot->cksumHandler.getChecksumToRun(m_req_digest);
            if(!m_req_cksum) {
                // No HTTP IANA checksums have been configured by the server admin, return a "METHOD_NOT_ALLOWED" error
                prot->SendSimpleResp(HTTP_METHOD_NOT_ALLOWED, NULL, NULL, (char *) "No HTTP-IANA compatible checksums have been configured.", 0, false);
                return -1;
            }
            m_resource_with_digest = resourceplusopaque;
            if (has_opaque) {
              m_resource_with_digest += "&cks.type=";
              m_resource_with_digest += m_req_cksum->getXRootDConfigDigestName().c_str();
            } else {
              m_resource_with_digest += "?cks.type=";
              m_resource_with_digest += m_req_cksum->getXRootDConfigDigestName().c_str();
            }
            if (prot->doChksum(m_resource_with_digest) < 0) {
              prot->SendSimpleResp(500, NULL, NULL, (char *) "Failed to start internal checksum request to satisfy Want-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) {
              prot->SendSimpleResp(503, 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(resource);
              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);
        if (! XrdHttpProtocol::usingEC) 
          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 = strtol(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 XrdOucString::append(), appendOpaque(), XrdOucString::c_str(), closeAfterError, XrdHttpProtocol::StaticPreloadInfo::data, DEBUG, depth, destination, encode_opaque(), XrdOucString::endswith(), XrdOucString::erasefromend(), fhandle, fileflags, filesize, fopened, hdr2cgistr, host, HTTP_METHOD_NOT_ALLOWED, 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, m_appended_asize, m_appended_hdr2cgistr, m_req_cksum, m_req_digest, m_resource_with_digest, obfuscateAuth(), opaque, parseBody(), ProcessHTTPReq(), XrdHttpExtHandler::ProcessReq(), ralist, readClosing, readRangeHandler, ReqReadV(), reqstate, request, reset(), resource, resourceplusopaque, rtDELETE, rtGET, rtHEAD, rtMalformed, rtMKCOL, rtMOVE, rtOPTIONS, rtPATCH, rtPROPFIND, rtPUT, rtUnknown, rtUnset, sendcontinue, STR_NPOS, TRACE, TRACE_DEBUG, TRACEI, TRACING, writtenbytes, and xrdreq.

Referenced by 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.

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

Parameters

info	the context associated with the result.
port	the port number in host byte format.
hname	the DNS name of the host or IP address is IPV4 or IPV6 format (i.e. "n.n.n.n" or "[ipv6_addr]").

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 545 of file XrdHttpReq.cc.

          {
 
 
 
  char buf[512];
  char hash[512];
  hash[0] = '\0';
  
  if (prot->isdesthttps)
    redirdest = "Location: https://";
  else
    redirdest = "Location: http://";
  
  // port < 0 signals switch to full URL
  if (port < 0)
  {
    if (strncmp(hname, "file://", 7) == 0)
    {
      TRACE(REQ, " XrdHttpReq::Redir Switching to file:// ");
      redirdest = "Location: "; // "file://" already contained in 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';
    redirdest += hname;
    vardata = pp+1;
    int varlen = strlen(vardata);
    
    //Now extract the remaining, vardata points to it
    while(*vardata == '&' && varlen) {vardata++; varlen--;}
    
    // Put the question mark back where it was
    *pp = '?';
  }
  else
    redirdest += hname;
 
  if (port > 0) {
    sprintf(buf, ":%d", port);
    redirdest += buf;
  }
 
  redirdest += encode_str(resource.c_str()).c_str();
  
  // 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 (!prot->isdesthttps && prot->ishttps) {
    // 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, this->resource.c_str(), (kXR_int16) request,
            &prot->SecEntity,
            timenow,
            prot->secretkey);
  }
 
  if (hash[0]) {
    appendOpaque(redirdest, &prot->SecEntity, hash, timenow);
  } else
    appendOpaque(redirdest, 0, 0, 0);
 
  
  TRACE(REQ, " XrdHttpReq::Redir Redirecting to " << obfuscateAuth(redirdest.c_str()).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(), calcHashes(), encode_opaque(), encode_str(), keepalive, obfuscateAuth(), redirdest, request, reset(), resource, rtGET, 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 397 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 kXR_readv, ralist, 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 2700 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_req_digest.clear();
  m_digest_header.clear();
  m_req_cksum = nullptr;
 
  m_resource_with_digest = "";
  m_user_agent = "";
  m_origin = "";
 
  headerok = false;
  keepalive = true;
  length = 0;
  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;
 
  httpStatusCode = -1;
  httpErrorCode = "";
  httpErrorBody = "";
 
}

References allheaders, closeAfterError, depth, destination, etext, filesize, fopened, hdr2cgistr, headerok, host, iovL, iovN, iovP, keepalive, kXR_noErrorYet, kXR_noResponsesYet, length, m_appended_asize, m_appended_hdr2cgistr, m_digest_header, m_origin, m_req_cksum, m_req_digest, m_resource_with_digest, mScitag, opaque, ralist, readClosing, readRangeHandler, redirdest, reqstate, request, resource, rtUnset, sendcontinue, stringresp, TRACE, writtenbytes, xrderrcode, xrdreq, and xrdresp.

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

Here is the caller graph for this function:

setTransferStatusHeader()

void XrdHttpReq::setTransferStatusHeader

(

std::string &

header

)

Definition at line 2002 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 254 of file XrdHttpReq.hh.

{return m_user_agent;}

Member Data Documentation

allheaders

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

Definition at line 263 of file XrdHttpReq.hh.

Referenced by parseLine(), and reset().

closeAfterError

bool XrdHttpReq::closeAfterError

Definition at line 282 of file XrdHttpReq.hh.

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

depth

int XrdHttpReq::depth

Definition at line 286 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 292 of file XrdHttpReq.hh.

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

etext

std::string XrdHttpReq::etext

Definition at line 327 of file XrdHttpReq.hh.

Referenced by Error(), and reset().

fhandle

char XrdHttpReq::fhandle[4]

Definition at line 341 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq().

filectime

long XrdHttpReq::filectime

Definition at line 340 of file XrdHttpReq.hh.

fileflags

long XrdHttpReq::fileflags

Definition at line 338 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq().

filemodtime

long XrdHttpReq::filemodtime

Definition at line 339 of file XrdHttpReq.hh.

filesize

long long XrdHttpReq::filesize

Definition at line 337 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

final

bool XrdHttpReq::final

true -> final result

Definition at line 334 of file XrdHttpReq.hh.

fopened

bool XrdHttpReq::fopened

Definition at line 342 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 308 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 274 of file XrdHttpReq.hh.

Referenced by XrdHttpReq(), and reset().

host

std::string XrdHttpReq::host

The host field specified in the req.

Definition at line 290 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

iovL

int XrdHttpReq::iovL

byte count

Definition at line 333 of file XrdHttpReq.hh.

Referenced by Data(), and reset().

iovN

int XrdHttpReq::iovN

array count

Definition at line 332 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 331 of file XrdHttpReq.hh.

Referenced by Data(), and reset().

keepalive

bool XrdHttpReq::keepalive

Definition at line 284 of file XrdHttpReq.hh.

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

length

long long XrdHttpReq::length

Definition at line 285 of file XrdHttpReq.hh.

Referenced by XrdHttpExtReq::XrdHttpExtReq(), XrdHttpReq(), parseLine(), ProcessHTTPReq(), 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 311 of file XrdHttpReq.hh.

{false};

Referenced by ProcessHTTPReq(), and reset().

m_appended_hdr2cgistr

bool XrdHttpReq::m_appended_hdr2cgistr

Definition at line 309 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 305 of file XrdHttpReq.hh.

Referenced by reset().

m_origin

std::string XrdHttpReq::m_origin

Definition at line 355 of file XrdHttpReq.hh.

Referenced by parseLine(), and reset().

m_req_cksum

XrdHttpChecksumHandler::XrdHttpChecksumRawPtr XrdHttpReq::m_req_cksum = nullptr

The checksum that was ran for this request.

Definition at line 298 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

m_req_digest

std::string XrdHttpReq::m_req_digest

The requested digest type.

Definition at line 295 of file XrdHttpReq.hh.

Referenced by parseLine(), 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 303 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

mScitag

int XrdHttpReq::mScitag

Definition at line 353 of file XrdHttpReq.hh.

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

opaque

XrdOucEnv* XrdHttpReq::opaque

The opaque data, after parsing.

Definition at line 268 of file XrdHttpReq.hh.

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

ralist

std::vector<readahead_list> XrdHttpReq::ralist

Definition at line 236 of file XrdHttpReq.hh.

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

readClosing

bool XrdHttpReq::readClosing

Definition at line 278 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 277 of file XrdHttpReq.hh.

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

redirdest

XrdOucString XrdHttpReq::redirdest

Definition at line 328 of file XrdHttpReq.hh.

Referenced by Redir(), and reset().

reqstate

int XrdHttpReq::reqstate

State machine to talk to the bridge.

Definition at line 348 of file XrdHttpReq.hh.

Referenced by ProcessHTTPReq(), and reset().

request

ReqType XrdHttpReq::request

The request we got.

Definition at line 258 of file XrdHttpReq.hh.

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

requestverb

std::string XrdHttpReq::requestverb

Definition at line 259 of file XrdHttpReq.hh.

Referenced by parseFirstLine().

resource

XrdOucString XrdHttpReq::resource

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

Definition at line 266 of file XrdHttpReq.hh.

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

resourceplusopaque

XrdOucString XrdHttpReq::resourceplusopaque

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

Definition at line 270 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 319 of file XrdHttpReq.hh.

rwOpPartialDone

unsigned int XrdHttpReq::rwOpPartialDone

Definition at line 319 of file XrdHttpReq.hh.

sendcontinue

bool XrdHttpReq::sendcontinue

Definition at line 287 of file XrdHttpReq.hh.

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

stringresp

std::string XrdHttpReq::stringresp

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

Definition at line 345 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 351 of file XrdHttpReq.hh.

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

xrderrcode

XErrorCode XrdHttpReq::xrderrcode

Definition at line 326 of file XrdHttpReq.hh.

Referenced by Error(), and reset().

xrdreq

ClientRequest XrdHttpReq::xrdreq

The last issued xrd request, often pending.

Definition at line 322 of file XrdHttpReq.hh.

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

xrdresp

XResponseType XrdHttpReq::xrdresp

The last response data we got.

Definition at line 325 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