diff options
Diffstat (limited to 'mailnews/compose/src/nsSmtpProtocol.cpp')
| -rw-r--r-- | mailnews/compose/src/nsSmtpProtocol.cpp | 2249 |
1 files changed, 2249 insertions, 0 deletions
diff --git a/mailnews/compose/src/nsSmtpProtocol.cpp b/mailnews/compose/src/nsSmtpProtocol.cpp new file mode 100644 index 000000000..d525d3f7f --- /dev/null +++ b/mailnews/compose/src/nsSmtpProtocol.cpp @@ -0,0 +1,2249 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "msgCore.h" +#include "nsSmtpProtocol.h" +#include "nscore.h" +#include "nsIStreamListener.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsISocketTransport.h" +#include "nsIMsgMailNewsUrl.h" +#include "nsMsgBaseCID.h" +#include "nsMsgCompCID.h" +#include "nsIPrompt.h" +#include "nsIAuthPrompt.h" +#include "nsStringGlue.h" +#include "nsTextFormatter.h" +#include "nsIMsgIdentity.h" +#include "nsISmtpServer.h" +#include "prtime.h" +#include "mozilla/Logging.h" +#include "prerror.h" +#include "prprf.h" +#include "prmem.h" +#include "plbase64.h" +#include "prnetdb.h" +#include "prsystem.h" +#include "nsMsgUtils.h" +#include "nsIPipe.h" +#include "nsNetUtil.h" +#include "nsIPrefService.h" +#include "nsISSLSocketControl.h" +#include "nsComposeStrings.h" +#include "nsIStringBundle.h" +#include "nsMsgCompUtils.h" +#include "nsIMsgWindow.h" +#include "MailNewsTypes2.h" // for nsMsgSocketType and nsMsgAuthMethod +#include "nsIIDNService.h" +#include "mozilla/mailnews/MimeHeaderParser.h" +#include "mozilla/Services.h" +#include "mozilla/Attributes.h" +#include "nsINetAddr.h" +#include "nsIProxyInfo.h" + +#ifndef XP_UNIX +#include <stdarg.h> +#endif /* !XP_UNIX */ + +#undef PostMessage // avoid to collision with WinUser.h + +static PRLogModuleInfo *SMTPLogModule = nullptr; + +using namespace mozilla::mailnews; + +/* the output_buffer_size must be larger than the largest possible line + * 2000 seems good for news + * + * jwz: I increased this to 4k since it must be big enough to hold the + * entire button-bar HTML, and with the new "mailto" format, that can + * contain arbitrarily long header fields like "references". + * + * fortezza: proxy auth is huge, buffer increased to 8k (sigh). + */ +#define OUTPUT_BUFFER_SIZE (4096*2) + +//////////////////////////////////////////////////////////////////////////////////////////// +// TEMPORARY HARD CODED FUNCTIONS +/////////////////////////////////////////////////////////////////////////////////////////// + +/* based on in NET_ExplainErrorDetails in mkmessag.c */ +nsresult nsExplainErrorDetails(nsISmtpUrl * aSmtpUrl, nsresult aCode, ...) +{ + NS_ENSURE_ARG(aSmtpUrl); + + va_list args; + + nsCOMPtr<nsIPrompt> dialog; + aSmtpUrl->GetPrompt(getter_AddRefs(dialog)); + NS_ENSURE_TRUE(dialog, NS_ERROR_FAILURE); + + char16_t * msg; + nsString eMsg; + nsCOMPtr<nsIStringBundleService> bundleService = + mozilla::services::GetStringBundleService(); + NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED); + nsCOMPtr<nsIStringBundle> bundle; + nsresult rv = bundleService->CreateBundle( + "chrome://messenger/locale/messengercompose/composeMsgs.properties", + getter_AddRefs(bundle)); + NS_ENSURE_SUCCESS(rv, rv); + + va_start (args, aCode); + + const char16_t* exitString; +#ifdef __GNUC__ +// Temporary workaroung until bug 783526 is fixed. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wswitch" +#endif + switch (aCode) + { + case NS_ERROR_ILLEGAL_LOCALPART: + bundle->GetStringFromName(u"errorIllegalLocalPart", + getter_Copies(eMsg)); + msg = nsTextFormatter::vsmprintf(eMsg.get(), args); + break; + case NS_ERROR_SMTP_SERVER_ERROR: + case NS_ERROR_TCP_READ_ERROR: + case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED: + case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1: + case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2: + case NS_ERROR_SENDING_FROM_COMMAND: + case NS_ERROR_SENDING_RCPT_COMMAND: + case NS_ERROR_SENDING_DATA_COMMAND: + case NS_ERROR_SENDING_MESSAGE: + case NS_ERROR_SMTP_GREETING: + exitString = errorStringNameForErrorCode(aCode); + bundle->GetStringFromName(exitString, getter_Copies(eMsg)); + msg = nsTextFormatter::vsmprintf(eMsg.get(), args); + break; + default: + NS_WARNING("falling to default error code"); + bundle->GetStringFromName(u"communicationsError", getter_Copies(eMsg)); + msg = nsTextFormatter::smprintf(eMsg.get(), aCode); + break; + } +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif + + if (msg) + { + rv = dialog->Alert(nullptr, msg); + nsTextFormatter::smprintf_free(msg); + } + + va_end (args); + + return rv; +} + +/* RFC 1891 -- extended smtp value encoding scheme + + 5. Additional parameters for RCPT and MAIL commands + + The extended RCPT and MAIL commands are issued by a client when it wishes to request a DSN from the + server, under certain conditions, for a particular recipient. The extended RCPT and MAIL commands are + identical to the RCPT and MAIL commands defined in [1], except that one or more of the following parameters + appear after the sender or recipient address, respectively. The general syntax for extended SMTP commands is + defined in [4]. + + NOTE: Although RFC 822 ABNF is used to describe the syntax of these parameters, they are not, in the + language of that document, "structured field bodies". Therefore, while parentheses MAY appear within an + emstp-value, they are not recognized as comment delimiters. + + The syntax for "esmtp-value" in [4] does not allow SP, "=", control characters, or characters outside the + traditional ASCII range of 1- 127 decimal to be transmitted in an esmtp-value. Because the ENVID and + ORCPT parameters may need to convey values outside this range, the esmtp-values for these parameters are + encoded as "xtext". "xtext" is formally defined as follows: + + xtext = *( xchar / hexchar ) + + xchar = any ASCII CHAR between "!" (33) and "~" (126) inclusive, except for "+" and "=". + + ; "hexchar"s are intended to encode octets that cannot appear + ; as ASCII characters within an esmtp-value. + + hexchar = ASCII "+" immediately followed by two upper case hexadecimal digits + + When encoding an octet sequence as xtext: + + + Any ASCII CHAR between "!" and "~" inclusive, except for "+" and "=", + MAY be encoded as itself. (A CHAR in this range MAY instead be encoded as a "hexchar", at the + implementor's discretion.) + + + ASCII CHARs that fall outside the range above must be encoded as + "hexchar". + + */ +/* caller must free the return buffer */ +static char * +esmtp_value_encode(const char *addr) +{ + char *buffer = (char *) PR_Malloc(512); /* esmtp ORCPT allow up to 500 chars encoded addresses */ + char *bp = buffer, *bpEnd = buffer+500; + int len, i; + + if (!buffer) return NULL; + + *bp=0; + if (! addr || *addr == 0) /* this will never happen */ + return buffer; + + for (i=0, len=PL_strlen(addr); i < len && bp < bpEnd; i++) + { + if (*addr >= 0x21 && + *addr <= 0x7E && + *addr != '+' && + *addr != '=') + { + *bp++ = *addr++; + } + else + { + PR_snprintf(bp, bpEnd-bp, "+%.2X", ((int)*addr++)); + bp += PL_strlen(bp); + } + } + *bp=0; + return buffer; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +// END OF TEMPORARY HARD CODED FUNCTIONS +/////////////////////////////////////////////////////////////////////////////////////////// + +NS_IMPL_ISUPPORTS_INHERITED(nsSmtpProtocol, nsMsgAsyncWriteProtocol, + msgIOAuth2ModuleListener) + +nsSmtpProtocol::nsSmtpProtocol(nsIURI * aURL) + : nsMsgAsyncWriteProtocol(aURL) +{ +} + +nsSmtpProtocol::~nsSmtpProtocol() +{ + // free our local state + PR_Free(m_dataBuf); + delete m_lineStreamBuffer; +} + +void nsSmtpProtocol::Initialize(nsIURI * aURL) +{ + NS_PRECONDITION(aURL, "invalid URL passed into Smtp Protocol"); + nsresult rv = NS_OK; + + m_flags = 0; + m_prefAuthMethods = 0; + m_failedAuthMethods = 0; + m_currentAuthMethod = 0; + m_usernamePrompted = false; + m_prefSocketType = nsMsgSocketType::trySTARTTLS; + m_tlsInitiated = false; + + m_urlErrorState = NS_ERROR_FAILURE; + + if (!SMTPLogModule) + SMTPLogModule = PR_NewLogModule("SMTP"); + + if (aURL) + m_runningURL = do_QueryInterface(aURL); + + // extract out message feedback if there is any. + nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aURL); + if (mailnewsUrl) + mailnewsUrl->GetStatusFeedback(getter_AddRefs(m_statusFeedback)); + + m_dataBuf = (char *) PR_Malloc(sizeof(char) * OUTPUT_BUFFER_SIZE); + m_dataBufSize = OUTPUT_BUFFER_SIZE; + + m_nextState = SMTP_START_CONNECT; + m_nextStateAfterResponse = SMTP_START_CONNECT; + m_responseCode = 0; + m_previousResponseCode = 0; + m_continuationResponse = -1; + m_tlsEnabled = false; + m_addressesLeft = 0; + + m_sendDone = false; + + m_sizelimit = 0; + m_totalMessageSize = 0; + nsCOMPtr<nsIFile> file; + m_runningURL->GetPostMessageFile(getter_AddRefs(file)); + if (file) + file->GetFileSize(&m_totalMessageSize); + + m_originalContentLength = 0; + m_totalAmountRead = 0; + + m_lineStreamBuffer = new nsMsgLineStreamBuffer(OUTPUT_BUFFER_SIZE, true); + // ** may want to consider caching the server capability to save lots of + // round trip communication between the client and server + int32_t authMethod = 0; + nsCOMPtr<nsISmtpServer> smtpServer; + m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer)); + if (smtpServer) { + smtpServer->GetAuthMethod(&authMethod); + smtpServer->GetSocketType(&m_prefSocketType); + smtpServer->GetHelloArgument(getter_Copies(m_helloArgument)); + + // Query for OAuth2 support. If the SMTP server preferences don't allow + // for OAuth2, then don't carry around the OAuth2 module any longer + // since we won't need it. + mOAuth2Support = do_CreateInstance(MSGIOAUTH2MODULE_CONTRACTID); + if (mOAuth2Support) + { + bool supportsOAuth = false; + mOAuth2Support->InitFromSmtp(smtpServer, &supportsOAuth); + if (!supportsOAuth) + mOAuth2Support = nullptr; + } + } + InitPrefAuthMethods(authMethod); + + nsAutoCString hostName; + int32_t port = 0; + + aURL->GetPort(&port); + aURL->GetAsciiHost(hostName); + + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP Connecting to: %s", hostName.get())); + + // When we are making a secure connection, we need to make sure that we + // pass an interface requestor down to the socket transport so that PSM can + // retrieve a nsIPrompt instance if needed. + nsCOMPtr<nsIInterfaceRequestor> callbacks; + nsCOMPtr<nsISmtpUrl> smtpUrl(do_QueryInterface(aURL)); + if (smtpUrl) + smtpUrl->GetNotificationCallbacks(getter_AddRefs(callbacks)); + + nsCOMPtr<nsIProxyInfo> proxyInfo; + rv = MsgExamineForProxy(this, getter_AddRefs(proxyInfo)); + if (NS_FAILED(rv)) proxyInfo = nullptr; + + if (m_prefSocketType == nsMsgSocketType::SSL) + rv = OpenNetworkSocketWithInfo(hostName.get(), port, "ssl", proxyInfo, + callbacks); + else if (m_prefSocketType != nsMsgSocketType::plain) + { + rv = OpenNetworkSocketWithInfo(hostName.get(), port, "starttls", + proxyInfo, callbacks); + if (NS_FAILED(rv) && m_prefSocketType == nsMsgSocketType::trySTARTTLS) + { + m_prefSocketType = nsMsgSocketType::plain; + rv = OpenNetworkSocketWithInfo(hostName.get(), port, nullptr, + proxyInfo, callbacks); + } + } + else + rv = OpenNetworkSocketWithInfo(hostName.get(), port, nullptr, proxyInfo, + callbacks); +} + +void nsSmtpProtocol::AppendHelloArgument(nsACString& aResult) +{ + nsresult rv; + + // is a custom EHLO/HELO argument configured for the transport to be used? + if (!m_helloArgument.IsEmpty()) + { + aResult += m_helloArgument; + } + else + { + // is a FQDN known for this system? + char hostName[256]; + PR_GetSystemInfo(PR_SI_HOSTNAME_UNTRUNCATED, hostName, sizeof hostName); + if ((hostName[0] != '\0') && (strchr(hostName, '.') != NULL)) + { + nsDependentCString cleanedHostName(hostName); + // avoid problems with hostnames containing newlines/whitespace + cleanedHostName.StripWhitespace(); + aResult += cleanedHostName; + } + else + { + nsCOMPtr<nsINetAddr> iaddr; // IP address for this connection + // our transport is always a nsISocketTransport + nsCOMPtr<nsISocketTransport> socketTransport = do_QueryInterface(m_transport); + // should return the interface ip of the SMTP connection + // minimum case - see bug 68877 and RFC 2821, chapter 4.1.1.1 + rv = socketTransport->GetScriptableSelfAddr(getter_AddRefs(iaddr)); + + if (NS_SUCCEEDED(rv)) + { + // turn it into a string + nsCString ipAddressString; + rv = iaddr->GetAddress(ipAddressString); + if (NS_SUCCEEDED(rv)) + { +#ifdef DEBUG + bool v4mapped = false; + iaddr->GetIsV4Mapped(&v4mapped); + NS_ASSERTION(!v4mapped, + "unexpected IPv4-mapped IPv6 address"); +#endif + + uint16_t family = nsINetAddr::FAMILY_INET; + iaddr->GetFamily(&family); + + if (family == nsINetAddr::FAMILY_INET6) // IPv6 style address? + aResult.AppendLiteral("[IPv6:"); + else + aResult.AppendLiteral("["); + + aResult.Append(ipAddressString); + aResult.Append(']'); + } + } + } + } +} + +///////////////////////////////////////////////////////////////////////////////////////////// +// we suppport the nsIStreamListener interface +//////////////////////////////////////////////////////////////////////////////////////////// + +// stop binding is a "notification" informing us that the stream +// associated with aURL is going away. +NS_IMETHODIMP nsSmtpProtocol::OnStopRequest(nsIRequest *request, nsISupports *ctxt, + nsresult aStatus) +{ + bool connDroppedDuringAuth = NS_SUCCEEDED(aStatus) && !m_sendDone && + (m_nextStateAfterResponse == SMTP_AUTH_LOGIN_STEP0_RESPONSE || + m_nextStateAfterResponse == SMTP_AUTH_LOGIN_RESPONSE); + // ignore errors handling the QUIT command so fcc can continue. + if (m_sendDone && NS_FAILED(aStatus)) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, + ("SMTP connection error quitting %lx, ignoring ", aStatus)); + aStatus = NS_OK; + } + if (NS_SUCCEEDED(aStatus) && !m_sendDone) { + // if we are getting OnStopRequest() with NS_OK, + // but we haven't finished clean, that's spells trouble. + // it means that the server has dropped us before we could send the whole mail + // for example, see bug #200647 + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, + ("SMTP connection dropped after %ld total bytes read", m_totalAmountRead)); + if (!connDroppedDuringAuth) + nsMsgAsyncWriteProtocol::OnStopRequest(nullptr, ctxt, NS_ERROR_NET_INTERRUPT); + } + else + nsMsgAsyncWriteProtocol::OnStopRequest(nullptr, ctxt, aStatus); + + // okay, we've been told that the send is done and the connection is going away. So + // we need to release all of our state + nsresult rv = nsMsgAsyncWriteProtocol::CloseSocket(); + // If the server dropped the connection when we were expecting + // a login response, reprompt for password, and if the user asks, + // retry the url. + if (connDroppedDuringAuth) + { + nsCOMPtr<nsIURI> runningURI = do_QueryInterface(m_runningURL); + nsresult rv = AuthLoginResponse(nullptr, 0); + if (NS_FAILED(rv)) + return rv; + return LoadUrl(runningURI, ctxt); + } + + return rv; +} + +///////////////////////////////////////////////////////////////////////////////////////////// +// End of nsIStreamListenerSupport +////////////////////////////////////////////////////////////////////////////////////////////// + +void nsSmtpProtocol::UpdateStatus(const char16_t* aStatusName) +{ + if (m_statusFeedback) + { + nsCOMPtr<nsIStringBundleService> bundleService = + mozilla::services::GetStringBundleService(); + if (!bundleService) return; + nsCOMPtr<nsIStringBundle> bundle; + nsresult rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle)); + if (NS_FAILED(rv)) return; + nsString msg; + bundle->GetStringFromName(aStatusName, getter_Copies(msg)); + UpdateStatusWithString(msg.get()); + } +} + +void nsSmtpProtocol::UpdateStatusWithString(const char16_t * aStatusString) +{ + if (m_statusFeedback && aStatusString) + m_statusFeedback->ShowStatusString(nsDependentString(aStatusString)); +} + +///////////////////////////////////////////////////////////////////////////////////////////// +// Begin protocol state machine functions... +////////////////////////////////////////////////////////////////////////////////////////////// + +/* + * gets the response code from the SMTP server and the + * response line + */ +nsresult nsSmtpProtocol::SmtpResponse(nsIInputStream * inputStream, uint32_t length) +{ + char * line = nullptr; + char cont_char; + uint32_t ln = 0; + bool pauseForMoreData = false; + + if (!m_lineStreamBuffer) + // this will force an error and at least we won't crash + return NS_ERROR_NULL_POINTER; + + line = m_lineStreamBuffer->ReadNextLine(inputStream, ln, pauseForMoreData); + + if (pauseForMoreData || !line) + { + SetFlag(SMTP_PAUSE_FOR_READ); /* pause */ + PR_Free(line); + return NS_OK; + } + + m_totalAmountRead += ln; + + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP Response: %s", line)); + cont_char = ' '; /* default */ + // sscanf() doesn't update m_responseCode if line doesn't start + // with a number. That can be dangerous. So be sure to set + // m_responseCode to 0 if no items read. + if (PR_sscanf(line, "%d%c", &m_responseCode, &cont_char) <= 0) + m_responseCode = 0; + + if (m_continuationResponse == -1) + { + if (cont_char == '-') /* begin continuation */ + m_continuationResponse = m_responseCode; + + // display the whole message if no valid response code or + // message shorter than 4 chars + m_responseText = (m_responseCode >= 100 && PL_strlen(line) > 3) ? line + 4 : line; + } + else + { /* have to continue */ + if (m_continuationResponse == m_responseCode && cont_char == ' ') + m_continuationResponse = -1; /* ended */ + + if (m_responseText.IsEmpty() || m_responseText.Last() != '\n') + m_responseText += "\n"; + + m_responseText += (PL_strlen(line) > 3) ? line + 4 : line; + } + + if (m_responseCode == 220 && m_responseText.Length() && !m_tlsInitiated && + !m_sendDone) + m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE; + + if (m_continuationResponse == -1) /* all done with this response? */ + { + m_nextState = m_nextStateAfterResponse; + ClearFlag(SMTP_PAUSE_FOR_READ); /* don't pause */ + } + + PR_Free(line); + return NS_OK; +} + +nsresult nsSmtpProtocol::ExtensionLoginResponse(nsIInputStream * inputStream, uint32_t length) +{ + nsresult status = NS_OK; + + if (m_responseCode != 220) + { +#ifdef DEBUG + nsresult rv = +#endif + nsExplainErrorDetails(m_runningURL, NS_ERROR_SMTP_GREETING, + m_responseText.get()); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return NS_ERROR_SMTP_AUTH_FAILURE; + } + + nsAutoCString buffer("EHLO "); + AppendHelloArgument(buffer); + buffer += CRLF; + + status = SendData(buffer.get()); + + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_SEND_EHLO_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + + return(status); +} + +nsresult nsSmtpProtocol::SendHeloResponse(nsIInputStream * inputStream, uint32_t length) +{ + nsresult status = NS_OK; + nsAutoCString buffer; + nsresult rv; + + if (m_responseCode != 250) + { +#ifdef DEBUG + rv = +#endif + nsExplainErrorDetails(m_runningURL, NS_ERROR_SMTP_SERVER_ERROR, + m_responseText.get()); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return NS_ERROR_SMTP_AUTH_FAILURE; + } + + // check if we're just verifying the ability to logon + nsCOMPtr<nsISmtpUrl> smtpUrl = do_QueryInterface(m_runningURL, &rv); + NS_ENSURE_SUCCESS(rv, rv); + bool verifyingLogon = false; + smtpUrl->GetVerifyLogon(&verifyingLogon); + if (verifyingLogon) + return SendQuit(); + + // extract the email address from the identity + nsCString emailAddress; + nsCOMPtr <nsIMsgIdentity> senderIdentity; + rv = m_runningURL->GetSenderIdentity(getter_AddRefs(senderIdentity)); + if (NS_FAILED(rv) || !senderIdentity) + { + m_urlErrorState = NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS; + return(NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS); + } + senderIdentity->GetEmail(emailAddress); + + if (emailAddress.IsEmpty()) + { + m_urlErrorState = NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS; + return(NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS); + } + + nsCString fullAddress; + // Quote the email address before passing it to the SMTP server. + MakeMimeAddress(EmptyCString(), emailAddress, fullAddress); + + buffer = "MAIL FROM:<"; + buffer += fullAddress; + buffer += ">"; + + nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIPrefBranch> prefBranch; + rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch)); + NS_ENSURE_SUCCESS(rv, rv); + + if (TestFlag(SMTP_EHLO_DSN_ENABLED)) + { + bool requestDSN = false; + rv = m_runningURL->GetRequestDSN(&requestDSN); + + if (requestDSN) + { + bool requestRetFull = false; + rv = prefBranch->GetBoolPref("mail.dsn.ret_full_on", &requestRetFull); + + buffer += requestRetFull ? " RET=FULL" : " RET=HDRS"; + + nsCString dsnEnvid; + + // get the envid from the smtpUrl + rv = m_runningURL->GetDsnEnvid(dsnEnvid); + + if (dsnEnvid.IsEmpty()) + dsnEnvid.Adopt(msg_generate_message_id(senderIdentity)); + + buffer += " ENVID="; + buffer += dsnEnvid; + } + } + + if (TestFlag(SMTP_EHLO_8BIT_ENABLED)) + { + bool strictlyMime = false; + rv = prefBranch->GetBoolPref("mail.strictly_mime", &strictlyMime); + + if (!strictlyMime) + buffer.Append(" BODY=8BITMIME"); + } + + if (TestFlag(SMTP_EHLO_SIZE_ENABLED)) + { + buffer.Append(" SIZE="); + buffer.AppendInt(m_totalMessageSize); + } + buffer += CRLF; + + status = SendData(buffer.get()); + + m_nextState = SMTP_RESPONSE; + + + m_nextStateAfterResponse = SMTP_SEND_MAIL_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + + return(status); +} + +nsresult nsSmtpProtocol::SendEhloResponse(nsIInputStream * inputStream, uint32_t length) +{ + nsresult status = NS_OK; + + if (m_responseCode != 250) + { + /* EHLO must not be implemented by the server, so fall back to the HELO case + * if command is unrecognized or unimplemented. + */ + if (m_responseCode == 500 || m_responseCode == 502) + { + /* If STARTTLS is requested by the user, EHLO is required to advertise it. + * But only if TLS handshake is not already accomplished. + */ + if (m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS && + !m_tlsEnabled) + { + m_nextState = SMTP_ERROR_DONE; + m_urlErrorState = NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS; + return(NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS); + } + + nsAutoCString buffer("HELO "); + AppendHelloArgument(buffer); + buffer += CRLF; + + status = SendData(buffer.get()); + + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_SEND_HELO_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + return (status); + } + /* e.g. getting 421 "Server says unauthorized, bye" or + * 501 "Syntax error in EHLOs parameters or arguments" + */ + else + { +#ifdef DEBUG + nsresult rv = +#endif + nsExplainErrorDetails(m_runningURL, NS_ERROR_SMTP_SERVER_ERROR, + m_responseText.get()); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return NS_ERROR_SMTP_AUTH_FAILURE; + } + } + + int32_t responseLength = m_responseText.Length(); + int32_t startPos = 0; + int32_t endPos; + do + { + endPos = m_responseText.FindChar('\n', startPos + 1); + nsAutoCString responseLine; + responseLine.Assign(Substring(m_responseText, startPos, + (endPos >= 0 ? endPos : responseLength) - startPos)); + + MsgCompressWhitespace(responseLine); + if (responseLine.LowerCaseEqualsLiteral("starttls")) + { + SetFlag(SMTP_EHLO_STARTTLS_ENABLED); + } + else if (responseLine.LowerCaseEqualsLiteral("dsn")) + { + SetFlag(SMTP_EHLO_DSN_ENABLED); + } + else if (StringBeginsWith(responseLine, NS_LITERAL_CSTRING("AUTH"), nsCaseInsensitiveCStringComparator())) + { + SetFlag(SMTP_AUTH); + + if (responseLine.Find(NS_LITERAL_CSTRING("GSSAPI"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_GSSAPI_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("CRAM-MD5"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_CRAM_MD5_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("NTLM"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_NTLM_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("MSN"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_MSN_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("PLAIN"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_PLAIN_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("LOGIN"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_LOGIN_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("EXTERNAL"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_EXTERNAL_ENABLED); + + if (responseLine.Find(NS_LITERAL_CSTRING("XOAUTH2"), + CaseInsensitiveCompare) >= 0) + SetFlag(SMTP_AUTH_OAUTH2_ENABLED); + } + else if (StringBeginsWith(responseLine, NS_LITERAL_CSTRING("SIZE"), nsCaseInsensitiveCStringComparator())) + { + SetFlag(SMTP_EHLO_SIZE_ENABLED); + + m_sizelimit = atol((responseLine.get()) + 4); + } + else if (StringBeginsWith(responseLine, NS_LITERAL_CSTRING("8BITMIME"), nsCaseInsensitiveCStringComparator())) + { + SetFlag(SMTP_EHLO_8BIT_ENABLED); + } + + startPos = endPos + 1; + } while (endPos >= 0); + + if (TestFlag(SMTP_EHLO_SIZE_ENABLED) && + m_sizelimit > 0 && (int32_t)m_totalMessageSize > m_sizelimit) + { +#ifdef DEBUG + nsresult rv = +#endif + nsExplainErrorDetails(m_runningURL, + NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1, m_sizelimit); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return(NS_ERROR_SENDING_FROM_COMMAND); + } + + m_nextState = SMTP_AUTH_PROCESS_STATE; + return status; +} + + +nsresult nsSmtpProtocol::SendTLSResponse() +{ + // only tear down our existing connection and open a new one if we received a 220 response + // from the smtp server after we issued the STARTTLS + nsresult rv = NS_OK; + if (m_responseCode == 220) + { + nsCOMPtr<nsISupports> secInfo; + nsCOMPtr<nsISocketTransport> strans = do_QueryInterface(m_transport, &rv); + if (NS_FAILED(rv)) return rv; + + rv = strans->GetSecurityInfo(getter_AddRefs(secInfo)); + + if (NS_SUCCEEDED(rv) && secInfo) { + nsCOMPtr<nsISSLSocketControl> sslControl = do_QueryInterface(secInfo, &rv); + + if (NS_SUCCEEDED(rv) && sslControl) + rv = sslControl->StartTLS(); + } + + if (NS_SUCCEEDED(rv)) + { + m_nextState = SMTP_EXTN_LOGIN_RESPONSE; + m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE; + m_tlsEnabled = true; + m_flags = 0; // resetting the flags + return rv; + } + } + + ClearFlag(SMTP_EHLO_STARTTLS_ENABLED); + m_tlsInitiated = false; + m_nextState = SMTP_AUTH_PROCESS_STATE; + + return rv; +} + +void nsSmtpProtocol::InitPrefAuthMethods(int32_t authMethodPrefValue) +{ + // for m_prefAuthMethods, using the same flags as server capablities. + switch (authMethodPrefValue) + { + case nsMsgAuthMethod::none: + m_prefAuthMethods = SMTP_AUTH_NONE_ENABLED; + break; + //case nsMsgAuthMethod::old -- no such thing for SMTP + case nsMsgAuthMethod::passwordCleartext: + m_prefAuthMethods = SMTP_AUTH_LOGIN_ENABLED | + SMTP_AUTH_PLAIN_ENABLED; + break; + case nsMsgAuthMethod::passwordEncrypted: + m_prefAuthMethods = SMTP_AUTH_CRAM_MD5_ENABLED; + break; + case nsMsgAuthMethod::NTLM: + m_prefAuthMethods = SMTP_AUTH_NTLM_ENABLED | + SMTP_AUTH_MSN_ENABLED; + break; + case nsMsgAuthMethod::GSSAPI: + m_prefAuthMethods = SMTP_AUTH_GSSAPI_ENABLED; + break; + case nsMsgAuthMethod::OAuth2: + m_prefAuthMethods = SMTP_AUTH_OAUTH2_ENABLED; + break; + case nsMsgAuthMethod::secure: + m_prefAuthMethods = SMTP_AUTH_CRAM_MD5_ENABLED | + SMTP_AUTH_GSSAPI_ENABLED | + SMTP_AUTH_NTLM_ENABLED | SMTP_AUTH_MSN_ENABLED | + SMTP_AUTH_EXTERNAL_ENABLED; // TODO: Expose EXTERNAL? How? + break; + default: + NS_ASSERTION(false, "SMTP: authMethod pref invalid"); + // TODO log to error console + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, + ("SMTP: bad pref authMethod = %d\n", authMethodPrefValue)); + // fall to any + MOZ_FALLTHROUGH; + case nsMsgAuthMethod::anything: + m_prefAuthMethods = + SMTP_AUTH_LOGIN_ENABLED | SMTP_AUTH_PLAIN_ENABLED | + SMTP_AUTH_CRAM_MD5_ENABLED | SMTP_AUTH_GSSAPI_ENABLED | + SMTP_AUTH_NTLM_ENABLED | SMTP_AUTH_MSN_ENABLED | + SMTP_AUTH_OAUTH2_ENABLED | + SMTP_AUTH_EXTERNAL_ENABLED; + break; + } + + // Only enable OAuth2 support if we can do the lookup. + if ((m_prefAuthMethods & SMTP_AUTH_OAUTH2_ENABLED) && !mOAuth2Support) + m_prefAuthMethods &= ~SMTP_AUTH_OAUTH2_ENABLED; + + NS_ASSERTION(m_prefAuthMethods != 0, "SMTP:InitPrefAuthMethods() failed"); +} + +/** + * Changes m_currentAuthMethod to pick the next-best one + * which is allowed by server and prefs and not marked failed. + * The order of preference and trying of auth methods is encoded here. + */ +nsresult nsSmtpProtocol::ChooseAuthMethod() +{ + int32_t serverCaps = m_flags; // from nsMsgProtocol::TestFlag() + int32_t availCaps = serverCaps & m_prefAuthMethods & ~m_failedAuthMethods; + + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, + ("SMTP auth: server caps 0x%X, pref 0x%X, failed 0x%X, avail caps 0x%X", + serverCaps, m_prefAuthMethods, m_failedAuthMethods, availCaps)); + MOZ_LOG(SMTPLogModule, mozilla::LogLevel:: Debug, + ("(GSSAPI = 0x%X, CRAM = 0x%X, NTLM = 0x%X, " + "MSN = 0x%X, PLAIN = 0x%X, LOGIN = 0x%X, EXTERNAL = 0x%X)", + SMTP_AUTH_GSSAPI_ENABLED, SMTP_AUTH_CRAM_MD5_ENABLED, + SMTP_AUTH_NTLM_ENABLED, SMTP_AUTH_MSN_ENABLED, SMTP_AUTH_PLAIN_ENABLED, + SMTP_AUTH_LOGIN_ENABLED, SMTP_AUTH_EXTERNAL_ENABLED)); + + if (SMTP_AUTH_GSSAPI_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_GSSAPI_ENABLED; + else if (SMTP_AUTH_CRAM_MD5_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_CRAM_MD5_ENABLED; + else if (SMTP_AUTH_NTLM_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_NTLM_ENABLED; + else if (SMTP_AUTH_MSN_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_MSN_ENABLED; + else if (SMTP_AUTH_OAUTH2_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_OAUTH2_ENABLED; + else if (SMTP_AUTH_PLAIN_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_PLAIN_ENABLED; + else if (SMTP_AUTH_LOGIN_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_LOGIN_ENABLED; + else if (SMTP_AUTH_EXTERNAL_ENABLED & availCaps) + m_currentAuthMethod = SMTP_AUTH_EXTERNAL_ENABLED; + else + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("no auth method remaining")); + m_currentAuthMethod = 0; + return NS_ERROR_SMTP_AUTH_FAILURE; + } + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("trying auth method 0x%X", m_currentAuthMethod)); + return NS_OK; +} + +void nsSmtpProtocol::MarkAuthMethodAsFailed(int32_t failedAuthMethod) +{ + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, + ("marking auth method 0x%X failed", failedAuthMethod)); + m_failedAuthMethods |= failedAuthMethod; +} + +/** + * Start over, trying all auth methods again + */ +void nsSmtpProtocol::ResetAuthMethods() +{ + m_currentAuthMethod = 0; + m_failedAuthMethods = 0; +} + +nsresult nsSmtpProtocol::ProcessAuth() +{ + nsresult status = NS_OK; + nsAutoCString buffer; + + if (!m_tlsEnabled) + { + if (TestFlag(SMTP_EHLO_STARTTLS_ENABLED)) + { + // Do not try to combine SMTPS with STARTTLS. + // If nsMsgSocketType::SSL is set, + // we are alrady using a secure connection. + // Do not attempt to do STARTTLS, + // even if server offers it. + if (m_prefSocketType == nsMsgSocketType::trySTARTTLS || + m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS) + { + buffer = "STARTTLS"; + buffer += CRLF; + + status = SendData(buffer.get()); + + m_tlsInitiated = true; + + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_TLS_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + return status; + } + } + else if (m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS) + { + m_nextState = SMTP_ERROR_DONE; + m_urlErrorState = NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS; + return NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS; + } + } + // (wrong indention until here) + + (void) ChooseAuthMethod(); // advance m_currentAuthMethod + + // We don't need to auth, per pref, or the server doesn't advertise AUTH, + // so skip auth and try to send message. + if (m_prefAuthMethods == SMTP_AUTH_NONE_ENABLED || !TestFlag(SMTP_AUTH)) + { + m_nextState = SMTP_SEND_HELO_RESPONSE; + // fake to 250 because SendHeloResponse() tests for this + m_responseCode = 250; + } + else if (m_currentAuthMethod == SMTP_AUTH_EXTERNAL_ENABLED) + { + buffer = "AUTH EXTERNAL ="; + buffer += CRLF; + SendData(buffer.get()); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_AUTH_EXTERNAL_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + return NS_OK; + } + else if (m_currentAuthMethod == SMTP_AUTH_GSSAPI_ENABLED) + { + m_nextState = SMTP_SEND_AUTH_GSSAPI_FIRST; + } + else if (m_currentAuthMethod == SMTP_AUTH_CRAM_MD5_ENABLED || + m_currentAuthMethod == SMTP_AUTH_PLAIN_ENABLED || + m_currentAuthMethod == SMTP_AUTH_NTLM_ENABLED) + { + m_nextState = SMTP_SEND_AUTH_LOGIN_STEP1; + } + else if (m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED || + m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED) + { + m_nextState = SMTP_SEND_AUTH_LOGIN_STEP0; + } + else if (m_currentAuthMethod == SMTP_AUTH_OAUTH2_ENABLED) + { + m_nextState = SMTP_AUTH_OAUTH2_STEP; + } + else // All auth methods failed + { + // show an appropriate error msg + if (m_failedAuthMethods == 0) + { + // we didn't even try anything, so we had a non-working config: + // pref doesn't match server + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, + ("no working auth mech - pref doesn't match server capas")); + + // pref has encrypted pw & server claims to support plaintext pw + if (m_prefAuthMethods == SMTP_AUTH_CRAM_MD5_ENABLED && + m_flags & (SMTP_AUTH_LOGIN_ENABLED | SMTP_AUTH_PLAIN_ENABLED)) + { + // have SSL + if (m_prefSocketType == nsMsgSocketType::SSL || + m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS) + // tell user to change to plaintext pw + m_urlErrorState = NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL; + else + // tell user to change to plaintext pw, with big warning + m_urlErrorState = NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL; + } + // pref has plaintext pw & server claims to support encrypted pw + else if (m_prefAuthMethods == (SMTP_AUTH_LOGIN_ENABLED | + SMTP_AUTH_PLAIN_ENABLED) && + m_flags & SMTP_AUTH_CRAM_MD5_ENABLED) + // tell user to change to encrypted pw + m_urlErrorState = NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT; + else + { + // just "change auth method" + m_urlErrorState = NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED; + } + } + else if (m_failedAuthMethods == SMTP_AUTH_GSSAPI_ENABLED) + { + // We have only GSSAPI, and it failed, so nothing left to do. + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("GSSAPI only and it failed")); + m_urlErrorState = NS_ERROR_SMTP_AUTH_GSSAPI; + } + else + { + // we tried to login, but it all failed + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("All auth attempts failed")); + m_urlErrorState = NS_ERROR_SMTP_AUTH_FAILURE; + } + m_nextState = SMTP_ERROR_DONE; + return NS_ERROR_SMTP_AUTH_FAILURE; + } + + return NS_OK; +} + + + +nsresult nsSmtpProtocol::AuthLoginResponse(nsIInputStream * stream, uint32_t length) +{ + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP Login response, code %d", m_responseCode)); + nsresult status = NS_OK; + + switch (m_responseCode/100) + { + case 2: + m_nextState = SMTP_SEND_HELO_RESPONSE; + // fake to 250 because SendHeloResponse() tests for this + m_responseCode = 250; + break; + case 3: + m_nextState = SMTP_SEND_AUTH_LOGIN_STEP2; + break; + case 5: + default: + nsCOMPtr<nsISmtpServer> smtpServer; + m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer)); + if (smtpServer) + { + // If one authentication failed, mark it failed, so that we're going to + // fall back on a less secure login method. + MarkAuthMethodAsFailed(m_currentAuthMethod); + + bool allFailed = NS_FAILED(ChooseAuthMethod()); + if (allFailed && m_failedAuthMethods > 0 && + m_failedAuthMethods != SMTP_AUTH_GSSAPI_ENABLED && + m_failedAuthMethods != SMTP_AUTH_EXTERNAL_ENABLED) + { + // We've tried all avail. methods, and they all failed, and we have no mechanism left. + // Ask user to try with a new password. + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, + ("SMTP: ask user what to do (after login failed): new password, retry or cancel")); + + nsCOMPtr<nsISmtpServer> smtpServer; + nsresult rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCString hostname; + rv = smtpServer->GetHostname(hostname); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t buttonPressed = 1; + if (NS_SUCCEEDED(MsgPromptLoginFailed(nullptr, hostname, + &buttonPressed))) + { + if (buttonPressed == 1) // Cancel button + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, ("cancel button pressed")); + // abort and get out of here + status = NS_ERROR_ABORT; + break; + } + else if (buttonPressed == 2) // 'New password' button + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, ("new password button pressed")); + // Change password was pressed. For now, forget the stored + // password and we'll prompt for a new one next time around. + smtpServer->ForgetPassword(); + if (m_usernamePrompted) + smtpServer->SetUsername(EmptyCString()); + + // Let's restore the original auth flags from SendEhloResponse + // so we can try them again with new password and username + ResetAuthMethods(); + // except for GSSAPI and EXTERNAL, which don't care about passwords. + MarkAuthMethodAsFailed(SMTP_AUTH_GSSAPI_ENABLED); + MarkAuthMethodAsFailed(SMTP_AUTH_EXTERNAL_ENABLED); + } + else if (buttonPressed == 0) // Retry button + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, ("retry button pressed")); + // try all again, including GSSAPI + ResetAuthMethods(); + } + } + } + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, + ("SMTP: login failed: failed %X, current %X", m_failedAuthMethods, m_currentAuthMethod)); + + m_nextState = SMTP_AUTH_PROCESS_STATE; // try auth (ProcessAuth()) again, with other method + } + else + status = NS_ERROR_SMTP_PASSWORD_UNDEFINED; + break; + } + + return (status); +} + +nsresult nsSmtpProtocol::AuthGSSAPIFirst() +{ + NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_GSSAPI_ENABLED, "called in invalid state"); + nsAutoCString command("AUTH GSSAPI "); + nsAutoCString resp; + nsAutoCString service("smtp@"); + nsCString hostName; + nsCString userName; + nsresult rv; + nsCOMPtr<nsISmtpServer> smtpServer; + rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer)); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + + rv = smtpServer->GetUsername(userName); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + + rv = smtpServer->GetHostname(hostName); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + service.Append(hostName); + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP: GSSAPI step 1 for user %s at server %s, service %s", + userName.get(), hostName.get(), service.get())); + + rv = DoGSSAPIStep1(service.get(), userName.get(), resp); + if (NS_FAILED(rv)) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("SMTP: GSSAPI step 1 failed early")); + MarkAuthMethodAsFailed(SMTP_AUTH_GSSAPI_ENABLED); + m_nextState = SMTP_AUTH_PROCESS_STATE; + return NS_OK; + } + else + command.Append(resp); + command.Append(CRLF); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_SEND_AUTH_GSSAPI_STEP; + SetFlag(SMTP_PAUSE_FOR_READ); + return SendData(command.get()); +} + +// GSSAPI may consist of multiple round trips + +nsresult nsSmtpProtocol::AuthGSSAPIStep() +{ + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP: GSSAPI auth step 2")); + NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_GSSAPI_ENABLED, "called in invalid state"); + nsresult rv; + nsAutoCString cmd; + + // Check to see what the server said + if (m_responseCode / 100 != 3) { + m_nextState = SMTP_AUTH_LOGIN_RESPONSE; + return NS_OK; + } + + rv = DoGSSAPIStep2(m_responseText, cmd); + if (NS_FAILED(rv)) + cmd = "*"; + cmd += CRLF; + + m_nextStateAfterResponse = (rv == NS_SUCCESS_AUTH_FINISHED)?SMTP_AUTH_LOGIN_RESPONSE:SMTP_SEND_AUTH_GSSAPI_STEP; + m_nextState = SMTP_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + + return SendData(cmd.get()); +} + + +// LOGIN and MSN consist of three steps (MSN not through the mechanism +// but by non-RFC2821 compliant implementation in MS servers) not two as +// PLAIN or CRAM-MD5, so we've to start here and continue with AuthStep1 +// if the server responds with with a 3xx code to "AUTH LOGIN" or "AUTH MSN" +nsresult nsSmtpProtocol::AuthLoginStep0() +{ + NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED || + m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED, + "called in invalid state"); + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP: MSN or LOGIN auth, step 0")); + nsAutoCString command(m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED + ? "AUTH MSN" CRLF : "AUTH LOGIN" CRLF); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_AUTH_LOGIN_STEP0_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + + return SendData(command.get()); +} + +void nsSmtpProtocol::AuthLoginStep0Response() +{ + NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED || + m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED, + "called in invalid state"); + // need the test to be here instead in AuthLoginResponse() to + // continue with step 1 instead of 2 in case of a code 3xx + m_nextState = (m_responseCode/100 == 3) ? + SMTP_SEND_AUTH_LOGIN_STEP1 : SMTP_AUTH_LOGIN_RESPONSE; +} + +nsresult nsSmtpProtocol::AuthLoginStep1() +{ + char buffer[512]; // TODO nsAutoCString + nsresult rv; + nsresult status = NS_OK; + nsCString username; + char *base64Str = nullptr; + nsAutoCString password; + nsCOMPtr<nsISmtpServer> smtpServer; + rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + + rv = smtpServer->GetUsername(username); + if (username.IsEmpty()) + { + rv = GetUsernamePassword(username, password); + m_usernamePrompted = true; + if (username.IsEmpty() || password.IsEmpty()) + return NS_ERROR_SMTP_PASSWORD_UNDEFINED; + } + + nsCString hostname; + smtpServer->GetHostname(hostname); + + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP AuthLoginStep1() for %s@%s", + username.get(), hostname.get())); + + GetPassword(password); + if (password.IsEmpty()) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("SMTP: password undefined")); + m_urlErrorState = NS_ERROR_SMTP_PASSWORD_UNDEFINED; + return NS_ERROR_SMTP_PASSWORD_UNDEFINED; + } + + if (m_currentAuthMethod == SMTP_AUTH_CRAM_MD5_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("CRAM auth, step 1")); + PR_snprintf(buffer, sizeof(buffer), "AUTH CRAM-MD5" CRLF); + } + else if (m_currentAuthMethod == SMTP_AUTH_NTLM_ENABLED || + m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("NTLM/MSN auth, step 1")); + nsAutoCString response; + rv = DoNtlmStep1(username.get(), password.get(), response); + PR_snprintf(buffer, sizeof(buffer), TestFlag(SMTP_AUTH_NTLM_ENABLED) ? + "AUTH NTLM %.256s" CRLF : + "%.256s" CRLF, response.get()); + } + else if (m_currentAuthMethod == SMTP_AUTH_PLAIN_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("PLAIN auth")); + char plain_string[512]; + int len = 1; /* first <NUL> char */ + + memset(plain_string, 0, 512); + PR_snprintf(&plain_string[1], 510, "%s", username.get()); + len += username.Length(); + len++; /* second <NUL> char */ + PR_snprintf(&plain_string[len], 511-len, "%s", password.get()); + len += password.Length(); + + base64Str = PL_Base64Encode(plain_string, len, nullptr); + PR_snprintf(buffer, sizeof(buffer), "AUTH PLAIN %.256s" CRLF, base64Str); + } + else if (m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("LOGIN auth")); + base64Str = PL_Base64Encode(username.get(), + username.Length(), nullptr); + PR_snprintf(buffer, sizeof(buffer), "%.256s" CRLF, base64Str); + } + else + return (NS_ERROR_COMMUNICATIONS_ERROR); + + status = SendData(buffer, true); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_AUTH_LOGIN_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + NS_Free(base64Str); + + return (status); +} + +nsresult nsSmtpProtocol::AuthLoginStep2() +{ + /* use cached smtp password first + * if not then use cached pop password + * if pop password undefined + * sync with smtp password + */ + nsresult status = NS_OK; + nsresult rv; + nsAutoCString password; + + GetPassword(password); + if (password.IsEmpty()) + { + m_urlErrorState = NS_ERROR_SMTP_PASSWORD_UNDEFINED; + return NS_ERROR_SMTP_PASSWORD_UNDEFINED; + } + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP AuthLoginStep2")); + + if (!password.IsEmpty()) + { + char buffer[512]; + if (m_currentAuthMethod == SMTP_AUTH_CRAM_MD5_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("CRAM auth, step 2")); + unsigned char digest[DIGEST_LENGTH]; + char * decodedChallenge = PL_Base64Decode(m_responseText.get(), + m_responseText.Length(), nullptr); + + if (decodedChallenge) + rv = MSGCramMD5(decodedChallenge, strlen(decodedChallenge), password.get(), password.Length(), digest); + else + rv = NS_ERROR_FAILURE; + + PR_Free(decodedChallenge); + if (NS_SUCCEEDED(rv)) + { + nsAutoCString encodedDigest; + char hexVal[8]; + + for (uint32_t j=0; j<16; j++) + { + PR_snprintf (hexVal,8, "%.2x", 0x0ff & (unsigned short)digest[j]); + encodedDigest.Append(hexVal); + } + + nsCOMPtr<nsISmtpServer> smtpServer; + rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer)); + if (NS_FAILED(rv)) return NS_ERROR_FAILURE; + + nsCString userName; + rv = smtpServer->GetUsername(userName); + + PR_snprintf(buffer, sizeof(buffer), "%s %s", userName.get(), encodedDigest.get()); + char *base64Str = PL_Base64Encode(buffer, strlen(buffer), nullptr); + PR_snprintf(buffer, sizeof(buffer), "%s" CRLF, base64Str); + NS_Free(base64Str); + } + if (NS_FAILED(rv)) + PR_snprintf(buffer, sizeof(buffer), "*" CRLF); + } + else if (m_currentAuthMethod == SMTP_AUTH_NTLM_ENABLED || + m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("NTLM/MSN auth, step 2")); + nsAutoCString response; + rv = DoNtlmStep2(m_responseText, response); + PR_snprintf(buffer, sizeof(buffer), "%.509s" CRLF, response.get()); + } + else if (m_currentAuthMethod == SMTP_AUTH_PLAIN_ENABLED || + m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("PLAIN/LOGIN auth, step 2")); + char *base64Str = PL_Base64Encode(password.get(), password.Length(), nullptr); + PR_snprintf(buffer, sizeof(buffer), "%.256s" CRLF, base64Str); + NS_Free(base64Str); + } + else + return NS_ERROR_COMMUNICATIONS_ERROR; + + status = SendData(buffer, true); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_AUTH_LOGIN_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + return (status); + } + + // XXX -1 is not a valid nsresult + return static_cast<nsresult>(-1); +} + +nsresult nsSmtpProtocol::AuthOAuth2Step1() +{ + MOZ_ASSERT(mOAuth2Support, "Can't do anything without OAuth2 support"); + + nsresult rv = mOAuth2Support->Connect(true, this); + NS_ENSURE_SUCCESS(rv, rv); + + m_nextState = SMTP_SUSPENDED; + return NS_OK; +} + +nsresult nsSmtpProtocol::OnSuccess(const nsACString &aAccessToken) +{ + MOZ_ASSERT(mOAuth2Support, "Can't do anything without OAuth2 support"); + + nsCString base64Str; + mOAuth2Support->BuildXOAuth2String(base64Str); + + // Send the AUTH XOAUTH2 command, and then siphon us back to the regular + // authentication login stream. + nsAutoCString buffer; + buffer.AppendLiteral("AUTH XOAUTH2 "); + buffer += base64Str; + buffer += CRLF; + nsresult rv = SendData(buffer.get(), true); + if (NS_FAILED(rv)) + { + m_nextState = SMTP_ERROR_DONE; + } + else + { + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_AUTH_LOGIN_RESPONSE; + } + + SetFlag(SMTP_PAUSE_FOR_READ); + + ProcessProtocolState(nullptr, nullptr, 0, 0); + return NS_OK; +} + +nsresult nsSmtpProtocol::OnFailure(nsresult aError) +{ + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("OAuth2 login error %08x", + (uint32_t)aError)); + m_urlErrorState = aError; + m_nextState = SMTP_ERROR_DONE; + return ProcessProtocolState(nullptr, nullptr, 0, 0); +} + + +nsresult nsSmtpProtocol::SendMailResponse() +{ + nsresult status = NS_OK; + nsAutoCString buffer; + nsresult rv; + + if (m_responseCode/10 != 25) + { + nsresult errorcode; + if (TestFlag(SMTP_EHLO_SIZE_ENABLED)) + errorcode = (m_responseCode == 452) ? NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED : + (m_responseCode == 552) ? NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2 : + NS_ERROR_SENDING_FROM_COMMAND; + else + errorcode = NS_ERROR_SENDING_FROM_COMMAND; + + rv = nsExplainErrorDetails(m_runningURL, errorcode, m_responseText.get()); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return(NS_ERROR_SENDING_FROM_COMMAND); + } + + /* Send the RCPT TO: command */ + bool requestDSN = false; + rv = m_runningURL->GetRequestDSN(&requestDSN); + + nsCOMPtr <nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv,rv); + + nsCOMPtr<nsIPrefBranch> prefBranch; + rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch)); + NS_ENSURE_SUCCESS(rv,rv); + + bool requestOnSuccess = false; + rv = prefBranch->GetBoolPref("mail.dsn.request_on_success_on", &requestOnSuccess); + + bool requestOnFailure = false; + rv = prefBranch->GetBoolPref("mail.dsn.request_on_failure_on", &requestOnFailure); + + bool requestOnDelay = false; + rv = prefBranch->GetBoolPref("mail.dsn.request_on_delay_on", &requestOnDelay); + + bool requestOnNever = false; + rv = prefBranch->GetBoolPref("mail.dsn.request_never_on", &requestOnNever); + + nsCString &address = m_addresses[m_addressesLeft - 1]; + if (TestFlag(SMTP_EHLO_DSN_ENABLED) && requestDSN && (requestOnSuccess || requestOnFailure || requestOnDelay || requestOnNever)) + { + char *encodedAddress = esmtp_value_encode(address.get()); + nsAutoCString dsnBuffer; + + if (encodedAddress) + { + buffer = "RCPT TO:<"; + buffer += address; + buffer += "> NOTIFY="; + + if (requestOnNever) + dsnBuffer += "NEVER"; + else + { + if (requestOnSuccess) + dsnBuffer += "SUCCESS"; + + if (requestOnFailure) + dsnBuffer += dsnBuffer.IsEmpty() ? "FAILURE" : ",FAILURE"; + + if (requestOnDelay) + dsnBuffer += dsnBuffer.IsEmpty() ? "DELAY" : ",DELAY"; + } + + buffer += dsnBuffer; + buffer += " ORCPT=rfc822;"; + buffer += encodedAddress; + buffer += CRLF; + PR_FREEIF(encodedAddress); + } + else + { + m_urlErrorState = NS_ERROR_OUT_OF_MEMORY; + return (NS_ERROR_OUT_OF_MEMORY); + } + } + else + { + buffer = "RCPT TO:<"; + buffer += address; + buffer += ">"; + buffer += CRLF; + } + status = SendData(buffer.get()); + + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_SEND_RCPT_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + + return(status); +} + +nsresult nsSmtpProtocol::SendRecipientResponse() +{ + nsresult status = NS_OK; + nsAutoCString buffer; + nsresult rv; + + if (m_responseCode / 10 != 25) + { + nsresult errorcode; + if (TestFlag(SMTP_EHLO_SIZE_ENABLED)) + errorcode = (m_responseCode == 452) ? NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED : + (m_responseCode == 552) ? NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2 : + NS_ERROR_SENDING_RCPT_COMMAND; + else + errorcode = NS_ERROR_SENDING_RCPT_COMMAND; + + if (errorcode == NS_ERROR_SENDING_RCPT_COMMAND) { + rv = nsExplainErrorDetails( + m_runningURL, errorcode, NS_ConvertUTF8toUTF16(m_responseText).get(), + NS_ConvertUTF8toUTF16(m_addresses[m_addressesLeft - 1]).get()); + } else { + rv = nsExplainErrorDetails(m_runningURL, errorcode, + m_responseText.get(), + m_addresses[m_addressesLeft - 1].get()); + } + + if (!NS_SUCCEEDED(rv)) + NS_ASSERTION(false, "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return(NS_ERROR_SENDING_RCPT_COMMAND); + } + + if (--m_addressesLeft > 0) + { + // more senders to RCPT to + // fake to 250 because SendMailResponse() can't handle 251 + m_responseCode = 250; + m_nextState = SMTP_SEND_MAIL_RESPONSE; + return NS_OK; + } + + /* else send the DATA command */ + buffer = "DATA"; + buffer += CRLF; + status = SendData(buffer.get()); + + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_SEND_DATA_RESPONSE; + SetFlag(SMTP_PAUSE_FOR_READ); + + return(status); +} + + +nsresult nsSmtpProtocol::SendData(const char *dataBuffer, bool aSuppressLogging) +{ + // XXX -1 is not a valid nsresult + if (!dataBuffer) return static_cast<nsresult>(-1); + + if (!aSuppressLogging) { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP Send: %s", dataBuffer)); + } else { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("Logging suppressed for this command (it probably contained authentication information)")); + } + return nsMsgAsyncWriteProtocol::SendData(dataBuffer); +} + + +nsresult nsSmtpProtocol::SendDataResponse() +{ + nsresult status = NS_OK; + + if (m_responseCode != 354) + { + mozilla::DebugOnly<nsresult> rv = nsExplainErrorDetails(m_runningURL, + NS_ERROR_SENDING_DATA_COMMAND, + m_responseText.get()); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return(NS_ERROR_SENDING_DATA_COMMAND); + } + + m_nextState = SMTP_SEND_POST_DATA; + ClearFlag(SMTP_PAUSE_FOR_READ); /* send data directly */ + + UpdateStatus(u"smtpDeliveringMail"); + + { +// m_runningURL->GetBodySize(&m_totalMessageSize); + } + return(status); +} + +void nsSmtpProtocol::SendMessageInFile() +{ + nsCOMPtr<nsIFile> file; + nsCOMPtr<nsIURI> url = do_QueryInterface(m_runningURL); + m_runningURL->GetPostMessageFile(getter_AddRefs(file)); + if (url && file) + // need to fully qualify to avoid getting overwritten by a #define + // in some windows header file + nsMsgAsyncWriteProtocol::PostMessage(url, file); + + SetFlag(SMTP_PAUSE_FOR_READ); + + // for now, we are always done at this point..we aren't making multiple calls + // to post data... + + UpdateStatus(u"smtpDeliveringMail"); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_SEND_MESSAGE_RESPONSE; +} + +void nsSmtpProtocol::SendPostData() +{ + // mscott: as a first pass, I'm writing everything at once and am not + // doing it in chunks... + + /* returns 0 on done and negative on error + * positive if it needs to continue. + */ + + // check to see if url is a file..if it is...call our file handler... + bool postMessageInFile = true; + m_runningURL->GetPostMessage(&postMessageInFile); + if (postMessageInFile) + { + SendMessageInFile(); + } + + /* Update the thermo and the status bar. This is done by hand, rather + than using the FE_GraphProgress* functions, because there seems to be + no way to make FE_GraphProgress shut up and not display anything more + when all the data has arrived. At the end, we want to show the + "message sent; waiting for reply" status; FE_GraphProgress gets in + the way of that. See bug #23414. */ +} + + + +nsresult nsSmtpProtocol::SendMessageResponse() +{ + if((m_responseCode/10 != 25)) + { + mozilla::DebugOnly<nsresult> rv = nsExplainErrorDetails(m_runningURL, + NS_ERROR_SENDING_MESSAGE, + m_responseText.get()); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error"); + + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return(NS_ERROR_SENDING_MESSAGE); + } + + UpdateStatus(u"smtpMailSent"); + + /* else */ + return SendQuit(); +} + +nsresult nsSmtpProtocol::SendQuit(SmtpState aNextStateAfterResponse) +{ + m_sendDone = true; + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = aNextStateAfterResponse; + + return SendData("QUIT" CRLF); // send a quit command to close the connection with the server. +} + +nsresult nsSmtpProtocol::LoadUrl(nsIURI * aURL, nsISupports * aConsumer ) +{ + if (!aURL) + return NS_OK; + + Initialize(aURL); + + m_continuationResponse = -1; /* init */ + m_runningURL = do_QueryInterface(aURL); + if (!m_runningURL) + return NS_ERROR_FAILURE; + + // we had a bug where we failed to bring up an alert if the host + // name was empty....so throw up an alert saying we don't have + // a host name and inform the caller that we are not going to + // run the url... + nsAutoCString hostName; + aURL->GetHost(hostName); + if (hostName.IsEmpty()) + { + nsCOMPtr <nsIMsgMailNewsUrl> aMsgUrl = do_QueryInterface(aURL); + if (aMsgUrl) + { + aMsgUrl->SetUrlState(true, NS_OK); + // set the url as a url currently being run... + aMsgUrl->SetUrlState(false /* we aren't running the url */, + NS_ERROR_SMTP_AUTH_FAILURE); + } + return NS_ERROR_BUT_DONT_SHOW_ALERT; + } + + bool postMessage = false; + m_runningURL->GetPostMessage(&postMessage); + + if (postMessage) + { + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE; + + // compile a minimal list of valid target addresses by + // - looking only at mailboxes + // - dropping addresses with invalid localparts (until we implement RFC 6532) + // - using ACE for IDN domainparts + // - stripping duplicates + nsCString addresses; + m_runningURL->GetRecipients(getter_Copies(addresses)); + + ExtractEmails(EncodedHeader(addresses), UTF16ArrayAdapter<>(m_addresses)); + + nsCOMPtr<nsIIDNService> converter = do_GetService(NS_IDNSERVICE_CONTRACTID); + addresses.Truncate(); + uint32_t count = m_addresses.Length(); + for (uint32_t i = 0; i < count; i++) + { + const char *start = m_addresses[i].get(); + // Location of the @ character + const char *lastAt = nullptr; + const char *ch = start; + for (; *ch; ch++) + { + if (*ch == '@') + lastAt = ch; + // Check for first illegal character (outside 0x09,0x20-0x7e) + else if ((*ch < ' ' || *ch > '~') && (*ch != '\t')) + { + break; + } + } + // validate the just parsed address + if (*ch || m_addresses[i].IsEmpty()) + { + // Fortunately, we will always have an @ in each mailbox address. + // We try to fix illegal character in the domain part by converting + // that to ACE. Illegal characters in the local part are not fixable + // (which charset would it be anyway?), hence we error out in that + // case as well. + nsresult rv = NS_ERROR_FAILURE; // anything but NS_OK + if (lastAt) + { + // Illegal char in the domain part, hence use ACE + nsAutoCString domain; + domain.Assign(lastAt + 1); + rv = converter->ConvertUTF8toACE(domain, domain); + if (NS_SUCCEEDED(rv)) + { + m_addresses[i].SetLength(lastAt - start + 1); + m_addresses[i] += domain; + } + } + if (NS_FAILED(rv)) + { + // Throw an error, including the broken address + m_nextState = SMTP_ERROR_DONE; + ClearFlag(SMTP_PAUSE_FOR_READ); + // Unfortunately, nsExplainErrorDetails will show the error above + // the mailnews main window, because we don't necessarily get + // passed down a compose window - we might be sending in the + // background! + rv = nsExplainErrorDetails(m_runningURL, + NS_ERROR_ILLEGAL_LOCALPART, start); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain illegal localpart"); + m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT; + return NS_ERROR_BUT_DONT_SHOW_ALERT; + } + } + } + + // final cleanup + m_addressesLeft = m_addresses.Length(); + + // hmm no addresses to send message to... + if (m_addressesLeft == 0) + { + m_nextState = SMTP_ERROR_DONE; + ClearFlag(SMTP_PAUSE_FOR_READ); + m_urlErrorState = NS_MSG_NO_RECIPIENTS; + return NS_MSG_NO_RECIPIENTS; + } + } // if post message + + return nsMsgProtocol::LoadUrl(aURL, aConsumer); +} + +/* + * returns negative if the transfer is finished or error'd out + * + * returns zero or more if the transfer needs to be continued. + */ +nsresult nsSmtpProtocol::ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream, + uint64_t sourceOffset, uint32_t length) + { + nsresult status = NS_OK; + ClearFlag(SMTP_PAUSE_FOR_READ); /* already paused; reset */ + + while(!TestFlag(SMTP_PAUSE_FOR_READ)) + { + MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP entering state: %d", + m_nextState)); + switch(m_nextState) + { + case SMTP_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SmtpResponse(inputStream, length); + break; + + case SMTP_START_CONNECT: + SetFlag(SMTP_PAUSE_FOR_READ); + m_nextState = SMTP_RESPONSE; + m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE; + break; + case SMTP_FINISH_CONNECT: + SetFlag(SMTP_PAUSE_FOR_READ); + break; + case SMTP_TLS_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendTLSResponse(); + break; + case SMTP_EXTN_LOGIN_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = ExtensionLoginResponse(inputStream, length); + break; + + case SMTP_SEND_HELO_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendHeloResponse(inputStream, length); + break; + case SMTP_SEND_EHLO_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendEhloResponse(inputStream, length); + break; + case SMTP_AUTH_PROCESS_STATE: + status = ProcessAuth(); + break; + + case SMTP_SEND_AUTH_GSSAPI_FIRST: + status = AuthGSSAPIFirst(); + break; + + case SMTP_SEND_AUTH_GSSAPI_STEP: + status = AuthGSSAPIStep(); + break; + + case SMTP_SEND_AUTH_LOGIN_STEP0: + status = AuthLoginStep0(); + break; + + case SMTP_AUTH_LOGIN_STEP0_RESPONSE: + AuthLoginStep0Response(); + status = NS_OK; + break; + + case SMTP_AUTH_EXTERNAL_RESPONSE: + case SMTP_AUTH_LOGIN_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = AuthLoginResponse(inputStream, length); + break; + + case SMTP_SEND_AUTH_LOGIN_STEP1: + status = AuthLoginStep1(); + break; + + case SMTP_SEND_AUTH_LOGIN_STEP2: + status = AuthLoginStep2(); + break; + + case SMTP_AUTH_OAUTH2_STEP: + status = AuthOAuth2Step1(); + break; + + + case SMTP_SEND_MAIL_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendMailResponse(); + break; + + case SMTP_SEND_RCPT_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendRecipientResponse(); + break; + + case SMTP_SEND_DATA_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendDataResponse(); + break; + + case SMTP_SEND_POST_DATA: + SendPostData(); + status = NS_OK; + break; + + case SMTP_SEND_MESSAGE_RESPONSE: + if (inputStream == nullptr) + SetFlag(SMTP_PAUSE_FOR_READ); + else + status = SendMessageResponse(); + break; + case SMTP_DONE: + { + nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(m_runningURL); + mailNewsUrl->SetUrlState(false, NS_OK); + } + + m_nextState = SMTP_FREE; + break; + + case SMTP_ERROR_DONE: + { + nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(m_runningURL); + // propagate the right error code + mailNewsUrl->SetUrlState(false, m_urlErrorState); + } + + m_nextState = SMTP_FREE; + break; + + case SMTP_FREE: + // smtp is a one time use connection so kill it if we get here... + nsMsgAsyncWriteProtocol::CloseSocket(); + return NS_OK; /* final end */ + + // This state means we're going into an async loop and waiting for + // something (say auth) to happen. ProcessProtocolState will be + // retriggered when necessary. + case SMTP_SUSPENDED: + return NS_OK; + + default: /* should never happen !!! */ + m_nextState = SMTP_ERROR_DONE; + break; + } + + /* check for errors during load and call error + * state if found + */ + if (NS_FAILED(status) && m_nextState != SMTP_FREE) { + // send a quit command to close the connection with the server. + if (NS_FAILED(SendQuit(SMTP_ERROR_DONE))) + { + m_nextState = SMTP_ERROR_DONE; + // Don't exit - loop around again and do the free case + ClearFlag(SMTP_PAUSE_FOR_READ); + } + } + } /* while(!SMTP_PAUSE_FOR_READ) */ + + return NS_OK; +} + +nsresult +nsSmtpProtocol::GetPassword(nsCString &aPassword) +{ + nsresult rv; + nsCOMPtr<nsISmtpUrl> smtpUrl = do_QueryInterface(m_runningURL, &rv); + NS_ENSURE_SUCCESS(rv,rv); + + nsCOMPtr<nsISmtpServer> smtpServer; + rv = smtpUrl->GetSmtpServer(getter_AddRefs(smtpServer)); + NS_ENSURE_SUCCESS(rv,rv); + + rv = smtpServer->GetPassword(aPassword); + NS_ENSURE_SUCCESS(rv,rv); + + if (!aPassword.IsEmpty()) + return rv; + // empty password + + nsCOMPtr <nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv,rv); + + nsCOMPtr<nsIPrefBranch> prefBranch; + rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch)); + NS_ENSURE_SUCCESS(rv,rv); + + nsCString username; + rv = smtpServer->GetUsername(username); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ConvertASCIItoUTF16 usernameUTF16(username); + + nsCString hostname; + rv = smtpServer->GetHostname(hostname); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString hostnameUTF16; + CopyASCIItoUTF16(hostname, hostnameUTF16); + + const char16_t *formatStrings[] = + { + hostnameUTF16.get(), + usernameUTF16.get() + }; + + rv = PromptForPassword(smtpServer, smtpUrl, formatStrings, aPassword); + NS_ENSURE_SUCCESS(rv,rv); + return rv; +} + +/** + * formatStrings is an array for the prompts, item 0 is the hostname, item 1 + * is the username. + */ +nsresult +nsSmtpProtocol::PromptForPassword(nsISmtpServer *aSmtpServer, nsISmtpUrl *aSmtpUrl, const char16_t **formatStrings, nsACString &aPassword) +{ + nsCOMPtr<nsIStringBundleService> stringService = + mozilla::services::GetStringBundleService(); + NS_ENSURE_TRUE(stringService, NS_ERROR_UNEXPECTED); + + nsCOMPtr<nsIStringBundle> composeStringBundle; + nsresult rv = stringService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(composeStringBundle)); + NS_ENSURE_SUCCESS(rv,rv); + + nsString passwordPromptString; + if(formatStrings[1]) + rv = composeStringBundle->FormatStringFromName( + u"smtpEnterPasswordPromptWithUsername", + formatStrings, 2, getter_Copies(passwordPromptString)); + else + rv = composeStringBundle->FormatStringFromName( + u"smtpEnterPasswordPrompt", + formatStrings, 1, getter_Copies(passwordPromptString)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIAuthPrompt> netPrompt; + rv = aSmtpUrl->GetAuthPrompt(getter_AddRefs(netPrompt)); + NS_ENSURE_SUCCESS(rv, rv); + + nsString passwordTitle; + rv = composeStringBundle->GetStringFromName( + u"smtpEnterPasswordPromptTitle", + getter_Copies(passwordTitle)); + NS_ENSURE_SUCCESS(rv,rv); + + rv = aSmtpServer->GetPasswordWithUI(passwordPromptString.get(), passwordTitle.get(), + netPrompt, aPassword); + NS_ENSURE_SUCCESS(rv,rv); + return rv; +} + +nsresult +nsSmtpProtocol::GetUsernamePassword(nsACString &aUsername, + nsACString &aPassword) +{ + nsresult rv; + nsCOMPtr<nsISmtpUrl> smtpUrl = do_QueryInterface(m_runningURL, &rv); + NS_ENSURE_SUCCESS(rv,rv); + + nsCOMPtr<nsISmtpServer> smtpServer; + rv = smtpUrl->GetSmtpServer(getter_AddRefs(smtpServer)); + NS_ENSURE_SUCCESS(rv,rv); + + rv = smtpServer->GetPassword(aPassword); + NS_ENSURE_SUCCESS(rv,rv); + + if (!aPassword.IsEmpty()) + { + rv = smtpServer->GetUsername(aUsername); + NS_ENSURE_SUCCESS(rv,rv); + + if (!aUsername.IsEmpty()) + return rv; + } + // empty password + + aPassword.Truncate(); + + nsCString hostname; + rv = smtpServer->GetHostname(hostname); + NS_ENSURE_SUCCESS(rv, rv); + + const char16_t *formatStrings[] = + { + NS_ConvertASCIItoUTF16(hostname).get(), + nullptr + }; + + rv = PromptForPassword(smtpServer, smtpUrl, formatStrings, aPassword); + NS_ENSURE_SUCCESS(rv,rv); + return rv; +} + |