XrdCl::AsyncSocketHandler Class Reference

#include <XrdClAsyncSocketHandler.hh>

Inheritance diagram for XrdCl::AsyncSocketHandler:

Collaboration diagram for XrdCl::AsyncSocketHandler:

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

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

Protected Attributes
std::unique_ptr< AsyncHSReader >	hsreader
std::unique_ptr< AsyncHSWriter >	hswriter
AnyObject *	pChannelData
time_t	pConnectionStarted
time_t	pConnectionTimeout
bool	pDoTransportDisc
std::unique_ptr< HandShakeData >	pHandShakeData
bool	pHandShakeDone
time_t	pHSWaitSeconds
time_t	pHSWaitStarted
time_t	pLastActivity
std::shared_ptr< Channel >	pOpenChannel
Poller *	pPoller
XRootDStatus	pReqConnResetError
XrdNetAddr	pSockAddr
Socket *	pSocket
Stream *	pStream
std::string	pStreamName
uint16_t	pSubStreamNum
time_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. More...

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() [1/2]

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

Constructors.

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 ),
    pDoTransportDisc( 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, pLastActivity, pSocket, pTimeoutResolution, and XrdCl::Socket::SetChannelID().

Here is the call graph for this function:

AsyncSocketHandler() [2/2]

XrdCl::AsyncSocketHandler::AsyncSocketHandler ( const AsyncSocketHandler &  other )

inline

Definition at line 56 of file XrdClAsyncSocketHandler.hh.

                                                           :
        AsyncSocketHandler( other.pUrl, other.pPoller, other.pTransport,
                            other.pChannelData, other.pSubStreamNum,
                            other.pStream )
      {
        pLastActivity = other.pLastActivity;
      }

References pLastActivity.

~AsyncSocketHandler()

XrdCl::AsyncSocketHandler::~AsyncSocketHandler

(

)

Destructor.

Definition at line 70 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 926 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. Can block until the poller can remove the socket, which may require waiting for dispatch of all queued events to all other sockets the poller thread is serving.

Definition at line 216 of file XrdClAsyncSocketHandler.cc.

  {
    Log *log = DefaultEnv::GetLog();
    log->Debug( AsyncSockMsg, "[%s] Closing the socket", pStreamName.c_str() );
 
    pPoller->RemoveSocket( pSocket );
 
    if( pDoTransportDisc )
    {
      pTransport->Disconnect( *pChannelData,
                              pSubStreamNum );
      pDoTransportDisc = false;
    }
 
    pSocket->Close();
    //--------------------------------------------------------------------------
    // Releases a reference count on Channel. May possibly cause it to be
    // destroyed, which will in turn destory pStream and thus us.
    //--------------------------------------------------------------------------
    pOpenChannel.reset();
    return XRootDStatus();
  }

References XrdCl::AsyncSockMsg, XrdCl::Socket::Close(), XrdCl::Log::Debug(), XrdCl::TransportHandler::Disconnect(), XrdCl::DefaultEnv::GetLog(), pChannelData, pDoTransportDisc, pOpenChannel, pPoller, pSocket, pStreamName, pSubStreamNum, pTransport, and XrdCl::Poller::RemoveSocket().

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 79 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 );
 
    pOpenChannel = pStream->GetChannel();
    pDoTransportDisc = true;
 
    //--------------------------------------------------------------------------
    // 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();
      pDoTransportDisc = false;
      pOpenChannel.reset();
      return st;
    }
 
    if( !pPoller->EnableWriteNotification( pSocket, true, pTimeoutResolution ) )
    {
      XRootDStatus st( stFatal, errPollerError );
      pPoller->RemoveSocket( pSocket );
      pSocket->Close();
      pDoTransportDisc = false;
      pOpenChannel.reset();
      return st;
    }
 
    return XRootDStatus();
  }

References XrdCl::Poller::AddSocket(), XrdCl::AsyncSockMsg, XrdCl::Socket::Close(), XrdCl::Socket::Connecting, XrdCl::Socket::ConnectToAddress(), XrdCl::Log::Debug(), XrdCl::DefaultTCPKeepAlive, XrdCl::DefaultTCPKeepAliveInterval, XrdCl::DefaultTCPKeepAliveProbes, XrdCl::DefaultTCPKeepAliveTime, XrdCl::Poller::EnableWriteNotification(), XrdCl::Log::Error(), XrdCl::errPollerError, XrdNetAddrInfo::Family(), XrdNetAddrInfo::fmtAdv6, XrdNetAddrInfo::Format(), XrdCl::Stream::GetChannel(), XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::DefaultEnv::GetLog(), XrdCl::Socket::Initialize(), XrdCl::Status::IsOK(), pConnectionStarted, pConnectionTimeout, pDoTransportDisc, pHandShakeDone, pHSWaitSeconds, pHSWaitStarted, pLastActivity, pOpenChannel, pPoller, pReqConnResetError, pSockAddr, pSocket, pStream, pStreamName, pTimeoutResolution, pTlsHandShakeOngoing, XrdCl::Poller::RemoveSocket(), XrdCl::Socket::SetSockOpt(), XrdCl::Socket::SetStatus(), 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 122 of file XrdClAsyncSocketHandler.hh.

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

References XrdCl::Poller::EnableWriteNotification(), XrdCl::errPollerError, pPoller, pSocket, and XrdCl::stFatal.

Referenced by XrdCl::Tls::Connect(), OnWrite(), OnWriteWhileHandshaking(), XrdCl::Tls::Read(), and XrdCl::Tls::Send().

Here is the call graph for this function:

Here is the caller graph for this function:

DoTlsHandShake()

XRootDStatus XrdCl::AsyncSocketHandler::DoTlsHandShake ( )

protected

Definition at line 836 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::URL::GetHostName(), XrdCl::DefaultEnv::GetLog(), XrdCl::Log::Info(), OnFaultWhileHandshaking(), pSocket, pStreamName, pTlsHandShakeOngoing, pUrl, XrdCl::suRetry, and XrdCl::Socket::TlsHandShake().

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 112 of file XrdClAsyncSocketHandler.hh.

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

References XrdCl::Poller::EnableWriteNotification(), XrdCl::errPollerError, pPoller, pSocket, pTimeoutResolution, and XrdCl::stFatal.

Referenced by XrdCl::Tls::Connect(), HandShakeNextStep(), XrdCl::Tls::Read(), XrdCl::Tls::Send(), and SendHSMsg().

Here is the call graph for this function:

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 250 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(), XrdCl::Status::IsOK(), XrdCl::Socket::MapEvent(), OnFault(), pReqConnResetError, and pSocket.

Here is the call graph for this function:

EventRead()

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

inlineprotected

Definition at line 284 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 324 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, XrdCl::Socket::GetStatus(), 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 80 of file XrdClAsyncSocketHandler.hh.

      {
        return pSockAddr;
      }

References pSockAddr.

GetHostName()

std::string XrdCl::AsyncSocketHandler::GetHostName

(

)

Get hostname.

Definition at line 968 of file XrdClAsyncSocketHandler.cc.

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

References XrdNetAddrInfo::Name(), and pSockAddr.

Here is the call graph for this function:

GetIpAddr()

std::string XrdCl::AsyncSocketHandler::GetIpAddr

(

)

Get IP address.

Definition at line 958 of file XrdClAsyncSocketHandler.cc.

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

References XrdNetAddrInfo::fmtAddr, XrdNetAddrInfo::Format(), XrdNetAddrInfo::noPort, and pSockAddr.

Here is the call graph for this function:

GetIpStack()

std::string XrdCl::AsyncSocketHandler::GetIpStack

(

)

const

Get the IP stack.

Definition at line 948 of file XrdClAsyncSocketHandler.cc.

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

References XrdNetAddrInfo::isIPType(), XrdNetAddrInfo::isMapped(), and pSockAddr.

Here is the call graph for this function:

GetLastActivity()

time_t XrdCl::AsyncSocketHandler::GetLastActivity ( )

inline

Get timestamp of last registered socket activity.

Definition at line 140 of file XrdClAsyncSocketHandler.hh.

      {
        return pLastActivity;
      }

References pLastActivity.

GetStreamName()

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

inline

Get stream name.

Definition at line 132 of file XrdClAsyncSocketHandler.hh.

      {
        return pStreamName;
      }

References pStreamName.

HandleHandShake()

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

protected

Definition at line 641 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(), XrdCl::TransportHandler::HandShake(), HandShakeNextStep(), XrdCl::Socket::IsEncrypted(), XrdCl::Status::IsOK(), XrdCl::TransportHandler::NeedEncryption(), 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 912 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 728 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, XrdCl::Stream::OnConnect(), 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 367 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::Socket::Cork(), XrdCl::Log::Debug(), XrdCl::Poller::EnableReadNotification(), XrdCl::errConnectionError, XrdCl::Log::Error(), XrdCl::errPollerError, XrdCl::errSocketOptError, XrdCl::DefaultEnv::GetLog(), XrdCl::Socket::GetServerAddress(), XrdCl::Socket::GetSockName(), XrdCl::Socket::GetSockOpt(), XrdCl::Stream::GetURL(), XrdCl::TransportHandler::HandShake(), hsreader, hswriter, XrdCl::Status::IsOK(), XrdCl::Stream::OnConnectError(), pChannelData, pHandShakeData, pPoller, pSocket, pStream, pStreamName, pSubStreamNum, pTimeoutResolution, pTransport, XrdCl::Socket::SetStatus(), 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 770 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(), XrdCl::Stream::OnError(), 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 782 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(), XrdCl::Stream::OnConnectError(), 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 824 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 ), false, 0 );
  }

References XrdCl::errSocketError, XrdCl::Stream::ForceError(), pStream, and XrdCl::stError.

Referenced by OnRead().

Here is the call graph for this function:

Here is the caller graph for this function:

OnRead()

bool XrdCl::AsyncSocketHandler::OnRead ( )

protected

Definition at line 561 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 802 of file XrdClAsyncSocketHandler.cc.

  {
    return pStream->OnReadTimeout( pSubStreamNum );
  }

References XrdCl::Stream::OnReadTimeout(), pStream, and pSubStreamNum.

Referenced by EventRead().

Here is the call graph for this function:

Here is the caller graph for this function:

OnReadWhileHandshaking()

bool XrdCl::AsyncSocketHandler::OnReadWhileHandshaking ( )

protected

Definition at line 610 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 810 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 864 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(), XrdCl::TransportHandler::HandShakeDone(), 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 469 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, XrdCl::Stream::DisableIfEmpty(), 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 794 of file XrdClAsyncSocketHandler.cc.

  {
    return pStream->OnWriteTimeout( pSubStreamNum );
  }

References XrdCl::Stream::OnWriteTimeout(), pStream, and pSubStreamNum.

Referenced by EventWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

OnWriteWhileHandshaking()

bool XrdCl::AsyncSocketHandler::OnWriteWhileHandshaking ( )

protected

Definition at line 517 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:

PreClose()

XRootDStatus XrdCl::AsyncSocketHandler::PreClose

(

)

Disable further event callbacks and performs close action on the transport. Will block until any currently running callback for this socket completes, unless called from within the callback itself.

Definition at line 196 of file XrdClAsyncSocketHandler.cc.

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

References XrdCl::AsyncSockMsg, XrdCl::Log::Debug(), XrdCl::TransportHandler::Disconnect(), XrdCl::DefaultEnv::GetLog(), pChannelData, pDoTransportDisc, pPoller, pSocket, pStreamName, pSubStreamNum, pTransport, and XrdCl::Poller::ShutdownEvents().

Here is the call graph for this function:

SendHSMsg()

bool XrdCl::AsyncSocketHandler::SendHSMsg ( )

protected

Definition at line 879 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 72 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 239 of file XrdClAsyncSocketHandler.cc.

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

References XrdCl::URL::GetHostId().

Here is the call graph for this function:

Member Data Documentation

hsreader

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

protected

Definition at line 308 of file XrdClAsyncSocketHandler.hh.

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

hswriter

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

protected

Definition at line 306 of file XrdClAsyncSocketHandler.hh.

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

pChannelData

AnyObject* XrdCl::AsyncSocketHandler::pChannelData

protected

Definition at line 287 of file XrdClAsyncSocketHandler.hh.

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

pConnectionStarted

time_t XrdCl::AsyncSocketHandler::pConnectionStarted

protected

Definition at line 296 of file XrdClAsyncSocketHandler.hh.

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

pConnectionTimeout

time_t XrdCl::AsyncSocketHandler::pConnectionTimeout

protected

Definition at line 297 of file XrdClAsyncSocketHandler.hh.

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

pDoTransportDisc

bool XrdCl::AsyncSocketHandler::pDoTransportDisc

protected

Definition at line 304 of file XrdClAsyncSocketHandler.hh.

Referenced by Close(), Connect(), and PreClose().

pHandShakeData

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

protected

Definition at line 293 of file XrdClAsyncSocketHandler.hh.

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

pHandShakeDone

bool XrdCl::AsyncSocketHandler::pHandShakeDone

protected

Definition at line 294 of file XrdClAsyncSocketHandler.hh.

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

pHSWaitSeconds

time_t XrdCl::AsyncSocketHandler::pHSWaitSeconds

protected

Definition at line 300 of file XrdClAsyncSocketHandler.hh.

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

pHSWaitStarted

time_t XrdCl::AsyncSocketHandler::pHSWaitStarted

protected

Definition at line 299 of file XrdClAsyncSocketHandler.hh.

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

pLastActivity

time_t XrdCl::AsyncSocketHandler::pLastActivity

protected

Definition at line 298 of file XrdClAsyncSocketHandler.hh.

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

pOpenChannel

std::shared_ptr<Channel> XrdCl::AsyncSocketHandler::pOpenChannel

protected

Definition at line 311 of file XrdClAsyncSocketHandler.hh.

Referenced by Close(), and Connect().

pPoller

Poller* XrdCl::AsyncSocketHandler::pPoller

protected

Definition at line 285 of file XrdClAsyncSocketHandler.hh.

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

pReqConnResetError

XRootDStatus XrdCl::AsyncSocketHandler::pReqConnResetError

protected

Definition at line 303 of file XrdClAsyncSocketHandler.hh.

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

pSockAddr

XrdNetAddr XrdCl::AsyncSocketHandler::pSockAddr

protected

Definition at line 292 of file XrdClAsyncSocketHandler.hh.

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

pSocket

Socket* XrdCl::AsyncSocketHandler::pSocket

protected

Definition at line 291 of file XrdClAsyncSocketHandler.hh.

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

pStream

Stream* XrdCl::AsyncSocketHandler::pStream

protected

Definition at line 289 of file XrdClAsyncSocketHandler.hh.

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

pStreamName

std::string XrdCl::AsyncSocketHandler::pStreamName

protected

Definition at line 290 of file XrdClAsyncSocketHandler.hh.

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

pSubStreamNum

uint16_t XrdCl::AsyncSocketHandler::pSubStreamNum

protected

Definition at line 288 of file XrdClAsyncSocketHandler.hh.

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

pTimeoutResolution

time_t XrdCl::AsyncSocketHandler::pTimeoutResolution

protected

Definition at line 295 of file XrdClAsyncSocketHandler.hh.

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

pTlsHandShakeOngoing

bool XrdCl::AsyncSocketHandler::pTlsHandShakeOngoing

protected

Definition at line 302 of file XrdClAsyncSocketHandler.hh.

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

pTransport

TransportHandler* XrdCl::AsyncSocketHandler::pTransport

protected

Definition at line 286 of file XrdClAsyncSocketHandler.hh.

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

pUrl

URL XrdCl::AsyncSocketHandler::pUrl

protected

Definition at line 301 of file XrdClAsyncSocketHandler.hh.

Referenced by DoTlsHandShake().

reqwriter

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

protected

Definition at line 309 of file XrdClAsyncSocketHandler.hh.

Referenced by HandShakeNextStep(), and OnWrite().

rspreader

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

protected

Definition at line 307 of file XrdClAsyncSocketHandler.hh.

Referenced by HandShakeNextStep(), and OnRead().

---

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

• XrdClAsyncSocketHandler.hh
• XrdClAsyncSocketHandler.cc