ACE/protocols/ace/INet/FTP_ClientRequestHandler.h

   1 /**
   2  * @file FTP_ClientRequestHandler.h
   3  *
   4  * @author Martin Corino <mcorino@remedy.nl>
   5  */
   6
   7 #ifndef ACE_FTP_CLIENT_REQUEST_HANDLER_H
   8 #define ACE_FTP_CLIENT_REQUEST_HANDLER_H
   9
  10 #include /**/ "ace/pre.h"
  11
  12 #include /**/ "ace/config-all.h"
  13
  14 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  15 # pragma once
  16 #endif /* ACE_LACKS_PRAGMA_ONCE */
  17
  18 #include "ace/Synch_Traits.h"
  19 #include "ace/Thread_Mutex.h"
  20 #include "ace/INet/INet_Export.h"
  21 #include "ace/INet/IOS_util.h"
  22 #include "ace/INet/StreamInterceptor.h"
  23 #include "ace/INet/ClientRequestHandler.h"
  24 #include "ace/INet/FTP_Request.h"
  25 #include "ace/INet/FTP_Response.h"
  26 #include "ace/INet/FTP_Session.h"
  27 #include "ace/INet/FTP_URL.h"
  28 #include "ace/INet/FTP_IOStream.h"
  29 #include "ace/INet/Sock_IOStream.h"
  30
  31 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  32
  33 namespace ACE
  34   {
  35     namespace FTP
  36       {
  37         /**
  38         * @class ACE_FTP_ClientRequestHandler
  39         *
  40         * @brief This class implements clientside request handling
  41         *   for FTP URLs.
  42         *
  43         * The class supports the FTP protocol as specified in RFCs 959
  44         * and 2428.
  45         */
  46         class ACE_INET_Export ClientRequestHandler
  47           : public ACE::INet::ClientINetRequestHandler,
  48             public ACE::IOS::StreamInterceptor
  49           {
  50             public:
  51               ClientRequestHandler (bool passive_mode = true);
  52               virtual ~ClientRequestHandler ();
  53
  54               bool uses_passive_mode () const;
  55
  56               void use_passive_mode ();
  57
  58               void use_active_mode (u_short port = 0);
  59
  60               u_short uses_active_port () const;
  61
  62               virtual Request& request ();
  63
  64               virtual const Request& request () const;
  65
  66               virtual Response& response ();
  67
  68               virtual const Response& response () const;
  69
  70               std::ostream& request_stream ();
  71
  72               virtual std::istream& response_stream ();
  73
  74               virtual bool is_response_ok () const;
  75
  76               virtual std::istream& handle_open_request (const ACE::INet::URL_Base& url);
  77
  78               virtual std::istream& handle_get_request (const URL& url, bool binary=true);
  79 /*
  80               virtual std::ostream& start_put_request (const URL& url, bool binary=true);
  81
  82               virtual bool finish_put_request ();
  83 */
  84               void quit_connection ();
  85
  86               static const ACE_CString anonymous_user_;
  87
  88             protected:
  89               static const ACE_CString empty_;
  90
  91               typedef Session_T<ACE_SYNCH>::connection_type connection_type;
  92               typedef ACE::IOS::Sock_IOStreamBase<ACE_SYNCH> stream_type;
  93
  94               virtual void on_eof ();
  95
  96               class Authentication
  97                 : public ACE::INet::AuthenticationBase
  98                 {
  99                   public:
 100                     Authentication (const ACE_CString& realm,
 101                                     ACE_CString& user,
 102                                     ACE_CString& pw);
 103
 104                     virtual ~Authentication ();
 105
 106                     virtual const ACE_CString& scheme () const;
 107
 108                     virtual const ACE_CString& realm () const;
 109
 110                     virtual const ACE_CString& user () const;
 111
 112                     virtual void user (const ACE_CString& usr);
 113
 114                     virtual const ACE_CString& password () const;
 115
 116                     virtual void password (const ACE_CString& pw);
 117
 118                   private:
 119                     const ACE_CString& realm_;
 120                     ACE_CString& user_;
 121                     ACE_CString& password_;
 122                 };
 123
 124               class SessionHolder
 125                 : public ACE::INet::ConnectionHolder
 126                 {
 127                   public:
 128                     typedef Session_T<ACE_SYNCH> session_type;
 129
 130                     SessionHolder ();
 131                     virtual ~SessionHolder();
 132
 133                     session_type& operator *();
 134                     session_type* operator ->();
 135
 136                   private:
 137                     session_type session_;
 138                 };
 139
 140               class SessionFactory
 141                 : public ACE::INet::ConnectionFactory
 142                 {
 143                   public:
 144                     SessionFactory ();
 145                     virtual ~SessionFactory ();
 146
 147                     virtual ACE::INet::ConnectionHolder* create_connection (
 148                         const ACE::INet::ConnectionKey& key) const;
 149                 };
 150
 151               SessionHolder& session ();
 152
 153               void session (SessionHolder* session);
 154
 155               virtual bool initialize_connection (const ACE_CString& host,
 156                                                   u_short port);
 157
 158               virtual bool handle_credentials (const URL& url,
 159                                                ACE_CString& user,
 160                                                ACE_CString& password);
 161
 162               virtual void handle_request_error (const URL& url);
 163
 164               virtual void handle_connection_error (const URL& url);
 165
 166               void release_connection ();
 167
 168               void close_connection ();
 169
 170               /*
 171                * FTP protocol helpers
 172                */
 173
 174               bool login (const ACE_CString& user, const ACE_CString& password);
 175
 176               bool logout ();
 177
 178               bool is_valid_path (const ACE_CString& path);
 179
 180               bool is_file (const ACE_CString& path);
 181
 182               bool is_dir (const ACE_CString& path);
 183
 184               bool set_filetype (bool binary);
 185
 186               stream_type* start_download (const ACE_CString& path, bool binary);
 187
 188               stream_type* start_upload (const ACE_CString& path, bool binary);
 189
 190               bool finish_transfer ();
 191
 192               bool abort_transfer ();
 193
 194               Response::StatusType process_command (const ACE_CString& cmd,
 195                                                     const ACE_CString& arg = empty_);
 196
 197               stream_type* open_data_connection (const ACE_CString& cmd,
 198                                                  const ACE_CString& arg);
 199
 200               bool get_passive_address (ACE_INET_Addr& addr);
 201
 202               bool parse_address (const ACE_CString& str, ACE_INET_Addr& addr);
 203
 204               bool parse_ext_address (const ACE_CString& str, ACE_INET_Addr& addr);
 205
 206               bool send_active_address (const ACE_INET_Addr& addr);
 207
 208             private:
 209               Request request_;
 210               Response response_;
 211               SessionHolder* session_;
 212               bool use_passive_mode_;
 213               u_short active_port_;
 214
 215               OStream out_data_stream_;
 216               IStream in_data_stream_;
 217               bool transfer_active_;
 218
 219               ACE_CString current_user_;
 220           };
 221       }
 222   }
 223
 224 ACE_END_VERSIONED_NAMESPACE_DECL
 225
 226 #if defined (__ACE_INLINE__)
 227 #include "ace/INet/FTP_ClientRequestHandler.inl"
 228 #endif
 229
 230 #include /**/ "ace/post.h"
 231 #endif /* ACE_INET_CLIENT_REQUEST_HANDLER_H */