ACE/protocols/ace/INet/FTP_Session.cpp

   1 #ifndef ACE_FTP_SESSION_CPP
   2 #define ACE_FTP_SESSION_CPP
   3
   4 #include "ace/INet/INet_Log.h"
   5 #include "ace/INet/FTP_Session.h"
   6 #include "ace/INet/String_IOStream.h"
   7 #include "ace/INet/IOS_util.h"
   8 #include "ace/INET_Addr.h"
   9 #include "ace/Event_Handler.h"
  10 #include "ace/Connector.h"
  11 #include "ace/String_Base.h"
  12 #include "ace/Truncate.h"
  13 #include <istream>
  14 #include <ostream>
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 namespace ACE
  19 {
  20   namespace FTP
  21   {
  22     template <ACE_SYNCH_DECL>
  23     Session_T<ACE_SYNCH_USE>::Session_T ()
  24       : port_ (FTP_PORT),
  25         reactive_ (false),
  26         connection_ (0),
  27         sock_stream_ (0),
  28         ftp_timeout_ (DEFAULT_TIMEOUT),
  29         cannot_reconnect_ (false),
  30         has_ftp_ext_ (true),
  31         new_connect_ (true)
  32       {
  33         INET_TRACE ("ACE_FTP_Session - ctor");
  34       }
  35
  36     template <ACE_SYNCH_DECL>
  37     Session_T<ACE_SYNCH_USE>::Session_T (const ACE_Time_Value& timeout)
  38       : port_ (FTP_PORT),
  39         reactive_ (false),
  40         connection_ (0),
  41         sock_stream_ (0),
  42         ftp_timeout_ (timeout),
  43         cannot_reconnect_ (false),
  44         has_ftp_ext_ (true),
  45         new_connect_ (true)
  46       {
  47         INET_TRACE ("ACE_FTP_Session - ctor");
  48       }
  49
  50     template <ACE_SYNCH_DECL>
  51     Session_T<ACE_SYNCH_USE>::~Session_T ()
  52       {
  53         INET_TRACE ("ACE_FTP_Session - dtor");
  54         this->close ();
  55       }
  56
  57     template <ACE_SYNCH_DECL>
  58     bool Session_T<ACE_SYNCH_USE>::is_connected () const
  59       {
  60         return this->connection_ && this->connection_->is_connected ();
  61       }
  62
  63     template <ACE_SYNCH_DECL>
  64     bool Session_T<ACE_SYNCH_USE>::is_new_connection () const
  65       {
  66         return this->new_connect_;
  67       }
  68
  69     template <ACE_SYNCH_DECL>
  70     void Session_T<ACE_SYNCH_USE>::set_host (const ACE_CString& host, u_short port)
  71       {
  72         if (!this->is_connected ())
  73           {
  74             this->host_ = host;
  75             this->port_ = port;
  76           }
  77       }
  78
  79     template <ACE_SYNCH_DECL>
  80     void Session_T<ACE_SYNCH_USE>::set_host (const ACE_CString& host)
  81       {
  82         if (!this->is_connected ())
  83           {
  84             this->host_ = host;
  85           }
  86       }
  87
  88     template <ACE_SYNCH_DECL>
  89     void Session_T<ACE_SYNCH_USE>::set_port (u_short port)
  90       {
  91         if (!this->is_connected ())
  92           {
  93             this->port_ = port;
  94           }
  95       }
  96
  97     template <ACE_SYNCH_DECL>
  98     const ACE_CString& Session_T<ACE_SYNCH_USE>::get_host () const
  99       {
 100         return this->host_;
 101       }
 102
 103     template <ACE_SYNCH_DECL>
 104     u_short Session_T<ACE_SYNCH_USE>::get_port () const
 105       {
 106         return this->port_;
 107       }
 108
 109     template <ACE_SYNCH_DECL>
 110     bool Session_T<ACE_SYNCH_USE>::connect (bool use_reactor)
 111       {
 112         INET_TRACE ("ACE_FTP_Session::connect");
 113
 114         typedef ACE_Connector<connection_type, ACE_SOCK_CONNECTOR> connector_type;
 115
 116         this->close ();
 117
 118         unsigned long f_reactor = use_reactor ? ACE_Synch_Options::USE_REACTOR : 0;
 119         ACE_Synch_Options sync_opt (ACE_Synch_Options::USE_TIMEOUT | f_reactor,
 120                                     this->ftp_timeout_);
 121         connector_type connector;
 122
 123         connection_type* new_connection = 0;
 124         ACE_NEW_RETURN (new_connection,
 125                         connection_type(sync_opt),
 126                         false);
 127         if (connector.connect (new_connection,
 128                                ACE_INET_Addr (this->port_,
 129                                               this->host_.c_str ()),
 130                                ACE_Synch_Options (0,this->ftp_timeout_)) == -1)
 131           {
 132             INET_ERROR (1, (LM_ERROR, DLINFO
 133                             ACE_TEXT ("(%d) ACE_FTP_Session::connect - ")
 134                             ACE_TEXT ("failed to connect; host=%C, port=%d"),
 135                             ACE_OS::last_error (), this->host_.c_str (), this->port_));
 136             // as the connection was dynamically allocated
 137             // the connector causes it to be destroyed after
 138             // the connection failure
 139             return false;
 140           }
 141
 142         this->connection_ = new_connection;
 143         this->connection_->reference_counting_policy ().value (
 144             ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
 145
 146         ACE_NEW_NORETURN (this->sock_stream_,
 147                           sock_stream_type (this->connection_));
 148         if (this->sock_stream_)
 149           {
 150             this->new_connect_ = true;
 151             this->cannot_reconnect_ = false;
 152             this->reactive_ = use_reactor;
 153
 154             return true;
 155           }
 156         else
 157           {
 158             this->close ();
 159             return false;
 160           }
 161       }
 162
 163     template <ACE_SYNCH_DECL>
 164     bool Session_T<ACE_SYNCH_USE>::connect (connection_type* connection)
 165       {
 166         INET_TRACE ("ACE_FTP_Session::connect(connection)");
 167
 168         this->close ();
 169
 170         if (connection->is_connected ())
 171           {
 172             ACE_INET_Addr remote;
 173             connection->peer ().get_remote_addr (remote);
 174             this->host_ = remote.get_host_name ();
 175             this->port_ = remote.get_port_number ();
 176           }
 177         else
 178           {
 179             typedef ACE_Connector<connection_type, ACE_SOCK_CONNECTOR> connector_type;
 180
 181             connector_type connector;
 182             if (connector.connect (connection,
 183                                    ACE_INET_Addr (this->host_.c_str (),
 184                                                   this->port_)) == -1)
 185               {
 186                 INET_ERROR (1, (LM_ERROR, DLINFO
 187                                 ACE_TEXT ("(%d) ACE_FTP_Session::connect(connection) - ")
 188                                 ACE_TEXT ("failed to connect; host=%C, port=%d"),
 189                                 ACE_OS::last_error (), this->host_.c_str (), this->port_));
 190                 return false;
 191               }
 192           }
 193
 194         this->connection_ = connection;
 195         this->connection_->add_reference ();
 196
 197         ACE_NEW_NORETURN (this->sock_stream_,
 198                           sock_stream_type (this->connection_));
 199
 200         if (this->sock_stream_)
 201           {
 202             this->new_connect_ = true;
 203             this->cannot_reconnect_ = true;
 204             return true;
 205           }
 206         else
 207           {
 208             this->close ();
 209             return false;
 210           }
 211       }
 212
 213     template <ACE_SYNCH_DECL>
 214     bool Session_T<ACE_SYNCH_USE>::send_request (Request& request)
 215       {
 216         INET_TRACE ("ACE_FTP_Session::send_request");
 217
 218         if (!this->is_connected ())
 219           {
 220             if (this->cannot_reconnect_ || !this->connect(this->reactive_))
 221               {
 222                 if (!this->cannot_reconnect_)
 223                   INET_ERROR (1, (LM_ERROR, DLINFO
 224                                   ACE_TEXT ("(%d) FTP_Session::send_request - ")
 225                                   ACE_TEXT ("reconnect failed\n"),
 226                                   ACE_OS::last_error ()));
 227                 return false;
 228               }
 229           }
 230
 231         this->new_connect_ = false;
 232
 233         request.write (*this->sock_stream_);
 234
 235         return this->is_connected () && this->sock_stream_->good ();
 236       }
 237
 238     template <ACE_SYNCH_DECL>
 239     bool Session_T<ACE_SYNCH_USE>::receive_response (Response& response)
 240       {
 241         INET_TRACE ("ACE_FTP_Session::receive_response");
 242
 243         this->sock_stream_->flush ();
 244
 245         response.reset ();
 246         return response.read (*this->sock_stream_);
 247       }
 248
 249     template <ACE_SYNCH_DECL>
 250     bool Session_T<ACE_SYNCH_USE>::send_interrupt ()
 251       {
 252         INET_TRACE ("ACE_FTP_Session::send_interrupt");
 253
 254         if (this->is_connected ())
 255           {
 256             this->sock_stream_->put (ACE_Utils::truncate_cast<char> (int (INTERRUPT)));
 257             this->sock_stream_->sync ();
 258             return this->sock_stream_->good ();
 259           }
 260
 261         return false;
 262       }
 263
 264     template <ACE_SYNCH_DECL>
 265     void Session_T<ACE_SYNCH_USE>::close ()
 266       {
 267         INET_TRACE ("ACE_FTP_Session::close");
 268
 269         if (this->connection_)
 270           {
 271             if (this->sock_stream_)
 272               {
 273                 delete this->sock_stream_;
 274                 this->sock_stream_ = 0;
 275               }
 276             // this should be the last referece and removing it
 277             // causes the connection to be destroyed
 278             this->connection_->remove_reference ();
 279             this->connection_ = 0;
 280           }
 281       }
 282
 283     template <ACE_SYNCH_DECL>
 284     bool Session_T<ACE_SYNCH_USE>::supports_ftp_extensions () const
 285       {
 286         return this->has_ftp_ext_;
 287       }
 288
 289     template <ACE_SYNCH_DECL>
 290     void Session_T<ACE_SYNCH_USE>::set_ftp_extension_support (bool f)
 291       {
 292         this->has_ftp_ext_ = f;
 293       }
 294
 295     template <ACE_SYNCH_DECL>
 296     bool Session_T<ACE_SYNCH_USE>::is_reactive () const
 297       {
 298         return this->reactive_;
 299       }
 300
 301     template <ACE_SYNCH_DECL>
 302     const ACE_Time_Value& Session_T<ACE_SYNCH_USE>::timeout () const
 303       {
 304         return this->ftp_timeout_;
 305       }
 306
 307     template <ACE_SYNCH_DECL>
 308     void Session_T<ACE_SYNCH_USE>::get_local_addr (ACE_INET_Addr& loc_addr) const
 309       {
 310         if (this->is_connected ())
 311           this->connection_->peer ().get_local_addr (loc_addr);
 312       }
 313
 314   }
 315 }
 316
 317 ACE_END_VERSIONED_NAMESPACE_DECL
 318
 319 #endif /* ACE_FTP_SESSION_CPP */