XrdHttpProtocol.cc File Reference

#include "XrdVersion.hh"
#include "Xrd/XrdBuffer.hh"
#include "Xrd/XrdLink.hh"
#include "XProtocol/XProtocol.hh"
#include "XrdOuc/XrdOuca2x.hh"
#include "XrdOuc/XrdOucStream.hh"
#include "XrdOuc/XrdOucEnv.hh"
#include "XrdOuc/XrdOucGMap.hh"
#include "XrdSys/XrdSysE2T.hh"
#include "XrdSys/XrdSysTimer.hh"
#include "XrdOuc/XrdOucPinLoader.hh"
#include "XrdHttpTrace.hh"
#include "XrdHttpProtocol.hh"
#include <sys/stat.h>
#include "XrdHttpUtils.hh"
#include "XrdHttpSecXtractor.hh"
#include "XrdHttpExtHandler.hh"
#include "XrdTls/XrdTls.hh"
#include "XrdTls/XrdTlsContext.hh"
#include "XrdOuc/XrdOucUtils.hh"
#include "XrdOuc/XrdOucPrivateUtils.hh"
#include "XrdHttpCors/XrdHttpCors.hh"
#include <charconv>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <vector>
#include <arpa/inet.h>
#include <sstream>
#include <cctype>
#include <fcntl.h>
#include <algorithm>

Include dependency graph for XrdHttpProtocol.cc:

Go to the source code of this file.

Namespaces
namespace	XrdHttpProtoInfo

Macros
#define	HTTPS_ALERT(x, y, z)
#define	TRACELINK   lp
#define	TRACELINK   Link
#define	TRACELINK   Link
#define	TS_Xeq(x, m)   (!strcmp(x,var)) GoNo = m(Config)
#define	TS_Xeq3(x, m)   (!strcmp(x,var)) GoNo = m(Config, extHIVec)
#define	XRHTTP_TK_GRACETIME   600

Functions
void *	BIO_get_data (BIO *bio)
int	BIO_get_flags (BIO *bio)
int	BIO_get_init (BIO *bio)
int	BIO_get_shutdown (BIO *bio)
void	BIO_set_data (BIO *bio, void *ptr)
void	BIO_set_flags (BIO *bio, int flags)
void	BIO_set_init (BIO *bio, int init)
void	BIO_set_shutdown (BIO *bio, int shut)
static int	BIO_XrdLink_create (BIO *bio)
static long	BIO_XrdLink_ctrl (BIO *bio, int cmd, long num, void *ptr)
static int	BIO_XrdLink_destroy (BIO *bio)
static int	BIO_XrdLink_read (BIO *bio, char *data, size_t datal, size_t *read)
int	BIO_XrdLink_write (BIO *bio, const char *data, size_t datal, size_t *written)
static	XrdVERSIONINFODEF (compiledVer, XrdHttpProtocolTest, XrdVNUMBER, XrdVERSION)

Variables
static const int	XrdHttpProtoInfo::hsmAuto = -1
static const int	XrdHttpProtoInfo::hsmMan = 1
static const int	XrdHttpProtoInfo::hsmOff = 0
static const int	XrdHttpProtoInfo::hsmOn = 1
int	XrdHttpProtoInfo::httpsmode = hsmAuto
bool	XrdHttpProtoInfo::httpsspec = false
int	XrdHttpProtoInfo::tlsCache = XrdTlsContext::scOff
bool	XrdHttpProtoInfo::tlsClientAuth = true
XrdTlsContext *	XrdHttpProtoInfo::xrdctx = 0
bool	XrdHttpProtoInfo::xrdctxVer = false
const char *	XrdHttpSecEntityTident = "http"
XrdSysTrace	XrdHttpTrace ("http")

Macro Definition Documentation

HTTPS_ALERT

#define HTTPS_ALERT	(		x,
			y,
			z
	)

Value:

        httpsspec = true;\
        if (xrdctx && httpsmode == hsmAuto && (z || xrdctx->x509Verify())) \
        eDest.Say("Config http." x " overrides the xrd." y " directive.")

Definition at line 988 of file XrdHttpProtocol.cc.

                                                                  {
  XrdOucEnv cfgEnv;
  XrdOucStream Config(&eDest, getenv("XRDINSTANCE"), &cfgEnv, "=====> ");
  std::vector<extHInfo> extHIVec;
  char *var;
  int cfgFD, GoNo, NoGo = 0, ismine;
 
  var = nullptr;
  XrdOucEnv::Import("XRD_READV_LIMITS", var);
  XrdHttpReadRangeHandler::Configure(eDest, var, ReadRangeConfig);
 
  pmarkHandle = (XrdNetPMark* ) myEnv->GetPtr("XrdNetPMark*");
 
  cksumHandler.configure(xrd_cslist);
  auto nonIanaChecksums = cksumHandler.getNonIANAConfiguredCksums();
  if(nonIanaChecksums.size()) {
      std::stringstream warningMsgSS;
      warningMsgSS << "Config warning: the following checksum algorithms are not IANA compliant: [";
      std::string unknownCksumString;
      for(auto unknownCksum: nonIanaChecksums) {
          unknownCksumString += unknownCksum + ",";
      }
      unknownCksumString.erase(unknownCksumString.size() - 1);
      warningMsgSS << unknownCksumString << "]" << ". They therefore cannot be queried by a user via HTTP." ;
      eDest.Say(warningMsgSS.str().c_str());
  }
 
  // Initialize our custom BIO type.
  if (!m_bio_type) {
 
    #if OPENSSL_VERSION_NUMBER < 0x10100000L
      m_bio_type = (26|0x0400|0x0100);
      m_bio_method = static_cast<BIO_METHOD*>(OPENSSL_malloc(sizeof(BIO_METHOD)));
 
      if (m_bio_method) {
        memset(m_bio_method, '\0', sizeof(BIO_METHOD));
        m_bio_method->type = m_bio_type;
        m_bio_method->bwrite = BIO_XrdLink_write;
        m_bio_method->bread = BIO_XrdLink_read;
        m_bio_method->create = BIO_XrdLink_create;
        m_bio_method->destroy = BIO_XrdLink_destroy;
        m_bio_method->ctrl = BIO_XrdLink_ctrl;
      }
    #else
      // OpenSSL 1.1 has an internal counter for generating unique types.
      // We'll switch to that when widely available.
      m_bio_type = BIO_get_new_index();
      m_bio_method = BIO_meth_new(m_bio_type, "xrdhttp-bio-method");
      
      if (m_bio_method) {
        BIO_meth_set_write(m_bio_method, BIO_XrdLink_write);
        BIO_meth_set_read(m_bio_method, BIO_XrdLink_read);
        BIO_meth_set_create(m_bio_method, BIO_XrdLink_create);
        BIO_meth_set_destroy(m_bio_method, BIO_XrdLink_destroy);
        BIO_meth_set_ctrl(m_bio_method, BIO_XrdLink_ctrl);
      }
      
    #endif
  }
 
  // If we have a tls context record whether it configured for verification
  // so that we can provide meaningful error and warning messages.
  //
  xrdctxVer = xrdctx && xrdctx->x509Verify();
 
  // Open and attach the config file
  //
  if ((cfgFD = open(ConfigFN, O_RDONLY, 0)) < 0)
    return eDest.Emsg("Config", errno, "open config file", ConfigFN);
  Config.Attach(cfgFD);
  static const char *cvec[] = { "*** http protocol config:", 0 };
  Config.Capture(cvec);
 
  // Process items
  //
  while ((var = Config.GetMyFirstWord())) {
    if ((ismine = !strncmp("http.", var, 5)) && var[5]) var += 5;
 
    if (ismine) {
           if TS_Xeq("trace", xtrace);
      else if TS_Xeq("cert", xsslcert);
      else if TS_Xeq("key", xsslkey);
      else if TS_Xeq("cadir", xsslcadir);
      else if TS_Xeq("cipherfilter", xsslcipherfilter);
      else if TS_Xeq("gridmap", xgmap);
      else if TS_Xeq("cafile", xsslcafile);
      else if TS_Xeq("secretkey", xsecretkey);
      else if TS_Xeq("desthttps", xdesthttps);
      else if TS_Xeq("secxtractor", xsecxtractor);
      else if TS_Xeq("cors", xcors);
      else if TS_Xeq3("exthandler", xexthandler);
      else if TS_Xeq("selfhttps2http", xselfhttps2http);
      else if TS_Xeq("embeddedstatic", xembeddedstatic);
      else if TS_Xeq("listingredir", xlistredir);
      else if TS_Xeq("staticredir", xstaticredir);
      else if TS_Xeq("staticpreload", xstaticpreload);
      else if TS_Xeq("staticheader", xstaticheader);
      else if TS_Xeq("listingdeny", xlistdeny);
      else if TS_Xeq("header2cgi", xheader2cgi);
      else if TS_Xeq("httpsmode", xhttpsmode);
      else if TS_Xeq("tlsreuse", xtlsreuse);
      else if TS_Xeq("auth", xauth);
      else if TS_Xeq("tlsclientauth", xtlsclientauth);
      else if TS_Xeq("maxdelay", xmaxdelay);
      else {
        eDest.Say("Config warning: ignoring unknown directive '", var, "'.");
        Config.Echo();
        continue;
      }
      if (GoNo) {
        Config.Echo();
        NoGo = 1;
      }
    }
  }
 
// To minimize message confusion down, if an error occurred during config
// parsing, just bail out now with a confirming message.
//
   if (NoGo)
      {eDest.Say("Config failure: one or more directives are flawed!");
       return 1;
      }
 
// Some headers must always be converted to CGI key=value pairs
//
   hdr2cgimap["Cache-Control"] = "cache-control";
 
// Test if XrdEC is loaded
   if (getenv("XRDCL_EC")) usingEC = true;
 
// Pre-compute the static headers
//
  const auto default_verb = m_staticheader_map.find("");
  std::string default_static_headers;
  if (default_verb != m_staticheader_map.end()) {
    for (const auto &header_entry : default_verb->second) {
      default_static_headers += header_entry.first + ": " + header_entry.second + "\r\n";
    }
  }
  m_staticheaders[""] = default_static_headers;
  for (const auto &item : m_staticheader_map) {
    if (item.first.empty()) {
      continue; // Skip default case; already handled
    }
    auto headers = default_static_headers;
    for (const auto &header_entry : item.second) {
      headers += header_entry.first + ": " + header_entry.second + "\r\n";
    }
 
    m_staticheaders[item.first] = headers;
  }
 
// Test if this is a caching server
//
   if (myEnv->Get("XrdCache")) hasCache = true;
 
   // Load CORS plugin if configured
   if(xrdcorsLibPath.size()) {
     if(LoadCorsHandler(&eDest, xrdcorsLibPath.c_str()) != 0) {
       return 1;
     }
     if (xrdcors->Configure(ConfigFN, &eDest) != 0) {
       return 1;
     }
   }
 
// If https was disabled, then issue a warning message if xrdtls configured
// of it's disabled because httpsmode was auto and xrdtls was not configured.
// If we get past this point then we know https is a plausible option but we
// can still fail if we cannot supply any missing but required options.
//
   if (httpsmode == hsmOff || (httpsmode == hsmAuto && !xrdctx && !httpsspec))
      {const char *why = (httpsmode == hsmOff ? "has been disabled!"
                         : "was not configured.");
       const char *what = Configed();
 
       eDest.Say("Config warning: HTTPS functionality ", why);
       httpsmode = hsmOff;
 
       LoadExtHandlerNoTls(extHIVec, ConfigFN, *myEnv);
       if (what)
          {eDest.Say("Config failure: ", what, " HTTPS but it ", why);
           NoGo = 1;
          }
       return NoGo;
      }
 
// Warn if a private key was specified without a cert as this has no meaning
// even as an auto overide as they must be paired.
//
   if (sslkey && !sslcert)
      {eDest.Say("Config warning: specifying http.key without http.cert "
                 "is meaningless; ignoring key!");
       free(sslkey); sslkey = 0;
      }
 
// If the mode is manual then we need to have at least a cert.
//
   if (httpsmode == hsmMan)
      {if (!sslcert)
          {eDest.Say("Config failure: 'httpsmode manual' requires atleast a "
                     "a cert specification!");
           return 1;
          }
      }
 
// If it's auto d through all possibilities. It's either auto with xrdtls
// configured or manual which needs at least a cert specification. For auto
// configuration we will only issue a warning if overrides were specified.
//
   if (httpsmode == hsmAuto && xrdctx)
      {const XrdTlsContext::CTX_Params *cP = xrdctx->GetParams();
       const char *what1 = 0, *what2 = 0, *what3 = 0;
 
       if (!sslcert && cP->cert.size())
          {sslcert = strdup(cP->cert.c_str());
           if (cP->pkey.size()) sslkey  = strdup(cP->pkey.c_str());
           what1 = "xrd.tls to supply 'cert' and 'key'.";
          }
       if (!sslcadir && cP->cadir.size())
          {sslcadir  = strdup(cP->cadir.c_str());
           what2 = "xrd.tlsca to supply 'cadir'.";
          }
       if (!sslcafile && cP->cafile.size())
          {sslcafile = strdup(cP->cafile.c_str());
           what2 = (what2 ? "xrd.tlsca to supply 'cadir' and 'cafile'."
                          : "xrd.tlsca to supply 'cafile'.");
          }
       if(cP->crlRT != XrdTlsContext::DEFAULT_CRL_REF_INT_SEC) {
           crlRefIntervalSec = cP->crlRT;
           what3 = "xrd.tlsca to supply 'refresh' interval.";
       }
       if (!httpsspec && what1) eDest.Say("Config Using ", what1);
       if (!httpsspec && what2) eDest.Say("Config Using ", what2);
       if (!httpsspec && what3) eDest.Say("Config Using ", what3);
      }
 
// If a gridmap or secxtractor is present then we must be able to verify certs
//
   if (!(sslcadir || sslcafile))
      {const char *what = Configed();
       const char *why  = (httpsspec ? "a cadir or cafile was not specified!"
                                     : "'xrd.tlsca noverify' was specified!");
       if (what)
          {eDest.Say("Config failure: ", what, " cert verification but ", why);
           return 1;
          }
      }
   httpsmode = hsmOn;
 
// Oddly we need to create an error bio at this point
//
   sslbio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
 
// Now we can configure HTTPS. We will not reuse the passed context as we will
// be setting our own options specific to out implementation. One day we will.
//
   const char *how = "completed.";
   eDest.Say("++++++ HTTPS initialization started.");
   if (!InitTLS()) {NoGo = 1; how = "failed.";}
   eDest.Say("------ HTTPS initialization ", how);
   if (NoGo) return NoGo;
 
// We can now load all the external handlers
//
   if (LoadExtHandler(extHIVec, ConfigFN, *myEnv)) return 1;
 
// At this point, we can actually initialize security plugins
//
   return (InitSecurity() ? NoGo : 1);
}
 
/******************************************************************************/
/*                              C o n f i g e d                               */
/******************************************************************************/
 
const char *XrdHttpProtocol::Configed()
{
   if (secxtractor && gridmap) return "gridmap and secxtractor require";
   if (secxtractor) return "secxtractor requires";
   if (gridmap) return "gridmap requires";
   return 0;
}
  
/******************************************************************************/
/*                           B u f f g e t L i n e                            */
/******************************************************************************/
  
 
int XrdHttpProtocol::BuffgetLine(XrdOucString &dest) {
 
  dest = "";
  char save;
 
  // Easy case
  if (myBuffEnd >= myBuffStart) {
    int l = 0;
    for (char *p = myBuffStart; p < myBuffEnd; p++) {
      l++;
      if (*p == '\n') {
        save = *(p+1);
        *(p+1) = '\0';
        dest.assign(myBuffStart, 0, l-1);
        *(p+1) = save;
 
        //strncpy(dest, myBuffStart, l);
        //dest[l] = '\0';
        BuffConsume(l);
 
        //if (dest[l-1] == '\n') dest[l - 1] = '\0';
        return l;
      }
 
    }
 
    return 0;
  } else {
    // More complex case... we have to do it in two segments
 
    // Segment 1: myBuffStart->myBuff->buff+myBuff->bsize
    int l = 0;
    for (char *p = myBuffStart; p < myBuff->buff + myBuff->bsize; p++) {
      l++;
      if ((*p == '\n') || (*p == '\0')) {
        save = *(p+1);
        *(p+1) = '\0';
        dest.assign(myBuffStart, 0, l-1);
        *(p+1) = save;
 
        //strncpy(dest, myBuffStart, l);
 
        BuffConsume(l);
 
        //if (dest[l-1] == '\n') dest[l - 1] = '\0';
        return l;
      }
 
    }
 
    // We did not find the \n, let's keep on searching in the 2nd segment
    // Segment 2: myBuff->buff --> myBuffEnd
    l = 0;
    for (char *p = myBuff->buff; p < myBuffEnd; p++) {
      l++;
      if ((*p == '\n') || (*p == '\0')) {
        save = *(p+1);
        *(p+1) = '\0';
        // Remember the 1st segment
        int l1 = myBuff->buff + myBuff->bsize - myBuffStart;
 
        dest.assign(myBuffStart, 0, l1-1);
        //strncpy(dest, myBuffStart, l1);
        BuffConsume(l1);
 
        dest.insert(myBuffStart, l1, l-1);
        //strncpy(dest + l1, myBuffStart, l);
        //dest[l + l1] = '\0';
        BuffConsume(l);
 
        *(p+1) = save;
 
        //if (dest[l + l1 - 1] == '\n') dest[l + l1 - 1] = '\0';
        return l + l1;
      }
 
    }
 
 
 
  }
 
  return 0;
}
 
/******************************************************************************/
/*                        g e t D a t a O n e S h o t                         */
/******************************************************************************/
  
int XrdHttpProtocol::getDataOneShot(int blen, bool wait) {
  int rlen, maxread;
 
  // Get up to blen bytes from the connection. Put them into mybuff.
  // This primitive, for the way it is used, is not supposed to block if wait=false
 
  // Returns:
  // 2: no space left in buffer
  // 1: timeout
  // -1: error
  // 0: everything read correctly
 
 
 
  // Check for buffer overflow first
  maxread = std::min(blen, BuffAvailable());
  TRACE(DEBUG, "getDataOneShot BuffAvailable: " << BuffAvailable() << " maxread: " << maxread);
 
  if (!maxread)
    return 2;
 
  if (ishttps) {
    int sslavail = maxread;
 
    if (!wait) {
      int l = SSL_pending(ssl);
      if (l > 0)
        sslavail = std::min(maxread, SSL_pending(ssl));
    }
 
    if (sslavail < 0) {
      Link->setEtext("link SSL_pending error");
      ERR_print_errors(sslbio_err);
      return -1;
    }
 
    TRACE(DEBUG, "getDataOneShot sslavail: " << sslavail);
    if (sslavail <= 0) return 0;
 
    if (myBuffEnd - myBuff->buff >= myBuff->bsize) {
      TRACE(DEBUG, "getDataOneShot Buffer panic");
      myBuffEnd = myBuff->buff;
    }
 
    rlen = SSL_read(ssl, myBuffEnd, sslavail);
    if (rlen <= 0) {
      Link->setEtext("link SSL read error");
      ERR_print_errors(sslbio_err);
      return -1;
    }
 
 
  } else {
 
    if (myBuffEnd - myBuff->buff >= myBuff->bsize) {
      TRACE(DEBUG, "getDataOneShot Buffer panic");
      myBuffEnd = myBuff->buff;
    }
 
    if (wait)
      rlen = Link->Recv(myBuffEnd, maxread, readWait);
    else
      rlen = Link->Recv(myBuffEnd, maxread);
 
 
    if (rlen == 0) {
      Link->setEtext("link read error or closed");
      return -1;
    }
 
    if (rlen < 0) {
      Link->setEtext("link timeout or other error");
      return -1;
    }
  }
 
  myBuffEnd += rlen;
 
  TRACE(REQ, "read " << rlen << " of " << blen << " bytes");
 
  return 0;
}
 
 
int XrdHttpProtocol::BuffAvailable() {
  int r;
 
  if (myBuffEnd >= myBuffStart)
    r = myBuff->buff + myBuff->bsize - myBuffEnd;
  else
    r = myBuffStart - myBuffEnd;
 
  if ((r < 0) || (r > myBuff->bsize)) {
    TRACE(REQ, "internal error, myBuffAvailable: " << r << " myBuff->bsize " << myBuff->bsize);
    abort();
  }
 
  return r;
}
 
/******************************************************************************/
/*                              B u f f U s e d                               */
/******************************************************************************/
  
 
int XrdHttpProtocol::BuffUsed() {
  int r;
 
  if (myBuffEnd >= myBuffStart)
    r = myBuffEnd - myBuffStart;
  else
 
    r = myBuff->bsize - (myBuffStart - myBuffEnd);
 
  if ((r < 0) || (r > myBuff->bsize)) {
    TRACE(REQ, "internal error, myBuffUsed: " << r << " myBuff->bsize " << myBuff->bsize);
    abort();
  }
 
  return r;
}
 
/******************************************************************************/
/*                              B u f f F r e e                               */
/******************************************************************************/
  
 
int XrdHttpProtocol::BuffFree() {
  return (myBuff->bsize - BuffUsed());
}
 
/******************************************************************************/
/*                           B u f f C o n s u m e                            */
/******************************************************************************/
  
void XrdHttpProtocol::BuffConsume(int blen) {
 
  if (blen > myBuff->bsize) {
    TRACE(REQ, "internal error, BuffConsume(" << blen << ") smaller than buffsize");
    abort();
  }
 
  if (blen > BuffUsed()) {
    TRACE(REQ, "internal error, BuffConsume(" << blen << ") larger than BuffUsed:" << BuffUsed());
    abort();
  }
 
  myBuffStart = myBuffStart + blen;
 
  if (myBuffStart >= myBuff->buff + myBuff->bsize)
    myBuffStart -= myBuff->bsize;
 
  if (myBuffEnd >= myBuff->buff + myBuff->bsize)
    myBuffEnd -= myBuff->bsize;
 
  if (BuffUsed() == 0)
    myBuffStart = myBuffEnd = myBuff->buff;
}
 
/******************************************************************************/
/*                           B u f f g e t D a t a                            */
/******************************************************************************/
  
int XrdHttpProtocol::BuffgetData(int blen, char **data, bool wait) {
  int rlen;
 
  TRACE(DEBUG, "BuffgetData: requested " << blen << " bytes");
 
 
  if (wait) {
    // If there's not enough data in the buffer then wait on the socket until it comes
    if  (blen > BuffUsed()) {
      TRACE(REQ, "BuffgetData: need to read " << blen - BuffUsed() << " bytes");
      if ( getDataOneShot(blen - BuffUsed(), true) )
        // The wanted data could not be read. Either timeout of connection closed
        return 0;
    }
  } else {
    // Get a peek at the socket, without waiting, if we have no data in the buffer
    if ( !BuffUsed() ) {
      if ( getDataOneShot(blen, false) )
        // The wanted data could not be read. Either timeout of connection closed
        return -1;
    }
  }
 
  // And now make available the data taken from the buffer. Note that the buffer
  // may be empty...
  if (myBuffStart <= myBuffEnd) {
    rlen = std::min( (long) blen, (long)(myBuffEnd - myBuffStart) );
 
  } else
    rlen = std::min( (long) blen, (long)(myBuff->buff + myBuff->bsize - myBuffStart) );
 
  *data = myBuffStart;
  BuffConsume(rlen);
  return rlen;
}
 
/******************************************************************************/
/*                              S e n d D a t a                               */
/******************************************************************************/
  
 
int XrdHttpProtocol::SendData(const char *body, int bodylen) {
 
  int r;
 
  if (body && bodylen) {
    TRACE(REQ, "Sending " << bodylen << " bytes");
    if (ishttps) {
      r = SSL_write(ssl, body, bodylen);
      if (r <= 0) {
        ERR_print_errors(sslbio_err);
        return -1;
      }
 
    } else {
      r = Link->Send(body, bodylen);
      if (r <= 0) return -1;
    }
  }
 
  return 0;
}
 
/******************************************************************************/
/*                       S t a r t S i m p l e R e s p                        */
/******************************************************************************/
 
int XrdHttpProtocol::StartSimpleResp(int code, const char *desc,
                                     const char *header_to_add,
                                     long long bodylen, bool keepalive) {
  static const std::unordered_map<int, std::string> statusTexts = {
      {100, "Continue"},
      {200, "OK"},
      {201, "Created"},
      {206, "Partial Content"},
      {302, "Redirect"},
      {307, "Temporary Redirect"},
      {400, "Bad Request"},
      {401, "Unauthorized"},
      {403, "Forbidden"},
      {404, "Not Found"},
      {405, "Method Not Allowed"},
      {409, "Conflict"},
      {416, "Range Not Satisfiable"},
      {423, "Locked"},
      {500, "Internal Server Error"},
      {502, "Bad Gateway"},
      {504, "Gateway Timeout"},
      {507, "Insufficient Storage"}};
 
  std::stringstream ss;
  const std::string crlf = "\r\n";
 
  ss << "HTTP/1.1 " << code << " ";
 
  if (desc) {
    ss << desc;
  } else {
    auto it = statusTexts.find(code);
    if (it != statusTexts.end()) {
      ss << it->second;
    } else {
      ss << "Unknown";
    }
  }
  ss << crlf;
 
  if (keepalive && (code != 100))
    ss << "Connection: Keep-Alive" << crlf;
  else
    ss << "Connection: Close" << crlf;
 
  ss << "Server: XrootD/" << XrdVSTRING << crlf;
 
  const auto iter = m_staticheaders.find(CurrentReq.requestverb);
  if (iter != m_staticheaders.end()) {
    ss << iter->second;
  } else {
    ss << m_staticheaders[""];
  }
 
  if(xrdcors) {
    auto corsAllowOrigin = xrdcors->getCORSAllowOriginHeader(CurrentReq.m_origin);
    if(corsAllowOrigin) {
      ss << *corsAllowOrigin << crlf;
    }
  }
 
  if ((bodylen >= 0) && (code != 100))
    ss << "Content-Length: " << bodylen << crlf;
 
  if (header_to_add && (header_to_add[0] != '\0')) ss << header_to_add << crlf;
 
  ss << crlf;
 
  const std::string &outhdr = ss.str();
  TRACEI(RSP, "Sending resp: " << code << " header len:" << outhdr.size());
  if (SendData(outhdr.c_str(), outhdr.size()))
   return -1;
 
  return 0;
}
 
/******************************************************************************/
/*                      S t a r t C h u n k e d R e s p                       */
/******************************************************************************/
  
int XrdHttpProtocol::StartChunkedResp(int code, const char *desc, const char *header_to_add, long long bodylen, bool keepalive) {
  const std::string crlf = "\r\n";
  std::stringstream ss;
 
  if (header_to_add && (header_to_add[0] != '\0')) {
    ss << header_to_add << crlf;
  }
 
  ss << "Transfer-Encoding: chunked";
  TRACEI(RSP, "Starting chunked response");
  return StartSimpleResp(code, desc, ss.str().c_str(), bodylen, keepalive);
}
 
/******************************************************************************/
/*                             C h u n k R e s p                              */
/******************************************************************************/
  
int XrdHttpProtocol::ChunkResp(const char *body, long long bodylen) {
  long long content_length = (bodylen <= 0) ? (body ? strlen(body) : 0) : bodylen;
  if (ChunkRespHeader(content_length))
    return -1;
 
  if (body && SendData(body, content_length))
    return -1;
 
  return ChunkRespFooter();
}
 
/******************************************************************************/
/*                       C h u n k R e s p H e a d e r                        */
/******************************************************************************/
 
int XrdHttpProtocol::ChunkRespHeader(long long bodylen) {
  const std::string crlf = "\r\n";
  std::stringstream ss;
 
  ss << std::hex << bodylen << std::dec << crlf;
 
  const std::string &chunkhdr = ss.str();
  TRACEI(RSP, "Sending encoded chunk of size " << bodylen);
  return (SendData(chunkhdr.c_str(), chunkhdr.size())) ? -1 : 0;
}
 
/******************************************************************************/
/*                       C h u n k R e s p F o o t e r                        */
/******************************************************************************/
 
int XrdHttpProtocol::ChunkRespFooter() {
  const std::string crlf = "\r\n";
  return (SendData(crlf.c_str(), crlf.size())) ? -1 : 0;
}
 
/******************************************************************************/
/*                        S e n d S i m p l e R e s p                         */
/******************************************************************************/
  
 
int XrdHttpProtocol::SendSimpleResp(int code, const char *desc, const char *header_to_add, const char *body, long long bodylen, bool keepalive) {
 
  long long content_length = bodylen;
  if (bodylen <= 0) {
    content_length = body ? strlen(body) : 0;
  }
 
  if (StartSimpleResp(code, desc, header_to_add, content_length, keepalive) < 0)
    return -1;
 
  //
  // Send the data
  //
  if (body)
    return SendData(body, content_length);
 
  return 0;
}
 
/******************************************************************************/
/*                             C o n f i g u r e                              */
/******************************************************************************/
  
int XrdHttpProtocol::Configure(char *parms, XrdProtocol_Config * pi) {
  /*
    Function: Establish configuration at load time.
 
    Input:    None.
 
    Output:   0 upon success or !0 otherwise.
   */
 
  char *rdf;
 
  // Copy out the special info we want to use at top level
  //
  eDest.logger(pi->eDest->logger());
  XrdHttpTrace.SetLogger(pi->eDest->logger());
  //  SI = new XrdXrootdStats(pi->Stats);
  Sched = pi->Sched;
  BPool = pi->BPool;
  xrd_cslist = getenv("XRD_CSLIST");
 
  Port = pi->Port;
 
  // Copy out the current TLS context
  //
  xrdctx = pi->tlsCtx;
 
  {
    char buf[16];
    sprintf(buf, "%d", Port);
    Port_str = strdup(buf);
  }
 
  // Now process and configuration parameters
  //
  rdf = (parms && *parms ? parms : pi->ConfigFN);
  if (rdf && Config(rdf, pi->theEnv)) return 0;
  if (pi->DebugON) XrdHttpTrace.What = TRACE_ALL;
 
  // Set the redirect flag if we are a pure redirector
  myRole = kXR_isServer;
  if ((rdf = getenv("XRDROLE"))) {
      eDest.Emsg("Config", "XRDROLE: ", rdf);
 
      if (!strcasecmp(rdf, "manager") || !strcasecmp(rdf, "supervisor")) {
        myRole = kXR_isManager;
        eDest.Emsg("Config", "Configured as HTTP(s) redirector.");
      } else {
 
        eDest.Emsg("Config", "Configured as HTTP(s) data server.");
      }
 
  } else {
    eDest.Emsg("Config", "No XRDROLE specified.");
  }
 
  // Schedule protocol object cleanup
  //
  ProtStack.Set(pi->Sched, &XrdHttpTrace,
                (XrdHttpTrace.What & TRACE_MEM ? TRACE_MEM : 0));
  ProtStack.Set((pi->ConnMax / 3 ? pi->ConnMax / 3 : 30), 60 * 60);
 
  // Return success
  //
 
  return 1;
}
 
/******************************************************************************/
/*                   p a r s e H e a d e r 2 C G I                            */
/******************************************************************************/
int XrdHttpProtocol::parseHeader2CGI(XrdOucStream &Config, XrdSysError & err,std::map<std::string, std::string> &header2cgi) {
  char *val, keybuf[1024], parmbuf[1024];
  char *parm;
 
  // Get the header key
  val = Config.GetWord();
  if (!val || !val[0]) {
    err.Emsg("Config", "No headerkey specified.");
    return 1;
  } else {
 
    // Trim the beginning, in place
    while ( *val && !isalnum(*val) ) val++;
    strcpy(keybuf, val);
 
    // Trim the end, in place
    char *pp;
    pp = keybuf + strlen(keybuf) - 1;
    while ( (pp >= keybuf) && (!isalnum(*pp)) ) {
      *pp = '\0';
      pp--;
    }
 
    parm = Config.GetWord();
 
    // Avoids segfault in case a key is given without value
    if(!parm || !parm[0]) {
      err.Emsg("Config", "No header2cgi value specified. key: '", keybuf, "'");
      return 1;
    }
 
    // Trim the beginning, in place
    while ( *parm && !isalnum(*parm) ) parm++;
    strcpy(parmbuf, parm);
 
    // Trim the end, in place
    pp = parmbuf + strlen(parmbuf) - 1;
    while ( (pp >= parmbuf) && (!isalnum(*pp)) ) {
      *pp = '\0';
      pp--;
    }
 
    // Add this mapping to the map that will be used
    try {
      header2cgi[keybuf] = parmbuf;
    } catch ( ... ) {
      err.Emsg("Config", "Can't insert new header2cgi rule. key: '", keybuf, "'");
      return 1;
    }
 
  }
  return 0;
}
 
 
/******************************************************************************/
/*                               I n i t T L S                                */
/******************************************************************************/
  
bool XrdHttpProtocol::InitTLS() {
 
   std::string eMsg;
   uint64_t opts = XrdTlsContext::servr | XrdTlsContext::logVF |
                   XrdTlsContext::artON | XrdTlsContext::rfCRL;
 
// Create a new TLS context
//
   if (sslverifydepth > 255) sslverifydepth = 255;
   opts = TLS_SET_VDEPTH(opts, sslverifydepth);
   //TLS_SET_REFINT will set the refresh interval in minutes, hence the division by 60
   opts = TLS_SET_REFINT(opts, crlRefIntervalSec/60);
   xrdctx = new XrdTlsContext(sslcert,sslkey,sslcadir,sslcafile,opts,&eMsg);
 
// Make sure the context was created
//
   if (!xrdctx->isOK())
      {eDest.Say("Config failure: ", eMsg.c_str());
       return false;
      }
 
// Setup session cache (this is controversial). The default is off but many
// programs expect it being enabled and break when it is disabled. In such
// cases it should be enabled. This is, of course, a big OpenSSL mess.
//
   static const char *sess_ctx_id = "XrdHTTPSessionCtx";
   unsigned int n =(unsigned int)(strlen(sess_ctx_id)+1);
   xrdctx->SessionCache(tlsCache, sess_ctx_id, n);
 
// Set special ciphers if so specified.
//
   if (sslcipherfilter && !xrdctx->SetContextCiphers(sslcipherfilter))
      {eDest.Say("Config failure: ", "Unable to set allowable https ciphers!");
       return false;
      }
 
// Enable or disable the config in the context
   xrdctx->SetTlsClientAuth(tlsClientAuth);
 
// All done
//
   return true;
}
 
/******************************************************************************/
/*                               C l e a n u p                                */
/******************************************************************************/
  
void XrdHttpProtocol::Cleanup() {
 
  TRACE(ALL, " Cleanup");
 
  if (BPool && myBuff) {
    BuffConsume(BuffUsed());
    BPool->Release(myBuff);
    myBuff = 0;
  }
 
  if (ssl) {
    // Shutdown the SSL/TLS connection
    // This triggers a bidirectional shutdown of the connection; the bidirectional
    // shutdown is useful to ensure that the client receives the server response;
    // a one-sided shutdown can result in the server sending a TCP reset packet, zapping
    // the contents of the TCP socket buffer on the client side.  The HTTP 1.1 RFC has a
    // description of why this is important:
    //   https://datatracker.ietf.org/doc/html/rfc9112#name-tls-connection-closure
    // Once we get the clean SSL shutdown message back from the client, we know that
    // the client has received the response and we can safely close the connection.
    int ret = SSL_shutdown(ssl);
    if (ret != 1) {
        if(ret == 0) {
            // ret == 0, the unidirectional shutdown was successful; wait for the acknowledgement.
            ret = SSL_shutdown(ssl);
            if (ret != 1) {
                TRACE(ALL, "SSL server failed to receive the SSL shutdown message from the client");
                ERR_print_errors(sslbio_err);
            }
        } else {
            //ret < 0, an error really happened.
            TRACE(ALL, "SSL server failed to send the shutdown message to the client");
            ERR_print_errors(sslbio_err);
        }
    }
 
    if (secxtractor)
        secxtractor->FreeSSL(ssl);
 
    SSL_free(ssl);
 
  }
 
 
  ssl = 0;
  sbio = 0;
 
  if (SecEntity.caps) free(SecEntity.caps);
  if (SecEntity.grps) free(SecEntity.grps);
  if (SecEntity.endorsements) free(SecEntity.endorsements);
  if (SecEntity.vorg) free(SecEntity.vorg);
  if (SecEntity.role) free(SecEntity.role);
  if (SecEntity.name) free(SecEntity.name);
  if (SecEntity.host) free(SecEntity.host);
  if (SecEntity.moninfo) free(SecEntity.moninfo);
 
  SecEntity.Reset();
 
  if (Addr_str) free(Addr_str);
  Addr_str = 0;
}
 
/******************************************************************************/
/*                                 R e s e t                                  */
/******************************************************************************/
  
void XrdHttpProtocol::Reset() {
 
  TRACE(ALL, " Reset");
  Link = 0;
  CurrentReq.reset();
  CurrentReq.reqstate = 0;
 
  if (myBuff) {
    BPool->Release(myBuff);
    myBuff = 0;
  }
  myBuffStart = myBuffEnd = 0;
 
  DoingLogin = false;
  DoneSetInfo = false;
 
  ResumeBytes = 0;
  Resume = 0;
 
  //
  //  numReads = 0;
  //  numReadP = 0;
  //  numReadV = 0;
  //  numSegsV = 0;
  //  numWrites = 0;
  //  numFiles = 0;
  //  cumReads = 0;
  //  cumReadV = 0;
  //  cumSegsV = 0;
  //  cumWrites = 0;
  //  totReadP = 0;
 
  SecEntity.Reset();
  SecEntity.tident = XrdHttpSecEntityTident;
  ishttps = false;
  ssldone = false;
 
  Bridge = 0;
  ssl = 0;
  sbio = 0;
 
}
 
/******************************************************************************/
/*                            x h t t p s m o d e                             */
/******************************************************************************/
 
/* Function: xhttpsmode
 
   Purpose:  To parse the directive: httpsmode {auto | disable | manual}
 
             auto      configure https if configured in xrd framework.
             disable   do not configure https no matter what
             manual    configure https and ignore the xrd framework
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xhttpsmode(XrdOucStream & Config) {
  char *val;
 
  // Get the val
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "httpsmode parameter not specified");
    return 1;
  }
 
  // Record the val
  //
       if (!strcmp(val, "auto"))    httpsmode = hsmAuto;
  else if (!strcmp(val, "disable")) httpsmode = hsmOff;
  else if (!strcmp(val, "manual"))  httpsmode = hsmMan;
  else {eDest.Emsg("Config", "invalid httpsmode parameter - ", val);
        return 1;
       }
  return 0;
}
 
/******************************************************************************/
/*                   x s s l v e r i f y d e p t h                            */
/******************************************************************************/
 
/* Function: xsslverifydepth
 
   Purpose:  To parse the directive: sslverifydepth <depth>
 
             <depth>   the max depth of the ssl cert verification
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsslverifydepth(XrdOucStream & Config) {
  char *val;
 
  // Get the val
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "sslverifydepth value not specified");
    return 1;
  }
 
  // Record the val
  //
  sslverifydepth = atoi(val);
 
  if (xrdctxVer){ HTTPS_ALERT("verifydepth","tlsca",false); }
  return 0;
}
 
/******************************************************************************/
/*                                 x s s l c e r t                            */
/******************************************************************************/
 
/* Function: xsslcert
 
   Purpose:  To parse the directive: sslcert <path>
 
             <path>    the path of the server certificate to be used.
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsslcert(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "HTTP X509 certificate not specified");
    return 1;
  }
 
  // Record the path
  //
  if (sslcert) free(sslcert);
  sslcert = strdup(val);
 
  // If we have an xrd context issue reminder
  //
  HTTPS_ALERT("cert","tls",true);
  return 0;
}
 
/******************************************************************************/
/*                                 x s s l k e y                              */
/******************************************************************************/
 
/* Function: xsslkey
 
   Purpose:  To parse the directive: sslkey <path>
 
             <path>    the path of the server key to be used.
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsslkey(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "HTTP X509 key not specified");
    return 1;
  }
 
  // Record the path
  //
  if (sslkey) free(sslkey);
  sslkey = strdup(val);
 
  HTTPS_ALERT("key","tls",true);
  return 0;
}
 
/******************************************************************************/
/*                                     x g m a p                              */
/******************************************************************************/
 
/* Function: xgmap
 
   Purpose:  To parse the directive: gridmap [required] [compatNameGeneration] <path>
 
     required   optional parameter which if present treats any grimap errors
                as fatal.
     <path>     the path of the gridmap file to be used. Normally it's
                /etc/grid-security/gridmap. No mapfile means no translation
                required. Pointing to a non existing mapfile is an error.
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xgmap(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "HTTP X509 gridmap file location not specified");
    return 1;
  }
 
  // Handle optional parameter "required"
  //
  if (!strncmp(val, "required", 8)) {
    isRequiredGridmap = true;
    val = Config.GetWord();
 
    if (!val || !val[0]) {
      eDest.Emsg("Config", "HTTP X509 gridmap file missing after [required] "
                 "parameter");
      return 1;
    }
  }
 
  // Handle optional parameter "compatNameGeneration"
  //
  if (!strcmp(val, "compatNameGeneration")) {
    compatNameGeneration = true;
    val = Config.GetWord();
    if (!val || !val[0]) {
      eDest.Emsg("Config", "HTTP X509 gridmap file missing after "
                 "[compatNameGeneration] parameter");
      return 1;
    }
  }
 
 
  // Record the path
  //
  if (gridmap) free(gridmap);
  gridmap = strdup(val);
  return 0;
}
 
/******************************************************************************/
/*                                 x s s l c a f i l e                        */
/******************************************************************************/
 
/* Function: xsslcafile
 
   Purpose:  To parse the directive: sslcafile <path>
 
             <path>    the path of the server key to be used.
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsslcafile(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "HTTP X509 CAfile not specified");
    return 1;
  }
 
  // Record the path
  //
  if (sslcafile) free(sslcafile);
  sslcafile = strdup(val);
 
  if (xrdctxVer){ HTTPS_ALERT("cafile","tlsca",false); }
  return 0;
}
 
/******************************************************************************/
/*                                 x s e c r e t k e y                        */
/******************************************************************************/
 
/* Function: xsecretkey
 
   Purpose:  To parse the directive: xsecretkey <key>
 
             <key>    the key to be used
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsecretkey(XrdOucStream & Config) {
  char *val;
  bool inFile = false;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "Shared secret key not specified");
    return 1;
  }
 
 
  // If the token starts with a slash, then we interpret it as
  // the path to a file that contains the secretkey
  // otherwise, the token itself is the secretkey
  if (val[0] == '/') {
    struct stat st;
    inFile = true;
    int fd = open(val, O_RDONLY);
 
    if ( fd == -1 ) {
      eDest.Emsg("Config", errno, "open shared secret key file", val);
      return 1;
    }
 
    if ( fstat(fd, &st) != 0 ) {
      eDest.Emsg("Config", errno, "fstat shared secret key file", val);
      close(fd);
      return 1;
    }
 
    if ( st.st_mode & S_IWOTH & S_IWGRP & S_IROTH) {
      eDest.Emsg("Config",
        "For your own security, the shared secret key file cannot be world readable or group writable '", val, "'");
      close(fd);
      return 1;
    }
 
    FILE *fp = fdopen(fd, "r");
 
    if ( fp == nullptr ) {
      eDest.Emsg("Config", errno, "fdopen shared secret key file", val);
      close(fd);
      return 1;
    }
 
    char line[1024];
    while( fgets(line, 1024, fp) ) {
      char *pp;
 
      // Trim the end
      pp = line + strlen(line) - 1;
      while ( (pp >= line) && (!isalnum(*pp)) ) {
        *pp = '\0';
        pp--;
      }
 
      // Trim the beginning
      pp = line;
      while ( *pp && !isalnum(*pp) ) pp++;
 
      if ( strlen(pp) >= 32 ) {
        eDest.Say("Config", "Secret key loaded.");
        // Record the path
        if (secretkey) free(secretkey);
        secretkey = strdup(pp);
 
        fclose(fp);
        return 0;
      }
 
    }
 
    fclose(fp);
    eDest.Emsg("Config", "Cannot find useful secretkey in file '", val, "'");
    return 1;
 
  }
 
  if ( strlen(val) < 32 ) {
    eDest.Emsg("Config", "Secret key is too short");
    return 1;
  }
 
  // Record the path
  if (secretkey) free(secretkey);
  secretkey = strdup(val);
  if (!inFile) Config.noEcho();
 
  return 0;
}
 
/******************************************************************************/
/*                                 x l i s t d e n y                          */
/******************************************************************************/
 
/* Function: xlistdeny
 
   Purpose:  To parse the directive: listingdeny <yes|no|0|1>
 
             <val>    makes this redirector deny listings with an error
 
   Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xlistdeny(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "listingdeny flag not specified");
    return 1;
  }
 
  // Record the value
  //
  listdeny = (!strcasecmp(val, "true") || !strcasecmp(val, "yes") || !strcmp(val, "1"));
 
 
  return 0;
}
 
/******************************************************************************/
/*                                 x l i s t r e d i r                        */
/******************************************************************************/
 
/* Function: xlistredir
 
   Purpose:  To parse the directive: listingredir <Url>
 
             <Url>    http/https server to redirect to in the case of listing
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xlistredir(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "listingredir flag not specified");
    return 1;
  }
 
  // Record the value
  //
  if (listredir) free(listredir);
  listredir = strdup(val);
 
 
  return 0;
}
 
/******************************************************************************/
/*                                 x s s l d e s t h t t p s                  */
/******************************************************************************/
 
/* Function: xdesthttps
 
   Purpose:  To parse the directive: desthttps <yes|no|0|1>
 
             <val>    makes this redirector produce http or https redirection targets
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xdesthttps(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "desthttps flag not specified");
    return 1;
  }
 
  // Record the value
  //
  isdesthttps = (!strcasecmp(val, "true") || !strcasecmp(val, "yes") || !strcmp(val, "1"));
 
 
  return 0;
}
 
/******************************************************************************/
/*                          x e m b e d d e d s t a t i c                     */
/******************************************************************************/
 
/* Function: xembeddedstatic
 
   Purpose:  To parse the directive: embeddedstatic <yes|no|0|1|true|false>
 
             <val>    this server will redirect HTTPS to itself using HTTP+token
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xembeddedstatic(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "embeddedstatic flag not specified");
    return 1;
  }
 
  // Record the value
  //
  embeddedstatic = (!strcasecmp(val, "true") || !strcasecmp(val, "yes") || !strcmp(val, "1"));
 
 
  return 0;
}
 
/******************************************************************************/
/*                                 x r e d i r s t a t i c                    */
/******************************************************************************/
 
/* Function: xstaticredir
 
   Purpose:  To parse the directive: staticredir <Url>
 
             <Url>    http/https server to redirect to in the case of /static
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xstaticredir(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "staticredir url not specified");
    return 1;
  }
 
  // Record the value
  //
  if (staticredir) free(staticredir);
  staticredir = strdup(val);
 
  return 0;
}
 
/******************************************************************************/
/*                             x p r e l o a d s t a t i c                    */
/******************************************************************************/
 
/* Function: xpreloadstatic
 
   Purpose:  To parse the directive: preloadstatic <http url path> <local file>
 
             <http url path>    http/http path whose response we are preloading
                                e.g. /static/mycss.css
                                NOTE: this must start with /static
 
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xstaticpreload(XrdOucStream & Config) {
  char *val, *k, key[1024];
 
  // Get the key
  //
  k = Config.GetWord();
  if (!k || !k[0]) {
    eDest.Emsg("Config", "preloadstatic urlpath not specified");
    return 1;
  }
 
  strcpy(key, k);
 
  // Get the val
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "preloadstatic filename not specified");
    return 1;
  }
 
  // Try to load the file into memory
  int fp = open(val, O_RDONLY);
  if( fp < 0 ) {
    eDest.Emsg("Config", errno, "open preloadstatic filename", val);
    return 1;
  }
 
  StaticPreloadInfo *nfo = new StaticPreloadInfo;
  // Max 64Kb ok?
  nfo->data = (char *)malloc(65536);
  nfo->len = read(fp, (void *)nfo->data, 65536);
  close(fp);
 
  if (nfo->len <= 0) {
      eDest.Emsg("Config", errno, "read from preloadstatic filename", val);
      return 1;
  }
 
  if (nfo->len >= 65536) {
      eDest.Emsg("Config", "Truncated preloadstatic filename. Max is 64 KB '", val, "'");
      return 1;
  }
 
  // Record the value
  //
  if (!staticpreload)
    staticpreload = new XrdOucHash<StaticPreloadInfo>;
 
  staticpreload->Rep((const char *)key, nfo);
  return 0;
}
 
/******************************************************************************/
/*                             x s t a t i c h e a d e r                      */
/******************************************************************************/
 
//
// xstaticheader parses the http.staticheader director with the following syntax:
//
// http.staticheader [-verb=[GET|HEAD|...]]* header [value]
//
// When set, this will cause XrdHttp to always return the specified header and
// value.
//
// Setting this option multiple times is additive (multiple headers may be set).
// Omitting the value will cause the static header setting to be unset.
//
// Omitting the -verb argument will cause it the header to be set unconditionally
// for all requests.
int XrdHttpProtocol::xstaticheader(XrdOucStream & Config) {
  auto val = Config.GetWord();
  std::vector<std::string> verbs;
  while (true) {
    if (!val || !val[0]) {
      eDest.Emsg("Config", "http.staticheader requires the header to be specified");
      return 1;
    }
 
    std::string match_verb;
    std::string_view val_str(val);
    if (val_str.substr(0, 6) == "-verb=") {
      verbs.emplace_back(val_str.substr(6));
    } else if (val_str == "-") {
      eDest.Emsg("Config", "http.staticheader is ignoring unknown flag: ", val_str.data());
    } else {
      break;
    }
 
    val = Config.GetWord();
  }
  if (verbs.empty()) {
    verbs.emplace_back();
  }
 
  std::string header = val;
 
  val = Config.GetWord();
  std::string header_value;
  if (val && val[0]) {
    header_value = val;
  }
 
  for (const auto &verb : verbs) {
    auto iter = m_staticheader_map.find(verb);
    if (iter == m_staticheader_map.end()) {
      if (!header_value.empty())
        m_staticheader_map.insert(iter, {verb, {{header, header_value}}});
    } else if (header_value.empty()) {
      iter->second.clear();
    } else {
      iter->second.emplace_back(header, header_value);
    }
  }
 
  return 0;
}
 
 
/******************************************************************************/
/*                          x s e l f h t t p s 2 h t t p                     */
/******************************************************************************/
 
/* Function: selfhttps2http
 
   Purpose:  To parse the directive: selfhttps2http <yes|no|0|1>
 
             <val>    this server will redirect HTTPS to itself using HTTP+token
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xselfhttps2http(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "selfhttps2http flag not specified");
    return 1;
  }
 
  // Record the value
  //
  selfhttps2http = (!strcasecmp(val, "true") || !strcasecmp(val, "yes") || !strcmp(val, "1"));
 
 
  return 0;
}
 
/******************************************************************************/
/*                            x s e c x t r a c t o r                         */
/******************************************************************************/
 
/* Function: xsecxtractor
 
   Purpose:  To parse the directive: secxtractor [required] <path> <params>
 
     required    optional parameter which if present treats any secxtractor
                 errors as fatal.
     <path>      the path of the plugin to be loaded
     <params>    parameters passed to the secxtractor library
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsecxtractor(XrdOucStream& Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "No security extractor plugin specified.");
    return 1;
  } else {
    // Handle optional parameter [required]
    //
    if (!strncmp(val, "required", 8)) {
      isRequiredXtractor = true;
      val = Config.GetWord();
 
      if (!val || !val[0]) {
        eDest.Emsg("Config", "No security extractor plugin after [required] "
                   "parameter");
        return 1;
      }
    }
 
    char libName[4096];
    strlcpy(libName, val, sizeof(libName));
    libName[sizeof(libName) - 1] = '\0';
    char libParms[4096];
 
    if (!Config.GetRest(libParms, 4095)) {
      eDest.Emsg("Config", "secxtractor config params longer than 4k");
      return 1;
    }
 
    // Try to load the plugin (if available) that extracts info from the
    // user cert/proxy
    if (LoadSecXtractor(&eDest, libName, libParms)) {
      return 1;
    }
  }
 
  return 0;
}
 
int XrdHttpProtocol::xcors(XrdOucStream& Config) {
  char * val;
  // Get the path
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "No CORS plugin specified.");
    return 1;
  }
  xrdcorsLibPath = val;
  return 0;
}
 
/******************************************************************************/
/*                            x e x t h a n d l e r                           */
/******************************************************************************/
 
/* Function: xexthandler
 * 
 *   Purpose:  To parse the directive: exthandler <name> <path> <initparm>
 * 
 *             <name>      a unique name (max 16chars) to be given to this
 *                         instance, e.g 'myhandler1'
 *             <path>      the path of the plugin to be loaded
 *             <initparm>  a string parameter (e.g. a config file) that is
 *                         passed to the initialization of the plugin
 * 
 *  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xexthandler(XrdOucStream &Config,
                                 std::vector<extHInfo> &hiVec) {
  char *val, path[1024], namebuf[1024];
  char *parm;
  // By default, every external handler need TLS configured to be loaded
  bool noTlsOK = false;
  
  // Get the name
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "No instance name specified for an http external handler plugin.");
    return 1;
  }
  if (strlen(val) >= 16) {
    eDest.Emsg("Config", "Instance name too long for an http external handler plugin.");
    return 1;
  }
  strncpy(namebuf, val, sizeof(namebuf));
  namebuf[ sizeof(namebuf)-1 ] = '\0';
 
  // Get the +notls option if it was provided
  val = Config.GetWord();
 
  if(val && !strcmp("+notls",val)) {
    noTlsOK = true;
    val = Config.GetWord();
  }
 
  // Get the path
  //
  if (!val || !val[0]) {
    eDest.Emsg("Config", "No http external handler plugin specified.");
    return 1;
  } 
  if (strlen(val) >= (int)sizeof(path)) {
    eDest.Emsg("Config", "Path too long for an http external handler plugin.");
    return 1;
  }
 
  strcpy(path, val);
  
  // Everything else is a free string
  //
  parm = Config.GetWord();
 
  // Verify whether this is a duplicate (we never supported replacements)
  //
  for (int i = 0; i < (int)hiVec.size(); i++)
      {if (hiVec[i].extHName == namebuf) {
         eDest.Emsg("Config", "Instance name already present for "
                              "http external handler plugin",
                               hiVec[i].extHPath.c_str());
         return 1;
      }
  }
 
  // Verify that we don't have more already than we are allowed to have
  //
  if (hiVec.size() >= MAX_XRDHTTPEXTHANDLERS) {
    eDest.Emsg("Config", "Cannot load one more exthandler. Max is 4");
    return 1;
  }
 
  // Create an info struct and push it on the list of ext handlers to load
  //
  hiVec.push_back(extHInfo(namebuf, path, (parm ? parm : ""), noTlsOK));
 
  return 0;
}
 
/******************************************************************************/
/*                           x h e a d e r 2 c g i                            */
/******************************************************************************/
  
/* Function: xheader2cgi
 * 
 *   Purpose:  To parse the directive: header2cgi <headerkey> <cgikey>
 * 
 *             <headerkey>   the name of an incoming HTTP header
 *                           to be transformed
 *             <cgikey>      the name to be given when adding it to the cgi info
 *                           that is kept only internally
 * 
 *  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xheader2cgi(XrdOucStream & Config) {
  return parseHeader2CGI(Config,eDest,hdr2cgimap);
}
 
/******************************************************************************/
/*                                 x s s l c a d i r                          */
/******************************************************************************/
 
/* Function: xsslcadir
 
   Purpose:  To parse the directive: sslcadir <path>
 
             <path>    the path of the server key to be used.
 
  Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsslcadir(XrdOucStream & Config) {
  char *val;
 
  // Get the path
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "HTTP X509 CAdir not specified");
    return 1;
  }
 
  // Record the path
  //
  if (sslcadir) free(sslcadir);
  sslcadir = strdup(val);
 
  if (xrdctxVer){ HTTPS_ALERT("cadir","tlsca",false); }
  return 0;
}
 
/******************************************************************************/
/*                      x s s l c i p h e r f i l t e r                       */
/******************************************************************************/
 
/* Function: xsslcipherfilter
 
   Purpose:  To parse the directive: cipherfilter <filter>
 
             <filter>    the filter string to be used when generating
                         the SSL cipher list
 
   Output: 0 upon success or !0 upon failure.
 */
 
int XrdHttpProtocol::xsslcipherfilter(XrdOucStream & Config) {
  char *val;
 
  // Get the filter string
  //
  val = Config.GetWord();
  if (!val || !val[0]) {
    eDest.Emsg("Config", "SSL cipherlist filter string not specified");
    return 1;
  }
 
  // Record the filter string
  //
  if (sslcipherfilter) free(sslcipherfilter);
  sslcipherfilter = strdup(val);
 
  return 0;
}
 
/******************************************************************************/
/*                             x t l s r e u s e                              */
/******************************************************************************/
 
/* Function: xtlsreuse
 
   Purpose:  To parse the directive: tlsreuse {on | off}
 
   Output: 0 upon success or 1 upon failure.
 */
 
int XrdHttpProtocol::xtlsreuse(XrdOucStream & Config) {
 
  char *val;
 
// Get the argument
//
   val = Config.GetWord();
   if (!val || !val[0])
      {eDest.Emsg("Config", "tlsreuse argument not specified"); return 1;}
 
// If it's off, we set it off
//
   if (!strcmp(val, "off"))
      {tlsCache = XrdTlsContext::scOff;
       return 0;
      }
 
// If it's on we set it on.
//
   if (!strcmp(val, "on"))
      {tlsCache = XrdTlsContext::scSrvr;
       return 0;
      }
 
// Bad argument
//
   eDest.Emsg("config", "invalid tlsreuse parameter -", val);
   return 1;
}
 
int XrdHttpProtocol::xtlsclientauth(XrdOucStream &Config) {
  auto val = Config.GetWord();
  if (!val || !val[0])
     {eDest.Emsg("Config", "tlsclientauth argument not specified"); return 1;}
 
  if (!strcmp(val, "off"))
     {tlsClientAuth = false;
      return 0;
     }
  if (!strcmp(val, "on"))
     {tlsClientAuth = true;
      return 0;
     }
 
  eDest.Emsg("config", "invalid tlsclientauth parameter -", val);
  return 1;
}
 
int XrdHttpProtocol::xauth(XrdOucStream &Config) {
  char *val = Config.GetWord();
  if(val) {
    if(!strcmp("tpc",val)) {
      if(!(val = Config.GetWord())) {
        eDest.Emsg("Config", "http.auth tpc value not specified."); return 1;
      } else {
        if(!strcmp("fcreds",val)) {
          tpcForwardCreds = true;
        } else {
          eDest.Emsg("Config", "http.auth tpc value is invalid"); return 1;
        }
      }
    } else {
      eDest.Emsg("Config", "http.auth value is invalid"); return 1;
    }
  }
  return 0;
}
 
int XrdHttpProtocol::xmaxdelay(XrdOucStream &Config) {
  char *val = Config.GetWord();
  if(val) {
    int maxdelay;
    if (XrdOuca2x::a2tm(eDest, "http.maxdelay", val, &maxdelay, 1)) return 1;
    m_maxdelay = maxdelay;
  } else {
    eDest.Emsg("Config", "http.maxdelay requires an argument in seconds (default is 30).  Example: http.maxdelay 30");
    return 1;
  }
  return 0;
}
 
/******************************************************************************/
/*                                x t r a c e                                 */
/******************************************************************************/
 
/* Function: xtrace
 
   Purpose:  To parse the directive: trace <events>
 
             <events> the blank separated list of events to trace. Trace
                      directives are cumulative.
 
   Output: 0 upon success or 1 upon failure.
 */
 
int XrdHttpProtocol::xtrace(XrdOucStream & Config) {
 
  char *val;
 
  static struct traceopts {
    const char *opname;
    int opval;
  } tropts[] = {
    {"all", TRACE_ALL},
    {"auth", TRACE_AUTH},
    {"debug", TRACE_DEBUG},
    {"mem", TRACE_MEM},
    {"redirect", TRACE_REDIR},
    {"request", TRACE_REQ},
    {"response", TRACE_RSP}
  };
  int i, neg, trval = 0, numopts = sizeof (tropts) / sizeof (struct traceopts);
 
  if (!(val = Config.GetWord())) {
    eDest.Emsg("config", "trace option not specified");
    return 1;
  }
  while (val) {
    if (!strcmp(val, "off")) trval = 0;
    else {
      if ((neg = (val[0] == '-' && val[1]))) val++;
      for (i = 0; i < numopts; i++) {
        if (!strcmp(val, tropts[i].opname)) {
          if (neg) trval &= ~tropts[i].opval;
          else trval |= tropts[i].opval;
          break;
        }
      }
      if (i >= numopts)
        eDest.Emsg("config", "invalid trace option", val);
    }
    val = Config.GetWord();
  }
  XrdHttpTrace.What = trval;
  return 0;
}
 
int XrdHttpProtocol::doStat(char *fname) {
  int l;
  bool b;
  CurrentReq.filesize = 0;
  CurrentReq.fileflags = 0;
  CurrentReq.filemodtime = 0;
 
  memset(&CurrentReq.xrdreq, 0, sizeof (ClientRequest));
  CurrentReq.xrdreq.stat.requestid = htons(kXR_stat);
  memset(CurrentReq.xrdreq.stat.reserved, 0,
          sizeof (CurrentReq.xrdreq.stat.reserved));
  l = strlen(fname) + 1;
  CurrentReq.xrdreq.stat.dlen = htonl(l);
 
  if (!Bridge) return -1;
  b = Bridge->Run((char *) &CurrentReq.xrdreq, fname, l);
  if (!b) {
    return -1;
  }
 
 
  return 0;
}
 
/******************************************************************************/
/*                              d o C h k s u m                               */
/******************************************************************************/
  
int XrdHttpProtocol::doChksum(const XrdOucString &fname) {
  size_t length;
  memset(&CurrentReq.xrdreq, 0, sizeof (ClientRequest));
  CurrentReq.xrdreq.query.requestid = htons(kXR_query);
  CurrentReq.xrdreq.query.infotype = htons(kXR_Qcksum);
  memset(CurrentReq.xrdreq.query.reserved1, '\0', sizeof(CurrentReq.xrdreq.query.reserved1));
  memset(CurrentReq.xrdreq.query.fhandle, '\0', sizeof(CurrentReq.xrdreq.query.fhandle));
  memset(CurrentReq.xrdreq.query.reserved2, '\0', sizeof(CurrentReq.xrdreq.query.reserved2));
  length = fname.length() + 1;
  CurrentReq.xrdreq.query.dlen = htonl(length);
 
  if (!Bridge) return -1;
 
  return Bridge->Run(reinterpret_cast<char *>(&CurrentReq.xrdreq), const_cast<char *>(fname.c_str()), length) ? 0 : -1;
}
 
 
static XrdVERSIONINFODEF(compiledVer, XrdHttpProtocolTest, XrdVNUMBER, XrdVERSION);
 
// Loads the SecXtractor plugin, if available
int XrdHttpProtocol::LoadSecXtractor(XrdSysError *myeDest, const char *libName,
                                     const char *libParms) {
  
  
  // We don't want to load it more than once
  if (secxtractor) return 1;
  
    XrdOucPinLoader myLib(myeDest, &compiledVer, "secxtractorlib", libName);
    XrdHttpSecXtractor *(*ep)(XrdHttpSecXtractorArgs);
 
    // Get the entry point of the object creator
    //
    ep = (XrdHttpSecXtractor *(*)(XrdHttpSecXtractorArgs))(myLib.Resolve("XrdHttpGetSecXtractor"));
    if (ep && (secxtractor = ep(myeDest, NULL, libParms))) return 0;
    myLib.Unload();
    return 1;
}
/******************************************************************************/
/*                        L o a d E x t H a n d l e r                         */
/******************************************************************************/
 
int XrdHttpProtocol::LoadExtHandlerNoTls(std::vector<extHInfo> &hiVec, const char *cFN, XrdOucEnv &myEnv) {
  for (int i = 0; i < (int) hiVec.size(); i++) {
    if(hiVec[i].extHNoTlsOK) {
      // The external plugin does not need TLS to be loaded
      if (LoadExtHandler(&eDest, hiVec[i].extHPath.c_str(), cFN,
                         hiVec[i].extHParm.c_str(), &myEnv,
                         hiVec[i].extHName.c_str()))
        return 1;
    }
  }
  return 0;
}
 
int XrdHttpProtocol::LoadExtHandler(std::vector<extHInfo> &hiVec,
                                    const char *cFN, XrdOucEnv &myEnv) {
 
  // Add the pointer to the cadir and the cakey to the environment.
  //
  if (sslcadir) myEnv.Put("http.cadir", sslcadir);
  if (sslcafile) myEnv.Put("http.cafile", sslcafile);
  if (sslcert)  myEnv.Put("http.cert",  sslcert);
  if (sslkey)   myEnv.Put("http.key"  , sslkey);
 
  // Load all of the specified external handlers.
  //
  for (int i = 0; i < (int)hiVec.size(); i++) {
    // Only load the external handlers that were not already loaded
    // by LoadExtHandlerNoTls(...)
    if(!ExtHandlerLoaded(hiVec[i].extHName.c_str())) {
      if (LoadExtHandler(&eDest, hiVec[i].extHPath.c_str(), cFN,
                         hiVec[i].extHParm.c_str(), &myEnv,
                         hiVec[i].extHName.c_str())) return 1;
    }
  }
  return 0;
}
  
// Loads the external handler plugin, if available
int XrdHttpProtocol::LoadExtHandler(XrdSysError *myeDest, const char *libName,
                                    const char *configFN, const char *libParms,
                                    XrdOucEnv *myEnv, const char *instName) {
  
  
  // This function will avoid loading doubles. No idea why this happens
  if (ExtHandlerLoaded(instName)) {
    eDest.Emsg("Config", "Instance name already present for an http external handler plugin.");
    return 1;
  }
  if (exthandlercnt >= MAX_XRDHTTPEXTHANDLERS) {
    eDest.Emsg("Config", "Cannot load one more exthandler. Max is 4");
    return 1;
  }
  
  XrdOucPinLoader myLib(myeDest, &compiledVer, "exthandlerlib", libName);
  XrdHttpExtHandler *(*ep)(XrdHttpExtHandlerArgs);
  
  // Get the entry point of the object creator
  //
  ep = (XrdHttpExtHandler *(*)(XrdHttpExtHandlerArgs))(myLib.Resolve("XrdHttpGetExtHandler"));
 
  XrdHttpExtHandler *newhandler;
  if (ep && (newhandler = ep(myeDest, configFN, libParms, myEnv))) {
    
    // Handler has been loaded, it's the last one in the list
    strncpy( exthandler[exthandlercnt].name,  instName, 16 );
    exthandler[exthandlercnt].name[15] = '\0';
    exthandler[exthandlercnt++].ptr = newhandler;
    
    return 0;
  }
 
  myLib.Unload();
  return 1;
}
 
 
int XrdHttpProtocol::LoadCorsHandler(XrdSysError *eDest, const char *libname) {
  if(xrdcors) return 1;
  XrdOucPinLoader corsLib(eDest, &compiledVer, "corslib",libname);
  XrdHttpCors *(*ep)(XrdHttpCorsGetHandlerArgs);
  ep = (XrdHttpCors *(*)(XrdHttpCorsGetHandlerArgs))(corsLib.Resolve("XrdHttpCorsGetHandler"));
  if(ep && (xrdcors = ep())) return 0;
  corsLib.Unload();
  return 1;
}
 
// Tells if we have already loaded a certain exthandler. Try to
// privilege speed, as this func may be invoked pretty often
bool XrdHttpProtocol::ExtHandlerLoaded(const char *handlername) {
  for (int i = 0; i < exthandlercnt; i++) {
    if ( !strncmp(exthandler[i].name, handlername, 15) ) {
      return true;
    }
  }
  return false;
}
 
// Locates a matching external handler for a given request, if available. Try to
// privilege speed, as this func is invoked for every incoming request
XrdHttpExtHandler * XrdHttpProtocol::FindMatchingExtHandler(const XrdHttpReq &req) {
  
  for (int i = 0; i < exthandlercnt; i++) {
    if (exthandler[i].ptr->MatchesPath(req.requestverb.c_str(), req.resource.c_str())) {
      return exthandler[i].ptr;
    }
  }
  return NULL;
}

TRACELINK [1/3]

#define TRACELINK   lp

Definition at line 227 of file XrdHttpProtocol.cc.

TRACELINK [2/3]

#define TRACELINK   Link

Definition at line 227 of file XrdHttpProtocol.cc.

TRACELINK [3/3]

#define TRACELINK   Link

Definition at line 227 of file XrdHttpProtocol.cc.

TS_Xeq

#define TS_Xeq	(		x,
			m
	)		(!strcmp(x,var)) GoNo = m(Config)

Definition at line 984 of file XrdHttpProtocol.cc.

TS_Xeq3

#define TS_Xeq3	(		x,
			m
	)		(!strcmp(x,var)) GoNo = m(Config, extHIVec)

Definition at line 986 of file XrdHttpProtocol.cc.

XRHTTP_TK_GRACETIME

#define XRHTTP_TK_GRACETIME   600

Definition at line 61 of file XrdHttpProtocol.cc.

Function Documentation

BIO_get_data()

void * BIO_get_data

(

BIO *

bio

)

Definition at line 168 of file XrdHttpProtocol.cc.

                             {
  return bio->ptr;
}

Referenced by BIO_XrdLink_destroy(), BIO_XrdLink_read(), and BIO_XrdLink_write().

Here is the caller graph for this function:

BIO_get_flags()

int BIO_get_flags

(

BIO *

bio

)

Definition at line 175 of file XrdHttpProtocol.cc.

                            {
  return bio->flags;
}

BIO_get_init()

int BIO_get_init

(

BIO *

bio

)

Definition at line 182 of file XrdHttpProtocol.cc.

                           {
  return bio->init;
}

BIO_get_shutdown()

int BIO_get_shutdown

(

BIO *

bio

)

Definition at line 191 of file XrdHttpProtocol.cc.

                               {
  return bio->shutdown;
}

Referenced by BIO_XrdLink_ctrl(), and BIO_XrdLink_destroy().

Here is the caller graph for this function:

BIO_set_data()

void BIO_set_data	(	BIO *	bio,
		void *	ptr
	)

Definition at line 171 of file XrdHttpProtocol.cc.

                                       {
  bio->ptr = ptr;
}

Referenced by BIO_XrdLink_create().

Here is the caller graph for this function:

BIO_set_flags()

void BIO_set_flags	(	BIO *	bio,
		int	flags
	)

Definition at line 179 of file XrdHttpProtocol.cc.

                                        {
  bio->flags = flags;
}

Referenced by BIO_XrdLink_create(), BIO_XrdLink_destroy(), and Tobase64().

Here is the caller graph for this function:

BIO_set_init()

void BIO_set_init	(	BIO *	bio,
		int	init
	)

Definition at line 185 of file XrdHttpProtocol.cc.

                                      {
  bio->init = init;
}

Referenced by BIO_XrdLink_create(), and BIO_XrdLink_destroy().

Here is the caller graph for this function:

BIO_set_shutdown()

void BIO_set_shutdown	(	BIO *	bio,
		int	shut
	)

Definition at line 188 of file XrdHttpProtocol.cc.

                                          {
  bio->shutdown = shut;
}

Referenced by BIO_XrdLink_ctrl().

Here is the caller graph for this function:

BIO_XrdLink_create()

static int BIO_XrdLink_create ( BIO *  bio )

static

Definition at line 415 of file XrdHttpProtocol.cc.

{
    
    
  BIO_set_init(bio, 0);
  //BIO_set_next(bio, 0);
  BIO_set_data(bio, NULL);
  BIO_set_flags(bio, 0);
  
#if OPENSSL_VERSION_NUMBER < 0x10100000L
 
  bio->num = 0;
 
#endif
  
  return 1;
}

References BIO_set_data(), BIO_set_flags(), and BIO_set_init().

Here is the call graph for this function:

BIO_XrdLink_ctrl()

static long BIO_XrdLink_ctrl ( BIO *  bio, int  cmd, long  num, void *  ptr  )

static

Definition at line 448 of file XrdHttpProtocol.cc.

{
  long ret = 1;
  switch (cmd) {
  case BIO_CTRL_GET_CLOSE:
    ret = BIO_get_shutdown(bio);
    break;
  case BIO_CTRL_SET_CLOSE:
    BIO_set_shutdown(bio, (int)num);
    break;  
  case BIO_CTRL_DUP:
  case BIO_CTRL_FLUSH:
    ret = 1;
    break;
  default:
    ret = 0;
    break;
  }
  return ret;
}

References BIO_get_shutdown(), and BIO_set_shutdown().

Here is the call graph for this function:

BIO_XrdLink_destroy()

static int BIO_XrdLink_destroy ( BIO *  bio )

static

Definition at line 434 of file XrdHttpProtocol.cc.

{
  if (bio == NULL) return 0;
  if (BIO_get_shutdown(bio)) {
    if (BIO_get_data(bio)) {
      static_cast<XrdLink*>(BIO_get_data(bio))->Close();
    }
    BIO_set_init(bio, 0);
    BIO_set_flags(bio, 0);
  }
  return 1;
}

References BIO_get_data(), BIO_get_shutdown(), BIO_set_flags(), and BIO_set_init().

Here is the call graph for this function:

BIO_XrdLink_read()

static int BIO_XrdLink_read ( BIO *  bio, char *  data, size_t  datal, size_t *  read  )

static

Definition at line 374 of file XrdHttpProtocol.cc.

{
  if (!data || !bio) {
    *read = 0;
    return 0;
  }
 
  errno = 0;
  
  XrdLink *lp = static_cast<XrdLink *>(BIO_get_data(bio));  
  int ret = lp->Recv(data, datal);
  BIO_clear_retry_flags(bio);
  if (ret <= 0) {
    *read = 0;
    if ((errno == EINTR) || (errno == EINPROGRESS) || (errno == EAGAIN) || (errno == EWOULDBLOCK))
      BIO_set_retry_read(bio);
    return ret;
  }
  *read = ret;
}

References BIO_get_data(), read, and XrdLink::Recv().

Here is the call graph for this function:

BIO_XrdLink_write()

int BIO_XrdLink_write	(	BIO *	bio,
		const char *	data,
		size_t	datal,
		size_t *	written
	)

Definition at line 331 of file XrdHttpProtocol.cc.

{
  if (!data || !bio) {
    *written = 0;
    return 0;
  }
  
  XrdLink *lp=static_cast<XrdLink *>(BIO_get_data(bio));
  
  errno = 0;
  int ret = lp->Send(data, datal);
  BIO_clear_retry_flags(bio);
  if (ret <= 0) {
    *written = 0;
    if ((errno == EINTR) || (errno == EINPROGRESS) || (errno == EAGAIN) || (errno == EWOULDBLOCK))
      BIO_set_retry_write(bio);
    return ret;
  }
  *written = ret;
  return 1;
}

References BIO_get_data(), and XrdLink::Send().

Here is the call graph for this function:

XrdVERSIONINFODEF()

static XrdVERSIONINFODEF ( compiledVer  , XrdHttpProtocolTest  , XrdVNUMBER  , XrdVERSION    )

static

Referenced by XrdCksConfig::XrdCksConfig(), XrdCksLoader::XrdCksLoader(), XrdFrmConfig::XrdFrmConfig(), XrdOssSys::XrdOssSys(), XrdSsiSfsConfig::XrdSsiSfsConfig(), XrdOucLogging::configLog(), XrdCryptoFactory::GetCryptoFactory(), XrdSysPlugin::getPlugin(), XrdOucN2NLoader::Load(), main(), XrdAccDefaultAuthorizeObject(), XrdXrootdloadFileSystem(), and XrdXrootdloadRedirLib().

Here is the caller graph for this function:

Variable Documentation

XrdHttpSecEntityTident

const char* XrdHttpSecEntityTident = "http"

Definition at line 69 of file XrdHttpProtocol.cc.

XrdHttpTrace

XrdSysTrace XrdHttpTrace("http")

(

"http"

)

Referenced by XrdHttpProtocol::Configure().