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).
int	Backlog ()
int	Client (char *buff, int blen)
int	Close (bool defer=false)
void	Enable ()
	Enable the link to field interrupts.
int	FDnum ()
int	getIOStats (long long &inbytes, long long &outbytes, int &numstall, int &numtardy)
XrdTlsPeerCerts *	getPeerCerts ()
XrdProtocol *	getProtocol ()
	Obtain current protocol object pointer.
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.
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.
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).
int	UseCnt () const
	Return link's reference count.
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.
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 XrdLink::XrdLink(), PollInfo, and Reset().

Referenced by XrdLinkCtl::RegisterCloseRequestCb().

Here is the call graph for this function:

Here is the caller 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.

Backlog()

int XrdLinkXeq::Backlog

(

)

Definition at line 140 of file XrdLinkXeq.cc.

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

References sendQ, and wrMutex.

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 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.
//
   while(LinkInfo.InUse > 1)
      {opHelper.UnLock();
       TRACEI(DEBUG, "Close FD "<<LinkInfo.FD <<" deferred, use count="
                     <<LinkInfo.InUse);
       Serialize();
       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(), XrdTcpMonPin::LinkInfo::fd, XrdLink::ID, XrdLink::Instance, XrdLink::isTLS, KeepFD, LinkInfo, XrdSysMutexHelper::Lock(), XrdGlobal::Log, PollInfo, ProtoAlt, Protocol, sendQ, XrdLink::Serialize(), Shutdown(), syncStats(), XrdGlobal::TcpMonPin, XrdTcpMonPin::LinkInfo::tident, tlsIO, TRACEI, XrdLinkCtl::Unhook(), XrdSysMutexHelper::UnLock(), and wrMutex.

Referenced by 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 293 of file XrdLinkXeq.cc.

{
   int rc;
 
// 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 (Protocol)
      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;
 
   if (doCl)
      {if (CloseRequestCb)
         {const bool res = CloseRequestCb(CloseRequestCbArg);
          if (!res) return;
         }
       Close();
      }
}

References Close(), CloseRequestCb, CloseRequestCbArg, XrdLink::ID, XrdGlobal::Log, PollInfo, Protocol, and XrdGlobal::Sched.

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, LinkInfo, stallCnt, stallCntTot, tardyCnt, and tardyCntTot.

getName()

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

static

getPeerCerts()

XrdTlsPeerCerts * XrdLinkXeq::getPeerCerts

(

)

Definition at line 331 of file XrdLinkXeq.cc.

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

References XrdLink::isTLS, and tlsIO.

getProtocol()

XrdProtocol * XrdLinkXeq::getProtocol ( )

inline

Definition at line 82 of file XrdLinkXeq.hh.

{return Protocol;}

References Protocol.

Name()

const char * XrdLinkXeq::Name ( ) const

inline

Definition at line 85 of file XrdLinkXeq.hh.

{return (const char *)Lname;}

References Lname.

NetAddr()

const XrdNetAddr * XrdLinkXeq::NetAddr ( ) const

inline

Definition at line 88 of file XrdLinkXeq.hh.

{return &Addr;}

References Addr.

Peek()

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

Definition at line 340 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 XrdLink::ID, isIdle, LinkInfo, XrdSysMutexHelper::Lock(), LockReads, XrdGlobal::Log, XrdPoll::Poll2Text(), PollInfo, and rdMutex.

Here is the call graph for this function:

Recv() [1/3]

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

Definition at line 383 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, XrdLink::ID, isIdle, LinkInfo, LockReads, XrdGlobal::Log, rdMutex, and read.

Recv() [2/3]

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

Definition at line 403 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, 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 458 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, 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 519 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, XrdLink::ID, isIdle, LinkInfo, LockReads, XrdGlobal::Log, XrdPoll::Poll2Text(), PollInfo, rdMutex, and TRACEI.

Here is the call graph for this function:

RecvIOV()

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

protected

Definition at line 561 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 XrdLink::ID, LinkInfo, XrdGlobal::Log, and readv.

Referenced by Recv().

Here is the caller graph for this function:

Register()

bool XrdLinkXeq::Register

(

const char *

hName

)

Definition at line 583 of file XrdLinkXeq.cc.

{
 
// First see if we can register this name with the address object
//
   if (!Addr.Register(hName)) return false;
 
// Make appropriate changes here
//
   if (HostName) free(HostName);
   HostName = strdup(hName);
   strlcpy(Lname, hName, sizeof(Lname));
   return true;
}

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

Here is the call graph for this function:

RegisterCloseRequestCb()

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

Definition at line 1469 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, XrdLink::ResetLink(), sendQ, SfIntr, stallCnt, stallCntTot, tardyCnt, tardyCntTot, and Uname.

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 602 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, XrdLink::ID, isIdle, LinkInfo, XrdGlobal::Log, sendQ, write, and wrMutex.

Send() [2/3]

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

Definition at line 689 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, XrdOucSFVec::fdnum, XrdLink::ID, isIdle, LinkInfo, XrdGlobal::Log, PollInfo, sendData(), XrdOucSFVec::sendsz, SfIntr, XrdOucSFVec::sfMax, XrdLink::sfOK, 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 640 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, XrdGlobal::maxIOV, SendIOV(), sendQ, and wrMutex.

Here is the call graph for this function:

sendData()

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

protected

Definition at line 824 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 LinkInfo, and write.

Referenced by Send().

Here is the caller graph for this function:

SendIOV()

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

protected

Definition at line 847 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 XrdLink::ID, LinkInfo, XrdGlobal::Log, write, and writev.

Referenced by Send().

Here is the caller graph for this function:

setID()

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

Definition at line 888 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, XrdLink::ID, XrdLink::isTLS, PollInfo, tlsIO, and Uname.

setLocation()

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

inline

Definition at line 107 of file XrdLinkXeq.hh.

{Addr.SetLocation(loc);}

References Addr.

setNB()

bool XrdLinkXeq::setNB

(

)

Definition at line 912 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, sendQ, TRACEI, and wrMutex.

setProtName()

void XrdLinkXeq::setProtName

(

const char *

name

)

Definition at line 958 of file XrdLinkXeq.cc.

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

References Addr, and LinkInfo.

setProtocol()

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

Definition at line 941 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, ProtoAlt, and Protocol.

setTLS()

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

Definition at line 972 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 Addr, eMsg, XrdLink::ID, XrdLink::isTLS, XrdGlobal::Log, PollInfo, XrdTls::TLS_AOK, XrdTlsSocket::TLS_HS_BLOCK, XrdTlsSocket::TLS_RBL_WBL, XrdGlobal::tlsCtx, tlsIO, and verTLS().

Here is the call graph for this function:

SFError()

int XrdLinkXeq::SFError ( int rc )

protected

Definition at line 1026 of file XrdLinkXeq.cc.

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

References XrdLink::ID, and XrdGlobal::Log.

Referenced by TLS_Send().

Here is the caller graph for this function:

Shutdown()

void XrdLinkXeq::Shutdown

(

bool

getLock

)

Definition at line 1036 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, XrdLink::ID, XrdLink::Instance, KeepFD, LinkInfo, XrdGlobal::Log, PollInfo, and TRACEI.

Referenced by Close().

Here is the caller graph for this function:

Stats()

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

static

Definition at line 1068 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 1104 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, LinkBytesIn, LinkBytesOut, LinkConTime, LinkCount, LinkInfo, LinkSfIntr, LinkStalls, LinkTimeOuts, Protocol, rdMutex, SfIntr, stallCnt, stallCntTot, statsMutex, tardyCnt, tardyCntTot, and wrMutex.

Referenced by Close().

Here is the caller graph for this function:

TLS_Error()

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

protected

Definition at line 1161 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 XrdLink::ID, XrdGlobal::Log, and XrdTls::RC2Text().

Referenced by TLS_Peek(), TLS_Recv(), TLS_Recv(), TLS_Send(), 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 1175 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, rdMutex, XrdTls::TLS_AOK, TLS_Error(), tlsIO, and XrdLink::Wait4Data().

Here is the call graph for this function:

TLS_Recv() [1/3]

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

Definition at line 1207 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, XrdTls::TLS_AOK, TLS_Error(), and tlsIO.

Referenced by 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 1229 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, rdMutex, 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 1276 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 1306 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 TLS_Recv(), tlsIO, and XrdLink::Wait4Data().

Here is the call graph for this function:

TLS_Send() [1/3]

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

Definition at line 1328 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, sendQ, XrdTls::TLS_AOK, TLS_Error(), tlsIO, and wrMutex.

Here is the call graph for this function:

TLS_Send() [2/3]

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

Definition at line 1394 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 1359 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, sendQ, XrdTls::TLS_AOK, TLS_Error(), tlsIO, 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 1435 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(), and tlsIO.

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 1460 of file XrdLinkXeq.cc.

{
   return tlsIO.Version();
}

References tlsIO.

Referenced by setTLS().

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(), Register(), setLocation(), setProtName(), and setTLS().

BytesIn

long long XrdLinkXeq::BytesIn

protected

Definition at line 173 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Recv(), Recv(), Recv(), RecvAll(), Reset(), syncStats(), TLS_Recv(), TLS_Recv(), 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(), Send(), Send(), syncStats(), TLS_Send(), TLS_Send(), 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(), Recv(), Recv(), RecvAll(), Reset(), Send(), Send(), Send(), TLS_Peek(), TLS_Recv(), TLS_Recv(), TLS_Recv(), TLS_Send(), TLS_Send(), 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 XrdLinkCtl::Alloc(), Stats(), and syncStats().

LinkCountMax

int XrdLinkXeq::LinkCountMax = 0

staticprotected

Definition at line 169 of file XrdLinkXeq.hh.

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

LinkCountTot

long long XrdLinkXeq::LinkCountTot = 0

staticprotected

Definition at line 167 of file XrdLinkXeq.hh.

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

LinkInfo

XrdLinkInfo XrdLinkXeq::LinkInfo

Definition at line 147 of file XrdLinkXeq.hh.

Referenced by XrdLinkCtl::Alloc(), Close(), getIOStats(), XrdLinkCtl::idleScan(), Peek(), Recv(), Recv(), Recv(), RecvAll(), RecvIOV(), Reset(), Send(), Send(), sendData(), SendIOV(), setNB(), setProtName(), setProtocol(), Shutdown(), and syncStats().

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(), Recv(), Recv(), RecvAll(), Reset(), TLS_Peek(), TLS_Recv(), TLS_Recv(), and TLS_Recv().

PollInfo

XrdPollInfo XrdLinkXeq::PollInfo

Definition at line 148 of file XrdLinkXeq.hh.

Referenced by XrdLinkXeq(), XrdLinkCtl::Alloc(), Close(), DoIt(), XrdLinkCtl::idleScan(), Peek(), Recv(), Recv(), RecvAll(), Reset(), Send(), setID(), setTLS(), and Shutdown().

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(), Recv(), Recv(), RecvAll(), syncStats(), TLS_Peek(), TLS_Recv(), TLS_Recv(), and TLS_Recv().

sendQ

XrdSendQ* XrdLinkXeq::sendQ

protected

Definition at line 200 of file XrdLinkXeq.hh.

Referenced by Backlog(), Close(), Reset(), Send(), Send(), setNB(), TLS_Send(), 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 XrdLinkCtl::Alloc(), Stats(), and syncStats().

tardyCnt

int XrdLinkXeq::tardyCnt

protected

Definition at line 179 of file XrdLinkXeq.hh.

Referenced by getIOStats(), Recv(), 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_Recv(), TLS_RecvAll(), TLS_Send(), 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(), Send(), Send(), setNB(), syncStats(), TLS_Send(), TLS_Send(), and TLS_Send().

---

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

• XrdLinkXeq.hh
• XrdLinkXeq.cc