The Tor Browser: netwerk/protocol/ftp/nsFtpConnectionThread.cpp@deefc01c0e14 (annotated)

netwerk/protocol/ftp/nsFtpConnectionThread.cpp@deefc01c0e14 (annotated)

netwerk/protocol/ftp/nsFtpConnectionThread.cpp

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim:set tw=80 ts=4 sts=4 sw=4 et cin: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <ctype.h>
 #include "prprf.h"
 #include "prlog.h"
 #include "prtime.h"
 #include "nsIOService.h"
 #include "nsFTPChannel.h"
 #include "nsFtpConnectionThread.h"
 #include "nsFtpControlConnection.h"
 #include "nsFtpProtocolHandler.h"
 #include "netCore.h"
 #include "nsCRT.h"
 #include "nsEscape.h"
 #include "nsMimeTypes.h"
 #include "nsNetUtil.h"
 #include "nsThreadUtils.h"
 #include "nsStreamUtils.h"
 #include "nsICacheService.h"
 #include "nsIURL.h"
 #include "nsISocketTransport.h"
 #include "nsIStreamListenerTee.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 #include "nsIStringBundle.h"
 #include "nsAuthInformationHolder.h"
 #include "nsIProtocolProxyService.h"
 #include "nsICancelable.h"
 #include "nsICacheEntryDescriptor.h"
 #include "nsIOutputStream.h"
 #include "nsIPrompt.h"
 #include "nsIProtocolHandler.h"
 #include "nsIProxyInfo.h"
 #include "nsIRunnable.h"
 #include "nsISocketTransportService.h"
 #include "nsIURI.h"
 #include "nsICacheSession.h"
 #ifdef MOZ_WIDGET_GONK
 #include "NetStatistics.h"
 #endif
 #if defined(PR_LOGGING)
 extern PRLogModuleInfo* gFTPLog;
 #endif
 #define LOG(args)         PR_LOG(gFTPLog, PR_LOG_DEBUG, args)
 #define LOG_ALWAYS(args)  PR_LOG(gFTPLog, PR_LOG_ALWAYS, args)
 using namespace mozilla::net;
 // remove FTP parameters (starting with ";") from the path
 static void
 removeParamsFromPath(nsCString& path)
 {
   int32_t index = path.FindChar(';');
   if (index >= 0) {
     path.SetLength(index);
   }
 }
 NS_IMPL_ISUPPORTS_INHERITED(nsFtpState,
                             nsBaseContentStream,
                             nsIInputStreamCallback,
                             nsITransportEventSink,
                             nsICacheListener,
                             nsIRequestObserver,
                             nsIProtocolProxyCallback)
 nsFtpState::nsFtpState()
     : nsBaseContentStream(true)
     , mState(FTP_INIT)
     , mNextState(FTP_S_USER)
     , mKeepRunning(true)
     , mReceivedControlData(false)
     , mTryingCachedControl(false)
     , mRETRFailed(false)
     , mFileSize(UINT64_MAX)
     , mServerType(FTP_GENERIC_TYPE)
     , mAction(GET)
     , mAnonymous(true)
     , mRetryPass(false)
     , mStorReplyReceived(false)
     , mInternalError(NS_OK)
     , mReconnectAndLoginAgain(false)
     , mCacheConnection(true)
     , mPort(21)
     , mAddressChecked(false)
     , mServerIsIPv6(false)
     , mUseUTF8(false)
     , mControlStatus(NS_OK)
     , mDeferredCallbackPending(false)
 {
     LOG_ALWAYS(("FTP:(%x) nsFtpState created", this));
     // make sure handler stays around
     NS_ADDREF(gFtpHandler);
 }
 nsFtpState::~nsFtpState()
 {
     LOG_ALWAYS(("FTP:(%x) nsFtpState destroyed", this));
     if (mProxyRequest)
         mProxyRequest->Cancel(NS_ERROR_FAILURE);
     // release reference to handler
     nsFtpProtocolHandler *handler = gFtpHandler;
     NS_RELEASE(handler);
 }
 // nsIInputStreamCallback implementation
 NS_IMETHODIMP
 nsFtpState::OnInputStreamReady(nsIAsyncInputStream *aInStream)
 {
     LOG(("FTP:(%p) data stream ready\n", this));
     // We are receiving a notification from our data stream, so just forward it
     // on to our stream callback.
     if (HasPendingCallback())
         DispatchCallbackSync();
     return NS_OK;
 }
 void
 nsFtpState::OnControlDataAvailable(const char *aData, uint32_t aDataLen)
 {
     LOG(("FTP:(%p) control data available [%u]\n", this, aDataLen));
     mControlConnection->WaitData(this);  // queue up another call
     if (!mReceivedControlData) {
         // parameter can be null cause the channel fills them in.
         OnTransportStatus(nullptr, NS_NET_STATUS_BEGIN_FTP_TRANSACTION, 0, 0);
         mReceivedControlData = true;
     }
     // Sometimes we can get two responses in the same packet, eg from LIST.
     // So we need to parse the response line by line
     nsCString buffer = mControlReadCarryOverBuf;
     // Clear the carryover buf - if we still don't have a line, then it will
     // be reappended below
     mControlReadCarryOverBuf.Truncate();
     buffer.Append(aData, aDataLen);
     const char* currLine = buffer.get();
     while (*currLine && mKeepRunning) {
         int32_t eolLength = strcspn(currLine, CRLF);
         int32_t currLineLength = strlen(currLine);
         // if currLine is empty or only contains CR or LF, then bail.  we can
         // sometimes get an ODA event with the full response line + CR without
         // the trailing LF.  the trailing LF might come in the next ODA event.
         // because we are happy enough to process a response line ending only
         // in CR, we need to take care to discard the extra LF (bug 191220).
         if (eolLength == 0 && currLineLength <= 1)
             break;
         if (eolLength == currLineLength) {
             mControlReadCarryOverBuf.Assign(currLine);
             break;
         }
         // Append the current segment, including the LF
         nsAutoCString line;
         int32_t crlfLength = 0;
         if ((currLineLength > eolLength) &&
             (currLine[eolLength] == nsCRT::CR) &&
             (currLine[eolLength+1] == nsCRT::LF)) {
             crlfLength = 2; // CR +LF
         } else {
             crlfLength = 1; // + LF or CR
         }
         line.Assign(currLine, eolLength + crlfLength);
         // Does this start with a response code?
         bool startNum = (line.Length() >= 3 &&
                            isdigit(line[0]) &&
                            isdigit(line[1]) &&
                            isdigit(line[2]));
         if (mResponseMsg.IsEmpty()) {
             // If we get here, then we know that we have a complete line, and
             // that it is the first one
             NS_ASSERTION(line.Length() > 4 && startNum,
                          "Read buffer doesn't include response code");
             mResponseCode = atoi(PromiseFlatCString(Substring(line,0,3)).get());
         }
         mResponseMsg.Append(line);
         // This is the last line if its 3 numbers followed by a space
         if (startNum && line[3] == ' ') {
             // yup. last line, let's move on.
             if (mState == mNextState) {
                 NS_ERROR("ftp read state mixup");
                 mInternalError = NS_ERROR_FAILURE;
                 mState = FTP_ERROR;
             } else {
                 mState = mNextState;
             }
             nsCOMPtr<nsIFTPEventSink> ftpSink;
             mChannel->GetFTPEventSink(ftpSink);
             if (ftpSink)
                 ftpSink->OnFTPControlLog(true, mResponseMsg.get());
             nsresult rv = Process();
             mResponseMsg.Truncate();
             if (NS_FAILED(rv)) {
                 CloseWithStatus(rv);
                 return;
             }
         }
         currLine = currLine + eolLength + crlfLength;
     }
 }
 void
 nsFtpState::OnControlError(nsresult status)
 {
     NS_ASSERTION(NS_FAILED(status), "expecting error condition");
     LOG(("FTP:(%p) CC(%p) error [%x was-cached=%u]\n",
          this, mControlConnection.get(), status, mTryingCachedControl));
     mControlStatus = status;
     if (mReconnectAndLoginAgain && NS_SUCCEEDED(mInternalError)) {
         mReconnectAndLoginAgain = false;
         mAnonymous = false;
         mControlStatus = NS_OK;
         Connect();
     } else if (mTryingCachedControl && NS_SUCCEEDED(mInternalError)) {
         mTryingCachedControl = false;
         Connect();
     } else {
         CloseWithStatus(status);
     }
 }
 nsresult
 nsFtpState::EstablishControlConnection()
 {
     NS_ASSERTION(!mControlConnection, "we already have a control connection");
     nsresult rv;
     LOG(("FTP:(%x) trying cached control\n", this));
     // Look to see if we can use a cached control connection:
     nsFtpControlConnection *connection = nullptr;
     // Don't use cached control if anonymous (bug #473371)
     if (!mChannel->HasLoadFlag(nsIRequest::LOAD_ANONYMOUS))
         gFtpHandler->RemoveConnection(mChannel->URI(), &connection);
     if (connection) {
         mControlConnection.swap(connection);
         if (mControlConnection->IsAlive())
         {
             // set stream listener of the control connection to be us.
             mControlConnection->WaitData(this);
             // read cached variables into us.
             mServerType = mControlConnection->mServerType;
             mPassword   = mControlConnection->mPassword;
             mPwd        = mControlConnection->mPwd;
             mUseUTF8    = mControlConnection->mUseUTF8;
             mTryingCachedControl = true;
             // we have to set charset to connection if server supports utf-8
             if (mUseUTF8)
                 mChannel->SetContentCharset(NS_LITERAL_CSTRING("UTF-8"));
             // we're already connected to this server, skip login.
             mState = FTP_S_PASV;
             mResponseCode = 530;  // assume the control connection was dropped.
             mControlStatus = NS_OK;
             mReceivedControlData = false;  // For this request, we have not.
             // if we succeed, return.  Otherwise, we need to create a transport
             rv = mControlConnection->Connect(mChannel->ProxyInfo(), this);
             if (NS_SUCCEEDED(rv))
                 return rv;
         }
         LOG(("FTP:(%p) cached CC(%p) is unusable\n", this,
             mControlConnection.get()));
         mControlConnection->WaitData(nullptr);
         mControlConnection = nullptr;
     }
     LOG(("FTP:(%p) creating CC\n", this));
     mState = FTP_READ_BUF;
     mNextState = FTP_S_USER;
     nsAutoCString host;
     rv = mChannel->URI()->GetAsciiHost(host);
     if (NS_FAILED(rv))
         return rv;
     mControlConnection = new nsFtpControlConnection(host, mPort);
     if (!mControlConnection)
         return NS_ERROR_OUT_OF_MEMORY;
     rv = mControlConnection->Connect(mChannel->ProxyInfo(), this);
     if (NS_FAILED(rv)) {
         LOG(("FTP:(%p) CC(%p) failed to connect [rv=%x]\n", this,
             mControlConnection.get(), rv));
         mControlConnection = nullptr;
         return rv;
     }
     return mControlConnection->WaitData(this);
 }
 void
 nsFtpState::MoveToNextState(FTP_STATE nextState)
 {
     if (NS_FAILED(mInternalError)) {
         mState = FTP_ERROR;
         LOG(("FTP:(%x) FAILED (%x)\n", this, mInternalError));
     } else {
         mState = FTP_READ_BUF;
         mNextState = nextState;
     }
 }
 nsresult
 nsFtpState::Process()
 {
     nsresult    rv = NS_OK;
     bool        processingRead = true;
     while (mKeepRunning && processingRead) {
         switch (mState) {
           case FTP_COMMAND_CONNECT:
             KillControlConnection();
             LOG(("FTP:(%p) establishing CC", this));
             mInternalError = EstablishControlConnection();  // sets mState
             if (NS_FAILED(mInternalError)) {
                 mState = FTP_ERROR;
                 LOG(("FTP:(%p) FAILED\n", this));
             } else {
                 LOG(("FTP:(%p) SUCCEEDED\n", this));
             }
             break;
           case FTP_READ_BUF:
             LOG(("FTP:(%p) Waiting for CC(%p)\n", this,
                 mControlConnection.get()));
             processingRead = false;
             break;
           case FTP_ERROR: // xx needs more work to handle dropped control connection cases
             if ((mTryingCachedControl && mResponseCode == 530 &&
                 mInternalError == NS_ERROR_FTP_PASV) ||
                 (mResponseCode == 425 &&
                 mInternalError == NS_ERROR_FTP_PASV)) {
                 // The user was logged out during an pasv operation
                 // we want to restart this request with a new control
                 // channel.
                 mState = FTP_COMMAND_CONNECT;
             } else if (mResponseCode == 421 &&
                        mInternalError != NS_ERROR_FTP_LOGIN) {
                 // The command channel dropped for some reason.
                 // Fire it back up, unless we were trying to login
                 // in which case the server might just be telling us
                 // that the max number of users has been reached...
                 mState = FTP_COMMAND_CONNECT;
             } else if (mAnonymous &&
                        mInternalError == NS_ERROR_FTP_LOGIN) {
                 // If the login was anonymous, and it failed, try again with a username
                 // Don't reuse old control connection, see #386167
                 mAnonymous = false;
                 mState = FTP_COMMAND_CONNECT;
             } else {
                 LOG(("FTP:(%x) FTP_ERROR - calling StopProcessing\n", this));
                 rv = StopProcessing();
                 NS_ASSERTION(NS_SUCCEEDED(rv), "StopProcessing failed.");
                 processingRead = false;
             }
             break;
           case FTP_COMPLETE:
             LOG(("FTP:(%x) COMPLETE\n", this));
             rv = StopProcessing();
             NS_ASSERTION(NS_SUCCEEDED(rv), "StopProcessing failed.");
             processingRead = false;
             break;
 // USER
           case FTP_S_USER:
             rv = S_user();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_LOGIN;
             MoveToNextState(FTP_R_USER);
             break;
           case FTP_R_USER:
             mState = R_user();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_LOGIN;
             break;
 // PASS
           case FTP_S_PASS:
             rv = S_pass();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_LOGIN;
             MoveToNextState(FTP_R_PASS);
             break;
           case FTP_R_PASS:
             mState = R_pass();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_LOGIN;
             break;
 // ACCT
           case FTP_S_ACCT:
             rv = S_acct();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_LOGIN;
             MoveToNextState(FTP_R_ACCT);
             break;
           case FTP_R_ACCT:
             mState = R_acct();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_LOGIN;
             break;
 // SYST
           case FTP_S_SYST:
             rv = S_syst();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_LOGIN;
             MoveToNextState(FTP_R_SYST);
             break;
           case FTP_R_SYST:
             mState = R_syst();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_LOGIN;
             break;
 // TYPE
           case FTP_S_TYPE:
             rv = S_type();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_TYPE);
             break;
           case FTP_R_TYPE:
             mState = R_type();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // CWD
           case FTP_S_CWD:
             rv = S_cwd();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_CWD;
             MoveToNextState(FTP_R_CWD);
             break;
           case FTP_R_CWD:
             mState = R_cwd();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_CWD;
             break;
 // LIST
           case FTP_S_LIST:
             rv = S_list();
             if (rv == NS_ERROR_NOT_RESUMABLE) {
                 mInternalError = rv;
             } else if (NS_FAILED(rv)) {
                 mInternalError = NS_ERROR_FTP_CWD;
             }
             MoveToNextState(FTP_R_LIST);
             break;
           case FTP_R_LIST:
             mState = R_list();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // SIZE
           case FTP_S_SIZE:
             rv = S_size();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_SIZE);
             break;
           case FTP_R_SIZE:
             mState = R_size();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // REST
           case FTP_S_REST:
             rv = S_rest();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_REST);
             break;
           case FTP_R_REST:
             mState = R_rest();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // MDTM
           case FTP_S_MDTM:
             rv = S_mdtm();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_MDTM);
             break;
           case FTP_R_MDTM:
             mState = R_mdtm();
             // Don't want to overwrite a more explicit status code
             if (FTP_ERROR == mState && NS_SUCCEEDED(mInternalError))
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // RETR
           case FTP_S_RETR:
             rv = S_retr();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_RETR);
             break;
           case FTP_R_RETR:
             mState = R_retr();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // STOR
           case FTP_S_STOR:
             rv = S_stor();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_STOR);
             break;
           case FTP_R_STOR:
             mState = R_stor();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // PASV
           case FTP_S_PASV:
             rv = S_pasv();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_PASV;
             MoveToNextState(FTP_R_PASV);
             break;
           case FTP_R_PASV:
             mState = R_pasv();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_PASV;
             break;
 // PWD
           case FTP_S_PWD:
             rv = S_pwd();
             if (NS_FAILED(rv))
                 mInternalError = NS_ERROR_FTP_PWD;
             MoveToNextState(FTP_R_PWD);
             break;
           case FTP_R_PWD:
             mState = R_pwd();
             if (FTP_ERROR == mState)
                 mInternalError = NS_ERROR_FTP_PWD;
             break;
 // FEAT for RFC2640 support
           case FTP_S_FEAT:
             rv = S_feat();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_FEAT);
             break;
           case FTP_R_FEAT:
             mState = R_feat();
             // Don't want to overwrite a more explicit status code
             if (FTP_ERROR == mState && NS_SUCCEEDED(mInternalError))
                 mInternalError = NS_ERROR_FAILURE;
             break;
 // OPTS for some non-RFC2640-compliant servers support
           case FTP_S_OPTS:
             rv = S_opts();
             if (NS_FAILED(rv))
                 mInternalError = rv;
             MoveToNextState(FTP_R_OPTS);
             break;
           case FTP_R_OPTS:
             mState = R_opts();
             // Don't want to overwrite a more explicit status code
             if (FTP_ERROR == mState && NS_SUCCEEDED(mInternalError))
                 mInternalError = NS_ERROR_FAILURE;
             break;
           default:
             ;
         }
     }
     return rv;
 }
 ///////////////////////////////////
 // STATE METHODS
 ///////////////////////////////////
 nsresult
 nsFtpState::S_user() {
     // some servers on connect send us a 421 or 521.  (84525) (141784)
     if ((mResponseCode == 421) || (mResponseCode == 521))
         return NS_ERROR_FAILURE;
     nsresult rv;
     nsAutoCString usernameStr("USER ");
     mResponseMsg = "";
     if (mAnonymous) {
         mReconnectAndLoginAgain = true;
         usernameStr.AppendLiteral("anonymous");
     } else {
         mReconnectAndLoginAgain = false;
         if (mUsername.IsEmpty()) {
             // No prompt for anonymous requests (bug #473371)
             if (mChannel->HasLoadFlag(nsIRequest::LOAD_ANONYMOUS))
               return NS_ERROR_FAILURE;
             nsCOMPtr<nsIAuthPrompt2> prompter;
             NS_QueryAuthPrompt2(static_cast<nsIChannel*>(mChannel),
                                 getter_AddRefs(prompter));
             if (!prompter)
                 return NS_ERROR_NOT_INITIALIZED;
             nsRefPtr<nsAuthInformationHolder> info =
                 new nsAuthInformationHolder(nsIAuthInformation::AUTH_HOST,
                                             EmptyString(),
                                             EmptyCString());
             bool retval;
             rv = prompter->PromptAuth(mChannel, nsIAuthPrompt2::LEVEL_NONE,
                                       info, &retval);
             // if the user canceled or didn't supply a username we want to fail
             if (NS_FAILED(rv) || !retval || info->User().IsEmpty())
                 return NS_ERROR_FAILURE;
             mUsername = info->User();
             mPassword = info->Password();
         }
         // XXX Is UTF-8 the best choice?
         AppendUTF16toUTF8(mUsername, usernameStr);
     }
     usernameStr.Append(CRLF);
     return SendFTPCommand(usernameStr);
 }
 FTP_STATE
 nsFtpState::R_user() {
     mReconnectAndLoginAgain = false;
     if (mResponseCode/100 == 3) {
         // send off the password
         return FTP_S_PASS;
     }
     if (mResponseCode/100 == 2) {
         // no password required, we're already logged in
         return FTP_S_SYST;
     }
     if (mResponseCode/100 == 5) {
         // problem logging in. typically this means the server
         // has reached it's user limit.
         return FTP_ERROR;
     }
     // LOGIN FAILED
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_pass() {
     nsresult rv;
     nsAutoCString passwordStr("PASS ");
     mResponseMsg = "";
     if (mAnonymous) {
         if (!mPassword.IsEmpty()) {
             // XXX Is UTF-8 the best choice?
             AppendUTF16toUTF8(mPassword, passwordStr);
         } else {
             nsXPIDLCString anonPassword;
             bool useRealEmail = false;
             nsCOMPtr<nsIPrefBranch> prefs =
                     do_GetService(NS_PREFSERVICE_CONTRACTID);
             if (prefs) {
                 rv = prefs->GetBoolPref("advanced.mailftp", &useRealEmail);
                 if (NS_SUCCEEDED(rv) && useRealEmail) {
                     prefs->GetCharPref("network.ftp.anonymous_password",
                                        getter_Copies(anonPassword));
                 }
             }
             if (!anonPassword.IsEmpty()) {
                 passwordStr.AppendASCII(anonPassword);
             } else {
                 // We need to default to a valid email address - bug 101027
                 // example.com is reserved (rfc2606), so use that
                 passwordStr.AppendLiteral("mozilla@example.com");
             }
         }
     } else {
         if (mPassword.IsEmpty() || mRetryPass) {
             // No prompt for anonymous requests (bug #473371)
             if (mChannel->HasLoadFlag(nsIRequest::LOAD_ANONYMOUS))
                 return NS_ERROR_FAILURE;
             nsCOMPtr<nsIAuthPrompt2> prompter;
             NS_QueryAuthPrompt2(static_cast<nsIChannel*>(mChannel),
                                 getter_AddRefs(prompter));
             if (!prompter)
                 return NS_ERROR_NOT_INITIALIZED;
             nsRefPtr<nsAuthInformationHolder> info =
                 new nsAuthInformationHolder(nsIAuthInformation::AUTH_HOST |
                                             nsIAuthInformation::ONLY_PASSWORD,
                                             EmptyString(),
                                             EmptyCString());
             info->SetUserInternal(mUsername);
             bool retval;
             rv = prompter->PromptAuth(mChannel, nsIAuthPrompt2::LEVEL_NONE,
                                       info, &retval);
             // we want to fail if the user canceled. Note here that if they want
             // a blank password, we will pass it along.
             if (NS_FAILED(rv) || !retval)
                 return NS_ERROR_FAILURE;
             mPassword = info->Password();
         }
         // XXX Is UTF-8 the best choice?
         AppendUTF16toUTF8(mPassword, passwordStr);
     }
     passwordStr.Append(CRLF);
     return SendFTPCommand(passwordStr);
 }
 FTP_STATE
 nsFtpState::R_pass() {
     if (mResponseCode/100 == 3) {
         // send account info
         return FTP_S_ACCT;
     }
     if (mResponseCode/100 == 2) {
         // logged in
         return FTP_S_SYST;
     }
     if (mResponseCode == 503) {
         // start over w/ the user command.
         // note: the password was successful, and it's stored in mPassword
         mRetryPass = false;
         return FTP_S_USER;
     }
     if (mResponseCode/100 == 5 || mResponseCode==421) {
         // There is no difference between a too-many-users error,
         // a wrong-password error, or any other sort of error
         if (!mAnonymous)
             mRetryPass = true;
         return FTP_ERROR;
     }
     // unexpected response code
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_pwd() {
     return SendFTPCommand(NS_LITERAL_CSTRING("PWD" CRLF));
 }
 FTP_STATE
 nsFtpState::R_pwd() {
     // Error response to PWD command isn't fatal, but don't cache the connection
     // if CWD command is sent since correct mPwd is needed for further requests.
     if (mResponseCode/100 != 2)
         return FTP_S_TYPE;
     nsAutoCString respStr(mResponseMsg);
     int32_t pos = respStr.FindChar('"');
     if (pos > -1) {
         respStr.Cut(0, pos+1);
         pos = respStr.FindChar('"');
         if (pos > -1) {
             respStr.Truncate(pos);
             if (mServerType == FTP_VMS_TYPE)
                 ConvertDirspecFromVMS(respStr);
             if (respStr.IsEmpty() || respStr.Last() != '/')
                 respStr.Append('/');
             mPwd = respStr;
         }
     }
     return FTP_S_TYPE;
 }
 nsresult
 nsFtpState::S_syst() {
     return SendFTPCommand(NS_LITERAL_CSTRING("SYST" CRLF));
 }
 FTP_STATE
 nsFtpState::R_syst() {
     if (mResponseCode/100 == 2) {
         if (( mResponseMsg.Find("L8") > -1) ||
             ( mResponseMsg.Find("UNIX") > -1) ||
             ( mResponseMsg.Find("BSD") > -1) ||
             ( mResponseMsg.Find("MACOS Peter's Server") > -1) ||
             ( mResponseMsg.Find("MACOS WebSTAR FTP") > -1) ||
             ( mResponseMsg.Find("MVS") > -1) ||
             ( mResponseMsg.Find("OS/390") > -1) ||
             ( mResponseMsg.Find("OS/400") > -1)) {
             mServerType = FTP_UNIX_TYPE;
         } else if (( mResponseMsg.Find("WIN32", true) > -1) ||
                    ( mResponseMsg.Find("windows", true) > -1)) {
             mServerType = FTP_NT_TYPE;
         } else if (mResponseMsg.Find("OS/2", true) > -1) {
             mServerType = FTP_OS2_TYPE;
         } else if (mResponseMsg.Find("VMS", true) > -1) {
             mServerType = FTP_VMS_TYPE;
         } else {
             NS_ERROR("Server type list format unrecognized.");
             // Guessing causes crashes.
             // (Of course, the parsing code should be more robust...)
             nsCOMPtr<nsIStringBundleService> bundleService =
                 do_GetService(NS_STRINGBUNDLE_CONTRACTID);
             if (!bundleService)
                 return FTP_ERROR;
             nsCOMPtr<nsIStringBundle> bundle;
             nsresult rv = bundleService->CreateBundle(NECKO_MSGS_URL,
                                                       getter_AddRefs(bundle));
             if (NS_FAILED(rv))
                 return FTP_ERROR;
             char16_t* ucs2Response = ToNewUnicode(mResponseMsg);
             const char16_t *formatStrings[1] = { ucs2Response };
             NS_NAMED_LITERAL_STRING(name, "UnsupportedFTPServer");
             nsXPIDLString formattedString;
             rv = bundle->FormatStringFromName(name.get(), formatStrings, 1,
                                               getter_Copies(formattedString));
             nsMemory::Free(ucs2Response);
             if (NS_FAILED(rv))
                 return FTP_ERROR;
             // TODO(darin): this code should not be dictating UI like this!
             nsCOMPtr<nsIPrompt> prompter;
             mChannel->GetCallback(prompter);
             if (prompter)
                 prompter->Alert(nullptr, formattedString.get());
             // since we just alerted the user, clear mResponseMsg,
             // which is displayed to the user.
             mResponseMsg = "";
             return FTP_ERROR;
         }
         return FTP_S_FEAT;
     }
     if (mResponseCode/100 == 5) {
         // server didn't like the SYST command.  Probably (500, 501, 502)
         // No clue.  We will just hope it is UNIX type server.
         mServerType = FTP_UNIX_TYPE;
         return FTP_S_FEAT;
     }
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_acct() {
     return SendFTPCommand(NS_LITERAL_CSTRING("ACCT noaccount" CRLF));
 }
 FTP_STATE
 nsFtpState::R_acct() {
     if (mResponseCode/100 == 2)
         return FTP_S_SYST;
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_type() {
     return SendFTPCommand(NS_LITERAL_CSTRING("TYPE I" CRLF));
 }
 FTP_STATE
 nsFtpState::R_type() {
     if (mResponseCode/100 != 2)
         return FTP_ERROR;
     return FTP_S_PASV;
 }
 nsresult
 nsFtpState::S_cwd() {
     // Don't cache the connection if PWD command failed
     if (mPwd.IsEmpty())
         mCacheConnection = false;
     nsAutoCString cwdStr;
     if (mAction != PUT)
         cwdStr = mPath;
     if (cwdStr.IsEmpty() || cwdStr.First() != '/')
         cwdStr.Insert(mPwd,0);
     if (mServerType == FTP_VMS_TYPE)
         ConvertDirspecToVMS(cwdStr);
     cwdStr.Insert("CWD ",0);
     cwdStr.Append(CRLF);
     return SendFTPCommand(cwdStr);
 }
 FTP_STATE
 nsFtpState::R_cwd() {
     if (mResponseCode/100 == 2) {
         if (mAction == PUT)
             return FTP_S_STOR;
         return FTP_S_LIST;
     }
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_size() {
     nsAutoCString sizeBuf(mPath);
     if (sizeBuf.IsEmpty() || sizeBuf.First() != '/')
         sizeBuf.Insert(mPwd,0);
     if (mServerType == FTP_VMS_TYPE)
         ConvertFilespecToVMS(sizeBuf);
     sizeBuf.Insert("SIZE ",0);
     sizeBuf.Append(CRLF);
     return SendFTPCommand(sizeBuf);
 }
 FTP_STATE
 nsFtpState::R_size() {
     if (mResponseCode/100 == 2) {
         PR_sscanf(mResponseMsg.get() + 4, "%llu", &mFileSize);
         mChannel->SetContentLength(mFileSize);
     }
     // We may want to be able to resume this
     return FTP_S_MDTM;
 }
 nsresult
 nsFtpState::S_mdtm() {
     nsAutoCString mdtmBuf(mPath);
     if (mdtmBuf.IsEmpty() || mdtmBuf.First() != '/')
         mdtmBuf.Insert(mPwd,0);
     if (mServerType == FTP_VMS_TYPE)
         ConvertFilespecToVMS(mdtmBuf);
     mdtmBuf.Insert("MDTM ",0);
     mdtmBuf.Append(CRLF);
     return SendFTPCommand(mdtmBuf);
 }
 FTP_STATE
 nsFtpState::R_mdtm() {
     if (mResponseCode == 213) {
         mResponseMsg.Cut(0,4);
         mResponseMsg.Trim(" \t\r\n");
         // yyyymmddhhmmss
         if (mResponseMsg.Length() != 14) {
             NS_ASSERTION(mResponseMsg.Length() == 14, "Unknown MDTM response");
         } else {
             mModTime = mResponseMsg;
             // Save lastModified time for downloaded files.
             nsAutoCString timeString;
             nsresult error;
             PRExplodedTime exTime;
             mResponseMsg.Mid(timeString, 0, 4);
             exTime.tm_year  = timeString.ToInteger(&error);
             mResponseMsg.Mid(timeString, 4, 2);
             exTime.tm_month = timeString.ToInteger(&error) - 1; //january = 0
             mResponseMsg.Mid(timeString, 6, 2);
             exTime.tm_mday  = timeString.ToInteger(&error);
             mResponseMsg.Mid(timeString, 8, 2);
             exTime.tm_hour  = timeString.ToInteger(&error);
             mResponseMsg.Mid(timeString, 10, 2);
             exTime.tm_min   = timeString.ToInteger(&error);
             mResponseMsg.Mid(timeString, 12, 2);
             exTime.tm_sec   = timeString.ToInteger(&error);
             exTime.tm_usec  = 0;
             exTime.tm_params.tp_gmt_offset = 0;
             exTime.tm_params.tp_dst_offset = 0;
             PR_NormalizeTime(&exTime, PR_GMTParameters);
             exTime.tm_params = PR_LocalTimeParameters(&exTime);
             PRTime time = PR_ImplodeTime(&exTime);
             (void)mChannel->SetLastModifiedTime(time);
         }
     }
     nsCString entityID;
     entityID.Truncate();
     entityID.AppendInt(int64_t(mFileSize));
     entityID.Append('/');
     entityID.Append(mModTime);
     mChannel->SetEntityID(entityID);
     // We weren't asked to resume
     if (!mChannel->ResumeRequested())
         return FTP_S_RETR;
     //if (our entityID == supplied one (if any))
     if (mSuppliedEntityID.IsEmpty() || entityID.Equals(mSuppliedEntityID))
         return FTP_S_REST;
     mInternalError = NS_ERROR_ENTITY_CHANGED;
     mResponseMsg.Truncate();
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::SetContentType()
 {
     // FTP directory URLs don't always end in a slash.  Make sure they do.
     // This check needs to be here rather than a more obvious place
     // (e.g. LIST command processing) so that it ensures the terminating
     // slash is appended for the new request case, as well as the case
     // where the URL is being loaded from the cache.
     if (!mPath.IsEmpty() && mPath.Last() != '/') {
         nsCOMPtr<nsIURL> url = (do_QueryInterface(mChannel->URI()));
         nsAutoCString filePath;
         if(NS_SUCCEEDED(url->GetFilePath(filePath))) {
             filePath.Append('/');
             url->SetFilePath(filePath);
         }
     }
     return mChannel->SetContentType(
         NS_LITERAL_CSTRING(APPLICATION_HTTP_INDEX_FORMAT));
 }
 nsresult
 nsFtpState::S_list() {
     nsresult rv = SetContentType();
     if (NS_FAILED(rv))
         // XXX Invalid cast of FTP_STATE to nsresult -- FTP_ERROR has
         // value < 0x80000000 and will pass NS_SUCCEEDED() (bug 778109)
         return (nsresult)FTP_ERROR;
     rv = mChannel->PushStreamConverter("text/ftp-dir",
                                        APPLICATION_HTTP_INDEX_FORMAT);
     if (NS_FAILED(rv)) {
         // clear mResponseMsg which is displayed to the user.
         // TODO: we should probably set this to something meaningful.
         mResponseMsg = "";
         return rv;
     }
     if (mCacheEntry) {
         // save off the server type if we are caching.
         nsAutoCString serverType;
         serverType.AppendInt(mServerType);
         mCacheEntry->SetMetaDataElement("servertype", serverType.get());
         nsAutoCString useUTF8;
         useUTF8.AppendInt(mUseUTF8);
         mCacheEntry->SetMetaDataElement("useUTF8", useUTF8.get());
         // open cache entry for writing, and configure it to receive data.
         if (NS_FAILED(InstallCacheListener())) {
             mCacheEntry->AsyncDoom(nullptr);
             mCacheEntry = nullptr;
         }
     }
     // dir listings aren't resumable
     NS_ENSURE_TRUE(!mChannel->ResumeRequested(), NS_ERROR_NOT_RESUMABLE);
     mChannel->SetEntityID(EmptyCString());
     const char *listString;
     if (mServerType == FTP_VMS_TYPE) {
         listString = "LIST *.*;0" CRLF;
     } else {
         listString = "LIST" CRLF;
     }
     return SendFTPCommand(nsDependentCString(listString));
 }
 FTP_STATE
 nsFtpState::R_list() {
     if (mResponseCode/100 == 1) {
         // OK, time to start reading from the data connection.
         if (mDataStream && HasPendingCallback())
             mDataStream->AsyncWait(this, 0, 0, CallbackTarget());
         return FTP_READ_BUF;
     }
     if (mResponseCode/100 == 2) {
         //(DONE)
         mNextState = FTP_COMPLETE;
         mDoomCache = false;
         return FTP_COMPLETE;
     }
     return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_retr() {
     nsAutoCString retrStr(mPath);
     if (retrStr.IsEmpty() || retrStr.First() != '/')
         retrStr.Insert(mPwd,0);
     if (mServerType == FTP_VMS_TYPE)
         ConvertFilespecToVMS(retrStr);
     retrStr.Insert("RETR ",0);
     retrStr.Append(CRLF);
     return SendFTPCommand(retrStr);
 }
 FTP_STATE
 nsFtpState::R_retr() {
     if (mResponseCode/100 == 2) {
         //(DONE)
         mNextState = FTP_COMPLETE;
         return FTP_COMPLETE;
     }
     if (mResponseCode/100 == 1) {
         // We're going to grab a file, not a directory. So we need to clear
         // any cache entry, otherwise we'll have problems reading it later.
         // See bug 122548
         if (mCacheEntry) {
             (void)mCacheEntry->AsyncDoom(nullptr);
             mCacheEntry = nullptr;
         }
         if (mDataStream && HasPendingCallback())
             mDataStream->AsyncWait(this, 0, 0, CallbackTarget());
         return FTP_READ_BUF;
     }
     // These error codes are related to problems with the connection.
     // If we encounter any at this point, do not try CWD and abort.
     if (mResponseCode == 421 || mResponseCode == 425 || mResponseCode == 426)
         return FTP_ERROR;
     if (mResponseCode/100 == 5) {
         mRETRFailed = true;
         return FTP_S_PASV;
     }
     return FTP_S_CWD;
 }
 nsresult
 nsFtpState::S_rest() {
     nsAutoCString restString("REST ");
     // The int64_t cast is needed to avoid ambiguity
     restString.AppendInt(int64_t(mChannel->StartPos()), 10);
     restString.Append(CRLF);
     return SendFTPCommand(restString);
 }
 FTP_STATE
 nsFtpState::R_rest() {
     if (mResponseCode/100 == 4) {
         // If REST fails, then we can't resume
         mChannel->SetEntityID(EmptyCString());
         mInternalError = NS_ERROR_NOT_RESUMABLE;
         mResponseMsg.Truncate();
         return FTP_ERROR;
     }
     return FTP_S_RETR;
 }
 nsresult
 nsFtpState::S_stor() {
     NS_ENSURE_STATE(mChannel->UploadStream());
     NS_ASSERTION(mAction == PUT, "Wrong state to be here");
     nsCOMPtr<nsIURL> url = do_QueryInterface(mChannel->URI());
     NS_ASSERTION(url, "I thought you were a nsStandardURL");
     nsAutoCString storStr;
     url->GetFilePath(storStr);
     NS_ASSERTION(!storStr.IsEmpty(), "What does it mean to store a empty path");
     // kill the first slash since we want to be relative to CWD.
     if (storStr.First() == '/')
         storStr.Cut(0,1);
     if (mServerType == FTP_VMS_TYPE)
         ConvertFilespecToVMS(storStr);
     NS_UnescapeURL(storStr);
     storStr.Insert("STOR ",0);
     storStr.Append(CRLF);
     return SendFTPCommand(storStr);
 }
 FTP_STATE
 nsFtpState::R_stor() {
     if (mResponseCode/100 == 2) {
         //(DONE)
         mNextState = FTP_COMPLETE;
         mStorReplyReceived = true;
         // Call Close() if it was not called in nsFtpState::OnStoprequest()
         if (!mUploadRequest && !IsClosed())
             Close();
         return FTP_COMPLETE;
     }
     if (mResponseCode/100 == 1) {
         LOG(("FTP:(%x) writing on DT\n", this));
         return FTP_READ_BUF;
     }
    mStorReplyReceived = true;
    return FTP_ERROR;
 }
 nsresult
 nsFtpState::S_pasv() {
     if (!mAddressChecked) {
         // Find socket address
         mAddressChecked = true;
         mServerAddress.raw.family = AF_INET;
         mServerAddress.inet.ip = htonl(INADDR_ANY);
         mServerAddress.inet.port = htons(0);
         nsITransport *controlSocket = mControlConnection->Transport();
         if (!controlSocket)
             // XXX Invalid cast of FTP_STATE to nsresult -- FTP_ERROR has
             // value < 0x80000000 and will pass NS_SUCCEEDED() (bug 778109)
             return (nsresult)FTP_ERROR;
         nsCOMPtr<nsISocketTransport> sTrans = do_QueryInterface(controlSocket);
         if (sTrans) {
             nsresult rv = sTrans->GetPeerAddr(&mServerAddress);
             if (NS_SUCCEEDED(rv)) {
                 if (!IsIPAddrAny(&mServerAddress))
                     mServerIsIPv6 = (mServerAddress.raw.family == AF_INET6) &&
                                     !IsIPAddrV4Mapped(&mServerAddress);
                 else {
                     /*
                      * In case of SOCKS5 remote DNS resolution, we do
                      * not know the remote IP address. Still, if it is
                      * an IPV6 host, then the external address of the
                      * socks server should also be IPv6, and this is the
                      * self address of the transport.
                      */
                     NetAddr selfAddress;
                     rv = sTrans->GetSelfAddr(&selfAddress);
                     if (NS_SUCCEEDED(rv))
                         mServerIsIPv6 = (selfAddress.raw.family == AF_INET6) &&
                                         !IsIPAddrV4Mapped(&selfAddress);
                 }
             }
         }
     }
     const char *string;
     if (mServerIsIPv6) {
         string = "EPSV" CRLF;
     } else {
         string = "PASV" CRLF;
     }
     return SendFTPCommand(nsDependentCString(string));
 }
 FTP_STATE
 nsFtpState::R_pasv() {
     if (mResponseCode/100 != 2)
         return FTP_ERROR;
     nsresult rv;
     int32_t port;
     nsAutoCString responseCopy(mResponseMsg);
     char *response = responseCopy.BeginWriting();
     char *ptr = response;
     // Make sure to ignore the address in the PASV response (bug 370559)
     if (mServerIsIPv6) {
         // The returned string is of the form
         // text (|||ppp|)
         // Where '|' can be any single character
         char delim;
         while (*ptr && *ptr != '(')
             ptr++;
         if (*ptr++ != '(')
             return FTP_ERROR;
         delim = *ptr++;
         if (!delim || *ptr++ != delim ||
                       *ptr++ != delim ||
                       *ptr < '0' || *ptr > '9')
             return FTP_ERROR;
         port = 0;
         do {
             port = port * 10 + *ptr++ - '0';
         } while (*ptr >= '0' && *ptr <= '9');
         if (*ptr++ != delim || *ptr != ')')
             return FTP_ERROR;
     } else {
         // The returned address string can be of the form
         // (xxx,xxx,xxx,xxx,ppp,ppp) or
         //  xxx,xxx,xxx,xxx,ppp,ppp (without parens)
         int32_t h0, h1, h2, h3, p0, p1;
         uint32_t fields = 0;
         // First try with parens
         while (*ptr && *ptr != '(')
             ++ptr;
         if (*ptr) {
             ++ptr;
             fields = PR_sscanf(ptr,
                                "%ld,%ld,%ld,%ld,%ld,%ld",
                                &h0, &h1, &h2, &h3, &p0, &p1);
         }
         if (!*ptr || fields < 6) {
             // OK, lets try w/o parens
             ptr = response;
             while (*ptr && *ptr != ',')
                 ++ptr;
             if (*ptr) {
                 // backup to the start of the digits
                 do {
                     ptr--;
                 } while ((ptr >=response) && (*ptr >= '0') && (*ptr <= '9'));
                 ptr++; // get back onto the numbers
                 fields = PR_sscanf(ptr,
                                    "%ld,%ld,%ld,%ld,%ld,%ld",
                                    &h0, &h1, &h2, &h3, &p0, &p1);
             }
         }
         NS_ASSERTION(fields == 6, "Can't parse PASV response");
         if (fields < 6)
             return FTP_ERROR;
         port = ((int32_t) (p0<<8)) + p1;
     }
     bool newDataConn = true;
     if (mDataTransport) {
         // Reuse this connection only if its still alive, and the port
         // is the same
         nsCOMPtr<nsISocketTransport> strans = do_QueryInterface(mDataTransport);
         if (strans) {
             int32_t oldPort;
             nsresult rv = strans->GetPort(&oldPort);
             if (NS_SUCCEEDED(rv)) {
                 if (oldPort == port) {
                     bool isAlive;
                     if (NS_SUCCEEDED(strans->IsAlive(&isAlive)) && isAlive)
                         newDataConn = false;
                 }
             }
         }
         if (newDataConn) {
             mDataTransport->Close(NS_ERROR_ABORT);
             mDataTransport = nullptr;
             mDataStream = nullptr;
         }
     }
     if (newDataConn) {
         // now we know where to connect our data channel
         nsCOMPtr<nsISocketTransportService> sts =
             do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID);
         if (!sts)
             return FTP_ERROR;
         nsCOMPtr<nsISocketTransport> strans;
         nsAutoCString host;
         if (!IsIPAddrAny(&mServerAddress)) {
             char buf[kIPv6CStrBufSize];
             NetAddrToString(&mServerAddress, buf, sizeof(buf));
             host.Assign(buf);
         } else {
             /*
              * In case of SOCKS5 remote DNS resolving, the peer address
              * fetched previously will be invalid (0.0.0.0): it is unknown
              * to us. But we can pass on the original hostname to the
              * connect for the data connection.
              */
             rv = mChannel->URI()->GetAsciiHost(host);
             if (NS_FAILED(rv))
                 return FTP_ERROR;
         }
         rv =  sts->CreateTransport(nullptr, 0, host,
                                    port, mChannel->ProxyInfo(),
                                    getter_AddRefs(strans)); // the data socket
         if (NS_FAILED(rv))
             return FTP_ERROR;
         mDataTransport = strans;
         strans->SetQoSBits(gFtpHandler->GetDataQoSBits());
         LOG(("FTP:(%x) created DT (%s:%x)\n", this, host.get(), port));
         // hook ourself up as a proxy for status notifications
         rv = mDataTransport->SetEventSink(this, NS_GetCurrentThread());
         NS_ENSURE_SUCCESS(rv, FTP_ERROR);
         if (mAction == PUT) {
             NS_ASSERTION(!mRETRFailed, "Failed before uploading");
             // nsIUploadChannel requires the upload stream to support ReadSegments.
             // therefore, we can open an unbuffered socket output stream.
             nsCOMPtr<nsIOutputStream> output;
             rv = mDataTransport->OpenOutputStream(nsITransport::OPEN_UNBUFFERED,
 , 0, getter_AddRefs(output));
             if (NS_FAILED(rv))
                 return FTP_ERROR;
             // perform the data copy on the socket transport thread.  we do this
             // because "output" is a socket output stream, so the result is that
             // all work will be done on the socket transport thread.
             nsCOMPtr<nsIEventTarget> stEventTarget =
                 do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID);
             if (!stEventTarget)
                 return FTP_ERROR;
             nsCOMPtr<nsIAsyncStreamCopier> copier;
             rv = NS_NewAsyncStreamCopier(getter_AddRefs(copier),
                                          mChannel->UploadStream(),
                                          output,
                                          stEventTarget,
                                          true,   // upload stream is buffered
                                          false); // output is NOT buffered
             if (NS_FAILED(rv))
                 return FTP_ERROR;
             rv = copier->AsyncCopy(this, nullptr);
             if (NS_FAILED(rv))
                 return FTP_ERROR;
             // hold a reference to the copier so we can cancel it if necessary.
             mUploadRequest = copier;
             // update the current working directory before sending the STOR
             // command.  this is needed since we might be reusing a control
             // connection.
             return FTP_S_CWD;
         }
         //
         // else, we are reading from the data connection...
         //
         // open a buffered, asynchronous socket input stream
         nsCOMPtr<nsIInputStream> input;
         rv = mDataTransport->OpenInputStream(0,
                                              nsIOService::gDefaultSegmentSize,
                                              nsIOService::gDefaultSegmentCount,
                                              getter_AddRefs(input));
         NS_ENSURE_SUCCESS(rv, FTP_ERROR);
         mDataStream = do_QueryInterface(input);
     }
     if (mRETRFailed || mPath.IsEmpty() || mPath.Last() == '/')
         return FTP_S_CWD;
     return FTP_S_SIZE;
 }
 nsresult
 nsFtpState::S_feat() {
     return SendFTPCommand(NS_LITERAL_CSTRING("FEAT" CRLF));
 }
 FTP_STATE
 nsFtpState::R_feat() {
     if (mResponseCode/100 == 2) {
         if (mResponseMsg.Find(NS_LITERAL_CSTRING(CRLF " UTF8" CRLF), true) > -1) {
             // This FTP server supports UTF-8 encoding
             mChannel->SetContentCharset(NS_LITERAL_CSTRING("UTF-8"));
             mUseUTF8 = true;
             return FTP_S_OPTS;
         }
     }
     mUseUTF8 = false;
     return FTP_S_PWD;
 }
 nsresult
 nsFtpState::S_opts() {
      // This command is for compatibility of old FTP spec (IETF Draft)
     return SendFTPCommand(NS_LITERAL_CSTRING("OPTS UTF8 ON" CRLF));
 }
 FTP_STATE
 nsFtpState::R_opts() {
     // Ignore error code because "OPTS UTF8 ON" is for compatibility of
     // FTP server using IETF draft
     return FTP_S_PWD;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // nsIRequest methods:
 static inline
 uint32_t GetFtpTime()
 {
     return uint32_t(PR_Now() / PR_USEC_PER_SEC);
 }
 uint32_t nsFtpState::mSessionStartTime = GetFtpTime();
 /* Is this cache entry valid to use for reading?
  * Since we make up an expiration time for ftp, use the following rules:
  * (see bug 103726)
  *
  * LOAD_FROM_CACHE                    : always use cache entry, even if expired
  * LOAD_BYPASS_CACHE                  : overwrite cache entry
  * LOAD_NORMAL|VALIDATE_ALWAYS        : overwrite cache entry
  * LOAD_NORMAL                        : honor expiration time
  * LOAD_NORMAL|VALIDATE_ONCE_PER_SESSION : overwrite cache entry if first access
  *                                         this session, otherwise use cache entry
  *                                         even if expired.
  * LOAD_NORMAL|VALIDATE_NEVER         : always use cache entry, even if expired
  *
  * Note that in theory we could use the mdtm time on the directory
  * In practice, the lack of a timezone plus the general lack of support for that
  * on directories means that its not worth it, I suspect. Revisit if we start
  * caching files - bbaetz
  */
 bool
 nsFtpState::CanReadCacheEntry()
 {
     NS_ASSERTION(mCacheEntry, "must have a cache entry");
     nsCacheAccessMode access;
     nsresult rv = mCacheEntry->GetAccessGranted(&access);
     if (NS_FAILED(rv))
         return false;
     // If I'm not granted read access, then I can't reuse it...
     if (!(access & nsICache::ACCESS_READ))
         return false;
     if (mChannel->HasLoadFlag(nsIRequest::LOAD_FROM_CACHE))
         return true;
     if (mChannel->HasLoadFlag(nsIRequest::LOAD_BYPASS_CACHE))
         return false;
     if (mChannel->HasLoadFlag(nsIRequest::VALIDATE_ALWAYS))
         return false;
     uint32_t time;
     if (mChannel->HasLoadFlag(nsIRequest::VALIDATE_ONCE_PER_SESSION)) {
         rv = mCacheEntry->GetLastModified(&time);
         if (NS_FAILED(rv))
             return false;
         return (mSessionStartTime > time);
     }
     if (mChannel->HasLoadFlag(nsIRequest::VALIDATE_NEVER))
         return true;
     // OK, now we just check the expiration time as usual
     rv = mCacheEntry->GetExpirationTime(&time);
     if (NS_FAILED(rv))
         return false;
     return (GetFtpTime() <= time);
 }
 nsresult
 nsFtpState::InstallCacheListener()
 {
     NS_ASSERTION(mCacheEntry, "must have a cache entry");
     nsCOMPtr<nsIOutputStream> out;
     mCacheEntry->OpenOutputStream(0, getter_AddRefs(out));
     NS_ENSURE_STATE(out);
     nsCOMPtr<nsIStreamListenerTee> tee =
             do_CreateInstance(NS_STREAMLISTENERTEE_CONTRACTID);
     NS_ENSURE_STATE(tee);
     nsresult rv = tee->Init(mChannel->StreamListener(), out, nullptr);
     NS_ENSURE_SUCCESS(rv, rv);
     mChannel->SetStreamListener(tee);
     return NS_OK;
 }
 nsresult
 nsFtpState::OpenCacheDataStream()
 {
     NS_ASSERTION(mCacheEntry, "must have a cache entry");
     // Get a transport to the cached data...
     nsCOMPtr<nsIInputStream> input;
     mCacheEntry->OpenInputStream(0, getter_AddRefs(input));
     NS_ENSURE_STATE(input);
     nsCOMPtr<nsIStreamTransportService> sts =
             do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
     NS_ENSURE_STATE(sts);
     nsCOMPtr<nsITransport> transport;
     sts->CreateInputTransport(input, -1, -1, true,
                               getter_AddRefs(transport));
     NS_ENSURE_STATE(transport);
     nsresult rv = transport->SetEventSink(this, NS_GetCurrentThread());
     NS_ENSURE_SUCCESS(rv, rv);
     // Open a non-blocking, buffered input stream...
     nsCOMPtr<nsIInputStream> transportInput;
     transport->OpenInputStream(0,
                                nsIOService::gDefaultSegmentSize,
                                nsIOService::gDefaultSegmentCount,
                                getter_AddRefs(transportInput));
     NS_ENSURE_STATE(transportInput);
     mDataStream = do_QueryInterface(transportInput);
     NS_ENSURE_STATE(mDataStream);
     mDataTransport = transport;
     return NS_OK;
 }
 nsresult
 nsFtpState::Init(nsFtpChannel *channel)
 {
     // parameter validation
     NS_ASSERTION(channel, "FTP: needs a channel");
     mChannel = channel; // a straight ref ptr to the channel
     // initialize counter for network metering
     mCountRecv = 0;
 #ifdef MOZ_WIDGET_GONK
     nsCOMPtr<nsINetworkInterface> activeNetwork;
     GetActiveNetworkInterface(activeNetwork);
     mActiveNetwork =
         new nsMainThreadPtrHolder<nsINetworkInterface>(activeNetwork);
 #endif
     mKeepRunning = true;
     mSuppliedEntityID = channel->EntityID();
     if (channel->UploadStream())
         mAction = PUT;
     nsresult rv;
     nsCOMPtr<nsIURL> url = do_QueryInterface(mChannel->URI());
     nsAutoCString host;
     if (url) {
         rv = url->GetAsciiHost(host);
     } else {
         rv = mChannel->URI()->GetAsciiHost(host);
     }
     if (NS_FAILED(rv) || host.IsEmpty()) {
         return NS_ERROR_MALFORMED_URI;
     }
     nsAutoCString path;
     if (url) {
         rv = url->GetFilePath(path);
     } else {
         rv = mChannel->URI()->GetPath(path);
     }
     if (NS_FAILED(rv))
         return rv;
     removeParamsFromPath(path);
     // FTP parameters such as type=i are ignored
     if (url) {
         url->SetFilePath(path);
     } else {
         mChannel->URI()->SetPath(path);
     }
     // Skip leading slash
     char *fwdPtr = path.BeginWriting();
     if (!fwdPtr)
         return NS_ERROR_OUT_OF_MEMORY;
     if (*fwdPtr == '/')
         fwdPtr++;
     if (*fwdPtr != '\0') {
         // now unescape it... %xx reduced inline to resulting character
         int32_t len = NS_UnescapeURL(fwdPtr);
         mPath.Assign(fwdPtr, len);
 #ifdef DEBUG
         if (mPath.FindCharInSet(CRLF) >= 0)
             NS_ERROR("NewURI() should've prevented this!!!");
 #endif
     }
     // pull any username and/or password out of the uri
     nsAutoCString uname;
     rv = mChannel->URI()->GetUsername(uname);
     if (NS_FAILED(rv))
         return rv;
     if (!uname.IsEmpty() && !uname.EqualsLiteral("anonymous")) {
         mAnonymous = false;
         CopyUTF8toUTF16(NS_UnescapeURL(uname), mUsername);
         // return an error if we find a CR or LF in the username
         if (uname.FindCharInSet(CRLF) >= 0)
             return NS_ERROR_MALFORMED_URI;
     }
     nsAutoCString password;
     rv = mChannel->URI()->GetPassword(password);
     if (NS_FAILED(rv))
         return rv;
     CopyUTF8toUTF16(NS_UnescapeURL(password), mPassword);
     // return an error if we find a CR or LF in the password
     if (mPassword.FindCharInSet(CRLF) >= 0)
         return NS_ERROR_MALFORMED_URI;
     // setup the connection cache key
     int32_t port;
     rv = mChannel->URI()->GetPort(&port);
     if (NS_FAILED(rv))
         return rv;
     if (port > 0)
         mPort = port;
     // Lookup Proxy information asynchronously if it isn't already set
     // on the channel and if we aren't configured explicitly to go directly
     nsCOMPtr<nsIProtocolProxyService> pps =
         do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID);
     if (pps && !mChannel->ProxyInfo()) {
         pps->AsyncResolve(mChannel, 0, this,
                           getter_AddRefs(mProxyRequest));
     }
     return NS_OK;
 }
 void
 nsFtpState::Connect()
 {
     mState = FTP_COMMAND_CONNECT;
     mNextState = FTP_S_USER;
     nsresult rv = Process();
     // check for errors.
     if (NS_FAILED(rv)) {
         LOG(("FTP:Process() failed: %x\n", rv));
         mInternalError = NS_ERROR_FAILURE;
         mState = FTP_ERROR;
         CloseWithStatus(mInternalError);
     }
 }
 void
 nsFtpState::KillControlConnection()
 {
     mControlReadCarryOverBuf.Truncate(0);
     mAddressChecked = false;
     mServerIsIPv6 = false;
     // if everything went okay, save the connection.
     // FIX: need a better way to determine if we can cache the connections.
     //      there are some errors which do not mean that we need to kill the connection
     //      e.g. fnf.
     if (!mControlConnection)
         return;
     // kill the reference to ourselves in the control connection.
     mControlConnection->WaitData(nullptr);
     if (NS_SUCCEEDED(mInternalError) &&
         NS_SUCCEEDED(mControlStatus) &&
         mControlConnection->IsAlive() &&
         mCacheConnection) {
         LOG_ALWAYS(("FTP:(%p) caching CC(%p)", this, mControlConnection.get()));
         // Store connection persistent data
         mControlConnection->mServerType = mServerType;
         mControlConnection->mPassword = mPassword;
         mControlConnection->mPwd = mPwd;
         mControlConnection->mUseUTF8 = mUseUTF8;
         nsresult rv = NS_OK;
         // Don't cache controlconnection if anonymous (bug #473371)
         if (!mChannel->HasLoadFlag(nsIRequest::LOAD_ANONYMOUS))
             rv = gFtpHandler->InsertConnection(mChannel->URI(),
                                                mControlConnection);
         // Can't cache it?  Kill it then.
         mControlConnection->Disconnect(rv);
     } else {
         mControlConnection->Disconnect(NS_BINDING_ABORTED);
     }
     mControlConnection = nullptr;
 }
 class nsFtpAsyncAlert : public nsRunnable
 {
 public:
     nsFtpAsyncAlert(nsIPrompt *aPrompter, nsString aResponseMsg)
         : mPrompter(aPrompter)
         , mResponseMsg(aResponseMsg)
     {
         MOZ_COUNT_CTOR(nsFtpAsyncAlert);
     }
     virtual ~nsFtpAsyncAlert()
     {
         MOZ_COUNT_DTOR(nsFtpAsyncAlert);
     }
     NS_IMETHOD Run()
     {
         if (mPrompter) {
             mPrompter->Alert(nullptr, mResponseMsg.get());
         }
         return NS_OK;
     }
 private:
     nsCOMPtr<nsIPrompt> mPrompter;
     nsString mResponseMsg;
 };
 nsresult
 nsFtpState::StopProcessing()
 {
     // Only do this function once.
     if (!mKeepRunning)
         return NS_OK;
     mKeepRunning = false;
     LOG_ALWAYS(("FTP:(%x) nsFtpState stopping", this));
 #ifdef DEBUG_dougt
     printf("FTP Stopped: [response code %d] [response msg follows:]\n%s\n", mResponseCode, mResponseMsg.get());
 #endif
     if (NS_FAILED(mInternalError) && !mResponseMsg.IsEmpty()) {
         // check to see if the control status is bad.
         // web shell wont throw an alert.  we better:
         // XXX(darin): this code should not be dictating UI like this!
         nsCOMPtr<nsIPrompt> prompter;
         mChannel->GetCallback(prompter);
         if (prompter) {
             nsCOMPtr<nsIRunnable> alertEvent;
             if (mUseUTF8) {
                 alertEvent = new nsFtpAsyncAlert(prompter,
                     NS_ConvertUTF8toUTF16(mResponseMsg));
             } else {
                 alertEvent = new nsFtpAsyncAlert(prompter,
                     NS_ConvertASCIItoUTF16(mResponseMsg));
             }
             NS_DispatchToMainThread(alertEvent, NS_DISPATCH_NORMAL);
         }
     }
     nsresult broadcastErrorCode = mControlStatus;
     if (NS_SUCCEEDED(broadcastErrorCode))
         broadcastErrorCode = mInternalError;
     mInternalError = broadcastErrorCode;
     KillControlConnection();
     // XXX This can fire before we are done loading data.  Is that a problem?
     OnTransportStatus(nullptr, NS_NET_STATUS_END_FTP_TRANSACTION, 0, 0);
     if (NS_FAILED(broadcastErrorCode))
         CloseWithStatus(broadcastErrorCode);
     return NS_OK;
 }
 nsresult
 nsFtpState::SendFTPCommand(const nsCSubstring& command)
 {
     NS_ASSERTION(mControlConnection, "null control connection");
     // we don't want to log the password:
     nsAutoCString logcmd(command);
     if (StringBeginsWith(command, NS_LITERAL_CSTRING("PASS ")))
         logcmd = "PASS xxxxx";
     LOG(("FTP:(%x) writing \"%s\"\n", this, logcmd.get()));
     nsCOMPtr<nsIFTPEventSink> ftpSink;
     mChannel->GetFTPEventSink(ftpSink);
     if (ftpSink)
         ftpSink->OnFTPControlLog(false, logcmd.get());
     if (mControlConnection)
         return mControlConnection->Write(command);
     return NS_ERROR_FAILURE;
 }
 // Convert a unix-style filespec to VMS format
 // /foo/fred/barney/file.txt -> foo:[fred.barney]file.txt
 // /foo/file.txt -> foo:[000000]file.txt
 void
 nsFtpState::ConvertFilespecToVMS(nsCString& fileString)
 {
     int ntok=1;
     char *t, *nextToken;
     nsAutoCString fileStringCopy;
     // Get a writeable copy we can strtok with.
     fileStringCopy = fileString;
     t = nsCRT::strtok(fileStringCopy.BeginWriting(), "/", &nextToken);
     if (t)
         while (nsCRT::strtok(nextToken, "/", &nextToken))
             ntok++; // count number of terms (tokens)
     LOG(("FTP:(%x) ConvertFilespecToVMS ntok: %d\n", this, ntok));
     LOG(("FTP:(%x) ConvertFilespecToVMS from: \"%s\"\n", this, fileString.get()));
     if (fileString.First() == '/') {
         // absolute filespec
         //   /        -> []
         //   /a       -> a (doesn't really make much sense)
         //   /a/b     -> a:[000000]b
         //   /a/b/c   -> a:[b]c
         //   /a/b/c/d -> a:[b.c]d
         if (ntok == 1) {
             if (fileString.Length() == 1) {
                 // Just a slash
                 fileString.Truncate();
                 fileString.AppendLiteral("[]");
             } else {
                 // just copy the name part (drop the leading slash)
                 fileStringCopy = fileString;
                 fileString = Substring(fileStringCopy, 1,
                                        fileStringCopy.Length()-1);
             }
         } else {
             // Get another copy since the last one was written to.
             fileStringCopy = fileString;
             fileString.Truncate();
             fileString.Append(nsCRT::strtok(fileStringCopy.BeginWriting(),
                               "/", &nextToken));
             fileString.AppendLiteral(":[");
             if (ntok > 2) {
                 for (int i=2; i<ntok; i++) {
                     if (i > 2) fileString.Append('.');
                     fileString.Append(nsCRT::strtok(nextToken,
                                       "/", &nextToken));
                 }
             } else {
                 fileString.AppendLiteral("000000");
             }
             fileString.Append(']');
             fileString.Append(nsCRT::strtok(nextToken, "/", &nextToken));
         }
     } else {
        // relative filespec
         //   a       -> a
         //   a/b     -> [.a]b
         //   a/b/c   -> [.a.b]c
         if (ntok == 1) {
             // no slashes, just use the name as is
         } else {
             // Get another copy since the last one was written to.
             fileStringCopy = fileString;
             fileString.Truncate();
             fileString.AppendLiteral("[.");
             fileString.Append(nsCRT::strtok(fileStringCopy.BeginWriting(),
                               "/", &nextToken));
             if (ntok > 2) {
                 for (int i=2; i<ntok; i++) {
                     fileString.Append('.');
                     fileString.Append(nsCRT::strtok(nextToken,
                                       "/", &nextToken));
                 }
             }
             fileString.Append(']');
             fileString.Append(nsCRT::strtok(nextToken, "/", &nextToken));
         }
     }
     LOG(("FTP:(%x) ConvertFilespecToVMS   to: \"%s\"\n", this, fileString.get()));
 }
 // Convert a unix-style dirspec to VMS format
 // /foo/fred/barney/rubble -> foo:[fred.barney.rubble]
 // /foo/fred -> foo:[fred]
 // /foo -> foo:[000000]
 // (null) -> (null)
 void
 nsFtpState::ConvertDirspecToVMS(nsCString& dirSpec)
 {
     LOG(("FTP:(%x) ConvertDirspecToVMS from: \"%s\"\n", this, dirSpec.get()));
     if (!dirSpec.IsEmpty()) {
         if (dirSpec.Last() != '/')
             dirSpec.Append('/');
         // we can use the filespec routine if we make it look like a file name
         dirSpec.Append('x');
         ConvertFilespecToVMS(dirSpec);
         dirSpec.Truncate(dirSpec.Length()-1);
     }
     LOG(("FTP:(%x) ConvertDirspecToVMS   to: \"%s\"\n", this, dirSpec.get()));
 }
 // Convert an absolute VMS style dirspec to UNIX format
 void
 nsFtpState::ConvertDirspecFromVMS(nsCString& dirSpec)
 {
     LOG(("FTP:(%x) ConvertDirspecFromVMS from: \"%s\"\n", this, dirSpec.get()));
     if (dirSpec.IsEmpty()) {
         dirSpec.Insert('.', 0);
     } else {
         dirSpec.Insert('/', 0);
         dirSpec.ReplaceSubstring(":[", "/");
         dirSpec.ReplaceChar('.', '/');
         dirSpec.ReplaceChar(']', '/');
     }
     LOG(("FTP:(%x) ConvertDirspecFromVMS   to: \"%s\"\n", this, dirSpec.get()));
 }
 //-----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsFtpState::OnTransportStatus(nsITransport *transport, nsresult status,
                               uint64_t progress, uint64_t progressMax)
 {
     // Mix signals from both the control and data connections.
     // Ignore data transfer events on the control connection.
     if (mControlConnection && transport == mControlConnection->Transport()) {
         switch (status) {
         case NS_NET_STATUS_RESOLVING_HOST:
         case NS_NET_STATUS_RESOLVED_HOST:
         case NS_NET_STATUS_CONNECTING_TO:
         case NS_NET_STATUS_CONNECTED_TO:
             break;
         default:
             return NS_OK;
         }
     }
     // Ignore the progressMax value from the socket.  We know the true size of
     // the file based on the response from our SIZE request. Additionally, only
     // report the max progress based on where we started/resumed.
     mChannel->OnTransportStatus(nullptr, status, progress,
                                 mFileSize - mChannel->StartPos());
     return NS_OK;
 }
 //-----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsFtpState::OnCacheEntryAvailable(nsICacheEntryDescriptor *entry,
                                   nsCacheAccessMode access,
                                   nsresult status)
 {
     // We may have been closed while we were waiting for this cache entry.
     if (IsClosed())
         return NS_OK;
     if (NS_SUCCEEDED(status) && entry) {
         mDoomCache = true;
         mCacheEntry = entry;
         if (CanReadCacheEntry() && ReadCacheEntry()) {
             mState = FTP_READ_CACHE;
             return NS_OK;
         }
     }
     Connect();
     return NS_OK;
 }
 //-----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsFtpState::OnCacheEntryDoomed(nsresult status)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 //-----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsFtpState::OnStartRequest(nsIRequest *request, nsISupports *context)
 {
     mStorReplyReceived = false;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsFtpState::OnStopRequest(nsIRequest *request, nsISupports *context,
                           nsresult status)
 {
     mUploadRequest = nullptr;
     // Close() will be called when reply to STOR command is received
     // see bug #389394
     if (!mStorReplyReceived)
       return NS_OK;
     // We're done uploading.  Let our consumer know that we're done.
     Close();
     return NS_OK;
 }
 //-----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsFtpState::Available(uint64_t *result)
 {
     if (mDataStream)
         return mDataStream->Available(result);
     return nsBaseContentStream::Available(result);
 }
 NS_IMETHODIMP
 nsFtpState::ReadSegments(nsWriteSegmentFun writer, void *closure,
                          uint32_t count, uint32_t *result)
 {
     // Insert a thunk here so that the input stream passed to the writer is this
     // input stream instead of mDataStream.
     if (mDataStream) {
         nsWriteSegmentThunk thunk = { this, writer, closure };
         nsresult rv;
         rv = mDataStream->ReadSegments(NS_WriteSegmentThunk, &thunk, count,
                                        result);
         if (NS_SUCCEEDED(rv)) {
             CountRecvBytes(*result);
         }
         return rv;
     }
     return nsBaseContentStream::ReadSegments(writer, closure, count, result);
 }
 nsresult
 nsFtpState::SaveNetworkStats(bool enforce)
 {
 #ifdef MOZ_WIDGET_GONK
     // Obtain app id
     uint32_t appId;
     bool isInBrowser;
     NS_GetAppInfo(mChannel, &appId, &isInBrowser);
     // Check if active network and appid are valid.
     if (!mActiveNetwork || appId == NECKO_NO_APP_ID) {
         return NS_OK;
     }
     if (mCountRecv <= 0) {
         // There is no traffic, no need to save.
         return NS_OK;
     }
     // If |enforce| is false, the traffic amount is saved
     // only when the total amount exceeds the predefined
     // threshold.
     if (!enforce && mCountRecv < NETWORK_STATS_THRESHOLD) {
         return NS_OK;
     }
     // Create the event to save the network statistics.
     // the event is then dispathed to the main thread.
     nsRefPtr<nsRunnable> event =
         new SaveNetworkStatsEvent(appId, mActiveNetwork, mCountRecv, 0, false);
     NS_DispatchToMainThread(event);
     // Reset the counters after saving.
     mCountRecv = 0;
     return NS_OK;
 #else
     return NS_ERROR_NOT_IMPLEMENTED;
 #endif
 }
 NS_IMETHODIMP
 nsFtpState::CloseWithStatus(nsresult status)
 {
     LOG(("FTP:(%p) close [%x]\n", this, status));
     // Shutdown the control connection processing if we are being closed with an
     // error.  Note: This method may be called several times.
     if (!IsClosed() && status != NS_BASE_STREAM_CLOSED && NS_FAILED(status)) {
         if (NS_SUCCEEDED(mInternalError))
             mInternalError = status;
         StopProcessing();
     }
     if (mUploadRequest) {
         mUploadRequest->Cancel(NS_ERROR_ABORT);
         mUploadRequest = nullptr;
     }
     if (mDataTransport) {
         // Save the network stats before data transport is closing.
         SaveNetworkStats(true);
         // Shutdown the data transport.
         mDataTransport->Close(NS_ERROR_ABORT);
         mDataTransport = nullptr;
     }
     mDataStream = nullptr;
     if (mDoomCache && mCacheEntry)
         mCacheEntry->AsyncDoom(nullptr);
     mCacheEntry = nullptr;
     return nsBaseContentStream::CloseWithStatus(status);
 }
 static nsresult
 CreateHTTPProxiedChannel(nsIChannel *channel, nsIProxyInfo *pi, nsIChannel **newChannel)
 {
     nsresult rv;
     nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);
     if (NS_FAILED(rv))
         return rv;
     nsCOMPtr<nsIProtocolHandler> handler;
     rv = ioService->GetProtocolHandler("http", getter_AddRefs(handler));
     if (NS_FAILED(rv))
         return rv;
     nsCOMPtr<nsIProxiedProtocolHandler> pph = do_QueryInterface(handler, &rv);
     if (NS_FAILED(rv))
         return rv;
     nsCOMPtr<nsIURI> uri;
     channel->GetURI(getter_AddRefs(uri));
     return pph->NewProxiedChannel(uri, pi, 0, nullptr, newChannel);
 }
 NS_IMETHODIMP
 nsFtpState::OnProxyAvailable(nsICancelable *request, nsIChannel *channel,
                              nsIProxyInfo *pi, nsresult status)
 {
   mProxyRequest = nullptr;
   // failed status code just implies DIRECT processing
   if (NS_SUCCEEDED(status)) {
     nsAutoCString type;
     if (pi && NS_SUCCEEDED(pi->GetType(type)) && type.EqualsLiteral("http")) {
         // Proxy the FTP url via HTTP
         // This would have been easier to just return a HTTP channel directly
         // from nsIIOService::NewChannelFromURI(), but the proxy type cannot
         // be reliabliy determined synchronously without jank due to pac, etc..
         LOG(("FTP:(%p) Configured to use a HTTP proxy channel\n", this));
         nsCOMPtr<nsIChannel> newChannel;
         if (NS_SUCCEEDED(CreateHTTPProxiedChannel(channel, pi,
                                                   getter_AddRefs(newChannel))) &&
             NS_SUCCEEDED(mChannel->Redirect(newChannel,
                                             nsIChannelEventSink::REDIRECT_INTERNAL,
                                             true))) {
             LOG(("FTP:(%p) Redirected to use a HTTP proxy channel\n", this));
             return NS_OK;
         }
     }
     else if (pi) {
         // Proxy using the FTP protocol routed through a socks proxy
         LOG(("FTP:(%p) Configured to use a SOCKS proxy channel\n", this));
         mChannel->SetProxyInfo(pi);
     }
   }
   if (mDeferredCallbackPending) {
       mDeferredCallbackPending = false;
       OnCallbackPending();
   }
   return NS_OK;
 }
 void
 nsFtpState::OnCallbackPending()
 {
     // If this is the first call, then see if we could use the cache.  If we
     // aren't going to read from (or write to) the cache, then just proceed to
     // connect to the server.
     if (mState == FTP_INIT) {
         if (mProxyRequest) {
             mDeferredCallbackPending = true;
             return;
         }
         if (CheckCache()) {
             mState = FTP_WAIT_CACHE;
             return;
         }
         if (mCacheEntry && CanReadCacheEntry() && ReadCacheEntry()) {
             mState = FTP_READ_CACHE;
             return;
         }
         Connect();
     } else if (mDataStream) {
         mDataStream->AsyncWait(this, 0, 0, CallbackTarget());
     }
 }
 bool
 nsFtpState::ReadCacheEntry()
 {
     NS_ASSERTION(mCacheEntry, "should have a cache entry");
     // make sure the channel knows wassup
     SetContentType();
     nsXPIDLCString serverType;
     mCacheEntry->GetMetaDataElement("servertype", getter_Copies(serverType));
     nsAutoCString serverNum(serverType.get());
     nsresult err;
     mServerType = serverNum.ToInteger(&err);
     nsXPIDLCString charset;
     mCacheEntry->GetMetaDataElement("useUTF8", getter_Copies(charset));
     const char *useUTF8 = charset.get();
     if (useUTF8 && atoi(useUTF8) == 1)
         mChannel->SetContentCharset(NS_LITERAL_CSTRING("UTF-8"));
     mChannel->PushStreamConverter("text/ftp-dir",
                                   APPLICATION_HTTP_INDEX_FORMAT);
     mChannel->SetEntityID(EmptyCString());
     if (NS_FAILED(OpenCacheDataStream()))
         return false;
     if (mDataStream && HasPendingCallback())
         mDataStream->AsyncWait(this, 0, 0, CallbackTarget());
     mDoomCache = false;
     return true;
 }
 bool
 nsFtpState::CheckCache()
 {
     // This function is responsible for setting mCacheEntry if there is a cache
     // entry that we can use.  It returns true if we end up waiting for access
     // to the cache.
     // In some cases, we don't want to use the cache:
     if (mChannel->UploadStream() || mChannel->ResumeRequested())
         return false;
     nsCOMPtr<nsICacheService> cache = do_GetService(NS_CACHESERVICE_CONTRACTID);
     if (!cache)
         return false;
     bool isPrivate = NS_UsePrivateBrowsing(mChannel);
     const char* sessionName = isPrivate ? "FTP-private" : "FTP";
     nsCacheStoragePolicy policy =
         isPrivate ? nsICache::STORE_IN_MEMORY : nsICache::STORE_ANYWHERE;
     nsCOMPtr<nsICacheSession> session;
     cache->CreateSession(sessionName,
                          policy,
                          nsICache::STREAM_BASED,
                          getter_AddRefs(session));
     if (!session)
         return false;
     session->SetDoomEntriesIfExpired(false);
     session->SetIsPrivate(isPrivate);
     // Set cache access requested:
     nsCacheAccessMode accessReq;
     if (NS_IsOffline()) {
         accessReq = nsICache::ACCESS_READ; // can only read
     } else if (mChannel->HasLoadFlag(nsIRequest::LOAD_BYPASS_CACHE)) {
         accessReq = nsICache::ACCESS_WRITE; // replace cache entry
     } else {
         accessReq = nsICache::ACCESS_READ_WRITE; // normal browsing
     }
     // Check to see if we are not allowed to write to the cache:
     if (mChannel->HasLoadFlag(nsIRequest::INHIBIT_CACHING)) {
         accessReq &= ~nsICache::ACCESS_WRITE;
         if (accessReq == nsICache::ACCESS_NONE)
             return false;
     }
     // Generate cache key (remove trailing #ref if any):
     nsAutoCString key;
     mChannel->URI()->GetAsciiSpec(key);
     int32_t pos = key.RFindChar('#');
     if (pos != kNotFound)
         key.Truncate(pos);
     NS_ENSURE_FALSE(key.IsEmpty(), false);
     nsresult rv = session->AsyncOpenCacheEntry(key, accessReq, this, false);
     return NS_SUCCEEDED(rv);
 }

The Tor Browser / annotate

netwerk/protocol/ftp/nsFtpConnectionThread.cpp@deefc01c0e14 (annotated)

netwerk/protocol/ftp/nsFtpConnectionThread.cpp