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