#include <XrdXrootdTransit.hh>

Inheritance diagram for XrdXrootdTransit:

Collaboration diagram for XrdXrootdTransit:

Public Member Functions
	XrdXrootdTransit ()
	Constructor & Destructor.
virtual	~XrdXrootdTransit ()
bool	Disc ()
	Handle dismantlement.
void	Proceed ()
	Resume processing after a waitresp completion.
int	Process (XrdLink *lp)
	Handle link activation (replaces parent activation).
void	Recycle (XrdLink lp, int consec, const char reason)
	Handle link shutdown.
void	Redrive ()
	Redrive a request after a wait.
bool	Run (const char xreqP, char xdataP=0, int xdataL=0)
	Inject an xrootd request into the protocol stack.
int	Send (int rcode, const struct iovec *ioVec, int ioNum, int ioLen)
	Handle request data response.
int	Send (long long offset, int dlen, int fdnum)
	Handle request sendfile response.
int	Send (XrdOucSFVec *sfvec, int sfvnum, int dlen)
int	setSF (kXR_char *fhandle, bool seton=false)
	Set sendfile() enablement.
void	SetWait (int wtime, bool notify=false)
	Set maximum wait time.
Public Member Functions inherited from XrdXrootd::Bridge
	Bridge ()
	Constructor & Destructor.
Public Member Functions inherited from XrdXrootdProtocol
	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	Process2 ()
int	ProcSig ()
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 XrdXrootdTransit *	Alloc (XrdXrootd::Bridge::Result respP, XrdLink linkP, XrdSecEntity seceP, const char nameP, const char *protP)
	Get a new transit object.
static int	Attn (XrdLink lP, short theSID, int rcode, const struct iovec *ioVec, int ioNum, int ioLen)
	Handle attention response (i.e. async response)
static void	Init (XrdScheduler *schedP, int qMax, int qTTL)
	Perform one-time initialization.
static const char *	ReqTable ()
	Initialize the valid request table.
Static Public Member Functions inherited from XrdXrootd::Bridge
static Bridge *	Login (Result rsltP, XrdLink linkP, XrdSecEntity seceP, const char nameP, const char *protP)
Static Public Member Functions inherited from XrdXrootdProtocol
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)

Additional Inherited Members
Public Attributes inherited from XrdJob
const char *	Comment
XrdJob *	NextJob
Static Public Attributes inherited from XrdXrootdProtocol
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 inherited from XrdXrootd::Bridge
virtual	~Bridge ()
Protected Member Functions inherited from XrdXrootdProtocol
void	MonAuth ()
bool	RequestClose ()
int	SetSF (kXR_char *fhandle, bool seton=false)
Static Protected Member Functions inherited from XrdXrootdProtocol
static bool	CloseRequestCb (void *cbarg)
static unsigned int	getSID ()
Protected Attributes inherited from XrdXrootdProtocol
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 inherited from XrdXrootdProtocol
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

Detailed Description

Definition at line 55 of file XrdXrootdTransit.hh.

Constructor & Destructor Documentation

◆ XrdXrootdTransit()

XrdXrootdTransit::XrdXrootdTransit ( )

inline

Constructor & Destructor.

Definition at line 162 of file XrdXrootdTransit.hh.

                                 : TranLink(this),
                                   respJob(this, &XrdXrootdTransit::Proceed,
                                           "Transit proceed"),
                                   waitJob(this, &XrdXrootdTransit::Redrive,
                                           "Transit redrive"),
                                   waitCnd(0)
                                 {}

References XrdXrootdTransit(), Proceed(), and Redrive().

Referenced by XrdXrootdTransit(), and Alloc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~XrdXrootdTransit()

virtual XrdXrootdTransit::~XrdXrootdTransit ( )

inlinevirtual

Definition at line 169 of file XrdXrootdTransit.hh.

169{}

Member Function Documentation

◆ Alloc()

XrdXrootdTransit * XrdXrootdTransit::Alloc	(	XrdXrootd::Bridge::Result *	respP,
		XrdLink *	linkP,
		XrdSecEntity *	seceP,
		const char *	nameP,
		const char *	protP )

static

Get a new transit object.

Definition at line 77 of file XrdXrootdTransit.cc.

{
   XrdXrootdTransit *xp;
 
// Simply return a new transit object masquerading as a bridge
//
   if (!(xp = TranStack.Pop())) xp = new XrdXrootdTransit();
   xp->Init(rsltP, linkP, seceP, nameP, protP);
   return xp;
}

References XrdXrootdTransit(), and Init().

Referenced by XrdXrootd::Bridge::Login().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Attn()

int XrdXrootdTransit::Attn	(	XrdLink *	lP,
		short *	theSID,
		int	rcode,
		const struct iovec *	ioVec,
		int	ioNum,
		int	ioLen )

static

Handle attention response (i.e. async response)

Definition at line 97 of file XrdXrootdTransit.cc.

{
   XrdXrootdTransPend *tP;
 
// Find the request
//
   if (!(tP = XrdXrootdTransPend::Remove(lP, *theSID)))
      {TRACE(REQ, "Unable to find request for " <<lP->ID <<" sid=" <<*theSID);
       return 0;
      }
 
// Resume the request as we have been waiting for the response.
//
   return tP->bridge->AttnCont(tP, rcode, ioV, ioN, ioL);
}

References XrdXrootdTransPend::bridge, XrdLink::ID, XrdXrootdTransPend::Remove(), and TRACE.

Referenced by XrdXrootdResponse::Send().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Disc()

bool XrdXrootdTransit::Disc ( )

virtual

Handle dismantlement.

Implements XrdXrootd::Bridge.

Definition at line 175 of file XrdXrootdTransit.cc.

{
   char buff[128];
 
// We do not allow disconnection while we are active
//
   if (runStatus.fetch_add(1, std::memory_order_acq_rel)) return false;
 
// Reconnect original protocol to the link
//
   Link->setProtocol(realProt);
 
// Now we need to recycle our xrootd part
//
   sprintf(buff, "%s disconnection", pName);
   XrdXrootdProtocol::Recycle(Link, time(0)-cTime, buff);
 
// Make sure that any pending wait jobs can exit
//
   {
     XrdSysCondVarHelper clk(waitCnd);
     waitPend = false;
     runWait = 0;
     waitCnd.Broadcast();
   }
 
// Now just free up our object.
//
   TranStack.Push(&TranLink);
   return true;
}

References XrdXrootdProtocol::Link, and XrdXrootdProtocol::Recycle().

Here is the call graph for this function:

◆ Init()

void XrdXrootdTransit::Init	(	XrdScheduler *	schedP,
		int	qMax,
		int	qTTL )

static

Perform one-time initialization.

Definition at line 234 of file XrdXrootdTransit.cc.

{
   TranStack.Set(schedP, &XrdXrootdTrace, TRACE_MEM);
   TranStack.Set(qMax, qTTL);
}

References TRACE_MEM, XrdJob::XrdScheduler, and XrdXrootdTrace.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Proceed()

void XrdXrootdTransit::Proceed ( )

Resume processing after a waitresp completion.

Definition at line 353 of file XrdXrootdTransit.cc.

{
   int rc;
 
// If we were interrupted in a reinvoke state, resume that state.
//
   if (reInvoke) rc = Process(Link);
      else rc = 0;
 
// Handle ending status
//
   if (rc >= 0) Link->Enable();
      else if (rc != -EINPROGRESS) Link->Close();
}

References XrdXrootdProtocol::Link, and Process().

Referenced by XrdXrootdTransit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Process()

int XrdXrootdTransit::Process ( XrdLink * lp )

virtual

Handle link activation (replaces parent activation).

Reimplemented from XrdXrootdProtocol.

Definition at line 372 of file XrdXrootdTransit.cc.

{
   int rc;
 
// This entry is serialized via link processing and data is now available.
// One of the following will be returned.
//
// < 0 -> Stop getting requests,
//        -EINPROGRESS leave link disabled but otherwise all is well
//        -n           Error, disable and close the link
// = 0 -> OK, get next request, if allowed, o/w enable the link
// > 0 -> Slow link, stop getting requests  and enable the link
//
 
// Reflect data is present to the underlying protocol and if Run() has been
// called we need to dispatch that request. This may be iterative.
//
do{rc = realProt->Process((reInvoke ? 0 : lp));
   if (rc >= 0 && runStatus.load(std::memory_order_acquire))
      {reInvoke = (rc == 0);
       if (runError) rc = Fatal(rc);
          else {runDone = false;
                rc = (Resume ? XrdXrootdProtocol::Process(lp) : Process2());
                if (rc >= 0)
                   {if (runDone) runStatus.store(0, std::memory_order_release);
                    if (runWait)
                       {XrdSysCondVarHelper clk(waitCnd);
                        waitPend = false;
                        waitCnd.Broadcast();
                        return -EINPROGRESS;
                       }
                    if (!runDone) return rc;
                   }
               }
      } else reInvoke = false;
   } while(rc >= 0 && reInvoke);
 
// Make sure that we indicate that we are no longer active
//
   runStatus.store(0, std::memory_order_release);
 
// All done
//
   return (rc ? rc : 1);
}

References XrdXrootdProtocol::Process(), XrdXrootdProtocol::Process2(), and XrdXrootdProtocol::Resume.

Referenced by Proceed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Recycle()

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

virtual

Handle link shutdown.

Reimplemented from XrdXrootdProtocol.

Definition at line 422 of file XrdXrootdTransit.cc.

{
 
// Set ourselves as active so we can't get more requests
//
   runStatus.fetch_add(1, std::memory_order_acq_rel);
 
// If we were active then we will need to quiesce before dismantling ourselves.
// Note that Recycle() can only be called if the link is enabled. So, this bit
// of code is improbable but we check it anyway.
//
   if (runWait > 0) {
       TRACEP(EMSG, "WARNING: Recycle is canceling wait job; the wait job might already be running during recycle.");
       Sched->Cancel(&waitJob);
   }
 
// First we need to recycle the real protocol
//
   if (realProt) realProt->Recycle(lp, consec, reason);
 
// Now we need to recycle our xrootd part
//
   XrdXrootdProtocol::Recycle(lp, consec, reason);
 
// Release the argument buffer
//
   if (runArgs) {free(runArgs); runArgs = 0;}
 
// Delete all pending requests
//
   XrdXrootdTransPend::Clear(this);
 
// Make sure that any pending wait jobs can exit
//
   {
     XrdSysCondVarHelper clk(waitCnd);
     waitPend = false;
     runWait = 0;
     waitCnd.Broadcast();
   }
 
// Now just free up our object.
//
   TranStack.Push(&TranLink);
}

References XrdXrootdTransPend::Clear(), EMSG, XrdXrootdProtocol::Recycle(), XrdXrootdProtocol::Sched, and TRACEP.

Here is the call graph for this function:

◆ Redrive()

void XrdXrootdTransit::Redrive ( )

Redrive a request after a wait.

Definition at line 472 of file XrdXrootdTransit.cc.

{
   static int  eCode         = htonl(kXR_NoMemory);
   static char eText[]       = "Insufficent memory to re-issue request";
   static struct iovec ioV[] = {{(char *)&eCode,sizeof(eCode)},
                                {(char *)&eText,sizeof(eText)}};
   int rc;
 
// we ensure waitPend has been cleared. This is to allow the process or
// redrive loops to have taken the correct action before we zero the
// runWait value.
//
   {
     XrdSysCondVarHelper clk(waitCnd);
     while(waitPend) waitCnd.Wait();
   }
 
// Do some tracing
//
   TRACEP(REQ, "Bridge redrive runStatus="<<runStatus.load(std::memory_order_acquire)
               <<" runError="<<runError
               <<" runWait="<<runWait<<" runWTot="<<runWTot);
 
// Update wait statistics
//
   runWTot += runWait;
   runWait = 0;
 
// While we are running asynchronously, there is no way that this object can
// be deleted while a timer is outstanding as the link has been disabled. So,
// we can reissue the request with little worry.
//
// This is a bit tricky here as a redriven request may result in a wait. If
// this happens we cannot hand the result off to the real protocol until we
// wait and successfully redrive. The wait handling occurs asynchronously
// so all we need to do is honor it here.
//
   if (!runALen || RunCopy(runArgs, runALen)) {
      do{runDone = false;
         rc = Process2();
         TRACEP(REQ, "Bridge redrive Process2 rc="<<rc
                     <<" runError="<<runError<<" runWait="<<runWait);
        if (rc < 0) break;
        if (runDone) runStatus.store(0, std::memory_order_release);
        if (runWait || !runDone || !reInvoke) break;
        rc = realProt->Process(NULL);
        TRACEP(REQ, "Bridge redrive callback rc="<<rc
                    <<" runStatus="<<runStatus.load(std::memory_order_acquire));
        if (rc < 0 || !runStatus.load(std::memory_order_acquire))
           {reInvoke = false;
            break;
           }
        reInvoke = (rc == 0);
        if (runError) rc = Fatal(rc);
      } while((rc >= 0) && !runError && !runWait);
   }
      else rc = Send(kXR_error, ioV, 2, 0);
 
// Defer the request if need be
//
   if (rc >= 0 && runWait)
      {XrdSysCondVarHelper clk(waitCnd);
       waitPend = false;
       waitCnd.Broadcast();
       return;
      }
   runWTot = 0;
 
// Indicate we are no longer active
//
   runStatus.store(0, std::memory_order_release);
 
// If the link needs to be terminated, terminate the link. Otherwise, we can
// enable the link for new requests at this point.
//
   if (rc < 0) Link->Close();
      else     Link->Enable();
}

References Fatal(), kXR_error, kXR_NoMemory, XrdXrootdProtocol::Link, XrdXrootdProtocol::Process2(), Send(), and TRACEP.

Referenced by XrdXrootdTransit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReqTable()

const char * XrdXrootdTransit::ReqTable ( )

static

Initialize the valid request table.

Definition at line 557 of file XrdXrootdTransit.cc.

{
   static char rTab[kXR_truncate-kXR_auth+1];
 
// Initialize the table
//
   memset(rTab, 0, sizeof(rTab));
   rTab[KXR_INDEX(kXR_chmod)]     = 1;
   rTab[KXR_INDEX(kXR_close)]     = 1;
   rTab[KXR_INDEX(kXR_dirlist)]   = 1;
   rTab[KXR_INDEX(kXR_locate)]    = 1;
   rTab[KXR_INDEX(kXR_mkdir)]     = 1;
   rTab[KXR_INDEX(kXR_mv)]        = 1;
   rTab[KXR_INDEX(kXR_open)]      = 1;
   rTab[KXR_INDEX(kXR_prepare)]   = 1;
   rTab[KXR_INDEX(kXR_protocol)]  = 1;
   rTab[KXR_INDEX(kXR_query)]     = 1;
   rTab[KXR_INDEX(kXR_read)]      = 2;
   rTab[KXR_INDEX(kXR_readv)]     = 2;
   rTab[KXR_INDEX(kXR_rm)]        = 1;
   rTab[KXR_INDEX(kXR_rmdir)]     = 1;
   rTab[KXR_INDEX(kXR_set)]       = 1;
   rTab[KXR_INDEX(kXR_stat)]      = 1;
   rTab[KXR_INDEX(kXR_statx)]     = 1;
   rTab[KXR_INDEX(kXR_sync)]      = 1;
   rTab[KXR_INDEX(kXR_truncate)]  = 1;
   rTab[KXR_INDEX(kXR_write)]     = 2;
 
// Now return the address
//
   return rTab;
}

References kXR_auth, kXR_chmod, kXR_close, kXR_dirlist, KXR_INDEX, kXR_locate, kXR_mkdir, kXR_mv, kXR_open, kXR_prepare, kXR_protocol, kXR_query, kXR_read, kXR_readv, kXR_rm, kXR_rmdir, kXR_set, kXR_stat, kXR_statx, kXR_sync, kXR_truncate, and kXR_write.

◆ Run()

bool XrdXrootdTransit::Run	(	const char *	xreqP,
		char *	xdataP = 0,
		int	xdataL = 0 )

virtual

Inject an xrootd request into the protocol stack.

Parameters

xreqP	xrootd request header
xdataP	xrootd request data (optional)
xdataL	xrootd request data length

Implements XrdXrootd::Bridge.

Definition at line 621 of file XrdXrootdTransit.cc.

{
   int movLen;
 
// We do not allow re-entry if we are curently processing a request.
// It will be reset, as need, when a response is effected.
//
 
   if (runStatus.fetch_add(1, std::memory_order_acq_rel))
      {TRACEP(REQ, "Bridge request failed due to re-entry");
       return false;
      }
 
// Copy the request header
//
   memcpy((void *)&Request, (void *)xreqP, sizeof(Request));
 
// Validate that we can actually handle this request
//
   Request.header.requestid = ntohs(Request.header.requestid);
   if (Request.header.requestid & 0x8000
   || Request.header.requestid > static_cast<kXR_unt16>(kXR_truncate)
   || !reqTab[Request.header.requestid - kXR_auth])
      {TRACEP(REQ, "Unsupported bridge request");
       return Fail(kXR_Unsupported, "Unsupported bridge request");
      }
 
// Validate the data length
//
   Request.header.dlen      = ntohl(Request.header.dlen);
   if (Request.header.dlen < 0)
      {TRACEP(REQ, "Invalid request data length");
       return Fail(kXR_ArgInvalid, "Invalid request data length");
      }
 
// Copy the stream id and trace this request
//
   Response.Set(Request.header.streamid);
   TRACEP(REQ, "Bridge req=" <<Request.header.requestid
               <<" dlen=" <<Request.header.dlen <<" blen=" <<xdataL);
 
// If this is a write request, we will need to do a lot more
//
   if (Request.header.requestid == kXR_write) return ReqWrite(xdataP, xdataL);
 
// Obtain any needed buffer and handle any existing data arguments. Also, we
// need to keep a shadow copy of the request arguments should we get a wait
// and will need to re-issue the request (the server mangles the args).
//
   if (Request.header.dlen)
      {movLen = (xdataL < Request.header.dlen ? xdataL : Request.header.dlen);
       if (!RunCopy(xdataP, movLen)) return true;
       if (!runArgs || movLen > runABsz)
          {if (runArgs) free(runArgs);
           if (!(runArgs = (char *)malloc(movLen)))
              {TRACEP(REQ, "Failed to allocate memory");
               return Fail(kXR_NoMemory, "Insufficient memory");
              }
           runABsz = movLen;
          }
       memcpy(runArgs, xdataP, movLen); runALen = movLen;
       if ((myBlen = Request.header.dlen - movLen))
          {myBuff = argp->buff + movLen;
           Resume = &XrdXrootdProtocol::Process2;
           return true;
          }
      } else runALen = 0;
 
// If we have all the data, indicate request accepted.
//
   runError = 0;
   Resume   = 0;
   return true;
}

References XrdXrootdProtocol::argp, kXR_ArgInvalid, kXR_auth, kXR_NoMemory, kXR_truncate, kXR_Unsupported, kXR_write, XrdXrootdProtocol::myBlen, XrdXrootdProtocol::myBuff, XrdXrootdProtocol::Process2(), XrdXrootdProtocol::Request, XrdXrootdProtocol::Response, XrdXrootdProtocol::Resume, and TRACEP.

Here is the call graph for this function:

◆ Send() [1/3]

int XrdXrootdTransit::Send	(	int	rcode,
		const struct iovec *	ioVec,
		int	ioNum,
		int	ioLen )

Handle request data response.

Definition at line 723 of file XrdXrootdTransit.cc.

{
   XrdXrootd::Bridge::Context rInfo(Link, Request.header.streamid,
                                          Request.header.requestid);
   const char *eMsg;
   int         rc;
   bool        aOK;
 
// Invoke the result object (we initially assume this is the final result)
//
   runDone = true;
   switch(rcode)
         {case kXR_error:
                   rc = XRD_GETNUM(ioV[0].iov_base);
                   eMsg = (ioN < 2 ? "" : (const char *)ioV[1].iov_base);
                   if (wBuff) respObj->Free(rInfo, wBuff, wBLen);
                   aOK = respObj->Error(rInfo, rc, eMsg);
                   break;
          case kXR_ok:
                   if (wBuff)  respObj->Free(rInfo, wBuff, wBLen);
                   aOK = (ioN ? respObj->Data(rInfo, ioV, ioN, ioL, true)
                              : respObj->Done(rInfo));
                   break;
          case kXR_oksofar:
                   aOK = respObj->Data(rInfo, ioV, ioN, ioL, false);
                   runDone = false;
                   break;
          case kXR_redirect:
                   if (wBuff) respObj->Free(rInfo, wBuff, wBLen);
                   rc = XRD_GETNUM(ioV[0].iov_base);
                   aOK = respObj->Redir(rInfo,rc,(const char *)ioV[1].iov_base);
                   break;
          case kXR_wait:
                   return Wait(rInfo, ioV, ioN, ioL);
                   break;
          case kXR_waitresp:
                   runDone = false;
                   return WaitResp(rInfo, ioV, ioN, ioL);
                   break;
          default: if (wBuff) respObj->Free(rInfo, wBuff, wBLen);
                   aOK = respObj->Error(rInfo, kXR_ServerError,
                                       "internal logic error");
                   break;
         };
 
// All done
//
   return (aOK ? 0 : -1);
}

References eMsg, kXR_error, kXR_ok, kXR_oksofar, kXR_redirect, kXR_ServerError, kXR_wait, kXR_waitresp, XrdXrootdProtocol::Link, XrdXrootdProtocol::Request, and XRD_GETNUM.

Referenced by Redrive().

Here is the caller graph for this function:

◆ Send() [2/3]

int XrdXrootdTransit::Send	(	long long	offset,
		int	dlen,
		int	fdnum )

Handle request sendfile response.

Definition at line 775 of file XrdXrootdTransit.cc.

{
   XrdXrootdTransSend sfInfo(Link, Request.header.streamid,
                                   Request.header.requestid,
                                   offset, dlen, fdnum);
 
// Effect callback (this is always a final result)
//
   runDone = true;
   return (respObj->File(sfInfo, dlen) ? 0 : -1);
}

References XrdXrootdProtocol::Link, and XrdXrootdProtocol::Request.

◆ Send() [3/3]

int XrdXrootdTransit::Send	(	XrdOucSFVec *	sfvec,
		int	sfvnum,
		int	dlen )

Definition at line 789 of file XrdXrootdTransit.cc.

{
   XrdXrootdTransSend sfInfo(Link, Request.header.streamid,
                                   Request.header.requestid,
                                   sfvec, sfvnum, dlen);
 
// Effect callback (this is always a final result)
//
   runDone = true;
   return (respObj->File(sfInfo, dlen) ? 0 : -1);
}

References XrdXrootdProtocol::Link, and XrdXrootdProtocol::Request.

◆ setSF()

int XrdXrootdTransit::setSF	(	kXR_char *	fhandle,
		bool	seton = false )

inlinevirtual

Set sendfile() enablement.

Implements XrdXrootd::Bridge.

Definition at line 148 of file XrdXrootdTransit.hh.

149 {return SetSF(fhandle, seton);}

XrdXrootdProtocol::SetSF

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

Definition XrdXrootdXeq.cc:4328

References XrdXrootdProtocol::SetSF().

Here is the call graph for this function:

◆ SetWait()

void XrdXrootdTransit::SetWait	(	int	wtime,
		bool	notify = false )

inlinevirtual

Set maximum wait time.

Implements XrdXrootd::Bridge.

Definition at line 155 of file XrdXrootdTransit.hh.

156 {runWMax = wtime; runWCall = notify;}

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

	XRootD

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ XrdXrootdTransit()

◆ ~XrdXrootdTransit()

Member Function Documentation

◆ Alloc()

◆ Attn()

◆ Disc()

◆ Init()

◆ Proceed()

◆ Process()

◆ Recycle()

◆ Redrive()

◆ ReqTable()

◆ Run()

◆ Send() [1/3]

◆ Send() [2/3]

◆ Send() [3/3]

◆ setSF()

◆ SetWait()