Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 755 insertions, 0 deletions

diff --git a/comm/mailnews/compose/src/nsSmtpUrl.cpp b/comm/mailnews/compose/src/nsSmtpUrl.cpp
new file mode 100644
index 0000000000..b9ac451650
--- /dev/null
+++ b/comm/mailnews/compose/src/nsSmtpUrl.cpp
@@ -0,0 +1,755 @@
+/* -*- 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 "nsIURI.h"
+#include "nsNetCID.h"
+#include "nsSmtpUrl.h"
+#include "nsString.h"
+#include "nsMsgUtils.h"
+#include "nsIMimeConverter.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsCRT.h"
+#include "mozilla/Encoding.h"
+
+/////////////////////////////////////////////////////////////////////////////////////
+// mailto url definition
+/////////////////////////////////////////////////////////////////////////////////////
+nsMailtoUrl::nsMailtoUrl() { mFormat = nsIMsgCompFormat::Default; }
+
+nsMailtoUrl::~nsMailtoUrl() {}
+
+NS_IMPL_ISUPPORTS(nsMailtoUrl, nsIMailtoUrl, nsIURI)
+
+static void UnescapeAndConvert(nsIMimeConverter* mimeConverter,
+                               const nsACString& escaped, nsACString& out) {
+  NS_ASSERTION(mimeConverter, "Set mimeConverter before calling!");
+  // If the string is empty, do absolutely nothing.
+  if (escaped.IsEmpty()) return;
+
+  MsgUnescapeString(escaped, 0, out);
+  nsAutoCString decodedString;
+  nsresult rv = mimeConverter->DecodeMimeHeaderToUTF8(out, "UTF_8", false, true,
+                                                      decodedString);
+  if (NS_SUCCEEDED(rv) && !decodedString.IsEmpty()) out = decodedString;
+}
+
+nsresult nsMailtoUrl::ParseMailtoUrl(char* searchPart) {
+  char* rest = searchPart;
+  nsCString escapedInReplyToPart;
+  nsCString escapedToPart;
+  nsCString escapedCcPart;
+  nsCString escapedSubjectPart;
+  nsCString escapedNewsgroupPart;
+  nsCString escapedNewsHostPart;
+  nsCString escapedReferencePart;
+  nsCString escapedBodyPart;
+  nsCString escapedBccPart;
+  nsCString escapedFollowUpToPart;
+  nsCString escapedFromPart;
+  nsCString escapedHtmlPart;
+  nsCString escapedOrganizationPart;
+  nsCString escapedReplyToPart;
+  nsCString escapedPriorityPart;
+
+  // okay, first, free up all of our old search part state.....
+  CleanupMailtoState();
+  // m_toPart has the escaped address from before the query string, copy it
+  // over so we can add on any additional to= addresses and unescape them all.
+  escapedToPart = m_toPart;
+
+  if (rest && *rest == '?') {
+    /* start past the '?' */
+    rest++;
+  }
+
+  if (rest) {
+    char* token = NS_strtok("&", &rest);
+    while (token && *token) {
+      char* value = 0;
+      char* eq = PL_strchr(token, '=');
+      if (eq) {
+        value = eq + 1;
+        *eq = 0;
+      }
+
+      nsCString decodedName;
+      MsgUnescapeString(nsDependentCString(token), 0, decodedName);
+
+      if (decodedName.IsEmpty()) break;
+
+      switch (NS_ToUpper(decodedName.First())) {
+          /* DO NOT support attachment= in mailto urls. This poses a security
+             fire hole!!! case 'A': if (!PL_strcasecmp (token, "attachment"))
+                            m_attachmentPart = value;
+                            break;
+                       */
+        case 'B':
+          if (decodedName.LowerCaseEqualsLiteral("bcc")) {
+            if (!escapedBccPart.IsEmpty()) {
+              escapedBccPart += ", ";
+              escapedBccPart += value;
+            } else
+              escapedBccPart = value;
+          } else if (decodedName.LowerCaseEqualsLiteral("body")) {
+            if (!escapedBodyPart.IsEmpty()) {
+              escapedBodyPart += "\n";
+              escapedBodyPart += value;
+            } else
+              escapedBodyPart = value;
+          }
+          break;
+        case 'C':
+          if (decodedName.LowerCaseEqualsLiteral("cc")) {
+            if (!escapedCcPart.IsEmpty()) {
+              escapedCcPart += ", ";
+              escapedCcPart += value;
+            } else
+              escapedCcPart = value;
+          }
+          break;
+        case 'F':
+          if (decodedName.LowerCaseEqualsLiteral("followup-to"))
+            escapedFollowUpToPart = value;
+          else if (decodedName.LowerCaseEqualsLiteral("from"))
+            escapedFromPart = value;
+          break;
+        case 'H':
+          if (decodedName.LowerCaseEqualsLiteral("html-part") ||
+              decodedName.LowerCaseEqualsLiteral("html-body")) {
+            // escapedHtmlPart holds the body for both html-part and html-body.
+            escapedHtmlPart = value;
+            mFormat = nsIMsgCompFormat::HTML;
+          }
+          break;
+        case 'I':
+          if (decodedName.LowerCaseEqualsLiteral("in-reply-to"))
+            escapedInReplyToPart = value;
+          break;
+
+        case 'N':
+          if (decodedName.LowerCaseEqualsLiteral("newsgroups"))
+            escapedNewsgroupPart = value;
+          else if (decodedName.LowerCaseEqualsLiteral("newshost"))
+            escapedNewsHostPart = value;
+          break;
+        case 'O':
+          if (decodedName.LowerCaseEqualsLiteral("organization"))
+            escapedOrganizationPart = value;
+          break;
+        case 'R':
+          if (decodedName.LowerCaseEqualsLiteral("references"))
+            escapedReferencePart = value;
+          else if (decodedName.LowerCaseEqualsLiteral("reply-to"))
+            escapedReplyToPart = value;
+          break;
+        case 'S':
+          if (decodedName.LowerCaseEqualsLiteral("subject"))
+            escapedSubjectPart = value;
+          break;
+        case 'P':
+          if (decodedName.LowerCaseEqualsLiteral("priority"))
+            escapedPriorityPart = PL_strdup(value);
+          break;
+        case 'T':
+          if (decodedName.LowerCaseEqualsLiteral("to")) {
+            if (!escapedToPart.IsEmpty()) {
+              escapedToPart += ", ";
+              escapedToPart += value;
+            } else
+              escapedToPart = value;
+          }
+          break;
+        default:
+          break;
+      }  // end of switch statement...
+
+      if (eq) *eq = '='; /* put it back */
+      token = NS_strtok("&", &rest);
+    }  // while we still have part of the url to parse...
+  }    // if rest && *rest
+
+  nsresult rv;
+  // Get a global converter
+  nsCOMPtr<nsIMimeConverter> mimeConverter =
+      do_GetService("@mozilla.org/messenger/mimeconverter;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now unescape everything, and mime-decode the things that can be encoded.
+  UnescapeAndConvert(mimeConverter, escapedToPart, m_toPart);
+  UnescapeAndConvert(mimeConverter, escapedCcPart, m_ccPart);
+  UnescapeAndConvert(mimeConverter, escapedBccPart, m_bccPart);
+  UnescapeAndConvert(mimeConverter, escapedSubjectPart, m_subjectPart);
+  UnescapeAndConvert(mimeConverter, escapedNewsgroupPart, m_newsgroupPart);
+  UnescapeAndConvert(mimeConverter, escapedReferencePart, m_referencePart);
+  if (!escapedBodyPart.IsEmpty())
+    MsgUnescapeString(escapedBodyPart, 0, m_bodyPart);
+  if (!escapedHtmlPart.IsEmpty())
+    MsgUnescapeString(escapedHtmlPart, 0, m_htmlPart);
+  UnescapeAndConvert(mimeConverter, escapedNewsHostPart, m_newsHostPart);
+  UnescapeAndConvert(mimeConverter, escapedFollowUpToPart, m_followUpToPart);
+  UnescapeAndConvert(mimeConverter, escapedFromPart, m_fromPart);
+  UnescapeAndConvert(mimeConverter, escapedOrganizationPart,
+                     m_organizationPart);
+  UnescapeAndConvert(mimeConverter, escapedReplyToPart, m_replyToPart);
+  UnescapeAndConvert(mimeConverter, escapedPriorityPart, m_priorityPart);
+
+  nsCString inReplyToPart;  // Not a member like the others...
+  UnescapeAndConvert(mimeConverter, escapedInReplyToPart, inReplyToPart);
+
+  if (!inReplyToPart.IsEmpty()) {
+    // Ensure that References and In-Reply-To are consistent... The last
+    // reference will be used as In-Reply-To header.
+    if (m_referencePart.IsEmpty()) {
+      // If References is not set, set it to be the In-Reply-To.
+      m_referencePart = inReplyToPart;
+    } else {
+      // References is set. Add the In-Reply-To as last header unless it's
+      // set as last reference already.
+      int32_t lastRefStart = m_referencePart.RFindChar('<');
+      nsAutoCString lastReference;
+      if (lastRefStart != -1)
+        lastReference = StringTail(m_referencePart, lastRefStart);
+      else
+        lastReference = m_referencePart;
+
+      if (lastReference != inReplyToPart) {
+        m_referencePart += " ";
+        m_referencePart += inReplyToPart;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMailtoUrl::SetSpecInternal(const nsACString& aSpec) {
+  nsresult rv = NS_MutateURI(NS_SIMPLEURIMUTATOR_CONTRACTID)
+                    .SetSpec(aSpec)
+                    .Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+nsresult nsMailtoUrl::CleanupMailtoState() {
+  m_ccPart = "";
+  m_subjectPart = "";
+  m_newsgroupPart = "";
+  m_newsHostPart = "";
+  m_referencePart = "";
+  m_bodyPart = "";
+  m_bccPart = "";
+  m_followUpToPart = "";
+  m_fromPart = "";
+  m_htmlPart = "";
+  m_organizationPart = "";
+  m_replyToPart = "";
+  m_priorityPart = "";
+  return NS_OK;
+}
+
+nsresult nsMailtoUrl::ParseUrl() {
+  // we can get the path from the simple url.....
+  nsCString escapedPath;
+  m_baseURL->GetPathQueryRef(escapedPath);
+
+  int32_t startOfSearchPart = escapedPath.FindChar('?');
+  if (startOfSearchPart >= 0) {
+    // now parse out the search field...
+    nsAutoCString searchPart(Substring(escapedPath, startOfSearchPart));
+
+    if (!searchPart.IsEmpty()) {
+      // now we need to strip off the search part from the
+      // to part....
+      escapedPath.SetLength(startOfSearchPart);
+      MsgUnescapeString(escapedPath, 0, m_toPart);
+      ParseMailtoUrl(searchPart.BeginWriting());
+    }
+  } else if (!escapedPath.IsEmpty()) {
+    MsgUnescapeString(escapedPath, 0, m_toPart);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetMessageContents(nsACString& aToPart, nsACString& aCcPart,
+                                nsACString& aBccPart, nsACString& aSubjectPart,
+                                nsACString& aBodyPart, nsACString& aHtmlPart,
+                                nsACString& aReferencePart,
+                                nsACString& aNewsgroupPart,
+                                MSG_ComposeFormat* aFormat) {
+  NS_ENSURE_ARG_POINTER(aFormat);
+
+  aToPart = m_toPart;
+  aCcPart = m_ccPart;
+  aBccPart = m_bccPart;
+  aSubjectPart = m_subjectPart;
+  aBodyPart = m_bodyPart;
+  aHtmlPart = m_htmlPart;
+  aReferencePart = m_referencePart;
+  aNewsgroupPart = m_newsgroupPart;
+  *aFormat = mFormat;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetFromPart(nsACString& aResult) {
+  aResult = m_fromPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetFollowUpToPart(nsACString& aResult) {
+  aResult = m_followUpToPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetOrganizationPart(nsACString& aResult) {
+  aResult = m_organizationPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetReplyToPart(nsACString& aResult) {
+  aResult = m_replyToPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetPriorityPart(nsACString& aResult) {
+  aResult = m_priorityPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetNewsHostPart(nsACString& aResult) {
+  aResult = m_newsHostPart;
+  return NS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Begin nsIURI support
+//////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsMailtoUrl::GetSpec(nsACString& aSpec) {
+  return m_baseURL->GetSpec(aSpec);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPrePath(nsACString& aPrePath) {
+  return m_baseURL->GetPrePath(aPrePath);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetScheme(nsACString& aScheme) {
+  return m_baseURL->GetScheme(aScheme);
+}
+
+nsresult nsMailtoUrl::SetScheme(const nsACString& aScheme) {
+  nsresult rv = NS_MutateURI(m_baseURL).SetScheme(aScheme).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetUserPass(nsACString& aUserPass) {
+  return m_baseURL->GetUserPass(aUserPass);
+}
+
+nsresult nsMailtoUrl::SetUserPass(const nsACString& aUserPass) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetUserPass(aUserPass).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetUsername(nsACString& aUsername) {
+  return m_baseURL->GetUsername(aUsername);
+}
+
+nsresult nsMailtoUrl::SetUsername(const nsACString& aUsername) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetUsername(aUsername).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPassword(nsACString& aPassword) {
+  return m_baseURL->GetPassword(aPassword);
+}
+
+nsresult nsMailtoUrl::SetPassword(const nsACString& aPassword) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetPassword(aPassword).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetHostPort(nsACString& aHostPort) {
+  return m_baseURL->GetHost(aHostPort);
+}
+
+nsresult nsMailtoUrl::SetHostPort(const nsACString& aHostPort) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetHostPort(aHostPort).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetHost(nsACString& aHost) {
+  return m_baseURL->GetHost(aHost);
+}
+
+nsresult nsMailtoUrl::SetHost(const nsACString& aHost) {
+  nsresult rv = NS_MutateURI(m_baseURL).SetHost(aHost).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPort(int32_t* aPort) {
+  return m_baseURL->GetPort(aPort);
+}
+
+nsresult nsMailtoUrl::SetPort(int32_t aPort) {
+  nsresult rv = NS_MutateURI(m_baseURL).SetPort(aPort).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPathQueryRef(nsACString& aPath) {
+  return m_baseURL->GetPathQueryRef(aPath);
+}
+
+nsresult nsMailtoUrl::SetPathQueryRef(const nsACString& aPath) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetPathQueryRef(aPath).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetAsciiHost(nsACString& aHostA) {
+  return m_baseURL->GetAsciiHost(aHostA);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetAsciiHostPort(nsACString& aHostPortA) {
+  return m_baseURL->GetAsciiHostPort(aHostPortA);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetAsciiSpec(nsACString& aSpecA) {
+  return m_baseURL->GetAsciiSpec(aSpecA);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SchemeIs(const char* aScheme, bool* _retval) {
+  return m_baseURL->SchemeIs(aScheme, _retval);
+}
+
+NS_IMETHODIMP nsMailtoUrl::Equals(nsIURI* other, bool* _retval) {
+  // The passed-in URI might be an nsMailtoUrl. Pass our inner URL to its
+  // Equals method. The other nsMailtoUrl will then pass its inner URL to
+  // to the Equals method of our inner URL. Other URIs will return false.
+  if (other) return other->Equals(m_baseURL, _retval);
+
+  return m_baseURL->Equals(other, _retval);
+}
+
+nsresult nsMailtoUrl::Clone(nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  RefPtr<nsMailtoUrl> clone = new nsMailtoUrl();
+
+  NS_ENSURE_TRUE(clone, NS_ERROR_OUT_OF_MEMORY);
+
+  nsresult rv = NS_MutateURI(m_baseURL).Finalize(clone->m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  clone->ParseUrl();
+  clone.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailtoUrl::Resolve(const nsACString& relativePath,
+                                   nsACString& result) {
+  return m_baseURL->Resolve(relativePath, result);
+}
+
+nsresult nsMailtoUrl::SetRef(const nsACString& aRef) {
+  return NS_MutateURI(m_baseURL).SetRef(aRef).Finalize(m_baseURL);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetRef(nsACString& result) { return m_baseURL->GetRef(result); }
+
+NS_IMETHODIMP nsMailtoUrl::EqualsExceptRef(nsIURI* other, bool* result) {
+  // The passed-in URI might be an nsMailtoUrl. Pass our inner URL to its
+  // Equals method. The other nsMailtoUrl will then pass its inner URL to
+  // to the Equals method of our inner URL. Other URIs will return false.
+  if (other) return other->EqualsExceptRef(m_baseURL, result);
+
+  return m_baseURL->EqualsExceptRef(other, result);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetSpecIgnoringRef(nsACString& result) {
+  return m_baseURL->GetSpecIgnoringRef(result);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplaySpec(nsACString& aUnicodeSpec) {
+  return m_baseURL->GetDisplaySpec(aUnicodeSpec);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplayHostPort(nsACString& aUnicodeHostPort) {
+  return m_baseURL->GetDisplayHostPort(aUnicodeHostPort);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplayHost(nsACString& aUnicodeHost) {
+  return m_baseURL->GetDisplayHost(aUnicodeHost);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplayPrePath(nsACString& aPrePath) {
+  return m_baseURL->GetDisplayPrePath(aPrePath);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetHasRef(bool* result) { return m_baseURL->GetHasRef(result); }
+
+NS_IMETHODIMP
+nsMailtoUrl::GetFilePath(nsACString& aFilePath) {
+  return m_baseURL->GetFilePath(aFilePath);
+}
+
+nsresult nsMailtoUrl::SetFilePath(const nsACString& aFilePath) {
+  return NS_MutateURI(m_baseURL).SetFilePath(aFilePath).Finalize(m_baseURL);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetQuery(nsACString& aQuery) {
+  return m_baseURL->GetQuery(aQuery);
+}
+
+nsresult nsMailtoUrl::SetQuery(const nsACString& aQuery) {
+  return NS_MutateURI(m_baseURL).SetQuery(aQuery).Finalize(m_baseURL);
+}
+
+nsresult nsMailtoUrl::SetQueryWithEncoding(const nsACString& aQuery,
+                                           const mozilla::Encoding* aEncoding) {
+  return NS_MutateURI(m_baseURL)
+      .SetQueryWithEncoding(aQuery, aEncoding)
+      .Finalize(m_baseURL);
+}
+
+NS_IMETHODIMP_(void)
+nsMailtoUrl::Serialize(mozilla::ipc::URIParams& aParams) {
+  m_baseURL->Serialize(aParams);
+}
+
+NS_IMPL_ISUPPORTS(nsMailtoUrl::Mutator, nsIURISetters, nsIURIMutator)
+
+NS_IMETHODIMP
+nsMailtoUrl::Mutate(nsIURIMutator** aMutator) {
+  RefPtr<nsMailtoUrl::Mutator> mutator = new nsMailtoUrl::Mutator();
+  nsresult rv = mutator->InitFromURI(this);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  mutator.forget(aMutator);
+  return NS_OK;
+}
+
+nsresult nsMailtoUrl::NewMailtoURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                                   nsIURI** _retval) {
+  nsresult rv;
+
+  nsCOMPtr<nsIURI> mailtoUrl;
+  rv = NS_MutateURI(new Mutator()).SetSpec(aSpec).Finalize(mailtoUrl);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mailtoUrl.forget(_retval);
+  return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// smtp url definition
+/////////////////////////////////////////////////////////////////////////////////////
+
+nsSmtpUrl::nsSmtpUrl() : nsMsgMailNewsUrl() {
+  // nsISmtpUrl specific state...
+
+  m_isPostMessage = true;
+  m_requestDSN = false;
+  m_verifyLogon = false;
+}
+
+nsSmtpUrl::~nsSmtpUrl() {}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsSmtpUrl, nsMsgMailNewsUrl, nsISmtpUrl)
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsISmtpUrl specific support
+
+////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsSmtpUrl::SetRecipients(const char* aRecipientsList) {
+  NS_ENSURE_ARG(aRecipientsList);
+  MsgUnescapeString(nsDependentCString(aRecipientsList), 0, m_toPart);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetRecipients(char** aRecipientsList) {
+  NS_ENSURE_ARG_POINTER(aRecipientsList);
+  if (aRecipientsList) *aRecipientsList = ToNewCString(m_toPart);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetSender(const char* aSender) {
+  NS_ENSURE_ARG(aSender);
+  MsgUnescapeString(nsDependentCString(aSender), 0, m_fromPart);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetSender(char** aSender) {
+  NS_ENSURE_ARG_POINTER(aSender);
+  if (aSender) *aSender = ToNewCString(m_fromPart);
+  return NS_OK;
+}
+
+NS_IMPL_GETSET(nsSmtpUrl, PostMessage, bool, m_isPostMessage)
+
+NS_IMPL_GETSET(nsSmtpUrl, VerifyLogon, bool, m_verifyLogon)
+
+// the message can be stored in a file....allow accessors for getting and
+// setting the file name to post...
+NS_IMETHODIMP nsSmtpUrl::SetPostMessageFile(nsIFile* aFile) {
+  NS_ENSURE_ARG_POINTER(aFile);
+  m_fileName = aFile;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSmtpUrl::GetPostMessageFile(nsIFile** aFile) {
+  NS_ENSURE_ARG_POINTER(aFile);
+  if (m_fileName) {
+    // Clone the file so nsLocalFile stat caching doesn't make the caller get
+    // the wrong file size.
+    m_fileName->Clone(aFile);
+    return *aFile ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+  }
+  return NS_ERROR_NULL_POINTER;
+}
+
+NS_IMPL_GETSET(nsSmtpUrl, RequestDSN, bool, m_requestDSN)
+
+NS_IMETHODIMP
+nsSmtpUrl::SetDsnEnvid(const nsACString& aDsnEnvid) {
+  m_dsnEnvid = aDsnEnvid;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetDsnEnvid(nsACString& aDsnEnvid) {
+  aDsnEnvid = m_dsnEnvid;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetSenderIdentity(nsIMsgIdentity** aSenderIdentity) {
+  NS_ENSURE_ARG_POINTER(aSenderIdentity);
+  NS_ADDREF(*aSenderIdentity = m_senderIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetSenderIdentity(nsIMsgIdentity* aSenderIdentity) {
+  NS_ENSURE_ARG_POINTER(aSenderIdentity);
+  m_senderIdentity = aSenderIdentity;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetPrompt(nsIPrompt* aNetPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetPrompt);
+  m_netPrompt = aNetPrompt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetPrompt(nsIPrompt** aNetPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetPrompt);
+  NS_ENSURE_TRUE(m_netPrompt, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aNetPrompt = m_netPrompt);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetAuthPrompt(nsIAuthPrompt* aNetAuthPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetAuthPrompt);
+  m_netAuthPrompt = aNetAuthPrompt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetAuthPrompt(nsIAuthPrompt** aNetAuthPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetAuthPrompt);
+  NS_ENSURE_TRUE(m_netAuthPrompt, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aNetAuthPrompt = m_netAuthPrompt);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks) {
+  NS_ENSURE_ARG_POINTER(aCallbacks);
+  m_callbacks = aCallbacks;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks) {
+  NS_ENSURE_ARG_POINTER(aCallbacks);
+  NS_ENSURE_TRUE(m_callbacks, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aCallbacks = m_callbacks);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetSmtpServer(nsISmtpServer* aSmtpServer) {
+  NS_ENSURE_ARG_POINTER(aSmtpServer);
+  m_smtpServer = aSmtpServer;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetSmtpServer(nsISmtpServer** aSmtpServer) {
+  NS_ENSURE_ARG_POINTER(aSmtpServer);
+  NS_ENSURE_TRUE(m_smtpServer, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aSmtpServer = m_smtpServer);
+  return NS_OK;
+}
+
+nsresult nsSmtpUrl::NewSmtpURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                               nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = 0;
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailNewsUrl> aSmtpUri = new nsSmtpUrl();
+  if (aBaseURI) {
+    nsAutoCString newSpec;
+    rv = aBaseURI->Resolve(aSpec, newSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aSmtpUri->SetSpecInternal(newSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    rv = aSmtpUri->SetSpecInternal(aSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  aSmtpUri.forget(_retval);
+
+  return rv;
+}