XrdLinkXeq Class Reference

#include <XrdLinkXeq.hh>

Inheritance diagram for XrdLinkXeq:

Collaboration diagram for XrdLinkXeq:

Public Member Functions
	XrdLinkXeq ()
	~XrdLinkXeq ()
XrdNetAddrInfo *	AddrInfo ()
int	Backlog ()
int	Client (char *buff, int blen)
int	Close (bool defer=false)
void	DoIt ()
int	getIOStats (long long &inbytes, long long &outbytes, int &numstall, int &numtardy)
XrdTlsPeerCerts *	getPeerCerts ()
XrdProtocol *	getProtocol ()
const char *	Name () const
const XrdNetAddr *	NetAddr () const
int	Peek (char *buff, int blen, int timeout=-1)
int	Recv (char *buff, int blen)
int	Recv (char *buff, int blen, int timeout)
int	Recv (const struct iovec *iov, int iocnt, int timeout)
int	RecvAll (char *buff, int blen, int timeout=-1)
bool	Register (const char *hName)
bool	RegisterCloseRequestCb (XrdProtocol *pp, bool(*cb)(void *), void *cbarg)
int	Send (const char *buff, int blen)
int	Send (const sfVec *sdP, int sdn)
int	Send (const struct iovec *iov, int iocnt, int bytes=0)
void	setID (const char *userid, int procid)
void	setLocation (XrdNetAddrInfo::LocInfo &loc)
bool	setNB ()
void	setProtName (const char *name)
XrdProtocol *	setProtocol (XrdProtocol *pp, bool push)
bool	setTLS (bool enable, XrdTlsContext *ctx=0)
void	Shutdown (bool getLock)
void	syncStats (int *ctime=0)
int	TLS_Peek (char *Buff, int Blen, int timeout)
int	TLS_Recv (char *Buff, int Blen)
int	TLS_Recv (char *Buff, int Blen, int timeout, bool havelock=false)
int	TLS_Recv (const struct iovec *iov, int iocnt, int timeout)
int	TLS_RecvAll (char *Buff, int Blen, int timeout)
int	TLS_Send (const char *Buff, int Blen)
int	TLS_Send (const sfVec *sfP, int sfN)
int	TLS_Send (const struct iovec *iov, int iocnt, int bytes)
const char *	verTLS ()

Static Public Member Functions
static int	getName (int &curr, char *bname, int blen, XrdLinkMatch *who=0)
static int	Stats (char *buff, int blen, bool do_sync=false)

Public Attributes
XrdLinkInfo	LinkInfo
XrdPollInfo	PollInfo

Protected Member Functions
int	RecvIOV (const struct iovec *iov, int iocnt)
void	Reset ()
int	sendData (const char *Buff, int Blen)
int	SendIOV (const struct iovec *iov, int iocnt, int bytes)
int	SFError (int rc)
int	TLS_Error (const char *act, XrdTls::RC rc)
bool	TLS_Write (const char *Buff, int Blen)
Protected Member Functions inherited from XrdLink
	~XrdLink ()
void	ResetLink ()
int	Wait4Data (int timeout)
	XrdLink (XrdLinkXeq &lxq)
bool	Activate ()
XrdNetAddrInfo *	AddrInfo ()
void	armBridge ()
	Mark this link as an in-memory communications bridge (internal use only). More...
int	Backlog ()
int	Client (char *buff, int blen)
int	Close (bool defer=false)
void	Enable ()
	Enable the link to field interrupts. More...
int	FDnum ()
int	getIOStats (long long &inbytes, long long &outbytes, int &numstall, int &numtardy)
XrdTlsPeerCerts *	getPeerCerts ()
XrdProtocol *	getProtocol ()
	Obtain current protocol object pointer. More...
bool	hasBridge () const
bool	hasTLS () const
void	Hold (bool lk)
const char *	Host () const
unsigned int	Inst () const
bool	isFlawed () const
bool	isInstance (unsigned int inst) const
const char *	Name () const
const XrdNetAddr *	NetAddr () const
int	Peek (char *buff, int blen, int timeout=-1)
int	Recv (char *buff, int blen)
int	Recv (char *buff, int blen, int timeout)
int	Recv (const struct iovec *iov, int iocnt, int timeout)
int	RecvAll (char *buff, int blen, int timeout=-1)
bool	Register (const char *hName)
int	Send (const char *buff, int blen)
int	Send (const sfVec *sdP, int sdn)
int	Send (const struct iovec *iov, int iocnt, int bytes=0)
void	Serialize ()
	Wait for all outstanding requests to be completed on the link. More...
int	setEtext (const char *text)
void	setID (const char *userid, int procid)
void	setLocation (XrdNetAddrInfo::LocInfo &loc)
bool	setNB ()
void	setProtName (const char *name)
XrdProtocol *	setProtocol (XrdProtocol *pp, bool runit=false, bool push=false)
void	setRef (int cnt)
bool	setTLS (bool enable, XrdTlsContext *ctx=0)
	Enable or disable TLS on the link. More...
void	Shutdown (bool getLock)
void	syncStats (int *ctime=0)
int	Terminate (const char *owner, int fdnum, unsigned int inst)
time_t	timeCon () const
	Return the time the link was made active (i.e. time of connection). More...
int	UseCnt () const
	Return link's reference count. More...
const char *	verTLS ()
Protected Member Functions inherited from XrdJob
	XrdJob (const char *desc="")
virtual	~XrdJob ()

Protected Attributes
XrdNetAddr	Addr
long long	BytesIn
long long	BytesInTot
long long	BytesOut
long long	BytesOutTot
bool(*	CloseRequestCb )(void *)
void *	CloseRequestCbArg
int	HNlen
char	isIdle
bool	KeepFD
char	Lname [256]
bool	LockReads
XrdProtocol *	ProtoAlt
XrdProtocol *	Protocol
XrdSysMutex	rdMutex
XrdSendQ *	sendQ
int	SfIntr
int	stallCnt
int	stallCntTot
int	tardyCnt
int	tardyCntTot
XrdTlsSocket	tlsIO
char	Uname [24]
XrdSysMutex	wrMutex
Protected Attributes inherited from XrdLink
char *	HostName
unsigned int	Instance
bool	isBridged
bool	isTLS
XrdLinkXeq &	linkXQ
void *	rsvd1 [3]
char	rsvd2 [2]
char *	ID
	Pointer to the client's link identity. More...
Protected Attributes inherited from XrdJob
const char *	Comment
XrdJob *	NextJob

Static Protected Attributes
static long long	LinkBytesIn = 0
static long long	LinkBytesOut = 0
static long long	LinkConTime = 0
static int	LinkCount = 0
static int	LinkCountMax = 0
static long long	LinkCountTot = 0
static int	LinkSfIntr = 0
static int	LinkStalls = 0
static int	LinkTimeOuts = 0
static XrdSysMutex	statsMutex
static const char *	TraceID = "LinkXeq"
Static Protected Attributes inherited from XrdLink
static bool	sfOK = false

Additional Inherited Members
Protected Types inherited from XrdLink
typedef XrdOucSFVec	sfVec
Static Protected Member Functions inherited from XrdLink
static XrdLink *	Find (int &curr, XrdLinkMatch *who=0)
static int	getName (int &curr, char *bname, int blen, XrdLinkMatch *who=0)
static int	Stats (char *buff, int blen, bool do_sync=0)

Detailed Description

Definition at line 52 of file XrdLinkXeq.hh.

Constructor & Destructor Documentation

XrdLinkXeq()

XrdLinkXeq::XrdLinkXeq

(

)

Definition at line 108 of file XrdLinkXeq.cc.

                       : XrdLink(*this), PollInfo((XrdLink &)*this)
{
   XrdLinkXeq::Reset();
}

References Reset().

Here is the call graph for this function:

~XrdLinkXeq()

XrdLinkXeq::~XrdLinkXeq ( )

inline

Definition at line 145 of file XrdLinkXeq.hh.

{}  // Is never deleted!

Member Function Documentation

AddrInfo()

XrdNetAddrInfo* XrdLinkXeq::AddrInfo ( )

inline

Definition at line 57 of file XrdLinkXeq.hh.

{return (XrdNetAddrInfo *)&Addr;}

References Addr.

Referenced by XrdLink::AddrInfo().

Here is the caller graph for this function:

Backlog()

int XrdLinkXeq::Backlog

(

)

Definition at line 140 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper lck(wrMutex);
 
// Return backlog information
//
   return (sendQ ? sendQ->Backlog() : 0);
}

References XrdSendQ::Backlog(), sendQ, and wrMutex.

Referenced by XrdLink::Backlog().

Here is the call graph for this function:

Here is the caller graph for this function:

Client()

int XrdLinkXeq::Client	(	char *	buff,
		int	blen
	)

Definition at line 153 of file XrdLinkXeq.cc.

{
   int ulen;
 
// Generate full client name
//
   if (nbsz <= 0) return 0;
   ulen = (Lname - ID);
   if ((ulen + HNlen) >= nbsz) ulen = 0;
      else {strncpy(nbuf, ID, ulen);
            strcpy(nbuf+ulen, HostName);
            ulen += HNlen;
           }
   return ulen;
}

References HNlen, XrdLink::HostName, XrdLink::ID, and Lname.

Referenced by XrdLink::Client(), and XrdLinkCtl::getName().

Here is the caller graph for this function:

Close()

int XrdLinkXeq::Close

(

bool

defer = false

)

Definition at line 173 of file XrdLinkXeq.cc.

{  XrdSysMutexHelper opHelper(LinkInfo.opMutex);
   int csec, fd, rc = 0;
 
// If a defer close is requested, we can close the descriptor but we must
// keep the slot number to prevent a new client getting the same fd number.
// Linux is peculiar in that any in-progress operations will remain in that
// state even after the FD is closed unless there is some activity either on
// the connection or an event occurs that causes an operation restart. We
// portably solve this problem by issuing a shutdown() on the socket prior
// closing it. On most platforms, this informs readers that the connection is
// gone (though not on old (i.e. <= 2.3) versions of Linux, sigh). Also, if
// nonblocking mode is enabled, we need to do this in a separate thread as
// a shutdown may block for a pretty long time if lots\ of messages are queued.
// We will ask the SendQ object to schedule the shutdown for us before it
// commits suicide.
// Note that we can hold the opMutex while we also get the wrMutex.
//
   if (defer)
      {if (!sendQ) Shutdown(false);
          else {TRACEI(DEBUG, "Shutdown FD " <<LinkInfo.FD<<" only via SendQ");
                LinkInfo.InUse++;
                LinkInfo.FD = -LinkInfo.FD; // Leave poll version untouched!
                wrMutex.Lock();
                sendQ->Terminate(this);
                sendQ = 0;
                wrMutex.UnLock();
               }
       return 0;
      }
 
// If we got here then this is not a deferred close so we just need to check
// if there is a sendq appendage we need to get rid of.
//
   if (sendQ)
      {wrMutex.Lock();
       sendQ->Terminate();
       sendQ = 0;
       wrMutex.UnLock();
      }
 
// Multiple protocols may be bound to this link. If it is in use, defer the
// actual close until the use count drops to one. Similarly, if a thread is
// dispatched into the protocol (i.e. inside Process()), wait for it to
// return before we recycle the protocol stack out from under it. Once both
// counts drain we hold the opMutex until the protocol is removed, so no new
// dispatch can slip in.
//
   while(LinkInfo.InUse > 1 || LinkInfo.dspCnt > 0)
      {if (LinkInfo.InUse > 1)
          {opHelper.UnLock();
           TRACEI(DEBUG, "Close FD "<<LinkInfo.FD <<" deferred, use count="
                         <<LinkInfo.InUse);
           Serialize();
          }
          else
          {LinkInfo.dspPost++;
           opHelper.UnLock();
           TRACEI(DEBUG, "Close FD "<<LinkInfo.FD <<" deferred, dispatch count="
                         <<LinkInfo.dspCnt);
           LinkInfo.dspSem.Wait();
          }
       opHelper.Lock(&LinkInfo.opMutex);
      }
   LinkInfo.InUse--;
   Instance = 0;
 
// Add up the statistic for this link
//
   syncStats(&csec);
 
// Cleanup TLS if it is active
//
   if (isTLS) tlsIO.Shutdown();
 
// Clean this link up
//
   if (Protocol) {Protocol->Recycle(this, csec, LinkInfo.Etext); Protocol = 0;}
   if (ProtoAlt) {ProtoAlt->Recycle(this, csec, LinkInfo.Etext); ProtoAlt = 0;}
   if (LinkInfo.Etext) {free(LinkInfo.Etext); LinkInfo.Etext = 0;}
   LinkInfo.InUse    = 0;
 
// At this point we can have no lock conflicts, so if someone is waiting for
// us to terminate let them know about it. Note that we will get the condvar
// mutex while we hold the opMutex. This is the required order! We will also
// zero out the pointer to the condvar while holding the opmutex.
//
   if (LinkInfo.KillcvP)
      {LinkInfo.KillcvP->Lock();
       LinkInfo.KillcvP->Signal();
       LinkInfo.KillcvP->UnLock();
       LinkInfo.KillcvP = 0;
      }
 
// Remove ourselves from the poll table and then from the Link table. We may
// not hold on to the opMutex when we acquire the LTMutex. However, the link
// table needs to be cleaned up prior to actually closing the socket. So, we
// do some fancy footwork to prevent multiple closes of this link.
//
   fd = abs(LinkInfo.FD);
   if (PollInfo.FD > 0)
      {if (PollInfo.Poller) {XrdPoll::Detach(PollInfo); PollInfo.Poller = 0;}
       PollInfo.FD = -1;
       opHelper.UnLock();
       XrdLinkCtl::Unhook(fd);
      } else opHelper.UnLock();
 
// Invoke the TCP monitor if it was loaded.
//
   if (TcpMonPin && fd > 2)
      {XrdTcpMonPin::LinkInfo lnkInfo;
       lnkInfo.tident   = ID;
       lnkInfo.fd       = fd;
       lnkInfo.consec   = csec;
       lnkInfo.bytesIn  = BytesInTot;
       lnkInfo.bytesOut = BytesOutTot;
       TcpMonPin->Monitor(Addr, lnkInfo, sizeof(lnkInfo));
      }
 
// Close the file descriptor if it isn't being shared. Do it as the last
// thing because closes and accepts and not interlocked.
//
   if (fd >= 2) {if (KeepFD) rc = 0;
                    else rc = (close(fd) < 0 ? errno : 0);
                }
   if (rc) Log.Emsg("Link", rc, "close", ID);
   return rc;
}

References Addr, XrdTcpMonPin::LinkInfo::bytesIn, BytesInTot, XrdTcpMonPin::LinkInfo::bytesOut, BytesOutTot, close, XrdTcpMonPin::LinkInfo::consec, DEBUG, XrdPoll::Detach(), XrdLinkInfo::dspCnt, XrdLinkInfo::dspPost, XrdLinkInfo::dspSem, XrdSysError::Emsg(), XrdLinkInfo::Etext, XrdLinkInfo::FD, XrdPollInfo::FD, XrdTcpMonPin::LinkInfo::fd, XrdLink::ID, XrdLink::Instance, XrdLinkInfo::InUse, XrdLink::isTLS, KeepFD, XrdLinkInfo::KillcvP, LinkInfo, XrdSysCondVar::Lock(), XrdSysMutex::Lock(), XrdSysMutexHelper::Lock(), XrdGlobal::Log, XrdTcpMonPin::Monitor(), XrdLinkInfo::opMutex, XrdPollInfo::Poller, PollInfo, ProtoAlt, Protocol, XrdProtocol::Recycle(), sendQ, XrdLink::Serialize(), Shutdown(), XrdTlsSocket::Shutdown(), XrdSysCondVar::Signal(), syncStats(), XrdGlobal::TcpMonPin, XrdSendQ::Terminate(), XrdTcpMonPin::LinkInfo::tident, tlsIO, TRACEI, XrdLinkCtl::Unhook(), XrdSysCondVar::UnLock(), XrdSysMutex::UnLock(), XrdSysMutexHelper::UnLock(), XrdSysSemaphore::Wait(), and wrMutex.

Referenced by XrdLink::Close(), and DoIt().

Here is the call graph for this function:

Here is the caller graph for this function:

DoIt()

void XrdLinkXeq::DoIt ( )

virtual

Reimplemented from XrdLink.

Definition at line 306 of file XrdLinkXeq.cc.

{
   int rc;
 
// Count this thread as dispatched into the protocol so that a concurrent
// Close() waits for the protocol call to return before recycling the protocol
// stack (e.g. XrdHttp's SSL session) out from under Process(). We may only do
// so while the link still has a protocol; Close() removes the protocol while
// continuously holding the opMutex after draining dispatched threads, making
// this check-and-count atomic with respect to link teardown. Note that we
// cannot use setRef() for this because InUse counts threads other than the
// one running the protocol (e.g. Serialize() called within Process() would
// count us and deadlock).
//
   LinkInfo.opMutex.Lock();
   bool isOpen = (Protocol != 0);
   if (isOpen) LinkInfo.dspCnt++;
   LinkInfo.opMutex.UnLock();
 
// The Process() return code tells us what to do:
// < 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
//
   if (isOpen)
      do {rc = Protocol->Process(this);} while (!rc && Sched.canStick());
      else {Log.Emsg("Link", "Dispatch on closed link", ID);
            return;
           }
 
// Either re-enable the link and cycle back waiting for a new request, leave
// disabled, or terminate the connection.
//
   bool doCl = false;
   if (rc >= 0)
      {if (PollInfo.Poller && !PollInfo.Poller->Enable(PollInfo)) doCl = true;}
      else if (rc != -EINPROGRESS) doCl = true;
 
// Indicate that we are no longer dispatched into the protocol, waking up any
// thread waiting to close this link. This must be done before we ourselves
// try to close the link lest we deadlock waiting on ourselves.
//
   LinkInfo.opMutex.Lock();
   LinkInfo.dspCnt--;
   while(LinkInfo.dspCnt == 0 && LinkInfo.dspPost)
        {LinkInfo.dspSem.Post(); LinkInfo.dspPost--;}
   LinkInfo.opMutex.UnLock();
 
   if (doCl)
      {if (CloseRequestCb)
         {const bool res = CloseRequestCb(CloseRequestCbArg);
          if (!res) return;
         }
       Close();
      }
}

References XrdScheduler::canStick(), Close(), CloseRequestCb, CloseRequestCbArg, XrdLinkInfo::dspCnt, XrdLinkInfo::dspPost, XrdLinkInfo::dspSem, XrdSysError::Emsg(), XrdPoll::Enable(), XrdLink::ID, LinkInfo, XrdSysMutex::Lock(), XrdGlobal::Log, XrdLinkInfo::opMutex, XrdPollInfo::Poller, PollInfo, XrdSysSemaphore::Post(), XrdProtocol::Process(), Protocol, XrdGlobal::Sched, and XrdSysMutex::UnLock().

Here is the call graph for this function:

getIOStats()

int XrdLinkXeq::getIOStats ( long long &  inbytes, long long &  outbytes, int &  numstall, int &  numtardy  )

inline

Definition at line 68 of file XrdLinkXeq.hh.

                        { inbytes = BytesIn + BytesInTot;
                         outbytes = BytesOut+BytesOutTot;
                         numstall = stallCnt + stallCntTot;
                         numtardy = tardyCnt + tardyCntTot;
                         return LinkInfo.InUse;
                        }

References BytesIn, BytesInTot, BytesOut, BytesOutTot, XrdLinkInfo::InUse, LinkInfo, stallCnt, stallCntTot, tardyCnt, and tardyCntTot.

Referenced by XrdLink::getIOStats().

Here is the caller graph for this function:

getName()

static int XrdLinkXeq::getName ( int &  curr, char *  bname, int  blen, XrdLinkMatch *  who = 0  )

static

getPeerCerts()

XrdTlsPeerCerts * XrdLinkXeq::getPeerCerts

(

)

Definition at line 369 of file XrdLinkXeq.cc.

{
   return (isTLS ? tlsIO.getCerts(true) : 0);
}

References XrdTlsSocket::getCerts(), XrdLink::isTLS, and tlsIO.

Referenced by XrdLink::getPeerCerts().

Here is the call graph for this function:

Here is the caller graph for this function:

getProtocol()

XrdProtocol* XrdLinkXeq::getProtocol ( )

inline

Definition at line 82 of file XrdLinkXeq.hh.

{return Protocol;}

References Protocol.

Referenced by XrdLink::getProtocol(), and XrdLink::Terminate().

Here is the caller graph for this function:

Name()

const char* XrdLinkXeq::Name ( ) const

inline

Definition at line 85 of file XrdLinkXeq.hh.

{return (const char *)Lname;}

References Lname.

Referenced by XrdLink::Name().

Here is the caller graph for this function:

NetAddr()

const XrdNetAddr* XrdLinkXeq::NetAddr ( ) const

inline

Definition at line 88 of file XrdLinkXeq.hh.

{return &Addr;}

References Addr.

Referenced by XrdLink::NetAddr().

Here is the caller graph for this function:

Peek()

int XrdLinkXeq::Peek	(	char *	buff,
		int	blen,
		int	timeout = -1
	)

Definition at line 378 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   struct pollfd polltab = {PollInfo.FD, POLLIN|POLLRDNORM, 0};
   ssize_t mlen;
   int retc;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads) theMutex.Lock(&rdMutex);
 
// Wait until we can actually read something
//
   isIdle = 0;
   do {retc = poll(&polltab, 1, timeout);} while(retc < 0 && errno == EINTR);
   if (retc != 1)
      {if (retc == 0) return 0;
       return Log.Emsg("Link", -errno, "poll", ID);
      }
 
// Verify it is safe to read now
//
   if (!(polltab.revents & (POLLIN|POLLRDNORM)))
      {Log.Emsg("Link", XrdPoll::Poll2Text(polltab.revents), "polling", ID);
       return -1;
      }
 
// Do the peek.
//
   do {mlen = recv(LinkInfo.FD, Buff, Blen, MSG_PEEK);}
      while(mlen < 0 && errno == EINTR);
 
// Return the result
//
   if (mlen >= 0) return int(mlen);
   Log.Emsg("Link", errno, "peek on", ID);
   return -1;
}

References XrdSysError::Emsg(), XrdLinkInfo::FD, XrdPollInfo::FD, XrdLink::ID, isIdle, LinkInfo, XrdSysMutexHelper::Lock(), LockReads, XrdGlobal::Log, XrdPoll::Poll2Text(), PollInfo, and rdMutex.

Referenced by XrdLink::Peek().

Here is the call graph for this function:

Here is the caller graph for this function:

Recv() [1/3]

int XrdLinkXeq::Recv	(	char *	buff,
		int	blen
	)

Definition at line 421 of file XrdLinkXeq.cc.

{
   ssize_t rlen;
 
// Note that we will read only as much as is queued. Use Recv() with a
// timeout to receive as much data as possible.
//
   if (LockReads) rdMutex.Lock();
   isIdle = 0;
   do {rlen = read(LinkInfo.FD, Buff, Blen);} while(rlen < 0 && errno == EINTR);
   if (rlen > 0) AtomicAdd(BytesIn, rlen);
   if (LockReads) rdMutex.UnLock();
 
   if (rlen >= 0) return int(rlen);
   if (LinkInfo.FD >= 0) Log.Emsg("Link", errno, "receive from", ID);
   return -1;
}

References AtomicAdd, BytesIn, XrdSysError::Emsg(), XrdLinkInfo::FD, XrdLink::ID, isIdle, LinkInfo, XrdSysMutex::Lock(), LockReads, XrdGlobal::Log, rdMutex, read(), and XrdSysMutex::UnLock().

Referenced by XrdLink::Recv().

Here is the call graph for this function:

Here is the caller graph for this function:

Recv() [2/3]

int XrdLinkXeq::Recv	(	char *	buff,
		int	blen,
		int	timeout
	)

Definition at line 441 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   struct pollfd polltab = {PollInfo.FD, POLLIN|POLLRDNORM, 0};
   ssize_t rlen, totlen = 0;
   int retc;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads) theMutex.Lock(&rdMutex);
 
// Wait up to timeout milliseconds for data to arrive
//
   isIdle = 0;
   while(Blen > 0)
        {do {retc = poll(&polltab,1,timeout);} while(retc < 0 && errno == EINTR);
         if (retc != 1)
            {if (retc == 0)
                {tardyCnt++;
                 if (totlen)
                    {if ((++stallCnt & 0xff) == 1) TRACEI(DEBUG,"read timed out");
                     AtomicAdd(BytesIn, totlen);
                    }
                 return int(totlen);
                }
             return (LinkInfo.FD >= 0 ? Log.Emsg("Link",-errno,"poll",ID) : -1);
            }
 
         // Verify it is safe to read now
         //
         if (!(polltab.revents & (POLLIN|POLLRDNORM)))
            {Log.Emsg("Link", XrdPoll::Poll2Text(polltab.revents),
                              "polling", ID);
             return -1;
            }
 
         // Read as much data as you can. Note that we will force an error
         // if we get a zero-length read after poll said it was OK.
         //
         do {rlen = recv(LinkInfo.FD, Buff, Blen, 0);}
            while(rlen < 0 && errno == EINTR);
         if (rlen <= 0)
            {if (!rlen) return -ENOMSG;
             if (LinkInfo.FD > 0) Log.Emsg("Link", -errno, "receive from", ID);
             return -1;
            }
         totlen += rlen; Blen -= rlen; Buff += rlen;
        }
 
   AtomicAdd(BytesIn, totlen);
   return int(totlen);
}

References AtomicAdd, BytesIn, DEBUG, XrdSysError::Emsg(), XrdLinkInfo::FD, XrdPollInfo::FD, XrdLink::ID, isIdle, LinkInfo, XrdSysMutexHelper::Lock(), LockReads, XrdGlobal::Log, XrdPoll::Poll2Text(), PollInfo, rdMutex, stallCnt, tardyCnt, and TRACEI.

Here is the call graph for this function:

Recv() [3/3]

int XrdLinkXeq::Recv	(	const struct iovec *	iov,
		int	iocnt,
		int	timeout
	)

Definition at line 496 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   struct pollfd polltab = {PollInfo.FD, POLLIN|POLLRDNORM, 0};
   int retc, rlen;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads) theMutex.Lock(&rdMutex);
 
// Wait up to timeout milliseconds for data to arrive
//
   isIdle = 0;
   do {retc = poll(&polltab,1,timeout);} while(retc < 0 && errno == EINTR);
   if (retc != 1)
      {if (retc == 0)
          {tardyCnt++;
           return 0;
          }
       return (LinkInfo.FD >= 0 ? Log.Emsg("Link",-errno,"poll",ID) : -1);
      }
 
// Verify it is safe to read now
//
   if (!(polltab.revents & (POLLIN|POLLRDNORM)))
      {Log.Emsg("Link", XrdPoll::Poll2Text(polltab.revents), "polling", ID);
       return -1;
      }
 
// If the iocnt is within limits then just go ahead and read once.
//
   if (iocnt <= maxIOV)
      {rlen = RecvIOV(iov, iocnt);
       if (rlen > 0) {AtomicAdd(BytesIn, rlen);}
       return rlen;
      }
 
// We will have to break this up into allowable segments and we need to add up
// the bytes in each segment so that we know when to stop reading.
//
   int seglen, segcnt = maxIOV, totlen = 0;
   do {seglen = 0;
       for (int i = 0; i < segcnt; i++) seglen += iov[i].iov_len;
       if ((rlen = RecvIOV(iov, segcnt)) < 0) return rlen;
       totlen += rlen;
       if (rlen < seglen) break;
       iov   += segcnt;
       iocnt -= segcnt;
       if (iocnt <= maxIOV) segcnt = iocnt;
      } while(iocnt > 0);
 
// All done
//
   AtomicAdd(BytesIn, totlen);
   return totlen;
}

References AtomicAdd, BytesIn, XrdSysError::Emsg(), XrdLinkInfo::FD, XrdPollInfo::FD, XrdLink::ID, isIdle, LinkInfo, XrdSysMutexHelper::Lock(), LockReads, XrdGlobal::Log, XrdGlobal::maxIOV, XrdPoll::Poll2Text(), PollInfo, rdMutex, RecvIOV(), and tardyCnt.

Here is the call graph for this function:

RecvAll()

int XrdLinkXeq::RecvAll	(	char *	buff,
		int	blen,
		int	timeout = -1
	)

Definition at line 557 of file XrdLinkXeq.cc.

{
   struct pollfd polltab = {PollInfo.FD, POLLIN|POLLRDNORM, 0};
   ssize_t rlen;
   int     retc;
 
// Check if timeout specified. Notice that the timeout is the max we will
// for some data. We will wait forever for all the data. Yeah, it's weird.
//
   if (timeout >= 0)
      {do {retc = poll(&polltab,1,timeout);} while(retc < 0 && errno == EINTR);
       if (retc != 1)
          {if (!retc) return -ETIMEDOUT;
           Log.Emsg("Link",errno,"poll",ID);
           return -1;
          }
       if (!(polltab.revents & (POLLIN|POLLRDNORM)))
          {Log.Emsg("Link",XrdPoll::Poll2Text(polltab.revents),"polling",ID);
           return -1;
          }
      }
 
// Note that we will block until we receive all he bytes.
//
   if (LockReads) rdMutex.Lock();
   isIdle = 0;
   do {rlen = recv(LinkInfo.FD, Buff, Blen, MSG_WAITALL);}
      while(rlen < 0 && errno == EINTR);
   if (rlen > 0) AtomicAdd(BytesIn, rlen);
   if (LockReads) rdMutex.UnLock();
 
   if (int(rlen) == Blen) return Blen;
        if (!rlen) {TRACEI(DEBUG, "No RecvAll() data; errno=" <<errno);}
   else if (rlen > 0) Log.Emsg("RecvAll", "Premature end from", ID);
   else if (LinkInfo.FD >= 0) Log.Emsg("Link", errno, "receive from", ID);
   return -1;
}

References AtomicAdd, BytesIn, DEBUG, XrdSysError::Emsg(), XrdLinkInfo::FD, XrdPollInfo::FD, XrdLink::ID, isIdle, LinkInfo, XrdSysMutex::Lock(), LockReads, XrdGlobal::Log, XrdPoll::Poll2Text(), PollInfo, rdMutex, TRACEI, and XrdSysMutex::UnLock().

Referenced by XrdLink::RecvAll().

Here is the call graph for this function:

Here is the caller graph for this function:

RecvIOV()

int XrdLinkXeq::RecvIOV ( const struct iovec *  iov, int  iocnt  )

protected

Definition at line 599 of file XrdLinkXeq.cc.

{
   ssize_t retc = 0;
 
// Read the data in. On some version of Unix (e.g., Linux) a readv() may
// end at any time without reading all the bytes when directed to a socket.
// We always return the number bytes read (or an error). The caller needs to
// restart the read at the appropriate place in the iovec when more data arrives.
//
   do {retc = readv(LinkInfo.FD, iov, iocnt);}
      while(retc < 0 && errno == EINTR);
 
// Check how we completed
//
   if (retc < 0) Log.Emsg("Link", errno, "receive from", ID);
   return retc;
}

References XrdSysError::Emsg(), XrdLinkInfo::FD, XrdLink::ID, LinkInfo, XrdGlobal::Log, and readv().

Referenced by Recv().

Here is the call graph for this function:

Here is the caller graph for this function:

Register()

bool XrdLinkXeq::Register

(

const char *

hName

)

Definition at line 621 of file XrdLinkXeq.cc.

{
 
// Make appropriate changes here
//
   if (HostName) free(HostName);
   HostName = strdup(hName);
   strlcpy(Lname, hName, sizeof(Lname));
   return true;
}

References XrdLink::HostName, Lname, and strlcpy().

Referenced by XrdLink::Register().

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterCloseRequestCb()

bool XrdLinkXeq::RegisterCloseRequestCb	(	XrdProtocol *	pp,
		bool(*)(void *)	cb,
		void *	cbarg
	)

Definition at line 1503 of file XrdLinkXeq.cc.

{
   if (pp != Protocol) return false;
 
   CloseRequestCb = cb;
   CloseRequestCbArg = cbarg;
   return true;
}

References CloseRequestCb, CloseRequestCbArg, and Protocol.

Referenced by XrdLinkCtl::RegisterCloseRequestCb().

Here is the caller graph for this function:

Reset()

void XrdLinkXeq::Reset ( )

protected

Definition at line 113 of file XrdLinkXeq.cc.

{
   memcpy(Uname+sizeof(Uname)-7, "anon.0@", 7);
   strcpy(Lname, "somewhere");
   ID       = &Uname[sizeof(Uname)-5];
   Comment  = ID;
   sendQ    = 0;
   stallCnt = stallCntTot = 0;
   tardyCnt = tardyCntTot = 0;
   SfIntr   = 0;
   isIdle   = 0;
   BytesOut = BytesIn = BytesOutTot = BytesInTot = 0;
   LockReads= false;
   KeepFD   = false;
   Protocol = 0;
   ProtoAlt = 0;
   CloseRequestCb = 0;
 
   LinkInfo.Reset();
   PollInfo.Zorch();
   ResetLink();
}

References BytesIn, BytesInTot, BytesOut, BytesOutTot, CloseRequestCb, XrdJob::Comment, XrdLink::ID, isIdle, KeepFD, LinkInfo, Lname, LockReads, PollInfo, ProtoAlt, Protocol, XrdLinkInfo::Reset(), XrdLink::ResetLink(), sendQ, SfIntr, stallCnt, stallCntTot, tardyCnt, tardyCntTot, Uname, and XrdPollInfo::Zorch().

Referenced by XrdLinkXeq(), and XrdLinkCtl::Alloc().

Here is the call graph for this function:

Here is the caller graph for this function:

Send() [1/3]

int XrdLinkXeq::Send	(	const char *	buff,
		int	blen
	)

Definition at line 636 of file XrdLinkXeq.cc.

{
   ssize_t retc = 0, bytesleft = Blen;
 
// Get a lock
//
   wrMutex.Lock();
   isIdle = 0;
   AtomicAdd(BytesOut, Blen);
 
// Do non-blocking writes if we are setup to do so.
//
   if (sendQ)
      {retc = sendQ->Send(Buff, Blen);
       wrMutex.UnLock();
       return retc;
      }
 
// Write the data out
//
   while(bytesleft)
        {if ((retc = write(LinkInfo.FD, Buff, bytesleft)) < 0)
            {if (errno == EINTR) continue;
                else break;
            }
         bytesleft -= retc; Buff += retc;
        }
 
// All done
//
   wrMutex.UnLock();
   if (retc >= 0) return Blen;
   Log.Emsg("Link", errno, "send to", ID);
   return -1;
}

References AtomicAdd, BytesOut, XrdSysError::Emsg(), XrdLinkInfo::FD, XrdLink::ID, isIdle, LinkInfo, XrdSysMutex::Lock(), XrdGlobal::Log, XrdSendQ::Send(), sendQ, XrdSysMutex::UnLock(), write(), and wrMutex.

Referenced by XrdLink::Send().

Here is the call graph for this function:

Here is the caller graph for this function:

Send() [2/3]

int XrdLinkXeq::Send	(	const sfVec *	sdP,
		int	sdn
	)

Definition at line 723 of file XrdLinkXeq.cc.

{
#if !defined(HAVE_SENDFILE)
 
   return -1;
 
#elif defined(__solaris__)
 
    sendfilevec_t vecSF[XrdOucSFVec::sfMax], *vecSFP = vecSF;
    size_t xframt, totamt, bytes = 0;
    ssize_t retc;
    int i = 0;
 
// Construct the sendfilev() vector
//
   for (i = 0; i < sfN; sfP++, i++)
       {if (sfP->fdnum < 0)
           {vecSF[i].sfv_fd  = SFV_FD_SELF;
            vecSF[i].sfv_off = (off_t)sfP->buffer;
           } else {
            vecSF[i].sfv_fd  = sfP->fdnum;
            vecSF[i].sfv_off = sfP->offset;
           }
        vecSF[i].sfv_flag = 0;
        vecSF[i].sfv_len  = sfP->sendsz;
        bytes += sfP->sendsz;
       }
   totamt = bytes;
 
// Lock the link, issue sendfilev(), and unlock the link. The documentation
// is very spotty and inconsistent. We can only retry this operation under
// very limited conditions.
//
   wrMutex.Lock();
   isIdle = 0;
do{retc = sendfilev(LinkInfo.FD, vecSFP, sfN, &xframt);
 
// Check if all went well and return if so (usual case)
//
   if (xframt == bytes)
      {AtomicAdd(BytesOut, bytes);
       wrMutex.UnLock();
       return totamt;
      }
 
// The only one we will recover from is EINTR. We cannot legally get EAGAIN.
//
   if (retc < 0 && errno != EINTR) break;
 
// Try to resume the transfer
//
   if (xframt > 0)
      {AtomicAdd(BytesOut, xframt); bytes -= xframt; SfIntr++;
       while(xframt > 0 && sfN)
            {if ((ssize_t)xframt < (ssize_t)vecSFP->sfv_len)
                {vecSFP->sfv_off += xframt; vecSFP->sfv_len -= xframt; break;}
             xframt -= vecSFP->sfv_len; vecSFP++; sfN--;
            }
      }
  } while(sfN > 0);
 
// See if we can recover without destroying the connection
//
   retc = (retc < 0 ? errno : ECANCELED);
   wrMutex.UnLock();
   Log.Emsg("Link", retc, "send file to", ID);
   return -1;
 
#elif defined(__linux__) || defined(__GNU__)
 
   static const int setON = 1, setOFF = 0;
   ssize_t retc = 0, bytesleft;
   off_t myOffset;
   int i, xfrbytes = 0, uncork = 1, xIntr = 0;
 
// lock the link
//
   wrMutex.Lock();
   isIdle = 0;
 
// In linux we need to cork the socket. On permanent errors we do not uncork
// the socket because it will be closed in short order.
//
   if (setsockopt(PollInfo.FD, SOL_TCP, TCP_CORK, &setON, sizeof(setON)) < 0)
      {Log.Emsg("Link", errno, "cork socket for", ID);
       uncork = 0; sfOK = 0;
      }
 
// Send the header first
//
   for (i = 0; i < sfN; sfP++, i++)
       {if (sfP->fdnum < 0) retc = sendData(sfP->buffer, sfP->sendsz);
           else {myOffset = sfP->offset; bytesleft = sfP->sendsz;
                 while(bytesleft
                 && (retc=sendfile(LinkInfo.FD,sfP->fdnum,&myOffset,bytesleft)) > 0)
                      {bytesleft -= retc; xIntr++;}
                }
        if (retc <  0 && errno == EINTR) continue;
        if (retc <= 0) break;
        xfrbytes += sfP->sendsz;
       }
 
// Diagnose any sendfile errors
//
   if (retc <= 0)
      {if (retc == 0) errno = ECANCELED;
       wrMutex.UnLock();
       Log.Emsg("Link", errno, "send file to", ID);
       return -1;
      }
 
// Now uncork the socket
//
   if (uncork
   &&  setsockopt(PollInfo.FD, SOL_TCP, TCP_CORK, &setOFF, sizeof(setOFF)) < 0)
      Log.Emsg("Link", errno, "uncork socket for", ID);
 
// All done
//
   if (xIntr > sfN) SfIntr += (xIntr - sfN);
   AtomicAdd(BytesOut, xfrbytes);
   wrMutex.UnLock();
   return xfrbytes;
 
#else
 
   return -1;
 
#endif
}

References AtomicAdd, BytesOut, XrdSysError::Emsg(), XrdLinkInfo::FD, XrdPollInfo::FD, XrdOucSFVec::fdnum, XrdLink::ID, isIdle, LinkInfo, XrdSysMutex::Lock(), XrdGlobal::Log, PollInfo, sendData(), XrdOucSFVec::sendsz, SfIntr, XrdOucSFVec::sfMax, XrdLink::sfOK, XrdSysMutex::UnLock(), and wrMutex.

Here is the call graph for this function:

Send() [3/3]

int XrdLinkXeq::Send	(	const struct iovec *	iov,
		int	iocnt,
		int	bytes = 0
	)

Definition at line 674 of file XrdLinkXeq.cc.

{
   int retc;
 
// Get a lock and assume we will be successful (statistically we are)
//
   wrMutex.Lock();
   isIdle = 0;
   AtomicAdd(BytesOut, bytes);
 
// Do non-blocking writes if we are setup to do so.
//
   if (sendQ)
      {retc = sendQ->Send(iov, iocnt, bytes);
       wrMutex.UnLock();
       return retc;
      }
 
// If the iocnt is within limits then just go ahead and write this out
//
   if (iocnt <= maxIOV)
      {retc = SendIOV(iov, iocnt, bytes);
       wrMutex.UnLock();
       return retc;
      }
 
// We will have to break this up into allowable segments
//
   int seglen, segcnt = maxIOV, iolen = 0;
   do {seglen = 0;
       for (int i = 0; i < segcnt; i++) seglen += iov[i].iov_len;
       if ((retc = SendIOV(iov, segcnt, seglen)) < 0)
          {wrMutex.UnLock();
           return retc;
          }
       iolen += retc;
       iov   += segcnt;
       iocnt -= segcnt;
       if (iocnt <= maxIOV) segcnt = iocnt;
      } while(iocnt > 0);
 
// All done
//
   wrMutex.UnLock();
   return iolen;
}

References AtomicAdd, BytesOut, isIdle, XrdSysMutex::Lock(), XrdGlobal::maxIOV, XrdSendQ::Send(), SendIOV(), sendQ, XrdSysMutex::UnLock(), and wrMutex.

Here is the call graph for this function:

sendData()

int XrdLinkXeq::sendData ( const char *  Buff, int  Blen  )

protected

Definition at line 858 of file XrdLinkXeq.cc.

{
   ssize_t retc = 0, bytesleft = Blen;
 
// Write the data out
//
   while(bytesleft)
        {if ((retc = write(LinkInfo.FD, Buff, bytesleft)) < 0)
            {if (errno == EINTR) continue;
                else break;
            }
         bytesleft -= retc; Buff += retc;
        }
 
// All done
//
   return retc;
}

References XrdLinkInfo::FD, LinkInfo, and write().

Referenced by Send().

Here is the call graph for this function:

Here is the caller graph for this function:

SendIOV()

int XrdLinkXeq::SendIOV ( const struct iovec *  iov, int  iocnt, int  bytes  )

protected

Definition at line 881 of file XrdLinkXeq.cc.

{
   ssize_t bytesleft, n, retc = 0;
   const char *Buff;
 
// Write the data out. On some version of Unix (e.g., Linux) a writev() may
// end at any time without writing all the bytes when directed to a socket.
// So, we attempt to resume the writev() using a combination of write() and
// a writev() continuation. This approach slowly converts a writev() to a
// series of writes if need be. We must do this inline because we must hold
// the lock until all the bytes are written or an error occurs.
//
   bytesleft = static_cast<ssize_t>(bytes);
   while(bytesleft)
        {do {retc = writev(LinkInfo.FD, iov, iocnt);}
            while(retc < 0 && errno == EINTR);
         if (retc >= bytesleft || retc < 0) break;
         bytesleft -= retc;
         while(retc >= (n = static_cast<ssize_t>(iov->iov_len)))
              {retc -= n; iov++; iocnt--;}
         Buff = (const char *)iov->iov_base + retc; n -= retc; iov++; iocnt--;
         while(n) {if ((retc = write(LinkInfo.FD, Buff, n)) < 0)
                      {if (errno == EINTR) continue;
                          else break;
                      }
                   n -= retc; Buff += retc; bytesleft -= retc;
                  }
         if (retc < 0 || iocnt < 1) break;
        }
 
// All done
//
   if (retc >= 0) return bytes;
   Log.Emsg("Link", errno, "send to", ID);
   return -1;
}

References XrdSysError::Emsg(), XrdLinkInfo::FD, XrdLink::ID, LinkInfo, XrdGlobal::Log, write(), and writev().

Referenced by Send().

Here is the call graph for this function:

Here is the caller graph for this function:

setID()

void XrdLinkXeq::setID	(	const char *	userid,
		int	procid
	)

Definition at line 922 of file XrdLinkXeq.cc.

{
   char buff[sizeof(Uname)], *bp, *sp;
   int ulen;
 
   snprintf(buff, sizeof(buff), "%s.%d:%d", userid, procid, PollInfo.FD);
   ulen = strlen(buff);
   sp = buff + ulen - 1;
   bp = &Uname[sizeof(Uname)-1];
   if (ulen > (int)sizeof(Uname)) ulen = sizeof(Uname);
   *bp = '@'; bp--;
   while(ulen--) {*bp = *sp; bp--; sp--;}
   ID = bp+1;
   Comment = (const char *)ID;
 
// Update the ID in the TLS socket if enabled
//
   if (isTLS) tlsIO.SetTraceID(ID);
}

References XrdJob::Comment, XrdPollInfo::FD, XrdLink::ID, XrdLink::isTLS, PollInfo, XrdTlsSocket::SetTraceID(), tlsIO, and Uname.

Referenced by XrdLink::setID().

Here is the call graph for this function:

Here is the caller graph for this function:

setLocation()

void XrdLinkXeq::setLocation ( XrdNetAddrInfo::LocInfo &  loc )

inline

Definition at line 107 of file XrdLinkXeq.hh.

{Addr.SetLocation(loc);}

References Addr, and XrdNetAddr::SetLocation().

Referenced by XrdLink::setLocation().

Here is the call graph for this function:

Here is the caller graph for this function:

setNB()

bool XrdLinkXeq::setNB

(

)

Definition at line 946 of file XrdLinkXeq.cc.

{
// We don't support non-blocking output except for Linux at the moment
//
#if !defined(__linux__)
   return false;
#else
// Trace this request
//
   TRACEI(DEBUG,"enabling non-blocking output");
 
// If we don't already have a sendQ object get one. This is a one-time call
// so to optimize checking if this object exists we also get the opMutex.'
//
   LinkInfo.opMutex.Lock();
   if (!sendQ)
      {wrMutex.Lock();
       sendQ = new XrdSendQ(*this, wrMutex);
       wrMutex.UnLock();
      }
   LinkInfo.opMutex.UnLock();
   return true;
#endif
}

References DEBUG, LinkInfo, XrdSysMutex::Lock(), XrdLinkInfo::opMutex, sendQ, TRACEI, XrdSysMutex::UnLock(), and wrMutex.

Referenced by XrdLink::setNB().

Here is the call graph for this function:

Here is the caller graph for this function:

setProtName()

void XrdLinkXeq::setProtName

(

const char *

name

)

Definition at line 992 of file XrdLinkXeq.cc.

{
 
// Set the protocol name.
//
   LinkInfo.opMutex.Lock();
   Addr.SetDialect(name);
   LinkInfo.opMutex.UnLock();
}

References Addr, LinkInfo, XrdSysMutex::Lock(), XrdLinkInfo::opMutex, XrdNetAddr::SetDialect(), and XrdSysMutex::UnLock().

Referenced by XrdLink::setProtName().

Here is the call graph for this function:

Here is the caller graph for this function:

setProtocol()

XrdProtocol * XrdLinkXeq::setProtocol	(	XrdProtocol *	pp,
		bool	push
	)

Definition at line 975 of file XrdLinkXeq.cc.

{
 
// Set new protocol.
//
   LinkInfo.opMutex.Lock();
   XrdProtocol *op = Protocol;
   if (push) ProtoAlt = Protocol;
   Protocol = pp; 
   LinkInfo.opMutex.UnLock();
   return op;
}

References LinkInfo, XrdSysMutex::Lock(), XrdLinkInfo::opMutex, ProtoAlt, Protocol, and XrdSysMutex::UnLock().

Referenced by XrdLink::setProtocol().

Here is the call graph for this function:

Here is the caller graph for this function:

setTLS()

bool XrdLinkXeq::setTLS	(	bool	enable,
		XrdTlsContext *	ctx = 0
	)

Definition at line 1006 of file XrdLinkXeq.cc.

{ //???
// static const XrdTlsConnection::RW_Mode rwMode=XrdTlsConnection::TLS_RNB_WBL;
   static const XrdTlsSocket::RW_Mode rwMode=XrdTlsSocket::TLS_RBL_WBL;
   static const XrdTlsSocket::HS_Mode hsMode=XrdTlsSocket::TLS_HS_BLOCK;
   const char *eNote;
   XrdTls::RC rc;
 
// If we are already in a compatible mode, we are done
//
 
   if (isTLS == enable) return true;
 
// If this is a shutdown, then do it now.
//
   if (!enable)
      {tlsIO.Shutdown();
       isTLS = enable;
       Addr.SetTLS(enable);
       return true;
      }
// We want to initialize TLS, do so now.
//
   if (!ctx) ctx = tlsCtx;
   eNote = tlsIO.Init(*ctx, PollInfo.FD, rwMode, hsMode, false, false, ID);
 
// Check for errors
//
   if (eNote)
      {char buff[1024];
       snprintf(buff, sizeof(buff), "Unable to enable tls for %s;", ID);
       Log.Emsg("LinkXeq", buff, eNote);
       return false;
      }
 
// Now we need to accept this TLS connection
//
   std::string eMsg;
   rc = tlsIO.Accept(&eMsg);
 
// Diagnose return state
//
   if (rc != XrdTls::TLS_AOK) Log.Emsg("LinkXeq", eMsg.c_str());
      else {isTLS = enable;
            Addr.SetTLS(enable);
            Log.Emsg("LinkXeq", ID, "connection upgraded to", verTLS());
           }
   return rc == XrdTls::TLS_AOK;
}

References XrdTlsSocket::Accept(), Addr, XrdSysError::Emsg(), eMsg, XrdPollInfo::FD, XrdLink::ID, XrdTlsSocket::Init(), XrdLink::isTLS, XrdGlobal::Log, PollInfo, XrdNetAddr::SetTLS(), XrdTlsSocket::Shutdown(), XrdTls::TLS_AOK, XrdTlsSocket::TLS_HS_BLOCK, XrdTlsSocket::TLS_RBL_WBL, XrdGlobal::tlsCtx, tlsIO, and verTLS().

Referenced by XrdLink::setTLS().

Here is the call graph for this function:

Here is the caller graph for this function:

SFError()

int XrdLinkXeq::SFError ( int  rc )

protected

Definition at line 1060 of file XrdLinkXeq.cc.

{
   Log.Emsg("TLS", rc, "send file to", ID);
   return -1;
}

References XrdSysError::Emsg(), XrdLink::ID, and XrdGlobal::Log.

Referenced by TLS_Send().

Here is the call graph for this function:

Here is the caller graph for this function:

Shutdown()

void XrdLinkXeq::Shutdown

(

bool

getLock

)

Definition at line 1070 of file XrdLinkXeq.cc.

{
   int temp;
 
// Trace the entry
//
   TRACEI(DEBUG, (getLock ? "Async" : "Sync") <<" link shutdown in progress");
 
// Get the lock if we need too (external entry via another thread)
//
   if (getLock) LinkInfo.opMutex.Lock();
 
// If there is something to do, do it now
//
   temp = Instance; Instance = 0;
   if (!KeepFD)
      {shutdown(PollInfo.FD, SHUT_RDWR);
       if (dup2(devNull, PollInfo.FD) < 0)
          {Instance = temp;
           Log.Emsg("Link", errno, "shutdown FD for", ID);
          }
      }
 
// All done
//
   if (getLock) LinkInfo.opMutex.UnLock();
}

References DEBUG, XrdGlobal::devNull, XrdSysError::Emsg(), XrdPollInfo::FD, XrdLink::ID, XrdLink::Instance, KeepFD, LinkInfo, XrdSysMutex::Lock(), XrdGlobal::Log, XrdLinkInfo::opMutex, PollInfo, TRACEI, and XrdSysMutex::UnLock().

Referenced by Close(), and XrdLink::Shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

Stats()

int XrdLinkXeq::Stats ( char *  buff, int  blen, bool  do_sync = false  )

static

Definition at line 1102 of file XrdLinkXeq.cc.

{
   static const char statfmt[] = "<stats id=\"link\"><num>%d</num>"
          "<maxn>%d</maxn><tot>%lld</tot><in>%lld</in><out>%lld</out>"
          "<ctime>%lld</ctime><tmo>%d</tmo><stall>%d</stall>"
          "<sfps>%d</sfps></stats>";
   int i;
 
// Check if actual length wanted
//
   if (!buff) return sizeof(statfmt)+17*6;
 
// We must synchronize the statistical counters
//
   if (do_sync) XrdLinkCtl::SyncAll();
 
// Obtain lock on the stats area and format it
//
   AtomicBeg(statsMutex);
   i = snprintf(buff, blen, statfmt, AtomicGet(LinkCount),
                                     AtomicGet(LinkCountMax),
                                     AtomicGet(LinkCountTot),
                                     AtomicGet(LinkBytesIn),
                                     AtomicGet(LinkBytesOut),
                                     AtomicGet(LinkConTime),
                                     AtomicGet(LinkTimeOuts),
                                     AtomicGet(LinkStalls),
                                     AtomicGet(LinkSfIntr));
   AtomicEnd(statsMutex);
   return i;
}

References AtomicBeg, AtomicEnd, AtomicGet, LinkBytesIn, LinkBytesOut, LinkConTime, LinkCount, LinkCountMax, LinkCountTot, LinkSfIntr, LinkStalls, LinkTimeOuts, statsMutex, and XrdLinkCtl::SyncAll().

Referenced by XrdLink::Stats().

Here is the call graph for this function:

Here is the caller graph for this function:

syncStats()

void XrdLinkXeq::syncStats

(

int *

ctime = 0

)

Definition at line 1138 of file XrdLinkXeq.cc.

{
   long long tmpLL;
   int       tmpI4;
 
// If this is dynamic, get the opMutex lock
//
   if (!ctime) LinkInfo.opMutex.Lock();
 
// Either the caller has the opMutex or this is called out of close. In either
// case, we need to get the read and write mutexes; each followed by the stats
// mutex. This order is important because we should not hold the stats mutex
// for very long and the r/w mutexes may take a long time to acquire. If we
// must maintain the link count we need to actually acquire the stats mutex as
// we will be doing compound operations. Atomics are still used to keep other
// threads from seeing partial results.
//
   AtomicBeg(rdMutex);
 
   if (ctime)
      {*ctime = time(0) - LinkInfo.conTime;
       AtomicAdd(LinkConTime, *ctime);
       statsMutex.Lock();
       if (LinkCount > 0) AtomicDec(LinkCount);
       statsMutex.UnLock();
      }
 
   AtomicBeg(statsMutex);
 
   tmpLL = AtomicFAZ(BytesIn);
   AtomicAdd(LinkBytesIn, tmpLL);  AtomicAdd(BytesInTot, tmpLL);
   tmpI4 = AtomicFAZ(tardyCnt);
   AtomicAdd(LinkTimeOuts, tmpI4); AtomicAdd(tardyCntTot, tmpI4);
   tmpI4 = AtomicFAZ(stallCnt);
   AtomicAdd(LinkStalls, tmpI4);   AtomicAdd(stallCntTot, tmpI4);
   AtomicEnd(statsMutex); AtomicEnd(rdMutex);
 
   AtomicBeg(wrMutex);    AtomicBeg(statsMutex);
   tmpLL = AtomicFAZ(BytesOut);
   AtomicAdd(LinkBytesOut, tmpLL); AtomicAdd(BytesOutTot, tmpLL);
   tmpI4 = AtomicFAZ(SfIntr);
   AtomicAdd(LinkSfIntr, tmpI4);
   AtomicEnd(statsMutex); AtomicEnd(wrMutex);
 
// Make sure the protocol updates it's statistics as well
//
   if (Protocol) Protocol->Stats(0, 0, 1);
 
// All done
//
   if (!ctime) LinkInfo.opMutex.UnLock();
}

References AtomicAdd, AtomicBeg, AtomicDec, AtomicEnd, AtomicFAZ, BytesIn, BytesInTot, BytesOut, BytesOutTot, XrdLinkInfo::conTime, LinkBytesIn, LinkBytesOut, LinkConTime, LinkCount, LinkInfo, LinkSfIntr, LinkStalls, LinkTimeOuts, XrdSysMutex::Lock(), XrdLinkInfo::opMutex, Protocol, rdMutex, SfIntr, stallCnt, stallCntTot, XrdProtocol::Stats(), statsMutex, tardyCnt, tardyCntTot, XrdSysMutex::UnLock(), and wrMutex.

Referenced by Close(), and XrdLink::syncStats().

Here is the call graph for this function:

Here is the caller graph for this function:

TLS_Error()

int XrdLinkXeq::TLS_Error ( const char *  act, XrdTls::RC  rc  )

protected

Definition at line 1195 of file XrdLinkXeq.cc.

{
   std::string reason = XrdTls::RC2Text(rc);
   char msg[512];
 
   snprintf(msg, sizeof(msg), "Unable to %s %s;", act, ID);
   Log.Emsg("TLS", msg, reason.c_str());
   return -1;
}

References XrdSysError::Emsg(), XrdLink::ID, XrdGlobal::Log, and XrdTls::RC2Text().

Referenced by TLS_Peek(), TLS_Recv(), TLS_Send(), and TLS_Write().

Here is the call graph for this function:

Here is the caller graph for this function:

TLS_Peek()

int XrdLinkXeq::TLS_Peek	(	char *	Buff,
		int	Blen,
		int	timeout
	)

Definition at line 1209 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   XrdTls::RC retc;
   int rc, rlen;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads) theMutex.Lock(&rdMutex);
 
// Wait until we can actually read something
//
   isIdle = 0;
   if (timeout)
      {rc = Wait4Data(timeout);
       if (rc < 1) return rc;
      }
 
// Do the peek and if sucessful, the number of bytes available.
//
   retc = tlsIO.Peek(Buff, Blen, rlen);
   if (retc == XrdTls::TLS_AOK) return rlen;
 
// Dianose the TLS error and return failure
//
   return TLS_Error("peek on", retc);
}

References isIdle, XrdSysMutexHelper::Lock(), LockReads, XrdTlsSocket::Peek(), rdMutex, XrdTls::TLS_AOK, TLS_Error(), tlsIO, and XrdLink::Wait4Data().

Referenced by XrdLink::Peek().

Here is the call graph for this function:

Here is the caller graph for this function:

TLS_Recv() [1/3]

int XrdLinkXeq::TLS_Recv	(	char *	Buff,
		int	Blen
	)

Definition at line 1241 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   XrdTls::RC retc;
   int rlen;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads) theMutex.Lock(&rdMutex);
 
// Note that we will read only as much as is queued. Use Recv() with a
// timeout to receive as much data as possible.
//
   isIdle = 0;
   retc = tlsIO.Read(Buff, Blen, rlen);
   if (retc != XrdTls::TLS_AOK) return TLS_Error("receive from", retc);
   if (rlen > 0) AtomicAdd(BytesIn, rlen);
   return rlen;
}

References AtomicAdd, BytesIn, isIdle, XrdSysMutexHelper::Lock(), LockReads, rdMutex, XrdTlsSocket::Read(), XrdTls::TLS_AOK, TLS_Error(), and tlsIO.

Referenced by XrdLink::Recv(), TLS_Recv(), and TLS_RecvAll().

Here is the call graph for this function:

Here is the caller graph for this function:

TLS_Recv() [2/3]

int XrdLinkXeq::TLS_Recv	(	char *	Buff,
		int	Blen,
		int	timeout,
		bool	havelock = false
	)

Definition at line 1263 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   XrdTls::RC retc;
   int pend, rlen, totlen = 0;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads && !havelock) theMutex.Lock(&rdMutex);
 
// Wait up to timeout milliseconds for data to arrive
//
   isIdle = 0;
   while(Blen > 0)
        {pend = tlsIO.Pending(true);
         if (!pend) pend = Wait4Data(timeout);
         if (pend < 1)
            {if (pend < 0) return -1;
             tardyCnt++;
             if (totlen)
                {if ((++stallCnt & 0xff) == 1) TRACEI(DEBUG,"read timed out");
                 AtomicAdd(BytesIn, totlen);
                }
             return totlen;
            }
 
         // Read as much data as you can. Note that we will force an error
         // if we get a zero-length read after poll said it was OK. However,
         // if we never read anything, then we simply return -ENOMSG to avoid
         // generating a "read link error" as clearly there was a hangup.
         //
         retc = tlsIO.Read(Buff, Blen, rlen);
         if (retc != XrdTls::TLS_AOK)
            {if (!totlen) return -ENOMSG;
             AtomicAdd(BytesIn, totlen);
             return TLS_Error("receive from", retc);
            }
         if (rlen <= 0) break;
         totlen += rlen; Blen -= rlen; Buff += rlen;
        }
 
   AtomicAdd(BytesIn, totlen);
   return totlen;
}

References AtomicAdd, BytesIn, DEBUG, isIdle, XrdSysMutexHelper::Lock(), LockReads, XrdTlsSocket::Pending(), rdMutex, XrdTlsSocket::Read(), stallCnt, tardyCnt, XrdTls::TLS_AOK, TLS_Error(), tlsIO, TRACEI, and XrdLink::Wait4Data().

Here is the call graph for this function:

TLS_Recv() [3/3]

int XrdLinkXeq::TLS_Recv	(	const struct iovec *	iov,
		int	iocnt,
		int	timeout
	)

Definition at line 1310 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper theMutex;
   char *Buff;
   int Blen, rlen, totlen = 0;
 
// Lock the read mutex if we need to, the helper will unlock it upon exit
//
   if (LockReads) theMutex.Lock(&rdMutex);
 
// Individually process each element until we can't read any more
//
   isIdle = 0;
   for (int i = 0; i < iocnt; i++)
       {Buff = (char *)iov[i].iov_base;
        Blen =         iov[i].iov_len;
        rlen = TLS_Recv(Buff, Blen, timeout, true);
        if (rlen <= 0) break;
        totlen += rlen;
        if (rlen < Blen) break;
       }
 
   if (totlen) {AtomicAdd(BytesIn, totlen);}
   return totlen;
}

References AtomicAdd, BytesIn, isIdle, XrdSysMutexHelper::Lock(), LockReads, rdMutex, and TLS_Recv().

Here is the call graph for this function:

TLS_RecvAll()

int XrdLinkXeq::TLS_RecvAll	(	char *	Buff,
		int	Blen,
		int	timeout
	)

Definition at line 1340 of file XrdLinkXeq.cc.

{
   int     retc;
 
// Check if timeout specified. Notice that the timeout is the max we will
// wait for some data. We will wait forever for all the data. Yeah, it's weird.
//
   if (timeout >= 0)
      {retc = tlsIO.Pending(true);
       if (!retc) retc = Wait4Data(timeout);
       if (retc < 1) return (retc ? -1 : -ETIMEDOUT);
      }
 
// Note that we will block until we receive all the bytes.
//
   return TLS_Recv(Buff, Blen, -1);
}

References XrdTlsSocket::Pending(), TLS_Recv(), tlsIO, and XrdLink::Wait4Data().

Referenced by XrdLink::RecvAll().

Here is the call graph for this function:

Here is the caller graph for this function:

TLS_Send() [1/3]

int XrdLinkXeq::TLS_Send	(	const char *	Buff,
		int	Blen
	)

Definition at line 1362 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper lck(wrMutex);
   ssize_t bytesleft = Blen;
   XrdTls::RC retc;
   int byteswritten;
 
// Prepare to send
//
   isIdle = 0;
   AtomicAdd(BytesOut, Blen);
 
// Do non-blocking writes if we are setup to do so.
//
   if (sendQ) return sendQ->Send(Buff, Blen);
 
// Write the data out
//
   while(bytesleft)
        {retc = tlsIO.Write(Buff, bytesleft, byteswritten);
         if (retc != XrdTls::TLS_AOK) return TLS_Error("send to", retc);
         bytesleft -= byteswritten; Buff += byteswritten;
        }
 
// All done
//
   return Blen;
}

References AtomicAdd, BytesOut, isIdle, XrdSendQ::Send(), sendQ, XrdTls::TLS_AOK, TLS_Error(), tlsIO, XrdTlsSocket::Write(), and wrMutex.

Referenced by XrdLink::Send().

Here is the call graph for this function:

Here is the caller graph for this function:

TLS_Send() [2/3]

int XrdLinkXeq::TLS_Send	(	const sfVec *	sfP,
		int	sfN
	)

Definition at line 1428 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper lck(wrMutex);
   int bytes, buffsz, fileFD, retc;
   off_t offset;
   ssize_t totamt = 0;
   char myBuff[65536];
 
// Convert the sendfile to a regular send. The conversion is not particularly
// fast and caller are advised to avoid using sendfile on TLS connections.
//
   isIdle = 0;
   for (int i = 0; i < sfN; sfP++, i++)
       {if (!(bytes = sfP->sendsz)) continue;
        totamt += bytes;
        if (sfP->fdnum < 0)
           {if (!TLS_Write(sfP->buffer, bytes)) return -1;
            continue;
           }
        offset = sfP->offset;
        fileFD = sfP->fdnum;
        buffsz = (bytes < (int)sizeof(myBuff) ? bytes : sizeof(myBuff));
        do {do {retc = pread(fileFD, myBuff, buffsz, offset);}
                       while(retc < 0 && errno == EINTR);
            if (retc < 0) return SFError(errno);
            if (!retc) break;
            if (!TLS_Write(myBuff, buffsz)) return -1;
            offset += buffsz; bytes -= buffsz; totamt += retc;
           } while(bytes > 0);
       }
 
// We are done
//
   AtomicAdd(BytesOut, totamt);
   return totamt;
}

References AtomicAdd, BytesOut, XrdOucSFVec::fdnum, isIdle, pread, XrdOucSFVec::sendsz, SFError(), TLS_Write(), and wrMutex.

Here is the call graph for this function:

TLS_Send() [3/3]

int XrdLinkXeq::TLS_Send	(	const struct iovec *	iov,
		int	iocnt,
		int	bytes
	)

Definition at line 1393 of file XrdLinkXeq.cc.

{
   XrdSysMutexHelper lck(wrMutex);
   XrdTls::RC retc;
   int byteswritten;
 
// Get a lock and assume we will be successful (statistically we are). Note
// that the calling interface gauranteed bytes are not zero.
//
   isIdle = 0;
   AtomicAdd(BytesOut, bytes);
 
// Do non-blocking writes if we are setup to do so.
//
   if (sendQ) return sendQ->Send(iov, iocnt, bytes);
 
// Write the data out.
//
   for (int i = 0; i < iocnt; i++)
       {ssize_t bytesleft = iov[i].iov_len;
        char *Buff = (char *)iov[i].iov_base;
        while(bytesleft)
             {retc = tlsIO.Write(Buff, bytesleft, byteswritten);
              if (retc != XrdTls::TLS_AOK) return TLS_Error("send to", retc);
              bytesleft -= byteswritten; Buff += byteswritten;
             }
       }
 
// All done
//
   return bytes;
}

References AtomicAdd, BytesOut, isIdle, XrdSendQ::Send(), sendQ, XrdTls::TLS_AOK, TLS_Error(), tlsIO, XrdTlsSocket::Write(), and wrMutex.

Here is the call graph for this function:

TLS_Write()

bool XrdLinkXeq::TLS_Write ( const char *  Buff, int  Blen  )

protected

Definition at line 1469 of file XrdLinkXeq.cc.

{
   XrdTls::RC retc;
   int byteswritten;
 
// Write the data out
//
   while(Blen)
        {retc = tlsIO.Write(Buff, Blen, byteswritten);
         if (retc != XrdTls::TLS_AOK)
            {TLS_Error("write to", retc);
             return false;
            }
         Blen -= byteswritten; Buff += byteswritten;
        }
 
// All done
//
   return true;
}

References XrdTls::TLS_AOK, TLS_Error(), tlsIO, and XrdTlsSocket::Write().

Referenced by TLS_Send().

Here is the call graph for this function:

Here is the caller graph for this function:

verTLS()

const char * XrdLinkXeq::verTLS

(

)

Definition at line 1494 of file XrdLinkXeq.cc.

{
   return tlsIO.Version();
}

References tlsIO, and XrdTlsSocket::Version().

Referenced by setTLS(), and XrdLink::verTLS().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Addr

XrdNetAddr XrdLinkXeq::Addr

protected

Definition at line 197 of file XrdLinkXeq.hh.

Referenced by AddrInfo(), XrdLinkCtl::Alloc(), Close(), NetAddr(), setLocation(), setProtName(), and setTLS().

BytesIn

long long XrdLinkXeq::BytesIn

protected

Definition at line 173 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Recv(), RecvAll(), Reset(), syncStats(), and TLS_Recv().

BytesInTot

long long XrdLinkXeq::BytesInTot

protected

Definition at line 174 of file XrdLinkXeq.hh.

Referenced by Close(), getIOStats(), Reset(), and syncStats().

BytesOut

long long XrdLinkXeq::BytesOut

protected

Definition at line 175 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Reset(), Send(), syncStats(), and TLS_Send().

BytesOutTot

long long XrdLinkXeq::BytesOutTot

protected

Definition at line 176 of file XrdLinkXeq.hh.

Referenced by Close(), getIOStats(), Reset(), and syncStats().

CloseRequestCb

bool(* XrdLinkXeq::CloseRequestCb) (void *)

protected

Definition at line 188 of file XrdLinkXeq.hh.

Referenced by DoIt(), RegisterCloseRequestCb(), and Reset().

CloseRequestCbArg

void* XrdLinkXeq::CloseRequestCbArg

protected

Definition at line 189 of file XrdLinkXeq.hh.

Referenced by DoIt(), and RegisterCloseRequestCb().

HNlen

int XrdLinkXeq::HNlen

protected

Definition at line 201 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Client(), XrdLinkCtl::Find(), and XrdLinkCtl::getName().

isIdle

char XrdLinkXeq::isIdle

protected

Definition at line 204 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::idleScan(), Peek(), Recv(), RecvAll(), Reset(), Send(), TLS_Peek(), TLS_Recv(), and TLS_Send().

KeepFD

bool XrdLinkXeq::KeepFD

protected

Definition at line 203 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Close(), Reset(), and Shutdown().

LinkBytesIn

long long XrdLinkXeq::LinkBytesIn = 0

staticprotected

Definition at line 164 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

LinkBytesOut

long long XrdLinkXeq::LinkBytesOut = 0

staticprotected

Definition at line 165 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

LinkConTime

long long XrdLinkXeq::LinkConTime = 0

staticprotected

Definition at line 166 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

LinkCount

int XrdLinkXeq::LinkCount = 0

staticprotected

Definition at line 168 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

LinkCountMax

int XrdLinkXeq::LinkCountMax = 0

staticprotected

Definition at line 169 of file XrdLinkXeq.hh.

Referenced by Stats().

LinkCountTot

long long XrdLinkXeq::LinkCountTot = 0

staticprotected

Definition at line 167 of file XrdLinkXeq.hh.

Referenced by Stats().

LinkInfo

XrdLinkInfo XrdLinkXeq::LinkInfo

Definition at line 147 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Close(), DoIt(), getIOStats(), XrdLink::Hold(), XrdLinkCtl::idleScan(), XrdLink::isFlawed(), Peek(), Recv(), RecvAll(), RecvIOV(), Reset(), Send(), sendData(), SendIOV(), XrdLink::Serialize(), XrdLink::setEtext(), setNB(), setProtName(), setProtocol(), XrdLink::setRef(), Shutdown(), syncStats(), XrdLink::Terminate(), XrdLink::timeCon(), and XrdLink::UseCnt().

LinkSfIntr

int XrdLinkXeq::LinkSfIntr = 0

staticprotected

Definition at line 172 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

LinkStalls

int XrdLinkXeq::LinkStalls = 0

staticprotected

Definition at line 171 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

LinkTimeOuts

int XrdLinkXeq::LinkTimeOuts = 0

staticprotected

Definition at line 170 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

Lname

char XrdLinkXeq::Lname[256]

protected

Definition at line 206 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Client(), XrdLinkCtl::Find(), XrdLinkCtl::getName(), Name(), Register(), and Reset().

LockReads

bool XrdLinkXeq::LockReads

protected

Definition at line 202 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Peek(), Recv(), RecvAll(), Reset(), TLS_Peek(), and TLS_Recv().

PollInfo

XrdPollInfo XrdLinkXeq::PollInfo

Definition at line 148 of file XrdLinkXeq.hh.

Referenced by XrdLink::Activate(), XrdLinkCtl::Alloc(), Close(), DoIt(), XrdLink::Enable(), XrdLinkCtl::fd2PollInfo(), XrdLink::FDnum(), XrdLinkCtl::idleScan(), XrdLink::isInstance(), Peek(), Recv(), RecvAll(), Reset(), Send(), setID(), setTLS(), Shutdown(), XrdLink::Terminate(), and XrdLink::Wait4Data().

ProtoAlt

XrdProtocol* XrdLinkXeq::ProtoAlt

protected

Definition at line 187 of file XrdLinkXeq.hh.

Referenced by Close(), Reset(), and setProtocol().

Protocol

XrdProtocol* XrdLinkXeq::Protocol

protected

Definition at line 186 of file XrdLinkXeq.hh.

Referenced by Close(), DoIt(), getProtocol(), RegisterCloseRequestCb(), Reset(), setProtocol(), and syncStats().

rdMutex

XrdSysMutex XrdLinkXeq::rdMutex

protected

Definition at line 198 of file XrdLinkXeq.hh.

Referenced by Peek(), Recv(), RecvAll(), syncStats(), TLS_Peek(), and TLS_Recv().

sendQ

XrdSendQ* XrdLinkXeq::sendQ

protected

Definition at line 200 of file XrdLinkXeq.hh.

Referenced by Backlog(), Close(), Reset(), Send(), setNB(), and TLS_Send().

SfIntr

int XrdLinkXeq::SfIntr

protected

Definition at line 181 of file XrdLinkXeq.hh.

Referenced by Reset(), Send(), and syncStats().

stallCnt

int XrdLinkXeq::stallCnt

protected

Definition at line 177 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Recv(), Reset(), syncStats(), and TLS_Recv().

stallCntTot

int XrdLinkXeq::stallCntTot

protected

Definition at line 178 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Reset(), and syncStats().

statsMutex

XrdSysMutex XrdLinkXeq::statsMutex

staticprotected

Definition at line 182 of file XrdLinkXeq.hh.

Referenced by Stats(), and syncStats().

tardyCnt

int XrdLinkXeq::tardyCnt

protected

Definition at line 179 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Recv(), Reset(), syncStats(), and TLS_Recv().

tardyCntTot

int XrdLinkXeq::tardyCntTot

protected

Definition at line 180 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Reset(), and syncStats().

tlsIO

XrdTlsSocket XrdLinkXeq::tlsIO

protected

Definition at line 193 of file XrdLinkXeq.hh.

Referenced by Close(), getPeerCerts(), setID(), setTLS(), TLS_Peek(), TLS_Recv(), TLS_RecvAll(), TLS_Send(), TLS_Write(), and verTLS().

TraceID

const char * XrdLinkXeq::TraceID = "LinkXeq"

staticprotected

Definition at line 160 of file XrdLinkXeq.hh.

Uname

char XrdLinkXeq::Uname[24]

protected

Definition at line 205 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Reset(), and setID().

wrMutex

XrdSysMutex XrdLinkXeq::wrMutex

protected

Definition at line 199 of file XrdLinkXeq.hh.

Referenced by Backlog(), Close(), Send(), setNB(), syncStats(), and TLS_Send().

---

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

• XrdLinkXeq.hh
• XrdLinkXeq.cc