XrdClSocket.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
// Author: Lukasz Janyst <ljanyst@cern.ch>
//------------------------------------------------------------------------------
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//------------------------------------------------------------------------------
 
#ifndef __XRD_CL_SOCKET_HH__
#define __XRD_CL_SOCKET_HH__
 
#include <cstdint>
#include <string>
#include <sys/socket.h>
#include <memory>
 
#include "XrdCl/XrdClXRootDResponses.hh"
#include "XrdNet/XrdNetAddr.hh"
#include "XrdSys/XrdSysKernelBuffer.hh"
 
 
namespace XrdCl
{
  class AnyObject;
  class Tls;
  class AsyncSocketHandler;
  class Message;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class Socket
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum SocketStatus
      {
        Disconnected  = 1,      
        Connected     = 2,      
        Connecting    = 3       
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Socket( int socket = -1, SocketStatus status = Disconnected );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~Socket();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Initialize( int family = AF_INET );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus SetFlags( int flags );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus GetFlags( int &flags );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus GetSockOpt( int level, int optname, void *optval,
                               socklen_t *optlen );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus SetSockOpt( int level, int optname, const void *optval,
                               socklen_t optlen );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Connect( const std::string &host,
                            uint16_t           port,
                            uint16_t           timout = 10 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus ConnectToAddress( const XrdNetAddr &addr,
                                     uint16_t          timout = 10 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void Close();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      SocketStatus GetStatus() const
      {
        return pStatus;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetStatus( SocketStatus status )
      {
        pStatus = status;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus ReadRaw( void *buffer, uint32_t size, int32_t timeout,
                            uint32_t &bytesRead );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus WriteRaw( void *buffer, uint32_t size, int32_t timeout,
                             uint32_t &bytesWritten );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus Send( const char *buffer, size_t size, int &bytesWritten );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Send( XrdSys::KernelBuffer &kbuff, int &bytesWritten );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Send( Message &msg, const std::string &strmname );
 
      //----------------------------------------------------------------------------
      //----------------------------------------------------------------------------
      virtual XRootDStatus Read( char *buffer, size_t size, int &bytesRead );
 
      //----------------------------------------------------------------------------
      //----------------------------------------------------------------------------
      XRootDStatus ReadV( iovec *iov, int iocnt, int &bytesRead );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      int GetFD()
      {
        return pSocket;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetSockName() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetPeerName() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetName() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const XrdNetAddr* GetServerAddress() const
      {
        return pServerAddr.get();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetChannelID( AnyObject *channelID )
      {
        pChannelID = channelID;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const AnyObject* GetChannelID() const
      {
        return pChannelID;
      }
 
      //------------------------------------------------------------------------
      // Classify errno while reading/writing
      //------------------------------------------------------------------------
      static XRootDStatus ClassifyErrno( int error );
 
      //------------------------------------------------------------------------
      // Cork the underlying socket
      //
      // As there is no way to do vector writes with SSL/TLS we need to cork
      // the socket and then flash it when appropriate
      //------------------------------------------------------------------------
      XRootDStatus Cork();
 
      //------------------------------------------------------------------------
      // Uncork the underlying socket
      //------------------------------------------------------------------------
      XRootDStatus Uncork();
 
      //------------------------------------------------------------------------
      // Flash the underlying socket
      //------------------------------------------------------------------------
      XRootDStatus Flash();
 
      //------------------------------------------------------------------------
      // Check if the socket is corked
      //------------------------------------------------------------------------
      inline bool IsCorked() const
      {
        return pCorked;
      }
 
      //------------------------------------------------------------------------
      // Do special event mapping if applicable
      //------------------------------------------------------------------------
      uint8_t MapEvent( uint8_t event );
 
      //------------------------------------------------------------------------
      // Enable encryption
      //
      // @param socketHandler : the socket handler that is handling the socket
      // @param the host      : host name for verification
      //------------------------------------------------------------------------
      XRootDStatus TlsHandShake( AsyncSocketHandler *socketHandler,
                               const std::string  &thehost = std::string() );
 
      //------------------------------------------------------------------------
      // @return : true if socket is using TLS layer for encryption,
      //           false otherwise
      //------------------------------------------------------------------------
      bool IsEncrypted();
 
    protected:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Poll( bool readyForReading, bool readyForWriting,
                         int32_t timeout );
 
      int                          pSocket;
      SocketStatus                 pStatus;
      std::unique_ptr<XrdNetAddr>  pServerAddr;
      mutable std::string          pSockName;     // mutable because it's for caching
      mutable std::string          pPeerName;
      mutable std::string          pName;
      int                          pProtocolFamily;
      AnyObject                   *pChannelID;
      bool                         pCorked;
 
      std::unique_ptr<Tls>         pTls;
  };
}
 
#endif // __XRD_CL_SOCKET_HH__