XrdXrootdProtocol Class Reference

#include <XrdXrootdProtocol.hh>

Inheritance diagram for XrdXrootdProtocol:

Collaboration diagram for XrdXrootdProtocol:

Classes
struct	GetDataCtl
union	GetDataCtl.__unnamed192__
union	GetDataCtl.__unnamed194__
struct	RC_Table
struct	RD_Table

Public Member Functions
	XrdXrootdProtocol ()
	~XrdXrootdProtocol ()
void	aioUpdate (int val)
void	aioUpdReq (int val)
XrdSfsXioHandle	Claim (const char *buff, int datasz, int minasz=0) override
int	do_WriteSpan ()
void	DoIt () override
int	getData (gdCallBack *gdcbP, const char *dtype, char *buff, int blen)
int	getData (gdCallBack *gdcbP, const char *dtype, struct iovec *iov, int iovn)
int	getDump (const char *dtype, int dlen)
int	getPathID ()
XrdProtocol *	Match (XrdLink *lp) override
XrdXrootdProtocol	operator= (const XrdXrootdProtocol &rhs)=delete
int	Process (XrdLink *lp) override
int	Process2 ()
int	ProcSig ()
void	Recycle (XrdLink *lp, int consec, const char *reason) override
int	SendFile (int fildes) override
int	SendFile (XrdOucSFVec *sfvec, int sfvnum) override
void	SetFD (int fildes) override
int	Stats (char *buff, int blen, int do_sync=0) override
void	StreamNOP ()
XrdSfsXioHandle	Swap (const char *buff, XrdSfsXioHandle h=0) override
XrdXrootdProtocol *	VerifyStream (int &rc, int pID, bool lok=true)
Public Member Functions inherited from XrdProtocol
	XrdProtocol (const char *jname)
virtual	~XrdProtocol ()
Public Member Functions inherited from XrdJob
	XrdJob (const char *desc="")
virtual	~XrdJob ()
Public Member Functions inherited from XrdXrootd::gdCallBack
	gdCallBack ()
virtual	~gdCallBack ()
virtual void	gdFail ()
Public Member Functions inherited from XrdSfsDio
	XrdSfsDio ()
	Constructor and destructor. More...
virtual	~XrdSfsDio ()
Public Member Functions inherited from XrdSfsXio
	XrdSfsXio (XrdSfsXioImpl &xioimpl)
virtual	~XrdSfsXio ()
	Constructor and destructor. More...

Static Public Member Functions
static char *	Buffer (XrdSfsXioHandle h, int *bsz)
static int	Configure (char *parms, XrdProtocol_Config *pi)
static void	Reclaim (XrdSfsXioHandle h)
Static Public Member Functions inherited from XrdSfsXio
static char *	Buffer (XrdSfsXioHandle theHand, int *buffsz=0)
static void	Reclaim (XrdSfsXioHandle theHand)

Static Public Attributes
static bool	as_aioOK = true
static bool	as_force = false
static int	as_maxperlnk = 8
static int	as_maxperreq = 8
static int	as_maxpersrv = 4096
static int	as_maxstalls = 4
static int	as_miniosz = 98304
static int	as_minsfsz = 8192
static bool	as_nosf = false
static short	as_okstutter = 1
static int	as_seghalf = 32768
static int	as_segsize = 65536
static bool	as_syncw = false
static short	as_timeout = 45
static const int	maxStreams = 16

Protected Member Functions
void	MonAuth ()
bool	RequestClose ()
int	SetSF (kXR_char *fhandle, bool seton=false)

Static Protected Member Functions
static bool	CloseRequestCb (void *cbarg)
static unsigned int	getSID ()

Protected Attributes
bool	ableTLS
char *	AppName
XrdBuffer *	argp
XrdSecProtocol *	AuthProt
XrdSysSemaphore *	boundRecycle
unsigned char	CapVer
XrdSecEntity *	Client
int	clientPV
int	clientRN
bool	CloseRequested
int	cumReadP
int	cumReads
int	cumReadV
int	cumSegsV
int	cumSegsW
int	cumWrites
int	cumWritV
char	doTLS
XrdSysCondVar2 *	endNote
XrdSecEntity	Entity
XrdXrootdFileTable *	FTab
struct XrdXrootdProtocol::GetDataCtl	gdCtl
int	halfBSize
int	hcNext
int	hcNow
int	hcPrev
XrdXrootd::IOParms	IO
bool	isActive
bool	isLinkWT
bool	isNOP
bool	isTLS
XrdLink *	Link
RAtomic_int	linkAioReq
XrdXrootdMonitor::User	Monitor
int	myBlast
int	myBlen
char *	myBuff
unsigned int	mySID
int	myStalls
bool	newPio
int	numFiles
int	numReadP
int	numReads
int	numReadV
int	numSegsV
int	numSegsW
int	numWrites
int	numWritV
short	PathID
XrdXrootdPgwCtl *	pgwCtl
XrdXrootdPio *	pioFirst
XrdXrootdPio *	pioFree
XrdXrootdPio *	pioLast
bool	pmDone
XrdNetPMark::Handle *	pmHandle
int	PrepareCount
XrdSecProtect *	Protect
short	rdType
XrdXrootdReqID	ReqID
ClientRequest	Request
char	reserved [3]
XrdXrootdResponse	Response
int(XrdXrootdProtocol::*	Resume )()
int(XrdXrootdProtocol::*	ResumePio )()
XrdSysSemaphore *	reTry
unsigned char	rvSeq
char	sigBuff [64]
bool	sigHere
bool	sigNeed
bool	sigRead
SecurityRequest	sigReq
ClientRequest	sigReq2Ver
bool	sigWarn
char	Status
XrdXrootdProtocol *	Stream [maxStreams]
XrdSysMutex	streamMutex
long long	totReadP
XrdSysMutex	unbindMutex
XrdXrootdWVInfo *	wvInfo
unsigned char	wvSeq

Static Protected Attributes
static XrdNetSocket *	AdminSock = 0
static XrdBuffManager *	BPool
static XrdSecService *	CIA = 0
static bool	CL_Redir = false
static XrdSecProtector *	DHS = 0
static XrdSfsFileSystem *	digFS = 0
static XrdSysError &	eDest = XrdXrootd::eLog
static uint64_t	fsFeatures = 0
static int	hailWait
static int	hcMax = 28657
static bool	isProxy = false
static char	isRedir = 0
static char	JobCKCGI =0
static XrdXrootdJob *	JobCKS = 0
static char *	JobCKT = 0
static XrdOucTList *	JobCKTLST = 0
static char	JobLCL = 0
static time_t	keepT = 86400
static bool	LimitError = true
static XrdXrootdFileLock *	Locker
static int	maxBuffsz
static const int	maxPio = 4
static int	maxReadv_ior
static int	maxTransz = 262144
static const char *	myCName = 0
static int	myCNlen = 0
static gid_t	myGID = 0
static const char *	myGName = "?"
static int	myGNLen = 1
static const char *	myInst = 0
static int	myPID = static_cast<int>(getpid())
static int	myRole = 0
static int	myRolf = 0
static uid_t	myUID = 0
static const char *	myUName = "?"
static int	myUNLen = 1
static char *	Notify = 0
static bool	OD_Bypass = false
static bool	OD_Redir = false
static int	OD_Stall = 33
static XrdSfsFileSystem *	osFS
static XrdNetPMark *	PMark = 0
static int	Port
static bool	PrepareAlt = false
static int	PrepareLimit = -1
static XrdOucReqID *	PrepID = 0
static int	readWait
static int	redirIPHold = 8*60*60
static XrdXrootdRedirPI *	RedirPI = 0
static const char	Req_TLSData = 0x01
static const char	Req_TLSGPFile = 0x02
static const char	Req_TLSLogin = 0x04
static const char	Req_TLSSess = 0x08
static const char	Req_TLSTPC = 0x10
static struct XrdXrootdProtocol::RD_Table	Route [RD_Num]
static struct XrdXrootdProtocol::RC_Table	RouteClient
static XrdXrootdXPath	RPList
static XrdXrootdXPath	RQList
static int	RQLxist = 0
static XrdScheduler *	Sched
static XrdXrootdStats *	SI
static RAtomic_int	srvrAioOps = {0}
static char	tlsCap = 0
static XrdTlsContext *	tlsCtx = 0
static char	tlsNot = 0
static int	tlsPort = 0
static const char *	TraceID = "Protocol"
static int	usxMaxNsz = kXR_faMaxNlen
static int	usxMaxVsz = kXR_faMaxVlen
static char *	usxParms = 0
static int	Window
static XrdXrootdXPath	XPList

Friends
class	XrdXrootdAdmin

Additional Inherited Members
Public Attributes inherited from XrdJob
const char *	Comment
XrdJob *	NextJob

Detailed Description

Definition at line 157 of file XrdXrootdProtocol.hh.

---

Class Documentation

XrdXrootdProtocol::GetDataCtl.__unnamed192__

union XrdXrootdProtocol::GetDataCtl.__unnamed192__

Definition at line 562 of file XrdXrootdProtocol.hh.

Collaboration diagram for XrdXrootdProtocol::GetDataCtl.__unnamed192__:

Class Members
int	BuffLen
int	DumpLen
int	iovAdj

XrdXrootdProtocol::GetDataCtl.__unnamed194__

union XrdXrootdProtocol::GetDataCtl.__unnamed194__

Definition at line 570 of file XrdXrootdProtocol.hh.

Collaboration diagram for XrdXrootdProtocol::GetDataCtl.__unnamed194__:

Class Members
char *	Buffer
struct iovec *	iovVec

XrdXrootdProtocol::RC_Table

struct XrdXrootdProtocol::RC_Table

Definition at line 454 of file XrdXrootdProtocol.hh.

Collaboration diagram for XrdXrootdProtocol::RC_Table:

Class Members
char *	Domain[4]
short	DomCnt
bool	lclDom
bool	pvtIP

XrdXrootdProtocol::RD_Table

struct XrdXrootdProtocol::RD_Table

Definition at line 450 of file XrdXrootdProtocol.hh.

Collaboration diagram for XrdXrootdProtocol::RD_Table:

Class Members
char *	Host[2]
unsigned short	Port[2]
short	RDSz[2]

Constructor & Destructor Documentation

XrdXrootdProtocol()

XrdXrootdProtocol::XrdXrootdProtocol

(

)

Definition at line 259 of file XrdXrootdProtocol.cc.

                    : XrdProtocol("xroot protocol handler"),
                      XrdSfsXio(SfsXioImpl),
                      ProtLink(this), Entity(0), AppName(0)
{
   Reset();
}

Referenced by Match().

Here is the caller graph for this function:

~XrdXrootdProtocol()

XrdXrootdProtocol::~XrdXrootdProtocol ( )

inline

Definition at line 215 of file XrdXrootdProtocol.hh.

{Cleanup();}

Member Function Documentation

aioUpdate()

void XrdXrootdProtocol::aioUpdate ( int  val )

inline

Definition at line 163 of file XrdXrootdProtocol.hh.

{srvrAioOps += val;}

References srvrAioOps.

Referenced by XrdXrootdAioBuff::Alloc(), XrdXrootdAioPgrw::Alloc(), and XrdXrootdAioPgrw::Recycle().

Here is the caller graph for this function:

aioUpdReq()

void XrdXrootdProtocol::aioUpdReq ( int  val )

inline

Definition at line 165 of file XrdXrootdProtocol.hh.

{linkAioReq += val;}

References linkAioReq.

Buffer()

char * XrdXrootdProtocol::Buffer ( XrdSfsXioHandle  h, int *  bsz  )

static

Definition at line 895 of file XrdXrootdProtocol.cc.

{
   XrdBuffer *xbP = (XrdBuffer *)h;
 
   if (h)
      {if (bsz) *bsz = xbP->bsize;
       return xbP->buff;
      }
   if (bsz) *bsz = 0;
   return 0;
}

References XrdBuffer::bsize, and XrdBuffer::buff.

Claim()

XrdSfsXioHandle XrdXrootdProtocol::Claim ( const char *  curBuff, int  datasz, int  minasz = 0  )

overridevirtual

Claim ownership of the current buffer if it is memory effecient to do so.

Parameters

curBuff	- The address of the current buffer. It must match the the buffer that was most recently passed to the caller.
datasz	- Number of useful bytes in the buffer (i.e. write size).
minasz	- Minimum buffer size that would be allocated to copy data.

Returns

!0 The buffer handle of the current buffer is returned along with ownership rights.

=0 Too much memory would be wasted by transferring ownership (errno == 0) or an error ocurred (errno != 0). When an error see Swap() below for possible types of errors.

Implements XrdSfsXio.

Definition at line 911 of file XrdXrootdProtocol.cc.

{
 
// Qualify swap choice
//
   if (minasz >= argp->bsize || datasz >= argp->bsize/2) return Swap(buff);
   errno = 0;
   return 0;
}

References argp, XrdBuffer::bsize, and Swap().

Here is the call graph for this function:

CloseRequestCb()

bool XrdXrootdProtocol::CloseRequestCb ( void *  cbarg )

staticprotected

Definition at line 1541 of file XrdXrootdProtocol.cc.

{
   XrdXrootdProtocol *pp = (XrdXrootdProtocol*)cbarg;
   return pp->RequestClose();
}

References RequestClose().

Here is the call graph for this function:

Configure()

int XrdXrootdProtocol::Configure ( char *  parms, XrdProtocol_Config *  pi  )

static

Definition at line 176 of file XrdXrootdConfig.cc.

{
/*
  Function: Establish configuration at load time.
 
  Input:    None.
 
  Output:   0 upon success or !0 otherwise.
*/
 
   extern XrdSfsFileSystem *XrdDigGetFS
                            (XrdSfsFileSystem *nativeFS,
                             XrdSysLogger     *Logger,
                             const char       *configFn,
                             const char       *theParms);
 
   XrdOucEnv xrootdEnv;
   XrdXrootdXPath *xp;
   char *adminp, *rdf, *bP, *tmp, buff[1024];
   int i, n;
 
// Copy out the special info we want to use at top level
//
   eDest.logger(pi->eDest->logger());
   XrdXrootdTrace.SetLogger(pi->eDest->logger());
   SI           = new XrdXrootdStats(pi->Stats);
   XrdXrootd::SI= SI;
   Sched        = pi->Sched; XrdXrootd::Sched = pi->Sched;
   BPool        = pi->BPool; XrdXrootd::BPool = pi->BPool;
   hailWait     = pi->hailWait;
   readWait     = pi->readWait;
   Port         = pi->Port;
   myInst       = pi->myInst;
   Window       = pi->WSize;
   tlsPort      = pi->tlsPort;
   tlsCtx       = pi->tlsCtx;
   XrdXrootdCF  = pi->totalCF;
 
// Record globally accessible values
//
   XrdXrootdInstance = pi->myInst;
   XrdXrootdPort     = pi->Port;
 
// Set the callback object static areas now!
//
   XrdXrootdCallBack::setVals(&eDest, SI, Sched, Port);
 
// Pick up exported paths from the command line
//
   for (i = 1; i < pi->argc; i++) xexpdo(pi->argv[i]);
 
// Pre-initialize some i/o values. Note that we now set maximum readv element
// transfer size to the buffer size (before it was a reasonable 256K).
//
   n = (pi->theEnv ? pi->theEnv->GetInt("MaxBuffSize") : 0);
   maxTransz = maxBuffsz = (n ? n : BPool->MaxSize());
   maxReadv_ior = maxTransz-(int)sizeof(readahead_list);
 
// Export the readv_ior_max and readv_iov_max values
//
  {char buff[256];
   snprintf(buff, sizeof(buff), "%d,%d",  maxReadv_ior, XrdProto::maxRvecsz);
   XrdOucEnv::Export("XRD_READV_LIMITS", buff);
  }
 
   memset(Route, 0, sizeof(Route));
 
// Now process and configuration parameters
//
   rdf = (parms && *parms ? parms : pi->ConfigFN);
   if (rdf && Config(rdf)) return 0;
   if (pi->DebugON) XrdXrootdTrace.What = TRACE_ALL;
 
// Initialize the packet marking framework if configured. We do that here as
// nothing else following this code can fail but we can so be consistent.
//
   bool bad = false;
   PMark = XrdNetPMarkCfg::Config(&eDest, pi->Sched, &XrdXrootdTrace, bad);
   if (PMark)
      {if (pi->theEnv) pi->theEnv->PutPtr("XrdNetPMark*", PMark);
       xrootdEnv.PutPtr("XrdNetPMark*", PMark);
      }
      else if (bad) return 0;
 
// Check if we are exporting a generic object name
//
   if (XPList.Opts() & XROOTDXP_NOSLASH)
      {eDest.Say("Config exporting ", XPList.Path(n)); n += 2;}
      else n = 0;
 
// Check if we are exporting anything
//
   if (!(xp = XPList.Next()) && !n)
      {XPList.Insert("/tmp"); n = 8;
       eDest.Say("Config warning: only '/tmp' will be exported.");
      } else {
       while(xp) {eDest.Say("Config exporting ", xp->Path(i));
                  n += i+2; xp = xp->Next();
                 }
      }
 
// Export the exports
//
   bP = tmp = (char *)malloc(n);
   if (XPList.Opts() & XROOTDXP_NOSLASH)
      {strcpy(bP, XPList.Path(i)); bP += i, *bP++ = ' ';}
   xp = XPList.Next();
   while(xp) {strcpy(bP, xp->Path(i)); bP += i; *bP++ = ' '; xp = xp->Next();}
   *(bP-1) = '\0';
   XrdOucEnv::Export("XRDEXPORTS", tmp); free(tmp);
 
// Initialize the security system if this is wanted
//
   if (!ConfigSecurity(xrootdEnv, pi->ConfigFN)) return 0;
 
// Set up the network for self-identification and display it
//
   pi->NetTCP->netIF.Port(Port);
   pi->NetTCP->netIF.Display("Config ");
 
// Establish our specific environment that will be passed along
//
   xrootdEnv.PutPtr("XrdInet*", (void *)(pi->NetTCP));
   xrootdEnv.PutPtr("XrdNetIF*", (void *)(&(pi->NetTCP->netIF)));
   xrootdEnv.PutPtr("XrdScheduler*", Sched);
 
// Copy over the xrd environment which contains plugin argv's and re-export
// the monitoring registration object into out own env for simplicity
//
   if (pi->theEnv)
      {xrootdEnv.PutPtr("xrdEnv*", pi->theEnv);
       void* theMon = pi->theEnv->GetPtr("XrdMonRoll*");
       if (theMon) xrootdEnv.PutPtr("XrdMonRoll*", theMon);
      }
 
// Initialize monitoring (it won't do anything if it wasn't enabled). This
// needs to be done before we load any plugins as plugins may need monitoring.
//
   if (!ConfigMon(pi, xrootdEnv)) return 0;
 
// Get the filesystem to be used and its features.
//
   if (!ConfigFS(xrootdEnv, pi->ConfigFN)) return 0;
   fsFeatures = osFS->Features();
   isProxy = (fsFeatures & XrdSfs::hasPRXY) != 0;
   if (pi->theEnv) pi->theEnv->PutPtr("XrdSfsFileSystem*", osFS);
 
// Check if the file system includes a custom prepare handler as this will
// affect how we handle prepare requests.
//
   if (fsFeatures & XrdSfs::hasPRP2 || xrootdEnv.Get("XRD_PrepHandler"))
      PrepareAlt = true;
 
// Check if the diglib should be loaded. We only support the builtin one. In
// the future we will have to change this code to be like the above.
//
   if (digParm)
      {TRACE(DEBUG, "Loading dig filesystem builtin");
       digFS = XrdDigGetFS(osFS, eDest.logger(), pi->ConfigFN, digParm);
       if (!digFS) eDest.Emsg("Config","Unable to load digFS; "
                                       "remote debugging disabled!");
      }
 
// Check if we are going to be processing checksums locally
//
   if (JobCKT) {
       XrdOucString csList(1024);
       XrdOucErrInfo myError("Config");
       XrdOucTList *tP = JobCKTLST;
       int csNum = 0;
       do {
           if(JobLCL) {
               // Check natively supported checksum
               if (osFS->chksum(XrdSfsFileSystem::csSize, tP->text, 0, myError)) {
                   eDest.Emsg("Config", tP->text, "checksum is not natively supported.");
                  return 0;
               }
           }
           tP->ival[1] = myError.getErrInfo();
           if (csNum) csList += ',';
           csList.append(csNum);
           csList.append(':');
           csList.append(tP->text);
           csNum++;
           tP = tP->next;
       } while (tP);
       if (csNum) XrdOucEnv::Export("XRD_CSLIST", csList.c_str());
   }
 
// Configure the redirect plugins.  After loading the chain we publish the
// final pointer in two places: the protocol environment (so external
// plugins can fetch the raw pointer of the plugin via the
// "XrdXrootdRedirPI*" key) and XrdXrootdRedirHelper, the in-tree adapter
// that fsRedirPI() and the HTTP TPC handler both call to apply plugin-
// driven routing (issue #2767).
//
   if (!RDLPath.empty())
      {for (int i = 0; i < (int)RDLPath.size(); i++)
           {const char* parm = (RDLParm[i].length() ? RDLParm[i].c_str() : 0);
             if (!ConfigRedirPI(RDLPath[i].c_str(),xrootdEnv,pi->ConfigFN,parm))
               return 0;
             if (pi->theEnv)
               pi->theEnv->PutPtr("XrdXrootdRedirPI*", RedirPI);
           }
       XrdXrootdRedirHelper::Init(RedirPI, &eDest, redirIPHold);
      }
 
// Initialiaze for AIO. If we are not in debug mode and aio is enabled then we
// turn off async I/O if tghe filesystem requests it or if this is a caching
// proxy and we were asked not to use aio in such a cacse.
//
   if (!(asyncFlags & asDebug) && as_aioOK)
      {if (fsFeatures & XrdSfs::hasNAIO) as_aioOK = false;
          else if (asyncFlags & asNoCache && fsFeatures & XrdSfs::hasCACH)
                  as_aioOK = false;
       if (!as_aioOK) eDest.Say("Config asynchronous I/O has been disabled!");
      }
 
// Compute the maximum stutter allowed during async I/O (one per 64k)
//
   if (as_segsize > 65536) as_okstutter = as_segsize/65536;
 
// Establish final sendfile processing mode. This may be turned off by the
// link or by the SFS plugin usually because it's a proxy.
//
   const char *why = 0;
   if (!as_nosf)
      {if (fsFeatures & XrdSfs::hasNOSF) why = "file system plugin.";
          else if (!XrdLink::sfOK) why = "OS kernel.";
       if (why)
          {as_nosf = true;
           eDest.Say("Config sendfile has been disabled by ", why);
          }
      }
 
// Create the file lock manager and initialize file handling
//
   Locker = (XrdXrootdFileLock *)new XrdXrootdFileLock1();
   XrdXrootdFile::Init(Locker, &eDest, !as_nosf);
 
// Schedule protocol object cleanup (also advise the transit protocol)
//
   ProtStack.Set(pi->Sched, &XrdXrootdTrace, TRACE_MEM);
   n = (pi->ConnMax/3 ? pi->ConnMax/3 : 30);
   ProtStack.Set(n, 60*60);
   XrdXrootdTransit::Init(pi->Sched, n, 60*60);
 
// Initialize the request ID generation object
//
   PrepID = new XrdOucReqID(pi->urAddr, (int)Port);
 
// Initialize for prepare processing
//
   XrdXrootdPrepQ = new XrdXrootdPrepare(&eDest, pi->Sched, PrepareAlt);
   sprintf(buff, "%%s://%s:%d/&L=%%d&U=%%s", pi->myName, pi->Port);
   Notify = strdup(buff);
 
// Set the redirect flag if we are a pure redirector
//
   int tlsFlags = myRole & kXR_tlsAny;
   myRole = kXR_isServer; myRolf = kXR_DataServer;
   if ((rdf = getenv("XRDREDIRECT"))
   && (!strcmp(rdf, "R") || !strcmp(rdf, "M")))
      {isRedir = *rdf;
       myRole = kXR_isManager; myRolf = kXR_LBalServer;
       if (!strcmp(rdf, "M"))  myRole |=kXR_attrMeta;
      }
   if (fsFeatures & XrdSfs::hasPRXY) myRole |= kXR_attrProxy;
   if (fsFeatures & XrdSfs::hasCACH) myRole |= kXR_attrCache;
   myRole |= tlsFlags;
 
// Turn off client redirects if we are neither a redirector nor a proxy server
//
   if (CL_Redir && !isRedir && !isProxy)
      {CL_Redir = false;
       eDest.Say("Config warning: 'redirect client' ignored; "
                 "not a redirector nor a proxy server");
      }
 
// Check if we are redirecting anything
//
   if ((xp = RPList.Next()))
      {int k;
       char buff[2048], puff[1024];
       do {k = xp->Opts();
           if (Route[k].Host[0] == Route[k].Host[1]
           &&  Route[k].Port[0] == Route[k].Port[1]) *puff = 0;
              else sprintf(puff, "%%%s:%d", Route[k].Host[1], Route[k].Port[1]);
           sprintf(buff," to %s:%d%s",Route[k].Host[0],Route[k].Port[0],puff);
           eDest.Say("Config redirect static ", xp->Path(), buff);
           xp = xp->Next();
          } while(xp);
      }
 
   if ((xp = RQList.Next()))
      {int k;
       const char *cgi1, *cgi2;
       char buff[2048], puff[1024], xCgi[RD_Num] = {0};
       if (isRedir) {cgi1 = "+"; cgi2 = getenv("XRDCMSCLUSTERID");}
          else      {cgi1 = "";  cgi2 = pi->myName;}
       myCNlen = snprintf(buff, sizeof(buff), "%s%s", cgi1, cgi2);
       myCName = strdup(buff);
       do {k = xp->Opts();
           if (Route[k].Host[0] == Route[k].Host[1]
           &&  Route[k].Port[0] == Route[k].Port[1]) *puff = 0;
              else sprintf(puff, "%%%s:%d", Route[k].Host[1], Route[k].Port[1]);
           sprintf(buff," to %s:%d%s",Route[k].Host[0],Route[k].Port[0],puff);
           eDest.Say("Config redirect enoent ", xp->Path(), buff);
           if (!xCgi[k] && cgi2)
              {bool isdup = Route[k].Host[0] == Route[k].Host[1]
                         && Route[k].Port[0] == Route[k].Port[1];
               for (i = 0; i < 2; i++)
                   {n = snprintf(buff,sizeof(buff), "%s?tried=%s%s",
                                 Route[k].Host[i], cgi1, cgi2);
                    free(Route[k].Host[i]); Route[k].Host[i] = strdup(buff);
                    Route[k].RDSz[i] = n;
                    if (isdup) {Route[k].Host[1] = Route[k].Host[0];
                                Route[k].RDSz[1] = n; break;
                               }
                   }
              }
           xCgi[k] = 1;
           xp = xp->Next();
          } while(xp);
      }
 
// Add all jobs that we can run to the admin object
//
   if (JobCKS) XrdXrootdAdmin::addJob("chksum", JobCKS);
 
// Establish the path to be used for admin functions. We will loose this
// storage upon an error but we don't care because we'll just exit.
//
   adminp = XrdOucUtils::genPath(pi->AdmPath, 0, ".xrootd");
 
// Setup the admin path (used in all roles).
//
   if (!(AdminSock = XrdNetSocket::Create(&eDest, adminp, "admin", pi->AdmMode))
   ||  !XrdXrootdAdmin::Init(&eDest, AdminSock)) return 0;
 
// Indicate whether or not we support extended attributes
//
  {XrdOucEnv     myEnv;
   XrdOucErrInfo eInfo("", &myEnv);
   char buff[128];
   if (osFS->FAttr(0, eInfo, 0) == SFS_OK)
      {usxMaxNsz = myEnv.GetInt("usxMaxNsz");
       if (usxMaxNsz < 0) usxMaxNsz = 0;
       usxMaxVsz = myEnv.GetInt("usxMaxVsz");
       if (usxMaxVsz < 0) usxMaxVsz = 0;
       snprintf(buff, sizeof(buff), "%d %d", usxMaxNsz, usxMaxVsz);
       usxParms  = strdup(buff);
      } else {
       usxMaxNsz = 0;
       usxMaxVsz = 0;
       usxParms  = strdup("0 0");
      }
  }
 
// Finally, check if we really need to be in bypass mode if it is set
//
   if (OD_Bypass)
      {const char *penv = getenv("XRDXROOTD_PROXY");
       if (!penv || *penv != '=')
          {OD_Bypass = false;
           eDest.Say("Config warning: 'fsoverload bypass' ignored; "
                                     "not a forwarding proxy.");
          }
      }
 
// Add any additional features
//
   if (fsFeatures & XrdSfs::hasPOSC) myRole |= kXR_supposc;
   if (fsFeatures & XrdSfs::hasPGRW) myRole |= kXR_suppgrw;
   if (fsFeatures & XrdSfs::hasGPF)  myRole |= kXR_supgpf;
   if (fsFeatures & XrdSfs::hasGPFA && myRole & kXR_supgpf)
      myRole |= kXR_anongpf;
 
// Finally note whether or not we have TLS enabled
//
   if (tlsCtx) myRole |= kXR_haveTLS;
 
// Return success
//
   free(adminp);
   return 1;
}

References XrdXrootdAdmin::addJob(), AdminSock, XrdProtocol_Config::AdmMode, XrdProtocol_Config::AdmPath, XrdOucString::append(), XrdProtocol_Config::argc, XrdProtocol_Config::argv, as_aioOK, as_nosf, as_okstutter, as_segsize, XrdProtocol_Config::BPool, XrdXrootd::BPool, BPool, XrdOucString::c_str(), XrdSfsFileSystem::chksum(), CL_Redir, XrdNetPMarkCfg::Config(), XrdProtocol_Config::ConfigFN, XrdProtocol_Config::ConnMax, XrdNetSocket::Create(), XrdSfsFileSystem::csSize, DEBUG, XrdProtocol_Config::DebugON, digFS, XrdNetIF::Display(), XrdProtocol_Config::eDest, eDest, XrdSysError::Emsg(), XrdOucEnv::Export(), XrdSfsFileSystem::FAttr(), XrdSfsFileSystem::Features(), fsFeatures, XrdOucUtils::genPath(), XrdOucEnv::Get(), XrdOucErrInfo::getErrInfo(), XrdOucEnv::GetInt(), XrdOucEnv::GetPtr(), XrdProtocol_Config::hailWait, hailWait, XrdSfs::hasCACH, XrdSfs::hasGPF, XrdSfs::hasGPFA, XrdSfs::hasNAIO, XrdSfs::hasNOSF, XrdSfs::hasPGRW, XrdSfs::hasPOSC, XrdSfs::hasPRP2, XrdSfs::hasPRXY, XrdXrootdProtocol::RD_Table::Host, XrdXrootdTransit::Init(), XrdXrootdAdmin::Init(), XrdXrootdFile::Init(), XrdXrootdRedirHelper::Init(), XrdXrootdXPath::Insert(), isProxy, isRedir, JobCKS, JobCKT, JobCKTLST, JobLCL, kXR_anongpf, kXR_attrCache, kXR_attrMeta, kXR_attrProxy, kXR_DataServer, kXR_haveTLS, kXR_isManager, kXR_isServer, kXR_LBalServer, kXR_supgpf, kXR_suppgrw, kXR_supposc, kXR_tlsAny, Locker, XrdGlobal::Logger, XrdSysError::logger(), maxBuffsz, maxReadv_ior, XrdProto::maxRvecsz, XrdBuffManager::MaxSize(), maxTransz, myCName, myCNlen, XrdProtocol_Config::myInst, myInst, XrdProtocol_Config::myName, myRole, myRolf, XrdInet::netIF, XrdProtocol_Config::NetTCP, XrdOucTList::next, XrdXrootdXPath::Next(), Notify, OD_Bypass, XrdXrootdXPath::Opts(), osFS, XrdXrootdXPath::Path(), PMark, XrdProtocol_Config::Port, XrdNetIF::Port(), Port, XrdXrootdProtocol::RD_Table::Port, PrepareAlt, PrepID, XrdOucEnv::PutPtr(), XrdXrootdProtocol::RD_Table::RDSz, XrdProtocol_Config::readWait, readWait, redirIPHold, RedirPI, Route, RPList, RQList, XrdSysError::Say(), XrdProtocol_Config::Sched, XrdXrootd::Sched, Sched, XrdObjectQ< T >::Set(), XrdSysTrace::SetLogger(), XrdXrootdCallBack::setVals(), XrdLink::sfOK, SFS_OK, XrdXrootd::SI, SI, XrdProtocol_Config::Stats, XrdOucTList::text, XrdProtocol_Config::theEnv, XrdProtocol_Config::tlsCtx, tlsCtx, XrdProtocol_Config::tlsPort, tlsPort, XrdProtocol_Config::totalCF, TRACE, TRACE_ALL, TRACE_MEM, usxMaxNsz, usxMaxVsz, usxParms, XrdSysTrace::What, Window, XrdProtocol_Config::WSize, XPList, XrdDigGetFS(), XrdXrootdCF, XrdXrootdInstance, XrdXrootdPort, XrdXrootdPrepQ, XrdXrootdTrace, and XROOTDXP_NOSLASH.

Referenced by XrdgetProtocol().

Here is the call graph for this function:

Here is the caller graph for this function:

do_WriteSpan()

int XrdXrootdProtocol::do_WriteSpan

(

)

Definition at line 3555 of file XrdXrootdXeq.cc.

{
   int rc;
   XrdXrootdFHandle fh(Request.write.fhandle);
   numWrites++;
 
// Unmarshall the data
//
   IO.IOLen  = Request.header.dlen;
              n2hll(Request.write.offset, IO.Offset);
 
// Find the file object. We will only drain socket data on the control path.
//                                                                             .
   if (!FTab || !(IO.File = FTab->Get(fh.handle)))
      {IO.IOLen -= myBlast;
       IO.File = 0;
       return do_WriteNone(Request.write.pathid);
      }
 
// If we are monitoring, insert a write entry
//
   if (Monitor.InOut())
      Monitor.Agent->Add_wr(IO.File->Stats.FileID, Request.write.dlen,
                                                  Request.write.offset);
   IO.File->Stats.wrOps(IO.IOLen); // Optimistically correct
 
// Trace this entry
//
   TRACEP(FSIO, "fh=" <<fh.handle <<" write " <<IO.IOLen <<'@' <<IO.Offset);
 
// Write data that was already read
//
   if ((rc = IO.File->XrdSfsp->write(IO.Offset, myBuff, myBlast)) < 0)
      {IO.IOLen  = IO.IOLen-myBlast; IO.EInfo[0] = rc; IO.EInfo[1] = 0;
       return do_WriteNone();
      }
    IO.Offset += myBlast; IO.IOLen -= myBlast;
 
// See if we need to finish this request in the normal way
//
   if (IO.IOLen > 0) return do_WriteAll();
   return Response.Send();
}

References XrdXrootdMonitor::Add_wr(), XrdXrootdMonitor::User::Agent, ClientRequestHdr::dlen, ClientWriteRequest::dlen, ClientWriteRequest::fhandle, XrdXrootd::IOParms::File, XrdXrootdFileStats::FileID, FTab, XrdXrootdFileTable::Get(), XrdXrootdFHandle::handle, ClientRequest::header, XrdXrootdMonitor::User::InOut(), IO, XrdXrootd::IOParms::IOLen, Monitor, myBlast, myBuff, numWrites, ClientWriteRequest::offset, ClientWriteRequest::pathid, Request, Response, XrdXrootdResponse::Send(), XrdXrootdFile::Stats, TRACEP, ClientRequest::write, XrdSfsFile::write(), XrdXrootdFileStats::wrOps(), and XrdXrootdFile::XrdSfsp.

Here is the call graph for this function:

DoIt()

void XrdXrootdProtocol::DoIt ( )

inlineoverridevirtual

Implements XrdJob.

Definition at line 173 of file XrdXrootdProtocol.hh.

{(*this.*Resume)();}

References Resume.

getData() [1/2]

int XrdXrootdProtocol::getData	(	gdCallBack *	gdcbP,
		const char *	dtype,
		char *	buff,
		int	blen
	)

Referenced by Process(), and ProcSig().

Here is the caller graph for this function:

getData() [2/2]

int XrdXrootdProtocol::getData	(	gdCallBack *	gdcbP,
		const char *	dtype,
		struct iovec *	iov,
		int	iovn
	)

getDump()

int XrdXrootdProtocol::getDump	(	const char *	dtype,
		int	dlen
	)

Definition at line 1404 of file XrdXrootdProtocol.cc.

{
   bool inCB = (gdCtl.Status == GetDataCtl::inCallBk);
 
// Setup the control information to direct the vector read
//
   memset((char *)&gdCtl, 0, sizeof(gdCtl));
   gdCtl.DumpLen = dlen;     // Bytes left to drain
   gdCtl.ioDType = dtype;    // Name of the data being read for tracing
   gdCtl.Status  = GetDataCtl::inDump;
 
// Effect the read. We prevent recursive calls if this was called while
// we were in a callback, which is possible due to I/O continuations.
//
   return (inCB ? 1 : getDumpCont());
}

References gdCtl, XrdXrootdProtocol::GetDataCtl::inCallBk, XrdXrootdProtocol::GetDataCtl::inDump, XrdXrootdProtocol::GetDataCtl::ioDType, and XrdXrootdProtocol::GetDataCtl::Status.

Referenced by XrdXrootdAioTask::gdDone().

Here is the caller graph for this function:

getPathID()

int XrdXrootdProtocol::getPathID ( )

inline

Definition at line 185 of file XrdXrootdProtocol.hh.

{return PathID;}

References PathID.

Referenced by XrdXrootdAioFob::Reset(), and XrdXrootdAioFob::Schedule().

Here is the caller graph for this function:

getSID()

unsigned int XrdXrootdProtocol::getSID ( )

staticprotected

Definition at line 271 of file XrdXrootdProtocol.cc.

{
   static XrdSysMutex  SidMutex;
   static unsigned int Sid = 1;
   unsigned int theSid;
 
// Generate unqiue number for this server instance
//
   AtomicBeg(SidMutex);
   theSid = AtomicInc(Sid);
   AtomicEnd(SidMutex);
   return theSid;
}

References AtomicBeg, AtomicEnd, and AtomicInc.

Match()

XrdProtocol * XrdXrootdProtocol::Match ( XrdLink *  lp )

overridevirtual

Implements XrdProtocol.

Definition at line 291 of file XrdXrootdProtocol.cc.

{
static  const int hsSZ = sizeof(ClientInitHandShake);
        char hsbuff[hsSZ];
        struct ClientInitHandShake   *hsData = (ClientInitHandShake *)hsbuff;
 
static  struct hs_response
               {kXR_unt16 streamid;
                kXR_unt16 status;
                kXR_unt32 rlen;   // Specified as kXR_int32 in doc!
                kXR_unt32 pval;   // Specified as kXR_int32 in doc!
                kXR_unt32 styp;   // Specified as kXR_int32 in doc!
               } hsresp={0, 0, htonl(8), htonl(kXR_PROTOCOLVERSION),
                         (isRedir ? htonl((unsigned int)kXR_LBalServer)
                                  : htonl((unsigned int)kXR_DataServer))};
XrdXrootdProtocol *xp;
int dlen, rc;
 
// Peek at the first 20 bytes of data
//
   if ((dlen = lp->Peek(hsbuff, hsSZ, hailWait)) < hsSZ)
      {if (dlen <= 0) lp->setEtext("handshake not received");
       return (XrdProtocol *)0;
      }
 
// Trace the data
//
// TRACEI(REQ, "received: " <<Trace->bin2hex(hsbuff,dlen));
 
// Verify that this is our protocol
//
   hsData->fourth  = ntohl(hsData->fourth);
   hsData->fifth   = ntohl(hsData->fifth);
   if (hsData->first || hsData->second || hsData->third
   ||  hsData->fourth != 4 || hsData->fifth != ROOTD_PQ) return 0;
 
// Send the handshake response. We used optimize the subsequent protocol
// request sent with handshake but the protocol request is now overloaded.
//
   rc = lp->Send((char *)&hsresp, sizeof(hsresp));
 
// Verify that our handshake response was actually sent
//
   if (!rc)
      {lp->setEtext("handshake failed");
       return (XrdProtocol *)0;
      }
 
// We can now read all 20 bytes and discard them (no need to wait for it)
//
   if (lp->Recv(hsbuff, hsSZ) != hsSZ)
      {lp->setEtext("reread failed");
       return (XrdProtocol *)0;
      }
 
// Get a protocol object off the stack (if none, allocate a new one)
//
   if (!(xp = ProtStack.Pop())) xp = new XrdXrootdProtocol();
 
// Bind the protocol to the link and return the protocol
//
   SI->Bump(SI->Count);
   xp->Link = lp;
   xp->Response.Set(lp);
   strcpy(xp->Entity.prot, "host");
   xp->Entity.host = (char *)lp->Host();
   xp->Entity.addrInfo = lp->AddrInfo();
   return (XrdProtocol *)xp;
}

References XrdXrootdProtocol(), XrdLink::AddrInfo(), XrdSecEntity::addrInfo, XrdOucStats::Bump(), XrdXrootdStats::Count, Entity, ClientInitHandShake::fifth, ClientInitHandShake::first, ClientInitHandShake::fourth, hailWait, XrdLink::Host(), XrdSecEntity::host, isRedir, kXR_DataServer, kXR_LBalServer, kXR_PROTOCOLVERSION, Link, XrdLink::Peek(), XrdObjectQ< T >::Pop(), XrdSecEntity::prot, XrdLink::Recv(), Response, ROOTD_PQ, ClientInitHandShake::second, XrdLink::Send(), XrdXrootdResponse::Set(), XrdLink::setEtext(), SI, and ClientInitHandShake::third.

Here is the call graph for this function:

MonAuth()

void XrdXrootdProtocol::MonAuth ( )

protected

Definition at line 4345 of file XrdXrootdXeq.cc.

{
         char Buff[4096];
   const char *bP = Buff;
 
   if (Client == &Entity) bP = Entity.moninfo;
      else {snprintf(Buff,sizeof(Buff),
                    "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
                     Client->prot,
                    (Client->name ? Client->name : ""),
                    (Client->host ? Client->host : ""),
                    (Client->vorg ? Client->vorg : ""),
                    (Client->role ? Client->role : ""),
                    (Client->grps ? Client->grps : ""),
                    (Client->moninfo ? Client->moninfo : ""),
                    (Entity.moninfo  ? Entity.moninfo  : ""),
                    (clientPV & XrdOucEI::uIPv4 ? '4' : '6')
                   );
            Client->secMon = &Monitor;
           }
 
   Monitor.Report(bP);
   if (Entity.moninfo) {free(Entity.moninfo); Entity.moninfo = 0;}
}

References Client, clientPV, Entity, XrdSecEntity::grps, XrdSecEntity::host, XrdSecEntity::moninfo, Monitor, XrdSecEntity::name, XrdSecEntity::prot, XrdXrootdMonitor::User::Report(), XrdSecEntity::role, XrdSecEntity::secMon, XrdOucEI::uIPv4, and XrdSecEntity::vorg.

Here is the call graph for this function:

operator=()

XrdXrootdProtocol XrdXrootdProtocol::operator= ( const XrdXrootdProtocol &  rhs )

delete

Process()

int XrdXrootdProtocol::Process ( XrdLink *  lp )

overridevirtual

Implements XrdProtocol.

Reimplemented in XrdXrootdTransit.

Definition at line 368 of file XrdXrootdProtocol.cc.

{
   int rc;
   kXR_unt16 reqID;
 
// Check if we are servicing a slow link
//
   if (Resume)
      {if (myBlen && (rc = getData("data", myBuff, myBlen)) != 0) return rc;
          else if ((rc = (*this.*Resume)()) != 0) return rc;
                  else {Resume = 0; return 0;}
      }
 
// Read the next request header
//
   if ((rc=getData("request",(char *)&Request,sizeof(Request))) != 0) return rc;
 
// Check if we need to copy the request prior to unmarshalling it
//
   reqID = ntohs(Request.header.requestid);
   if (reqID != kXR_sigver && NEED2SECURE(Protect)(Request))
      {memcpy(&sigReq2Ver, &Request, sizeof(ClientRequest));
       sigNeed = true;
      }
 
// Deserialize the data
//
   Request.header.requestid = reqID;
   Request.header.dlen      = ntohl(Request.header.dlen);
   Response.Set(Request.header.streamid);
   TRACEP(REQ, "req=" <<XProtocol::reqName(reqID)
               <<" dlen=" <<Request.header.dlen);
 
// Every request has an associated data length. It better be >= 0 or we won't
// be able to know how much data to read.
//
   if (Request.header.dlen < 0)
      {Response.Send(kXR_ArgInvalid, "Invalid request data length");
       return Link->setEtext("protocol data length error");
      }
 
// Process sigver requests now as they appear ahead of a request
//
   if (reqID == kXR_sigver) return ProcSig();
 
// Read any argument data at this point, except when the request is a write.
// The argument may have to be segmented and we're not prepared to do that here.
//
   if (reqID != kXR_write && reqID != kXR_pgwrite && Request.header.dlen)
      {if (!argp || Request.header.dlen+1 > argp->bsize)
          {if (argp) BPool->Release(argp);
           if (!(argp = BPool->Obtain(Request.header.dlen+1)))
              {Response.Send(kXR_ArgTooLong, "Request argument is too long");
               return 0;
              }
           hcNow = hcPrev; halfBSize = argp->bsize >> 1;
          }
       argp->buff[Request.header.dlen] = '\0';
       if ((rc = getData("arg", argp->buff, Request.header.dlen)))
          {Resume = &XrdXrootdProtocol::Process2; return rc;}
      }
 
// Continue with request processing at the resume point
//
   return Process2();
}

References argp, BPool, XrdBuffer::bsize, XrdBuffer::buff, ClientRequestHdr::dlen, getData(), halfBSize, hcNow, hcPrev, ClientRequest::header, kXR_ArgInvalid, kXR_ArgTooLong, kXR_pgwrite, kXR_sigver, kXR_write, Link, myBlen, myBuff, NEED2SECURE, XrdBuffManager::Obtain(), Process2(), ProcSig(), Protect, XrdBuffManager::Release(), XProtocol::reqName(), Request, ClientRequestHdr::requestid, Response, Resume, XrdXrootdResponse::Send(), XrdXrootdResponse::Set(), XrdLink::setEtext(), sigNeed, sigReq2Ver, ClientRequestHdr::streamid, and TRACEP.

Referenced by XrdXrootdTransit::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

Process2()

int XrdXrootdProtocol::Process2

(

)

Definition at line 439 of file XrdXrootdProtocol.cc.

{
// If we are verifying requests, see if this request needs to be verified
//
   if (sigNeed)
      {const char *eText = "Request not signed";
       if (!sigHere || (eText = Protect->Verify(sigReq,sigReq2Ver,argp->buff)))
          {Response.Send(kXR_SigVerErr, eText);
           TRACEP(REQ, "req=" <<XProtocol::reqName(Request.header.requestid)
                  <<" verification failed; " <<eText);
           SI->Bump(SI->badSCnt);
           return Link->setEtext(eText);
          } else {
           SI->Bump(SI->aokSCnt);
           sigNeed = sigHere = false;
         }
      } else {
       if (sigHere)
          {TRACEP(REQ, "req=" <<XProtocol::reqName(Request.header.requestid)
                     <<" unneeded signature discarded.");
           if (sigWarn)
              {eDest.Emsg("Protocol","Client is needlessly signing requests.");
               sigWarn = false;
              }
           SI->Bump(SI->ignSCnt);
           sigHere = false;
          }
      }
 
// If the user is not yet logged in, restrict what the user can do
//
   if (!Status)
      switch(Request.header.requestid)
            {case kXR_login:    return do_Login();
             case kXR_protocol: return do_Protocol();
             case kXR_bind:     return do_Bind();
             default:           Response.Send(kXR_InvalidRequest,
                                "Invalid request; user not logged in");
                                return Link->setEtext("request without login");
            }
 
// Help the compiler, select the the high activity requests (the ones with
// file handles) in a separate switch statement. A special case exists for
// sync() which return with a callback, so handle it here. Note that stat(fh)
// normally never does a callback but historically we allowed it to do so.
// We maintain that capability even when it's likely never used.
//
   switch(Request.header.requestid)   // First, the ones with file handles
         {case kXR_read:     return do_Read();
          case kXR_readv:    return do_ReadV();
          case kXR_write:    return do_Write();
          case kXR_writev:   return do_WriteV();
          case kXR_pgread:   return do_PgRead();
          case kXR_pgwrite:  return do_PgWrite();
          case kXR_sync:     ReqID.setID(Request.header.streamid);
                             return do_Sync();
          case kXR_close:    ReqID.setID(Request.header.streamid);
                             return do_Close();
          case kXR_stat:     if (!Request.header.dlen)
                                {ReqID.setID(Request.header.streamid);
                                 return do_Stat();
                                }
                             break;
          case kXR_truncate: ReqID.setID(Request.header.streamid);
                             if (!Request.header.dlen) return do_Truncate();
                             break;
          case kXR_query:    if (!Request.header.dlen) return do_Qfh();
                             break;
          case kXR_chkpoint: return do_ChkPnt();
          case kXR_clone:    return do_Clone();
          default:           break;
         }
 
// Now select the requests that do not need authentication
//
   switch(Request.header.requestid)
         {case kXR_protocol: return do_Protocol();   // dlen ignored
          case kXR_ping:     return do_Ping();       // dlen ignored
          default:           break;
         }
 
// Force authentication at this point, if need be
//
   if (Status & XRD_NEED_AUTH)
      {int rc;
       if (Request.header.requestid == kXR_auth) rc = do_Auth();
          else {Response.Send(kXR_InvalidRequest,
                              "Invalid request; user not authenticated");
                rc = -1;
               }
       if (tlsCtx) XrdTls::ClearErrorQueue();
       return rc;
      }
 
// Construct request ID as the following functions are async eligible
//
   ReqID.setID(Request.header.streamid);
 
// Process items that don't need arguments but may have them
//
   switch(Request.header.requestid)
         {case kXR_endsess:   return do_Endsess();
          default:            break;
         }
 
// All remaining requests require an argument. Make sure we have one
//
   if (!argp || !Request.header.dlen)
      {Response.Send(kXR_ArgMissing, "Required argument not present");
       return 0;
      }
 
// All of the subsequent requests can be redirected and are subject to
// prefunctory redirection which we check here.
//
   if (CL_Redir && !Link->hasBridge())
      {bool doRdr = false;
       if (Link->AddrInfo()->isPrivate()) rdType = 1;
            if (RouteClient.pvtIP && rdType) doRdr = true;
       else if (RouteClient.lclDom && XrdNetIF::InDomain( Link->AddrInfo()))
               doRdr = true;
       else if (RouteClient.DomCnt)
               {XrdOucString hName = Link->Host();
                for (int i = 0; i < RouteClient.DomCnt; i++)
                    {if (hName.endswith(RouteClient.Domain[i]))
                        {doRdr = true; break;}
                    }
               }
       if (doRdr)
          {Response.Send(kXR_redirect,Route[RD_client].Port[rdType],
                                      Route[RD_client].Host[rdType]);
           return -1;
          }
      }
 
// Process items that keep own statistics
//
   switch(Request.header.requestid)
         {case kXR_open:      return do_Open();
          case kXR_gpfile:    return do_gpFile();
          default:            break;
         }
 
// Update misc stats count
//
   SI->Bump(SI->miscCnt);
 
// Now process whatever we have
//
   switch(Request.header.requestid)
         {case kXR_chmod:     return do_Chmod();
          case kXR_dirlist:   return do_Dirlist();
          case kXR_fattr:     return do_FAttr();
          case kXR_locate:    return do_Locate();
          case kXR_mkdir:     return do_Mkdir();
          case kXR_mv:        return do_Mv();
          case kXR_query:     return do_Query();
          case kXR_prepare:   return do_Prepare();
          case kXR_rm:        return do_Rm();
          case kXR_rmdir:     return do_Rmdir();
          case kXR_set:       return do_Set();
          case kXR_stat:      return do_Stat();
          case kXR_statx:     return do_Statx();
          case kXR_truncate:  return do_Truncate();
          default:            break;
         }
 
// Whatever we have, it's not valid
//
   Response.Send(kXR_InvalidRequest, "Invalid request code");
   return 0;
}

References XrdLink::AddrInfo(), XrdXrootdStats::aokSCnt, argp, XrdXrootdStats::badSCnt, XrdBuffer::buff, XrdOucStats::Bump(), CL_Redir, XrdTls::ClearErrorQueue(), ClientRequestHdr::dlen, XrdXrootdProtocol::RC_Table::Domain, XrdXrootdProtocol::RC_Table::DomCnt, eDest, XrdSysError::Emsg(), XrdOucString::endswith(), XrdLink::hasBridge(), ClientRequest::header, XrdLink::Host(), XrdXrootdStats::ignSCnt, XrdNetIF::InDomain(), XrdNetAddrInfo::isPrivate(), kXR_ArgMissing, kXR_auth, kXR_bind, kXR_chkpoint, kXR_chmod, kXR_clone, kXR_close, kXR_dirlist, kXR_endsess, kXR_fattr, kXR_gpfile, kXR_InvalidRequest, kXR_locate, kXR_login, kXR_mkdir, kXR_mv, kXR_open, kXR_pgread, kXR_pgwrite, kXR_ping, kXR_prepare, kXR_protocol, kXR_query, kXR_read, kXR_readv, kXR_redirect, kXR_rm, kXR_rmdir, kXR_set, kXR_SigVerErr, kXR_stat, kXR_statx, kXR_sync, kXR_truncate, kXR_write, kXR_writev, XrdXrootdProtocol::RC_Table::lclDom, Link, XrdXrootdStats::miscCnt, Port, Protect, XrdXrootdProtocol::RC_Table::pvtIP, rdType, ReqID, XProtocol::reqName(), Request, ClientRequestHdr::requestid, Response, Route, RouteClient, XrdXrootdResponse::Send(), XrdLink::setEtext(), XrdXrootdReqID::setID(), SI, sigHere, sigNeed, sigReq, sigReq2Ver, sigWarn, Status, ClientRequestHdr::streamid, tlsCtx, TRACEP, XrdSecProtect::Verify(), and XRD_NEED_AUTH.

Referenced by XrdXrootdTransit::Process(), Process(), XrdXrootdTransit::Redrive(), and XrdXrootdTransit::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcSig()

int XrdXrootdProtocol::ProcSig

(

)

Definition at line 616 of file XrdXrootdProtocol.cc.

{
   int rc;
 
// Check if we completed reading the signature and if so, we are done
//
   if (sigRead)
      {sigRead = false;
       sigHere = true;
       return 0;
      }
 
// Verify that the hash is not longer that what we support and is present
//
   if (Request.header.dlen <= 0
   ||  Request.header.dlen > (int)sizeof(sigBuff))
      {Response.Send(kXR_ArgInvalid, "Invalid signature data length");
       return Link->setEtext("signature data length error");
      }
 
// Save relevant information for the next round
//
   memcpy(&sigReq, &Request, sizeof(ClientSigverRequest));
   sigReq.header.dlen = htonl(Request.header.dlen);
 
// Now read in the signature
//
   sigRead = true;
   if ((rc = getData("arg", sigBuff, Request.header.dlen)))
      {Resume = &XrdXrootdProtocol::ProcSig; return rc;}
   sigRead = false;
 
// All done
//
   sigHere = true;
   return 0;
}

References ClientRequestHdr::dlen, getData(), ClientRequest::header, SecurityRequest::header, kXR_ArgInvalid, Link, Request, Response, Resume, XrdXrootdResponse::Send(), XrdLink::setEtext(), sigBuff, sigHere, sigRead, and sigReq.

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

Reclaim()

void XrdXrootdProtocol::Reclaim ( XrdSfsXioHandle  h )

static

Definition at line 926 of file XrdXrootdProtocol.cc.

{
 
   if (h) BPool->Release((XrdBuffer *)h);
}

References BPool, and XrdBuffManager::Release().

Here is the call graph for this function:

Recycle()

void XrdXrootdProtocol::Recycle ( XrdLink *  lp, int  consec, const char *  reason  )

overridevirtual

Implements XrdProtocol.

Reimplemented in XrdXrootdTransit.

Definition at line 661 of file XrdXrootdProtocol.cc.

{
   char *sfxp, ctbuff[24], buff[128], Flags = (reason ? XROOTD_MON_FORCED : 0);
   const char *What;
   XrdSysMutexHelper recycleHelper(unbindMutex);
 
// Check for disconnect or unbind
//
   if (Status == XRD_BOUNDPATH) {What = "unbind"; Flags |= XROOTD_MON_BOUNDP;}
      else What = "disc";
 
// Document the disconnect or undind
//
   if (lp)
      {XrdSysTimer::s2hms(csec, ctbuff, sizeof(ctbuff));
       if (reason && strcmp(reason, "hangup"))
          {snprintf(buff, sizeof(buff), "%s (%s)", ctbuff, reason);
           sfxp = buff;
          } else sfxp = ctbuff;
 
       eDest.Log(SYS_LOG_02, "Xeq", lp->ID, (char *)What, sfxp);
      }
 
// Handle any waiting read on this link. This is a tricky proposition because
// we don't know if the thread is waiting to run or not. However, we will
// indicate that gdFail was already called and should the thread run, it will
// promptly exit should it ever run again. That way, we handle the cleanup.
//
   if (gdCtl.linkWait.fetch_or(GetDataCtl::Terminate) == GetDataCtl::Active
   && (gdCtl.Status == GetDataCtl::inData
   ||  gdCtl.Status == GetDataCtl::inDataIov)) gdCtl.CallBack->gdFail();
 
// If this is a bound stream then we cannot release the resources until
// all activity ceases on this stream (i.e., lp == 0). This is only relevant for
// writes that read from the link. if we are still tagged as active and not
// waiting for link activity then ask to be signalled once activity stops.
// Otherwise, redrive the parallel I/O so that it cleans up.
//
   if (lp && Status == XRD_BOUNDPATH)
      {streamMutex.Lock();
       isNOP = true;
       if (isActive)
          {if (isLinkWT)
              {streamMutex.UnLock();
               do_OffloadIO();
              } else {
               while(isActive)
                    {XrdSysCondVar2 aioDone(streamMutex);
                     endNote = &aioDone;
                     aioDone.Wait();
                     endNote = 0;
                    }
               streamMutex.UnLock();
              }
          } else streamMutex.UnLock();
       boundRecycle->Post();
       if (lp) return;  // Async close
      }
 
// Release all appendages
//
   Cleanup();
 
// If we are monitoring logins then we are also monitoring disconnects. We do
// this after cleanup so that close records can be generated before we cut a
// disconnect record. This then requires we clear the monitor object here.
// We and the destrcutor are the only ones who call cleanup and a deletion
// will call the monitor clear method. So, we won't leak memeory.
//
   if (Monitor.Logins()) Monitor.Agent->Disc(Monitor.Did, csec, Flags);
   if (Monitor.Fstat() ) XrdXrootdMonFile::Disc(Monitor.Did);
   Monitor.Clear();
 
// Set fields to starting point (debugging mostly)
//
   Reset();
 
// Push ourselves on the stack
//
   if (Response.isOurs()) ProtStack.Push(&ProtLink);
}

References XrdXrootdProtocol::GetDataCtl::Active, XrdXrootdMonitor::User::Agent, boundRecycle, XrdXrootdProtocol::GetDataCtl::CallBack, XrdXrootdMonitor::User::Clear(), XrdXrootdMonitor::User::Did, XrdXrootdMonitor::Disc(), XrdXrootdMonFile::Disc(), eDest, endNote, XrdSys::RAtomic< T >::fetch_or(), XrdXrootdMonitor::User::Fstat(), gdCtl, XrdXrootd::gdCallBack::gdFail(), XrdLink::ID, XrdXrootdProtocol::GetDataCtl::inData, XrdXrootdProtocol::GetDataCtl::inDataIov, isActive, isLinkWT, isNOP, XrdXrootdResponse::isOurs(), XrdXrootdProtocol::GetDataCtl::linkWait, XrdSysMutex::Lock(), XrdSysError::Log(), XrdXrootdMonitor::User::Logins(), Monitor, XrdSysSemaphore::Post(), XrdObjectQ< T >::Push(), Response, XrdSysTimer::s2hms(), Status, XrdXrootdProtocol::GetDataCtl::Status, streamMutex, SYS_LOG_02, XrdXrootdProtocol::GetDataCtl::Terminate, unbindMutex, XrdSysMutex::UnLock(), XrdSysCondVar2::Wait(), XRD_BOUNDPATH, XROOTD_MON_BOUNDP, and XROOTD_MON_FORCED.

Referenced by XrdXrootdTransit::Disc(), and XrdXrootdTransit::Recycle().

Here is the call graph for this function:

Here is the caller graph for this function:

RequestClose()

bool XrdXrootdProtocol::RequestClose ( )

protected

Definition at line 1551 of file XrdXrootdProtocol.cc.

{
   XrdSysMutexHelper lk(unbindMutex);
   if (CloseRequested) return false;
   CloseRequested = true;
   return true;
}

References CloseRequested, and unbindMutex.

Referenced by CloseRequestCb().

Here is the caller graph for this function:

SendFile() [1/2]

int XrdXrootdProtocol::SendFile ( int  fildes )

overridevirtual

Send data to a client using the sendfile() system interface.

Parameters

fildes

- The file descriptor to use to effect a sendfile() for all of the requested data. The original offset and length are used relative to this file descriptor.

Returns

>0 - data has been sent in a previous call. This is indicative of a logic error in SendData() as only one call is allowed.

=0 - data has been sent.

<0 - A fatal transmission error occurred. SendData() should return SFS_ERROR to force the connection to be closed.

Implements XrdSfsDio.

Definition at line 3832 of file XrdXrootdXeq.cc.

{
 
// Make sure we have some data to send
//
   if (!IO.IOLen) return 1;
 
// Send off the data
//
   IO.IOLen = Response.Send(fildes, IO.Offset, IO.IOLen);
   return IO.IOLen;
}

References IO, XrdXrootd::IOParms::IOLen, Response, and XrdXrootdResponse::Send().

Here is the call graph for this function:

SendFile() [2/2]

int XrdXrootdProtocol::SendFile ( XrdOucSFVec *  sfvec, int  sfvnum  )

overridevirtual

Send data to a client using the sendfile() system interface.

Parameters

sfvec	- One or more XrdOucSFVec elements describing what should be transferred. The first element of the vector must be available for use by the interface for proper framing. That is, start filling in elements at sfvec[1] and sfvnum should be the count of elements filled in plus 1.
sfvnum	- total number of elements in sfvec and includes the first unused element. There is a maximum number of elements that the vector may have; defined inside XrdOucSFVec.

Returns

>0 - either data has been sent in a previous call or the total amount of data in sfvec is greater than the original request. This is indicative of a SendData() logic error.

=0 - data has been sent.

<0 - A fatal transmission error occurred. SendData() should return SFS_ERROR to force the connection to be closed.

Implements XrdSfsDio.

Definition at line 3847 of file XrdXrootdXeq.cc.

{
   int i, xframt = 0;
 
// Make sure we have some data to send
//
   if (!IO.IOLen) return 1;
 
// Verify the length, it can't be greater than what the client wants
//
   for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
   if (xframt > IO.IOLen) return 1;
 
// Send off the data
//
   if (xframt) IO.IOLen = Response.Send(sfvec, sfvnum, xframt);
      else {IO.IOLen = 0; Response.Send();}
   return IO.IOLen;
}

References IO, XrdXrootd::IOParms::IOLen, Response, and XrdXrootdResponse::Send().

Here is the call graph for this function:

SetFD()

void XrdXrootdProtocol::SetFD ( int  fildes )

overridevirtual

Change the file descriptor setting and, consequently, interface processing.

Parameters

fildes

- The file descriptor to use in the future, as follows: < 0 - Disable sendfile and always use read(). >= 0 - Enable sendfile and always use sendfile() w/o invoking this interface (i.e. fast path).

Implements XrdSfsDio.

Definition at line 3871 of file XrdXrootdXeq.cc.

{
   if (fildes < 0) IO.File->sfEnabled = 0;
      else IO.File->fdNum = fildes;
}

References XrdXrootd::IOParms::File, IO, and XrdXrootdFile::sfEnabled.

SetSF()

int XrdXrootdProtocol::SetSF ( kXR_char *  fhandle, bool  seton = false  )

protected

Definition at line 4414 of file XrdXrootdXeq.cc.

{
   XrdXrootdFHandle fh(fhandle);
   XrdXrootdFile   *theFile;
 
   if (!FTab || !(theFile = FTab->Get(fh.handle))) return -EBADF;
 
// Turn it off or on if so wanted
//
   if (!seton) theFile->sfEnabled = 0;
      else if (theFile->fdNum >= 0) theFile->sfEnabled = 1;
 
// All done
//
   return 0;
}

References FTab, XrdXrootdFileTable::Get(), XrdXrootdFHandle::handle, and XrdXrootdFile::sfEnabled.

Referenced by XrdXrootdTransit::setSF().

Here is the call graph for this function:

Here is the caller graph for this function:

Stats()

int XrdXrootdProtocol::Stats ( char *  buff, int  blen, int  do_sync = 0  )

overridevirtual

Implements XrdProtocol.

Definition at line 857 of file XrdXrootdProtocol.cc.

{
// Synchronize statistics if need be
//
   if (do_sync)
      {SI->statsMutex.Lock();
       SI->readCnt += numReads;
       cumReads += numReads; numReads  = 0;
       SI->prerCnt += numReadP;
       cumReadP += numReadP; numReadP = 0;
 
       SI->rvecCnt += numReadV;
       cumReadV += numReadV; numReadV = 0;
       SI->rsegCnt += numSegsV;
       cumSegsV += numSegsV; numSegsV = 0;
 
       SI->wvecCnt += numWritV;
       cumWritV += numWritV; numWritV = 0;
       SI->wsegCnt += numSegsW;
       cumSegsW += numSegsW, numSegsW = 0;
 
       SI->writeCnt += numWrites;
       cumWrites+= numWrites;numWrites = 0;
       SI->statsMutex.UnLock();
      }
 
// Now return the statistics
//
   return SI->Stats(buff, blen, do_sync);
}

References cumReadP, cumReads, cumReadV, cumSegsV, cumSegsW, cumWrites, cumWritV, XrdSysMutex::Lock(), numReadP, numReads, numReadV, numSegsV, numSegsW, numWrites, numWritV, XrdXrootdStats::prerCnt, XrdXrootdStats::readCnt, XrdXrootdStats::rsegCnt, XrdXrootdStats::rvecCnt, SI, XrdXrootdStats::Stats(), XrdOucStats::statsMutex, XrdSysMutex::UnLock(), XrdXrootdStats::writeCnt, XrdXrootdStats::wsegCnt, and XrdXrootdStats::wvecCnt.

Here is the call graph for this function:

StreamNOP()

void XrdXrootdProtocol::StreamNOP

(

)

Definition at line 936 of file XrdXrootdProtocol.cc.

{
 
// Mark this stream as not operation if it is not the control strea,
//
   if (PathID)
      {streamMutex.Lock();
       isNOP = true;
       streamMutex.UnLock();
      }
}

References isNOP, XrdSysMutex::Lock(), PathID, streamMutex, and XrdSysMutex::UnLock().

Here is the call graph for this function:

Swap()

XrdSfsXioHandle XrdXrootdProtocol::Swap ( const char *  curBuff, XrdSfsXioHandle  oldHand = 0  )

overridevirtual

Swap the current I/O buffer

Parameters

curBuff	- The address of the current buffer. It must match the the buffer that was most recently passed to the caller.
oldHand	- The handle associated with a buffer returned by a previous call to Swap(). A value of zero indicates that the caller is taking control of the buffer but has no replacement buffer.

Returns

!0 The buffer handle of the current buffer is returned along with ownership rights. If oldHand was not nil, the caller's ownership of the associated buffer is reclaimed.

=0 An error occurred and nothing has changed; errno holds the reason for the error. Typically, EINVAL - curBuff doe not match current buffer. ENOBUFS - not enough memory to give up buffer. ENOTSUP - unsupported context for call.

Implements XrdSfsXio.

Definition at line 952 of file XrdXrootdProtocol.cc.

{
   XrdBuffer *oldBP = argp;
 
// Verify the context and linkage and if OK, swap buffers
//
   if (Request.header.requestid != kXR_write) errno = ENOTSUP;
      else if (buff != argp->buff) errno = EINVAL;
              else {if (h)
                       {argp = (XrdBuffer *)h;
                        return oldBP;
                       } else {
                        argp = BPool->Obtain(argp->bsize);
                        if (argp) return oldBP;
                        argp = oldBP;
                        errno = ENOBUFS;
                       }
                   }
   return 0;
}

References argp, BPool, XrdBuffer::bsize, XrdBuffer::buff, ClientRequest::header, kXR_write, XrdBuffManager::Obtain(), Request, and ClientRequestHdr::requestid.

Referenced by Claim().

Here is the call graph for this function:

Here is the caller graph for this function:

VerifyStream()

XrdXrootdProtocol * XrdXrootdProtocol::VerifyStream	(	int &	rc,
		int	pID,
		bool	lok = true
	)

Definition at line 977 of file XrdXrootdProtocol.cc.

{
   XrdXrootdProtocol *pp;
 
// Verify that the path actually exists
//
   if (pID >= maxStreams || !(pp = Stream[pID]))
      {rc = Response.Send(kXR_ArgInvalid, "invalid path ID");
       return 0;
      }
 
// Verify that this path is still functional
//
   pp->streamMutex.Lock();
   if (pp->isNOP)
      {pp->streamMutex.UnLock();
       rc = Response.Send(kXR_ArgInvalid, "path ID is not operational");
       return 0;
      }
 
// All done!
//
   if (!lok) pp->streamMutex.UnLock();
   return pp;
}

References isNOP, kXR_ArgInvalid, XrdSysMutex::Lock(), maxStreams, Response, XrdXrootdResponse::Send(), Stream, streamMutex, and XrdSysMutex::UnLock().

Here is the call graph for this function:

Friends And Related Function Documentation

XrdXrootdAdmin

friend class XrdXrootdAdmin

friend

Definition at line 160 of file XrdXrootdProtocol.hh.

Member Data Documentation

ableTLS

bool XrdXrootdProtocol::ableTLS

protected

Definition at line 624 of file XrdXrootdProtocol.hh.

AdminSock

XrdNetSocket * XrdXrootdProtocol::AdminSock = 0

staticprotected

Definition at line 426 of file XrdXrootdProtocol.hh.

Referenced by Configure().

AppName

char* XrdXrootdProtocol::AppName

protected

Definition at line 534 of file XrdXrootdProtocol.hh.

argp

XrdBuffer* XrdXrootdProtocol::argp

protected

Definition at line 515 of file XrdXrootdProtocol.hh.

Referenced by Claim(), Process(), Process2(), XrdXrootdTransit::Run(), and Swap().

as_aioOK

bool XrdXrootdProtocol::as_aioOK = true

static

Definition at line 232 of file XrdXrootdProtocol.hh.

Referenced by Configure().

as_force

bool XrdXrootdProtocol::as_force = false

static

Definition at line 231 of file XrdXrootdProtocol.hh.

as_maxperlnk

int XrdXrootdProtocol::as_maxperlnk = 8

static

Definition at line 221 of file XrdXrootdProtocol.hh.

as_maxperreq

int XrdXrootdProtocol::as_maxperreq = 8

static

Definition at line 222 of file XrdXrootdProtocol.hh.

as_maxpersrv

int XrdXrootdProtocol::as_maxpersrv = 4096

static

Definition at line 223 of file XrdXrootdProtocol.hh.

as_maxstalls

int XrdXrootdProtocol::as_maxstalls = 4

static

Definition at line 228 of file XrdXrootdProtocol.hh.

as_miniosz

int XrdXrootdProtocol::as_miniosz = 98304

static

Definition at line 224 of file XrdXrootdProtocol.hh.

as_minsfsz

int XrdXrootdProtocol::as_minsfsz = 8192

static

Definition at line 225 of file XrdXrootdProtocol.hh.

as_nosf

bool XrdXrootdProtocol::as_nosf = false

static

Definition at line 233 of file XrdXrootdProtocol.hh.

Referenced by Configure().

as_okstutter

short XrdXrootdProtocol::as_okstutter = 1

static

Definition at line 229 of file XrdXrootdProtocol.hh.

Referenced by Configure().

as_seghalf

int XrdXrootdProtocol::as_seghalf = 32768

static

Definition at line 226 of file XrdXrootdProtocol.hh.

as_segsize

int XrdXrootdProtocol::as_segsize = 65536

static

Definition at line 227 of file XrdXrootdProtocol.hh.

Referenced by XrdXrootdAioBuff::Alloc(), and Configure().

as_syncw

bool XrdXrootdProtocol::as_syncw = false

static

Definition at line 234 of file XrdXrootdProtocol.hh.

as_timeout

short XrdXrootdProtocol::as_timeout = 45

static

Definition at line 230 of file XrdXrootdProtocol.hh.

AuthProt

XrdSecProtocol* XrdXrootdProtocol::AuthProt

protected

Definition at line 531 of file XrdXrootdProtocol.hh.

boundRecycle

XrdSysSemaphore* XrdXrootdProtocol::boundRecycle

protected

Definition at line 605 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

BPool

XrdBuffManager * XrdXrootdProtocol::BPool

staticprotected

Definition at line 405 of file XrdXrootdProtocol.hh.

Referenced by Configure(), Process(), Reclaim(), and Swap().

CapVer

unsigned char XrdXrootdProtocol::CapVer

protected

Definition at line 525 of file XrdXrootdProtocol.hh.

CIA

XrdSecService * XrdXrootdProtocol::CIA = 0

staticprotected

Definition at line 400 of file XrdXrootdProtocol.hh.

CL_Redir

bool XrdXrootdProtocol::CL_Redir = false

staticprotected

Definition at line 463 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Process2().

Client

XrdSecEntity* XrdXrootdProtocol::Client

protected

Definition at line 530 of file XrdXrootdProtocol.hh.

Referenced by MonAuth().

clientPV

int XrdXrootdProtocol::clientPV

protected

Definition at line 519 of file XrdXrootdProtocol.hh.

Referenced by MonAuth().

clientRN

int XrdXrootdProtocol::clientRN

protected

Definition at line 520 of file XrdXrootdProtocol.hh.

CloseRequested

bool XrdXrootdProtocol::CloseRequested

protected

Definition at line 526 of file XrdXrootdProtocol.hh.

Referenced by RequestClose().

cumReadP

int XrdXrootdProtocol::cumReadP

protected

Definition at line 503 of file XrdXrootdProtocol.hh.

Referenced by Stats().

cumReads

int XrdXrootdProtocol::cumReads

protected

Definition at line 502 of file XrdXrootdProtocol.hh.

Referenced by Stats().

cumReadV

int XrdXrootdProtocol::cumReadV

protected

Definition at line 504 of file XrdXrootdProtocol.hh.

Referenced by Stats().

cumSegsV

int XrdXrootdProtocol::cumSegsV

protected

Definition at line 505 of file XrdXrootdProtocol.hh.

Referenced by Stats().

cumSegsW

int XrdXrootdProtocol::cumSegsW

protected

Definition at line 507 of file XrdXrootdProtocol.hh.

Referenced by Stats().

cumWrites

int XrdXrootdProtocol::cumWrites

protected

Definition at line 508 of file XrdXrootdProtocol.hh.

Referenced by Stats().

cumWritV

int XrdXrootdProtocol::cumWritV

protected

Definition at line 506 of file XrdXrootdProtocol.hh.

Referenced by Stats().

DHS

XrdSecProtector * XrdXrootdProtocol::DHS = 0

staticprotected

Definition at line 401 of file XrdXrootdProtocol.hh.

digFS

XrdSfsFileSystem * XrdXrootdProtocol::digFS = 0

staticprotected

Definition at line 399 of file XrdXrootdProtocol.hh.

Referenced by Configure().

doTLS

char XrdXrootdProtocol::doTLS

protected

Definition at line 623 of file XrdXrootdProtocol.hh.

eDest

XrdSysError & XrdXrootdProtocol::eDest = XrdXrootd::eLog

staticprotected

Definition at line 406 of file XrdXrootdProtocol.hh.

Referenced by Configure(), Process2(), and Recycle().

endNote

XrdSysCondVar2* XrdXrootdProtocol::endNote

protected

Definition at line 606 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

Entity

XrdSecEntity XrdXrootdProtocol::Entity

protected

Definition at line 532 of file XrdXrootdProtocol.hh.

Referenced by Match(), and MonAuth().

fsFeatures

uint64_t XrdXrootdProtocol::fsFeatures = 0

staticprotected

Definition at line 446 of file XrdXrootdProtocol.hh.

Referenced by Configure().

FTab

XrdXrootdFileTable* XrdXrootdProtocol::FTab

protected

Definition at line 516 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), and SetSF().

gdCtl

struct XrdXrootdProtocol::GetDataCtl XrdXrootdProtocol::gdCtl

protected

Referenced by getDump(), and Recycle().

hailWait

int XrdXrootdProtocol::hailWait

staticprotected

Definition at line 430 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Match().

halfBSize

int XrdXrootdProtocol::halfBSize

protected

Definition at line 598 of file XrdXrootdProtocol.hh.

Referenced by Process().

hcMax

int XrdXrootdProtocol::hcMax = 28657

staticprotected

Definition at line 594 of file XrdXrootdProtocol.hh.

hcNext

int XrdXrootdProtocol::hcNext

protected

Definition at line 596 of file XrdXrootdProtocol.hh.

hcNow

int XrdXrootdProtocol::hcNow

protected

Definition at line 597 of file XrdXrootdProtocol.hh.

Referenced by Process().

hcPrev

int XrdXrootdProtocol::hcPrev

protected

Definition at line 595 of file XrdXrootdProtocol.hh.

Referenced by Process().

IO

XrdXrootd::IOParms XrdXrootdProtocol::IO

protected

Definition at line 590 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), SendFile(), and SetFD().

isActive

bool XrdXrootdProtocol::isActive

protected

Definition at line 609 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

isLinkWT

bool XrdXrootdProtocol::isLinkWT

protected

Definition at line 610 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

isNOP

bool XrdXrootdProtocol::isNOP

protected

Definition at line 611 of file XrdXrootdProtocol.hh.

Referenced by Recycle(), StreamNOP(), and VerifyStream().

isProxy

bool XrdXrootdProtocol::isProxy = false

staticprotected

Definition at line 465 of file XrdXrootdProtocol.hh.

Referenced by Configure().

isRedir

char XrdXrootdProtocol::isRedir = 0

staticprotected

Definition at line 439 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Match().

isTLS

bool XrdXrootdProtocol::isTLS

protected

Definition at line 625 of file XrdXrootdProtocol.hh.

JobCKCGI

char XrdXrootdProtocol::JobCKCGI =0

staticprotected

Definition at line 441 of file XrdXrootdProtocol.hh.

JobCKS

XrdXrootdJob * XrdXrootdProtocol::JobCKS = 0

staticprotected

Definition at line 442 of file XrdXrootdProtocol.hh.

Referenced by Configure().

JobCKT

char * XrdXrootdProtocol::JobCKT = 0

staticprotected

Definition at line 443 of file XrdXrootdProtocol.hh.

Referenced by Configure().

JobCKTLST

XrdOucTList * XrdXrootdProtocol::JobCKTLST = 0

staticprotected

Definition at line 444 of file XrdXrootdProtocol.hh.

Referenced by Configure().

JobLCL

char XrdXrootdProtocol::JobLCL = 0

staticprotected

Definition at line 440 of file XrdXrootdProtocol.hh.

Referenced by Configure().

keepT

time_t XrdXrootdProtocol::keepT = 86400

staticprotected

Definition at line 422 of file XrdXrootdProtocol.hh.

LimitError

bool XrdXrootdProtocol::LimitError = true

staticprotected

Definition at line 630 of file XrdXrootdProtocol.hh.

Link

XrdLink* XrdXrootdProtocol::Link

protected

Definition at line 514 of file XrdXrootdProtocol.hh.

Referenced by XrdXrootdTransit::Disc(), Match(), XrdXrootdTransit::Proceed(), Process(), Process2(), ProcSig(), XrdXrootdTransit::Redrive(), and XrdXrootdTransit::Send().

linkAioReq

RAtomic_int XrdXrootdProtocol::linkAioReq

protected

Definition at line 548 of file XrdXrootdProtocol.hh.

Referenced by aioUpdReq().

Locker

XrdXrootdFileLock * XrdXrootdProtocol::Locker

staticprotected

Definition at line 403 of file XrdXrootdProtocol.hh.

Referenced by Configure().

maxBuffsz

int XrdXrootdProtocol::maxBuffsz

staticprotected

Definition at line 486 of file XrdXrootdProtocol.hh.

Referenced by Configure().

maxPio

const int XrdXrootdProtocol::maxPio = 4

staticprotected

Definition at line 613 of file XrdXrootdProtocol.hh.

maxReadv_ior

int XrdXrootdProtocol::maxReadv_ior

staticprotected

Initial value:

=
                      XrdXrootdProtocol::maxTransz-(int)sizeof(readahead_list)

Definition at line 488 of file XrdXrootdProtocol.hh.

Referenced by Configure().

maxStreams

const int XrdXrootdProtocol::maxStreams = 16

static

Definition at line 217 of file XrdXrootdProtocol.hh.

Referenced by VerifyStream().

maxTransz

int XrdXrootdProtocol::maxTransz = 262144

staticprotected

Definition at line 487 of file XrdXrootdProtocol.hh.

Referenced by Configure().

Monitor

XrdXrootdMonitor::User XrdXrootdProtocol::Monitor

protected

Definition at line 517 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), MonAuth(), and Recycle().

myBlast

int XrdXrootdProtocol::myBlast

protected

Definition at line 556 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan().

myBlen

int XrdXrootdProtocol::myBlen

protected

Definition at line 555 of file XrdXrootdProtocol.hh.

Referenced by Process(), and XrdXrootdTransit::Run().

myBuff

char* XrdXrootdProtocol::myBuff

protected

Definition at line 554 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), Process(), and XrdXrootdTransit::Run().

myCName

const char * XrdXrootdProtocol::myCName = 0

staticprotected

Definition at line 437 of file XrdXrootdProtocol.hh.

Referenced by Configure().

myCNlen

int XrdXrootdProtocol::myCNlen = 0

staticprotected

Definition at line 438 of file XrdXrootdProtocol.hh.

Referenced by Configure().

myGID

gid_t XrdXrootdProtocol::myGID = 0

staticprotected

Definition at line 416 of file XrdXrootdProtocol.hh.

myGName

const char * XrdXrootdProtocol::myGName = "?"

staticprotected

Definition at line 420 of file XrdXrootdProtocol.hh.

myGNLen

int XrdXrootdProtocol::myGNLen = 1

staticprotected

Definition at line 418 of file XrdXrootdProtocol.hh.

myInst

const char * XrdXrootdProtocol::myInst = 0

staticprotected

Definition at line 409 of file XrdXrootdProtocol.hh.

Referenced by Configure().

myPID

int XrdXrootdProtocol::myPID = static_cast<int>(getpid())

staticprotected

Definition at line 412 of file XrdXrootdProtocol.hh.

myRole

int XrdXrootdProtocol::myRole = 0

staticprotected

Definition at line 413 of file XrdXrootdProtocol.hh.

Referenced by Configure().

myRolf

int XrdXrootdProtocol::myRolf = 0

staticprotected

Definition at line 414 of file XrdXrootdProtocol.hh.

Referenced by Configure().

mySID

unsigned int XrdXrootdProtocol::mySID

protected

Definition at line 608 of file XrdXrootdProtocol.hh.

myStalls

int XrdXrootdProtocol::myStalls

protected

Definition at line 509 of file XrdXrootdProtocol.hh.

myUID

uid_t XrdXrootdProtocol::myUID = 0

staticprotected

Definition at line 417 of file XrdXrootdProtocol.hh.

myUName

const char * XrdXrootdProtocol::myUName = "?"

staticprotected

Definition at line 421 of file XrdXrootdProtocol.hh.

myUNLen

int XrdXrootdProtocol::myUNLen = 1

staticprotected

Definition at line 419 of file XrdXrootdProtocol.hh.

newPio

bool XrdXrootdProtocol::newPio

protected

Definition at line 619 of file XrdXrootdProtocol.hh.

Notify

char * XrdXrootdProtocol::Notify = 0

staticprotected

Definition at line 436 of file XrdXrootdProtocol.hh.

Referenced by Configure().

numFiles

int XrdXrootdProtocol::numFiles

protected

Definition at line 500 of file XrdXrootdProtocol.hh.

numReadP

int XrdXrootdProtocol::numReadP

protected

Definition at line 494 of file XrdXrootdProtocol.hh.

Referenced by Stats().

numReads

int XrdXrootdProtocol::numReads

protected

Definition at line 493 of file XrdXrootdProtocol.hh.

Referenced by Stats().

numReadV

int XrdXrootdProtocol::numReadV

protected

Definition at line 495 of file XrdXrootdProtocol.hh.

Referenced by Stats().

numSegsV

int XrdXrootdProtocol::numSegsV

protected

Definition at line 496 of file XrdXrootdProtocol.hh.

Referenced by Stats().

numSegsW

int XrdXrootdProtocol::numSegsW

protected

Definition at line 498 of file XrdXrootdProtocol.hh.

Referenced by Stats().

numWrites

int XrdXrootdProtocol::numWrites

protected

Definition at line 499 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), and Stats().

numWritV

int XrdXrootdProtocol::numWritV

protected

Definition at line 497 of file XrdXrootdProtocol.hh.

Referenced by Stats().

OD_Bypass

bool XrdXrootdProtocol::OD_Bypass = false

staticprotected

Definition at line 460 of file XrdXrootdProtocol.hh.

Referenced by Configure().

OD_Redir

bool XrdXrootdProtocol::OD_Redir = false

staticprotected

Definition at line 461 of file XrdXrootdProtocol.hh.

OD_Stall

int XrdXrootdProtocol::OD_Stall = 33

staticprotected

Definition at line 459 of file XrdXrootdProtocol.hh.

osFS

XrdSfsFileSystem * XrdXrootdProtocol::osFS

staticprotected

Definition at line 398 of file XrdXrootdProtocol.hh.

Referenced by Configure().

PathID

short XrdXrootdProtocol::PathID

protected

Definition at line 618 of file XrdXrootdProtocol.hh.

Referenced by getPathID(), and StreamNOP().

pgwCtl

XrdXrootdPgwCtl* XrdXrootdProtocol::pgwCtl

protected

Definition at line 553 of file XrdXrootdProtocol.hh.

pioFirst

XrdXrootdPio* XrdXrootdProtocol::pioFirst

protected

Definition at line 614 of file XrdXrootdProtocol.hh.

pioFree

XrdXrootdPio* XrdXrootdProtocol::pioFree

protected

Definition at line 616 of file XrdXrootdProtocol.hh.

pioLast

XrdXrootdPio* XrdXrootdProtocol::pioLast

protected

Definition at line 615 of file XrdXrootdProtocol.hh.

PMark

XrdNetPMark * XrdXrootdProtocol::PMark = 0

staticprotected

Definition at line 407 of file XrdXrootdProtocol.hh.

Referenced by Configure().

pmDone

bool XrdXrootdProtocol::pmDone

protected

Definition at line 521 of file XrdXrootdProtocol.hh.

pmHandle

XrdNetPMark::Handle* XrdXrootdProtocol::pmHandle

protected

Definition at line 518 of file XrdXrootdProtocol.hh.

Port

int XrdXrootdProtocol::Port

staticprotected

Definition at line 432 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Process2().

PrepareAlt

bool XrdXrootdProtocol::PrepareAlt = false

staticprotected

Definition at line 629 of file XrdXrootdProtocol.hh.

Referenced by Configure().

PrepareCount

int XrdXrootdProtocol::PrepareCount

protected

Definition at line 632 of file XrdXrootdProtocol.hh.

PrepareLimit

int XrdXrootdProtocol::PrepareLimit = -1

staticprotected

Definition at line 633 of file XrdXrootdProtocol.hh.

PrepID

XrdOucReqID * XrdXrootdProtocol::PrepID = 0

staticprotected

Definition at line 445 of file XrdXrootdProtocol.hh.

Referenced by Configure().

Protect

XrdSecProtect* XrdXrootdProtocol::Protect

protected

Definition at line 533 of file XrdXrootdProtocol.hh.

Referenced by Process(), and Process2().

rdType

short XrdXrootdProtocol::rdType

protected

Definition at line 523 of file XrdXrootdProtocol.hh.

Referenced by Process2().

readWait

int XrdXrootdProtocol::readWait

staticprotected

Definition at line 431 of file XrdXrootdProtocol.hh.

Referenced by Configure().

redirIPHold

int XrdXrootdProtocol::redirIPHold = 8*60*60

staticprotected

Definition at line 435 of file XrdXrootdProtocol.hh.

Referenced by Configure().

RedirPI

XrdXrootdRedirPI * XrdXrootdProtocol::RedirPI = 0

staticprotected

Definition at line 408 of file XrdXrootdProtocol.hh.

Referenced by Configure().

Req_TLSData

const char XrdXrootdProtocol::Req_TLSData = 0x01

staticprotected

Definition at line 475 of file XrdXrootdProtocol.hh.

Req_TLSGPFile

const char XrdXrootdProtocol::Req_TLSGPFile = 0x02

staticprotected

Definition at line 476 of file XrdXrootdProtocol.hh.

Req_TLSLogin

const char XrdXrootdProtocol::Req_TLSLogin = 0x04

staticprotected

Definition at line 477 of file XrdXrootdProtocol.hh.

Req_TLSSess

const char XrdXrootdProtocol::Req_TLSSess = 0x08

staticprotected

Definition at line 478 of file XrdXrootdProtocol.hh.

Req_TLSTPC

const char XrdXrootdProtocol::Req_TLSTPC = 0x10

staticprotected

Definition at line 479 of file XrdXrootdProtocol.hh.

ReqID

XrdXrootdReqID XrdXrootdProtocol::ReqID

protected

Definition at line 637 of file XrdXrootdProtocol.hh.

Referenced by Process2().

Request

ClientRequest XrdXrootdProtocol::Request

protected

Definition at line 638 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), Process(), Process2(), ProcSig(), XrdXrootdTransit::Run(), XrdXrootdTransit::Send(), and Swap().

reserved

char XrdXrootdProtocol::reserved[3]

protected

Definition at line 522 of file XrdXrootdProtocol.hh.

Response

XrdXrootdResponse XrdXrootdProtocol::Response

protected

Definition at line 639 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), Match(), Process(), Process2(), ProcSig(), Recycle(), XrdXrootdTransit::Run(), SendFile(), and VerifyStream().

Resume

int(XrdXrootdProtocol::* XrdXrootdProtocol::Resume) ()

protected

Definition at line 589 of file XrdXrootdProtocol.hh.

Referenced by DoIt(), XrdXrootdTransit::Process(), Process(), ProcSig(), and XrdXrootdTransit::Run().

ResumePio

int(XrdXrootdProtocol::* XrdXrootdProtocol::ResumePio) ()

protected

Definition at line 588 of file XrdXrootdProtocol.hh.

reTry

XrdSysSemaphore* XrdXrootdProtocol::reTry

protected

Definition at line 604 of file XrdXrootdProtocol.hh.

Route

struct XrdXrootdProtocol::RD_Table XrdXrootdProtocol::Route[RD_Num]

staticprotected

Referenced by Configure(), and Process2().

RouteClient

struct XrdXrootdProtocol::RC_Table XrdXrootdProtocol::RouteClient

staticprotected

Referenced by Process2().

RPList

XrdXrootdXPath XrdXrootdProtocol::RPList

staticprotected

Definition at line 395 of file XrdXrootdProtocol.hh.

Referenced by Configure().

RQList

XrdXrootdXPath XrdXrootdProtocol::RQList

staticprotected

Definition at line 396 of file XrdXrootdProtocol.hh.

Referenced by Configure().

RQLxist

int XrdXrootdProtocol::RQLxist = 0

staticprotected

Definition at line 411 of file XrdXrootdProtocol.hh.

rvSeq

unsigned char XrdXrootdProtocol::rvSeq

protected

Definition at line 620 of file XrdXrootdProtocol.hh.

Sched

XrdScheduler * XrdXrootdProtocol::Sched

staticprotected

Definition at line 404 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and XrdXrootdTransit::Recycle().

SI

XrdXrootdStats * XrdXrootdProtocol::SI

staticprotected

Definition at line 492 of file XrdXrootdProtocol.hh.

Referenced by Configure(), Match(), Process2(), and Stats().

sigBuff

char XrdXrootdProtocol::sigBuff[64]

protected

Definition at line 540 of file XrdXrootdProtocol.hh.

Referenced by ProcSig().

sigHere

bool XrdXrootdProtocol::sigHere

protected

Definition at line 542 of file XrdXrootdProtocol.hh.

Referenced by Process2(), and ProcSig().

sigNeed

bool XrdXrootdProtocol::sigNeed

protected

Definition at line 541 of file XrdXrootdProtocol.hh.

Referenced by Process(), and Process2().

sigRead

bool XrdXrootdProtocol::sigRead

protected

Definition at line 543 of file XrdXrootdProtocol.hh.

Referenced by ProcSig().

sigReq

SecurityRequest XrdXrootdProtocol::sigReq

protected

Definition at line 539 of file XrdXrootdProtocol.hh.

Referenced by Process2(), and ProcSig().

sigReq2Ver

ClientRequest XrdXrootdProtocol::sigReq2Ver

protected

Definition at line 538 of file XrdXrootdProtocol.hh.

Referenced by Process(), and Process2().

sigWarn

bool XrdXrootdProtocol::sigWarn

protected

Definition at line 544 of file XrdXrootdProtocol.hh.

Referenced by Process2().

srvrAioOps

RAtomic_int XrdXrootdProtocol::srvrAioOps = {0}

staticprotected

Definition at line 549 of file XrdXrootdProtocol.hh.

Referenced by aioUpdate().

Status

char XrdXrootdProtocol::Status

protected

Definition at line 524 of file XrdXrootdProtocol.hh.

Referenced by Process2(), and Recycle().

Stream

XrdXrootdProtocol* XrdXrootdProtocol::Stream[maxStreams]

protected

Definition at line 607 of file XrdXrootdProtocol.hh.

Referenced by VerifyStream().

streamMutex

XrdSysMutex XrdXrootdProtocol::streamMutex

protected

Definition at line 603 of file XrdXrootdProtocol.hh.

Referenced by Recycle(), StreamNOP(), and VerifyStream().

tlsCap

char XrdXrootdProtocol::tlsCap = 0

staticprotected

Definition at line 481 of file XrdXrootdProtocol.hh.

tlsCtx

XrdTlsContext * XrdXrootdProtocol::tlsCtx = 0

staticprotected

Definition at line 402 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Process2().

tlsNot

char XrdXrootdProtocol::tlsNot = 0

staticprotected

Definition at line 482 of file XrdXrootdProtocol.hh.

tlsPort

int XrdXrootdProtocol::tlsPort = 0

staticprotected

Definition at line 434 of file XrdXrootdProtocol.hh.

Referenced by Configure().

totReadP

long long XrdXrootdProtocol::totReadP

protected

Definition at line 510 of file XrdXrootdProtocol.hh.

TraceID

const char * XrdXrootdProtocol::TraceID = "Protocol"

staticprotected

Definition at line 410 of file XrdXrootdProtocol.hh.

unbindMutex

XrdSysMutex XrdXrootdProtocol::unbindMutex

protected

Definition at line 602 of file XrdXrootdProtocol.hh.

Referenced by Recycle(), and RequestClose().

usxMaxNsz

int XrdXrootdProtocol::usxMaxNsz = kXR_faMaxNlen

staticprotected

Definition at line 469 of file XrdXrootdProtocol.hh.

Referenced by Configure().

usxMaxVsz

int XrdXrootdProtocol::usxMaxVsz = kXR_faMaxVlen

staticprotected

Definition at line 470 of file XrdXrootdProtocol.hh.

Referenced by Configure().

usxParms

char * XrdXrootdProtocol::usxParms = 0

staticprotected

Definition at line 471 of file XrdXrootdProtocol.hh.

Referenced by Configure().

Window

int XrdXrootdProtocol::Window

staticprotected

Definition at line 433 of file XrdXrootdProtocol.hh.

Referenced by Configure().

wvInfo

XrdXrootdWVInfo* XrdXrootdProtocol::wvInfo

protected

Definition at line 587 of file XrdXrootdProtocol.hh.

wvSeq

unsigned char XrdXrootdProtocol::wvSeq

protected

Definition at line 621 of file XrdXrootdProtocol.hh.

XPList

XrdXrootdXPath XrdXrootdProtocol::XPList

staticprotected

Definition at line 397 of file XrdXrootdProtocol.hh.

Referenced by Configure().

---

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

• XrdXrootdProtocol.hh
• XrdXrootdConfig.cc
• XrdXrootdConfigMon.cc
• XrdXrootdProtocol.cc
• XrdXrootdXeq.cc
• XrdXrootdXeqChkPnt.cc
• XrdXrootdXeqFAttr.cc
• XrdXrootdXeqPgrw.cc