net/ftp/ftp_network_transaction.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_FTP_FTP_NETWORK_TRANSACTION_H_
   6 #define NET_FTP_FTP_NETWORK_TRANSACTION_H_
   7
   8 #include <string>
   9 #include <utility>
  10
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "net/base/address_list.h"
  15 #include "net/base/auth.h"
  16 #include "net/base/net_log.h"
  17 #include "net/dns/host_resolver.h"
  18 #include "net/dns/single_request_host_resolver.h"
  19 #include "net/ftp/ftp_ctrl_response_buffer.h"
  20 #include "net/ftp/ftp_response_info.h"
  21 #include "net/ftp/ftp_transaction.h"
  22
  23 namespace net {
  24
  25 class ClientSocketFactory;
  26 class FtpNetworkSession;
  27 class StreamSocket;
  28
  29 class NET_EXPORT_PRIVATE FtpNetworkTransaction : public FtpTransaction {
  30  public:
  31   FtpNetworkTransaction(FtpNetworkSession* session,
  32                         ClientSocketFactory* socket_factory);
  33   virtual ~FtpNetworkTransaction();
  34
  35   virtual int Stop(int error);
  36   virtual int RestartIgnoringLastError(const CompletionCallback& callback);
  37
  38   // FtpTransaction methods:
  39   virtual int Start(const FtpRequestInfo* request_info,
  40                     const CompletionCallback& callback,
  41                     const BoundNetLog& net_log) OVERRIDE;
  42   virtual int RestartWithAuth(const AuthCredentials& credentials,
  43                               const CompletionCallback& callback) OVERRIDE;
  44   virtual int Read(IOBuffer* buf, int buf_len,
  45                    const CompletionCallback& callback) OVERRIDE;
  46   virtual const FtpResponseInfo* GetResponseInfo() const OVERRIDE;
  47   virtual LoadState GetLoadState() const OVERRIDE;
  48   virtual uint64 GetUploadProgress() const OVERRIDE;
  49
  50  private:
  51   FRIEND_TEST_ALL_PREFIXES(FtpNetworkTransactionTest,
  52                            DownloadTransactionEvilPasvUnsafeHost);
  53
  54   enum Command {
  55     COMMAND_NONE,
  56     COMMAND_USER,
  57     COMMAND_PASS,
  58     COMMAND_SYST,
  59     COMMAND_TYPE,
  60     COMMAND_EPSV,
  61     COMMAND_PASV,
  62     COMMAND_PWD,
  63     COMMAND_SIZE,
  64     COMMAND_RETR,
  65     COMMAND_CWD,
  66     COMMAND_LIST,
  67     COMMAND_QUIT,
  68   };
  69
  70   // Major categories of remote system types, as returned by SYST command.
  71   enum SystemType {
  72     SYSTEM_TYPE_UNKNOWN,
  73     SYSTEM_TYPE_UNIX,
  74     SYSTEM_TYPE_WINDOWS,
  75     SYSTEM_TYPE_OS2,
  76     SYSTEM_TYPE_VMS,
  77   };
  78
  79   // Data representation type, see RFC 959 section 3.1.1. Data Types.
  80   // We only support the two most popular data types.
  81   enum DataType {
  82     DATA_TYPE_ASCII,
  83     DATA_TYPE_IMAGE,
  84   };
  85
  86   // In FTP we need to issue different commands depending on whether a resource
  87   // is a file or directory. If we don't know that, we're going to autodetect
  88   // it.
  89   enum ResourceType {
  90     RESOURCE_TYPE_UNKNOWN,
  91     RESOURCE_TYPE_FILE,
  92     RESOURCE_TYPE_DIRECTORY,
  93   };
  94
  95   enum State {
  96     // Control connection states:
  97     STATE_CTRL_RESOLVE_HOST,
  98     STATE_CTRL_RESOLVE_HOST_COMPLETE,
  99     STATE_CTRL_CONNECT,
 100     STATE_CTRL_CONNECT_COMPLETE,
 101     STATE_CTRL_READ,
 102     STATE_CTRL_READ_COMPLETE,
 103     STATE_CTRL_WRITE,
 104     STATE_CTRL_WRITE_COMPLETE,
 105     STATE_CTRL_WRITE_USER,
 106     STATE_CTRL_WRITE_PASS,
 107     STATE_CTRL_WRITE_SYST,
 108     STATE_CTRL_WRITE_TYPE,
 109     STATE_CTRL_WRITE_EPSV,
 110     STATE_CTRL_WRITE_PASV,
 111     STATE_CTRL_WRITE_PWD,
 112     STATE_CTRL_WRITE_RETR,
 113     STATE_CTRL_WRITE_SIZE,
 114     STATE_CTRL_WRITE_CWD,
 115     STATE_CTRL_WRITE_LIST,
 116     STATE_CTRL_WRITE_QUIT,
 117     // Data connection states:
 118     STATE_DATA_CONNECT,
 119     STATE_DATA_CONNECT_COMPLETE,
 120     STATE_DATA_READ,
 121     STATE_DATA_READ_COMPLETE,
 122     STATE_NONE
 123   };
 124
 125   // Resets the members of the transaction so it can be restarted.
 126   void ResetStateForRestart();
 127
 128   // Resets the data connection after an error and switches to |next_state|.
 129   void ResetDataConnectionAfterError(State next_state);
 130
 131   void DoCallback(int result);
 132   void OnIOComplete(int result);
 133
 134   // Executes correct ProcessResponse + command_name function based on last
 135   // issued command. Returns error code.
 136   int ProcessCtrlResponse();
 137
 138   int SendFtpCommand(const std::string& command,
 139                      const std::string& command_for_log,
 140                      Command cmd);
 141
 142   // Returns request path suitable to be included in an FTP command. If the path
 143   // will be used as a directory, |is_directory| should be true.
 144   std::string GetRequestPathForFtpCommand(bool is_directory) const;
 145
 146   // See if the request URL contains a typecode and make us respect it.
 147   void DetectTypecode();
 148
 149   // Runs the state transition loop.
 150   int DoLoop(int result);
 151
 152   // Each of these methods corresponds to a State value.  Those with an input
 153   // argument receive the result from the previous state.  If a method returns
 154   // ERR_IO_PENDING, then the result from OnIOComplete will be passed to the
 155   // next state method as the result arg.
 156   int DoCtrlResolveHost();
 157   int DoCtrlResolveHostComplete(int result);
 158   int DoCtrlConnect();
 159   int DoCtrlConnectComplete(int result);
 160   int DoCtrlRead();
 161   int DoCtrlReadComplete(int result);
 162   int DoCtrlWrite();
 163   int DoCtrlWriteComplete(int result);
 164   int DoCtrlWriteUSER();
 165   int ProcessResponseUSER(const FtpCtrlResponse& response);
 166   int DoCtrlWritePASS();
 167   int ProcessResponsePASS(const FtpCtrlResponse& response);
 168   int DoCtrlWriteSYST();
 169   int ProcessResponseSYST(const FtpCtrlResponse& response);
 170   int DoCtrlWritePWD();
 171   int ProcessResponsePWD(const FtpCtrlResponse& response);
 172   int DoCtrlWriteTYPE();
 173   int ProcessResponseTYPE(const FtpCtrlResponse& response);
 174   int DoCtrlWriteEPSV();
 175   int ProcessResponseEPSV(const FtpCtrlResponse& response);
 176   int DoCtrlWritePASV();
 177   int ProcessResponsePASV(const FtpCtrlResponse& response);
 178   int DoCtrlWriteRETR();
 179   int ProcessResponseRETR(const FtpCtrlResponse& response);
 180   int DoCtrlWriteSIZE();
 181   int ProcessResponseSIZE(const FtpCtrlResponse& response);
 182   int DoCtrlWriteCWD();
 183   int ProcessResponseCWD(const FtpCtrlResponse& response);
 184   int ProcessResponseCWDNotADirectory();
 185   int DoCtrlWriteLIST();
 186   int ProcessResponseLIST(const FtpCtrlResponse& response);
 187   int DoCtrlWriteQUIT();
 188   int ProcessResponseQUIT(const FtpCtrlResponse& response);
 189
 190   int DoDataConnect();
 191   int DoDataConnectComplete(int result);
 192   int DoDataRead();
 193   int DoDataReadComplete(int result);
 194
 195   void RecordDataConnectionError(int result);
 196
 197   Command command_sent_;
 198
 199   CompletionCallback io_callback_;
 200   CompletionCallback user_callback_;
 201
 202   scoped_refptr<FtpNetworkSession> session_;
 203
 204   BoundNetLog net_log_;
 205   const FtpRequestInfo* request_;
 206   FtpResponseInfo response_;
 207
 208   // Cancels the outstanding request on destruction.
 209   SingleRequestHostResolver resolver_;
 210   AddressList addresses_;
 211
 212   // User buffer passed to the Read method for control socket.
 213   scoped_refptr<IOBuffer> read_ctrl_buf_;
 214
 215   scoped_ptr<FtpCtrlResponseBuffer> ctrl_response_buffer_;
 216
 217   scoped_refptr<IOBuffer> read_data_buf_;
 218   int read_data_buf_len_;
 219
 220   // Buffer holding the command line to be written to the control socket.
 221   scoped_refptr<IOBufferWithSize> write_command_buf_;
 222
 223   // Buffer passed to the Write method of control socket. It actually writes
 224   // to the write_command_buf_ at correct offset.
 225   scoped_refptr<DrainableIOBuffer> write_buf_;
 226
 227   int last_error_;
 228
 229   SystemType system_type_;
 230
 231   // Data type to be used for the TYPE command.
 232   DataType data_type_;
 233
 234   // Detected resource type (file or directory).
 235   ResourceType resource_type_;
 236
 237   // Initially we favour EPSV over PASV for transfers but should any
 238   // EPSV fail, we fall back to PASV for the duration of connection.
 239   bool use_epsv_;
 240
 241   AuthCredentials credentials_;
 242
 243   // Current directory on the remote server, as returned by last PWD command,
 244   // with any trailing slash removed.
 245   std::string current_remote_directory_;
 246
 247   int data_connection_port_;
 248
 249   ClientSocketFactory* socket_factory_;
 250
 251   scoped_ptr<StreamSocket> ctrl_socket_;
 252   scoped_ptr<StreamSocket> data_socket_;
 253
 254   State next_state_;
 255
 256   // State to switch to after data connection is complete.
 257   State state_after_data_connect_complete_;
 258 };
 259
 260 }  // namespace net
 261
 262 #endif  // NET_FTP_FTP_NETWORK_TRANSACTION_H_