XrdClXRootDTransport.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2014 by European Organization for Nuclear Research (CERN)
// Author: Lukasz Janyst <ljanyst@cern.ch>
//------------------------------------------------------------------------------
// This file is part of the XRootD software suite.
//
// 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/>.
//
// In applying this licence, CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
//------------------------------------------------------------------------------
 
#ifndef __XRD_CL_XROOTD_TRANSPORT_HH__
#define __XRD_CL_XROOTD_TRANSPORT_HH__
 
#include "XrdCl/XrdClPostMaster.hh"
#include "XrdCl/XrdClMessage.hh"
#include "XProtocol/XProtocol.hh"
#include "XrdSec/XrdSecInterface.hh"
#include "XrdOuc/XrdOucEnv.hh"
 
class XrdSysPlugin;
class XrdSecProtect;
 
namespace XrdCl
{
  class Tls;
  class Socket;
  struct XRootDChannelInfo;
  struct PluginUnloadHandler;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class XRootDTransport: public TransportHandler
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDTransport();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~XRootDTransport();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus GetHeader( Message &message, Socket *socket );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus GetBody( Message &message, Socket *socket );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus GetMore( Message &message, Socket *socket );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void InitializeChannel( const URL  &url,
                                      AnyObject  &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void FinalizeChannel( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus HandShake( HandShakeData *handShakeData,
                                      AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      // @return true if handshake has been done and stream is connected,
      //         false otherwise
      //------------------------------------------------------------------------
      virtual bool HandShakeDone( HandShakeData *handShakeData,
                                  AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool IsStreamTTLElapsed( time_t     time,
                                       AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status IsStreamBroken( time_t     inactiveTime,
                                     AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual PathID Multiplex( Message   *msg,
                                AnyObject &channelData,
                                PathID    *hint = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual PathID MultiplexSubStream( Message   *msg,
                                         AnyObject &channelData,
                                         PathID    *hint = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t SubStreamNumber( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool NeedControlConnection()
      {
        return true;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static XRootDStatus MarshallRequest( Message *msg )
      {
        MarshallRequest( msg->GetBuffer() );
        msg->SetIsMarshalled( true );
        return XRootDStatus();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus MarshallRequest( char *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus UnMarshallRequest( Message *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus UnMarshallBody( Message *msg, uint16_t reqType );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus UnMarshalStatusBody( Message &msg, uint16_t reqType );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus UnMarchalStatusMore( Message &msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void UnMarshallHeader( Message &msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void LogErrorResponse( const Message &msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static uint16_t NbConnectedStrm( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void Disconnect( AnyObject &channelData,
                               uint16_t   subStreamId );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status Query( uint16_t   query,
                            AnyObject &result,
                            AnyObject &channelData );
 
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void GenerateDescription( char *msg, std::ostringstream &o );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static void SetDescription( Message *msg )
      {
        std::ostringstream o;
        GenerateDescription( msg->GetBuffer(), o );
        msg->SetDescription( o.str() );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint32_t MessageReceived( Message   &msg,
                                        uint16_t   subStream,
                                        AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void MessageSent( Message   *msg,
                                uint16_t   subStream,
                                uint32_t   bytesSent,
                                AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status GetSignature( Message *toSign, Message *&sign,
                                   AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status GetSignature( Message *toSign, Message *&sign,
                                   XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void DecFileInstCnt( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void WaitBeforeExit();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool NeedEncryption( HandShakeData  *handShakeData,
                                  AnyObject      &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual URL GetBindPreference( const URL  &url,
                                     AnyObject  &channelData );
 
    private:
 
      //------------------------------------------------------------------------
      // Hand shake the main stream
      //------------------------------------------------------------------------
      XRootDStatus HandShakeMain( HandShakeData *handShakeData,
                            AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      // Hand shake a parallel stream
      //------------------------------------------------------------------------
      XRootDStatus HandShakeParallel( HandShakeData *handShakeData,
                                AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      // Generate the message to be sent as an initial handshake
      // (handshake + kXR_protocol)
      //------------------------------------------------------------------------
      Message *GenerateInitialHSProtocol( HandShakeData     *hsData,
                                          XRootDChannelInfo *info,
                                          kXR_char           expect );
 
      //------------------------------------------------------------------------
      // Generate the protocol message
      //------------------------------------------------------------------------
      Message *GenerateProtocol( HandShakeData     *hsData,
                                 XRootDChannelInfo *info,
                                 kXR_char           expect );
 
      //------------------------------------------------------------------------
      // Initialize protocol request
      //------------------------------------------------------------------------
      void InitProtocolReq( ClientProtocolRequest *request,
                            XRootDChannelInfo     *info,
                            kXR_char               expect );
 
      //------------------------------------------------------------------------
      // Process the server initial handshake response
      //------------------------------------------------------------------------
      XRootDStatus ProcessServerHS( HandShakeData     *hsData,
                                    XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Process the protocol response
      //------------------------------------------------------------------------
      XRootDStatus ProcessProtocolResp( HandShakeData     *hsData,
                                        XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Process the protocol body:
      //  * 'B' : bind preferences
      //  * 'S' : security requirements
      //------------------------------------------------------------------------
      XRootDStatus ProcessProtocolBody( char              *bodybuff,
                                        size_t             bodysize,
                                        XRootDChannelInfo *info  );
 
      //------------------------------------------------------------------------
      // Generate the bind message
      //------------------------------------------------------------------------
      Message *GenerateBind( HandShakeData     *hsData,
                             XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Generate the bind message
      //------------------------------------------------------------------------
      XRootDStatus ProcessBindResp( HandShakeData     *hsData,
                                    XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Generate the login  message
      //------------------------------------------------------------------------
      Message *GenerateLogIn( HandShakeData     *hsData,
                              XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Process the login response
      //------------------------------------------------------------------------
      XRootDStatus ProcessLogInResp( HandShakeData     *hsData,
                               XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Do the authentication
      //------------------------------------------------------------------------
      XRootDStatus DoAuthentication( HandShakeData     *hsData,
                               XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Get the initial credentials using one of the protocols
      //------------------------------------------------------------------------
      XRootDStatus GetCredentials( XrdSecCredentials *&credentials,
                                   HandShakeData      *hsData,
                                   XRootDChannelInfo  *info );
 
      //------------------------------------------------------------------------
      // Clean up the data structures created for the authentication process
      //------------------------------------------------------------------------
      Status CleanUpAuthentication( XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Clean up the data structures created for the protection purposes
      //------------------------------------------------------------------------
      Status CleanUpProtection( XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Get the authentication function handle
      //------------------------------------------------------------------------
      XrdSecGetProt_t GetAuthHandler();
 
      //------------------------------------------------------------------------
      // Generate the end session message
      //------------------------------------------------------------------------
      Message *GenerateEndSession( HandShakeData     *hsData,
                                   XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Process the end session response
      //------------------------------------------------------------------------
      Status ProcessEndSessionResp( HandShakeData     *hsData,
                                    XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Get a string representation of the server flags
      //------------------------------------------------------------------------
      static std::string ServerFlagsToStr( uint32_t flags );
 
      //------------------------------------------------------------------------
      // Get a string representation of file handle
      //------------------------------------------------------------------------
      static std::string FileHandleToStr( const unsigned char handle[4] );
 
      friend struct PluginUnloadHandler;
      PluginUnloadHandler *pSecUnloadHandler;
  };
}
 
#endif // __XRD_CL_XROOTD_TRANSPORT_HANDLER_HH__