#include <XrdXrootdProtocol.hh>

Inheritance diagram for XrdXrootdProtocol:

Collaboration diagram for XrdXrootdProtocol:

Classes
struct	GetDataCtl

union	GetDataCtl.__unnamed0__

union	GetDataCtl.__unnamed1__

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.

virtual	~XrdSfsDio ()

Public Member Functions inherited from XrdSfsXio
	XrdSfsXio (XrdSfsXioImpl &xioimpl)

virtual	~XrdSfsXio ()
	Constructor and destructor.

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 = 86060

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 158 of file XrdXrootdProtocol.hh.

Class Documentation

◆ XrdXrootdProtocol::GetDataCtl.unnamed0

union XrdXrootdProtocol::GetDataCtl.__unnamed0__

Definition at line 563 of file XrdXrootdProtocol.hh.

Collaboration diagram for XrdXrootdProtocol::GetDataCtl.__unnamed0__:

Class Members
int	BuffLen
int	DumpLen
int	iovAdj

◆ XrdXrootdProtocol::GetDataCtl.unnamed1

union XrdXrootdProtocol::GetDataCtl.__unnamed1__

Definition at line 571 of file XrdXrootdProtocol.hh.

Collaboration diagram for XrdXrootdProtocol::GetDataCtl.__unnamed1__:

Class Members
char *	Buffer
struct iovec *	iovVec

◆ XrdXrootdProtocol::RC_Table

struct XrdXrootdProtocol::RC_Table

Definition at line 455 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 451 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();
}

References XrdProtocol::XrdProtocol(), XrdSfsXio::XrdSfsXio(), AppName, and Entity.

Referenced by CloseRequestCb(), Match(), operator=(), and VerifyStream().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~XrdXrootdProtocol()

XrdXrootdProtocol::~XrdXrootdProtocol ( )

inline

Definition at line 216 of file XrdXrootdProtocol.hh.

216{Cleanup();}

Member Function Documentation

◆ aioUpdate()

void XrdXrootdProtocol::aioUpdate ( int val )

inline

Definition at line 164 of file XrdXrootdProtocol.hh.

164{srvrAioOps += val;}

XrdXrootdProtocol::srvrAioOps

static RAtomic_int srvrAioOps

Definition XrdXrootdProtocol.hh:176

References srvrAioOps.

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

Here is the caller graph for this function:

◆ aioUpdReq()

void XrdXrootdProtocol::aioUpdReq ( int val )

inline

Definition at line 166 of file XrdXrootdProtocol.hh.

166{linkAioReq += val;}

XrdXrootdProtocol::linkAioReq

RAtomic_int linkAioReq

Definition XrdXrootdProtocol.hh:549

References linkAioReq.

◆ Buffer()

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

static

Definition at line 894 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 910 of file XrdXrootdProtocol.cc.

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

References argp, and Swap().

Here is the call graph for this function:

◆ CloseRequestCb()

bool XrdXrootdProtocol::CloseRequestCb ( void * cbarg )

staticprotected

Definition at line 1540 of file XrdXrootdProtocol.cc.

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

References XrdXrootdProtocol(), and RequestClose().

Here is the call graph for this function:

◆ Configure()

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

static

Definition at line 175 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
//
   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;
           }
      }
 
// 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;
}

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 3372 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 FTab, XrdXrootdFHandle::handle, IO, Monitor, myBlast, myBuff, numWrites, Request, Response, and TRACEP.

◆ DoIt()

void XrdXrootdProtocol::DoIt ( )

inlineoverridevirtual

Implements XrdJob.

Definition at line 174 of file XrdXrootdProtocol.hh.

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

XrdXrootdProtocol::Resume

int(XrdXrootdProtocol::* Resume)()

Definition XrdXrootdProtocol.hh:590

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 1403 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, and XrdXrootdProtocol::GetDataCtl::inDump.

Referenced by XrdXrootdAioTask::gdDone().

Here is the caller graph for this function:

◆ getPathID()

int XrdXrootdProtocol::getPathID ( )

inline

Definition at line 186 of file XrdXrootdProtocol.hh.

186{return PathID;}

XrdXrootdProtocol::PathID

short PathID

Definition XrdXrootdProtocol.hh:619

References PathID.

Referenced by XrdXrootdAioFob::Reset(), XrdXrootdAioFob::Schedule(), 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 XrdProtocol::XrdProtocol(), XrdXrootdProtocol(), XrdLink::AddrInfo(), XrdSecEntity::addrInfo, Entity, ClientInitHandShake::fifth, ClientInitHandShake::first, ClientInitHandShake::fourth, hailWait, XrdLink::Host(), XrdSecEntity::host, isRedir, kXR_DataServer, kXR_LBalServer, kXR_PROTOCOLVERSION, Link, XrdLink::Peek(), 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 4259 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, Monitor, and XrdOucEI::uIPv4.

◆ operator=()

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

delete

References XrdXrootdProtocol().

Here is the call graph for this function:

◆ 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, getData(), halfBSize, hcNow, hcPrev, kXR_ArgInvalid, kXR_ArgTooLong, kXR_pgwrite, kXR_sigver, kXR_write, Link, myBlen, myBuff, NEED2SECURE, Process2(), ProcSig(), Protect, XProtocol::reqName(), Request, Response, Resume, sigNeed, sigReq2Ver, 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();
          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 argp, CL_Redir, XrdTls::ClearErrorQueue(), eDest, XrdOucString::endswith(), XrdNetIF::InDomain(), kXR_ArgMissing, kXR_auth, kXR_bind, kXR_chkpoint, kXR_chmod, 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, Link, Port, Protect, rdType, ReqID, XProtocol::reqName(), Request, Response, Route, RouteClient, SI, sigHere, sigNeed, sigReq, sigReq2Ver, sigWarn, Status, tlsCtx, TRACEP, and XRD_NEED_AUTH.

Referenced by Process(), XrdXrootdTransit::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 615 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 getData(), kXR_ArgInvalid, Link, ProcSig(), Request, Response, Resume, sigBuff, sigHere, sigRead, and sigReq.

Referenced by Process(), and ProcSig().

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 925 of file XrdXrootdProtocol.cc.

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

References BPool.

◆ Recycle()

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

overridevirtual

Implements XrdProtocol.

Reimplemented in XrdXrootdTransit.

Definition at line 660 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, boundRecycle, XrdXrootdMonFile::Disc(), eDest, endNote, gdCtl, XrdLink::ID, XrdXrootdProtocol::GetDataCtl::inData, XrdXrootdProtocol::GetDataCtl::inDataIov, isActive, isLinkWT, isNOP, Monitor, Response, XrdSysTimer::s2hms(), Status, streamMutex, SYS_LOG_02, XrdXrootdProtocol::GetDataCtl::Terminate, unbindMutex, 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 1550 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 3649 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, and Response.

◆ 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 3664 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, and Response.

◆ 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 3688 of file XrdXrootdXeq.cc.

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

References IO.

◆ SetSF()

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

protected

Definition at line 4328 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, XrdXrootdFHandle::handle, and XrdXrootdFile::sfEnabled.

Referenced by XrdXrootdTransit::setSF().

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 856 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, numReadP, numReads, numReadV, numSegsV, numSegsW, numWrites, numWritV, and SI.

◆ StreamNOP()

void XrdXrootdProtocol::StreamNOP ( )

Definition at line 935 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, PathID, and streamMutex.

◆ 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 951 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, kXR_write, and Request.

Referenced by Claim().

Here is the caller graph for this function:

◆ VerifyStream()

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

Definition at line 976 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 XrdXrootdProtocol(), isNOP, kXR_ArgInvalid, XrdSysMutex::Lock(), maxStreams, Response, Stream, streamMutex, and XrdSysMutex::UnLock().

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ XrdXrootdAdmin

friend class XrdXrootdAdmin

friend

Definition at line 161 of file XrdXrootdProtocol.hh.

References XrdXrootdAdmin.

Referenced by XrdXrootdAdmin.

Member Data Documentation

◆ ableTLS

bool XrdXrootdProtocol::ableTLS

protected

Definition at line 625 of file XrdXrootdProtocol.hh.

◆ AdminSock

XrdNetSocket * XrdXrootdProtocol::AdminSock = 0

staticprotected

Definition at line 427 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ AppName

char* XrdXrootdProtocol::AppName

protected

Definition at line 535 of file XrdXrootdProtocol.hh.

Referenced by XrdXrootdProtocol().

◆ argp

XrdBuffer* XrdXrootdProtocol::argp

protected

Definition at line 516 of file XrdXrootdProtocol.hh.

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

◆ as_aioOK

bool XrdXrootdProtocol::as_aioOK = true

static

Definition at line 233 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ as_force

bool XrdXrootdProtocol::as_force = false

static

Definition at line 232 of file XrdXrootdProtocol.hh.

◆ as_maxperlnk

int XrdXrootdProtocol::as_maxperlnk = 8

static

Definition at line 222 of file XrdXrootdProtocol.hh.

◆ as_maxperreq

int XrdXrootdProtocol::as_maxperreq = 8

static

Definition at line 223 of file XrdXrootdProtocol.hh.

◆ as_maxpersrv

int XrdXrootdProtocol::as_maxpersrv = 4096

static

Definition at line 224 of file XrdXrootdProtocol.hh.

◆ as_maxstalls

int XrdXrootdProtocol::as_maxstalls = 4

static

Definition at line 229 of file XrdXrootdProtocol.hh.

◆ as_miniosz

int XrdXrootdProtocol::as_miniosz = 98304

static

Definition at line 225 of file XrdXrootdProtocol.hh.

◆ as_minsfsz

int XrdXrootdProtocol::as_minsfsz = 8192

static

Definition at line 226 of file XrdXrootdProtocol.hh.

◆ as_nosf

bool XrdXrootdProtocol::as_nosf = false

static

Definition at line 234 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ as_okstutter

short XrdXrootdProtocol::as_okstutter = 1

static

Definition at line 230 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ as_seghalf

int XrdXrootdProtocol::as_seghalf = 32768

static

Definition at line 227 of file XrdXrootdProtocol.hh.

◆ as_segsize

int XrdXrootdProtocol::as_segsize = 65536

static

Definition at line 228 of file XrdXrootdProtocol.hh.

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

◆ as_syncw

bool XrdXrootdProtocol::as_syncw = false

static

Definition at line 235 of file XrdXrootdProtocol.hh.

◆ as_timeout

short XrdXrootdProtocol::as_timeout = 45

static

Definition at line 231 of file XrdXrootdProtocol.hh.

◆ AuthProt

XrdSecProtocol* XrdXrootdProtocol::AuthProt

protected

Definition at line 532 of file XrdXrootdProtocol.hh.

◆ boundRecycle

XrdSysSemaphore* XrdXrootdProtocol::boundRecycle

protected

Definition at line 606 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

◆ BPool

XrdBuffManager * XrdXrootdProtocol::BPool

staticprotected

Definition at line 406 of file XrdXrootdProtocol.hh.

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

◆ CapVer

unsigned char XrdXrootdProtocol::CapVer

protected

Definition at line 526 of file XrdXrootdProtocol.hh.

◆ CIA

XrdSecService * XrdXrootdProtocol::CIA = 0

staticprotected

Definition at line 401 of file XrdXrootdProtocol.hh.

◆ CL_Redir

bool XrdXrootdProtocol::CL_Redir = false

staticprotected

Definition at line 464 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Process2().

◆ Client

XrdSecEntity* XrdXrootdProtocol::Client

protected

Definition at line 531 of file XrdXrootdProtocol.hh.

Referenced by MonAuth().

◆ clientPV

int XrdXrootdProtocol::clientPV

protected

Definition at line 520 of file XrdXrootdProtocol.hh.

Referenced by MonAuth().

◆ clientRN

int XrdXrootdProtocol::clientRN

protected

Definition at line 521 of file XrdXrootdProtocol.hh.

◆ CloseRequested

bool XrdXrootdProtocol::CloseRequested

protected

Definition at line 527 of file XrdXrootdProtocol.hh.

Referenced by RequestClose().

◆ cumReadP

int XrdXrootdProtocol::cumReadP

protected

Definition at line 504 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ cumReads

int XrdXrootdProtocol::cumReads

protected

Definition at line 503 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ cumReadV

int XrdXrootdProtocol::cumReadV

protected

Definition at line 505 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ cumSegsV

int XrdXrootdProtocol::cumSegsV

protected

Definition at line 506 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ cumSegsW

int XrdXrootdProtocol::cumSegsW

protected

Definition at line 508 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ cumWrites

int XrdXrootdProtocol::cumWrites

protected

Definition at line 509 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ cumWritV

int XrdXrootdProtocol::cumWritV

protected

Definition at line 507 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ DHS

XrdSecProtector * XrdXrootdProtocol::DHS = 0

staticprotected

Definition at line 402 of file XrdXrootdProtocol.hh.

◆ digFS

XrdSfsFileSystem * XrdXrootdProtocol::digFS = 0

staticprotected

Definition at line 400 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ doTLS

char XrdXrootdProtocol::doTLS

protected

Definition at line 624 of file XrdXrootdProtocol.hh.

◆ eDest

XrdSysError & XrdXrootdProtocol::eDest = XrdXrootd::eLog

staticprotected

Definition at line 407 of file XrdXrootdProtocol.hh.

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

◆ endNote

XrdSysCondVar2* XrdXrootdProtocol::endNote

protected

Definition at line 607 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

◆ Entity

XrdSecEntity XrdXrootdProtocol::Entity

protected

Definition at line 533 of file XrdXrootdProtocol.hh.

Referenced by XrdXrootdProtocol(), Match(), and MonAuth().

◆ fsFeatures

uint64_t XrdXrootdProtocol::fsFeatures = 0

staticprotected

Definition at line 447 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ FTab

XrdXrootdFileTable* XrdXrootdProtocol::FTab

protected

Definition at line 517 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 431 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Match().

◆ halfBSize

int XrdXrootdProtocol::halfBSize

protected

Definition at line 599 of file XrdXrootdProtocol.hh.

Referenced by Process().

◆ hcMax

int XrdXrootdProtocol::hcMax = 28657

staticprotected

Definition at line 595 of file XrdXrootdProtocol.hh.

◆ hcNext

int XrdXrootdProtocol::hcNext

protected

Definition at line 597 of file XrdXrootdProtocol.hh.

◆ hcNow

int XrdXrootdProtocol::hcNow

protected

Definition at line 598 of file XrdXrootdProtocol.hh.

Referenced by Process().

◆ hcPrev

int XrdXrootdProtocol::hcPrev

protected

Definition at line 596 of file XrdXrootdProtocol.hh.

Referenced by Process().

◆ IO

XrdXrootd::IOParms XrdXrootdProtocol::IO

protected

Definition at line 591 of file XrdXrootdProtocol.hh.

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

◆ isActive

bool XrdXrootdProtocol::isActive

protected

Definition at line 610 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

◆ isLinkWT

bool XrdXrootdProtocol::isLinkWT

protected

Definition at line 611 of file XrdXrootdProtocol.hh.

Referenced by Recycle().

◆ isNOP

bool XrdXrootdProtocol::isNOP

protected

Definition at line 612 of file XrdXrootdProtocol.hh.

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

◆ isProxy

bool XrdXrootdProtocol::isProxy = false

staticprotected

Definition at line 466 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ isRedir

char XrdXrootdProtocol::isRedir = 0

staticprotected

Definition at line 440 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Match().

◆ isTLS

bool XrdXrootdProtocol::isTLS

protected

Definition at line 626 of file XrdXrootdProtocol.hh.

◆ JobCKCGI

char XrdXrootdProtocol::JobCKCGI =0

staticprotected

Definition at line 442 of file XrdXrootdProtocol.hh.

◆ JobCKS

XrdXrootdJob * XrdXrootdProtocol::JobCKS = 0

staticprotected

Definition at line 443 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ JobCKT

char * XrdXrootdProtocol::JobCKT = 0

staticprotected

Definition at line 444 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ JobCKTLST

XrdOucTList * XrdXrootdProtocol::JobCKTLST = 0

staticprotected

Definition at line 445 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ JobLCL

char XrdXrootdProtocol::JobLCL = 0

staticprotected

Definition at line 441 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ keepT

time_t XrdXrootdProtocol::keepT = 86400

staticprotected

Definition at line 423 of file XrdXrootdProtocol.hh.

◆ LimitError

bool XrdXrootdProtocol::LimitError = true

staticprotected

Definition at line 631 of file XrdXrootdProtocol.hh.

◆ Link

XrdLink* XrdXrootdProtocol::Link

protected

Definition at line 515 of file XrdXrootdProtocol.hh.

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

◆ linkAioReq

RAtomic_int XrdXrootdProtocol::linkAioReq

protected

Definition at line 549 of file XrdXrootdProtocol.hh.

Referenced by aioUpdReq().

◆ Locker

XrdXrootdFileLock * XrdXrootdProtocol::Locker

staticprotected

Definition at line 404 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ maxBuffsz

int XrdXrootdProtocol::maxBuffsz

staticprotected

Definition at line 487 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ maxPio

const int XrdXrootdProtocol::maxPio = 4

staticprotected

Definition at line 614 of file XrdXrootdProtocol.hh.

◆ maxReadv_ior

int XrdXrootdProtocol::maxReadv_ior

staticprotected

Initial value:

=

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

readahead_list

Definition XProtocol.hh:658

Definition at line 489 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ maxStreams

const int XrdXrootdProtocol::maxStreams = 16

static

Definition at line 218 of file XrdXrootdProtocol.hh.

Referenced by VerifyStream().

◆ maxTransz

int XrdXrootdProtocol::maxTransz = 262144

staticprotected

Definition at line 488 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ Monitor

XrdXrootdMonitor::User XrdXrootdProtocol::Monitor

protected

Definition at line 518 of file XrdXrootdProtocol.hh.

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

◆ myBlast

int XrdXrootdProtocol::myBlast

protected

Definition at line 557 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan().

◆ myBlen

int XrdXrootdProtocol::myBlen

protected

Definition at line 556 of file XrdXrootdProtocol.hh.

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

◆ myBuff

char* XrdXrootdProtocol::myBuff

protected

Definition at line 555 of file XrdXrootdProtocol.hh.

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

◆ myCName

const char * XrdXrootdProtocol::myCName = 0

staticprotected

Definition at line 438 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ myCNlen

int XrdXrootdProtocol::myCNlen = 0

staticprotected

Definition at line 439 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ myGID

gid_t XrdXrootdProtocol::myGID = 0

staticprotected

Definition at line 417 of file XrdXrootdProtocol.hh.

◆ myGName

const char * XrdXrootdProtocol::myGName = "?"

staticprotected

Definition at line 421 of file XrdXrootdProtocol.hh.

◆ myGNLen

int XrdXrootdProtocol::myGNLen = 1

staticprotected

Definition at line 419 of file XrdXrootdProtocol.hh.

◆ myInst

const char * XrdXrootdProtocol::myInst = 0

staticprotected

Definition at line 410 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ myPID

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

staticprotected

Definition at line 413 of file XrdXrootdProtocol.hh.

◆ myRole

int XrdXrootdProtocol::myRole = 0

staticprotected

Definition at line 414 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ myRolf

int XrdXrootdProtocol::myRolf = 0

staticprotected

Definition at line 415 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ mySID

unsigned int XrdXrootdProtocol::mySID

protected

Definition at line 609 of file XrdXrootdProtocol.hh.

◆ myStalls

int XrdXrootdProtocol::myStalls

protected

Definition at line 510 of file XrdXrootdProtocol.hh.

◆ myUID

uid_t XrdXrootdProtocol::myUID = 0

staticprotected

Definition at line 418 of file XrdXrootdProtocol.hh.

◆ myUName

const char * XrdXrootdProtocol::myUName = "?"

staticprotected

Definition at line 422 of file XrdXrootdProtocol.hh.

◆ myUNLen

int XrdXrootdProtocol::myUNLen = 1

staticprotected

Definition at line 420 of file XrdXrootdProtocol.hh.

◆ newPio

bool XrdXrootdProtocol::newPio

protected

Definition at line 620 of file XrdXrootdProtocol.hh.

◆ Notify

char * XrdXrootdProtocol::Notify = 0

staticprotected

Definition at line 437 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ numFiles

int XrdXrootdProtocol::numFiles

protected

Definition at line 501 of file XrdXrootdProtocol.hh.

◆ numReadP

int XrdXrootdProtocol::numReadP

protected

Definition at line 495 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ numReads

int XrdXrootdProtocol::numReads

protected

Definition at line 494 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ numReadV

int XrdXrootdProtocol::numReadV

protected

Definition at line 496 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ numSegsV

int XrdXrootdProtocol::numSegsV

protected

Definition at line 497 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ numSegsW

int XrdXrootdProtocol::numSegsW

protected

Definition at line 499 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ numWrites

int XrdXrootdProtocol::numWrites

protected

Definition at line 500 of file XrdXrootdProtocol.hh.

Referenced by do_WriteSpan(), and Stats().

◆ numWritV

int XrdXrootdProtocol::numWritV

protected

Definition at line 498 of file XrdXrootdProtocol.hh.

Referenced by Stats().

◆ OD_Bypass

bool XrdXrootdProtocol::OD_Bypass = false

staticprotected

Definition at line 461 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ OD_Redir

bool XrdXrootdProtocol::OD_Redir = false

staticprotected

Definition at line 462 of file XrdXrootdProtocol.hh.

◆ OD_Stall

int XrdXrootdProtocol::OD_Stall = 33

staticprotected

Definition at line 460 of file XrdXrootdProtocol.hh.

◆ osFS

XrdSfsFileSystem * XrdXrootdProtocol::osFS

staticprotected

Definition at line 399 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ PathID

short XrdXrootdProtocol::PathID

protected

Definition at line 619 of file XrdXrootdProtocol.hh.

Referenced by getPathID(), and StreamNOP().

◆ pgwCtl

XrdXrootdPgwCtl* XrdXrootdProtocol::pgwCtl

protected

Definition at line 554 of file XrdXrootdProtocol.hh.

◆ pioFirst

XrdXrootdPio* XrdXrootdProtocol::pioFirst

protected

Definition at line 615 of file XrdXrootdProtocol.hh.

◆ pioFree

XrdXrootdPio* XrdXrootdProtocol::pioFree

protected

Definition at line 617 of file XrdXrootdProtocol.hh.

◆ pioLast

XrdXrootdPio* XrdXrootdProtocol::pioLast

protected

Definition at line 616 of file XrdXrootdProtocol.hh.

◆ PMark

XrdNetPMark * XrdXrootdProtocol::PMark = 0

staticprotected

Definition at line 408 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ pmDone

bool XrdXrootdProtocol::pmDone

protected

Definition at line 522 of file XrdXrootdProtocol.hh.

◆ pmHandle

XrdNetPMark::Handle* XrdXrootdProtocol::pmHandle

protected

Definition at line 519 of file XrdXrootdProtocol.hh.

◆ Port

int XrdXrootdProtocol::Port

staticprotected

Definition at line 433 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Process2().

◆ PrepareAlt

bool XrdXrootdProtocol::PrepareAlt = false

staticprotected

Definition at line 630 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ PrepareCount

int XrdXrootdProtocol::PrepareCount

protected

Definition at line 633 of file XrdXrootdProtocol.hh.

◆ PrepareLimit

int XrdXrootdProtocol::PrepareLimit = -1

staticprotected

Definition at line 634 of file XrdXrootdProtocol.hh.

◆ PrepID

XrdOucReqID * XrdXrootdProtocol::PrepID = 0

staticprotected

Definition at line 446 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ Protect

XrdSecProtect* XrdXrootdProtocol::Protect

protected

Definition at line 534 of file XrdXrootdProtocol.hh.

Referenced by Process(), and Process2().

◆ rdType

short XrdXrootdProtocol::rdType

protected

Definition at line 524 of file XrdXrootdProtocol.hh.

Referenced by Process2().

◆ readWait

int XrdXrootdProtocol::readWait

staticprotected

Definition at line 432 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ redirIPHold

int XrdXrootdProtocol::redirIPHold = 8*60*60

staticprotected

Definition at line 436 of file XrdXrootdProtocol.hh.

◆ RedirPI

XrdXrootdRedirPI * XrdXrootdProtocol::RedirPI = 0

staticprotected

Definition at line 409 of file XrdXrootdProtocol.hh.

◆ Req_TLSData

const char XrdXrootdProtocol::Req_TLSData = 0x01

staticprotected

Definition at line 476 of file XrdXrootdProtocol.hh.

◆ Req_TLSGPFile

const char XrdXrootdProtocol::Req_TLSGPFile = 0x02

staticprotected

Definition at line 477 of file XrdXrootdProtocol.hh.

◆ Req_TLSLogin

const char XrdXrootdProtocol::Req_TLSLogin = 0x04

staticprotected

Definition at line 478 of file XrdXrootdProtocol.hh.

◆ Req_TLSSess

const char XrdXrootdProtocol::Req_TLSSess = 0x08

staticprotected

Definition at line 479 of file XrdXrootdProtocol.hh.

◆ Req_TLSTPC

const char XrdXrootdProtocol::Req_TLSTPC = 0x10

staticprotected

Definition at line 480 of file XrdXrootdProtocol.hh.

◆ ReqID

XrdXrootdReqID XrdXrootdProtocol::ReqID

protected

Definition at line 638 of file XrdXrootdProtocol.hh.

Referenced by Process2().

◆ Request

ClientRequest XrdXrootdProtocol::Request

protected

Definition at line 639 of file XrdXrootdProtocol.hh.

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

◆ reserved

char XrdXrootdProtocol::reserved[3]

protected

Definition at line 523 of file XrdXrootdProtocol.hh.

◆ Response

XrdXrootdResponse XrdXrootdProtocol::Response

protected

Definition at line 640 of file XrdXrootdProtocol.hh.

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

◆ Resume

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

protected

Definition at line 590 of file XrdXrootdProtocol.hh.

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

◆ ResumePio

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

protected

Definition at line 589 of file XrdXrootdProtocol.hh.

◆ reTry

XrdSysSemaphore* XrdXrootdProtocol::reTry

protected

Definition at line 605 of file XrdXrootdProtocol.hh.

◆ Route

struct XrdXrootdProtocol::RD_Table XrdXrootdProtocol::Route

staticprotected

Definition at line 159 of file XrdXrootdProtocol.cc.

Referenced by Configure(), and Process2().

◆ RouteClient

struct XrdXrootdProtocol::RC_Table XrdXrootdProtocol::RouteClient

staticprotected

Definition at line 160 of file XrdXrootdProtocol.cc.

Referenced by Process2().

◆ RPList

XrdXrootdXPath XrdXrootdProtocol::RPList

staticprotected

Definition at line 396 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ RQList

XrdXrootdXPath XrdXrootdProtocol::RQList

staticprotected

Definition at line 397 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ RQLxist

int XrdXrootdProtocol::RQLxist = 0

staticprotected

Definition at line 412 of file XrdXrootdProtocol.hh.

◆ rvSeq

unsigned char XrdXrootdProtocol::rvSeq

protected

Definition at line 621 of file XrdXrootdProtocol.hh.

◆ Sched

XrdScheduler * XrdXrootdProtocol::Sched

staticprotected

Definition at line 405 of file XrdXrootdProtocol.hh.

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

◆ SI

XrdXrootdStats * XrdXrootdProtocol::SI

staticprotected

Definition at line 493 of file XrdXrootdProtocol.hh.

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

◆ sigBuff

char XrdXrootdProtocol::sigBuff[64]

protected

Definition at line 541 of file XrdXrootdProtocol.hh.

Referenced by ProcSig().

◆ sigHere

bool XrdXrootdProtocol::sigHere

protected

Definition at line 543 of file XrdXrootdProtocol.hh.

Referenced by Process2(), and ProcSig().

◆ sigNeed

bool XrdXrootdProtocol::sigNeed

protected

Definition at line 542 of file XrdXrootdProtocol.hh.

Referenced by Process(), and Process2().

◆ sigRead

bool XrdXrootdProtocol::sigRead

protected

Definition at line 544 of file XrdXrootdProtocol.hh.

Referenced by ProcSig().

◆ sigReq

SecurityRequest XrdXrootdProtocol::sigReq

protected

Definition at line 540 of file XrdXrootdProtocol.hh.

Referenced by Process2(), and ProcSig().

◆ sigReq2Ver

ClientRequest XrdXrootdProtocol::sigReq2Ver

protected

Definition at line 539 of file XrdXrootdProtocol.hh.

Referenced by Process(), and Process2().

◆ sigWarn

bool XrdXrootdProtocol::sigWarn

protected

Definition at line 545 of file XrdXrootdProtocol.hh.

Referenced by Process2().

◆ srvrAioOps

RAtomic_int XrdXrootdProtocol::srvrAioOps = {0}

staticprotected

Definition at line 176 of file XrdXrootdProtocol.hh.

Referenced by aioUpdate().

◆ Status

char XrdXrootdProtocol::Status

protected

Definition at line 525 of file XrdXrootdProtocol.hh.

Referenced by Process2(), and Recycle().

◆ Stream

XrdXrootdProtocol* XrdXrootdProtocol::Stream[maxStreams]

protected

Definition at line 608 of file XrdXrootdProtocol.hh.

Referenced by VerifyStream().

◆ streamMutex

XrdSysMutex XrdXrootdProtocol::streamMutex

protected

Definition at line 604 of file XrdXrootdProtocol.hh.

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

◆ tlsCap

char XrdXrootdProtocol::tlsCap = 0

staticprotected

Definition at line 482 of file XrdXrootdProtocol.hh.

◆ tlsCtx

XrdTlsContext * XrdXrootdProtocol::tlsCtx = 0

staticprotected

Definition at line 403 of file XrdXrootdProtocol.hh.

Referenced by Configure(), and Process2().

◆ tlsNot

char XrdXrootdProtocol::tlsNot = 0

staticprotected

Definition at line 483 of file XrdXrootdProtocol.hh.

◆ tlsPort

int XrdXrootdProtocol::tlsPort = 0

staticprotected

Definition at line 435 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ totReadP

long long XrdXrootdProtocol::totReadP

protected

Definition at line 511 of file XrdXrootdProtocol.hh.

◆ TraceID

const char * XrdXrootdProtocol::TraceID = "Protocol"

staticprotected

Definition at line 411 of file XrdXrootdProtocol.hh.

◆ unbindMutex

XrdSysMutex XrdXrootdProtocol::unbindMutex

protected

Definition at line 603 of file XrdXrootdProtocol.hh.

Referenced by Recycle(), and RequestClose().

◆ usxMaxNsz

int XrdXrootdProtocol::usxMaxNsz = kXR_faMaxNlen

staticprotected

Definition at line 470 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ usxMaxVsz

int XrdXrootdProtocol::usxMaxVsz = kXR_faMaxVlen

staticprotected

Definition at line 471 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ usxParms

char * XrdXrootdProtocol::usxParms = 0

staticprotected

Definition at line 472 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ Window

int XrdXrootdProtocol::Window

staticprotected

Definition at line 434 of file XrdXrootdProtocol.hh.

Referenced by Configure().

◆ wvInfo

XrdXrootdWVInfo* XrdXrootdProtocol::wvInfo

protected

Definition at line 588 of file XrdXrootdProtocol.hh.

◆ wvSeq

unsigned char XrdXrootdProtocol::wvSeq

protected

Definition at line 622 of file XrdXrootdProtocol.hh.

◆ XPList

XrdXrootdXPath XrdXrootdProtocol::XPList

staticprotected

Definition at line 398 of file XrdXrootdProtocol.hh.

Referenced by Configure().

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

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Class Documentation

◆ XrdXrootdProtocol::GetDataCtl.__unnamed0__

◆ XrdXrootdProtocol::GetDataCtl.__unnamed1__

◆ XrdXrootdProtocol::RC_Table

◆ XrdXrootdProtocol::RD_Table

Constructor & Destructor Documentation

◆ XrdXrootdProtocol()

◆ ~XrdXrootdProtocol()

Member Function Documentation

◆ aioUpdate()

◆ aioUpdReq()

◆ Buffer()

◆ Claim()

◆ CloseRequestCb()

◆ Configure()

◆ do_WriteSpan()

◆ DoIt()

◆ getData() [1/2]

◆ getData() [2/2]

◆ getDump()

◆ getPathID()

◆ getSID()

◆ Match()

◆ MonAuth()

◆ operator=()

◆ Process()

◆ Process2()

◆ ProcSig()

◆ Reclaim()

◆ Recycle()

◆ RequestClose()

◆ SendFile() [1/2]

◆ SendFile() [2/2]

◆ SetFD()

◆ SetSF()

◆ Stats()

◆ StreamNOP()

◆ Swap()

◆ VerifyStream()

Friends And Related Symbol Documentation

◆ XrdXrootdAdmin

Member Data Documentation

◆ ableTLS

◆ AdminSock

◆ AppName

◆ argp

◆ as_aioOK

◆ as_force

◆ as_maxperlnk

◆ as_maxperreq

◆ as_maxpersrv

◆ as_maxstalls

◆ as_miniosz

◆ as_minsfsz

◆ as_nosf

◆ as_okstutter

◆ as_seghalf

◆ as_segsize

◆ as_syncw

◆ as_timeout

◆ AuthProt

◆ boundRecycle

◆ BPool

◆ CapVer

◆ CIA

◆ CL_Redir

◆ Client

◆ clientPV

◆ clientRN

◆ XrdXrootdProtocol::GetDataCtl.unnamed0

◆ XrdXrootdProtocol::GetDataCtl.unnamed1