Home | History | Annotate | Download | only in ftp
      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 #include "net/ftp/ftp_network_transaction.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/bind_helpers.h"
      9 #include "base/compiler_specific.h"
     10 #include "base/metrics/histogram.h"
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/string_util.h"
     13 #include "base/strings/string_split.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "base/values.h"
     16 #include "net/base/address_list.h"
     17 #include "net/base/connection_type_histograms.h"
     18 #include "net/base/escape.h"
     19 #include "net/base/net_errors.h"
     20 #include "net/base/net_log.h"
     21 #include "net/base/net_util.h"
     22 #include "net/ftp/ftp_network_session.h"
     23 #include "net/ftp/ftp_request_info.h"
     24 #include "net/ftp/ftp_util.h"
     25 #include "net/socket/client_socket_factory.h"
     26 #include "net/socket/stream_socket.h"
     27 
     28 const char kCRLF[] = "\r\n";
     29 
     30 const int kCtrlBufLen = 1024;
     31 
     32 namespace {
     33 
     34 // Returns true if |input| can be safely used as a part of FTP command.
     35 bool IsValidFTPCommandString(const std::string& input) {
     36   // RFC 959 only allows ASCII strings, but at least Firefox can send non-ASCII
     37   // characters in the command if the request path contains them. To be
     38   // compatible, we do the same and allow non-ASCII characters in a command.
     39 
     40   // Protect agains newline injection attack.
     41   if (input.find_first_of("\r\n") != std::string::npos)
     42     return false;
     43 
     44   return true;
     45 }
     46 
     47 enum ErrorClass {
     48   // The requested action was initiated. The client should expect another
     49   // reply before issuing the next command.
     50   ERROR_CLASS_INITIATED,
     51 
     52   // The requested action has been successfully completed.
     53   ERROR_CLASS_OK,
     54 
     55   // The command has been accepted, but to complete the operation, more
     56   // information must be sent by the client.
     57   ERROR_CLASS_INFO_NEEDED,
     58 
     59   // The command was not accepted and the requested action did not take place.
     60   // This condition is temporary, and the client is encouraged to restart the
     61   // command sequence.
     62   ERROR_CLASS_TRANSIENT_ERROR,
     63 
     64   // The command was not accepted and the requested action did not take place.
     65   // This condition is rather permanent, and the client is discouraged from
     66   // repeating the exact request.
     67   ERROR_CLASS_PERMANENT_ERROR,
     68 };
     69 
     70 // Returns the error class for given response code. Caller should ensure
     71 // that |response_code| is in range 100-599.
     72 ErrorClass GetErrorClass(int response_code) {
     73   if (response_code >= 100 && response_code <= 199)
     74     return ERROR_CLASS_INITIATED;
     75 
     76   if (response_code >= 200 && response_code <= 299)
     77     return ERROR_CLASS_OK;
     78 
     79   if (response_code >= 300 && response_code <= 399)
     80     return ERROR_CLASS_INFO_NEEDED;
     81 
     82   if (response_code >= 400 && response_code <= 499)
     83     return ERROR_CLASS_TRANSIENT_ERROR;
     84 
     85   if (response_code >= 500 && response_code <= 599)
     86     return ERROR_CLASS_PERMANENT_ERROR;
     87 
     88   // We should not be called on invalid error codes.
     89   NOTREACHED() << response_code;
     90   return ERROR_CLASS_PERMANENT_ERROR;
     91 }
     92 
     93 // Returns network error code for received FTP |response_code|.
     94 int GetNetErrorCodeForFtpResponseCode(int response_code) {
     95   switch (response_code) {
     96     case 421:
     97       return net::ERR_FTP_SERVICE_UNAVAILABLE;
     98     case 426:
     99       return net::ERR_FTP_TRANSFER_ABORTED;
    100     case 450:
    101       return net::ERR_FTP_FILE_BUSY;
    102     case 500:
    103     case 501:
    104       return net::ERR_FTP_SYNTAX_ERROR;
    105     case 502:
    106     case 504:
    107       return net::ERR_FTP_COMMAND_NOT_SUPPORTED;
    108     case 503:
    109       return net::ERR_FTP_BAD_COMMAND_SEQUENCE;
    110     default:
    111       return net::ERR_FTP_FAILED;
    112   }
    113 }
    114 
    115 // From RFC 2428 Section 3:
    116 //   The text returned in response to the EPSV command MUST be:
    117 //     <some text> (<d><d><d><tcp-port><d>)
    118 //   <d> is a delimiter character, ideally to be |
    119 bool ExtractPortFromEPSVResponse(const net::FtpCtrlResponse& response,
    120                                  int* port) {
    121   if (response.lines.size() != 1)
    122     return false;
    123   const char* ptr = response.lines[0].c_str();
    124   while (*ptr && *ptr != '(')
    125     ++ptr;
    126   if (!*ptr)
    127     return false;
    128   char sep = *(++ptr);
    129   if (!sep || isdigit(sep) || *(++ptr) != sep || *(++ptr) != sep)
    130     return false;
    131   if (!isdigit(*(++ptr)))
    132     return false;
    133   *port = *ptr - '0';
    134   while (isdigit(*(++ptr))) {
    135     *port *= 10;
    136     *port += *ptr - '0';
    137   }
    138   if (*ptr != sep)
    139     return false;
    140 
    141   return true;
    142 }
    143 
    144 // There are two way we can receive IP address and port.
    145 // (127,0,0,1,23,21) IP address and port encapsulated in ().
    146 // 127,0,0,1,23,21  IP address and port without ().
    147 //
    148 // See RFC 959, Section 4.1.2
    149 bool ExtractPortFromPASVResponse(const net::FtpCtrlResponse& response,
    150                                  int* port) {
    151   if (response.lines.size() != 1)
    152     return false;
    153 
    154   std::string line(response.lines[0]);
    155   if (!base::IsStringASCII(line))
    156     return false;
    157   if (line.length() < 2)
    158     return false;
    159 
    160   size_t paren_pos = line.find('(');
    161   if (paren_pos == std::string::npos) {
    162     // Find the first comma and use it to locate the beginning
    163     // of the response data.
    164     size_t comma_pos = line.find(',');
    165     if (comma_pos == std::string::npos)
    166       return false;
    167 
    168     size_t space_pos = line.rfind(' ', comma_pos);
    169     if (space_pos != std::string::npos)
    170       line = line.substr(space_pos + 1);
    171   } else {
    172     // Remove the parentheses and use the text inside them.
    173     size_t closing_paren_pos = line.rfind(')');
    174     if (closing_paren_pos == std::string::npos)
    175       return false;
    176     if (closing_paren_pos <= paren_pos)
    177       return false;
    178 
    179     line = line.substr(paren_pos + 1, closing_paren_pos - paren_pos - 1);
    180   }
    181 
    182   // Split the line into comma-separated pieces and extract
    183   // the last two.
    184   std::vector<std::string> pieces;
    185   base::SplitString(line, ',', &pieces);
    186   if (pieces.size() != 6)
    187     return false;
    188 
    189   // Ignore the IP address supplied in the response. We are always going
    190   // to connect back to the same server to prevent FTP PASV port scanning.
    191   int p0, p1;
    192   if (!base::StringToInt(pieces[4], &p0))
    193     return false;
    194   if (!base::StringToInt(pieces[5], &p1))
    195     return false;
    196   *port = (p0 << 8) + p1;
    197 
    198   return true;
    199 }
    200 
    201 }  // namespace
    202 
    203 namespace net {
    204 
    205 FtpNetworkTransaction::FtpNetworkTransaction(
    206     FtpNetworkSession* session,
    207     ClientSocketFactory* socket_factory)
    208     : command_sent_(COMMAND_NONE),
    209       io_callback_(base::Bind(&FtpNetworkTransaction::OnIOComplete,
    210                               base::Unretained(this))),
    211       session_(session),
    212       request_(NULL),
    213       resolver_(session->host_resolver()),
    214       read_ctrl_buf_(new IOBuffer(kCtrlBufLen)),
    215       read_data_buf_len_(0),
    216       last_error_(OK),
    217       system_type_(SYSTEM_TYPE_UNKNOWN),
    218       // Use image (binary) transfer by default. It should always work,
    219       // whereas the ascii transfer may damage binary data.
    220       data_type_(DATA_TYPE_IMAGE),
    221       resource_type_(RESOURCE_TYPE_UNKNOWN),
    222       use_epsv_(true),
    223       data_connection_port_(0),
    224       socket_factory_(socket_factory),
    225       next_state_(STATE_NONE),
    226       state_after_data_connect_complete_(STATE_CTRL_WRITE_SIZE) {}
    227 
    228 FtpNetworkTransaction::~FtpNetworkTransaction() {
    229 }
    230 
    231 int FtpNetworkTransaction::Stop(int error) {
    232   if (command_sent_ == COMMAND_QUIT)
    233     return error;
    234 
    235   next_state_ = STATE_CTRL_WRITE_QUIT;
    236   last_error_ = error;
    237   return OK;
    238 }
    239 
    240 int FtpNetworkTransaction::RestartIgnoringLastError(
    241     const CompletionCallback& callback) {
    242   return ERR_NOT_IMPLEMENTED;
    243 }
    244 
    245 int FtpNetworkTransaction::Start(const FtpRequestInfo* request_info,
    246                                  const CompletionCallback& callback,
    247                                  const BoundNetLog& net_log) {
    248   net_log_ = net_log;
    249   request_ = request_info;
    250 
    251   ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer(net_log_));
    252 
    253   if (request_->url.has_username()) {
    254     base::string16 username;
    255     base::string16 password;
    256     GetIdentityFromURL(request_->url, &username, &password);
    257     credentials_.Set(username, password);
    258   } else {
    259     credentials_.Set(base::ASCIIToUTF16("anonymous"),
    260                      base::ASCIIToUTF16("chrome (at) example.com"));
    261   }
    262 
    263   DetectTypecode();
    264 
    265   next_state_ = STATE_CTRL_RESOLVE_HOST;
    266   int rv = DoLoop(OK);
    267   if (rv == ERR_IO_PENDING)
    268     user_callback_ = callback;
    269   return rv;
    270 }
    271 
    272 int FtpNetworkTransaction::RestartWithAuth(const AuthCredentials& credentials,
    273                                            const CompletionCallback& callback) {
    274   ResetStateForRestart();
    275 
    276   credentials_ = credentials;
    277 
    278   next_state_ = STATE_CTRL_RESOLVE_HOST;
    279   int rv = DoLoop(OK);
    280   if (rv == ERR_IO_PENDING)
    281     user_callback_ = callback;
    282   return rv;
    283 }
    284 
    285 int FtpNetworkTransaction::Read(IOBuffer* buf,
    286                                 int buf_len,
    287                                 const CompletionCallback& callback) {
    288   DCHECK(buf);
    289   DCHECK_GT(buf_len, 0);
    290 
    291   read_data_buf_ = buf;
    292   read_data_buf_len_ = buf_len;
    293 
    294   next_state_ = STATE_DATA_READ;
    295   int rv = DoLoop(OK);
    296   if (rv == ERR_IO_PENDING)
    297     user_callback_ = callback;
    298   return rv;
    299 }
    300 
    301 const FtpResponseInfo* FtpNetworkTransaction::GetResponseInfo() const {
    302   return &response_;
    303 }
    304 
    305 LoadState FtpNetworkTransaction::GetLoadState() const {
    306   if (next_state_ == STATE_CTRL_RESOLVE_HOST_COMPLETE)
    307     return LOAD_STATE_RESOLVING_HOST;
    308 
    309   if (next_state_ == STATE_CTRL_CONNECT_COMPLETE ||
    310       next_state_ == STATE_DATA_CONNECT_COMPLETE)
    311     return LOAD_STATE_CONNECTING;
    312 
    313   if (next_state_ == STATE_DATA_READ_COMPLETE)
    314     return LOAD_STATE_READING_RESPONSE;
    315 
    316   if (command_sent_ == COMMAND_RETR && read_data_buf_.get())
    317     return LOAD_STATE_READING_RESPONSE;
    318 
    319   if (command_sent_ == COMMAND_QUIT)
    320     return LOAD_STATE_IDLE;
    321 
    322   if (command_sent_ != COMMAND_NONE)
    323     return LOAD_STATE_SENDING_REQUEST;
    324 
    325   return LOAD_STATE_IDLE;
    326 }
    327 
    328 uint64 FtpNetworkTransaction::GetUploadProgress() const {
    329   return 0;
    330 }
    331 
    332 void FtpNetworkTransaction::ResetStateForRestart() {
    333   command_sent_ = COMMAND_NONE;
    334   user_callback_.Reset();
    335   response_ = FtpResponseInfo();
    336   read_ctrl_buf_ = new IOBuffer(kCtrlBufLen);
    337   ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer(net_log_));
    338   read_data_buf_ = NULL;
    339   read_data_buf_len_ = 0;
    340   if (write_buf_.get())
    341     write_buf_->SetOffset(0);
    342   last_error_ = OK;
    343   data_connection_port_ = 0;
    344   ctrl_socket_.reset();
    345   data_socket_.reset();
    346   next_state_ = STATE_NONE;
    347   state_after_data_connect_complete_ = STATE_CTRL_WRITE_SIZE;
    348 }
    349 
    350 void FtpNetworkTransaction::ResetDataConnectionAfterError(State next_state) {
    351   // The server _might_ have reset the data connection
    352   // (see RFC 959 3.2. ESTABLISHING DATA CONNECTIONS:
    353   // "The server MUST close the data connection under the following
    354   // conditions:
    355   // ...
    356   // 5. An irrecoverable error condition occurs.")
    357   //
    358   // It is ambiguous what an irrecoverable error condition is,
    359   // so we take no chances.
    360   state_after_data_connect_complete_ = next_state;
    361   next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
    362 }
    363 
    364 void FtpNetworkTransaction::DoCallback(int rv) {
    365   DCHECK(rv != ERR_IO_PENDING);
    366   DCHECK(!user_callback_.is_null());
    367 
    368   // Since Run may result in Read being called, clear callback_ up front.
    369   CompletionCallback c = user_callback_;
    370   user_callback_.Reset();
    371   c.Run(rv);
    372 }
    373 
    374 void FtpNetworkTransaction::OnIOComplete(int result) {
    375   int rv = DoLoop(result);
    376   if (rv != ERR_IO_PENDING)
    377     DoCallback(rv);
    378 }
    379 
    380 int FtpNetworkTransaction::ProcessCtrlResponse() {
    381   FtpCtrlResponse response = ctrl_response_buffer_->PopResponse();
    382 
    383   int rv = OK;
    384   switch (command_sent_) {
    385     case COMMAND_NONE:
    386       // TODO(phajdan.jr): Check for errors in the welcome message.
    387       next_state_ = STATE_CTRL_WRITE_USER;
    388       break;
    389     case COMMAND_USER:
    390       rv = ProcessResponseUSER(response);
    391       break;
    392     case COMMAND_PASS:
    393       rv = ProcessResponsePASS(response);
    394       break;
    395     case COMMAND_SYST:
    396       rv = ProcessResponseSYST(response);
    397       break;
    398     case COMMAND_PWD:
    399       rv = ProcessResponsePWD(response);
    400       break;
    401     case COMMAND_TYPE:
    402       rv = ProcessResponseTYPE(response);
    403       break;
    404     case COMMAND_EPSV:
    405       rv = ProcessResponseEPSV(response);
    406       break;
    407     case COMMAND_PASV:
    408       rv = ProcessResponsePASV(response);
    409       break;
    410     case COMMAND_SIZE:
    411       rv = ProcessResponseSIZE(response);
    412       break;
    413     case COMMAND_RETR:
    414       rv = ProcessResponseRETR(response);
    415       break;
    416     case COMMAND_CWD:
    417       rv = ProcessResponseCWD(response);
    418       break;
    419     case COMMAND_LIST:
    420       rv = ProcessResponseLIST(response);
    421       break;
    422     case COMMAND_QUIT:
    423       rv = ProcessResponseQUIT(response);
    424       break;
    425     default:
    426       LOG(DFATAL) << "Unexpected value of command_sent_: " << command_sent_;
    427       return ERR_UNEXPECTED;
    428   }
    429 
    430   // We may get multiple responses for some commands,
    431   // see http://crbug.com/18036.
    432   while (ctrl_response_buffer_->ResponseAvailable() && rv == OK) {
    433     response = ctrl_response_buffer_->PopResponse();
    434 
    435     switch (command_sent_) {
    436       case COMMAND_RETR:
    437         rv = ProcessResponseRETR(response);
    438         break;
    439       case COMMAND_LIST:
    440         rv = ProcessResponseLIST(response);
    441         break;
    442       default:
    443         // Multiple responses for other commands are invalid.
    444         return Stop(ERR_INVALID_RESPONSE);
    445     }
    446   }
    447 
    448   return rv;
    449 }
    450 
    451 // Used to prepare and send FTP command.
    452 int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
    453                                           const std::string& command_for_log,
    454                                           Command cmd) {
    455   // If we send a new command when we still have unprocessed responses
    456   // for previous commands, the response receiving code will have no way to know
    457   // which responses are for which command.
    458   DCHECK(!ctrl_response_buffer_->ResponseAvailable());
    459 
    460   DCHECK(!write_command_buf_.get());
    461   DCHECK(!write_buf_.get());
    462 
    463   if (!IsValidFTPCommandString(command)) {
    464     // Callers should validate the command themselves and return a more specific
    465     // error code.
    466     NOTREACHED();
    467     return Stop(ERR_UNEXPECTED);
    468   }
    469 
    470   command_sent_ = cmd;
    471 
    472   write_command_buf_ = new IOBufferWithSize(command.length() + 2);
    473   write_buf_ = new DrainableIOBuffer(write_command_buf_.get(),
    474                                      write_command_buf_->size());
    475   memcpy(write_command_buf_->data(), command.data(), command.length());
    476   memcpy(write_command_buf_->data() + command.length(), kCRLF, 2);
    477 
    478   net_log_.AddEvent(NetLog::TYPE_FTP_COMMAND_SENT,
    479                     NetLog::StringCallback("command", &command_for_log));
    480 
    481   next_state_ = STATE_CTRL_WRITE;
    482   return OK;
    483 }
    484 
    485 std::string FtpNetworkTransaction::GetRequestPathForFtpCommand(
    486     bool is_directory) const {
    487   std::string path(current_remote_directory_);
    488   if (request_->url.has_path()) {
    489     std::string gurl_path(request_->url.path());
    490 
    491     // Get rid of the typecode, see RFC 1738 section 3.2.2. FTP url-path.
    492     std::string::size_type pos = gurl_path.rfind(';');
    493     if (pos != std::string::npos)
    494       gurl_path.resize(pos);
    495 
    496     path.append(gurl_path);
    497   }
    498   // Make sure that if the path is expected to be a file, it won't end
    499   // with a trailing slash.
    500   if (!is_directory && path.length() > 1 && path[path.length() - 1] == '/')
    501     path.erase(path.length() - 1);
    502   UnescapeRule::Type unescape_rules = UnescapeRule::SPACES |
    503                                       UnescapeRule::URL_SPECIAL_CHARS;
    504   // This may unescape to non-ASCII characters, but we allow that. See the
    505   // comment for IsValidFTPCommandString.
    506   path = net::UnescapeURLComponent(path, unescape_rules);
    507 
    508   if (system_type_ == SYSTEM_TYPE_VMS) {
    509     if (is_directory)
    510       path = FtpUtil::UnixDirectoryPathToVMS(path);
    511     else
    512       path = FtpUtil::UnixFilePathToVMS(path);
    513   }
    514 
    515   DCHECK(IsValidFTPCommandString(path));
    516   return path;
    517 }
    518 
    519 void FtpNetworkTransaction::DetectTypecode() {
    520   if (!request_->url.has_path())
    521     return;
    522   std::string gurl_path(request_->url.path());
    523 
    524   // Extract the typecode, see RFC 1738 section 3.2.2. FTP url-path.
    525   std::string::size_type pos = gurl_path.rfind(';');
    526   if (pos == std::string::npos)
    527     return;
    528   std::string typecode_string(gurl_path.substr(pos));
    529   if (typecode_string == ";type=a") {
    530     data_type_ = DATA_TYPE_ASCII;
    531     resource_type_ = RESOURCE_TYPE_FILE;
    532   } else if (typecode_string == ";type=i") {
    533     data_type_ = DATA_TYPE_IMAGE;
    534     resource_type_ = RESOURCE_TYPE_FILE;
    535   } else if (typecode_string == ";type=d") {
    536     resource_type_ = RESOURCE_TYPE_DIRECTORY;
    537   }
    538 }
    539 
    540 int FtpNetworkTransaction::DoLoop(int result) {
    541   DCHECK(next_state_ != STATE_NONE);
    542 
    543   int rv = result;
    544   do {
    545     State state = next_state_;
    546     next_state_ = STATE_NONE;
    547     switch (state) {
    548       case STATE_CTRL_RESOLVE_HOST:
    549         DCHECK(rv == OK);
    550         rv = DoCtrlResolveHost();
    551         break;
    552       case STATE_CTRL_RESOLVE_HOST_COMPLETE:
    553         rv = DoCtrlResolveHostComplete(rv);
    554         break;
    555       case STATE_CTRL_CONNECT:
    556         DCHECK(rv == OK);
    557         rv = DoCtrlConnect();
    558         break;
    559       case STATE_CTRL_CONNECT_COMPLETE:
    560         rv = DoCtrlConnectComplete(rv);
    561         break;
    562       case STATE_CTRL_READ:
    563         DCHECK(rv == OK);
    564         rv = DoCtrlRead();
    565         break;
    566       case STATE_CTRL_READ_COMPLETE:
    567         rv = DoCtrlReadComplete(rv);
    568         break;
    569       case STATE_CTRL_WRITE:
    570         DCHECK(rv == OK);
    571         rv = DoCtrlWrite();
    572         break;
    573       case STATE_CTRL_WRITE_COMPLETE:
    574         rv = DoCtrlWriteComplete(rv);
    575         break;
    576       case STATE_CTRL_WRITE_USER:
    577         DCHECK(rv == OK);
    578         rv = DoCtrlWriteUSER();
    579         break;
    580       case STATE_CTRL_WRITE_PASS:
    581         DCHECK(rv == OK);
    582         rv = DoCtrlWritePASS();
    583         break;
    584       case STATE_CTRL_WRITE_SYST:
    585         DCHECK(rv == OK);
    586         rv = DoCtrlWriteSYST();
    587         break;
    588       case STATE_CTRL_WRITE_PWD:
    589         DCHECK(rv == OK);
    590         rv = DoCtrlWritePWD();
    591         break;
    592       case STATE_CTRL_WRITE_TYPE:
    593         DCHECK(rv == OK);
    594         rv = DoCtrlWriteTYPE();
    595         break;
    596       case STATE_CTRL_WRITE_EPSV:
    597         DCHECK(rv == OK);
    598         rv = DoCtrlWriteEPSV();
    599         break;
    600       case STATE_CTRL_WRITE_PASV:
    601         DCHECK(rv == OK);
    602         rv = DoCtrlWritePASV();
    603         break;
    604       case STATE_CTRL_WRITE_RETR:
    605         DCHECK(rv == OK);
    606         rv = DoCtrlWriteRETR();
    607         break;
    608       case STATE_CTRL_WRITE_SIZE:
    609         DCHECK(rv == OK);
    610         rv = DoCtrlWriteSIZE();
    611         break;
    612       case STATE_CTRL_WRITE_CWD:
    613         DCHECK(rv == OK);
    614         rv = DoCtrlWriteCWD();
    615         break;
    616       case STATE_CTRL_WRITE_LIST:
    617         DCHECK(rv == OK);
    618         rv = DoCtrlWriteLIST();
    619         break;
    620       case STATE_CTRL_WRITE_QUIT:
    621         DCHECK(rv == OK);
    622         rv = DoCtrlWriteQUIT();
    623         break;
    624       case STATE_DATA_CONNECT:
    625         DCHECK(rv == OK);
    626         rv = DoDataConnect();
    627         break;
    628       case STATE_DATA_CONNECT_COMPLETE:
    629         rv = DoDataConnectComplete(rv);
    630         break;
    631       case STATE_DATA_READ:
    632         DCHECK(rv == OK);
    633         rv = DoDataRead();
    634         break;
    635       case STATE_DATA_READ_COMPLETE:
    636         rv = DoDataReadComplete(rv);
    637         break;
    638       default:
    639         NOTREACHED() << "bad state";
    640         rv = ERR_UNEXPECTED;
    641         break;
    642     }
    643   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
    644   return rv;
    645 }
    646 
    647 int FtpNetworkTransaction::DoCtrlResolveHost() {
    648   next_state_ = STATE_CTRL_RESOLVE_HOST_COMPLETE;
    649 
    650   HostResolver::RequestInfo info(HostPortPair::FromURL(request_->url));
    651   // No known referrer.
    652   return resolver_.Resolve(
    653       info,
    654       DEFAULT_PRIORITY,
    655       &addresses_,
    656       base::Bind(&FtpNetworkTransaction::OnIOComplete, base::Unretained(this)),
    657       net_log_);
    658 }
    659 
    660 int FtpNetworkTransaction::DoCtrlResolveHostComplete(int result) {
    661   if (result == OK)
    662     next_state_ = STATE_CTRL_CONNECT;
    663   return result;
    664 }
    665 
    666 int FtpNetworkTransaction::DoCtrlConnect() {
    667   next_state_ = STATE_CTRL_CONNECT_COMPLETE;
    668   ctrl_socket_ = socket_factory_->CreateTransportClientSocket(
    669       addresses_, net_log_.net_log(), net_log_.source());
    670   net_log_.AddEvent(
    671       NetLog::TYPE_FTP_CONTROL_CONNECTION,
    672       ctrl_socket_->NetLog().source().ToEventParametersCallback());
    673   return ctrl_socket_->Connect(io_callback_);
    674 }
    675 
    676 int FtpNetworkTransaction::DoCtrlConnectComplete(int result) {
    677   if (result == OK) {
    678     // Put the peer's IP address and port into the response.
    679     IPEndPoint ip_endpoint;
    680     result = ctrl_socket_->GetPeerAddress(&ip_endpoint);
    681     if (result == OK) {
    682       response_.socket_address = HostPortPair::FromIPEndPoint(ip_endpoint);
    683       next_state_ = STATE_CTRL_READ;
    684 
    685       if (ip_endpoint.GetFamily() == ADDRESS_FAMILY_IPV4) {
    686         // Do not use EPSV for IPv4 connections. Some servers become confused
    687         // and we time out while waiting to connect. PASV is perfectly fine for
    688         // IPv4. Note that this blacklists IPv4 not to use EPSV instead of
    689         // whitelisting IPv6 to use it, to make the code more future-proof:
    690         // all future protocols should just use EPSV.
    691         use_epsv_ = false;
    692       }
    693     }
    694   }
    695   return result;
    696 }
    697 
    698 int FtpNetworkTransaction::DoCtrlRead() {
    699   next_state_ = STATE_CTRL_READ_COMPLETE;
    700   return ctrl_socket_->Read(read_ctrl_buf_.get(), kCtrlBufLen, io_callback_);
    701 }
    702 
    703 int FtpNetworkTransaction::DoCtrlReadComplete(int result) {
    704   if (result == 0) {
    705     // Some servers (for example Pure-FTPd) apparently close the control
    706     // connection when anonymous login is not permitted. For more details
    707     // see http://crbug.com/25023.
    708     if (command_sent_ == COMMAND_USER &&
    709         credentials_.username() == base::ASCIIToUTF16("anonymous")) {
    710       response_.needs_auth = true;
    711     }
    712     return Stop(ERR_EMPTY_RESPONSE);
    713   }
    714   if (result < 0)
    715     return Stop(result);
    716 
    717   ctrl_response_buffer_->ConsumeData(read_ctrl_buf_->data(), result);
    718 
    719   if (!ctrl_response_buffer_->ResponseAvailable()) {
    720     // Read more data from the control socket.
    721     next_state_ = STATE_CTRL_READ;
    722     return OK;
    723   }
    724 
    725   return ProcessCtrlResponse();
    726 }
    727 
    728 int FtpNetworkTransaction::DoCtrlWrite() {
    729   next_state_ = STATE_CTRL_WRITE_COMPLETE;
    730 
    731   return ctrl_socket_->Write(
    732       write_buf_.get(), write_buf_->BytesRemaining(), io_callback_);
    733 }
    734 
    735 int FtpNetworkTransaction::DoCtrlWriteComplete(int result) {
    736   if (result < 0)
    737     return result;
    738 
    739   write_buf_->DidConsume(result);
    740   if (write_buf_->BytesRemaining() == 0) {
    741     // Clear the write buffer.
    742     write_buf_ = NULL;
    743     write_command_buf_ = NULL;
    744 
    745     next_state_ = STATE_CTRL_READ;
    746   } else {
    747     next_state_ = STATE_CTRL_WRITE;
    748   }
    749   return OK;
    750 }
    751 
    752 // FTP Commands and responses
    753 
    754 // USER Command.
    755 int FtpNetworkTransaction::DoCtrlWriteUSER() {
    756   std::string command = "USER " + base::UTF16ToUTF8(credentials_.username());
    757 
    758   if (!IsValidFTPCommandString(command))
    759     return Stop(ERR_MALFORMED_IDENTITY);
    760 
    761   next_state_ = STATE_CTRL_READ;
    762   return SendFtpCommand(command, "USER ***", COMMAND_USER);
    763 }
    764 
    765 int FtpNetworkTransaction::ProcessResponseUSER(
    766     const FtpCtrlResponse& response) {
    767   switch (GetErrorClass(response.status_code)) {
    768     case ERROR_CLASS_OK:
    769       next_state_ = STATE_CTRL_WRITE_SYST;
    770       break;
    771     case ERROR_CLASS_INFO_NEEDED:
    772       next_state_ = STATE_CTRL_WRITE_PASS;
    773       break;
    774     case ERROR_CLASS_TRANSIENT_ERROR:
    775     case ERROR_CLASS_PERMANENT_ERROR:
    776       response_.needs_auth = true;
    777       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    778     default:
    779       NOTREACHED();
    780       return Stop(ERR_UNEXPECTED);
    781   }
    782   return OK;
    783 }
    784 
    785 // PASS command.
    786 int FtpNetworkTransaction::DoCtrlWritePASS() {
    787   std::string command = "PASS " + base::UTF16ToUTF8(credentials_.password());
    788 
    789   if (!IsValidFTPCommandString(command))
    790     return Stop(ERR_MALFORMED_IDENTITY);
    791 
    792   next_state_ = STATE_CTRL_READ;
    793   return SendFtpCommand(command, "PASS ***", COMMAND_PASS);
    794 }
    795 
    796 int FtpNetworkTransaction::ProcessResponsePASS(
    797     const FtpCtrlResponse& response) {
    798   switch (GetErrorClass(response.status_code)) {
    799     case ERROR_CLASS_OK:
    800       next_state_ = STATE_CTRL_WRITE_SYST;
    801       break;
    802     case ERROR_CLASS_INFO_NEEDED:
    803       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    804     case ERROR_CLASS_TRANSIENT_ERROR:
    805     case ERROR_CLASS_PERMANENT_ERROR:
    806       response_.needs_auth = true;
    807       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    808     default:
    809       NOTREACHED();
    810       return Stop(ERR_UNEXPECTED);
    811   }
    812   return OK;
    813 }
    814 
    815 // SYST command.
    816 int FtpNetworkTransaction::DoCtrlWriteSYST() {
    817   std::string command = "SYST";
    818   next_state_ = STATE_CTRL_READ;
    819   return SendFtpCommand(command, command, COMMAND_SYST);
    820 }
    821 
    822 int FtpNetworkTransaction::ProcessResponseSYST(
    823     const FtpCtrlResponse& response) {
    824   switch (GetErrorClass(response.status_code)) {
    825     case ERROR_CLASS_INITIATED:
    826       return Stop(ERR_INVALID_RESPONSE);
    827     case ERROR_CLASS_OK: {
    828       // All important info should be on the first line.
    829       std::string line = response.lines[0];
    830       // The response should be ASCII, which allows us to do case-insensitive
    831       // comparisons easily. If it is not ASCII, we leave the system type
    832       // as unknown.
    833       if (base::IsStringASCII(line)) {
    834         line = StringToLowerASCII(line);
    835 
    836         // Remove all whitespace, to correctly handle cases like fancy "V M S"
    837         // response instead of "VMS".
    838         base::RemoveChars(line, base::kWhitespaceASCII, &line);
    839 
    840         // The "magic" strings we test for below have been gathered by an
    841         // empirical study. VMS needs to come first because some VMS systems
    842         // also respond with "UNIX emulation", which is not perfect. It is much
    843         // more reliable to talk to these servers in their native language.
    844         if (line.find("vms") != std::string::npos) {
    845           system_type_ = SYSTEM_TYPE_VMS;
    846         } else if (line.find("l8") != std::string::npos ||
    847                    line.find("unix") != std::string::npos ||
    848                    line.find("bsd") != std::string::npos) {
    849           system_type_ = SYSTEM_TYPE_UNIX;
    850         } else if (line.find("win32") != std::string::npos ||
    851                    line.find("windows") != std::string::npos) {
    852           system_type_ = SYSTEM_TYPE_WINDOWS;
    853         } else if (line.find("os/2") != std::string::npos) {
    854           system_type_ = SYSTEM_TYPE_OS2;
    855         }
    856       }
    857       next_state_ = STATE_CTRL_WRITE_PWD;
    858       break;
    859     }
    860     case ERROR_CLASS_INFO_NEEDED:
    861       return Stop(ERR_INVALID_RESPONSE);
    862     case ERROR_CLASS_TRANSIENT_ERROR:
    863       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    864     case ERROR_CLASS_PERMANENT_ERROR:
    865       // Server does not recognize the SYST command so proceed.
    866       next_state_ = STATE_CTRL_WRITE_PWD;
    867       break;
    868     default:
    869       NOTREACHED();
    870       return Stop(ERR_UNEXPECTED);
    871   }
    872   return OK;
    873 }
    874 
    875 // PWD command.
    876 int FtpNetworkTransaction::DoCtrlWritePWD() {
    877   std::string command = "PWD";
    878   next_state_ = STATE_CTRL_READ;
    879   return SendFtpCommand(command, command, COMMAND_PWD);
    880 }
    881 
    882 int FtpNetworkTransaction::ProcessResponsePWD(const FtpCtrlResponse& response) {
    883   switch (GetErrorClass(response.status_code)) {
    884     case ERROR_CLASS_INITIATED:
    885       return Stop(ERR_INVALID_RESPONSE);
    886     case ERROR_CLASS_OK: {
    887       // The info we look for should be on the first line.
    888       std::string line = response.lines[0];
    889       if (line.empty())
    890         return Stop(ERR_INVALID_RESPONSE);
    891       std::string::size_type quote_pos = line.find('"');
    892       if (quote_pos != std::string::npos) {
    893         line = line.substr(quote_pos + 1);
    894         quote_pos = line.find('"');
    895         if (quote_pos == std::string::npos)
    896           return Stop(ERR_INVALID_RESPONSE);
    897         line = line.substr(0, quote_pos);
    898       }
    899       if (system_type_ == SYSTEM_TYPE_VMS)
    900         line = FtpUtil::VMSPathToUnix(line);
    901       if (line.length() && line[line.length() - 1] == '/')
    902         line.erase(line.length() - 1);
    903       current_remote_directory_ = line;
    904       next_state_ = STATE_CTRL_WRITE_TYPE;
    905       break;
    906     }
    907     case ERROR_CLASS_INFO_NEEDED:
    908       return Stop(ERR_INVALID_RESPONSE);
    909     case ERROR_CLASS_TRANSIENT_ERROR:
    910       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    911     case ERROR_CLASS_PERMANENT_ERROR:
    912       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    913     default:
    914       NOTREACHED();
    915       return Stop(ERR_UNEXPECTED);
    916   }
    917   return OK;
    918 }
    919 
    920 // TYPE command.
    921 int FtpNetworkTransaction::DoCtrlWriteTYPE() {
    922   std::string command = "TYPE ";
    923   if (data_type_ == DATA_TYPE_ASCII) {
    924     command += "A";
    925   } else if (data_type_ == DATA_TYPE_IMAGE) {
    926     command += "I";
    927   } else {
    928     NOTREACHED();
    929     return Stop(ERR_UNEXPECTED);
    930   }
    931   next_state_ = STATE_CTRL_READ;
    932   return SendFtpCommand(command, command, COMMAND_TYPE);
    933 }
    934 
    935 int FtpNetworkTransaction::ProcessResponseTYPE(
    936     const FtpCtrlResponse& response) {
    937   switch (GetErrorClass(response.status_code)) {
    938     case ERROR_CLASS_INITIATED:
    939       return Stop(ERR_INVALID_RESPONSE);
    940     case ERROR_CLASS_OK:
    941       next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
    942       break;
    943     case ERROR_CLASS_INFO_NEEDED:
    944       return Stop(ERR_INVALID_RESPONSE);
    945     case ERROR_CLASS_TRANSIENT_ERROR:
    946       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    947     case ERROR_CLASS_PERMANENT_ERROR:
    948       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
    949     default:
    950       NOTREACHED();
    951       return Stop(ERR_UNEXPECTED);
    952   }
    953   return OK;
    954 }
    955 
    956 // EPSV command
    957 int FtpNetworkTransaction::DoCtrlWriteEPSV() {
    958   const std::string command = "EPSV";
    959   next_state_ = STATE_CTRL_READ;
    960   return SendFtpCommand(command, command, COMMAND_EPSV);
    961 }
    962 
    963 int FtpNetworkTransaction::ProcessResponseEPSV(
    964     const FtpCtrlResponse& response) {
    965   switch (GetErrorClass(response.status_code)) {
    966     case ERROR_CLASS_INITIATED:
    967       return Stop(ERR_INVALID_RESPONSE);
    968     case ERROR_CLASS_OK:
    969       if (!ExtractPortFromEPSVResponse( response, &data_connection_port_))
    970         return Stop(ERR_INVALID_RESPONSE);
    971       if (data_connection_port_ < 1024 ||
    972           !IsPortAllowedByFtp(data_connection_port_))
    973         return Stop(ERR_UNSAFE_PORT);
    974       next_state_ = STATE_DATA_CONNECT;
    975       break;
    976     case ERROR_CLASS_INFO_NEEDED:
    977       return Stop(ERR_INVALID_RESPONSE);
    978     case ERROR_CLASS_TRANSIENT_ERROR:
    979     case ERROR_CLASS_PERMANENT_ERROR:
    980       use_epsv_ = false;
    981       next_state_ = STATE_CTRL_WRITE_PASV;
    982       return OK;
    983     default:
    984       NOTREACHED();
    985       return Stop(ERR_UNEXPECTED);
    986   }
    987   return OK;
    988 }
    989 
    990 // PASV command
    991 int FtpNetworkTransaction::DoCtrlWritePASV() {
    992   std::string command = "PASV";
    993   next_state_ = STATE_CTRL_READ;
    994   return SendFtpCommand(command, command, COMMAND_PASV);
    995 }
    996 
    997 int FtpNetworkTransaction::ProcessResponsePASV(
    998     const FtpCtrlResponse& response) {
    999   switch (GetErrorClass(response.status_code)) {
   1000     case ERROR_CLASS_INITIATED:
   1001       return Stop(ERR_INVALID_RESPONSE);
   1002     case ERROR_CLASS_OK:
   1003       if (!ExtractPortFromPASVResponse(response, &data_connection_port_))
   1004         return Stop(ERR_INVALID_RESPONSE);
   1005       if (data_connection_port_ < 1024 ||
   1006           !IsPortAllowedByFtp(data_connection_port_))
   1007         return Stop(ERR_UNSAFE_PORT);
   1008       next_state_ = STATE_DATA_CONNECT;
   1009       break;
   1010     case ERROR_CLASS_INFO_NEEDED:
   1011       return Stop(ERR_INVALID_RESPONSE);
   1012     case ERROR_CLASS_TRANSIENT_ERROR:
   1013       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1014     case ERROR_CLASS_PERMANENT_ERROR:
   1015       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1016     default:
   1017       NOTREACHED();
   1018       return Stop(ERR_UNEXPECTED);
   1019   }
   1020   return OK;
   1021 }
   1022 
   1023 // RETR command
   1024 int FtpNetworkTransaction::DoCtrlWriteRETR() {
   1025   std::string command = "RETR " + GetRequestPathForFtpCommand(false);
   1026   next_state_ = STATE_CTRL_READ;
   1027   return SendFtpCommand(command, command, COMMAND_RETR);
   1028 }
   1029 
   1030 int FtpNetworkTransaction::ProcessResponseRETR(
   1031     const FtpCtrlResponse& response) {
   1032   switch (GetErrorClass(response.status_code)) {
   1033     case ERROR_CLASS_INITIATED:
   1034       // We want the client to start reading the response at this point.
   1035       // It got here either through Start or RestartWithAuth. We want that
   1036       // method to complete. Not setting next state here will make DoLoop exit
   1037       // and in turn make Start/RestartWithAuth complete.
   1038       resource_type_ = RESOURCE_TYPE_FILE;
   1039       break;
   1040     case ERROR_CLASS_OK:
   1041       resource_type_ = RESOURCE_TYPE_FILE;
   1042       next_state_ = STATE_CTRL_WRITE_QUIT;
   1043       break;
   1044     case ERROR_CLASS_INFO_NEEDED:
   1045       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1046     case ERROR_CLASS_TRANSIENT_ERROR:
   1047       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1048     case ERROR_CLASS_PERMANENT_ERROR:
   1049       // Code 550 means "Failed to open file". Other codes are unrelated,
   1050       // like "Not logged in" etc.
   1051       if (response.status_code != 550 || resource_type_ == RESOURCE_TYPE_FILE)
   1052         return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1053 
   1054       // It's possible that RETR failed because the path is a directory.
   1055       resource_type_ = RESOURCE_TYPE_DIRECTORY;
   1056 
   1057       // We're going to try CWD next, but first send a PASV one more time,
   1058       // because some FTP servers, including FileZilla, require that.
   1059       // See http://crbug.com/25316.
   1060       next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
   1061       break;
   1062     default:
   1063       NOTREACHED();
   1064       return Stop(ERR_UNEXPECTED);
   1065   }
   1066 
   1067   // We should be sure about our resource type now. Otherwise we risk
   1068   // an infinite loop (RETR can later send CWD, and CWD can later send RETR).
   1069   DCHECK_NE(RESOURCE_TYPE_UNKNOWN, resource_type_);
   1070 
   1071   return OK;
   1072 }
   1073 
   1074 // SIZE command
   1075 int FtpNetworkTransaction::DoCtrlWriteSIZE() {
   1076   std::string command = "SIZE " + GetRequestPathForFtpCommand(false);
   1077   next_state_ = STATE_CTRL_READ;
   1078   return SendFtpCommand(command, command, COMMAND_SIZE);
   1079 }
   1080 
   1081 int FtpNetworkTransaction::ProcessResponseSIZE(
   1082     const FtpCtrlResponse& response) {
   1083   State state_after_size;
   1084   if (resource_type_ == RESOURCE_TYPE_FILE)
   1085     state_after_size = STATE_CTRL_WRITE_RETR;
   1086   else
   1087     state_after_size = STATE_CTRL_WRITE_CWD;
   1088 
   1089   switch (GetErrorClass(response.status_code)) {
   1090     case ERROR_CLASS_INITIATED:
   1091       next_state_ = state_after_size;
   1092       break;
   1093     case ERROR_CLASS_OK:
   1094       if (response.lines.size() != 1)
   1095         return Stop(ERR_INVALID_RESPONSE);
   1096       int64 size;
   1097       if (!base::StringToInt64(response.lines[0], &size))
   1098         return Stop(ERR_INVALID_RESPONSE);
   1099       if (size < 0)
   1100         return Stop(ERR_INVALID_RESPONSE);
   1101 
   1102       // A successful response to SIZE does not mean the resource is a file.
   1103       // Some FTP servers (for example, the qnx one) send a SIZE even for
   1104       // directories.
   1105       response_.expected_content_size = size;
   1106 
   1107       next_state_ = state_after_size;
   1108       break;
   1109     case ERROR_CLASS_INFO_NEEDED:
   1110       next_state_ = state_after_size;
   1111       break;
   1112     case ERROR_CLASS_TRANSIENT_ERROR:
   1113       ResetDataConnectionAfterError(state_after_size);
   1114       break;
   1115     case ERROR_CLASS_PERMANENT_ERROR:
   1116       // It's possible that SIZE failed because the path is a directory.
   1117       if (resource_type_ == RESOURCE_TYPE_UNKNOWN &&
   1118           response.status_code != 550) {
   1119         return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1120       }
   1121 
   1122       ResetDataConnectionAfterError(state_after_size);
   1123       break;
   1124     default:
   1125       NOTREACHED();
   1126       return Stop(ERR_UNEXPECTED);
   1127   }
   1128 
   1129   return OK;
   1130 }
   1131 
   1132 // CWD command
   1133 int FtpNetworkTransaction::DoCtrlWriteCWD() {
   1134   std::string command = "CWD " + GetRequestPathForFtpCommand(true);
   1135   next_state_ = STATE_CTRL_READ;
   1136   return SendFtpCommand(command, command, COMMAND_CWD);
   1137 }
   1138 
   1139 int FtpNetworkTransaction::ProcessResponseCWD(const FtpCtrlResponse& response) {
   1140   // We should never issue CWD if we know the target resource is a file.
   1141   DCHECK_NE(RESOURCE_TYPE_FILE, resource_type_);
   1142 
   1143   switch (GetErrorClass(response.status_code)) {
   1144     case ERROR_CLASS_INITIATED:
   1145       return Stop(ERR_INVALID_RESPONSE);
   1146     case ERROR_CLASS_OK:
   1147       next_state_ = STATE_CTRL_WRITE_LIST;
   1148       break;
   1149     case ERROR_CLASS_INFO_NEEDED:
   1150       return Stop(ERR_INVALID_RESPONSE);
   1151     case ERROR_CLASS_TRANSIENT_ERROR:
   1152       // Some FTP servers send response 451 (not a valid CWD response according
   1153       // to RFC 959) instead of 550.
   1154       if (response.status_code == 451)
   1155         return ProcessResponseCWDNotADirectory();
   1156 
   1157       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1158     case ERROR_CLASS_PERMANENT_ERROR:
   1159       if (response.status_code == 550)
   1160         return ProcessResponseCWDNotADirectory();
   1161 
   1162       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1163     default:
   1164       NOTREACHED();
   1165       return Stop(ERR_UNEXPECTED);
   1166   }
   1167 
   1168   return OK;
   1169 }
   1170 
   1171 int FtpNetworkTransaction::ProcessResponseCWDNotADirectory() {
   1172   if (resource_type_ == RESOURCE_TYPE_DIRECTORY) {
   1173     // We're assuming that the resource is a directory, but the server
   1174     // says it's not true. The most probable interpretation is that it
   1175     // doesn't exist (with FTP we can't be sure).
   1176     return Stop(ERR_FILE_NOT_FOUND);
   1177   }
   1178 
   1179   // We are here because SIZE failed and we are not sure what the resource
   1180   // type is. It could still be file, and SIZE could fail because of
   1181   // an access error (http://crbug.com/56734). Try RETR just to be sure.
   1182   resource_type_ = RESOURCE_TYPE_FILE;
   1183 
   1184   ResetDataConnectionAfterError(STATE_CTRL_WRITE_RETR);
   1185   return OK;
   1186 }
   1187 
   1188 // LIST command
   1189 int FtpNetworkTransaction::DoCtrlWriteLIST() {
   1190   // Use the -l option for mod_ftp configured in LISTIsNLST mode: the option
   1191   // forces LIST output instead of NLST (which would be ambiguous for us
   1192   // to parse).
   1193   std::string command("LIST -l");
   1194   if (system_type_ == SYSTEM_TYPE_VMS)
   1195     command = "LIST *.*;0";
   1196 
   1197   next_state_ = STATE_CTRL_READ;
   1198   return SendFtpCommand(command, command, COMMAND_LIST);
   1199 }
   1200 
   1201 int FtpNetworkTransaction::ProcessResponseLIST(
   1202     const FtpCtrlResponse& response) {
   1203   switch (GetErrorClass(response.status_code)) {
   1204     case ERROR_CLASS_INITIATED:
   1205       // We want the client to start reading the response at this point.
   1206       // It got here either through Start or RestartWithAuth. We want that
   1207       // method to complete. Not setting next state here will make DoLoop exit
   1208       // and in turn make Start/RestartWithAuth complete.
   1209       response_.is_directory_listing = true;
   1210       break;
   1211     case ERROR_CLASS_OK:
   1212       response_.is_directory_listing = true;
   1213       next_state_ = STATE_CTRL_WRITE_QUIT;
   1214       break;
   1215     case ERROR_CLASS_INFO_NEEDED:
   1216       return Stop(ERR_INVALID_RESPONSE);
   1217     case ERROR_CLASS_TRANSIENT_ERROR:
   1218       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1219     case ERROR_CLASS_PERMANENT_ERROR:
   1220       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
   1221     default:
   1222       NOTREACHED();
   1223       return Stop(ERR_UNEXPECTED);
   1224   }
   1225   return OK;
   1226 }
   1227 
   1228 // QUIT command
   1229 int FtpNetworkTransaction::DoCtrlWriteQUIT() {
   1230   std::string command = "QUIT";
   1231   next_state_ = STATE_CTRL_READ;
   1232   return SendFtpCommand(command, command, COMMAND_QUIT);
   1233 }
   1234 
   1235 int FtpNetworkTransaction::ProcessResponseQUIT(
   1236     const FtpCtrlResponse& response) {
   1237   ctrl_socket_->Disconnect();
   1238   return last_error_;
   1239 }
   1240 
   1241 // Data Connection
   1242 
   1243 int FtpNetworkTransaction::DoDataConnect() {
   1244   next_state_ = STATE_DATA_CONNECT_COMPLETE;
   1245   IPEndPoint ip_endpoint;
   1246   AddressList data_address;
   1247   // Connect to the same host as the control socket to prevent PASV port
   1248   // scanning attacks.
   1249   int rv = ctrl_socket_->GetPeerAddress(&ip_endpoint);
   1250   if (rv != OK)
   1251     return Stop(rv);
   1252   data_address = AddressList::CreateFromIPAddress(
   1253       ip_endpoint.address(), data_connection_port_);
   1254   data_socket_ = socket_factory_->CreateTransportClientSocket(
   1255         data_address, net_log_.net_log(), net_log_.source());
   1256   net_log_.AddEvent(
   1257       NetLog::TYPE_FTP_DATA_CONNECTION,
   1258       data_socket_->NetLog().source().ToEventParametersCallback());
   1259   return data_socket_->Connect(io_callback_);
   1260 }
   1261 
   1262 int FtpNetworkTransaction::DoDataConnectComplete(int result) {
   1263   if (result != OK && use_epsv_) {
   1264     // It's possible we hit a broken server, sadly. They can break in different
   1265     // ways. Some time out, some reset a connection. Fall back to PASV.
   1266     // TODO(phajdan.jr): remember it for future transactions with this server.
   1267     // TODO(phajdan.jr): write a test for this code path.
   1268     use_epsv_ = false;
   1269     next_state_ = STATE_CTRL_WRITE_PASV;
   1270     return OK;
   1271   }
   1272 
   1273   // Only record the connection error after we've applied all our fallbacks.
   1274   // We want to capture the final error, one we're not going to recover from.
   1275   RecordDataConnectionError(result);
   1276 
   1277   if (result != OK)
   1278     return Stop(result);
   1279 
   1280   next_state_ = state_after_data_connect_complete_;
   1281   return OK;
   1282 }
   1283 
   1284 int FtpNetworkTransaction::DoDataRead() {
   1285   DCHECK(read_data_buf_.get());
   1286   DCHECK_GT(read_data_buf_len_, 0);
   1287 
   1288   if (data_socket_ == NULL || !data_socket_->IsConnected()) {
   1289     // If we don't destroy the data socket completely, some servers will wait
   1290     // for us (http://crbug.com/21127). The half-closed TCP connection needs
   1291     // to be closed on our side too.
   1292     data_socket_.reset();
   1293 
   1294     if (ctrl_socket_->IsConnected()) {
   1295       // Wait for the server's response, we should get it before sending QUIT.
   1296       next_state_ = STATE_CTRL_READ;
   1297       return OK;
   1298     }
   1299 
   1300     // We are no longer connected to the server, so just finish the transaction.
   1301     return Stop(OK);
   1302   }
   1303 
   1304   next_state_ = STATE_DATA_READ_COMPLETE;
   1305   read_data_buf_->data()[0] = 0;
   1306   return data_socket_->Read(
   1307       read_data_buf_.get(), read_data_buf_len_, io_callback_);
   1308 }
   1309 
   1310 int FtpNetworkTransaction::DoDataReadComplete(int result) {
   1311   return result;
   1312 }
   1313 
   1314 // We're using a histogram as a group of counters, with one bucket for each
   1315 // enumeration value.  We're only interested in the values of the counters.
   1316 // Ignore the shape, average, and standard deviation of the histograms because
   1317 // they are meaningless.
   1318 //
   1319 // We use two histograms.  In the first histogram we tally whether the user has
   1320 // seen an error of that type during the session.  In the second histogram we
   1321 // tally the total number of times the users sees each errer.
   1322 void FtpNetworkTransaction::RecordDataConnectionError(int result) {
   1323   // Gather data for http://crbug.com/3073. See how many users have trouble
   1324   // establishing FTP data connection in passive FTP mode.
   1325   enum {
   1326     // Data connection successful.
   1327     NET_ERROR_OK = 0,
   1328 
   1329     // Local firewall blocked the connection.
   1330     NET_ERROR_ACCESS_DENIED = 1,
   1331 
   1332     // Connection timed out.
   1333     NET_ERROR_TIMED_OUT = 2,
   1334 
   1335     // Connection has been estabilished, but then got broken (either reset
   1336     // or aborted).
   1337     NET_ERROR_CONNECTION_BROKEN = 3,
   1338 
   1339     // Connection has been refused.
   1340     NET_ERROR_CONNECTION_REFUSED = 4,
   1341 
   1342     // No connection to the internet.
   1343     NET_ERROR_INTERNET_DISCONNECTED = 5,
   1344 
   1345     // Could not reach the destination address.
   1346     NET_ERROR_ADDRESS_UNREACHABLE = 6,
   1347 
   1348     // A programming error in our network stack.
   1349     NET_ERROR_UNEXPECTED = 7,
   1350 
   1351     // Other kind of error.
   1352     NET_ERROR_OTHER = 20,
   1353 
   1354     NUM_OF_NET_ERROR_TYPES
   1355   } type;
   1356   switch (result) {
   1357     case OK:
   1358       type = NET_ERROR_OK;
   1359       break;
   1360     case ERR_ACCESS_DENIED:
   1361     case ERR_NETWORK_ACCESS_DENIED:
   1362       type = NET_ERROR_ACCESS_DENIED;
   1363       break;
   1364     case ERR_TIMED_OUT:
   1365       type = NET_ERROR_TIMED_OUT;
   1366       break;
   1367     case ERR_CONNECTION_ABORTED:
   1368     case ERR_CONNECTION_RESET:
   1369     case ERR_CONNECTION_CLOSED:
   1370       type = NET_ERROR_CONNECTION_BROKEN;
   1371       break;
   1372     case ERR_CONNECTION_FAILED:
   1373     case ERR_CONNECTION_REFUSED:
   1374       type = NET_ERROR_CONNECTION_REFUSED;
   1375       break;
   1376     case ERR_INTERNET_DISCONNECTED:
   1377       type = NET_ERROR_INTERNET_DISCONNECTED;
   1378       break;
   1379     case ERR_ADDRESS_INVALID:
   1380     case ERR_ADDRESS_UNREACHABLE:
   1381       type = NET_ERROR_ADDRESS_UNREACHABLE;
   1382       break;
   1383     case ERR_UNEXPECTED:
   1384       type = NET_ERROR_UNEXPECTED;
   1385       break;
   1386     default:
   1387       type = NET_ERROR_OTHER;
   1388       break;
   1389   };
   1390   static bool had_error_type[NUM_OF_NET_ERROR_TYPES];
   1391 
   1392   DCHECK(type >= 0 && type < NUM_OF_NET_ERROR_TYPES);
   1393   if (!had_error_type[type]) {
   1394     had_error_type[type] = true;
   1395     UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorHappened",
   1396         type, NUM_OF_NET_ERROR_TYPES);
   1397   }
   1398   UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorCount",
   1399       type, NUM_OF_NET_ERROR_TYPES);
   1400 }
   1401 
   1402 }  // namespace net
   1403