XrdCl::AsyncSocketHandler Class Reference

#include <XrdClAsyncSocketHandler.hh>

Inheritance diagram for XrdCl::AsyncSocketHandler:

Collaboration diagram for XrdCl::AsyncSocketHandler:

Public Member Functions
	AsyncSocketHandler (const URL &url, Poller *poller, TransportHandler *transport, AnyObject *channelData, uint16_t subStreamNum, Stream *strm)
	Constructor.
	~AsyncSocketHandler ()
	Destructor.
XRootDStatus	Close ()
	Close the connection.
XRootDStatus	Connect (time_t timeout)
	Connect to the currently set address.
XRootDStatus	DisableUplink ()
	Disable uplink.
XRootDStatus	EnableUplink ()
	Enable uplink.
virtual void	Event (uint8_t type, XrdCl::Socket *)
	Handle a socket event.
const XrdNetAddr &	GetAddress () const
	Get the address that the socket is connected to.
std::string	GetHostName ()
	Get hostname.
std::string	GetIpAddr ()
	Get IP address.
std::string	GetIpStack () const
	Get the IP stack.
time_t	GetLastActivity ()
	Get timestamp of last registered socket activity.
const std::string &	GetStreamName ()
	Get stream name.
void	SetAddress (const XrdNetAddr &address)
	Set address.
Public Member Functions inherited from XrdCl::SocketHandler
virtual	~SocketHandler ()
virtual void	Finalize ()
	Finalizer.
virtual void	Initialize (Poller *)
	Initializer.

Protected Member Functions
bool	CheckHSWait () XRD_WARN_UNUSED_RESULT
XRootDStatus	DoTlsHandShake ()
bool	EventRead (uint8_t type) XRD_WARN_UNUSED_RESULT
bool	EventWrite (uint8_t type) XRD_WARN_UNUSED_RESULT
bool	HandleHandShake (std::unique_ptr< Message > msg) XRD_WARN_UNUSED_RESULT
kXR_int32	HandleWaitRsp (Message *rsp)
bool	HandShakeNextStep (bool done) XRD_WARN_UNUSED_RESULT
virtual bool	OnConnectionReturn () XRD_WARN_UNUSED_RESULT
void	OnFault (XRootDStatus st)
void	OnFaultWhileHandshaking (XRootDStatus st)
void	OnHeaderCorruption ()
bool	OnRead () XRD_WARN_UNUSED_RESULT
bool	OnReadTimeout () XRD_WARN_UNUSED_RESULT
bool	OnReadWhileHandshaking () XRD_WARN_UNUSED_RESULT
bool	OnTimeoutWhileHandshaking () XRD_WARN_UNUSED_RESULT
bool	OnTLSHandShake () XRD_WARN_UNUSED_RESULT
bool	OnWrite () XRD_WARN_UNUSED_RESULT
bool	OnWriteTimeout () XRD_WARN_UNUSED_RESULT
bool	OnWriteWhileHandshaking () XRD_WARN_UNUSED_RESULT
bool	SendHSMsg () XRD_WARN_UNUSED_RESULT

Static Protected Member Functions
static std::string	ToStreamName (const URL &url, uint16_t strmnb)
	Convert Stream object and sub-stream number to stream name.

Protected Attributes
std::unique_ptr< AsyncHSReader >	hsreader
std::unique_ptr< AsyncHSWriter >	hswriter
AnyObject *	pChannelData
time_t	pConnectionStarted
time_t	pConnectionTimeout
std::unique_ptr< HandShakeData >	pHandShakeData
bool	pHandShakeDone
time_t	pHSWaitSeconds
time_t	pHSWaitStarted
time_t	pLastActivity
Poller *	pPoller
XRootDStatus	pReqConnResetError
XrdNetAddr	pSockAddr
Socket *	pSocket
Stream *	pStream
std::string	pStreamName
uint16_t	pSubStreamNum
uint16_t	pTimeoutResolution
bool	pTlsHandShakeOngoing
TransportHandler *	pTransport
URL	pUrl
std::unique_ptr< AsyncMsgWriter >	reqwriter
std::unique_ptr< AsyncMsgReader >	rspreader

Additional Inherited Members
Public Types inherited from XrdCl::SocketHandler
enum	EventType {   ReadyToRead = 0x01 ,   ReadTimeOut = 0x02 ,   ReadyToWrite = 0x04 ,   WriteTimeOut = 0x08 }
	Event type. More...
Static Public Member Functions inherited from XrdCl::SocketHandler
static std::string	EventTypeToString (uint8_t event)
	Translate the event type to a string.

Detailed Description

Utility class handling asynchronous socket interactions and forwarding events to the parent stream.

Definition at line 43 of file XrdClAsyncSocketHandler.hh.

Constructor & Destructor Documentation

AsyncSocketHandler()

XrdCl::AsyncSocketHandler::AsyncSocketHandler	(	const URL &	url,
		Poller *	poller,
		TransportHandler *	transport,
		AnyObject *	channelData,
		uint16_t	subStreamNum,
		Stream *	strm )

Constructor.

Definition at line 35 of file XrdClAsyncSocketHandler.cc.

                                                                  :
    pPoller( poller ),
    pTransport( transport ),
    pChannelData( channelData ),
    pSubStreamNum( subStreamNum ),
    pStream( strm ),
    pStreamName( ToStreamName( url, subStreamNum ) ),
    pSocket( new Socket() ),
    pHandShakeDone( false ),
    pConnectionStarted( 0 ),
    pConnectionTimeout( 0 ),
    pHSWaitStarted( 0 ),
    pHSWaitSeconds( 0 ),
    pUrl( url ),
    pTlsHandShakeOngoing( false )
  {
    Env *env = DefaultEnv::GetEnv();
 
    int timeoutResolution = DefaultTimeoutResolution;
    env->GetInt( "TimeoutResolution", timeoutResolution );
    pTimeoutResolution = timeoutResolution;
 
    pSocket->SetChannelID( pChannelData );
    pLastActivity = time(0);
  }

References XrdCl::DefaultTimeoutResolution, XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), pChannelData, pConnectionStarted, pConnectionTimeout, pHandShakeDone, pHSWaitSeconds, pHSWaitStarted, pLastActivity, pPoller, pSocket, pStream, pStreamName, pSubStreamNum, pTimeoutResolution, pTlsHandShakeOngoing, pTransport, pUrl, and ToStreamName().

Here is the call graph for this function:

~AsyncSocketHandler()

XrdCl::AsyncSocketHandler::~AsyncSocketHandler

(

)

Destructor.

Definition at line 69 of file XrdClAsyncSocketHandler.cc.

  {
    Close();
    delete pSocket;
  }

References Close(), and pSocket.

Here is the call graph for this function:

Member Function Documentation

CheckHSWait()

bool XrdCl::AsyncSocketHandler::CheckHSWait ( )

protected

Definition at line 887 of file XrdClAsyncSocketHandler.cc.

  {
    time_t now = time( 0 );
    if( now - pHSWaitStarted >= pHSWaitSeconds )
    {
      Log *log = DefaultEnv::GetLog();
      log->Debug( AsyncSockMsg, "[%s] The hand-shake wait time elapsed, will "
                  "replay the endsess request.", pStreamName.c_str() );
      if( !SendHSMsg() )
        return false;
      //------------------------------------------------------------------------
      // Make sure the wait state is reset
      //------------------------------------------------------------------------
      pHSWaitSeconds = 0;
      pHSWaitStarted = 0;
    }
    return true;
  }

References XrdCl::AsyncSockMsg, XrdCl::Log::Debug(), XrdCl::DefaultEnv::GetLog(), pHSWaitSeconds, pHSWaitStarted, pStreamName, and SendHSMsg().

Referenced by EventRead().

Here is the call graph for this function:

Here is the caller graph for this function:

Close()

XRootDStatus XrdCl::AsyncSocketHandler::Close

(

)

Close the connection.

Definition at line 187 of file XrdClAsyncSocketHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    log->Debug( AsyncSockMsg, "[%s] Closing the socket", pStreamName.c_str() );
 
    pTransport->Disconnect( *pChannelData,
                            pSubStreamNum );
 
    pPoller->RemoveSocket( pSocket );
    pSocket->Close();
    return XRootDStatus();
  }

References XrdCl::AsyncSockMsg, XrdCl::Log::Debug(), XrdCl::DefaultEnv::GetLog(), pChannelData, pPoller, pSocket, pStreamName, pSubStreamNum, and pTransport.

Referenced by ~AsyncSocketHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

Connect()

XRootDStatus XrdCl::AsyncSocketHandler::Connect

(

time_t

timeout

)

Connect to the currently set address.

Definition at line 78 of file XrdClAsyncSocketHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    pLastActivity = pConnectionStarted = ::time(0);
    pConnectionTimeout = timeout;
 
    //--------------------------------------------------------------------------
    // Initialize the socket
    //--------------------------------------------------------------------------
    XRootDStatus st = pSocket->Initialize( pSockAddr.Family() );
    if( !st.IsOK() )
    {
      log->Error( AsyncSockMsg, "[%s] Unable to initialize socket: %s",
                  pStreamName.c_str(), st.ToString().c_str() );
      st.status = stFatal;
      return st;
    }
 
    //--------------------------------------------------------------------------
    // Set the keep-alive up
    //--------------------------------------------------------------------------
    Env *env = DefaultEnv::GetEnv();
 
    int keepAlive = DefaultTCPKeepAlive;
    env->GetInt( "TCPKeepAlive", keepAlive );
    if( keepAlive )
    {
      int          param = 1;
      XRootDStatus st    = pSocket->SetSockOpt( SOL_SOCKET, SO_KEEPALIVE, &param,
                                          sizeof(param) );
      if( !st.IsOK() )
        log->Error( AsyncSockMsg, "[%s] Unable to turn on keepalive: %s",
                    pStreamName.c_str(), st.ToString().c_str() );
 
#if ( defined(__linux__) || defined(__GNU__) ) && defined( TCP_KEEPIDLE ) && \
    defined( TCP_KEEPINTVL ) && defined( TCP_KEEPCNT )
 
      param = DefaultTCPKeepAliveTime;
      env->GetInt( "TCPKeepAliveTime", param );
      st = pSocket->SetSockOpt(SOL_TCP, TCP_KEEPIDLE, &param, sizeof(param));
      if( !st.IsOK() )
        log->Error( AsyncSockMsg, "[%s] Unable to set keepalive time: %s",
                    pStreamName.c_str(), st.ToString().c_str() );
 
      param = DefaultTCPKeepAliveInterval;
      env->GetInt( "TCPKeepAliveInterval", param );
      st = pSocket->SetSockOpt(SOL_TCP, TCP_KEEPINTVL, &param, sizeof(param));
      if( !st.IsOK() )
        log->Error( AsyncSockMsg, "[%s] Unable to set keepalive interval: %s",
                    pStreamName.c_str(), st.ToString().c_str() );
 
      param = DefaultTCPKeepAliveProbes;
      env->GetInt( "TCPKeepAliveProbes", param );
      st = pSocket->SetSockOpt(SOL_TCP, TCP_KEEPCNT, &param, sizeof(param));
      if( !st.IsOK() )
        log->Error( AsyncSockMsg, "[%s] Unable to set keepalive probes: %s",
                    pStreamName.c_str(), st.ToString().c_str() );
#endif
    }
 
    pHandShakeDone = false;
    pTlsHandShakeOngoing = false;
    pHSWaitStarted = 0;
    pHSWaitSeconds = 0;
    pReqConnResetError = XRootDStatus();
 
    //--------------------------------------------------------------------------
    // Initiate async connection to the address
    //--------------------------------------------------------------------------
    char nameBuff[256];
    pSockAddr.Format( nameBuff, sizeof(nameBuff), XrdNetAddrInfo::fmtAdv6 );
    log->Debug( AsyncSockMsg, "[%s] Attempting connection to %s",
                pStreamName.c_str(), nameBuff );
 
    st = pSocket->ConnectToAddress( pSockAddr, 0 );
    if( !st.IsOK() )
    {
      log->Error( AsyncSockMsg, "[%s] Unable to initiate the connection: %s",
                  pStreamName.c_str(), st.ToString().c_str() );
      return st;
    }
 
    pSocket->SetStatus( Socket::Connecting );
 
    //--------------------------------------------------------------------------
    // We should get the ready to write event once we're really connected
    // so we need to listen to it
    //--------------------------------------------------------------------------
    if( !pPoller->AddSocket( pSocket, this ) )
    {
      XRootDStatus st( stFatal, errPollerError );
      pSocket->Close();
      return st;
    }
 
    if( !pPoller->EnableWriteNotification( pSocket, true, pTimeoutResolution ) )
    {
      XRootDStatus st( stFatal, errPollerError );
      pPoller->RemoveSocket( pSocket );
      pSocket->Close();
      return st;
    }
 
    return XRootDStatus();
  }

References XrdCl::AsyncSockMsg, XrdCl::Socket::Connecting, XrdCl::Log::Debug(), XrdCl::DefaultTCPKeepAlive, XrdCl::DefaultTCPKeepAliveInterval, XrdCl::DefaultTCPKeepAliveProbes, XrdCl::DefaultTCPKeepAliveTime, XrdCl::Log::Error(), XrdCl::errPollerError, XrdNetAddrInfo::fmtAdv6, XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::DefaultEnv::GetLog(), XrdCl::Status::IsOK(), pConnectionStarted, pConnectionTimeout, pHandShakeDone, pHSWaitSeconds, pHSWaitStarted, pLastActivity, pPoller, pReqConnResetError, pSockAddr, pSocket, pStreamName, pTimeoutResolution, pTlsHandShakeOngoing, XrdCl::Status::status, XrdCl::stFatal, and XrdCl::Status::ToString().

Here is the call graph for this function:

DisableUplink()

XRootDStatus XrdCl::AsyncSocketHandler::DisableUplink ( )

inline

Disable uplink.

Definition at line 105 of file XrdClAsyncSocketHandler.hh.

      {
        if( !pPoller->EnableWriteNotification( pSocket, false ) )
          return XRootDStatus( stFatal, errPollerError );
        return XRootDStatus();
      }

References XrdCl::errPollerError, pPoller, pSocket, and XrdCl::stFatal.

Referenced by OnWrite(), and OnWriteWhileHandshaking().

Here is the caller graph for this function:

DoTlsHandShake()

XRootDStatus XrdCl::AsyncSocketHandler::DoTlsHandShake ( )

protected

Definition at line 797 of file XrdClAsyncSocketHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    log->Debug( AsyncSockMsg, "[%s] TLS hand-shake exchange.", pStreamName.c_str() );
 
    XRootDStatus st;
    if( !( st = pSocket->TlsHandShake( this, pUrl.GetHostName() ) ).IsOK() )
    {
      pTlsHandShakeOngoing = false;
      OnFaultWhileHandshaking( st );
      return st;
    }
 
    if( st.code == suRetry )
    {
      pTlsHandShakeOngoing = true;
      return st;
    }
 
    pTlsHandShakeOngoing = false;
    log->Info( AsyncSockMsg, "[%s] TLS hand-shake done.", pStreamName.c_str() );
 
    return st;
  }

References XrdCl::AsyncSockMsg, XrdCl::Status::code, XrdCl::Log::Debug(), XrdCl::DefaultEnv::GetLog(), XrdCl::Log::Info(), OnFaultWhileHandshaking(), pSocket, pStreamName, pTlsHandShakeOngoing, pUrl, and XrdCl::suRetry.

Referenced by HandleHandShake(), and OnTLSHandShake().

Here is the call graph for this function:

Here is the caller graph for this function:

EnableUplink()

XRootDStatus XrdCl::AsyncSocketHandler::EnableUplink ( )

inline

Enable uplink.

Definition at line 95 of file XrdClAsyncSocketHandler.hh.

      {
        if( !pPoller->EnableWriteNotification( pSocket, true, pTimeoutResolution ) )
          return XRootDStatus( stFatal, errPollerError );
        return XRootDStatus();
      }

References XrdCl::errPollerError, pPoller, pSocket, pTimeoutResolution, and XrdCl::stFatal.

Referenced by HandShakeNextStep(), and SendHSMsg().

Here is the caller graph for this function:

Event()

void XrdCl::AsyncSocketHandler::Event ( uint8_t type, XrdCl::Socket *  )

virtual

Handle a socket event.

Implements XrdCl::SocketHandler.

Definition at line 211 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // First check if the socket itself wants to apply some mapping on the
    // event. E.g. in case of TLS socket it might want to map read events to
    // write events and vice-versa.
    //--------------------------------------------------------------------------
    type = pSocket->MapEvent( type );
 
    //--------------------------------------------------------------------------
    // Handle any read or write events. If any of the handlers indicate an error
    // we will have been disconnected. A disconnection may cause the current
    // object to be asynchronously reused or deleted, so we return immediately.
    //--------------------------------------------------------------------------
    if( !EventRead( type ) )
      return;
 
    //--------------------------------------------------------------------------
    // If there's a previosuly noted ECONNRESET error from write we give the
    // fault now. This gave us the chance to process a read event.
    //--------------------------------------------------------------------------
    if( !pReqConnResetError.IsOK() )
    {
      OnFault( pReqConnResetError );
      return;
    }
 
    if( !EventWrite( type ) )
      return;
  }

References EventRead(), EventWrite(), OnFault(), pReqConnResetError, and pSocket.

Here is the call graph for this function:

EventRead()

bool XrdCl::AsyncSocketHandler::EventRead ( uint8_t type )

inlineprotected

Definition at line 245 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Read event
    //--------------------------------------------------------------------------
    if( type & ReadyToRead )
    {
      pLastActivity = time(0);
      if( unlikely( pTlsHandShakeOngoing ) )
        return OnTLSHandShake();
 
      if( likely( pHandShakeDone ) )
        return OnRead();
 
      return OnReadWhileHandshaking();
    }
 
    //--------------------------------------------------------------------------
    // Read timeout
    //--------------------------------------------------------------------------
    else if( type & ReadTimeOut )
    {
      if( pHSWaitSeconds )
      {
        if( !CheckHSWait() )
          return false;
      }
 
      if( likely( pHandShakeDone ) )
        return OnReadTimeout();
 
      return OnTimeoutWhileHandshaking();
    }
 
    return true;
  }

References CheckHSWait(), likely, OnRead(), OnReadTimeout(), OnReadWhileHandshaking(), OnTimeoutWhileHandshaking(), OnTLSHandShake(), pHandShakeDone, pHSWaitSeconds, pLastActivity, pTlsHandShakeOngoing, XrdCl::SocketHandler::ReadTimeOut, XrdCl::SocketHandler::ReadyToRead, and unlikely.

Referenced by Event().

Here is the call graph for this function:

Here is the caller graph for this function:

EventWrite()

bool XrdCl::AsyncSocketHandler::EventWrite ( uint8_t type )

inlineprotected

Definition at line 285 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Write event
    //--------------------------------------------------------------------------
    if( type & ReadyToWrite )
    {
      pLastActivity = time(0);
      if( unlikely( pSocket->GetStatus() == Socket::Connecting ) )
        return OnConnectionReturn();
 
      //------------------------------------------------------------------------
      // Make sure we are not writing anything if we have been told to wait.
      //------------------------------------------------------------------------
      if( pHSWaitSeconds != 0 )
        return true;
 
      if( unlikely( pTlsHandShakeOngoing ) )
        return OnTLSHandShake();
 
      if( likely( pHandShakeDone ) )
        return OnWrite();
 
      return OnWriteWhileHandshaking();
    }
 
    //--------------------------------------------------------------------------
    // Write timeout
    //--------------------------------------------------------------------------
    else if( type & WriteTimeOut )
    {
      if( likely( pHandShakeDone ) )
        return OnWriteTimeout();
 
      return OnTimeoutWhileHandshaking();
    }
 
    return true;
  }

References XrdCl::Socket::Connecting, likely, OnConnectionReturn(), OnTimeoutWhileHandshaking(), OnTLSHandShake(), OnWrite(), OnWriteTimeout(), OnWriteWhileHandshaking(), pHandShakeDone, pHSWaitSeconds, pLastActivity, pSocket, pTlsHandShakeOngoing, XrdCl::SocketHandler::ReadyToWrite, unlikely, and XrdCl::SocketHandler::WriteTimeOut.

Referenced by Event().

Here is the call graph for this function:

Here is the caller graph for this function:

GetAddress()

const XrdNetAddr & XrdCl::AsyncSocketHandler::GetAddress ( ) const

inline

Get the address that the socket is connected to.

Definition at line 72 of file XrdClAsyncSocketHandler.hh.

      {
        return pSockAddr;
      }

References pSockAddr.

GetHostName()

std::string XrdCl::AsyncSocketHandler::GetHostName

(

)

Get hostname.

Definition at line 929 of file XrdClAsyncSocketHandler.cc.

  {
    const char *cstr = pSockAddr.Name();
    if( !cstr )
      return std::string();
    return cstr;
  }

References pSockAddr.

GetIpAddr()

std::string XrdCl::AsyncSocketHandler::GetIpAddr

(

)

Get IP address.

Definition at line 919 of file XrdClAsyncSocketHandler.cc.

  {
    char nameBuff[256];
    pSockAddr.Format( nameBuff, sizeof(nameBuff), XrdNetAddrInfo::fmtAddr, XrdNetAddrInfo::noPort );
    return nameBuff;
  }

References XrdNetAddrInfo::fmtAddr, XrdNetAddrInfo::noPort, and pSockAddr.

GetIpStack()

std::string XrdCl::AsyncSocketHandler::GetIpStack

(

)

const

Get the IP stack.

Definition at line 909 of file XrdClAsyncSocketHandler.cc.

  {
    std::string ipstack( ( pSockAddr.isIPType( XrdNetAddr::IPType::IPv6 ) &&
                           !pSockAddr.isMapped() ) ? "IPv6" : "IPv4" );
    return ipstack;
  }

References XrdNetAddrInfo::IPv6, and pSockAddr.

GetLastActivity()

time_t XrdCl::AsyncSocketHandler::GetLastActivity ( )

inline

Get timestamp of last registered socket activity.

Definition at line 123 of file XrdClAsyncSocketHandler.hh.

      {
        return pLastActivity;
      }

References pLastActivity.

GetStreamName()

const std::string & XrdCl::AsyncSocketHandler::GetStreamName ( )

inline

Get stream name.

Definition at line 115 of file XrdClAsyncSocketHandler.hh.

      {
        return pStreamName;
      }

References pStreamName.

HandleHandShake()

bool XrdCl::AsyncSocketHandler::HandleHandShake ( std::unique_ptr< Message > msg )

protected

Definition at line 602 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // OK, we have a new message, let's deal with it;
    //--------------------------------------------------------------------------
    pHandShakeData->in = msg.release();
    XRootDStatus st = pTransport->HandShake( pHandShakeData.get(), *pChannelData );
 
    //--------------------------------------------------------------------------
    // Deal with wait responses
    //--------------------------------------------------------------------------
    kXR_int32 waitSeconds = HandleWaitRsp( pHandShakeData->in );
 
    delete pHandShakeData->in;
    pHandShakeData->in = 0;
 
    if( !st.IsOK() )
    {
      OnFaultWhileHandshaking( st );
      return false;
    }
 
    if( st.code == suRetry )
    {
      //------------------------------------------------------------------------
      // We are handling a wait response and the transport handler told
      // as to retry the request
      //------------------------------------------------------------------------
      if( waitSeconds >=0 )
      {
        time_t resendTime = ::time( 0 ) + waitSeconds;
        if( resendTime > pConnectionStarted + pConnectionTimeout )
        {
          Log *log = DefaultEnv::GetLog();
          log->Error( AsyncSockMsg,
                      "[%s] Won't retry kXR_endsess request because would"
                      "reach connection timeout.",
                      pStreamName.c_str() );
 
          OnFaultWhileHandshaking( XRootDStatus( stError, errSocketTimeout ) );
          return false;
        }
        else
        {
          //--------------------------------------------------------------------
          // We need to wait before replaying the request
          //--------------------------------------------------------------------
          Log *log = DefaultEnv::GetLog();
          log->Debug( AsyncSockMsg, "[%s] Received a wait response to endsess request, "
                      "will wait for %d seconds before replaying the endsess request",
                      pStreamName.c_str(), waitSeconds );
          pHSWaitStarted = time( 0 );
          pHSWaitSeconds = waitSeconds;
        }
        return true;
      }
      //------------------------------------------------------------------------
      // We are re-sending a protocol request
      //------------------------------------------------------------------------
      else if( pHandShakeData->out )
      {
        return SendHSMsg();
      }
    }
 
    //--------------------------------------------------------------------------
    // If now is the time to enable encryption
    //--------------------------------------------------------------------------
    if( !pSocket->IsEncrypted() &&
         pTransport->NeedEncryption( pHandShakeData.get(), *pChannelData ) )
    {
      XRootDStatus st = DoTlsHandShake();
      if( !st.IsOK() )
        return false;
      if ( st.code == suRetry )
        return true;
    }
 
    //--------------------------------------------------------------------------
    // Now prepare the next step of the hand-shake procedure
    //--------------------------------------------------------------------------
    return HandShakeNextStep( st.IsOK() && st.code == suDone );
  }

References XrdCl::AsyncSockMsg, XrdCl::Status::code, XrdCl::Log::Debug(), DoTlsHandShake(), XrdCl::Log::Error(), XrdCl::errSocketTimeout, XrdCl::DefaultEnv::GetLog(), HandleWaitRsp(), HandShakeNextStep(), XrdCl::Status::IsOK(), OnFaultWhileHandshaking(), pChannelData, pConnectionStarted, pConnectionTimeout, pHandShakeData, pHSWaitSeconds, pHSWaitStarted, pSocket, pStreamName, pTransport, SendHSMsg(), XrdCl::stError, XrdCl::suDone, and XrdCl::suRetry.

Referenced by OnReadWhileHandshaking().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleWaitRsp()

kXR_int32 XrdCl::AsyncSocketHandler::HandleWaitRsp ( Message * rsp )

inlineprotected

Definition at line 873 of file XrdClAsyncSocketHandler.cc.

  {
    // It would be more coherent if this could be done in the
    // transport layer, unfortunately the API does not allow it.
    kXR_int32 waitSeconds = -1;
    ServerResponse *rsp = (ServerResponse*)msg->GetBuffer();
    if( rsp->hdr.status == kXR_wait )
      waitSeconds = rsp->body.wait.seconds;
    return waitSeconds;
  }

References ServerResponse::body, XrdCl::Buffer::GetBuffer(), ServerResponse::hdr, kXR_wait, and ServerResponseHeader::status.

Referenced by HandleHandShake().

Here is the call graph for this function:

Here is the caller graph for this function:

HandShakeNextStep()

bool XrdCl::AsyncSocketHandler::HandShakeNextStep ( bool done )

protected

Definition at line 689 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // We successfully proceeded to the next step
    //--------------------------------------------------------------------------
    ++pHandShakeData->step;
 
    //--------------------------------------------------------------------------
    // The hand shake process is done
    //--------------------------------------------------------------------------
    if( done )
    {
      pHandShakeData.reset();
      hswriter.reset();
      hsreader.reset();
      //------------------------------------------------------------------------
      // Initialize the request writer & reader
      //------------------------------------------------------------------------
      reqwriter.reset( new AsyncMsgWriter( *pTransport, *pSocket, pStreamName, *pStream, pSubStreamNum, *pChannelData ) );
      rspreader.reset( new AsyncMsgReader( *pTransport, *pSocket, pStreamName, *pStream, pSubStreamNum ) );
      XRootDStatus st;
      if( !(st = EnableUplink()).IsOK() )
      {
        OnFaultWhileHandshaking( st );
        return false;
      }
      pHandShakeDone = true;
      pStream->OnConnect( pSubStreamNum );
    }
    //--------------------------------------------------------------------------
    // The transport handler gave us something to write
    //--------------------------------------------------------------------------
    else if( pHandShakeData->out )
    {
      return SendHSMsg();
    }
    return true;
  }

References EnableUplink(), hsreader, hswriter, OnFaultWhileHandshaking(), pChannelData, pHandShakeData, pHandShakeDone, pSocket, pStream, pStreamName, pSubStreamNum, pTransport, reqwriter, rspreader, and SendHSMsg().

Referenced by HandleHandShake(), and OnTLSHandShake().

Here is the call graph for this function:

Here is the caller graph for this function:

OnConnectionReturn()

bool XrdCl::AsyncSocketHandler::OnConnectionReturn ( )

protectedvirtual

Definition at line 328 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Check whether we were able to connect
    //--------------------------------------------------------------------------
    Log *log = DefaultEnv::GetLog();
    log->Debug( AsyncSockMsg, "[%s] Async connection call returned",
                pStreamName.c_str() );
 
    int errorCode = 0;
    socklen_t optSize = sizeof( errorCode );
    XRootDStatus st = pSocket->GetSockOpt( SOL_SOCKET, SO_ERROR, &errorCode,
                                     &optSize );
 
    //--------------------------------------------------------------------------
    // This is an internal error really (either logic or system fault),
    // so we call it a day and don't retry
    //--------------------------------------------------------------------------
    if( !st.IsOK() )
    {
      log->Error( AsyncSockMsg, "[%s] Unable to get the status of the "
                  "connect operation: %s", pStreamName.c_str(),
                  XrdSysE2T( errno ) );
      pStream->OnConnectError( pSubStreamNum,
                               XRootDStatus( stFatal, errSocketOptError, errno ) );
      return false;
    }
 
    //--------------------------------------------------------------------------
    // We were unable to connect
    //--------------------------------------------------------------------------
    if( errorCode )
    {
      log->Error( AsyncSockMsg, "[%s] Unable to connect: %s",
                  pStreamName.c_str(), XrdSysE2T( errorCode ) );
      pStream->OnConnectError( pSubStreamNum,
                               XRootDStatus( stError, errConnectionError ) );
      return false;
    }
    pSocket->SetStatus( Socket::Connected );
 
    //--------------------------------------------------------------------------
    // Cork the socket
    //--------------------------------------------------------------------------
    st = pSocket->Cork();
    if( !st.IsOK() )
    {
      pStream->OnConnectError( pSubStreamNum, st );
      return false;
    }
 
    //--------------------------------------------------------------------------
    // Initialize the handshake
    //--------------------------------------------------------------------------
    pHandShakeData.reset( new HandShakeData( pStream->GetURL(),
                                        pSubStreamNum ) );
    pHandShakeData->serverAddr = pSocket->GetServerAddress();
    pHandShakeData->clientName = pSocket->GetSockName();
    pHandShakeData->streamName = pStreamName;
 
    st = pTransport->HandShake( pHandShakeData.get(), *pChannelData );
    if( !st.IsOK() )
    {
      log->Error( AsyncSockMsg, "[%s] Connection negotiation failed",
                  pStreamName.c_str() );
      pStream->OnConnectError( pSubStreamNum, st );
      return false;
    }
 
    if( st.code != suRetry )
      ++pHandShakeData->step;
 
    //--------------------------------------------------------------------------
    // Initialize the hand-shake reader and writer
    //--------------------------------------------------------------------------
    hswriter.reset( new AsyncHSWriter( *pSocket, pStreamName ) );
    hsreader.reset( new AsyncHSReader( *pTransport, *pSocket, pStreamName, *pStream, pSubStreamNum ) );
 
    //--------------------------------------------------------------------------
    // Transport has given us something to send
    //--------------------------------------------------------------------------
    if( pHandShakeData->out )
    {
      hswriter->Reset( pHandShakeData->out );
      pHandShakeData->out = nullptr;
    }
 
    //--------------------------------------------------------------------------
    // Listen to what the server has to say
    //--------------------------------------------------------------------------
    if( !pPoller->EnableReadNotification( pSocket, true, pTimeoutResolution ) )
    {
      pStream->OnConnectError( pSubStreamNum,
                               XRootDStatus( stFatal, errPollerError ) );
      return false;
    }
    return true;
  }

References XrdCl::AsyncSockMsg, XrdCl::Status::code, XrdCl::Socket::Connected, XrdCl::Log::Debug(), XrdCl::errConnectionError, XrdCl::Log::Error(), XrdCl::errPollerError, XrdCl::errSocketOptError, XrdCl::DefaultEnv::GetLog(), hsreader, hswriter, XrdCl::Status::IsOK(), pChannelData, pHandShakeData, pPoller, pSocket, pStream, pStreamName, pSubStreamNum, pTimeoutResolution, pTransport, XrdCl::stError, XrdCl::stFatal, XrdCl::suRetry, and XrdSysE2T().

Referenced by EventWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

OnFault()

void XrdCl::AsyncSocketHandler::OnFault ( XRootDStatus st )

protected

Definition at line 731 of file XrdClAsyncSocketHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    log->Error( AsyncSockMsg, "[%s] Socket error encountered: %s",
                pStreamName.c_str(), st.ToString().c_str() );
 
    pStream->OnError( pSubStreamNum, st );
  }

References XrdCl::AsyncSockMsg, XrdCl::Log::Error(), XrdCl::DefaultEnv::GetLog(), pStream, pStreamName, pSubStreamNum, and XrdCl::Status::ToString().

Referenced by Event(), OnRead(), OnReadWhileHandshaking(), and OnWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

OnFaultWhileHandshaking()

void XrdCl::AsyncSocketHandler::OnFaultWhileHandshaking ( XRootDStatus st )

protected

Definition at line 743 of file XrdClAsyncSocketHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    log->Error( AsyncSockMsg, "[%s] Socket error while handshaking: %s",
                pStreamName.c_str(), st.ToString().c_str() );
 
    pStream->OnConnectError( pSubStreamNum, st );
  }

References XrdCl::AsyncSockMsg, XrdCl::Log::Error(), XrdCl::DefaultEnv::GetLog(), pStream, pStreamName, pSubStreamNum, and XrdCl::Status::ToString().

Referenced by DoTlsHandShake(), HandleHandShake(), HandShakeNextStep(), OnReadWhileHandshaking(), OnTimeoutWhileHandshaking(), OnWriteWhileHandshaking(), and SendHSMsg().

Here is the call graph for this function:

Here is the caller graph for this function:

OnHeaderCorruption()

void XrdCl::AsyncSocketHandler::OnHeaderCorruption ( )

protected

Definition at line 785 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // We need to force a socket error so this is handled in a similar way as
    // a stream t/o and all requests are retried
    //--------------------------------------------------------------------------
    pStream->ForceError( XRootDStatus( stError, errSocketError ) );
  }

References XrdCl::errSocketError, pStream, and XrdCl::stError.

Referenced by OnRead().

Here is the caller graph for this function:

OnRead()

bool XrdCl::AsyncSocketHandler::OnRead ( )

protected

Definition at line 522 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Make sure the response reader object exists
    //--------------------------------------------------------------------------
    if( !rspreader )
    {
      OnFault( XRootDStatus( stError, errInternal, 0, "Response reader is null." ) );
      return false;
    }
 
    //--------------------------------------------------------------------------
    // Readout the data from the socket
    //--------------------------------------------------------------------------
    XRootDStatus st = rspreader->Read();
 
    //--------------------------------------------------------------------------
    // Handler header corruption
    //--------------------------------------------------------------------------
    if( !st.IsOK() && st.code == errCorruptedHeader )
    {
      OnHeaderCorruption();
      return false;
    }
 
    //--------------------------------------------------------------------------
    // Handler other errors
    //--------------------------------------------------------------------------
    if( !st.IsOK() )
    {
      OnFault( st );
      return false;
    }
 
    //--------------------------------------------------------------------------
    // We are not done yet
    //--------------------------------------------------------------------------
    if( st.code == suRetry ) return true;
 
    //--------------------------------------------------------------------------
    // We are done, reset the response reader so we can read out next message
    //--------------------------------------------------------------------------
    rspreader->Reset();
    return true;
  }

References XrdCl::Status::code, XrdCl::errCorruptedHeader, XrdCl::errInternal, XrdCl::Status::IsOK(), OnFault(), OnHeaderCorruption(), rspreader, XrdCl::stError, and XrdCl::suRetry.

Referenced by EventRead().

Here is the call graph for this function:

Here is the caller graph for this function:

OnReadTimeout()

bool XrdCl::AsyncSocketHandler::OnReadTimeout ( )

protected

Definition at line 763 of file XrdClAsyncSocketHandler.cc.

  {
    return pStream->OnReadTimeout( pSubStreamNum );
  }

References pStream, and pSubStreamNum.

Referenced by EventRead().

Here is the caller graph for this function:

OnReadWhileHandshaking()

bool XrdCl::AsyncSocketHandler::OnReadWhileHandshaking ( )

protected

Definition at line 571 of file XrdClAsyncSocketHandler.cc.

  {
    //--------------------------------------------------------------------------
    // Make sure the response reader object exists
    //--------------------------------------------------------------------------
    if( !hsreader )
    {
      OnFault( XRootDStatus( stError, errInternal, 0, "Hand-shake reader is null." ) );
      return false;
    }
 
    //--------------------------------------------------------------------------
    // Read the message and let the transport handler look at it when
    // reading has finished
    //--------------------------------------------------------------------------
    XRootDStatus st = hsreader->Read();
    if( !st.IsOK() )
    {
      OnFaultWhileHandshaking( st );
      return false;
    }
 
    if( st.code != suDone )
      return true;
 
    return HandleHandShake( hsreader->ReleaseMsg() );
  }

References XrdCl::Status::code, XrdCl::errInternal, HandleHandShake(), hsreader, XrdCl::Status::IsOK(), OnFault(), OnFaultWhileHandshaking(), XrdCl::stError, and XrdCl::suDone.

Referenced by EventRead().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTimeoutWhileHandshaking()

bool XrdCl::AsyncSocketHandler::OnTimeoutWhileHandshaking ( )

protected

Definition at line 771 of file XrdClAsyncSocketHandler.cc.

  {
    time_t now = time(0);
    if( now > pConnectionStarted+pConnectionTimeout )
    {
      OnFaultWhileHandshaking( XRootDStatus( stError, errSocketTimeout ) );
      return false;
    }
    return true;
  }

References XrdCl::errSocketTimeout, OnFaultWhileHandshaking(), pConnectionStarted, pConnectionTimeout, and XrdCl::stError.

Referenced by EventRead(), and EventWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTLSHandShake()

bool XrdCl::AsyncSocketHandler::OnTLSHandShake ( )

inlineprotected

Definition at line 825 of file XrdClAsyncSocketHandler.cc.

  {
    XRootDStatus st = DoTlsHandShake();
    if( !st.IsOK() )
      return false;
    if ( st.code == suRetry )
      return true;
 
    return HandShakeNextStep( pTransport->HandShakeDone( pHandShakeData.get(),
                                                         *pChannelData ) );
  }

References XrdCl::Status::code, DoTlsHandShake(), HandShakeNextStep(), XrdCl::Status::IsOK(), pChannelData, pHandShakeData, pTransport, and XrdCl::suRetry.

Referenced by EventRead(), and EventWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

OnWrite()

bool XrdCl::AsyncSocketHandler::OnWrite ( )

protected

Definition at line 430 of file XrdClAsyncSocketHandler.cc.

  {
    if( !reqwriter )
    {
      OnFault( XRootDStatus( stError, errInternal, 0, "Request writer is null." ) );
      return false;
    }
    //--------------------------------------------------------------------------
    // Let's do the writing ...
    //--------------------------------------------------------------------------
    XRootDStatus st = reqwriter->Write();
 
    //--------------------------------------------------------------------------
    // In the case of ECONNRESET perhaps the server sent us something.
    // To give a chance to read it in the next event poll we pass this as a
    // retry, but return the error after the next event.
    //--------------------------------------------------------------------------
    if( st.code == errSocketError && st.errNo == ECONNRESET )
    {
      if( (DisableUplink()).IsOK() )
      {
        pReqConnResetError = st;
        st = XRootDStatus( stOK, suRetry );
      }
    }
    if( !st.IsOK() )
    {
      //------------------------------------------------------------------------
      // We failed
      //------------------------------------------------------------------------
      OnFault( st );
      return false;
    }
    //--------------------------------------------------------------------------
    // We are not done yet
    //--------------------------------------------------------------------------
    if( st.code == suRetry) return true;
    //--------------------------------------------------------------------------
    // Disable the respective substream if empty
    //--------------------------------------------------------------------------
    reqwriter->Reset();
    pStream->DisableIfEmpty( pSubStreamNum );
    return true;
  }

References XrdCl::Status::code, DisableUplink(), XrdCl::errInternal, XrdCl::Status::errNo, XrdCl::errSocketError, XrdCl::Status::IsOK(), OnFault(), pReqConnResetError, pStream, pSubStreamNum, reqwriter, XrdCl::stError, XrdCl::stOK, and XrdCl::suRetry.

Referenced by EventWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

OnWriteTimeout()

bool XrdCl::AsyncSocketHandler::OnWriteTimeout ( )

protected

Definition at line 755 of file XrdClAsyncSocketHandler.cc.

  {
    return pStream->OnWriteTimeout( pSubStreamNum );
  }

References pStream, and pSubStreamNum.

Referenced by EventWrite().

Here is the caller graph for this function:

OnWriteWhileHandshaking()

bool XrdCl::AsyncSocketHandler::OnWriteWhileHandshaking ( )

protected

Definition at line 478 of file XrdClAsyncSocketHandler.cc.

  {
    XRootDStatus st;
    if( !hswriter || !hswriter->HasMsg() )
    {
      if( !(st = DisableUplink()).IsOK() )
      {
        OnFaultWhileHandshaking( st );
        return false;
      }
      return true;
    }
    //--------------------------------------------------------------------------
    // Let's do the writing ...
    //--------------------------------------------------------------------------
    st = hswriter->Write();
    if( !st.IsOK() )
    {
      //------------------------------------------------------------------------
      // We failed
      //------------------------------------------------------------------------
      OnFaultWhileHandshaking( st );
      return false;
    }
    //--------------------------------------------------------------------------
    // We are not done yet
    //--------------------------------------------------------------------------
    if( st.code == suRetry ) return true;
    //--------------------------------------------------------------------------
    // Disable the uplink
    // Note: at this point we don't deallocate the HS message as we might need
    //       to re-send it in case of a kXR_wait response
    //--------------------------------------------------------------------------
    if( !(st = DisableUplink()).IsOK() )
    {
      OnFaultWhileHandshaking( st );
      return false;
    }
    return true;
  }

References XrdCl::Status::code, DisableUplink(), hswriter, XrdCl::Status::IsOK(), OnFaultWhileHandshaking(), and XrdCl::suRetry.

Referenced by EventWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

SendHSMsg()

bool XrdCl::AsyncSocketHandler::SendHSMsg ( )

protected

Definition at line 840 of file XrdClAsyncSocketHandler.cc.

  {
    if( !hswriter )
    {
      OnFaultWhileHandshaking( XRootDStatus( stError, errInternal, 0,
                                             "HS writer object missing!" ) );
      return false;
    }
    //--------------------------------------------------------------------------
    // We only set a new HS message if this is not a replay due to kXR_wait
    //--------------------------------------------------------------------------
    if( !pHSWaitSeconds )
    {
      hswriter->Reset( pHandShakeData->out );
      pHandShakeData->out = nullptr;
    }
    //--------------------------------------------------------------------------
    // otherwise we replay the kXR_endsess request
    //--------------------------------------------------------------------------
    else
      hswriter->Replay();
    //--------------------------------------------------------------------------
    // Enable writing so we can replay the HS message
    //--------------------------------------------------------------------------
    XRootDStatus st;
    if( !(st = EnableUplink()).IsOK() )
    {
      OnFaultWhileHandshaking( st );
      return false;
    }
    return true;
  }

References EnableUplink(), XrdCl::errInternal, hswriter, OnFaultWhileHandshaking(), pHandShakeData, pHSWaitSeconds, and XrdCl::stError.

Referenced by CheckHSWait(), HandleHandShake(), and HandShakeNextStep().

Here is the call graph for this function:

Here is the caller graph for this function:

SetAddress()

void XrdCl::AsyncSocketHandler::SetAddress ( const XrdNetAddr & address )

inline

Set address.

Definition at line 64 of file XrdClAsyncSocketHandler.hh.

      {
        pSockAddr = address;
      }

References pSockAddr.

ToStreamName()

std::string XrdCl::AsyncSocketHandler::ToStreamName ( const URL & url, uint16_t strmnb )

staticprotected

Convert Stream object and sub-stream number to stream name.

Definition at line 200 of file XrdClAsyncSocketHandler.cc.

  {
    std::ostringstream o;
    o << url.GetHostId();
    o << "." << strmnb;
    return o.str();
  }

References XrdCl::URL::GetHostId().

Referenced by AsyncSocketHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

hsreader

std::unique_ptr<AsyncHSReader> XrdCl::AsyncSocketHandler::hsreader

protected

Definition at line 290 of file XrdClAsyncSocketHandler.hh.

Referenced by HandShakeNextStep(), OnConnectionReturn(), and OnReadWhileHandshaking().

hswriter

std::unique_ptr<AsyncHSWriter> XrdCl::AsyncSocketHandler::hswriter

protected

Definition at line 288 of file XrdClAsyncSocketHandler.hh.

Referenced by HandShakeNextStep(), OnConnectionReturn(), OnWriteWhileHandshaking(), and SendHSMsg().

pChannelData

AnyObject* XrdCl::AsyncSocketHandler::pChannelData

protected

Definition at line 270 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Close(), HandleHandShake(), HandShakeNextStep(), OnConnectionReturn(), and OnTLSHandShake().

pConnectionStarted

time_t XrdCl::AsyncSocketHandler::pConnectionStarted

protected

Definition at line 279 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Connect(), HandleHandShake(), and OnTimeoutWhileHandshaking().

pConnectionTimeout

time_t XrdCl::AsyncSocketHandler::pConnectionTimeout

protected

Definition at line 280 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Connect(), HandleHandShake(), and OnTimeoutWhileHandshaking().

pHandShakeData

std::unique_ptr<HandShakeData> XrdCl::AsyncSocketHandler::pHandShakeData

protected

Definition at line 276 of file XrdClAsyncSocketHandler.hh.

Referenced by HandleHandShake(), HandShakeNextStep(), OnConnectionReturn(), OnTLSHandShake(), and SendHSMsg().

pHandShakeDone

bool XrdCl::AsyncSocketHandler::pHandShakeDone

protected

Definition at line 277 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Connect(), EventRead(), EventWrite(), and HandShakeNextStep().

pHSWaitSeconds

time_t XrdCl::AsyncSocketHandler::pHSWaitSeconds

protected

Definition at line 283 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), CheckHSWait(), Connect(), EventRead(), EventWrite(), HandleHandShake(), and SendHSMsg().

pHSWaitStarted

time_t XrdCl::AsyncSocketHandler::pHSWaitStarted

protected

Definition at line 282 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), CheckHSWait(), Connect(), and HandleHandShake().

pLastActivity

time_t XrdCl::AsyncSocketHandler::pLastActivity

protected

Definition at line 281 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Connect(), EventRead(), EventWrite(), and GetLastActivity().

pPoller

Poller* XrdCl::AsyncSocketHandler::pPoller

protected

Definition at line 268 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Close(), Connect(), DisableUplink(), EnableUplink(), and OnConnectionReturn().

pReqConnResetError

XRootDStatus XrdCl::AsyncSocketHandler::pReqConnResetError

protected

Definition at line 286 of file XrdClAsyncSocketHandler.hh.

Referenced by Connect(), Event(), and OnWrite().

pSockAddr

XrdNetAddr XrdCl::AsyncSocketHandler::pSockAddr

protected

Definition at line 275 of file XrdClAsyncSocketHandler.hh.

Referenced by Connect(), GetAddress(), GetHostName(), GetIpAddr(), GetIpStack(), and SetAddress().

pSocket

Socket* XrdCl::AsyncSocketHandler::pSocket

protected

Definition at line 274 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), ~AsyncSocketHandler(), Close(), Connect(), DisableUplink(), DoTlsHandShake(), EnableUplink(), Event(), EventWrite(), HandleHandShake(), HandShakeNextStep(), and OnConnectionReturn().

pStream

Stream* XrdCl::AsyncSocketHandler::pStream

protected

Definition at line 272 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), HandShakeNextStep(), OnConnectionReturn(), OnFault(), OnFaultWhileHandshaking(), OnHeaderCorruption(), OnReadTimeout(), OnWrite(), and OnWriteTimeout().

pStreamName

std::string XrdCl::AsyncSocketHandler::pStreamName

protected

Definition at line 273 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), CheckHSWait(), Close(), Connect(), DoTlsHandShake(), GetStreamName(), HandleHandShake(), HandShakeNextStep(), OnConnectionReturn(), OnFault(), and OnFaultWhileHandshaking().

pSubStreamNum

uint16_t XrdCl::AsyncSocketHandler::pSubStreamNum

protected

Definition at line 271 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Close(), HandShakeNextStep(), OnConnectionReturn(), OnFault(), OnFaultWhileHandshaking(), OnReadTimeout(), OnWrite(), and OnWriteTimeout().

pTimeoutResolution

uint16_t XrdCl::AsyncSocketHandler::pTimeoutResolution

protected

Definition at line 278 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Connect(), EnableUplink(), and OnConnectionReturn().

pTlsHandShakeOngoing

bool XrdCl::AsyncSocketHandler::pTlsHandShakeOngoing

protected

Definition at line 285 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Connect(), DoTlsHandShake(), EventRead(), and EventWrite().

pTransport

TransportHandler* XrdCl::AsyncSocketHandler::pTransport

protected

Definition at line 269 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), Close(), HandleHandShake(), HandShakeNextStep(), OnConnectionReturn(), and OnTLSHandShake().

pUrl

URL XrdCl::AsyncSocketHandler::pUrl

protected

Definition at line 284 of file XrdClAsyncSocketHandler.hh.

Referenced by AsyncSocketHandler(), and DoTlsHandShake().

reqwriter

std::unique_ptr<AsyncMsgWriter> XrdCl::AsyncSocketHandler::reqwriter

protected

Definition at line 291 of file XrdClAsyncSocketHandler.hh.

Referenced by HandShakeNextStep(), and OnWrite().

rspreader

std::unique_ptr<AsyncMsgReader> XrdCl::AsyncSocketHandler::rspreader

protected

Definition at line 289 of file XrdClAsyncSocketHandler.hh.

Referenced by HandShakeNextStep(), and OnRead().

---

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

• XrdClAsyncSocketHandler.hh
• XrdClAsyncSocketHandler.cc