diff options
Diffstat (limited to 'comm/mailnews/base/src/nsMsgAccountManager.cpp')
| -rw-r--r-- | comm/mailnews/base/src/nsMsgAccountManager.cpp | 3546 |
1 files changed, 3546 insertions, 0 deletions
diff --git a/comm/mailnews/base/src/nsMsgAccountManager.cpp b/comm/mailnews/base/src/nsMsgAccountManager.cpp new file mode 100644 index 0000000000..5352486cb4 --- /dev/null +++ b/comm/mailnews/base/src/nsMsgAccountManager.cpp @@ -0,0 +1,3546 @@ +/* -*- 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/. */ + +/** + * The account manager service - manages all accounts, servers, and identities + */ + +#include "nsCOMPtr.h" +#include "nsISupports.h" +#include "nsIThread.h" +#include "nscore.h" +#include "mozilla/Assertions.h" +#include "mozilla/Likely.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/RefCountType.h" +#include "mozilla/RefPtr.h" +#include "nsIComponentManager.h" +#include "nsIServiceManager.h" +#include "nsMsgAccountManager.h" +#include "prmem.h" +#include "prcmon.h" +#include "prthread.h" +#include "plstr.h" +#include "nsString.h" +#include "nsMemory.h" +#include "nsUnicharUtils.h" +#include "nscore.h" +#include "prprf.h" +#include "nsIMsgFolderCache.h" +#include "nsMsgFolderCache.h" +#include "nsMsgUtils.h" +#include "nsMsgDBFolder.h" +#include "nsIFile.h" +#include "nsIURL.h" +#include "nsNetCID.h" +#include "nsIPrefService.h" +#include "nsIPrefBranch.h" +#include "nsISmtpService.h" +#include "nsIMsgBiffManager.h" +#include "nsIMsgPurgeService.h" +#include "nsIObserverService.h" +#include "nsINoIncomingServer.h" +#include "nsIMsgMailSession.h" +#include "nsIDirectoryService.h" +#include "nsAppDirectoryServiceDefs.h" +#include "nsMailDirServiceDefs.h" +#include "nsMsgFolderFlags.h" +#include "nsIMsgFolderNotificationService.h" +#include "nsIImapIncomingServer.h" +#include "nsIImapUrl.h" +#include "nsICategoryManager.h" +#include "nsISupportsPrimitives.h" +#include "nsIMsgFilterService.h" +#include "nsIMsgFilter.h" +#include "nsIMsgSearchSession.h" +#include "nsIMsgSearchTerm.h" +#include "nsIDBFolderInfo.h" +#include "nsIMsgHdr.h" +#include "nsILineInputStream.h" +#include "nsThreadUtils.h" +#include "nsNetUtil.h" +#include "nsIStringBundle.h" +#include "nsMsgMessageFlags.h" +#include "nsIMsgFilterList.h" +#include "nsDirectoryServiceUtils.h" +#include "mozilla/Components.h" +#include "mozilla/Services.h" +#include "nsIFileStreams.h" +#include "nsIOutputStream.h" +#include "nsISafeOutputStream.h" +#include "nsXULAppAPI.h" +#include "nsICacheStorageService.h" +#include "UrlListener.h" +#include "nsIIDNService.h" + +#define PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS "mail.accountmanager.accounts" +#define PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT \ + "mail.accountmanager.defaultaccount" +#define PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER \ + "mail.accountmanager.localfoldersserver" +#define PREF_MAIL_SERVER_PREFIX "mail.server." +#define ACCOUNT_PREFIX "account" +#define SERVER_PREFIX "server" +#define ID_PREFIX "id" +#define ABOUT_TO_GO_OFFLINE_TOPIC "network:offline-about-to-go-offline" +#define ACCOUNT_DELIMITER ',' +#define APPEND_ACCOUNTS_VERSION_PREF_NAME "append_preconfig_accounts.version" +#define MAILNEWS_ROOT_PREF "mailnews." +#define PREF_MAIL_ACCOUNTMANAGER_APPEND_ACCOUNTS \ + "mail.accountmanager.appendaccounts" + +#define NS_MSGACCOUNT_CID \ + { \ + 0x68b25510, 0xe641, 0x11d2, { \ + 0xb7, 0xfc, 0x0, 0x80, 0x5f, 0x5, 0xff, 0xa5 \ + } \ + } +static NS_DEFINE_CID(kMsgAccountCID, NS_MSGACCOUNT_CID); + +#define SEARCH_FOLDER_FLAG "searchFolderFlag" +#define SEARCH_FOLDER_FLAG_LEN (sizeof(SEARCH_FOLDER_FLAG) - 1) + +const char* kSearchFolderUriProp = "searchFolderUri"; + +bool nsMsgAccountManager::m_haveShutdown = false; +bool nsMsgAccountManager::m_shutdownInProgress = false; + +NS_IMPL_ISUPPORTS(nsMsgAccountManager, nsIMsgAccountManager, nsIObserver, + nsISupportsWeakReference, nsIFolderListener) + +nsMsgAccountManager::nsMsgAccountManager() + : m_accountsLoaded(false), + m_emptyTrashInProgress(false), + m_cleanupInboxInProgress(false), + m_userAuthenticated(false), + m_loadingVirtualFolders(false), + m_virtualFoldersLoaded(false), + m_lastFindServerPort(0) {} + +nsMsgAccountManager::~nsMsgAccountManager() { + if (!m_haveShutdown) { + Shutdown(); + // Don't remove from Observer service in Shutdown because Shutdown also gets + // called from xpcom shutdown observer. And we don't want to remove from + // the service in that case. + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (observerService) { + observerService->RemoveObserver(this, "search-folders-changed"); + observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + observerService->RemoveObserver(this, "quit-application-granted"); + observerService->RemoveObserver(this, ABOUT_TO_GO_OFFLINE_TOPIC); + observerService->RemoveObserver(this, "sleep_notification"); + } + } +} + +nsresult nsMsgAccountManager::Init() { + if (!XRE_IsParentProcess()) { + return NS_ERROR_NOT_AVAILABLE; + } + + nsresult rv; + + m_prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (observerService) { + observerService->AddObserver(this, "search-folders-changed", true); + observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true); + observerService->AddObserver(this, "quit-application-granted", true); + observerService->AddObserver(this, ABOUT_TO_GO_OFFLINE_TOPIC, true); + observerService->AddObserver(this, "profile-before-change", true); + observerService->AddObserver(this, "sleep_notification", true); + } + + // Make sure PSM gets initialized before any accounts use certificates. + net_EnsurePSMInit(); + + return NS_OK; +} + +nsresult nsMsgAccountManager::Shutdown() { + if (m_haveShutdown) // do not shutdown twice + return NS_OK; + + nsresult rv; + + SaveVirtualFolders(); + + if (m_dbService) { + nsTObserverArray<RefPtr<VirtualFolderChangeListener>>::ForwardIterator iter( + m_virtualFolderListeners); + RefPtr<VirtualFolderChangeListener> listener; + + while (iter.HasMore()) { + listener = iter.GetNext(); + m_dbService->UnregisterPendingListener(listener); + } + + m_dbService = nullptr; + } + m_virtualFolders.Clear(); + if (m_msgFolderCache) WriteToFolderCache(m_msgFolderCache); + (void)ShutdownServers(); + (void)UnloadAccounts(); + + // shutdown removes nsIIncomingServer listener from biff manager, so do it + // after accounts have been unloaded + nsCOMPtr<nsIMsgBiffManager> biffService = + do_GetService("@mozilla.org/messenger/biffManager;1", &rv); + if (NS_SUCCEEDED(rv) && biffService) biffService->Shutdown(); + + // shutdown removes nsIIncomingServer listener from purge service, so do it + // after accounts have been unloaded + nsCOMPtr<nsIMsgPurgeService> purgeService = + do_GetService("@mozilla.org/messenger/purgeService;1", &rv); + if (NS_SUCCEEDED(rv) && purgeService) purgeService->Shutdown(); + + if (m_msgFolderCache) { + // The DTOR is meant to do the flushing, but observed behaviour is + // that it doesn't always get called. So flush explicitly. + m_msgFolderCache->Flush(); + m_msgFolderCache = nullptr; + } + + m_haveShutdown = true; + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetShutdownInProgress(bool* _retval) { + NS_ENSURE_ARG_POINTER(_retval); + *_retval = m_shutdownInProgress; + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetUserNeedsToAuthenticate(bool* aRetval) { + NS_ENSURE_ARG_POINTER(aRetval); + if (!m_userAuthenticated) + return m_prefs->GetBoolPref("mail.password_protect_local_cache", aRetval); + *aRetval = !m_userAuthenticated; + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::SetUserNeedsToAuthenticate(bool aUserNeedsToAuthenticate) { + m_userAuthenticated = !aUserNeedsToAuthenticate; + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* someData) { + if (!strcmp(aTopic, "search-folders-changed")) { + nsCOMPtr<nsIMsgFolder> virtualFolder = do_QueryInterface(aSubject); + nsCOMPtr<nsIMsgDatabase> db; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(db)); + nsCString srchFolderUris; + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, srchFolderUris); + AddVFListenersForVF(virtualFolder, srchFolderUris); + return NS_OK; + } + if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + Shutdown(); + return NS_OK; + } + if (!strcmp(aTopic, "quit-application-granted")) { + // CleanupOnExit will set m_shutdownInProgress to true. + CleanupOnExit(); + return NS_OK; + } + if (!strcmp(aTopic, ABOUT_TO_GO_OFFLINE_TOPIC)) { + nsAutoString dataString(u"offline"_ns); + if (someData) { + nsAutoString someDataString(someData); + if (dataString.Equals(someDataString)) CloseCachedConnections(); + } + return NS_OK; + } + if (!strcmp(aTopic, "sleep_notification")) return CloseCachedConnections(); + + if (!strcmp(aTopic, "profile-before-change")) { + Shutdown(); + return NS_OK; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetUniqueAccountKey(nsACString& aResult) { + int32_t lastKey = 0; + nsresult rv; + nsCOMPtr<nsIPrefService> prefservice( + do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr<nsIPrefBranch> prefBranch; + prefservice->GetBranch("", getter_AddRefs(prefBranch)); + + rv = prefBranch->GetIntPref("mail.account.lastKey", &lastKey); + if (NS_FAILED(rv) || lastKey == 0) { + // If lastKey pref does not contain a valid value, loop over existing + // pref names mail.account.* . + nsCOMPtr<nsIPrefBranch> prefBranchAccount; + rv = prefservice->GetBranch("mail.account.", + getter_AddRefs(prefBranchAccount)); + if (NS_SUCCEEDED(rv)) { + nsTArray<nsCString> prefList; + rv = prefBranchAccount->GetChildList("", prefList); + if (NS_SUCCEEDED(rv)) { + // Pref names are of the format accountX. + // Find the maximum value of 'X' used so far. + for (auto& prefName : prefList) { + if (StringBeginsWith(prefName, nsLiteralCString(ACCOUNT_PREFIX))) { + int32_t dotPos = prefName.FindChar('.'); + if (dotPos != kNotFound) { + nsCString keyString(Substring(prefName, strlen(ACCOUNT_PREFIX), + dotPos - strlen(ACCOUNT_PREFIX))); + int32_t thisKey = keyString.ToInteger(&rv); + if (NS_SUCCEEDED(rv)) lastKey = std::max(lastKey, thisKey); + } + } + } + } + } + } + + // Use next available key and store the value in the pref. + aResult.Assign(ACCOUNT_PREFIX); + aResult.AppendInt(++lastKey); + rv = prefBranch->SetIntPref("mail.account.lastKey", lastKey); + } else { + // If pref service is not working, try to find a free accountX key + // by checking which keys exist. + int32_t i = 1; + nsCOMPtr<nsIMsgAccount> account; + + do { + aResult = ACCOUNT_PREFIX; + aResult.AppendInt(i++); + GetAccount(aResult, getter_AddRefs(account)); + } while (account); + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetUniqueServerKey(nsACString& aResult) { + nsAutoCString prefResult; + bool usePrefsScan = true; + nsresult rv; + nsCOMPtr<nsIPrefService> prefService( + do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); + if (NS_FAILED(rv)) usePrefsScan = false; + + // Loop over existing pref names mail.server.server(lastKey).type + nsCOMPtr<nsIPrefBranch> prefBranchServer; + if (prefService) { + rv = prefService->GetBranch(PREF_MAIL_SERVER_PREFIX, + getter_AddRefs(prefBranchServer)); + if (NS_FAILED(rv)) usePrefsScan = false; + } + + if (usePrefsScan) { + nsAutoCString type; + nsAutoCString typeKey; + for (uint32_t lastKey = 1;; lastKey++) { + aResult.AssignLiteral(SERVER_PREFIX); + aResult.AppendInt(lastKey); + typeKey.Assign(aResult); + typeKey.AppendLiteral(".type"); + prefBranchServer->GetCharPref(typeKey.get(), type); + if (type.IsEmpty()) // a server slot with no type is considered empty + return NS_OK; + } + } else { + // If pref service fails, try to find a free serverX key + // by checking which keys exist. + nsAutoCString internalResult; + nsCOMPtr<nsIMsgIncomingServer> server; + uint32_t i = 1; + do { + aResult.AssignLiteral(SERVER_PREFIX); + aResult.AppendInt(i++); + m_incomingServers.Get(aResult, getter_AddRefs(server)); + } while (server); + return NS_OK; + } +} + +nsresult nsMsgAccountManager::CreateIdentity(nsIMsgIdentity** _retval) { + NS_ENSURE_ARG_POINTER(_retval); + nsresult rv; + nsAutoCString key; + nsCOMPtr<nsIMsgIdentity> identity; + int32_t i = 1; + do { + key.AssignLiteral(ID_PREFIX); + key.AppendInt(i++); + m_identities.Get(key, getter_AddRefs(identity)); + } while (identity); + + rv = createKeyedIdentity(key, _retval); + return rv; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetIdentity(const nsACString& key, + nsIMsgIdentity** _retval) { + NS_ENSURE_ARG_POINTER(_retval); + nsresult rv = NS_OK; + *_retval = nullptr; + + if (!key.IsEmpty()) { + nsCOMPtr<nsIMsgIdentity> identity; + m_identities.Get(key, getter_AddRefs(identity)); + if (identity) + identity.forget(_retval); + else // identity doesn't exist. create it. + rv = createKeyedIdentity(key, _retval); + } + + return rv; +} + +/* + * the shared identity-creation code + * create an identity and add it to the accountmanager's list. + */ +nsresult nsMsgAccountManager::createKeyedIdentity(const nsACString& key, + nsIMsgIdentity** aIdentity) { + nsresult rv; + nsCOMPtr<nsIMsgIdentity> identity = + do_CreateInstance("@mozilla.org/messenger/identity;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + identity->SetKey(key); + m_identities.InsertOrUpdate(key, identity); + identity.forget(aIdentity); + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::CreateIncomingServer(const nsACString& username, + const nsACString& hostname, + const nsACString& type, + nsIMsgIncomingServer** _retval) { + NS_ENSURE_ARG_POINTER(_retval); + + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString key; + GetUniqueServerKey(key); + rv = createKeyedServer(key, username, hostname, type, _retval); + if (*_retval) { + nsCString defaultStore; + m_prefs->GetCharPref("mail.serverDefaultStoreContractID", defaultStore); + (*_retval)->SetCharValue("storeContractID", defaultStore); + + // From when we first create the account until we have created some folders, + // we can change the store type. + (*_retval)->SetBoolValue("canChangeStoreType", true); + } + return rv; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetIncomingServer(const nsACString& key, + nsIMsgIncomingServer** _retval) { + NS_ENSURE_ARG_POINTER(_retval); + nsresult rv; + + if (m_incomingServers.Get(key, _retval)) return NS_OK; + + // server doesn't exist, so create it + // this is really horrible because we are doing our own prefname munging + // instead of leaving it up to the incoming server. + // this should be fixed somehow so that we can create the incoming server + // and then read from the incoming server's attributes + + // in order to create the right kind of server, we have to look + // at the pref for this server to get the username, hostname, and type + nsAutoCString serverPrefPrefix(PREF_MAIL_SERVER_PREFIX); + serverPrefPrefix.Append(key); + + nsCString serverType; + nsAutoCString serverPref(serverPrefPrefix); + serverPref.AppendLiteral(".type"); + rv = m_prefs->GetCharPref(serverPref.get(), serverType); + NS_ENSURE_SUCCESS(rv, NS_ERROR_NOT_INITIALIZED); + + // + // .userName + serverPref = serverPrefPrefix; + serverPref.AppendLiteral(".userName"); + nsCString username; + rv = m_prefs->GetCharPref(serverPref.get(), username); + + // .hostname + serverPref = serverPrefPrefix; + serverPref.AppendLiteral(".hostname"); + nsCString hostname; + rv = m_prefs->GetCharPref(serverPref.get(), hostname); + NS_ENSURE_SUCCESS(rv, NS_ERROR_NOT_INITIALIZED); + + return createKeyedServer(key, username, hostname, serverType, _retval); +} + +NS_IMETHODIMP +nsMsgAccountManager::RemoveIncomingServer(nsIMsgIncomingServer* aServer, + bool aRemoveFiles) { + NS_ENSURE_ARG_POINTER(aServer); + + nsCString serverKey; + nsresult rv = aServer->GetKey(serverKey); + NS_ENSURE_SUCCESS(rv, rv); + + // close cached connections and forget session password + LogoutOfServer(aServer); + + // invalidate the FindServer() cache if we are removing the cached server + if (m_lastFindServerResult == aServer) + SetLastServerFound(nullptr, EmptyCString(), EmptyCString(), 0, + EmptyCString()); + + m_incomingServers.Remove(serverKey); + + nsCOMPtr<nsIMsgFolder> rootFolder; + rv = aServer->GetRootFolder(getter_AddRefs(rootFolder)); + NS_ENSURE_SUCCESS(rv, rv); + + nsTArray<RefPtr<nsIMsgFolder>> allDescendants; + rv = rootFolder->GetDescendants(allDescendants); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIMsgFolderNotificationService> notifier = + do_GetService("@mozilla.org/messenger/msgnotificationservice;1"); + nsCOMPtr<nsIFolderListener> mailSession = + do_GetService("@mozilla.org/messenger/services/session;1"); + + for (auto folder : allDescendants) { + folder->ForceDBClosed(); + if (notifier) notifier->NotifyFolderDeleted(folder); + if (mailSession) { + nsCOMPtr<nsIMsgFolder> parentFolder; + folder->GetParent(getter_AddRefs(parentFolder)); + mailSession->OnFolderRemoved(parentFolder, folder); + } + } + if (notifier) notifier->NotifyFolderDeleted(rootFolder); + if (mailSession) mailSession->OnFolderRemoved(nullptr, rootFolder); + + removeListenersFromFolder(rootFolder); + NotifyServerUnloaded(aServer); + if (aRemoveFiles) { + rv = aServer->RemoveFiles(); + NS_ENSURE_SUCCESS(rv, rv); + } + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + obs->NotifyObservers(aServer, "message-server-removed", + NS_ConvertUTF8toUTF16(serverKey).get()); + } + + // now clear out the server once and for all. + // watch out! could be scary + aServer->ClearAllValues(); + rootFolder->Shutdown(true); + return rv; +} + +/* + * create a server when you know the key and the type + */ +nsresult nsMsgAccountManager::createKeyedServer( + const nsACString& key, const nsACString& username, + const nsACString& hostname, const nsACString& type, + nsIMsgIncomingServer** aServer) { + nsresult rv; + *aServer = nullptr; + + // construct the contractid + nsAutoCString serverContractID("@mozilla.org/messenger/server;1?type="); + serverContractID += type; + + // finally, create the server + // (This will fail if type is from an extension that has been removed) + nsCOMPtr<nsIMsgIncomingServer> server = + do_CreateInstance(serverContractID.get(), &rv); + NS_ENSURE_SUCCESS(rv, NS_ERROR_NOT_AVAILABLE); + + int32_t port; + nsCOMPtr<nsIMsgIncomingServer> existingServer; + server->SetKey(key); + server->SetType(type); + server->SetUsername(username); + server->SetHostName(hostname); + server->GetPort(&port); + FindServer(username, hostname, type, port, getter_AddRefs(existingServer)); + // don't allow duplicate servers. + if (existingServer) return NS_ERROR_FAILURE; + + m_incomingServers.InsertOrUpdate(key, server); + + // now add all listeners that are supposed to be + // waiting on root folders + nsCOMPtr<nsIMsgFolder> rootFolder; + rv = server->GetRootFolder(getter_AddRefs(rootFolder)); + NS_ENSURE_SUCCESS(rv, rv); + + nsTObserverArray<nsCOMPtr<nsIFolderListener>>::ForwardIterator iter( + mFolderListeners); + while (iter.HasMore()) { + rootFolder->AddFolderListener(iter.GetNext()); + } + + server.forget(aServer); + return NS_OK; +} + +void nsMsgAccountManager::removeListenersFromFolder(nsIMsgFolder* aFolder) { + nsTObserverArray<nsCOMPtr<nsIFolderListener>>::ForwardIterator iter( + mFolderListeners); + while (iter.HasMore()) { + aFolder->RemoveFolderListener(iter.GetNext()); + } +} + +NS_IMETHODIMP +nsMsgAccountManager::RemoveAccount(nsIMsgAccount* aAccount, + bool aRemoveFiles = false) { + NS_ENSURE_ARG_POINTER(aAccount); + // Hold account in scope while we tidy up potentially-shared identities. + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + if (!m_accounts.RemoveElement(aAccount)) { + return NS_ERROR_INVALID_ARG; + } + + rv = OutputAccountsPref(); + // If we couldn't write out the pref, restore the account. + if (NS_FAILED(rv)) { + m_accounts.AppendElement(aAccount); + return rv; + } + + // If it's the default, choose a new default account. + if (m_defaultAccount == aAccount) AutosetDefaultAccount(); + + // XXX - need to figure out if this is the last time this server is + // being used, and only send notification then. + // (and only remove from hashtable then too!) + nsCOMPtr<nsIMsgIncomingServer> server; + rv = aAccount->GetIncomingServer(getter_AddRefs(server)); + if (NS_SUCCEEDED(rv) && server) RemoveIncomingServer(server, aRemoveFiles); + + nsTArray<RefPtr<nsIMsgIdentity>> identities; + rv = aAccount->GetIdentities(identities); + if (NS_SUCCEEDED(rv)) { + for (auto identity : identities) { + bool identityStillUsed = false; + // for each identity, see if any remaining account still uses it, + // and if not, clear it. + // Note that we are also searching here accounts with missing servers from + // unloaded extension types. + for (auto account : m_accounts) { + nsTArray<RefPtr<nsIMsgIdentity>> existingIdentities; + account->GetIdentities(existingIdentities); + auto pos = existingIdentities.IndexOf(identity); + if (pos != existingIdentities.NoIndex) { + identityStillUsed = true; + break; + } + } + // clear out all identity information if no other account uses it. + if (!identityStillUsed) identity->ClearAllValues(); + } + } + + nsCString accountKey; + aAccount->GetKey(accountKey); + + // It is not a critical problem if this fails as the account was already + // removed from the list of accounts so should not ever be referenced. + // Just print it out for debugging. + rv = aAccount->ClearAllValues(); + NS_ASSERTION(NS_SUCCEEDED(rv), "removing of account prefs failed"); + + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + obs->NotifyObservers(nullptr, "message-account-removed", + NS_ConvertUTF8toUTF16(accountKey).get()); + } + return NS_OK; +} + +nsresult nsMsgAccountManager::OutputAccountsPref() { + nsCString accountKey; + mAccountKeyList.Truncate(); + + for (uint32_t index = 0; index < m_accounts.Length(); index++) { + m_accounts[index]->GetKey(accountKey); + if (index) mAccountKeyList.Append(ACCOUNT_DELIMITER); + mAccountKeyList.Append(accountKey); + } + return m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS, + mAccountKeyList); +} + +/** + * Get the default account. If no default account, return null. + */ +NS_IMETHODIMP +nsMsgAccountManager::GetDefaultAccount(nsIMsgAccount** aDefaultAccount) { + NS_ENSURE_ARG_POINTER(aDefaultAccount); + + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + if (!m_defaultAccount) { + nsCString defaultKey; + rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT, + defaultKey); + if (NS_SUCCEEDED(rv)) { + rv = GetAccount(defaultKey, getter_AddRefs(m_defaultAccount)); + if (NS_SUCCEEDED(rv) && m_defaultAccount) { + bool canBeDefault = false; + rv = CheckDefaultAccount(m_defaultAccount, canBeDefault); + if (NS_FAILED(rv) || !canBeDefault) m_defaultAccount = nullptr; + } + } + } + + NS_IF_ADDREF(*aDefaultAccount = m_defaultAccount); + return NS_OK; +} + +/** + * Check if the given account can be default. + */ +nsresult nsMsgAccountManager::CheckDefaultAccount(nsIMsgAccount* aAccount, + bool& aCanBeDefault) { + aCanBeDefault = false; + nsCOMPtr<nsIMsgIncomingServer> server; + // Server could be null if created by an unloaded extension. + nsresult rv = aAccount->GetIncomingServer(getter_AddRefs(server)); + NS_ENSURE_SUCCESS(rv, rv); + if (server) { + // Check if server can be default. + rv = server->GetCanBeDefaultServer(&aCanBeDefault); + } + return rv; +} + +/** + * Pick the first account that can be default and make it the default. + */ +nsresult nsMsgAccountManager::AutosetDefaultAccount() { + for (nsIMsgAccount* account : m_accounts) { + bool canBeDefault = false; + nsresult rv = CheckDefaultAccount(account, canBeDefault); + if (NS_SUCCEEDED(rv) && canBeDefault) { + return SetDefaultAccount(account); + } + } + + // No accounts can be the default. Clear it. + if (m_defaultAccount) { + nsCOMPtr<nsIMsgAccount> oldAccount = m_defaultAccount; + m_defaultAccount = nullptr; + (void)setDefaultAccountPref(nullptr); + (void)notifyDefaultServerChange(oldAccount, nullptr); + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::SetDefaultAccount(nsIMsgAccount* aDefaultAccount) { + if (!aDefaultAccount) return NS_ERROR_INVALID_ARG; + + if (m_defaultAccount != aDefaultAccount) { + bool canBeDefault = false; + nsresult rv = CheckDefaultAccount(aDefaultAccount, canBeDefault); + if (NS_FAILED(rv) || !canBeDefault) { + // Report failure if we were explicitly asked to use an unusable server. + return NS_ERROR_INVALID_ARG; + } + nsCOMPtr<nsIMsgAccount> oldAccount = m_defaultAccount; + m_defaultAccount = aDefaultAccount; + (void)setDefaultAccountPref(aDefaultAccount); + (void)notifyDefaultServerChange(oldAccount, aDefaultAccount); + } + return NS_OK; +} + +// fire notifications +nsresult nsMsgAccountManager::notifyDefaultServerChange( + nsIMsgAccount* aOldAccount, nsIMsgAccount* aNewAccount) { + nsresult rv; + + nsCOMPtr<nsIMsgIncomingServer> server; + nsCOMPtr<nsIMsgFolder> rootFolder; + + // first tell old server it's no longer the default + if (aOldAccount) { + rv = aOldAccount->GetIncomingServer(getter_AddRefs(server)); + if (NS_SUCCEEDED(rv) && server) { + rv = server->GetRootFolder(getter_AddRefs(rootFolder)); + if (NS_SUCCEEDED(rv) && rootFolder) + rootFolder->NotifyBoolPropertyChanged(kDefaultServer, true, false); + } + } + + // now tell new server it is. + if (aNewAccount) { + rv = aNewAccount->GetIncomingServer(getter_AddRefs(server)); + if (NS_SUCCEEDED(rv) && server) { + rv = server->GetRootFolder(getter_AddRefs(rootFolder)); + if (NS_SUCCEEDED(rv) && rootFolder) + rootFolder->NotifyBoolPropertyChanged(kDefaultServer, false, true); + } + } + + // only notify if the user goes and changes default account + if (aOldAccount && aNewAccount) { + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + + if (observerService) + observerService->NotifyObservers(nullptr, "mailDefaultAccountChanged", + nullptr); + } + + return NS_OK; +} + +nsresult nsMsgAccountManager::setDefaultAccountPref( + nsIMsgAccount* aDefaultAccount) { + nsresult rv; + + if (aDefaultAccount) { + nsCString key; + rv = aDefaultAccount->GetKey(key); + NS_ENSURE_SUCCESS(rv, rv); + + rv = m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT, key); + NS_ENSURE_SUCCESS(rv, rv); + } else + m_prefs->ClearUserPref(PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT); + + return NS_OK; +} + +void nsMsgAccountManager::LogoutOfServer(nsIMsgIncomingServer* aServer) { + if (!aServer) return; + mozilla::DebugOnly<nsresult> rv = aServer->Shutdown(); + NS_ASSERTION(NS_SUCCEEDED(rv), "Shutdown of server failed"); + rv = aServer->ForgetSessionPassword(false); + NS_ASSERTION(NS_SUCCEEDED(rv), + "failed to remove the password associated with server"); +} + +NS_IMETHODIMP nsMsgAccountManager::GetFolderCache( + nsIMsgFolderCache** aFolderCache) { + NS_ENSURE_ARG_POINTER(aFolderCache); + + if (m_msgFolderCache) { + NS_IF_ADDREF(*aFolderCache = m_msgFolderCache); + return NS_OK; + } + + // Create the foldercache. + nsCOMPtr<nsIFile> cacheFile; + nsresult rv = NS_GetSpecialDirectory(NS_APP_MESSENGER_FOLDER_CACHE_50_FILE, + getter_AddRefs(cacheFile)); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsIFile> legacyFile; + rv = NS_GetSpecialDirectory(NS_APP_MESSENGER_LEGACY_FOLDER_CACHE_50_FILE, + getter_AddRefs(legacyFile)); + NS_ENSURE_SUCCESS(rv, rv); + m_msgFolderCache = new nsMsgFolderCache(); + m_msgFolderCache->Init(cacheFile, legacyFile); + NS_IF_ADDREF(*aFolderCache = m_msgFolderCache); + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetAccounts(nsTArray<RefPtr<nsIMsgAccount>>& accounts) { + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + accounts.Clear(); + accounts.SetCapacity(m_accounts.Length()); + for (auto existingAccount : m_accounts) { + nsCOMPtr<nsIMsgIncomingServer> server; + existingAccount->GetIncomingServer(getter_AddRefs(server)); + if (!server) continue; + if (server) { + bool hidden = false; + server->GetHidden(&hidden); + if (hidden) continue; + } + accounts.AppendElement(existingAccount); + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetAllIdentities( + nsTArray<RefPtr<nsIMsgIdentity>>& result) { + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + result.Clear(); + + for (auto account : m_accounts) { + nsTArray<RefPtr<nsIMsgIdentity>> identities; + rv = account->GetIdentities(identities); + if (NS_FAILED(rv)) continue; + + for (auto identity : identities) { + // Have we already got this identity? + nsAutoCString key; + rv = identity->GetKey(key); + if (NS_FAILED(rv)) continue; + + bool found = false; + for (auto thisIdentity : result) { + nsAutoCString thisKey; + rv = thisIdentity->GetKey(thisKey); + if (NS_FAILED(rv)) continue; + + if (key == thisKey) { + found = true; + break; + } + } + + if (!found) result.AppendElement(identity); + } + } + return rv; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetAllServers( + nsTArray<RefPtr<nsIMsgIncomingServer>>& servers) { + servers.Clear(); + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + if (!server) continue; + + bool hidden = false; + server->GetHidden(&hidden); + if (hidden) continue; + + nsCString type; + if (NS_FAILED(server->GetType(type))) { + NS_WARNING("server->GetType() failed"); + continue; + } + + if (!type.EqualsLiteral("im")) { + servers.AppendElement(server); + } + } + return NS_OK; +} + +nsresult nsMsgAccountManager::LoadAccounts() { + nsresult rv; + + // for now safeguard multiple calls to this function + if (m_accountsLoaded) return NS_OK; + + // If we have code trying to do things after we've unloaded accounts, + // ignore it. + if (m_shutdownInProgress || m_haveShutdown) return NS_ERROR_FAILURE; + + // Make sure correct modules are loaded before creating any server. + nsCOMPtr<nsIObserver> moduleLoader; + moduleLoader = + do_GetService("@mozilla.org/messenger/imap-module-loader;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIMsgMailSession> mailSession = + do_GetService("@mozilla.org/messenger/services/session;1", &rv); + + if (NS_SUCCEEDED(rv)) + mailSession->AddFolderListener( + this, nsIFolderListener::added | nsIFolderListener::removed | + nsIFolderListener::intPropertyChanged); + + // Ensure biff service has started + nsCOMPtr<nsIMsgBiffManager> biffService = + do_GetService("@mozilla.org/messenger/biffManager;1", &rv); + + if (NS_SUCCEEDED(rv)) biffService->Init(); + + // Ensure purge service has started + nsCOMPtr<nsIMsgPurgeService> purgeService = + do_GetService("@mozilla.org/messenger/purgeService;1", &rv); + + if (NS_SUCCEEDED(rv)) purgeService->Init(); + + nsCOMPtr<nsIPrefService> prefservice( + do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + // mail.accountmanager.accounts is the main entry point for all accounts + nsCString accountList; + rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS, accountList); + + /** + * Check to see if we need to add pre-configured accounts. + * Following prefs are important to note in understanding the procedure here. + * + * 1. pref("mailnews.append_preconfig_accounts.version", version number); + * This pref registers the current version in the user prefs file. A default + * value is stored in mailnews.js file. If a given vendor needs to add more + * preconfigured accounts, the default version number can be increased. + * Comparing version number from user's prefs file and the default one from + * mailnews.js, we can add new accounts and any other version level changes + * that need to be done. + * + * 2. pref("mail.accountmanager.appendaccounts", <comma sep. account list>); + * This pref contains the list of pre-configured accounts that ISP/Vendor + * wants to add to the existing accounts list. + */ + nsCOMPtr<nsIPrefBranch> defaultsPrefBranch; + rv = prefservice->GetDefaultBranch(MAILNEWS_ROOT_PREF, + getter_AddRefs(defaultsPrefBranch)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIPrefBranch> prefBranch; + rv = prefservice->GetBranch(MAILNEWS_ROOT_PREF, getter_AddRefs(prefBranch)); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t appendAccountsCurrentVersion = 0; + int32_t appendAccountsDefaultVersion = 0; + rv = prefBranch->GetIntPref(APPEND_ACCOUNTS_VERSION_PREF_NAME, + &appendAccountsCurrentVersion); + NS_ENSURE_SUCCESS(rv, rv); + + rv = defaultsPrefBranch->GetIntPref(APPEND_ACCOUNTS_VERSION_PREF_NAME, + &appendAccountsDefaultVersion); + NS_ENSURE_SUCCESS(rv, rv); + + // Update the account list if needed + if ((appendAccountsCurrentVersion <= appendAccountsDefaultVersion)) { + // Get a list of pre-configured accounts + nsCString appendAccountList; + rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_APPEND_ACCOUNTS, + appendAccountList); + appendAccountList.StripWhitespace(); + + // If there are pre-configured accounts, we need to add them to the + // existing list. + if (!appendAccountList.IsEmpty()) { + if (!accountList.IsEmpty()) { + // Tokenize the data and add each account + // in the user's current mailnews account list + nsTArray<nsCString> accountsArray; + ParseString(accountList, ACCOUNT_DELIMITER, accountsArray); + uint32_t i = accountsArray.Length(); + + // Append each account in the pre-configured account list + ParseString(appendAccountList, ACCOUNT_DELIMITER, accountsArray); + + // Now add each account that does not already appear in the list + for (; i < accountsArray.Length(); i++) { + if (accountsArray.IndexOf(accountsArray[i]) == i) { + accountList.Append(ACCOUNT_DELIMITER); + accountList.Append(accountsArray[i]); + } + } + } else { + accountList = appendAccountList; + } + // Increase the version number so that updates will happen as and when + // needed + rv = prefBranch->SetIntPref(APPEND_ACCOUNTS_VERSION_PREF_NAME, + appendAccountsCurrentVersion + 1); + } + } + + // It is ok to return null accounts like when we create new profile. + m_accountsLoaded = true; + m_haveShutdown = false; + + if (accountList.IsEmpty()) return NS_OK; + + /* parse accountList and run loadAccount on each string, comma-separated */ + nsCOMPtr<nsIMsgAccount> account; + // Tokenize the data and add each account + // in the user's current mailnews account list + nsTArray<nsCString> accountsArray; + ParseString(accountList, ACCOUNT_DELIMITER, accountsArray); + + // These are the duplicate accounts we found. We keep track of these + // because if any other server defers to one of these accounts, we need + // to defer to the correct account. + nsCOMArray<nsIMsgAccount> dupAccounts; + + // Now add each account that does not already appear in the list + for (uint32_t i = 0; i < accountsArray.Length(); i++) { + // if we've already seen this exact account, advance to the next account. + // After the loop, we'll notice that we don't have as many actual accounts + // as there were accounts in the pref, and rewrite the pref. + if (accountsArray.IndexOf(accountsArray[i]) != i) continue; + + // get the "server" pref to see if we already have an account with this + // server. If we do, we ignore this account. + nsAutoCString serverKeyPref("mail.account."); + serverKeyPref += accountsArray[i]; + + nsCOMPtr<nsIPrefBranch> accountPrefBranch; + rv = prefservice->GetBranch(serverKeyPref.get(), + getter_AddRefs(accountPrefBranch)); + NS_ENSURE_SUCCESS(rv, rv); + + serverKeyPref += ".server"; + nsCString serverKey; + rv = m_prefs->GetCharPref(serverKeyPref.get(), serverKey); + if (NS_FAILED(rv)) continue; + + nsCOMPtr<nsIMsgAccount> serverAccount; + findAccountByServerKey(serverKey, getter_AddRefs(serverAccount)); + // If we have an existing account with the same server, ignore this account + if (serverAccount) continue; + + if (NS_FAILED(createKeyedAccount(accountsArray[i], true, + getter_AddRefs(account))) || + !account) { + NS_WARNING("unexpected entry in account list; prefs corrupt?"); + continue; + } + + // See nsIMsgAccount.idl for a description of the secondsToLeaveUnavailable + // and timeFoundUnavailable preferences + nsAutoCString toLeavePref(PREF_MAIL_SERVER_PREFIX); + toLeavePref.Append(serverKey); + nsAutoCString unavailablePref( + toLeavePref); // this is the server-specific prefix + unavailablePref.AppendLiteral(".timeFoundUnavailable"); + toLeavePref.AppendLiteral(".secondsToLeaveUnavailable"); + int32_t secondsToLeave = 0; + int32_t timeUnavailable = 0; + + m_prefs->GetIntPref(toLeavePref.get(), &secondsToLeave); + + // force load of accounts (need to find a better way to do this) + nsTArray<RefPtr<nsIMsgIdentity>> unused; + account->GetIdentities(unused); + + rv = account->CreateServer(); + bool deleteAccount = NS_FAILED(rv); + + if (secondsToLeave) { // we need to process timeUnavailable + if (NS_SUCCEEDED(rv)) // clear the time if server is available + { + m_prefs->ClearUserPref(unavailablePref.get()); + } + // NS_ERROR_NOT_AVAILABLE signifies a server that could not be + // instantiated, presumably because of an invalid type. + else if (rv == NS_ERROR_NOT_AVAILABLE) { + m_prefs->GetIntPref(unavailablePref.get(), &timeUnavailable); + if (!timeUnavailable) { // we need to set it, this must be the first + // time unavailable + uint32_t nowSeconds; + PRTime2Seconds(PR_Now(), &nowSeconds); + m_prefs->SetIntPref(unavailablePref.get(), nowSeconds); + deleteAccount = false; + } + } + } + + // Our server is still unavailable. Have we timed out yet? + if (rv == NS_ERROR_NOT_AVAILABLE && timeUnavailable != 0) { + uint32_t nowSeconds; + PRTime2Seconds(PR_Now(), &nowSeconds); + if ((int32_t)nowSeconds < timeUnavailable + secondsToLeave) + deleteAccount = false; + } + + if (deleteAccount) { + dupAccounts.AppendObject(account); + m_accounts.RemoveElement(account); + } + } + + // Check if we removed one or more of the accounts in the pref string. + // If so, rewrite the pref string. + if (accountsArray.Length() != m_accounts.Length()) OutputAccountsPref(); + + int32_t cnt = dupAccounts.Count(); + nsCOMPtr<nsIMsgAccount> dupAccount; + + // Go through the accounts seeing if any existing server is deferred to + // an account we removed. If so, fix the deferral. Then clean up the prefs + // for the removed account. + for (int32_t i = 0; i < cnt; i++) { + dupAccount = dupAccounts[i]; + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + /* + * This loop gets run for every incoming server, and is passed a + * duplicate account. It checks that the server is not deferred to the + * duplicate account. If it is, then it looks up the information for the + * duplicate account's server (username, hostName, type), and finds an + * account with a server with the same username, hostname, and type, and + * if it finds one, defers to that account instead. Generally, this will + * be a Local Folders account, since 2.0 has a bug where duplicate Local + * Folders accounts are created. + */ + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + nsCString type; + server->GetType(type); + if (type.EqualsLiteral("pop3")) { + nsCString deferredToAccount; + // Get the pref directly, because the GetDeferredToAccount accessor + // attempts to fix broken deferrals, but we know more about what the + // deferred to account was. + server->GetCharValue("deferred_to_account", deferredToAccount); + if (!deferredToAccount.IsEmpty()) { + nsCString dupAccountKey; + dupAccount->GetKey(dupAccountKey); + if (deferredToAccount.Equals(dupAccountKey)) { + nsresult rv; + nsCString accountPref("mail.account."); + nsCString dupAccountServerKey; + accountPref.Append(dupAccountKey); + accountPref.AppendLiteral(".server"); + nsCOMPtr<nsIPrefService> prefservice( + do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); + if (NS_FAILED(rv)) { + continue; + } + nsCOMPtr<nsIPrefBranch> prefBranch( + do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); + if (NS_FAILED(rv)) { + continue; + } + rv = + prefBranch->GetCharPref(accountPref.get(), dupAccountServerKey); + if (NS_FAILED(rv)) { + continue; + } + nsCOMPtr<nsIPrefBranch> serverPrefBranch; + nsCString serverKeyPref(PREF_MAIL_SERVER_PREFIX); + serverKeyPref.Append(dupAccountServerKey); + serverKeyPref.Append('.'); + rv = prefservice->GetBranch(serverKeyPref.get(), + getter_AddRefs(serverPrefBranch)); + if (NS_FAILED(rv)) { + continue; + } + nsCString userName; + nsCString hostName; + nsCString type; + serverPrefBranch->GetCharPref("userName", userName); + serverPrefBranch->GetCharPref("hostname", hostName); + serverPrefBranch->GetCharPref("type", type); + // Find a server with the same info. + nsCOMPtr<nsIMsgAccountManager> accountManager = + do_GetService("@mozilla.org/messenger/account-manager;1", &rv); + if (NS_FAILED(rv)) { + continue; + } + nsCOMPtr<nsIMsgIncomingServer> server; + accountManager->FindServer(userName, hostName, type, 0, + getter_AddRefs(server)); + if (server) { + nsCOMPtr<nsIMsgAccount> replacement; + accountManager->FindAccountForServer(server, + getter_AddRefs(replacement)); + if (replacement) { + nsCString accountKey; + replacement->GetKey(accountKey); + if (!accountKey.IsEmpty()) + server->SetCharValue("deferred_to_account", accountKey); + } + } + } + } + } + } + + nsAutoCString accountKeyPref("mail.account."); + nsCString dupAccountKey; + dupAccount->GetKey(dupAccountKey); + if (dupAccountKey.IsEmpty()) continue; + accountKeyPref.Append(dupAccountKey); + accountKeyPref.Append('.'); + + nsCOMPtr<nsIPrefBranch> accountPrefBranch; + rv = prefservice->GetBranch(accountKeyPref.get(), + getter_AddRefs(accountPrefBranch)); + if (accountPrefBranch) { + nsTArray<nsCString> prefNames; + nsresult rv = accountPrefBranch->GetChildList("", prefNames); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto& prefName : prefNames) { + accountPrefBranch->ClearUserPref(prefName.get()); + } + } + } + + // Make sure we have an account that points at the local folders server + nsCString localFoldersServerKey; + rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER, + localFoldersServerKey); + + if (!localFoldersServerKey.IsEmpty()) { + nsCOMPtr<nsIMsgIncomingServer> server; + rv = GetIncomingServer(localFoldersServerKey, getter_AddRefs(server)); + if (server) { + nsCOMPtr<nsIMsgAccount> localFoldersAccount; + findAccountByServerKey(localFoldersServerKey, + getter_AddRefs(localFoldersAccount)); + // If we don't have an existing account pointing at the local folders + // server, we're going to add one. + if (!localFoldersAccount) { + nsCOMPtr<nsIMsgAccount> account; + (void)CreateAccount(getter_AddRefs(account)); + if (account) account->SetIncomingServer(server); + } + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::ReactivateAccounts() { + for (nsIMsgAccount* account : m_accounts) { + // This will error out if the account already has its server, or + // if this isn't the account that the extension is trying to reactivate. + if (NS_SUCCEEDED(account->CreateServer())) { + nsCOMPtr<nsIMsgIncomingServer> server; + account->GetIncomingServer(getter_AddRefs(server)); + // This triggers all of the notifications required by the UI. + account->SetIncomingServer(server); + } + } + return NS_OK; +} + +// this routine goes through all the identities and makes sure +// that the special folders for each identity have the +// correct special folder flags set, e.g, the Sent folder has +// the sent flag set. +// +// it also goes through all the spam settings for each account +// and makes sure the folder flags are set there, too +NS_IMETHODIMP +nsMsgAccountManager::SetSpecialFolders() { + nsTArray<RefPtr<nsIMsgIdentity>> identities; + GetAllIdentities(identities); + + for (auto identity : identities) { + nsresult rv; + nsCString folderUri; + nsCOMPtr<nsIMsgFolder> folder; + + identity->GetFccFolder(folderUri); + if (!folderUri.IsEmpty() && + NS_SUCCEEDED(GetOrCreateFolder(folderUri, getter_AddRefs(folder)))) { + nsCOMPtr<nsIMsgFolder> parent; + rv = folder->GetParent(getter_AddRefs(parent)); + if (NS_SUCCEEDED(rv) && parent) { + rv = folder->SetFlag(nsMsgFolderFlags::SentMail); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + identity->GetDraftFolder(folderUri); + if (!folderUri.IsEmpty() && + NS_SUCCEEDED(GetOrCreateFolder(folderUri, getter_AddRefs(folder)))) { + nsCOMPtr<nsIMsgFolder> parent; + rv = folder->GetParent(getter_AddRefs(parent)); + if (NS_SUCCEEDED(rv) && parent) { + rv = folder->SetFlag(nsMsgFolderFlags::Drafts); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + identity->GetArchiveFolder(folderUri); + if (!folderUri.IsEmpty() && + NS_SUCCEEDED(GetOrCreateFolder(folderUri, getter_AddRefs(folder)))) { + nsCOMPtr<nsIMsgFolder> parent; + rv = folder->GetParent(getter_AddRefs(parent)); + if (NS_SUCCEEDED(rv) && parent) { + bool archiveEnabled; + identity->GetArchiveEnabled(&archiveEnabled); + if (archiveEnabled) + rv = folder->SetFlag(nsMsgFolderFlags::Archive); + else + rv = folder->ClearFlag(nsMsgFolderFlags::Archive); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + identity->GetStationeryFolder(folderUri); + if (!folderUri.IsEmpty() && + NS_SUCCEEDED(GetOrCreateFolder(folderUri, getter_AddRefs(folder)))) { + nsCOMPtr<nsIMsgFolder> parent; + rv = folder->GetParent(getter_AddRefs(parent)); + if (NS_SUCCEEDED(rv) && parent) { + folder->SetFlag(nsMsgFolderFlags::Templates); + NS_ENSURE_SUCCESS(rv, rv); + } + } + } + + // XXX todo + // get all servers + // get all spam settings for each server + // set the JUNK folder flag on the spam folders, right? + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::UnloadAccounts() { + // release the default account + m_defaultAccount = nullptr; + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + if (!server) continue; + nsresult rv; + NotifyServerUnloaded(server); + + nsCOMPtr<nsIMsgFolder> rootFolder; + rv = server->GetRootFolder(getter_AddRefs(rootFolder)); + if (NS_SUCCEEDED(rv)) { + removeListenersFromFolder(rootFolder); + + rootFolder->Shutdown(true); + } + } + + m_accounts.Clear(); // will release all elements + m_identities.Clear(); + m_incomingServers.Clear(); + mAccountKeyList.Truncate(); + SetLastServerFound(nullptr, EmptyCString(), EmptyCString(), 0, + EmptyCString()); + + if (m_accountsLoaded) { + nsCOMPtr<nsIMsgMailSession> mailSession = + do_GetService("@mozilla.org/messenger/services/session;1"); + if (mailSession) mailSession->RemoveFolderListener(this); + m_accountsLoaded = false; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::ShutdownServers() { + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + if (server) server->Shutdown(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::CloseCachedConnections() { + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + if (server) server->CloseCachedConnections(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::CleanupOnExit() { + // This can get called multiple times, and potentially re-entrantly. + // So add some protection against that. + if (m_shutdownInProgress) return NS_OK; + + m_shutdownInProgress = true; + + nsresult rv; + // If enabled, clear cache on shutdown. This is common to all accounts. + bool clearCache = false; + m_prefs->GetBoolPref("privacy.clearOnShutdown.cache", &clearCache); + if (clearCache) { + nsCOMPtr<nsICacheStorageService> cacheStorageService = + do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv); + if (NS_SUCCEEDED(rv)) cacheStorageService->Clear(); + } + + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + + bool emptyTrashOnExit = false; + bool cleanupInboxOnExit = false; + + if (WeAreOffline()) break; + + if (!server) continue; + + server->GetEmptyTrashOnExit(&emptyTrashOnExit); + nsCOMPtr<nsIImapIncomingServer> imapserver = do_QueryInterface(server); + if (imapserver) { + imapserver->GetCleanupInboxOnExit(&cleanupInboxOnExit); + imapserver->SetShuttingDown(true); + } + if (emptyTrashOnExit || cleanupInboxOnExit) { + nsCOMPtr<nsIMsgFolder> root; + server->GetRootFolder(getter_AddRefs(root)); + nsCString type; + server->GetType(type); + if (root) { + nsString passwd; + int32_t authMethod = 0; + bool serverRequiresPasswordForAuthentication = true; + bool isImap = type.EqualsLiteral("imap"); + if (isImap) { + server->GetServerRequiresPasswordForBiff( + &serverRequiresPasswordForAuthentication); + server->GetPassword(passwd); + server->GetAuthMethod(&authMethod); + } + if (!isImap || (isImap && (!serverRequiresPasswordForAuthentication || + !passwd.IsEmpty() || + authMethod == nsMsgAuthMethod::OAuth2))) { + nsCOMPtr<nsIMsgAccountManager> accountManager = + do_GetService("@mozilla.org/messenger/account-manager;1", &rv); + if (NS_FAILED(rv)) continue; + + if (isImap && cleanupInboxOnExit) { + // Find the inbox. + nsTArray<RefPtr<nsIMsgFolder>> subFolders; + rv = root->GetSubFolders(subFolders); + if (NS_SUCCEEDED(rv)) { + for (nsIMsgFolder* folder : subFolders) { + uint32_t flags; + folder->GetFlags(&flags); + if (flags & nsMsgFolderFlags::Inbox) { + // This is inbox, so Compact() it. There's an implied + // Expunge too, because this is IMAP. + RefPtr<UrlListener> cleanupListener = new UrlListener(); + RefPtr<nsMsgAccountManager> self = this; + // This runs when the compaction (+expunge) is complete. + cleanupListener->mStopFn = + [self](nsIURI* url, nsresult status) -> nsresult { + if (self->m_folderDoingCleanupInbox) { + PR_CEnterMonitor(self->m_folderDoingCleanupInbox); + PR_CNotifyAll(self->m_folderDoingCleanupInbox); + self->m_cleanupInboxInProgress = false; + PR_CExitMonitor(self->m_folderDoingCleanupInbox); + self->m_folderDoingCleanupInbox = nullptr; + } + return NS_OK; + }; + + rv = folder->Compact(cleanupListener, nullptr); + if (NS_SUCCEEDED(rv)) + accountManager->SetFolderDoingCleanupInbox(folder); + break; + } + } + } + } + + if (emptyTrashOnExit) { + RefPtr<UrlListener> emptyTrashListener = new UrlListener(); + RefPtr<nsMsgAccountManager> self = this; + // This runs when the trash-emptying is complete. + // (It'll be a nsIImapUrl::nsImapDeleteAllMsgs url). + emptyTrashListener->mStopFn = [self](nsIURI* url, + nsresult status) -> nsresult { + if (self->m_folderDoingEmptyTrash) { + PR_CEnterMonitor(self->m_folderDoingEmptyTrash); + PR_CNotifyAll(self->m_folderDoingEmptyTrash); + self->m_emptyTrashInProgress = false; + PR_CExitMonitor(self->m_folderDoingEmptyTrash); + self->m_folderDoingEmptyTrash = nullptr; + } + return NS_OK; + }; + + rv = root->EmptyTrash(emptyTrashListener); + if (isImap && NS_SUCCEEDED(rv)) + accountManager->SetFolderDoingEmptyTrash(root); + } + + if (isImap) { + nsCOMPtr<nsIThread> thread(do_GetCurrentThread()); + + // Pause until any possible inbox-compaction and trash-emptying + // are complete (or time out). + bool inProgress = false; + if (cleanupInboxOnExit) { + int32_t loopCount = 0; // used to break out after 5 seconds + accountManager->GetCleanupInboxInProgress(&inProgress); + while (inProgress && loopCount++ < 5000) { + accountManager->GetCleanupInboxInProgress(&inProgress); + PR_CEnterMonitor(root); + PR_CWait(root, PR_MicrosecondsToInterval(1000UL)); + PR_CExitMonitor(root); + NS_ProcessPendingEvents(thread, + PR_MicrosecondsToInterval(1000UL)); + } + } + if (emptyTrashOnExit) { + accountManager->GetEmptyTrashInProgress(&inProgress); + int32_t loopCount = 0; + while (inProgress && loopCount++ < 5000) { + accountManager->GetEmptyTrashInProgress(&inProgress); + PR_CEnterMonitor(root); + PR_CWait(root, PR_MicrosecondsToInterval(1000UL)); + PR_CExitMonitor(root); + NS_ProcessPendingEvents(thread, + PR_MicrosecondsToInterval(1000UL)); + } + } + } + } + } + } + } + + // Try to do this early on in the shutdown process before + // necko shuts itself down. + CloseCachedConnections(); + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::WriteToFolderCache(nsIMsgFolderCache* folderCache) { + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + iter.Data()->WriteToFolderCache(folderCache); + } + return NS_OK; +} + +nsresult nsMsgAccountManager::createKeyedAccount(const nsCString& key, + bool forcePositionToEnd, + nsIMsgAccount** aAccount) { + nsresult rv; + nsCOMPtr<nsIMsgAccount> account = do_CreateInstance(kMsgAccountCID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + account->SetKey(key); + + nsCString localFoldersAccountKey; + nsCString lastFolderAccountKey; + if (!forcePositionToEnd) { + nsCOMPtr<nsIMsgIncomingServer> localFoldersServer; + rv = GetLocalFoldersServer(getter_AddRefs(localFoldersServer)); + if (NS_SUCCEEDED(rv)) { + for (auto account : m_accounts) { + nsCOMPtr<nsIMsgIncomingServer> server; + rv = account->GetIncomingServer(getter_AddRefs(server)); + if (NS_SUCCEEDED(rv) && server == localFoldersServer) { + account->GetKey(localFoldersAccountKey); + break; + } + } + } + + // Extracting the account key of the last mail acoount. + for (int32_t index = m_accounts.Length() - 1; index >= 0; index--) { + nsCOMPtr<nsIMsgIncomingServer> server; + rv = m_accounts[index]->GetIncomingServer(getter_AddRefs(server)); + if (NS_SUCCEEDED(rv) && server) { + nsCString accountType; + rv = server->GetType(accountType); + if (NS_SUCCEEDED(rv) && !accountType.EqualsLiteral("im")) { + m_accounts[index]->GetKey(lastFolderAccountKey); + break; + } + } + } + } + + if (!forcePositionToEnd && !localFoldersAccountKey.IsEmpty() && + !lastFolderAccountKey.IsEmpty() && + lastFolderAccountKey == localFoldersAccountKey) { + // Insert account before Local Folders if that is the last account. + m_accounts.InsertElementAt(m_accounts.Length() - 1, account); + } else { + m_accounts.AppendElement(account); + } + + nsCString newAccountKeyList; + nsCString accountKey; + for (uint32_t index = 0; index < m_accounts.Length(); index++) { + m_accounts[index]->GetKey(accountKey); + if (index) newAccountKeyList.Append(ACCOUNT_DELIMITER); + newAccountKeyList.Append(accountKey); + } + mAccountKeyList = newAccountKeyList; + + m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS, mAccountKeyList); + account.forget(aAccount); + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::CreateAccount(nsIMsgAccount** _retval) { + NS_ENSURE_ARG_POINTER(_retval); + + nsAutoCString key; + GetUniqueAccountKey(key); + + return createKeyedAccount(key, false, _retval); +} + +NS_IMETHODIMP +nsMsgAccountManager::GetAccount(const nsACString& aKey, + nsIMsgAccount** aAccount) { + NS_ENSURE_ARG_POINTER(aAccount); + *aAccount = nullptr; + + for (uint32_t i = 0; i < m_accounts.Length(); ++i) { + nsCOMPtr<nsIMsgAccount> account(m_accounts[i]); + nsCString key; + account->GetKey(key); + if (key.Equals(aKey)) { + account.forget(aAccount); + break; + } + } + + // If not found, create on demand. + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::FindServerIndex(nsIMsgIncomingServer* server, + int32_t* result) { + NS_ENSURE_ARG_POINTER(server); + NS_ENSURE_ARG_POINTER(result); + + nsCString key; + nsresult rv = server->GetKey(key); + NS_ENSURE_SUCCESS(rv, rv); + + // do this by account because the account list is in order + uint32_t i; + for (i = 0; i < m_accounts.Length(); ++i) { + nsCOMPtr<nsIMsgIncomingServer> server; + rv = m_accounts[i]->GetIncomingServer(getter_AddRefs(server)); + if (!server || NS_FAILED(rv)) continue; + + nsCString serverKey; + rv = server->GetKey(serverKey); + if (NS_FAILED(rv)) continue; + + // stop when found, + // index will be set to the current index + if (serverKey.Equals(key)) break; + } + + // Even if the search failed, we can return index. + // This means that all servers not in the array return an index higher + // than all "registered" servers. + *result = i; + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::AddIncomingServerListener( + nsIIncomingServerListener* serverListener) { + m_incomingServerListeners.AppendObject(serverListener); + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::RemoveIncomingServerListener( + nsIIncomingServerListener* serverListener) { + m_incomingServerListeners.RemoveObject(serverListener); + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::NotifyServerLoaded( + nsIMsgIncomingServer* server) { + int32_t count = m_incomingServerListeners.Count(); + for (int32_t i = 0; i < count; i++) { + nsIIncomingServerListener* listener = m_incomingServerListeners[i]; + listener->OnServerLoaded(server); + } + + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::NotifyServerUnloaded( + nsIMsgIncomingServer* server) { + NS_ENSURE_ARG_POINTER(server); + + int32_t count = m_incomingServerListeners.Count(); + // Clear this to cut shutdown leaks. We are always passing valid non-null + // server here. + server->SetFilterList(nullptr); + + for (int32_t i = 0; i < count; i++) { + nsIIncomingServerListener* listener = m_incomingServerListeners[i]; + listener->OnServerUnloaded(server); + } + + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::NotifyServerChanged( + nsIMsgIncomingServer* server) { + int32_t count = m_incomingServerListeners.Count(); + for (int32_t i = 0; i < count; i++) { + nsIIncomingServerListener* listener = m_incomingServerListeners[i]; + listener->OnServerChanged(server); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::FindServerByURI(nsIURI* aURI, + nsIMsgIncomingServer** aResult) { + NS_ENSURE_ARG_POINTER(aURI); + + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + // Get username and hostname and port so we can get the server + nsAutoCString username; + nsAutoCString escapedUsername; + rv = aURI->GetUserPass(escapedUsername); + if (NS_SUCCEEDED(rv) && !escapedUsername.IsEmpty()) + MsgUnescapeString(escapedUsername, 0, username); + + nsAutoCString hostname; + nsAutoCString escapedHostname; + rv = aURI->GetHost(escapedHostname); + if (NS_SUCCEEDED(rv) && !escapedHostname.IsEmpty()) { + MsgUnescapeString(escapedHostname, 0, hostname); + } + + nsAutoCString type; + rv = aURI->GetScheme(type); + if (NS_SUCCEEDED(rv) && !type.IsEmpty()) { + // Remove "-message" from the scheme in case we get called with + // "imap-message", "mailbox-message", or friends. + if (StringEndsWith(type, "-message"_ns)) type.SetLength(type.Length() - 8); + // now modify type if pop or news + if (type.EqualsLiteral("pop")) type.AssignLiteral("pop3"); + // we use "nntp" in the server list so translate it here. + else if (type.EqualsLiteral("news")) + type.AssignLiteral("nntp"); + // we use "any" as the wildcard type. + else if (type.EqualsLiteral("any")) + type.Truncate(); + } + + int32_t port = 0; + // check the port of the scheme is not 'none' or blank + if (!(type.EqualsLiteral("none") || type.IsEmpty())) { + rv = aURI->GetPort(&port); + // Set the port to zero if we got a -1 (use default) + if (NS_SUCCEEDED(rv) && (port == -1)) port = 0; + } + + return findServerInternal(username, hostname, type, port, aResult); +} + +nsresult nsMsgAccountManager::findServerInternal( + const nsACString& username, const nsACString& serverHostname, + const nsACString& type, int32_t port, nsIMsgIncomingServer** aResult) { + if ((m_lastFindServerUserName.Equals(username)) && + (m_lastFindServerHostName.Equals(serverHostname)) && + (m_lastFindServerType.Equals(type)) && (m_lastFindServerPort == port) && + m_lastFindServerResult) { + NS_ADDREF(*aResult = m_lastFindServerResult); + return NS_OK; + } + + nsresult rv; + nsCString hostname; + nsCOMPtr<nsIIDNService> idnService = + do_GetService("@mozilla.org/network/idn-service;1"); + rv = idnService->Normalize(serverHostname, hostname); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + // Find matching server by user+host+type+port. + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + + if (!server) continue; + + nsCString thisHostname; + rv = server->GetHostName(thisHostname); + if (NS_FAILED(rv)) continue; + + rv = idnService->Normalize(thisHostname, thisHostname); + if (NS_FAILED(rv)) continue; + + // If the hostname was a IP with trailing dot, that dot gets removed + // during URI mutation. We may well be here in findServerInternal to + // find a server from a folder URI. Remove the trailing dot so we can + // find the server. + nsCString thisHostnameNoDot(thisHostname); + if (!thisHostname.IsEmpty() && + thisHostname.CharAt(thisHostname.Length() - 1) == '.') { + thisHostnameNoDot.Cut(thisHostname.Length() - 1, 1); + } + + nsCString thisUsername; + rv = server->GetUsername(thisUsername); + if (NS_FAILED(rv)) continue; + + nsCString thisType; + rv = server->GetType(thisType); + if (NS_FAILED(rv)) continue; + + int32_t thisPort = -1; // use the default port identifier + // Don't try and get a port for the 'none' scheme + if (!thisType.EqualsLiteral("none")) { + rv = server->GetPort(&thisPort); + if (NS_FAILED(rv)) { + continue; + } + } + + // treat "" as a wild card, so if the caller passed in "" for the desired + // attribute treat it as a match + if ((type.IsEmpty() || thisType.Equals(type)) && + (hostname.IsEmpty() || + thisHostname.Equals(hostname, nsCaseInsensitiveCStringComparator) || + thisHostnameNoDot.Equals(hostname, + nsCaseInsensitiveCStringComparator)) && + (!(port != 0) || (port == thisPort)) && + (username.IsEmpty() || thisUsername.Equals(username))) { + // stop on first find; cache for next time + SetLastServerFound(server, hostname, username, port, type); + + NS_ADDREF(*aResult = server); // Was populated from member variable. + return NS_OK; + } + } + + return NS_ERROR_UNEXPECTED; +} + +// Always return NS_OK; +NS_IMETHODIMP +nsMsgAccountManager::FindServer(const nsACString& username, + const nsACString& hostname, + const nsACString& type, int32_t port, + nsIMsgIncomingServer** aResult) { + *aResult = nullptr; + findServerInternal(username, hostname, type, port, aResult); + return NS_OK; +} + +void nsMsgAccountManager::findAccountByServerKey(const nsCString& aKey, + nsIMsgAccount** aResult) { + *aResult = nullptr; + + for (uint32_t i = 0; i < m_accounts.Length(); ++i) { + nsCOMPtr<nsIMsgIncomingServer> server; + nsresult rv = m_accounts[i]->GetIncomingServer(getter_AddRefs(server)); + if (!server || NS_FAILED(rv)) continue; + + nsCString key; + rv = server->GetKey(key); + if (NS_FAILED(rv)) continue; + + // if the keys are equal, the servers are equal + if (key.Equals(aKey)) { + NS_ADDREF(*aResult = m_accounts[i]); + break; // stop on first found account + } + } +} + +NS_IMETHODIMP +nsMsgAccountManager::FindAccountForServer(nsIMsgIncomingServer* server, + nsIMsgAccount** aResult) { + NS_ENSURE_ARG_POINTER(aResult); + + if (!server) { + (*aResult) = nullptr; + return NS_OK; + } + + nsresult rv; + + nsCString key; + rv = server->GetKey(key); + NS_ENSURE_SUCCESS(rv, rv); + + findAccountByServerKey(key, aResult); + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetFirstIdentityForServer(nsIMsgIncomingServer* aServer, + nsIMsgIdentity** aIdentity) { + NS_ENSURE_ARG_POINTER(aServer); + NS_ENSURE_ARG_POINTER(aIdentity); + + nsTArray<RefPtr<nsIMsgIdentity>> identities; + nsresult rv = GetIdentitiesForServer(aServer, identities); + NS_ENSURE_SUCCESS(rv, rv); + + // not all servers have identities + // for example, Local Folders + if (identities.IsEmpty()) { + *aIdentity = nullptr; + } else { + NS_IF_ADDREF(*aIdentity = identities[0]); + } + return rv; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetIdentitiesForServer( + nsIMsgIncomingServer* server, + nsTArray<RefPtr<nsIMsgIdentity>>& identities) { + NS_ENSURE_ARG_POINTER(server); + nsresult rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + identities.Clear(); + + nsAutoCString serverKey; + rv = server->GetKey(serverKey); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto account : m_accounts) { + nsCOMPtr<nsIMsgIncomingServer> thisServer; + rv = account->GetIncomingServer(getter_AddRefs(thisServer)); + if (NS_FAILED(rv) || !thisServer) continue; + + nsAutoCString thisServerKey; + rv = thisServer->GetKey(thisServerKey); + if (serverKey.Equals(thisServerKey)) { + nsTArray<RefPtr<nsIMsgIdentity>> theseIdentities; + rv = account->GetIdentities(theseIdentities); + NS_ENSURE_SUCCESS(rv, rv); + identities.AppendElements(theseIdentities); + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetServersForIdentity( + nsIMsgIdentity* aIdentity, + nsTArray<RefPtr<nsIMsgIncomingServer>>& servers) { + NS_ENSURE_ARG_POINTER(aIdentity); + servers.Clear(); + + nsresult rv; + rv = LoadAccounts(); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto account : m_accounts) { + nsTArray<RefPtr<nsIMsgIdentity>> identities; + if (NS_FAILED(account->GetIdentities(identities))) continue; + + nsCString identityKey; + aIdentity->GetKey(identityKey); + for (auto thisIdentity : identities) { + nsCString thisIdentityKey; + rv = thisIdentity->GetKey(thisIdentityKey); + + if (NS_SUCCEEDED(rv) && identityKey.Equals(thisIdentityKey)) { + nsCOMPtr<nsIMsgIncomingServer> thisServer; + rv = account->GetIncomingServer(getter_AddRefs(thisServer)); + if (thisServer && NS_SUCCEEDED(rv)) { + servers.AppendElement(thisServer); + break; + } + } + } + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::AddRootFolderListener(nsIFolderListener* aListener) { + NS_ENSURE_TRUE(aListener, NS_OK); + mFolderListeners.AppendElement(aListener); + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgFolder> rootFolder; + nsresult rv = iter.Data()->GetRootFolder(getter_AddRefs(rootFolder)); + if (NS_FAILED(rv)) { + continue; + } + rv = rootFolder->AddFolderListener(aListener); + } + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::RemoveRootFolderListener(nsIFolderListener* aListener) { + NS_ENSURE_TRUE(aListener, NS_OK); + mFolderListeners.RemoveElement(aListener); + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgFolder> rootFolder; + nsresult rv = iter.Data()->GetRootFolder(getter_AddRefs(rootFolder)); + if (NS_FAILED(rv)) { + continue; + } + rv = rootFolder->RemoveFolderListener(aListener); + } + + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::SetLocalFoldersServer( + nsIMsgIncomingServer* aServer) { + NS_ENSURE_ARG_POINTER(aServer); + nsCString key; + nsresult rv = aServer->GetKey(key); + NS_ENSURE_SUCCESS(rv, rv); + + return m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER, key); +} + +NS_IMETHODIMP nsMsgAccountManager::GetLocalFoldersServer( + nsIMsgIncomingServer** aServer) { + NS_ENSURE_ARG_POINTER(aServer); + + nsCString serverKey; + + nsresult rv = m_prefs->GetCharPref( + PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER, serverKey); + + if (NS_SUCCEEDED(rv) && !serverKey.IsEmpty()) { + rv = GetIncomingServer(serverKey, aServer); + if (NS_SUCCEEDED(rv)) return rv; + // otherwise, we're going to fall through to looking for an existing local + // folders account, because now we fail creating one if one already exists. + } + + // try ("nobody","Local Folders","none"), and work down to any "none" server. + rv = findServerInternal("nobody"_ns, "Local Folders"_ns, "none"_ns, 0, + aServer); + if (NS_FAILED(rv) || !*aServer) { + rv = findServerInternal("nobody"_ns, EmptyCString(), "none"_ns, 0, aServer); + if (NS_FAILED(rv) || !*aServer) { + rv = findServerInternal(EmptyCString(), "Local Folders"_ns, "none"_ns, 0, + aServer); + if (NS_FAILED(rv) || !*aServer) + rv = findServerInternal(EmptyCString(), EmptyCString(), "none"_ns, 0, + aServer); + } + } + + NS_ENSURE_SUCCESS(rv, rv); + if (!*aServer) return NS_ERROR_FAILURE; + + // we don't want the Smart Mailboxes server to be the local server. + bool hidden; + (*aServer)->GetHidden(&hidden); + if (hidden) return NS_ERROR_FAILURE; + + rv = SetLocalFoldersServer(*aServer); + return rv; +} + +nsresult nsMsgAccountManager::GetLocalFoldersPrettyName( + nsString& localFoldersName) { + // we don't want "nobody at Local Folders" to show up in the + // folder pane, so we set the pretty name to a localized "Local Folders" + nsCOMPtr<nsIStringBundle> bundle; + nsresult rv; + nsCOMPtr<nsIStringBundleService> sBundleService = + mozilla::components::StringBundle::Service(); + NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED); + + rv = sBundleService->CreateBundle( + "chrome://messenger/locale/messenger.properties", getter_AddRefs(bundle)); + NS_ENSURE_SUCCESS(rv, rv); + + return bundle->GetStringFromName("localFolders", localFoldersName); +} + +NS_IMETHODIMP +nsMsgAccountManager::CreateLocalMailAccount() { + // create the server + nsCOMPtr<nsIMsgIncomingServer> server; + nsresult rv = CreateIncomingServer("nobody"_ns, "Local Folders"_ns, "none"_ns, + getter_AddRefs(server)); + NS_ENSURE_SUCCESS(rv, rv); + + nsString localFoldersName; + rv = GetLocalFoldersPrettyName(localFoldersName); + NS_ENSURE_SUCCESS(rv, rv); + server->SetPrettyName(localFoldersName); + + nsCOMPtr<nsINoIncomingServer> noServer; + noServer = do_QueryInterface(server, &rv); + if (NS_FAILED(rv)) return rv; + + // create the directory structure for old 4.x "Local Mail" + // under <profile dir>/Mail/Local Folders or + // <"mail.directory" pref>/Local Folders + nsCOMPtr<nsIFile> mailDir; + bool dirExists; + + // we want <profile>/Mail + rv = NS_GetSpecialDirectory(NS_APP_MAIL_50_DIR, getter_AddRefs(mailDir)); + if (NS_FAILED(rv)) return rv; + + rv = mailDir->Exists(&dirExists); + if (NS_SUCCEEDED(rv) && !dirExists) + rv = mailDir->Create(nsIFile::DIRECTORY_TYPE, 0775); + if (NS_FAILED(rv)) return rv; + + // set the default local path for "none" + rv = server->SetDefaultLocalPath(mailDir); + if (NS_FAILED(rv)) return rv; + + // Create an account when valid server values are established. + // This will keep the status of accounts sane by avoiding the addition of + // incomplete accounts. + nsCOMPtr<nsIMsgAccount> account; + rv = CreateAccount(getter_AddRefs(account)); + if (NS_FAILED(rv)) return rv; + + // notice, no identity for local mail + // hook the server to the account + // after we set the server's local path + // (see bug #66018) + account->SetIncomingServer(server); + + // remember this as the local folders server + return SetLocalFoldersServer(server); +} + +NS_IMETHODIMP +nsMsgAccountManager::SetFolderDoingEmptyTrash(nsIMsgFolder* folder) { + m_folderDoingEmptyTrash = folder; + m_emptyTrashInProgress = true; + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetEmptyTrashInProgress(bool* bVal) { + NS_ENSURE_ARG_POINTER(bVal); + *bVal = m_emptyTrashInProgress; + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::SetFolderDoingCleanupInbox(nsIMsgFolder* folder) { + m_folderDoingCleanupInbox = folder; + m_cleanupInboxInProgress = true; + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetCleanupInboxInProgress(bool* bVal) { + NS_ENSURE_ARG_POINTER(bVal); + *bVal = m_cleanupInboxInProgress; + return NS_OK; +} + +void nsMsgAccountManager::SetLastServerFound(nsIMsgIncomingServer* server, + const nsACString& hostname, + const nsACString& username, + const int32_t port, + const nsACString& type) { + m_lastFindServerResult = server; + m_lastFindServerHostName = hostname; + m_lastFindServerUserName = username; + m_lastFindServerPort = port; + m_lastFindServerType = type; +} + +NS_IMETHODIMP +nsMsgAccountManager::SaveAccountInfo() { + nsresult rv; + nsCOMPtr<nsIPrefService> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + return pref->SavePrefFile(nullptr); +} + +NS_IMETHODIMP +nsMsgAccountManager::GetChromePackageName(const nsACString& aExtensionName, + nsACString& aChromePackageName) { + nsresult rv; + nsCOMPtr<nsICategoryManager> catman = + do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISimpleEnumerator> e; + rv = catman->EnumerateCategory(MAILNEWS_ACCOUNTMANAGER_EXTENSIONS, + getter_AddRefs(e)); + if (NS_SUCCEEDED(rv) && e) { + while (true) { + nsCOMPtr<nsISupports> supports; + rv = e->GetNext(getter_AddRefs(supports)); + nsCOMPtr<nsISupportsCString> catEntry = do_QueryInterface(supports); + if (NS_FAILED(rv) || !catEntry) break; + + nsAutoCString entryString; + rv = catEntry->GetData(entryString); + if (NS_FAILED(rv)) break; + + nsCString contractidString; + rv = catman->GetCategoryEntry(MAILNEWS_ACCOUNTMANAGER_EXTENSIONS, + entryString, contractidString); + if (NS_FAILED(rv)) break; + + nsCOMPtr<nsIMsgAccountManagerExtension> extension = + do_GetService(contractidString.get(), &rv); + if (NS_FAILED(rv) || !extension) break; + + nsCString name; + rv = extension->GetName(name); + if (NS_FAILED(rv)) break; + + if (name.Equals(aExtensionName)) + return extension->GetChromePackageName(aChromePackageName); + } + } + return NS_ERROR_UNEXPECTED; +} + +class VFChangeListenerEvent : public mozilla::Runnable { + public: + VFChangeListenerEvent(VirtualFolderChangeListener* vfChangeListener, + nsIMsgFolder* virtFolder, nsIMsgDatabase* virtDB) + : mozilla::Runnable("VFChangeListenerEvent"), + mVFChangeListener(vfChangeListener), + mFolder(virtFolder), + mDB(virtDB) {} + + NS_IMETHOD Run() { + if (mVFChangeListener) mVFChangeListener->ProcessUpdateEvent(mFolder, mDB); + return NS_OK; + } + + private: + RefPtr<VirtualFolderChangeListener> mVFChangeListener; + nsCOMPtr<nsIMsgFolder> mFolder; + nsCOMPtr<nsIMsgDatabase> mDB; +}; + +NS_IMPL_ISUPPORTS(VirtualFolderChangeListener, nsIDBChangeListener) + +VirtualFolderChangeListener::VirtualFolderChangeListener() + : m_searchOnMsgStatus(false), m_batchingEvents(false) {} + +nsresult VirtualFolderChangeListener::Init() { + nsCOMPtr<nsIMsgDatabase> msgDB; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + + nsresult rv = m_virtualFolder->GetDBFolderInfoAndDB( + getter_AddRefs(dbFolderInfo), getter_AddRefs(msgDB)); + if (NS_SUCCEEDED(rv) && msgDB) { + nsCString searchTermString; + dbFolderInfo->GetCharProperty("searchStr", searchTermString); + nsCOMPtr<nsIMsgFilterService> filterService = + do_GetService("@mozilla.org/messenger/services/filters;1", &rv); + nsCOMPtr<nsIMsgFilterList> filterList; + rv = filterService->GetTempFilterList(m_virtualFolder, + getter_AddRefs(filterList)); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsIMsgFilter> tempFilter; + filterList->CreateFilter(u"temp"_ns, getter_AddRefs(tempFilter)); + NS_ENSURE_SUCCESS(rv, rv); + filterList->ParseCondition(tempFilter, searchTermString.get()); + NS_ENSURE_SUCCESS(rv, rv); + m_searchSession = + do_CreateInstance("@mozilla.org/messenger/searchSession;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsTArray<RefPtr<nsIMsgSearchTerm>> searchTerms; + rv = tempFilter->GetSearchTerms(searchTerms); + NS_ENSURE_SUCCESS(rv, rv); + + // we add the search scope right before we match the header, + // because we don't want the search scope caching the body input + // stream, because that holds onto the mailbox file, breaking + // compaction. + + // add each search term to the search session + for (nsIMsgSearchTerm* searchTerm : searchTerms) { + nsMsgSearchAttribValue attrib; + searchTerm->GetAttrib(&attrib); + if (attrib == nsMsgSearchAttrib::MsgStatus) m_searchOnMsgStatus = true; + m_searchSession->AppendTerm(searchTerm); + } + } + return rv; +} + +/** + * nsIDBChangeListener + */ + +NS_IMETHODIMP +VirtualFolderChangeListener::OnHdrPropertyChanged( + nsIMsgDBHdr* aHdrChanged, const nsACString& property, bool aPreChange, + uint32_t* aStatus, nsIDBChangeListener* aInstigator) { + const uint32_t kMatch = 0x1; + const uint32_t kRead = 0x2; + const uint32_t kNew = 0x4; + NS_ENSURE_ARG_POINTER(aHdrChanged); + NS_ENSURE_ARG_POINTER(aStatus); + + uint32_t flags; + bool match; + nsCOMPtr<nsIMsgDatabase> msgDB; + nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB)); + NS_ENSURE_SUCCESS(rv, rv); + // we don't want any early returns from this function, until we've + // called ClearScopes on the search session. + m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, + m_folderWatching); + rv = m_searchSession->MatchHdr(aHdrChanged, msgDB, &match); + m_searchSession->ClearScopes(); + NS_ENSURE_SUCCESS(rv, rv); + aHdrChanged->GetFlags(&flags); + + if (aPreChange) // We're looking at the old header, save status + { + *aStatus = 0; + if (match) *aStatus |= kMatch; + if (flags & nsMsgMessageFlags::Read) *aStatus |= kRead; + if (flags & nsMsgMessageFlags::New) *aStatus |= kNew; + return NS_OK; + } + + // This is the post change section where changes are detected + + bool wasMatch = *aStatus & kMatch; + if (!match && !wasMatch) // header not in virtual folder + return NS_OK; + + int32_t totalDelta = 0, unreadDelta = 0, newDelta = 0; + + if (match) { + totalDelta++; + if (!(flags & nsMsgMessageFlags::Read)) unreadDelta++; + if (flags & nsMsgMessageFlags::New) newDelta++; + } + + if (wasMatch) { + totalDelta--; + if (!(*aStatus & kRead)) unreadDelta--; + if (*aStatus & kNew) newDelta--; + } + + if (!(unreadDelta || totalDelta || newDelta)) return NS_OK; + + nsCOMPtr<nsIMsgDatabase> virtDatabase; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(virtDatabase)); + NS_ENSURE_SUCCESS(rv, rv); + + if (unreadDelta) dbFolderInfo->ChangeNumUnreadMessages(unreadDelta); + + if (newDelta) { + int32_t numNewMessages; + m_virtualFolder->GetNumNewMessages(false, &numNewMessages); + m_virtualFolder->SetNumNewMessages(numNewMessages + newDelta); + m_virtualFolder->SetHasNewMessages(numNewMessages + newDelta > 0); + } + + if (totalDelta) { + dbFolderInfo->ChangeNumMessages(totalDelta); + nsCString searchUri; + m_virtualFolder->GetURI(searchUri); + msgDB->UpdateHdrInCache(searchUri, aHdrChanged, totalDelta == 1); + } + + PostUpdateEvent(m_virtualFolder, virtDatabase); + + return NS_OK; +} + +void VirtualFolderChangeListener::DecrementNewMsgCount() { + int32_t numNewMessages; + m_virtualFolder->GetNumNewMessages(false, &numNewMessages); + if (numNewMessages > 0) numNewMessages--; + m_virtualFolder->SetNumNewMessages(numNewMessages); + if (!numNewMessages) m_virtualFolder->SetHasNewMessages(false); +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnHdrFlagsChanged( + nsIMsgDBHdr* aHdrChanged, uint32_t aOldFlags, uint32_t aNewFlags, + nsIDBChangeListener* aInstigator) { + nsCOMPtr<nsIMsgDatabase> msgDB; + + nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB)); + bool oldMatch = false, newMatch = false; + // we don't want any early returns from this function, until we've + // called ClearScopes 0n the search session. + m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, + m_folderWatching); + rv = m_searchSession->MatchHdr(aHdrChanged, msgDB, &newMatch); + if (NS_SUCCEEDED(rv) && m_searchOnMsgStatus) { + // if status is a search criteria, check if the header matched before + // it changed, in order to determine if we need to bump the counts. + aHdrChanged->SetFlags(aOldFlags); + rv = m_searchSession->MatchHdr(aHdrChanged, msgDB, &oldMatch); + // restore new flags even on match failure. + aHdrChanged->SetFlags(aNewFlags); + } else + oldMatch = newMatch; + m_searchSession->ClearScopes(); + NS_ENSURE_SUCCESS(rv, rv); + // we don't want to change the total counts if this virtual folder is open in + // a view, because we won't remove the header from view while it's open. On + // the other hand, it's hard to fix the count when the user clicks away to + // another folder, w/o re-running the search, or setting some sort of pending + // count change. Maybe this needs to be handled in the view code...the view + // could do the same calculation and also keep track of the counts changed. + // Then, when the view was closed, if it's a virtual folder, it could update + // the counts for the db. + if (oldMatch != newMatch || + (oldMatch && (aOldFlags & nsMsgMessageFlags::Read) != + (aNewFlags & nsMsgMessageFlags::Read))) { + nsCOMPtr<nsIMsgDatabase> virtDatabase; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + + rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(virtDatabase)); + NS_ENSURE_SUCCESS(rv, rv); + int32_t totalDelta = 0, unreadDelta = 0; + if (oldMatch != newMatch) { + // bool isOpen = false; + // nsCOMPtr<nsIMsgMailSession> mailSession = + // do_GetService("@mozilla.org/messenger/services/session;1"); + // if (mailSession && aFolder) + // mailSession->IsFolderOpenInWindow(m_virtualFolder, &isOpen); + // we can't remove headers that no longer match - but we might add headers + // that newly match, someday. + // if (!isOpen) + totalDelta = (oldMatch) ? -1 : 1; + } + bool msgHdrIsRead; + aHdrChanged->GetIsRead(&msgHdrIsRead); + if (oldMatch == newMatch) // read flag changed state + unreadDelta = (msgHdrIsRead) ? -1 : 1; + else if (oldMatch) // else header should removed + unreadDelta = (aOldFlags & nsMsgMessageFlags::Read) ? 0 : -1; + else // header should be added + unreadDelta = (aNewFlags & nsMsgMessageFlags::Read) ? 0 : 1; + if (unreadDelta) dbFolderInfo->ChangeNumUnreadMessages(unreadDelta); + if (totalDelta) dbFolderInfo->ChangeNumMessages(totalDelta); + if (unreadDelta == -1 && aOldFlags & nsMsgMessageFlags::New) + DecrementNewMsgCount(); + + if (totalDelta) { + nsCString searchUri; + m_virtualFolder->GetURI(searchUri); + msgDB->UpdateHdrInCache(searchUri, aHdrChanged, totalDelta == 1); + } + + PostUpdateEvent(m_virtualFolder, virtDatabase); + } else if (oldMatch && (aOldFlags & nsMsgMessageFlags::New) && + !(aNewFlags & nsMsgMessageFlags::New)) + DecrementNewMsgCount(); + + return rv; +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnHdrDeleted( + nsIMsgDBHdr* aHdrDeleted, nsMsgKey aParentKey, int32_t aFlags, + nsIDBChangeListener* aInstigator) { + nsCOMPtr<nsIMsgDatabase> msgDB; + + nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB)); + NS_ENSURE_SUCCESS(rv, rv); + bool match = false; + m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, + m_folderWatching); + // Since the notifier went to the trouble of passing in the msg flags, + // we should use them when doing the match. + uint32_t msgFlags; + aHdrDeleted->GetFlags(&msgFlags); + aHdrDeleted->SetFlags(aFlags); + rv = m_searchSession->MatchHdr(aHdrDeleted, msgDB, &match); + aHdrDeleted->SetFlags(msgFlags); + m_searchSession->ClearScopes(); + if (match) { + nsCOMPtr<nsIMsgDatabase> virtDatabase; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + + rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(virtDatabase)); + NS_ENSURE_SUCCESS(rv, rv); + bool msgHdrIsRead; + aHdrDeleted->GetIsRead(&msgHdrIsRead); + if (!msgHdrIsRead) dbFolderInfo->ChangeNumUnreadMessages(-1); + dbFolderInfo->ChangeNumMessages(-1); + if (aFlags & nsMsgMessageFlags::New) { + int32_t numNewMessages; + m_virtualFolder->GetNumNewMessages(false, &numNewMessages); + m_virtualFolder->SetNumNewMessages(numNewMessages - 1); + if (numNewMessages == 1) m_virtualFolder->SetHasNewMessages(false); + } + + nsCString searchUri; + m_virtualFolder->GetURI(searchUri); + msgDB->UpdateHdrInCache(searchUri, aHdrDeleted, false); + + PostUpdateEvent(m_virtualFolder, virtDatabase); + } + return rv; +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnHdrAdded( + nsIMsgDBHdr* aNewHdr, nsMsgKey aParentKey, int32_t aFlags, + nsIDBChangeListener* aInstigator) { + nsCOMPtr<nsIMsgDatabase> msgDB; + + nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB)); + NS_ENSURE_SUCCESS(rv, rv); + bool match = false; + if (!m_searchSession) return NS_ERROR_NULL_POINTER; + + m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, + m_folderWatching); + rv = m_searchSession->MatchHdr(aNewHdr, msgDB, &match); + m_searchSession->ClearScopes(); + if (match) { + nsCOMPtr<nsIMsgDatabase> virtDatabase; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + + rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(virtDatabase)); + NS_ENSURE_SUCCESS(rv, rv); + bool msgHdrIsRead; + uint32_t msgFlags; + aNewHdr->GetIsRead(&msgHdrIsRead); + aNewHdr->GetFlags(&msgFlags); + if (!msgHdrIsRead) dbFolderInfo->ChangeNumUnreadMessages(1); + if (msgFlags & nsMsgMessageFlags::New) { + int32_t numNewMessages; + m_virtualFolder->GetNumNewMessages(false, &numNewMessages); + m_virtualFolder->SetHasNewMessages(true); + m_virtualFolder->SetNumNewMessages(numNewMessages + 1); + } + nsCString searchUri; + m_virtualFolder->GetURI(searchUri); + msgDB->UpdateHdrInCache(searchUri, aNewHdr, true); + dbFolderInfo->ChangeNumMessages(1); + PostUpdateEvent(m_virtualFolder, virtDatabase); + } + return rv; +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnParentChanged( + nsMsgKey aKeyChanged, nsMsgKey oldParent, nsMsgKey newParent, + nsIDBChangeListener* aInstigator) { + return NS_OK; +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnAnnouncerGoingAway( + nsIDBChangeAnnouncer* instigator) { + nsCOMPtr<nsIMsgDatabase> msgDB = do_QueryInterface(instigator); + if (msgDB) msgDB->RemoveListener(this); + return NS_OK; +} + +NS_IMETHODIMP +VirtualFolderChangeListener::OnEvent(nsIMsgDatabase* aDB, const char* aEvent) { + return NS_OK; +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnReadChanged( + nsIDBChangeListener* aInstigator) { + return NS_OK; +} + +NS_IMETHODIMP VirtualFolderChangeListener::OnJunkScoreChanged( + nsIDBChangeListener* aInstigator) { + return NS_OK; +} + +nsresult VirtualFolderChangeListener::PostUpdateEvent( + nsIMsgFolder* virtualFolder, nsIMsgDatabase* virtDatabase) { + if (m_batchingEvents) return NS_OK; + m_batchingEvents = true; + nsCOMPtr<nsIRunnable> event = + new VFChangeListenerEvent(this, virtualFolder, virtDatabase); + return NS_DispatchToCurrentThread(event); +} + +void VirtualFolderChangeListener::ProcessUpdateEvent(nsIMsgFolder* virtFolder, + nsIMsgDatabase* virtDB) { + m_batchingEvents = false; + virtFolder->UpdateSummaryTotals(true); // force update from db. + virtDB->Commit(nsMsgDBCommitType::kLargeCommit); +} + +nsresult nsMsgAccountManager::GetVirtualFoldersFile(nsCOMPtr<nsIFile>& aFile) { + nsCOMPtr<nsIFile> profileDir; + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(profileDir)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = profileDir->AppendNative("virtualFolders.dat"_ns); + if (NS_SUCCEEDED(rv)) aFile = profileDir; + return rv; +} + +NS_IMETHODIMP nsMsgAccountManager::LoadVirtualFolders() { + nsCOMPtr<nsIFile> file; + GetVirtualFoldersFile(file); + if (!file) return NS_ERROR_FAILURE; + + if (m_virtualFoldersLoaded) return NS_OK; + + m_loadingVirtualFolders = true; + + // Before loading virtual folders, ensure that all real folders exist. + // Some may not have been created yet, which would break virtual folders + // that depend on them. + nsTArray<RefPtr<nsIMsgIncomingServer>> allServers; + nsresult rv = GetAllServers(allServers); + NS_ENSURE_SUCCESS(rv, rv); + for (auto server : allServers) { + if (server) { + nsCOMPtr<nsIMsgFolder> rootFolder; + server->GetRootFolder(getter_AddRefs(rootFolder)); + if (rootFolder) { + nsTArray<RefPtr<nsIMsgFolder>> dummy; + rootFolder->GetSubFolders(dummy); + } + } + } + + if (!m_dbService) { + m_dbService = do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + } + + nsCOMPtr<nsIFileInputStream> fileStream = + do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + rv = fileStream->Init(file, PR_RDONLY, 0664, false); + nsCOMPtr<nsILineInputStream> lineInputStream(do_QueryInterface(fileStream)); + + bool isMore = true; + nsAutoCString buffer; + int32_t version = -1; + nsCOMPtr<nsIMsgFolder> virtualFolder; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + + while (isMore && NS_SUCCEEDED(lineInputStream->ReadLine(buffer, &isMore))) { + if (!buffer.IsEmpty()) { + if (version == -1) { + buffer.Cut(0, 8); + nsresult irv; + version = buffer.ToInteger(&irv); + continue; + } + if (StringBeginsWith(buffer, "uri="_ns)) { + buffer.Cut(0, 4); + dbFolderInfo = nullptr; + + rv = GetOrCreateFolder(buffer, getter_AddRefs(virtualFolder)); + NS_ENSURE_SUCCESS(rv, rv); + + virtualFolder->SetFlag(nsMsgFolderFlags::Virtual); + + nsCOMPtr<nsIMsgFolder> grandParent; + nsCOMPtr<nsIMsgFolder> oldParent; + nsCOMPtr<nsIMsgFolder> parentFolder; + bool isServer; + // This loop handles creating virtual folders without an existing + // parent. + do { + // need to add the folder as a sub-folder of its parent. + int32_t lastSlash = buffer.RFindChar('/'); + if (lastSlash == kNotFound) break; + nsDependentCSubstring parentUri(buffer, 0, lastSlash); + // hold a reference so it won't get deleted before it's parented. + oldParent = parentFolder; + + rv = GetOrCreateFolder(parentUri, getter_AddRefs(parentFolder)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoString currentFolderNameStr; + nsAutoCString currentFolderNameCStr; + MsgUnescapeString( + nsCString(Substring(buffer, lastSlash + 1, buffer.Length())), 0, + currentFolderNameCStr); + CopyUTF8toUTF16(currentFolderNameCStr, currentFolderNameStr); + nsCOMPtr<nsIMsgFolder> childFolder; + nsCOMPtr<nsIMsgDatabase> db; + // force db to get created. + // XXX TODO: is this SetParent() right? Won't it screw up if virtual + // folder is nested >2 deep? Leave for now, but revisit when getting + // rid of dangling folders (BenC). + virtualFolder->SetParent(parentFolder); + rv = virtualFolder->GetMsgDatabase(getter_AddRefs(db)); + if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING) + m_dbService->CreateNewDB(virtualFolder, getter_AddRefs(db)); + if (db) + rv = db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo)); + else + break; + + parentFolder->AddSubfolder(currentFolderNameStr, + getter_AddRefs(childFolder)); + if (childFolder) parentFolder->NotifyFolderAdded(childFolder); + // here we make sure if our parent is rooted - if not, we're + // going to loop and add our parent as a child of its grandparent + // and repeat until we get to the server, or a folder that + // has its parent set. + parentFolder->GetParent(getter_AddRefs(grandParent)); + parentFolder->GetIsServer(&isServer); + buffer.SetLength(lastSlash); + } while (!grandParent && !isServer); + } else if (dbFolderInfo && StringBeginsWith(buffer, "scope="_ns)) { + buffer.Cut(0, 6); + // if this is a cross folder virtual folder, we have a list of folders + // uris, and we have to add a pending listener for each of them. + if (!buffer.IsEmpty()) { + ParseAndVerifyVirtualFolderScope(buffer); + dbFolderInfo->SetCharProperty(kSearchFolderUriProp, buffer); + AddVFListenersForVF(virtualFolder, buffer); + } + } else if (dbFolderInfo && StringBeginsWith(buffer, "terms="_ns)) { + buffer.Cut(0, 6); + dbFolderInfo->SetCharProperty("searchStr", buffer); + } else if (dbFolderInfo && StringBeginsWith(buffer, "searchOnline="_ns)) { + buffer.Cut(0, 13); + dbFolderInfo->SetBooleanProperty("searchOnline", + buffer.EqualsLiteral("true")); + } else if (dbFolderInfo && + Substring(buffer, 0, SEARCH_FOLDER_FLAG_LEN + 1) + .Equals(SEARCH_FOLDER_FLAG "=")) { + buffer.Cut(0, SEARCH_FOLDER_FLAG_LEN + 1); + dbFolderInfo->SetCharProperty(SEARCH_FOLDER_FLAG, buffer); + } + } + } + + m_loadingVirtualFolders = false; + m_virtualFoldersLoaded = true; + return rv; +} + +NS_IMETHODIMP nsMsgAccountManager::SaveVirtualFolders() { + if (!m_virtualFoldersLoaded) return NS_OK; + + nsCOMPtr<nsIFile> file; + GetVirtualFoldersFile(file); + + // Open a buffered, safe output stream + nsCOMPtr<nsIOutputStream> outStream; + nsresult rv = MsgNewSafeBufferedFileOutputStream( + getter_AddRefs(outStream), file, PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE, + 0664); + NS_ENSURE_SUCCESS(rv, rv); + + WriteLineToOutputStream("version=", "1", outStream); + for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data(); + if (server) { + nsCOMPtr<nsIMsgFolder> rootFolder; + server->GetRootFolder(getter_AddRefs(rootFolder)); + if (rootFolder) { + nsTArray<RefPtr<nsIMsgFolder>> virtualFolders; + nsresult rv = rootFolder->GetFoldersWithFlags(nsMsgFolderFlags::Virtual, + virtualFolders); + if (NS_FAILED(rv)) { + continue; + } + for (auto msgFolder : virtualFolders) { + nsCOMPtr<nsIMsgDatabase> db; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + rv = msgFolder->GetDBFolderInfoAndDB( + getter_AddRefs(dbFolderInfo), + getter_AddRefs(db)); // force db to get created. + if (dbFolderInfo) { + nsCString srchFolderUri; + nsCString searchTerms; + nsCString regexScope; + nsCString vfFolderFlag; + bool searchOnline = false; + dbFolderInfo->GetBooleanProperty("searchOnline", false, + &searchOnline); + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, srchFolderUri); + dbFolderInfo->GetCharProperty("searchStr", searchTerms); + // logically searchFolderFlag is an int, but since we want to + // write out a string, get it as a string. + dbFolderInfo->GetCharProperty(SEARCH_FOLDER_FLAG, vfFolderFlag); + nsCString uri; + msgFolder->GetURI(uri); + if (!srchFolderUri.IsEmpty() && !searchTerms.IsEmpty()) { + WriteLineToOutputStream("uri=", uri.get(), outStream); + if (!vfFolderFlag.IsEmpty()) + WriteLineToOutputStream(SEARCH_FOLDER_FLAG "=", + vfFolderFlag.get(), outStream); + WriteLineToOutputStream("scope=", srchFolderUri.get(), outStream); + WriteLineToOutputStream("terms=", searchTerms.get(), outStream); + WriteLineToOutputStream( + "searchOnline=", searchOnline ? "true" : "false", outStream); + } + } + } + } + } + } + + nsCOMPtr<nsISafeOutputStream> safeStream = do_QueryInterface(outStream, &rv); + NS_ASSERTION(safeStream, "expected a safe output stream!"); + if (safeStream) { + rv = safeStream->Finish(); + if (NS_FAILED(rv)) { + NS_WARNING("failed to save personal dictionary file! possible data loss"); + } + } + return rv; +} + +nsresult nsMsgAccountManager::WriteLineToOutputStream( + const char* prefix, const char* line, nsIOutputStream* outputStream) { + uint32_t writeCount; + outputStream->Write(prefix, strlen(prefix), &writeCount); + outputStream->Write(line, strlen(line), &writeCount); + outputStream->Write("\n", 1, &writeCount); + return NS_OK; +} + +/** + * Parse the '|' separated folder uri string into individual folders, verify + * that the folders are real. If we were to add things like wildcards, we + * could implement the expansion into real folders here. + * + * @param buffer On input, list of folder uri's, on output, verified list. + */ +void nsMsgAccountManager::ParseAndVerifyVirtualFolderScope(nsCString& buffer) { + if (buffer.Equals("*")) { + // This is a special virtual folder that searches all folders in all + // accounts. Folders are chosen by the front end at search time. + return; + } + nsCString verifiedFolders; + nsTArray<nsCString> folderUris; + ParseString(buffer, '|', folderUris); + nsCOMPtr<nsIMsgIncomingServer> server; + nsCOMPtr<nsIMsgFolder> parent; + + for (uint32_t i = 0; i < folderUris.Length(); i++) { + nsCOMPtr<nsIMsgFolder> realFolder; + nsresult rv = GetOrCreateFolder(folderUris[i], getter_AddRefs(realFolder)); + if (!NS_SUCCEEDED(rv)) { + continue; + } + realFolder->GetParent(getter_AddRefs(parent)); + if (!parent) continue; + realFolder->GetServer(getter_AddRefs(server)); + if (!server) continue; + if (!verifiedFolders.IsEmpty()) verifiedFolders.Append('|'); + verifiedFolders.Append(folderUris[i]); + } + buffer.Assign(verifiedFolders); +} + +// This conveniently works to add a single folder as well. +nsresult nsMsgAccountManager::AddVFListenersForVF( + nsIMsgFolder* virtualFolder, const nsCString& srchFolderUris) { + if (srchFolderUris.Equals("*")) { + return NS_OK; + } + + nsresult rv; + if (!m_dbService) { + m_dbService = do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Avoid any possible duplicate listeners for this virtual folder. + RemoveVFListenerForVF(virtualFolder, nullptr); + + nsTArray<nsCString> folderUris; + ParseString(srchFolderUris, '|', folderUris); + + for (uint32_t i = 0; i < folderUris.Length(); i++) { + nsCOMPtr<nsIMsgFolder> realFolder; + rv = GetOrCreateFolder(folderUris[i], getter_AddRefs(realFolder)); + NS_ENSURE_SUCCESS(rv, rv); + RefPtr<VirtualFolderChangeListener> dbListener = + new VirtualFolderChangeListener(); + NS_ENSURE_TRUE(dbListener, NS_ERROR_OUT_OF_MEMORY); + dbListener->m_virtualFolder = virtualFolder; + dbListener->m_folderWatching = realFolder; + if (NS_FAILED(dbListener->Init())) { + dbListener = nullptr; + continue; + } + m_virtualFolderListeners.AppendElement(dbListener); + m_dbService->RegisterPendingListener(realFolder, dbListener); + } + if (!m_virtualFolders.Contains(virtualFolder)) { + m_virtualFolders.AppendElement(virtualFolder); + } + return NS_OK; +} + +// This is called if a folder that's part of the scope of a saved search +// has gone away. +nsresult nsMsgAccountManager::RemoveVFListenerForVF(nsIMsgFolder* virtualFolder, + nsIMsgFolder* folder) { + nsresult rv; + if (!m_dbService) { + m_dbService = do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + } + + nsTObserverArray<RefPtr<VirtualFolderChangeListener>>::ForwardIterator iter( + m_virtualFolderListeners); + RefPtr<VirtualFolderChangeListener> listener; + + while (iter.HasMore()) { + listener = iter.GetNext(); + if (listener->m_virtualFolder == virtualFolder && + (!folder || listener->m_folderWatching == folder)) { + m_dbService->UnregisterPendingListener(listener); + m_virtualFolderListeners.RemoveElement(listener); + if (folder) { + break; + } + } + } + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::GetAllFolders( + nsTArray<RefPtr<nsIMsgFolder>>& aAllFolders) { + aAllFolders.Clear(); + nsTArray<RefPtr<nsIMsgIncomingServer>> allServers; + nsresult rv = GetAllServers(allServers); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto server : allServers) { + if (server) { + nsCOMPtr<nsIMsgFolder> rootFolder; + server->GetRootFolder(getter_AddRefs(rootFolder)); + if (rootFolder) { + nsTArray<RefPtr<nsIMsgFolder>> descendents; + rootFolder->GetDescendants(descendents); + aAllFolders.AppendElements(descendents); + } + } + } + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderAdded(nsIMsgFolder* parent, + nsIMsgFolder* folder) { + if (!parent) { + // This method gets called for folders that aren't connected to anything, + // such as a junk folder that appears when an IMAP account is created. We + // don't want these added to the virtual folder. + return NS_OK; + } + + uint32_t folderFlags; + folder->GetFlags(&folderFlags); + + bool addToSmartFolders = false; + folder->IsSpecialFolder(nsMsgFolderFlags::Inbox | + nsMsgFolderFlags::Templates | + nsMsgFolderFlags::Trash | + nsMsgFolderFlags::Drafts | nsMsgFolderFlags::Junk, + false, &addToSmartFolders); + // For Sent/Archives/Trash, we treat sub-folders of those folders as + // "special", and want to add them the smart folders search scope. + // So we check if this is a sub-folder of one of those special folders + // and set the corresponding folderFlag if so. + if (!addToSmartFolders) { + bool isSpecial = false; + folder->IsSpecialFolder(nsMsgFolderFlags::SentMail, true, &isSpecial); + if (isSpecial) { + addToSmartFolders = true; + folderFlags |= nsMsgFolderFlags::SentMail; + } + folder->IsSpecialFolder(nsMsgFolderFlags::Archive, true, &isSpecial); + if (isSpecial) { + addToSmartFolders = true; + folderFlags |= nsMsgFolderFlags::Archive; + } + folder->IsSpecialFolder(nsMsgFolderFlags::Trash, true, &isSpecial); + if (isSpecial) { + addToSmartFolders = true; + folderFlags |= nsMsgFolderFlags::Trash; + } + } + nsresult rv = NS_OK; + // if this is a special folder, check if we have a saved search over + // folders with this flag, and if so, add this folder to the scope. + if (addToSmartFolders) { + // quick way to enumerate the saved searches. + for (nsCOMPtr<nsIMsgFolder> virtualFolder : m_virtualFolders) { + nsCOMPtr<nsIMsgDatabase> db; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(db)); + if (dbFolderInfo) { + uint32_t vfFolderFlag; + dbFolderInfo->GetUint32Property("searchFolderFlag", 0, &vfFolderFlag); + // found a saved search over folders w/ the same flag as the new folder. + if (vfFolderFlag & folderFlags) { + nsCString searchURI; + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI); + + // "normalize" searchURI so we can search for |folderURI|. + if (!searchURI.IsEmpty()) { + searchURI.Insert('|', 0); + searchURI.Append('|'); + } + nsCString folderURI; + folder->GetURI(folderURI); + folderURI.Insert('|', 0); + folderURI.Append('|'); + + int32_t index = searchURI.Find(folderURI); + if (index == kNotFound) { + searchURI.Cut(0, 1); + folderURI.Cut(0, 1); + folderURI.SetLength(folderURI.Length() - 1); + searchURI.Append(folderURI); + dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI); + nsCOMPtr<nsIObserverService> obs = + mozilla::services::GetObserverService(); + obs->NotifyObservers(virtualFolder, "search-folders-changed", + nullptr); + } + + // Add sub-folders to smart folder. + nsTArray<RefPtr<nsIMsgFolder>> allDescendants; + rv = folder->GetDescendants(allDescendants); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIMsgFolder> parentFolder; + for (auto subFolder : allDescendants) { + subFolder->GetParent(getter_AddRefs(parentFolder)); + OnFolderAdded(parentFolder, subFolder); + } + } + } + } + } + + // Find any virtual folders that search `parent`, and add `folder` to them. + if (!(folderFlags & nsMsgFolderFlags::Virtual)) { + nsTObserverArray<RefPtr<VirtualFolderChangeListener>>::ForwardIterator iter( + m_virtualFolderListeners); + RefPtr<VirtualFolderChangeListener> listener; + + while (iter.HasMore()) { + listener = iter.GetNext(); + if (listener->m_folderWatching == parent) { + nsCOMPtr<nsIMsgDatabase> db; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + listener->m_virtualFolder->GetDBFolderInfoAndDB( + getter_AddRefs(dbFolderInfo), getter_AddRefs(db)); + + uint32_t vfFolderFlag; + dbFolderInfo->GetUint32Property("searchFolderFlag", 0, &vfFolderFlag); + if (addToSmartFolders && vfFolderFlag && + !(vfFolderFlag & nsMsgFolderFlags::Trash)) { + // Don't add folders of one type to the unified folder of another + // type, unless it's the Trash unified folder. + continue; + } + nsCString searchURI; + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI); + + // "normalize" searchURI so we can search for |folderURI|. + if (!searchURI.IsEmpty()) { + searchURI.Insert('|', 0); + searchURI.Append('|'); + } + nsCString folderURI; + folder->GetURI(folderURI); + + int32_t index = searchURI.Find(folderURI); + if (index == kNotFound) { + searchURI.Cut(0, 1); + searchURI.Append(folderURI); + dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI); + nsCOMPtr<nsIObserverService> obs = + mozilla::services::GetObserverService(); + obs->NotifyObservers(listener->m_virtualFolder, + "search-folders-changed", nullptr); + } + } + } + } + + // need to make sure this isn't happening during loading of virtualfolders.dat + if (folderFlags & nsMsgFolderFlags::Virtual && !m_loadingVirtualFolders) { + // When a new virtual folder is added, need to create a db Listener for it. + nsCOMPtr<nsIMsgDatabase> virtDatabase; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + rv = folder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(virtDatabase)); + NS_ENSURE_SUCCESS(rv, rv); + nsCString srchFolderUri; + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, srchFolderUri); + AddVFListenersForVF(folder, srchFolderUri); + rv = SaveVirtualFolders(); + } + return rv; +} + +NS_IMETHODIMP nsMsgAccountManager::OnMessageAdded(nsIMsgFolder* parent, + nsIMsgDBHdr* msg) { + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderRemoved(nsIMsgFolder* parentFolder, + nsIMsgFolder* folder) { + nsresult rv = NS_OK; + uint32_t folderFlags; + folder->GetFlags(&folderFlags); + // if we removed a VF, flush VF list to disk. + if (folderFlags & nsMsgFolderFlags::Virtual) { + RemoveVFListenerForVF(folder, nullptr); + m_virtualFolders.RemoveElement(folder); + rv = SaveVirtualFolders(); + // clear flags on deleted folder if it's a virtual folder, so that creating + // a new folder with the same name doesn't cause confusion. + folder->SetFlags(0); + return rv; + } + // need to update the saved searches to check for a few things: + // 1. Folder removed was in the scope of a saved search - if so, remove the + // uri from the scope of the saved search. + // 2. If the scope is now empty, remove the saved search. + + // build a "normalized" uri that we can do a find on. + nsCString removedFolderURI; + folder->GetURI(removedFolderURI); + removedFolderURI.Insert('|', 0); + removedFolderURI.Append('|'); + + // Enumerate the saved searches. + nsTObserverArray<RefPtr<VirtualFolderChangeListener>>::ForwardIterator iter( + m_virtualFolderListeners); + RefPtr<VirtualFolderChangeListener> listener; + + while (iter.HasMore()) { + listener = iter.GetNext(); + nsCOMPtr<nsIMsgDatabase> db; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + nsCOMPtr<nsIMsgFolder> savedSearch = listener->m_virtualFolder; + savedSearch->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(db)); + if (dbFolderInfo) { + nsCString searchURI; + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI); + // "normalize" searchURI so we can search for |folderURI|. + searchURI.Insert('|', 0); + searchURI.Append('|'); + int32_t index = searchURI.Find(removedFolderURI); + if (index != kNotFound) { + RemoveVFListenerForVF(savedSearch, folder); + + // remove |folderURI + searchURI.Cut(index, removedFolderURI.Length() - 1); + // remove last '|' we added + searchURI.SetLength(searchURI.Length() - 1); + + uint32_t vfFolderFlag; + dbFolderInfo->GetUint32Property("searchFolderFlag", 0, &vfFolderFlag); + + // If saved search is empty now, delete it. But not if it's a smart + // folder. + if (searchURI.IsEmpty() && !vfFolderFlag) { + db = nullptr; + dbFolderInfo = nullptr; + + nsCOMPtr<nsIMsgFolder> parent; + rv = savedSearch->GetParent(getter_AddRefs(parent)); + NS_ENSURE_SUCCESS(rv, rv); + + if (!parent) continue; + parent->PropagateDelete(savedSearch, true); + } else { + if (!searchURI.IsEmpty()) { + // Remove leading '|' we added (or one after |folderURI, if first + // URI). + searchURI.Cut(0, 1); + } + dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI); + nsCOMPtr<nsIObserverService> obs = + mozilla::services::GetObserverService(); + obs->NotifyObservers(savedSearch, "search-folders-changed", nullptr); + } + } + } + } + + return rv; +} + +NS_IMETHODIMP nsMsgAccountManager::OnMessageRemoved(nsIMsgFolder* parent, + nsIMsgDBHdr* msg) { + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderPropertyChanged( + nsIMsgFolder* folder, const nsACString& property, + const nsACString& oldValue, const nsACString& newValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsMsgAccountManager::OnFolderIntPropertyChanged(nsIMsgFolder* aFolder, + const nsACString& aProperty, + int64_t oldValue, + int64_t newValue) { + if (aProperty.Equals(kFolderFlag)) { + if (newValue & nsMsgFolderFlags::Virtual) { + // This is a virtual folder, let's get out of here. + return NS_OK; + } + uint32_t smartFlagsChanged = + (oldValue ^ newValue) & + (nsMsgFolderFlags::SpecialUse & ~nsMsgFolderFlags::Queue); + if (smartFlagsChanged) { + if (smartFlagsChanged & newValue) { + // if the smart folder flag was set, calling OnFolderAdded will + // do the right thing. + nsCOMPtr<nsIMsgFolder> parent; + aFolder->GetParent(getter_AddRefs(parent)); + nsresult rv = OnFolderAdded(parent, aFolder); + NS_ENSURE_SUCCESS(rv, rv); + + // This folder has one of the smart folder flags. + // Remove it from any other smart folders it might've been included in + // because of the flags of its ancestors. + RemoveFolderFromSmartFolder( + aFolder, (nsMsgFolderFlags::SpecialUse & ~nsMsgFolderFlags::Queue) & + ~newValue); + return NS_OK; + } + RemoveFolderFromSmartFolder(aFolder, smartFlagsChanged); + + nsTArray<RefPtr<nsIMsgFolder>> allDescendants; + nsresult rv = aFolder->GetDescendants(allDescendants); + NS_ENSURE_SUCCESS(rv, rv); + for (auto subFolder : allDescendants) { + RemoveFolderFromSmartFolder(subFolder, smartFlagsChanged); + } + } + } + return NS_OK; +} + +nsresult nsMsgAccountManager::RemoveFolderFromSmartFolder( + nsIMsgFolder* aFolder, uint32_t flagsChanged) { + nsCString removedFolderURI; + aFolder->GetURI(removedFolderURI); + removedFolderURI.Insert('|', 0); + removedFolderURI.Append('|'); + uint32_t flags; + aFolder->GetFlags(&flags); + NS_ASSERTION(!(flags & flagsChanged), "smart folder flag should not be set"); + // Flag was removed. Look for smart folder based on that flag, + // and remove this folder from its scope. + for (nsCOMPtr<nsIMsgFolder> virtualFolder : m_virtualFolders) { + nsCOMPtr<nsIMsgDatabase> db; + nsCOMPtr<nsIDBFolderInfo> dbFolderInfo; + virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), + getter_AddRefs(db)); + if (dbFolderInfo) { + uint32_t vfFolderFlag; + dbFolderInfo->GetUint32Property("searchFolderFlag", 0, &vfFolderFlag); + // found a smart folder over the removed flag + if (vfFolderFlag & flagsChanged) { + nsCString searchURI; + dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI); + // "normalize" searchURI so we can search for |folderURI|. + searchURI.Insert('|', 0); + searchURI.Append('|'); + int32_t index = searchURI.Find(removedFolderURI); + if (index != kNotFound) { + RemoveVFListenerForVF(virtualFolder, aFolder); + + // remove |folderURI + searchURI.Cut(index, removedFolderURI.Length() - 1); + // remove last '|' we added + searchURI.SetLength(searchURI.Length() - 1); + + // remove leading '|' we added (or one after |folderURI, if first URI) + searchURI.Cut(0, 1); + dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI); + nsCOMPtr<nsIObserverService> obs = + mozilla::services::GetObserverService(); + obs->NotifyObservers(virtualFolder, "search-folders-changed", + nullptr); + } + } + } + } + return NS_OK; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderBoolPropertyChanged( + nsIMsgFolder* folder, const nsACString& property, bool oldValue, + bool newValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderUnicharPropertyChanged( + nsIMsgFolder* folder, const nsACString& property, const nsAString& oldValue, + const nsAString& newValue) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderPropertyFlagChanged( + nsIMsgDBHdr* msg, const nsACString& property, uint32_t oldFlag, + uint32_t newFlag) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsMsgAccountManager::OnFolderEvent(nsIMsgFolder* aFolder, + const nsACString& aEvent) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsMsgAccountManager::FolderUriForPath(nsIFile* aLocalPath, + nsACString& aMailboxUri) { + NS_ENSURE_ARG_POINTER(aLocalPath); + bool equals; + if (m_lastPathLookedUp && + NS_SUCCEEDED(aLocalPath->Equals(m_lastPathLookedUp, &equals)) && equals) { + aMailboxUri = m_lastFolderURIForPath; + return NS_OK; + } + nsTArray<RefPtr<nsIMsgFolder>> folders; + nsresult rv = GetAllFolders(folders); + NS_ENSURE_SUCCESS(rv, rv); + + for (auto folder : folders) { + nsCOMPtr<nsIFile> folderPath; + rv = folder->GetFilePath(getter_AddRefs(folderPath)); + NS_ENSURE_SUCCESS(rv, rv); + + // Check if we're equal + rv = folderPath->Equals(aLocalPath, &equals); + NS_ENSURE_SUCCESS(rv, rv); + + if (equals) { + rv = folder->GetURI(aMailboxUri); + m_lastFolderURIForPath = aMailboxUri; + aLocalPath->Clone(getter_AddRefs(m_lastPathLookedUp)); + return rv; + } + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsMsgAccountManager::GetSortOrder(nsIMsgIncomingServer* aServer, + int32_t* aSortOrder) { + NS_ENSURE_ARG_POINTER(aServer); + NS_ENSURE_ARG_POINTER(aSortOrder); + + // If the passed in server is the default, return its sort order as 0 + // regardless of its server sort order. + + nsCOMPtr<nsIMsgAccount> defaultAccount; + nsresult rv = GetDefaultAccount(getter_AddRefs(defaultAccount)); + if (NS_SUCCEEDED(rv) && defaultAccount) { + nsCOMPtr<nsIMsgIncomingServer> defaultServer; + rv = m_defaultAccount->GetIncomingServer(getter_AddRefs(defaultServer)); + if (NS_SUCCEEDED(rv) && (aServer == defaultServer)) { + *aSortOrder = 0; + return NS_OK; + } + // It is OK if there is no default account. + } + + // This function returns the sort order by querying the server object for its + // sort order value and then incrementing it by the position of the server in + // the accounts list. This ensures that even when several accounts have the + // same sort order value, the returned value is not the same and keeps + // their relative order in the account list when and unstable sort is run + // on the returned sort order values. + int32_t sortOrder; + int32_t serverIndex; + + rv = aServer->GetSortOrder(&sortOrder); + if (NS_SUCCEEDED(rv)) rv = FindServerIndex(aServer, &serverIndex); + + if (NS_FAILED(rv)) { + *aSortOrder = 999999999; + } else { + *aSortOrder = sortOrder + serverIndex; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsMsgAccountManager::ReorderAccounts(const nsTArray<nsCString>& newAccounts) { + nsTArray<nsCString> allNewAccounts = newAccounts.Clone(); + + // Add all hidden accounts to the list of new accounts. + nsresult rv; + for (auto account : m_accounts) { + nsCString key; + account->GetKey(key); + nsCOMPtr<nsIMsgIncomingServer> server; + rv = account->GetIncomingServer(getter_AddRefs(server)); + if (NS_SUCCEEDED(rv) && server) { + bool hidden = false; + rv = server->GetHidden(&hidden); + if (NS_SUCCEEDED(rv) && hidden && !allNewAccounts.Contains(key)) { + allNewAccounts.AppendElement(key); + } + } + } + + // Check that the new account list contains all the existing accounts, + // just in a different order. + if (allNewAccounts.Length() != m_accounts.Length()) + return NS_ERROR_INVALID_ARG; + + for (uint32_t i = 0; i < m_accounts.Length(); i++) { + nsCString accountKey; + m_accounts[i]->GetKey(accountKey); + if (!allNewAccounts.Contains(accountKey)) return NS_ERROR_INVALID_ARG; + } + + // In-place swap the elements in m_accounts to the order defined in + // newAccounts. + for (uint32_t i = 0; i < allNewAccounts.Length(); i++) { + nsCString newKey = allNewAccounts[i]; + for (uint32_t j = i; j < m_accounts.Length(); j++) { + nsCString oldKey; + m_accounts[j]->GetKey(oldKey); + if (newKey.Equals(oldKey)) { + if (i != j) std::swap(m_accounts[i], m_accounts[j]); + break; + } + } + } + + return OutputAccountsPref(); +} |