#include <FTP_ClientRequestHandler.h>

Inheritance diagram for ACE::FTP::ClientRequestHandler:

Collaboration diagram for ACE::FTP::ClientRequestHandler:

Classes
class	Authentication
class	SessionFactory
class	SessionHolder
Public Member Functions
	ClientRequestHandler (bool passive_mode=true)
virtual	~ClientRequestHandler ()
bool	uses_passive_mode () const
void	use_passive_mode ()
void	use_active_mode (u_short port=0)
u_short	uses_active_port () const
virtual Request &	request ()
virtual const Request &	request () const
virtual Response &	response ()
virtual const Response &	response () const
std::ostream &	request_stream ()
virtual std::istream &	response_stream ()
virtual bool	is_response_ok () const
virtual std::istream &	handle_open_request (const ACE::INet::URL_Base &url)
virtual std::istream &	handle_get_request (const URL &url, bool binary=true)
void	quit_connection ()
Static Public Attributes
static const ACE_CString	anonymous_user_ = "anonymous"
Protected Types
typedef Session_T< ACE_SYNCH > ::connection_type	connection_type
typedef ACE::IOS::Sock_IOStreamBase < ACE_SYNCH >	stream_type
Protected Member Functions
virtual void	on_eof ()
SessionHolder &	session ()
void	session (SessionHolder *session)
virtual bool	initialize_connection (const ACE_CString &host, u_short port)
virtual bool	handle_credentials (const URL &url, ACE_CString &user, ACE_CString &password)
virtual void	handle_request_error (const URL &url)
virtual void	handle_connection_error (const URL &url)
void	release_connection ()
void	close_connection ()
bool	login (const ACE_CString &user, const ACE_CString &password)
bool	logout ()
bool	is_valid_path (const ACE_CString &path)
bool	is_file (const ACE_CString &path)
bool	is_dir (const ACE_CString &path)
bool	set_filetype (bool binary)
stream_type *	start_download (const ACE_CString &path, bool binary)
stream_type *	start_upload (const ACE_CString &path, bool binary)
bool	finish_transfer ()
bool	abort_transfer ()
Response::StatusType	process_command (const ACE_CString &cmd, const ACE_CString &arg=empty_)
stream_type *	open_data_connection (const ACE_CString &cmd, const ACE_CString &arg)
bool	get_passive_address (ACE_INET_Addr &addr)
bool	parse_address (const ACE_CString &str, ACE_INET_Addr &addr)
bool	parse_ext_address (const ACE_CString &str, ACE_INET_Addr &addr)
bool	send_active_address (const ACE_INET_Addr &addr)
Static Protected Attributes
static const ACE_CString	empty_
Private Attributes
Request	request_
Response	response_
SessionHolder *	session_
bool	use_passive_mode_
u_short	active_port_
OStream	out_data_stream_
IStream	in_data_stream_
bool	transfer_active_
ACE_CString	current_user_

Detailed Description

Definition at line 48 of file FTP_ClientRequestHandler.h.

Member Typedef Documentation

typedef Session_T<ACE_SYNCH>::connection_type ACE::FTP::ClientRequestHandler::connection_type [protected]

Definition at line 93 of file FTP_ClientRequestHandler.h.

typedef ACE::IOS::Sock_IOStreamBase<ACE_SYNCH> ACE::FTP::ClientRequestHandler::stream_type [protected]

Definition at line 94 of file FTP_ClientRequestHandler.h.

Constructor & Destructor Documentation

ACE::FTP::ClientRequestHandler::ClientRequestHandler ( bool passive_mode = true )

Definition at line 105 of file FTP_ClientRequestHandler.cpp.

      {
        this->password_ = pw;
      }

    const ACE_CString ClientRequestHandler::anonymous_user_ = "anonymous";
    const ACE_CString ClientRequestHandler::empty_;

    ClientRequestHandler::ClientRequestHandler (bool passive_mode)
      : session_ (0),
        use_passive_mode_ (passive_mode),

ACE::FTP::ClientRequestHandler::~ClientRequestHandler ( ) [virtual]

Definition at line 117 of file FTP_ClientRequestHandler.cpp.

Member Function Documentation

bool ACE::FTP::ClientRequestHandler::abort_transfer ( ) [protected]

Definition at line 381 of file FTP_ClientRequestHandler.cpp.

      {
        if (transfer_active_)
          {
            this->session ()->send_interrupt ();
            this->process_command (Request::FTP_ABOR);
            if (this->response_.status () == 426)
              this->session ()->receive_response (this->response_);

            stream_type* old_stream = dynamic_cast<stream_type*> (this->in_data_stream_.set_stream (0));
              {
                // decrease ref count to 1
                const_cast<connection_type&> (old_stream->stream ()).remove_reference ();
                // also removes last ref count on stream handler
                delete old_stream;
              }
            old_stream = dynamic_cast<stream_type*> (this->out_data_stream_.set_stream (0));
              {
                // decrease ref count to 1
                const_cast<connection_type&> (old_stream->stream ()).remove_reference ();
                // also removes last ref count on stream handler
                delete old_stream;

void ACE::FTP::ClientRequestHandler::close_connection ( ) [protected]

Definition at line 246 of file FTP_ClientRequestHandler.cpp.

      {
        if (this->session_)

bool ACE::FTP::ClientRequestHandler::finish_transfer ( ) [protected]

Definition at line 353 of file FTP_ClientRequestHandler.cpp.

      {
        if (this->set_filetype (binary))
          {
            return this->open_data_connection (Request::FTP_STOR, path);
          }
        return 0;
      }

    bool ClientRequestHandler::finish_transfer ()
      {
        if (transfer_active_)
          {
            stream_type* old_stream = dynamic_cast<stream_type*> (this->in_data_stream_.set_stream (0));
            if (old_stream)
              {
                // decrease ref count to 1
                const_cast<connection_type&> (old_stream->stream ()).remove_reference ();
                // also removes last ref count on stream handler
                delete old_stream;
              }
            old_stream = dynamic_cast<stream_type*> (this->out_data_stream_.set_stream (0));
              {
                // decrease ref count to 1
                const_cast<connection_type&> (old_stream->stream ()).remove_reference ();
                // also removes last ref count on stream handler
                delete old_stream;
              }

bool ACE::FTP::ClientRequestHandler::get_passive_address ( ACE_INET_Addr & addr ) [protected]

Definition at line 570 of file FTP_ClientRequestHandler.cpp.

      {
        // can we use the RFC 2428 extensions?
        if (this->session ()->supports_ftp_extensions ())
          {
            if (this->process_command (Request::FTP_EPSV) == Response::COMPLETED_OK)
              {
                return this->parse_ext_address (this->response_.response ()[0],
                                            addr);
              }
            // flag RFC 2428 extensions as unsupported
            this->session ()->set_ftp_extension_support (false);
          }

void ACE::FTP::ClientRequestHandler::handle_connection_error ( const URL & url ) [protected, virtual]

Reimplemented in My_FTP_RequestHandler.

Definition at line 230 of file FTP_ClientRequestHandler.cpp.

bool ACE::FTP::ClientRequestHandler::handle_credentials	(	const URL &	url,
		ACE_CString &	user,
		ACE_CString &	password
	)			`[protected, virtual]`

Definition at line 216 of file FTP_ClientRequestHandler.cpp.

          {
            this->session (dynamic_cast<SessionHolder*> (pch));
            return true;
          }
        else
          return false;
      }

    bool ClientRequestHandler::handle_credentials (const URL& url,

std::istream & ACE::FTP::ClientRequestHandler::handle_get_request	(	const URL &	url,
		bool	binary = `true`
	)			`[virtual]`

Definition at line 136 of file FTP_ClientRequestHandler.cpp.

      {
        const URL& ftp_url = dynamic_cast<const URL&> (url);
        return this->handle_get_request (ftp_url);
      }

    std::istream& ClientRequestHandler::handle_get_request (
        const URL& ftp_url,
        bool binary)
      {
        if (this->initialize_connection (ftp_url.get_host (),
                                         ftp_url.get_port ()))
          {
            bool rc = true;
            if (this->session ()->is_new_connection () ||
                (!ftp_url.get_user_info ().empty () &&
                    ftp_url.get_user_info () != this->current_user_))
              {
                if (!this->session ()->is_new_connection ())
                  rc = this->logout ();

                if (rc)
                  {
                    ACE_CString user = ftp_url.get_user_info ().empty () ?
                        anonymous_user_ : ftp_url.get_user_info ();
                    ACE_CString password = user;
                    rc = this->handle_credentials (ftp_url, user, password);
                    if (rc) rc = this->login (user, password);
                  }
              }

            if (rc) rc = this->finish_transfer ();

            if (rc)
              {
                stream_type* data_stream =
                    this->start_download (ftp_url.get_path (), binary);
                if (data_stream)
                  {
                    // no need to check prev stream since we just called finish_transfer
                    // to clean everything up
                    this->in_data_stream_.set_stream (data_stream);
                  }
                else
                  {
                    rc = false;
                  }
              }

            if (!rc)
              {
                this->close_connection ();

                this->handle_request_error(ftp_url);
              }

std::istream & ACE::FTP::ClientRequestHandler::handle_open_request ( const ACE::INet::URL_Base & url ) [virtual]

Definition at line 129 of file FTP_ClientRequestHandler.cpp.

      {
        return this->response_.is_completed_ok () ||
               (this->response_.is_preliminary_ok () &&
                    !this->in_data_stream_.bad ());

void ACE::FTP::ClientRequestHandler::handle_request_error ( const URL & url ) [protected, virtual]

Reimplemented in My_FTP_RequestHandler.

Definition at line 226 of file FTP_ClientRequestHandler.cpp.

      {
        Authentication authentication (url.get_host(),

bool ACE::FTP::ClientRequestHandler::initialize_connection	(	const ACE_CString &	host,
		u_short	port
	)			`[protected, virtual]`

Definition at line 199 of file FTP_ClientRequestHandler.cpp.

      {
        this->finish_transfer ();
      }

    bool ClientRequestHandler::initialize_connection (const ACE_CString& host,
                                                      u_short port)
      {
        static const SessionFactory session_factory;

        ACE::INet::ConnectionHolder* pch = 0;
        if (this->connection_cache ().claim_connection (INetConnectionKey (host, port),
                                                        pch,

bool ACE::FTP::ClientRequestHandler::is_dir ( const ACE_CString & path ) [protected]

Definition at line 312 of file FTP_ClientRequestHandler.cpp.

      {
        return (this->is_valid_path (path) &&

bool ACE::FTP::ClientRequestHandler::is_file ( const ACE_CString & path ) [protected]

Definition at line 306 of file FTP_ClientRequestHandler.cpp.

bool ACE::FTP::ClientRequestHandler::is_response_ok ( ) const [virtual]

Definition at line 122 of file FTP_ClientRequestHandler.cpp.

      {
        this->release_connection ();

bool ACE::FTP::ClientRequestHandler::is_valid_path ( const ACE_CString & path ) [protected]

Definition at line 301 of file FTP_ClientRequestHandler.cpp.

              {
                this->process_command (Request::FTP_PASS, password);
              }

bool ACE::FTP::ClientRequestHandler::login	(	const ACE_CString &	user,
		const ACE_CString &	password
	)			`[protected]`

Definition at line 284 of file FTP_ClientRequestHandler.cpp.

      {
        // read startup message
        this->session ()->receive_response (this->response_);
        if (this->response_.is_completed_ok ())
          {
            // send user name

bool ACE::FTP::ClientRequestHandler::logout ( ) [protected]

Definition at line 264 of file FTP_ClientRequestHandler.cpp.

      {
        this->logout ();
        this->close_connection ();
      }

    bool ClientRequestHandler::logout ()
      {
        bool rc = true;
        if (this->session ()->is_connected ())
          {
            try
              {
                this->finish_transfer ();
              }
            catch (...)
              {

void ACE::FTP::ClientRequestHandler::on_eof ( void ) [protected, virtual]

Reimplemented from ACE::IOS::StreamInterceptorBase< ACE_CHAR_T, TR >.

Reimplemented in My_FTP_RequestHandler.

Definition at line 194 of file FTP_ClientRequestHandler.cpp.

          {
            this->handle_connection_error (ftp_url);
          }

ClientRequestHandler::stream_type * ACE::FTP::ClientRequestHandler::open_data_connection	(	const ACE_CString &	cmd,
		const ACE_CString &	arg
	)			`[protected]`

Definition at line 428 of file FTP_ClientRequestHandler.cpp.

          {
            this->response_(0);
          }
        return this->response_.status_type ();
      }

    ClientRequestHandler::stream_type*
    ClientRequestHandler::open_data_connection (const ACE_CString& cmd,
                                                const ACE_CString& arg)
      {
        if (this->use_passive_mode_)
          {
            // get address for passive data connection
            ACE_INET_Addr data_addr;
            if (this->get_passive_address (data_addr))
              {
                // establish data connection

                // copy sync settings from session
                unsigned long f_reactor =
                    this->session ()->is_reactive() ? ACE_Synch_Options::USE_REACTOR : 0;
                ACE_Synch_Options sync_opt (ACE_Synch_Options::USE_TIMEOUT | f_reactor,
                                            this->session ()->timeout ());

                typedef ACE_Connector<SessionHolder::session_type::connection_type,
                                      ACE_SOCK_CONNECTOR> connector_type;
                connector_type connector;

                // create connection object (stream handler)
                SessionHolder::session_type::connection_type* data_connection = 0;
                ACE_NEW_NORETURN (data_connection,
                                SessionHolder::session_type::connection_type(sync_opt));
                if (data_connection == 0)
                  {
                    return 0;
                  }

                // connect to data connection address
                if (connector.connect (data_connection,
                                       data_addr,
                                       ACE_Synch_Options (0,
                                                          this->session ()->timeout ())) == -1)
                  {
                    INET_ERROR (1, (LM_ERROR, DLINFO
                                ACE_TEXT ("(%d) ACE_FTP_ClientRequestHandler::open_data_connection - ")
                                ACE_TEXT ("failed to connect to %C:%d\n"),
                                ACE_OS::last_error (),
                                data_addr.get_host_name (),
                                data_addr.get_port_number ()));
                    // as the connection was dynamically allocated
                    // the connector causes it to be destroyed after
                    // the connection failure
                    return 0;
                  }

                // enable ref counting so we can control when to destroy
                data_connection->reference_counting_policy ().value (
                    ACE_Event_Handler::Reference_Counting_Policy::ENABLED);

                // create io stream for connection
                stream_type* data_stream = 0;
                ACE_NEW_NORETURN (data_stream,
                                  stream_type (data_connection));
                if (data_stream)
                  {
                    if (this->process_command (cmd, arg) == Response::PRELIM_OK)
                      return data_stream;

                    delete data_stream; // decreases ref count on connection
                  }
                // remove last ref count -> delete
                data_connection->remove_reference ();
              }
          }
        else
          {
            // address for active data connection
            ACE_INET_Addr data_addr;
            this->session ()->get_local_addr (data_addr);
            data_addr.set_port_number (this->active_port_);

            // copy sync settings from session
            unsigned long f_reactor =
                this->session ()->is_reactive() ? ACE_Synch_Options::USE_REACTOR : 0;
            ACE_Synch_Options sync_opt (ACE_Synch_Options::USE_TIMEOUT | f_reactor,
                                        this->session ()->timeout ());

            typedef ACE_Oneshot_Acceptor<SessionHolder::session_type::connection_type,
                                         ACE_SOCK_ACCEPTOR> acceptor_type;
            acceptor_type acceptor;

            // start data connection acceptor listening and retrieve actual listening address
            if (acceptor.open (data_addr) == 0 &&
                acceptor.acceptor ().get_local_addr (data_addr) == 0)
              {
                // send listen address to peer followed by data command to execute
                if (this->send_active_address (data_addr) &&
                    this->process_command (cmd, arg) == Response::PRELIM_OK)
                  {
                    // create connection object (stream handler)
                    SessionHolder::session_type::connection_type* data_connection = 0;
                    ACE_NEW_NORETURN (data_connection,
                                    SessionHolder::session_type::connection_type(sync_opt));
                    if (data_connection == 0)
                      {
                        return 0;
                      }

                    // accept data connection from peer
                    if (acceptor.accept (data_connection,
                                         0,
                                         ACE_Synch_Options (ACE_Synch_Options::USE_TIMEOUT,
                                                            this->session ()->timeout ())) == -1)
                      {
                        INET_ERROR (1, (LM_ERROR, DLINFO
                                    ACE_TEXT ("(%d) ACE_FTP_ClientRequestHandler::open_data_connection - ")
                                    ACE_TEXT ("failed to accept connection to %C:%d\n"),
                                    ACE_OS::last_error (),
                                    data_addr.get_host_name (),
                                    data_addr.get_port_number ()));

                        // as the connection was dynamically allocated
                        // the acceptor causes it to be destroyed after
                        // the connection failure
                        return 0;
                      }

                    // enable ref counting so we can control when to destroy
                    data_connection->reference_counting_policy ().value (
                        ACE_Event_Handler::Reference_Counting_Policy::ENABLED);

                    // create io stream for connection
                    stream_type* data_stream = 0;
                    ACE_NEW_NORETURN (data_stream,
                                      stream_type (data_connection));
                    if (data_stream)
                      {
                        return data_stream;

bool ACE::FTP::ClientRequestHandler::parse_address	(	const ACE_CString &	str,
		ACE_INET_Addr &	addr
	)			`[protected]`

Definition at line 593 of file FTP_ClientRequestHandler.cpp.

          {
            return this->parse_address (this->response_.response ()[0],
                                        addr);
          }
        return false;
      }

    bool
    ClientRequestHandler::parse_address (const ACE_CString& str, ACE_INET_Addr& addr)
      {
        static const int eof_ = std::char_traits<char>::eof ();

        ACE::IOS::CString_OStream sos_host;
        u_short port_hi = 0, port_lo = 0;

        ACE::IOS::CString_IStream sis (str);
        sis.ignore (str.length (), '(');
        int ch = sis.get ();
        if (ACE_OS::ace_isdigit (ch))
          {
            for (int i=0; i<4 ;++i)
              {
                if (ch == ',')
                  {
                    sos_host.put ('.');
                    ch = sis.get ();
                  }
                while (ch != eof_ && ACE_OS::ace_isdigit (ch))
                  {
                    sos_host.put (ch);
                    ch = sis.get ();
                  }
              }
            if (ch == ',')
              {
                sis >> port_hi;
                ch = sis.get ();
                if (ch == ',')
                  {
                    sis >> port_lo;

bool ACE::FTP::ClientRequestHandler::parse_ext_address	(	const ACE_CString &	str,
		ACE_INET_Addr &	addr
	)			`[protected]`

Definition at line 636 of file FTP_ClientRequestHandler.cpp.

      {
        static const int eof_ = std::char_traits<char>::eof ();

        ACE::IOS::CString_IStream sis (str);
        sis.ignore (str.length (), '(');
        int ch = sis.get ();
        if (ch != eof_)
          {
            int delim = ch;
            sis.ignore (str.length (), delim);
            sis.ignore (str.length (), delim);
            if (sis.peek () != eof_)
              {

Response::StatusType ACE::FTP::ClientRequestHandler::process_command	(	const ACE_CString &	cmd,
		const ACE_CString &	arg = `empty_`
	)			`[protected]`

Definition at line 413 of file FTP_ClientRequestHandler.cpp.

      {
        if (this->session ()->send_request (this->request_(cmd) << arg))
          {

void ACE::FTP::ClientRequestHandler::quit_connection ( )

Definition at line 258 of file FTP_ClientRequestHandler.cpp.

void ACE::FTP::ClientRequestHandler::release_connection ( ) [protected]

Definition at line 234 of file FTP_ClientRequestHandler.cpp.

      {
      }

    void ClientRequestHandler::handle_connection_error (const URL& /*url*/)
      {
      }

    void ClientRequestHandler::release_connection ()
      {
        if (this->session_)

Request & ACE::FTP::ClientRequestHandler::request ( ) [inline, virtual]

Definition at line 50 of file FTP_ClientRequestHandler.inl.

      {
        return this->request_;
      }

const Request & ACE::FTP::ClientRequestHandler::request ( ) const [inline, virtual]

Definition at line 56 of file FTP_ClientRequestHandler.inl.

      {
        return this->request_;
      }

std::ostream & ACE::FTP::ClientRequestHandler::request_stream ( ) [inline]

Definition at line 86 of file FTP_ClientRequestHandler.inl.

      {
        if (this->session_)
          return this->out_data_stream_;
        else
          return ACE::IOS::Null::out_stream_;
      }

const Response & ACE::FTP::ClientRequestHandler::response ( ) const [inline, virtual]

Definition at line 68 of file FTP_ClientRequestHandler.inl.

      {
        return this->response_;
      }

Response & ACE::FTP::ClientRequestHandler::response ( ) [inline, virtual]

Definition at line 62 of file FTP_ClientRequestHandler.inl.

      {
        return this->response_;
      }

std::istream & ACE::FTP::ClientRequestHandler::response_stream ( ) [inline, virtual]

Definition at line 95 of file FTP_ClientRequestHandler.inl.

      {
        if (this->session_)
          return this->in_data_stream_;
        else
          return ACE::IOS::Null::in_stream_;
      }

bool ACE::FTP::ClientRequestHandler::send_active_address ( const ACE_INET_Addr & addr ) [protected]

Definition at line 660 of file FTP_ClientRequestHandler.cpp.

      {
        ACE::IOS::CString_OStream arg;
        char ip_buf[128];
        if (addr.get_host_addr (ip_buf, sizeof(ip_buf)) == 0)
          {
            return false;
          }
        u_short port = addr.get_port_number ();
        // can we use the RFC 2428 extensions?
        if (this->session ()->supports_ftp_extensions ())
          {
            arg << '|'
                << (addr.get_type () == AF_INET ? '1' : '2')
                << '|'
                << (&ip_buf[0])
                << '|'
                << port
                << '|';
            if (this->process_command (Request::FTP_EPRT, arg.str ()) == Response::COMPLETED_OK)
              {
                return true;
              }
            // flag RFC 2428 extensions as unsupported
            this->session ()->set_ftp_extension_support (false);

            arg.clear ();
          }
        // use 'old' command
        ACE_CString ip_addr = addr.get_host_addr (ip_buf, sizeof(ip_buf));
        ACE_CString::size_type pos;
        while ((pos = ip_addr.find ('.')) != ACE_CString::npos)
          {

void ACE::FTP::ClientRequestHandler::session ( SessionHolder * session ) [inline, protected]

Definition at line 80 of file FTP_ClientRequestHandler.inl.

      {
        this->session_ = session;
      }

ClientRequestHandler::SessionHolder & ACE::FTP::ClientRequestHandler::session ( ) [inline, protected]

Definition at line 74 of file FTP_ClientRequestHandler.inl.

      {
        return *this->session_;
      }

bool ACE::FTP::ClientRequestHandler::set_filetype ( bool binary ) [protected]

Definition at line 318 of file FTP_ClientRequestHandler.cpp.

ClientRequestHandler::stream_type * ACE::FTP::ClientRequestHandler::start_download	(	const ACE_CString &	path,
		bool	binary
	)			`[protected]`

Definition at line 324 of file FTP_ClientRequestHandler.cpp.

      {
        return this->process_command (Request::FTP_TYPE, binary ? "I" : "A") == Response::COMPLETED_OK;
      }

    ClientRequestHandler::stream_type*
    ClientRequestHandler::start_download (const ACE_CString& path, bool binary)
      {
        if (path.empty () || this->is_dir (path))
          {
            if (this->set_filetype (false))
              {
                return this->open_data_connection (Request::FTP_LIST, path);
              }
          }
        else

ClientRequestHandler::stream_type * ACE::FTP::ClientRequestHandler::start_upload	(	const ACE_CString &	path,
		bool	binary
	)			`[protected]`

Definition at line 344 of file FTP_ClientRequestHandler.cpp.

              {
                return this->open_data_connection (Request::FTP_RETR, path);
              }
          }
        return 0;
      }

    ClientRequestHandler::stream_type*

void ACE::FTP::ClientRequestHandler::use_active_mode ( u_short port = 0 ) [inline]

Definition at line 36 of file FTP_ClientRequestHandler.inl.

      {
        this->use_passive_mode_ = false;
        this->active_port_ = port;
      }

void ACE::FTP::ClientRequestHandler::use_passive_mode ( ) [inline]

Definition at line 30 of file FTP_ClientRequestHandler.inl.

      {
        this->use_passive_mode_ = true;
      }

u_short ACE::FTP::ClientRequestHandler::uses_active_port ( ) const [inline]

Definition at line 43 of file FTP_ClientRequestHandler.inl.

      {
        return this->active_port_;
      }

bool ACE::FTP::ClientRequestHandler::uses_passive_mode ( ) const [inline]

Definition at line 24 of file FTP_ClientRequestHandler.inl.

      {
        return this->use_passive_mode_;
      }

Member Data Documentation

u_short ACE::FTP::ClientRequestHandler::active_port_ [private]

Definition at line 215 of file FTP_ClientRequestHandler.h.

const ACE_CString ACE::FTP::ClientRequestHandler::anonymous_user_ = "anonymous" [static]

Definition at line 88 of file FTP_ClientRequestHandler.h.

ACE_CString ACE::FTP::ClientRequestHandler::current_user_ [private]

Definition at line 221 of file FTP_ClientRequestHandler.h.

const ACE_CString ACE::FTP::ClientRequestHandler::empty_ [static, protected]

Definition at line 91 of file FTP_ClientRequestHandler.h.

IStream ACE::FTP::ClientRequestHandler::in_data_stream_ [private]

Definition at line 218 of file FTP_ClientRequestHandler.h.

OStream ACE::FTP::ClientRequestHandler::out_data_stream_ [private]

Definition at line 217 of file FTP_ClientRequestHandler.h.

Request ACE::FTP::ClientRequestHandler::request_ [private]

Definition at line 211 of file FTP_ClientRequestHandler.h.

Response ACE::FTP::ClientRequestHandler::response_ [private]

Definition at line 212 of file FTP_ClientRequestHandler.h.

SessionHolder* ACE::FTP::ClientRequestHandler::session_ [private]

Definition at line 213 of file FTP_ClientRequestHandler.h.

bool ACE::FTP::ClientRequestHandler::transfer_active_ [private]

Definition at line 219 of file FTP_ClientRequestHandler.h.

bool ACE::FTP::ClientRequestHandler::use_passive_mode_ [private]

Definition at line 214 of file FTP_ClientRequestHandler.h.

The documentation for this class was generated from the following files:

ACE::FTP::ClientRequestHandler Class Reference

Classes

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation