#include <XrdXrootdTransit.hh>

Inheritance diagram for XrdXrootdTransit:

Collaboration diagram for XrdXrootdTransit:

Public Member Functions
	XrdXrootdTransit ()
	Constructor & Destructor. More...

virtual	~XrdXrootdTransit ()

bool	Disc ()
	Handle dismantlement. More...

void	Proceed ()
	Resume processing after a waitresp completion. More...

int	Process (XrdLink *lp)
	Handle link activation (replaces parent activation). More...

void	Recycle (XrdLink lp, int consec, const char reason)
	Handle link shutdown. More...

void	Redrive ()
	Redrive a request after a wait. More...

bool	Run (const char xreqP, char xdataP=0, int xdataL=0)
	Inject an xrootd request into the protocol stack. More...

int	Send (int rcode, const struct iovec *ioVec, int ioNum, int ioLen)
	Handle request data response. More...

int	Send (long long offset, int dlen, int fdnum)
	Handle request sendfile response. More...

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

int	setSF (kXR_char *fhandle, bool seton=false)
	Set sendfile() enablement. More...

void	SetWait (int wtime, bool notify=false)
	Set maximum wait time. More...

Public Member Functions inherited from XrdXrootd::Bridge
	Bridge ()
	Constructor & Destructor. More...

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. More...

virtual	~XrdSfsDio ()

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

virtual	~XrdSfsXio ()
	Constructor and destructor. More...

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. More...

static int	Attn (XrdLink lP, short theSID, int rcode, const struct iovec *ioVec, int ioNum, int ioLen)
	Handle attention response (i.e. async response) More...

static void	Init (XrdScheduler *schedP, int qMax, int qTTL)
	Perform one-time initialization. More...

static const char *	ReqTable ()
	Initialize the valid request table. More...

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)
                                  {}

Referenced by Alloc().

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(), Init(), and XrdObjectQ< T >::Pop().

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 XrdSysCondVar::Broadcast(), XrdXrootdProtocol::Link, XrdObjectQ< T >::Push(), XrdXrootdProtocol::Recycle(), and XrdLink::setProtocol().

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 XrdOfsPrepGPIReal::schedP, XrdObjectQ< T >::Set(), TRACE_MEM, 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 XrdLink::Close(), XrdLink::Enable(), XrdXrootdProtocol::Link, and Process().

Here is the call 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 XrdSysCondVar::Broadcast(), XrdXrootdProtocol::Process(), XrdProtocol::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 XrdSysCondVar::Broadcast(), XrdScheduler::Cancel(), XrdXrootdTransPend::Clear(), EMSG, XrdObjectQ< T >::Push(), XrdXrootdProtocol::Recycle(), XrdProtocol::Recycle(), XrdXrootdProtocol::Sched, and TRACEP.

Here is the call graph for this function:

◆ Redrive()

void XrdXrootdTransit::Redrive ( void )

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 XrdSysCondVar::Broadcast(), XrdLink::Close(), XrdLink::Enable(), Fatal(), kXR_error, kXR_NoMemory, XrdXrootdProtocol::Link, XrdProtocol::Process(), XrdXrootdProtocol::Process2(), Send(), TRACEP, and XrdSysCondVar::Wait().

Here is the call 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, XrdBuffer::buff, ClientRequestHdr::dlen, ClientRequest::header, kXR_ArgInvalid, kXR_auth, kXR_NoMemory, kXR_truncate, kXR_Unsupported, kXR_write, XrdXrootdProtocol::myBlen, XrdXrootdProtocol::myBuff, XrdXrootdProtocol::Process2(), XrdXrootdProtocol::Request, ClientRequestHdr::requestid, XrdXrootdProtocol::Response, XrdXrootdProtocol::Resume, XrdXrootdResponse::Set(), ClientRequestHdr::streamid, 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 XrdXrootd::Bridge::Result::Data(), XrdXrootd::Bridge::Result::Done(), eMsg, XrdXrootd::Bridge::Result::Error(), XrdXrootd::Bridge::Result::Free(), ClientRequest::header, kXR_error, kXR_ok, kXR_oksofar, kXR_redirect, kXR_ServerError, kXR_wait, kXR_waitresp, XrdXrootdProtocol::Link, XrdXrootd::Bridge::Result::Redir(), XrdXrootdProtocol::Request, ClientRequestHdr::requestid, ClientRequestHdr::streamid, and XRD_GETNUM.

Referenced by Redrive(), and XrdXrootdResponse::Send().

Here is the call graph for this function:

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 XrdXrootd::Bridge::Result::File(), ClientRequest::header, XrdXrootdProtocol::Link, XrdXrootdProtocol::Request, ClientRequestHdr::requestid, and ClientRequestHdr::streamid.

Here is the call graph for this function:

◆ 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 XrdXrootd::Bridge::Result::File(), ClientRequest::header, XrdXrootdProtocol::Link, XrdXrootdProtocol::Request, ClientRequestHdr::requestid, and ClientRequestHdr::streamid.

Here is the call graph for this function:

◆ 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:

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()