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 "XProtocol/XProtocol.hh"
#include "XrdSec/XrdSecInterface.hh"
#include "XrdOuc/XrdOucEnv.hh"
 
class XrdSysPlugin;
class XrdSecProtect;
 
namespace XrdCl
{
  struct XRootDChannelInfo;
  struct PluginUnloadHandler;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct XRootDQuery
  {
    static const uint16_t ServerFlags     = 1002; 
    static const uint16_t ProtocolVersion = 1003; 
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class XRootDTransport: public TransportHandler
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDTransport();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~XRootDTransport();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status GetHeader( Message *message, int socket );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status GetBody( Message *message, int socket );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void InitializeChannel( AnyObject &channelData ); //< we keep this as we need to implement the abstract method
      virtual void InitializeChannel( const URL  &url, AnyObject  &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void FinalizeChannel( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status HandShake( HandShakeData *handShakeData,
                                AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool IsStreamTTLElapsed( time_t     time,
                                       uint16_t   streamId,
                                       AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status IsStreamBroken( time_t     inactiveTime,
                                     uint16_t   streamId,
                                     AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual PathID Multiplex( Message   *msg,
                                AnyObject &channelData,
                                PathID    *hint = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual PathID MultiplexSubStream( Message   *msg,
                                         uint16_t   streamId,
                                         AnyObject &channelData,
                                         PathID    *hint = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t StreamNumber( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t SubStreamNumber( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool NeedControlConnection()
      {
        return true;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status MarshallRequest( Message *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status UnMarshallRequest( Message *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status UnMarshallBody( Message *msg, uint16_t reqType );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void UnMarshallHeader( Message *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void LogErrorResponse( const Message &msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static uint16_t NbConnectedStrm( AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void Disconnect( AnyObject &channelData,
                               uint16_t   streamId,
                               uint16_t   subStreamId );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status Query( uint16_t   query,
                            AnyObject &result,
                            AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void SetDescription( Message *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint32_t MessageReceived( Message   *msg,
                                        uint16_t   streamId,
                                        uint16_t   subStream,
                                        AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void MessageSent( Message   *msg,
                                uint16_t   streamId,
                                uint16_t   subStream,
                                uint32_t   bytesSent,
                                AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status GetSignature( Message *toSign, Message *&sign,
                                   AnyObject &channelData );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Status GetSignature( Message *toSign, Message *&sign, XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Status ClassifyErrno( int error );
 
    private:
 
      //------------------------------------------------------------------------
      // Hand shake the main stream
      //------------------------------------------------------------------------
      Status HandShakeMain( HandShakeData *handShakeData,
                            AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      // Hand shake a parallel stream
      //------------------------------------------------------------------------
      Status HandShakeParallel( HandShakeData *handShakeData,
                                AnyObject     &channelData );
 
      //------------------------------------------------------------------------
      // Generate the message to be sent as an initial handshake
      //------------------------------------------------------------------------
      Message *GenerateInitialHS( HandShakeData     *hsData,
                                  XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Generate the message to be sent as an initial handshake
      // (handshake + kXR_protocol)
      //------------------------------------------------------------------------
      Message *GenerateInitialHSProtocol( HandShakeData     *hsData,
                                          XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Process the server initial handshake response
      //------------------------------------------------------------------------
      Status ProcessServerHS( HandShakeData     *hsData,
                              XRootDChannelInfo *info );
 
      //-----------------------------------------------------------------------
      // Process the protocol response
      //------------------------------------------------------------------------
      Status ProcessProtocolResp( HandShakeData     *hsData,
                                  XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Generate the bind message
      //------------------------------------------------------------------------
      Message *GenerateBind( HandShakeData     *hsData,
                             XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Generate the bind message
      //------------------------------------------------------------------------
      Status ProcessBindResp( HandShakeData     *hsData,
                              XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Generate the login  message
      //------------------------------------------------------------------------
      Message *GenerateLogIn( HandShakeData     *hsData,
                              XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Process the login response
      //------------------------------------------------------------------------
      Status ProcessLogInResp( HandShakeData     *hsData,
                               XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Do the authentication
      //------------------------------------------------------------------------
      Status DoAuthentication( HandShakeData     *hsData,
                               XRootDChannelInfo *info );
 
      //------------------------------------------------------------------------
      // Get the initial credentials using one of the protocols
      //------------------------------------------------------------------------
      Status 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__