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, 679 insertions, 0 deletions

diff --git a/comm/mailnews/import/src/nsWMSettings.cpp b/comm/mailnews/import/src/nsWMSettings.cpp
new file mode 100644
index 0000000000..ee741fa053
--- /dev/null
+++ b/comm/mailnews/import/src/nsWMSettings.cpp
@@ -0,0 +1,679 @@
+/* -*- 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/. */
+
+/*
+  Windows Live Mail (Win32) settings
+*/
+
+#include "nsCOMPtr.h"
+#include "nscore.h"
+#include "nsString.h"
+#include "nsMsgUtils.h"
+#include "nsWMImport.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgAccount.h"
+#include "nsIImportSettings.h"
+#include "nsWMSettings.h"
+#include "nsMsgI18N.h"
+#include "nsISmtpService.h"
+#include "nsISmtpServer.h"
+#include "nsWMStringBundle.h"
+#include "ImportDebug.h"
+#include "nsIPop3IncomingServer.h"
+#include "nsIImapIncomingServer.h"
+#include "nsINntpIncomingServer.h"
+#include "stdlib.h"
+#include "mozilla/dom/Document.h"
+#include "nsIFile.h"
+#include "nsNetUtil.h"
+#include "nsTArray.h"
+#include <windows.h>
+#include "nsIWindowsRegKey.h"
+#include "nsCOMArray.h"
+#include "nsWMUtils.h"
+
+class WMSettings {
+ public:
+  static bool DoImport(nsIMsgAccount** ppAccount);
+  static bool DoIMAPServer(nsIMsgAccountManager* pMgr,
+                           mozilla::dom::Document* xmlDoc,
+                           const nsString& serverName,
+                           nsIMsgAccount** ppAccount);
+  static bool DoPOP3Server(nsIMsgAccountManager* pMgr,
+                           mozilla::dom::Document* xmlDoc,
+                           const nsString& serverName,
+                           nsIMsgAccount** ppAccount);
+  static bool DoNNTPServer(nsIMsgAccountManager* pMgr,
+                           mozilla::dom::Document* xmlDoc,
+                           const nsString& serverName,
+                           nsIMsgAccount** ppAccount);
+  static void SetIdentities(nsIMsgAccountManager* pMgr, nsIMsgAccount* pAcc,
+                            mozilla::dom::Document* xmlDoc,
+                            nsAutoString& userName, int32_t authMethodIncoming,
+                            bool isNNTP);
+  static void SetSmtpServer(mozilla::dom::Document* xmlDoc, nsIMsgIdentity* id,
+                            nsAutoString& inUserName,
+                            int32_t authMethodIncoming);
+};
+
+static int32_t checkNewMailTime;  // WM global setting, let's default to 30
+static bool checkNewMail;         // WM global setting, let's default to false
+                                  // This won't cause unwanted autodownloads-
+                                  // user can set prefs after import
+
+////////////////////////////////////////////////////////////////////////
+nsresult nsWMSettings::Create(nsIImportSettings** aImport) {
+  NS_ENSURE_ARG_POINTER(aImport);
+  NS_ADDREF(*aImport = new nsWMSettings());
+  return NS_OK;
+}
+
+nsWMSettings::nsWMSettings() {}
+
+nsWMSettings::~nsWMSettings() {}
+
+NS_IMPL_ISUPPORTS(nsWMSettings, nsIImportSettings)
+
+NS_IMETHODIMP nsWMSettings::AutoLocate(char16_t** description,
+                                       nsIFile** location, bool* _retval) {
+  NS_ASSERTION(description != nullptr, "null ptr");
+  NS_ASSERTION(_retval != nullptr, "null ptr");
+  if (!description || !_retval) return NS_ERROR_NULL_POINTER;
+
+  *description = nsWMStringBundle::GetStringByID(WMIMPORT_NAME);
+  *_retval = false;
+
+  if (location) *location = nullptr;
+  nsCOMPtr<nsIWindowsRegKey> key;
+  if (NS_SUCCEEDED(nsWMUtils::FindWMKey(getter_AddRefs(key)))) *_retval = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsWMSettings::SetLocation(nsIFile* location) { return NS_OK; }
+
+NS_IMETHODIMP nsWMSettings::Import(nsIMsgAccount** localMailAccount,
+                                   bool* _retval) {
+  NS_ASSERTION(_retval != nullptr, "null ptr");
+
+  if (WMSettings::DoImport(localMailAccount)) {
+    *_retval = true;
+    IMPORT_LOG0("Settings import appears successful\n");
+  } else {
+    *_retval = false;
+    IMPORT_LOG0("Settings import returned FALSE\n");
+  }
+
+  return NS_OK;
+}
+
+bool WMSettings::DoImport(nsIMsgAccount** ppAccount) {
+  // do the windows registry stuff first
+  nsCOMPtr<nsIWindowsRegKey> key;
+  if (NS_FAILED(nsWMUtils::FindWMKey(getter_AddRefs(key)))) {
+    IMPORT_LOG0("*** Error finding Windows Live Mail registry account keys\n");
+    return false;
+  }
+  // 'poll for messages' setting in WM is a global setting-Like OE
+  // for all accounts dword ==0xffffffff for don't poll else 1/60000 = minutes
+  checkNewMailTime = 30;
+  checkNewMail = false;
+
+  nsresult rv;
+  nsCOMPtr<nsIWindowsRegKey> subKey;
+  if (NS_SUCCEEDED(key->OpenChild(u"mail"_ns,
+                                  nsIWindowsRegKey::ACCESS_QUERY_VALUE,
+                                  getter_AddRefs(subKey)))) {
+    uint32_t dwordResult = 0xffffffff;
+    rv = subKey->ReadIntValue(u"Poll For Mail"_ns,
+                              &dwordResult);  // reg_dword
+    subKey->Close();
+    if (NS_SUCCEEDED(rv) && dwordResult != 0xffffffff) {
+      checkNewMail = true;
+      checkNewMailTime = dwordResult / 60000;
+    }
+  }
+  // these are in main windowsmail key and if they don't exist-not to worry
+  // (less than 64 chars) e.g.
+  // account{4A18B81E-83CA-472A-8D7F-5301C0B97B8D}.oeaccount
+  nsAutoString defMailAcct, defNewsAcct;
+  key->ReadStringValue(u"Default Mail Account"_ns,
+                       defMailAcct);  // ref_sz
+  key->ReadStringValue(u"Default News Account"_ns,
+                       defNewsAcct);  // ref_sz
+
+  nsCOMPtr<nsIMsgAccountManager> accMgr =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  if (NS_FAILED(rv)) {
+    IMPORT_LOG0("*** Failed to create an account manager!\n");
+    return false;
+  }
+
+  nsCOMArray<nsIFile> fileArray;
+  if (NS_FAILED(nsWMUtils::GetOEAccountFiles(fileArray))) {
+    IMPORT_LOG0("*** Failed to get .oeaccount file!\n");
+    return false;
+  }
+
+  // Loop through *.oeaccounts files looking for POP3 & IMAP & NNTP accounts
+  // Ignore LDAP for now!
+  int accounts = 0;
+  nsCOMPtr<mozilla::dom::Document> xmlDoc;
+
+  for (int32_t i = fileArray.Count() - 1; i >= 0; i--) {
+    nsWMUtils::MakeXMLdoc(getter_AddRefs(xmlDoc), fileArray[i]);
+
+    nsAutoCString name;
+    fileArray[i]->GetNativeLeafName(name);
+    nsAutoString value;
+    nsCOMPtr<nsIMsgAccount> anAccount;
+    if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "IMAP_Server", value)))
+      if (DoIMAPServer(accMgr, xmlDoc, value, getter_AddRefs(anAccount)))
+        accounts++;
+    if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "NNTP_Server", value)))
+      if (DoNNTPServer(accMgr, xmlDoc, value, getter_AddRefs(anAccount)))
+        accounts++;
+    if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "POP3_Server", value)))
+      if (DoPOP3Server(accMgr, xmlDoc, value, getter_AddRefs(anAccount)))
+        accounts++;
+
+    if (anAccount) {
+      nsString name;
+      // Is this the default account?
+      fileArray[i]->GetLeafName(name);
+      if (defMailAcct.Equals(name)) accMgr->SetDefaultAccount(anAccount);
+    }
+  }
+
+  // Now save the new acct info to pref file.
+  rv = accMgr->SaveAccountInfo();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "Can't save account info to pref file");
+
+  return accounts != 0;
+}
+
+bool WMSettings::DoIMAPServer(nsIMsgAccountManager* pMgr,
+                              mozilla::dom::Document* xmlDoc,
+                              const nsString& serverName,
+                              nsIMsgAccount** ppAccount) {
+  int32_t authMethod;  // Secure Password Authentication (SPA)
+  nsresult errorCode;
+  if (ppAccount) *ppAccount = nullptr;
+
+  nsAutoString userName, value;
+  if (NS_FAILED(nsWMUtils::GetValueForTag(xmlDoc, "IMAP_User_Name", userName)))
+    return false;
+  bool result = false;
+  // I now have a user name/server name pair, find out if it already exists?
+  nsCOMPtr<nsIMsgIncomingServer> in;
+  nsresult rv = pMgr->FindServer(NS_ConvertUTF16toUTF8(userName),
+                                 NS_ConvertUTF16toUTF8(serverName), "imap"_ns,
+                                 0, getter_AddRefs(in));
+  if (NS_FAILED(rv) || (in == nullptr)) {
+    // Create the incoming server and an account for it?
+    rv = pMgr->CreateIncomingServer(NS_ConvertUTF16toUTF8(userName),
+                                    NS_ConvertUTF16toUTF8(serverName),
+                                    "imap"_ns, getter_AddRefs(in));
+    if (NS_SUCCEEDED(rv) && in) {
+      nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(in);
+      if (!imapServer) {
+        IMPORT_LOG1("*** Failed to create nsIImapIncomingServer for %S!\n",
+                    static_cast<const wchar_t*>(serverName.get()));
+        return false;
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "IMAP_Root_Folder", value))) {
+        imapServer->SetServerDirectory(NS_ConvertUTF16toUTF8(value));
+      }
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(
+              xmlDoc, "IMAP_Secure_Connection", value))) {
+        if (value.ToInteger(&errorCode, 16))
+          in->SetSocketType(nsMsgSocketType::SSL);
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "IMAP_Use_Sicily", value))) {
+        bool secAuth = (bool)value.ToInteger(&errorCode, 16);
+        authMethod = secAuth ? nsMsgAuthMethod::secure
+                             : nsMsgAuthMethod::passwordCleartext;
+        in->SetAuthMethod(authMethod);
+      }
+
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "IMAP_Port", value))) {
+        in->SetPort(value.ToInteger(&errorCode, 16));
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "Account_Name", value))) {
+        rv = in->SetPrettyName(value);
+      }
+      in->SetDoBiff(checkNewMail);
+      in->SetBiffMinutes(checkNewMailTime);
+
+      IMPORT_LOG2("Created IMAP server named: %S, userName: %S\n",
+                  static_cast<const wchar_t*>(serverName.get()),
+                  static_cast<const wchar_t*>(userName.get()));
+
+      // We have a server, create an account.
+      nsCOMPtr<nsIMsgAccount> account;
+      rv = pMgr->CreateAccount(getter_AddRefs(account));
+      if (NS_SUCCEEDED(rv) && account) {
+        rv = account->SetIncomingServer(in);
+
+        IMPORT_LOG0(
+            "Created an account and set the IMAP server "
+            "as the incoming server\n");
+
+        // Fiddle with the identities
+        SetIdentities(pMgr, account, xmlDoc, userName, authMethod, false);
+        result = true;
+        if (ppAccount) account.forget(ppAccount);
+      }
+    }
+  } else if (NS_SUCCEEDED(rv) && in) {
+    // for an existing server we create another identity,
+    //  TB lists under 'manage identities'
+    nsCOMPtr<nsIMsgAccount> account;
+    rv = pMgr->FindAccountForServer(in, getter_AddRefs(account));
+    if (NS_SUCCEEDED(rv) && account) {
+      IMPORT_LOG0(
+          "Created an identity and added to existing "
+          "IMAP incoming server\n");
+      // Fiddle with the identities
+      in->GetAuthMethod(&authMethod);
+      SetIdentities(pMgr, account, xmlDoc, userName, authMethod, false);
+      result = true;
+      if (ppAccount) account.forget(ppAccount);
+    }
+  } else
+    result = true;
+  return result;
+}
+
+bool WMSettings::DoPOP3Server(nsIMsgAccountManager* pMgr,
+                              mozilla::dom::Document* xmlDoc,
+                              const nsString& serverName,
+                              nsIMsgAccount** ppAccount) {
+  int32_t authMethod;  // Secure Password Authentication (SPA)
+  nsresult errorCode;
+  if (ppAccount) *ppAccount = nullptr;
+
+  nsAutoString userName, value;
+  if (NS_FAILED(nsWMUtils::GetValueForTag(xmlDoc, "POP3_User_Name", userName)))
+    return false;
+  bool result = false;
+  // I now have a user name/server name pair, find out if it already exists?
+  nsCOMPtr<nsIMsgIncomingServer> in;
+  nsresult rv = pMgr->FindServer(NS_ConvertUTF16toUTF8(userName),
+                                 NS_ConvertUTF16toUTF8(serverName), "pop3"_ns,
+                                 0, getter_AddRefs(in));
+  if (NS_FAILED(rv) || (in == nullptr)) {
+    // Create the incoming server and an account for it?
+    rv = pMgr->CreateIncomingServer(NS_ConvertUTF16toUTF8(userName),
+                                    NS_ConvertUTF16toUTF8(serverName),
+                                    "pop3"_ns, getter_AddRefs(in));
+    if (NS_SUCCEEDED(rv) && in) {
+      nsCOMPtr<nsIPop3IncomingServer> pop3Server = do_QueryInterface(in);
+      if (!pop3Server) {
+        IMPORT_LOG1("*** Failed to create nsIPop3IncomingServer for %S!\n",
+                    static_cast<const wchar_t*>(serverName.get()));
+        return false;
+      }
+
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(
+              xmlDoc, "POP3_Secure_Connection", value)) &&
+          value.ToInteger(&errorCode, 16)) {
+        in->SetSocketType(nsMsgSocketType::SSL);
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "POP3_Use_Sicily", value))) {
+        bool secAuth = (bool)value.ToInteger(&errorCode, 16);
+        authMethod = secAuth ? nsMsgAuthMethod::secure
+                             : nsMsgAuthMethod::passwordCleartext;
+        in->SetAuthMethod(authMethod);
+      }
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "POP3_Port", value))) {
+        in->SetPort(value.ToInteger(&errorCode, 16));
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "POP3_Skip_Account", value))) {
+        if (!value.IsEmpty())
+          // OE:0=='Include this account when receiving mail or synchronizing'==
+          // TB:1==ActMgr:Server:advanced:Include this server when getting new
+          // mail
+          pop3Server->SetDeferGetNewMail(value.ToInteger(&errorCode, 16) == 0);
+        else
+          pop3Server->SetDeferGetNewMail(false);
+      }
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "Leave_Mail_On_Server",
+                                                 value))) {
+        pop3Server->SetLeaveMessagesOnServer(
+            (bool)value.ToInteger(&errorCode, 16));
+      }
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "Remove_When_Deleted",
+                                                 value))) {
+        pop3Server->SetDeleteMailLeftOnServer(
+            (bool)value.ToInteger(&errorCode, 16));
+      }
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "Remove_When_Expired",
+                                                 value))) {
+        pop3Server->SetDeleteByAgeFromServer(
+            (bool)value.ToInteger(&errorCode, 16));
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "Expire_Days", value))) {
+        pop3Server->SetNumDaysToLeaveOnServer(value.ToInteger(&errorCode, 16));
+      }
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "Account_Name", value))) {
+        rv = in->SetPrettyName(value);
+      }
+
+      in->SetDoBiff(checkNewMail);
+      in->SetBiffMinutes(checkNewMailTime);
+
+      // set local folders as the Inbox to use for this POP3 server
+      nsCOMPtr<nsIMsgIncomingServer> localFoldersServer;
+      pMgr->GetLocalFoldersServer(getter_AddRefs(localFoldersServer));
+      if (!localFoldersServer) {
+        // XXX: We may need to move this local folder creation
+        // code to the generic nsImportSettings code
+        // if the other import modules end up needing to do this too.
+        // if Local Folders does not exist already, create it
+        rv = pMgr->CreateLocalMailAccount();
+        if (NS_FAILED(rv)) {
+          IMPORT_LOG0("*** Failed to create Local Folders!\n");
+          return false;
+        }
+        pMgr->GetLocalFoldersServer(getter_AddRefs(localFoldersServer));
+      }
+
+      // now get the account for this server
+      nsCOMPtr<nsIMsgAccount> localFoldersAccount;
+      pMgr->FindAccountForServer(localFoldersServer,
+                                 getter_AddRefs(localFoldersAccount));
+      if (localFoldersAccount) {
+        nsCString localFoldersAcctKey;
+        localFoldersAccount->GetKey(localFoldersAcctKey);
+        pop3Server->SetDeferredToAccount(localFoldersAcctKey);
+      }
+
+      IMPORT_LOG2("Created POP3 server named: %S, userName: %S\n",
+                  static_cast<const wchar_t*>(serverName.get()),
+                  static_cast<const wchar_t*>(userName.get()));
+
+      // We have a server, create an account.
+      nsCOMPtr<nsIMsgAccount> account;
+      rv = pMgr->CreateAccount(getter_AddRefs(account));
+      if (NS_SUCCEEDED(rv) && account) {
+        rv = account->SetIncomingServer(in);
+        IMPORT_LOG0(
+            "Created a new account and set the incoming "
+            "server to the POP3 server.\n");
+
+        // Fiddle with the identities
+        SetIdentities(pMgr, account, xmlDoc, userName, authMethod, false);
+        result = true;
+        if (ppAccount) account.forget(ppAccount);
+      }
+    }
+  } else if (NS_SUCCEEDED(rv) && in) {
+    IMPORT_LOG2("Existing POP3 server named: %S, userName: %S\n",
+                static_cast<const wchar_t*>(serverName.get()),
+                static_cast<const wchar_t*>(userName.get()));
+    // for an existing server we create another identity,
+    // TB listed under 'manage identities'
+    nsCOMPtr<nsIMsgAccount> account;
+    rv = pMgr->FindAccountForServer(in, getter_AddRefs(account));
+    if (NS_SUCCEEDED(rv) && account) {
+      IMPORT_LOG0(
+          "Created identity and added to existing POP3 incoming server.\n");
+      // Fiddle with the identities
+      in->GetAuthMethod(&authMethod);
+      SetIdentities(pMgr, account, xmlDoc, userName, authMethod, false);
+      result = true;
+      if (ppAccount) account.forget(ppAccount);
+    }
+  } else
+    result = true;
+  return result;
+}
+
+bool WMSettings::DoNNTPServer(nsIMsgAccountManager* pMgr,
+                              mozilla::dom::Document* xmlDoc,
+                              const nsString& serverName,
+                              nsIMsgAccount** ppAccount) {
+  int32_t authMethod;
+  nsresult errorCode;
+  if (ppAccount) *ppAccount = nullptr;
+
+  nsAutoString userName, value;
+  // this only exists if NNTP server requires it or not, anonymous login
+  nsWMUtils::GetValueForTag(xmlDoc, "NNTP_User_Name", userName);
+  bool result = false;
+
+  // I now have a user name/server name pair, find out if it already exists?
+  // NNTP can have empty user name.  This is wild card in findserver
+  nsCOMPtr<nsIMsgIncomingServer> in;
+  nsresult rv =
+      pMgr->FindServer(EmptyCString(), NS_ConvertUTF16toUTF8(serverName),
+                       "nntp"_ns, 0, getter_AddRefs(in));
+  if (NS_FAILED(rv) || (in == nullptr)) {
+    // Create the incoming server and an account for it?
+    rv = pMgr->CreateIncomingServer(EmptyCString(),
+                                    NS_ConvertUTF16toUTF8(serverName),
+                                    "nntp"_ns, getter_AddRefs(in));
+    if (NS_SUCCEEDED(rv) && in) {
+      nsCOMPtr<nsINntpIncomingServer> nntpServer = do_QueryInterface(in);
+      if (!nntpServer) {
+        IMPORT_LOG1("*** Failed to create nsINnntpIncomingServer for %S!\n",
+                    static_cast<const wchar_t*>(serverName.get()));
+        return false;
+      }
+      if (!userName.IsEmpty()) {  // if username req'd then auth req'd
+        nntpServer->SetPushAuth(true);
+        in->SetUsername(NS_ConvertUTF16toUTF8(userName));
+      }
+
+      nsAutoString value;
+      if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(xmlDoc, "NNTP_Port", value))) {
+        in->SetPort(value.ToInteger(&errorCode, 16));
+      }
+
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "Account_Name", value))) {
+        in->SetPrettyName(value);
+      }
+
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "NNTP_Use_Sicily", value))) {
+        bool secAuth = (bool)value.ToInteger(&errorCode, 16);
+        authMethod = secAuth ? nsMsgAuthMethod::secure
+                             : nsMsgAuthMethod::passwordCleartext;
+        in->SetAuthMethod(authMethod);
+      }
+
+      IMPORT_LOG2("Created NNTP server named: %S, userName: %S\n",
+                  static_cast<const wchar_t*>(serverName.get()),
+                  static_cast<const wchar_t*>(userName.get()));
+
+      // We have a server, create an account.
+      nsCOMPtr<nsIMsgAccount> account;
+      rv = pMgr->CreateAccount(getter_AddRefs(account));
+      if (NS_SUCCEEDED(rv) && account) {
+        rv = account->SetIncomingServer(in);
+
+        IMPORT_LOG0(
+            "Created an account and set the NNTP server "
+            "as the incoming server\n");
+
+        // Fiddle with the identities
+        SetIdentities(pMgr, account, xmlDoc, userName, authMethod, true);
+        result = true;
+        if (ppAccount) account.forget(ppAccount);
+      }
+    }
+  } else if (NS_SUCCEEDED(rv) && in) {
+    // for the existing server...
+    nsCOMPtr<nsIMsgAccount> account;
+    rv = pMgr->FindAccountForServer(in, getter_AddRefs(account));
+    if (NS_SUCCEEDED(rv) && account) {
+      IMPORT_LOG0(
+          "Using existing account and set the "
+          "NNTP server as the incoming server\n");
+      // Fiddle with the identities
+      in->GetAuthMethod(&authMethod);
+      SetIdentities(pMgr, account, xmlDoc, userName, authMethod, true);
+      result = true;
+      if (ppAccount) account.forget(ppAccount);
+    }
+  } else
+    result = true;
+  return result;
+}
+
+void WMSettings::SetIdentities(nsIMsgAccountManager* pMgr, nsIMsgAccount* pAcc,
+                               mozilla::dom::Document* xmlDoc,
+                               nsAutoString& inUserName,
+                               int32_t authMethodIncoming, bool isNNTP) {
+  // Get the relevant information for an identity
+  nsAutoString value;
+
+  nsCOMPtr<nsIMsgIdentity> id;
+  pMgr->CreateIdentity(getter_AddRefs(id));
+  if (id) {
+    IMPORT_LOG0("Created identity and added to the account\n");
+    if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(
+            xmlDoc, isNNTP ? "NNTP_Display_Name" : "SMTP_Display_Name",
+            value))) {
+      id->SetFullName(value);
+      IMPORT_LOG1("\tname: %S\n", static_cast<const wchar_t*>(value.get()));
+    }
+
+    if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(
+            xmlDoc,
+            isNNTP ? "NNTP_Organization_Name" : "SMTP_Organization_Name",
+            value))) {
+      id->SetOrganization(value);
+    }
+
+    if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(
+            xmlDoc, isNNTP ? "NNTP_Email_Address" : "SMTP_Email_Address",
+            value))) {
+      id->SetEmail(NS_ConvertUTF16toUTF8(value));
+      IMPORT_LOG1("\temail: %S\n", static_cast<const wchar_t*>(value.get()));
+    }
+
+    if (NS_SUCCEEDED(
+            nsWMUtils::GetValueForTag(xmlDoc,
+                                      isNNTP ? "NNTP_Reply_To_Email_Address"
+                                             : "SMTP_Reply_To_Email_Address",
+                                      value))) {
+      id->SetReplyTo(NS_ConvertUTF16toUTF8(value));
+    }
+
+    // Windows users are used to top style quoting.
+    id->SetReplyOnTop(isNNTP ? 0 : 1);
+    pAcc->AddIdentity(id);
+  }
+
+  if (!isNNTP)  // NNTP does not use SMTP in OE or TB
+    SetSmtpServer(xmlDoc, id, inUserName, authMethodIncoming);
+}
+
+void WMSettings::SetSmtpServer(mozilla::dom::Document* xmlDoc,
+                               nsIMsgIdentity* id, nsAutoString& inUserName,
+                               int32_t authMethodIncoming) {
+  nsresult errorCode;
+
+  // set the id.smtpserver accordingly
+  if (!id) return;
+  nsCString smtpServerKey, userName;
+  nsAutoString value, smtpName;
+  if (NS_FAILED(nsWMUtils::GetValueForTag(xmlDoc, "SMTP_Server", smtpName)))
+    return;
+
+  // first we have to calculate the smtp user name which is based on sicily
+  // smtp user name depends on sicily which may or not exist
+  int32_t useSicily = 0;
+  if (NS_SUCCEEDED(
+          nsWMUtils::GetValueForTag(xmlDoc, "SMTP_Use_Sicily", value))) {
+    useSicily = (int32_t)value.ToInteger(&errorCode, 16);
+  }
+  switch (useSicily) {
+    case 1:
+    case 3:
+      if (NS_SUCCEEDED(
+              nsWMUtils::GetValueForTag(xmlDoc, "SMTP_User_Name", value))) {
+        CopyUTF16toUTF8(value, userName);
+      } else {
+        CopyUTF16toUTF8(inUserName, userName);
+      }
+      break;
+    case 2:
+      CopyUTF16toUTF8(inUserName, userName);
+      break;
+    default:
+      break;  // initial userName == ""
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsISmtpService> smtpService(
+      do_GetService("@mozilla.org/messengercompose/smtp;1", &rv));
+  if (NS_SUCCEEDED(rv) && smtpService) {
+    nsCOMPtr<nsISmtpServer> extgServer;
+    // don't try to make another server
+    // regardless if username doesn't match
+    rv = smtpService->FindServer(userName.get(),
+                                 NS_ConvertUTF16toUTF8(smtpName).get(),
+                                 getter_AddRefs(extgServer));
+    if (NS_SUCCEEDED(rv) && extgServer) {
+      // set our account keyed to this smptserver key
+      extgServer->GetKey(getter_Copies(smtpServerKey));
+      id->SetSmtpServerKey(smtpServerKey);
+
+      IMPORT_LOG1("SMTP server already exists: %s\n",
+                  NS_ConvertUTF16toUTF8(smtpName).get());
+    } else {
+      nsCOMPtr<nsISmtpServer> smtpServer;
+      rv = smtpService->CreateServer(getter_AddRefs(smtpServer));
+      if (NS_SUCCEEDED(rv) && smtpServer) {
+        if (NS_SUCCEEDED(
+                nsWMUtils::GetValueForTag(xmlDoc, "SMTP_Port", value))) {
+          smtpServer->SetPort(value.ToInteger(&errorCode, 16));
+        }
+
+        if (NS_SUCCEEDED(nsWMUtils::GetValueForTag(
+                xmlDoc, "SMTP_Secure_Connection", value))) {
+          if (value.ToInteger(&errorCode, 16) == 1)
+            smtpServer->SetSocketType(nsMsgSocketType::SSL);
+          else
+            smtpServer->SetSocketType(nsMsgSocketType::plain);
+        }
+        smtpServer->SetUsername(userName);
+        switch (useSicily) {
+          case 1:
+            smtpServer->SetAuthMethod(nsMsgAuthMethod::secure);
+            break;
+          case 2:  // requires SMTP authentication to use the incoming server
+                   // settings
+            smtpServer->SetAuthMethod(authMethodIncoming);
+            break;
+          case 3:
+            smtpServer->SetAuthMethod(nsMsgAuthMethod::passwordCleartext);
+            break;
+          default:
+            smtpServer->SetAuthMethod(nsMsgAuthMethod::none);
+        }
+
+        smtpServer->SetHostname(NS_ConvertUTF16toUTF8(smtpName));
+
+        smtpServer->GetKey(getter_Copies(smtpServerKey));
+        id->SetSmtpServerKey(smtpServerKey);
+
+        IMPORT_LOG1("Created new SMTP server: %s\n",
+                    NS_ConvertUTF16toUTF8(smtpName).get());
+      }
+    }
+  }
+}