diff options
Diffstat (limited to 'comm/mailnews/imap/src/nsImapHostSessionList.cpp')
| -rw-r--r-- | comm/mailnews/imap/src/nsImapHostSessionList.cpp | 595 |
1 files changed, 595 insertions, 0 deletions
diff --git a/comm/mailnews/imap/src/nsImapHostSessionList.cpp b/comm/mailnews/imap/src/nsImapHostSessionList.cpp new file mode 100644 index 0000000000..fbdbeac231 --- /dev/null +++ b/comm/mailnews/imap/src/nsImapHostSessionList.cpp @@ -0,0 +1,595 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "msgCore.h" +#include "nsImapHostSessionList.h" +#include "nsImapNamespace.h" +#include "nsIImapIncomingServer.h" +#include "nsCOMPtr.h" +#include "nsIMsgIncomingServer.h" +#include "nsIObserverService.h" +#include "nsServiceManagerUtils.h" +#include "nsMsgUtils.h" +#include "mozilla/Services.h" + +nsIMAPHostInfo::nsIMAPHostInfo(const char* serverKey, + nsIImapIncomingServer* server) { + fServerKey = serverKey; + NS_ASSERTION(server, "*** Fatal null imap incoming server..."); + server->GetServerDirectory(fOnlineDir); + fNextHost = NULL; + fCapabilityFlags = kCapabilityUndefined; + fHierarchyDelimiters = NULL; +#ifdef DEBUG_bienvenu1 + fHaveWeEverDiscoveredFolders = + true; // try this, see what bad happens - we'll need to + // figure out a way to make new accounts have it be false +#else + fHaveWeEverDiscoveredFolders = false; // try this, see what bad happens +#endif + fDiscoveryForHostInProgress = false; + fCanonicalOnlineSubDir = NULL; + fNamespaceList = nsImapNamespaceList::CreatensImapNamespaceList(); + fUsingSubscription = true; + server->GetUsingSubscription(&fUsingSubscription); + fOnlineTrashFolderExists = false; + fShouldAlwaysListInbox = true; + fPasswordVerifiedOnline = false; + fDeleteIsMoveToTrash = true; + fShowDeletedMessages = false; + fGotNamespaces = false; + fHaveAdminURL = false; + fNamespacesOverridable = true; + server->GetOverrideNamespaces(&fNamespacesOverridable); + fTempNamespaceList = nsImapNamespaceList::CreatensImapNamespaceList(); +} + +nsIMAPHostInfo::~nsIMAPHostInfo() { + PR_Free(fHierarchyDelimiters); + delete fNamespaceList; + delete fTempNamespaceList; +} + +NS_IMPL_ISUPPORTS(nsImapHostSessionList, nsIImapHostSessionList, nsIObserver, + nsISupportsWeakReference) + +nsImapHostSessionList::nsImapHostSessionList() { + gCachedHostInfoMonitor = PR_NewMonitor(/* "accessing-hostlist-monitor"*/); + fHostInfoList = nullptr; +} + +nsImapHostSessionList::~nsImapHostSessionList() { + ResetAll(); + PR_DestroyMonitor(gCachedHostInfoMonitor); +} + +nsresult nsImapHostSessionList::Init() { + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED); + observerService->AddObserver(this, "profile-before-change", true); + observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true); + return NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* someData) { + if (!strcmp(aTopic, "profile-before-change")) + ResetAll(); + else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED); + observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + observerService->RemoveObserver(this, "profile-before-change"); + } + return NS_OK; +} + +nsIMAPHostInfo* nsImapHostSessionList::FindHost(const char* serverKey) { + nsIMAPHostInfo* host; + + // ### should also check userName here, if NON NULL + for (host = fHostInfoList; host; host = host->fNextHost) { + if (host->fServerKey.Equals(serverKey, nsCaseInsensitiveCStringComparator)) + return host; + } + return host; +} + +// reset any cached connection info - delete the lot of 'em +NS_IMETHODIMP nsImapHostSessionList::ResetAll() { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* nextHost = NULL; + for (nsIMAPHostInfo* host = fHostInfoList; host; host = nextHost) { + nextHost = host->fNextHost; + delete host; + } + fHostInfoList = NULL; + PR_ExitMonitor(gCachedHostInfoMonitor); + return NS_OK; +} + +NS_IMETHODIMP +nsImapHostSessionList::AddHostToList(const char* serverKey, + nsIImapIncomingServer* server) { + nsIMAPHostInfo* newHost = NULL; + PR_EnterMonitor(gCachedHostInfoMonitor); + if (!FindHost(serverKey)) { + // stick it on the front + newHost = new nsIMAPHostInfo(serverKey, server); + if (newHost) { + newHost->fNextHost = fHostInfoList; + fHostInfoList = newHost; + } + } + PR_ExitMonitor(gCachedHostInfoMonitor); + return (newHost == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetPasswordForHost(const char* serverKey, + nsString& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fCachedPassword; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetPasswordForHost( + const char* serverKey, const nsAString& password) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fCachedPassword = password; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetPasswordVerifiedOnline( + const char* serverKey) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fPasswordVerifiedOnline = true; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetPasswordVerifiedOnline( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fPasswordVerifiedOnline; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetOnlineDirForHost(const char* serverKey, + nsString& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) CopyASCIItoUTF16(host->fOnlineDir, result); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetOnlineDirForHost( + const char* serverKey, const char* onlineDir) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) { + if (onlineDir) host->fOnlineDir = onlineDir; + } + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetDeleteIsMoveToTrashForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fDeleteIsMoveToTrash; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetShowDeletedMessagesForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fShowDeletedMessages; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetDeleteIsMoveToTrashForHost( + const char* serverKey, bool isMoveToTrash) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fDeleteIsMoveToTrash = isMoveToTrash; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetShowDeletedMessagesForHost( + const char* serverKey, bool showDeletedMessages) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fShowDeletedMessages = showDeletedMessages; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetGotNamespacesForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fGotNamespaces; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetGotNamespacesForHost( + const char* serverKey, bool gotNamespaces) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fGotNamespaces = gotNamespaces; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetHostIsUsingSubscription( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fUsingSubscription; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetHostIsUsingSubscription( + const char* serverKey, bool usingSubscription) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fUsingSubscription = usingSubscription; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetHostHasAdminURL(const char* serverKey, + bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fHaveAdminURL; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetHostHasAdminURL(const char* serverKey, + bool haveAdminURL) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fHaveAdminURL = haveAdminURL; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetHaveWeEverDiscoveredFoldersForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fHaveWeEverDiscoveredFolders; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetHaveWeEverDiscoveredFoldersForHost( + const char* serverKey, bool discovered) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fHaveWeEverDiscoveredFolders = discovered; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetDiscoveryForHostInProgress( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) + result = host->fDiscoveryForHostInProgress; + else + result = false; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetDiscoveryForHostInProgress( + const char* serverKey, bool inProgress) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fDiscoveryForHostInProgress = inProgress; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetOnlineTrashFolderExistsForHost( + const char* serverKey, bool exists) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fOnlineTrashFolderExists = exists; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetOnlineTrashFolderExistsForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fOnlineTrashFolderExists; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::AddNewNamespaceForHost( + const char* serverKey, nsImapNamespace* ns) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fNamespaceList->AddNewNamespace(ns); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetNamespaceFromPrefForHost( + const char* serverKey, const char* namespacePref, + EIMAPNamespaceType nstype) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) { + if (namespacePref) { + int numNamespaces = host->fNamespaceList->UnserializeNamespaces( + namespacePref, nullptr, 0); + char** prefixes = (char**)PR_CALLOC(numNamespaces * sizeof(char*)); + if (prefixes) { + int len = host->fNamespaceList->UnserializeNamespaces( + namespacePref, prefixes, numNamespaces); + for (int i = 0; i < len; i++) { + char* thisns = prefixes[i]; + char delimiter = '/'; // a guess + if (PL_strlen(thisns) >= 1) delimiter = thisns[PL_strlen(thisns) - 1]; + nsImapNamespace* ns = + new nsImapNamespace(nstype, thisns, delimiter, true); + if (ns) host->fNamespaceList->AddNewNamespace(ns); + PR_FREEIF(thisns); + } + PR_Free(prefixes); + } + } + } + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetNamespaceForMailboxForHost( + const char* serverKey, const char* mailbox_name, nsImapNamespace*& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fNamespaceList->GetNamespaceForMailbox(mailbox_name); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::ClearPrefsNamespacesForHost( + const char* serverKey) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fNamespaceList->ClearNamespaces(true, false, true); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::ClearServerAdvertisedNamespacesForHost( + const char* serverKey) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fNamespaceList->ClearNamespaces(false, true, true); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetDefaultNamespaceOfTypeForHost( + const char* serverKey, EIMAPNamespaceType type, nsImapNamespace*& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fNamespaceList->GetDefaultNamespaceOfType(type); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetNamespacesOverridableForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fNamespacesOverridable; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetNamespacesOverridableForHost( + const char* serverKey, bool overridable) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fNamespacesOverridable = overridable; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetNumberOfNamespacesForHost( + const char* serverKey, uint32_t& result) { + int32_t intResult = 0; + + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) intResult = host->fNamespaceList->GetNumberOfNamespaces(); + PR_ExitMonitor(gCachedHostInfoMonitor); + NS_ASSERTION(intResult >= 0, "negative number of namespaces"); + result = (uint32_t)intResult; + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetNamespaceNumberForHost( + const char* serverKey, int32_t n, nsImapNamespace*& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) result = host->fNamespaceList->GetNamespaceNumber(n); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +nsresult nsImapHostSessionList::SetNamespacesPrefForHost( + nsIImapIncomingServer* aHost, EIMAPNamespaceType type, const char* pref) { + if (type == kPersonalNamespace) + aHost->SetPersonalNamespace(nsDependentCString(pref)); + else if (type == kPublicNamespace) + aHost->SetPublicNamespace(nsDependentCString(pref)); + else if (type == kOtherUsersNamespace) + aHost->SetOtherUsersNamespace(nsDependentCString(pref)); + else + NS_ASSERTION(false, "bogus namespace type"); + return NS_OK; +} +// do we need this? What should we do about the master thing? +// Make sure this is running in the Mozilla thread when called +NS_IMETHODIMP nsImapHostSessionList::CommitNamespacesForHost( + nsIImapIncomingServer* aHost) { + NS_ENSURE_ARG_POINTER(aHost); + nsCString serverKey; + nsCOMPtr<nsIMsgIncomingServer> incomingServer = do_QueryInterface(aHost); + if (!incomingServer) return NS_ERROR_NULL_POINTER; + + nsresult rv = incomingServer->GetKey(serverKey); + NS_ENSURE_SUCCESS(rv, rv); + + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey.get()); + if (host) { + host->fGotNamespaces = + true; // so we only issue NAMESPACE once per host per session. + EIMAPNamespaceType type = kPersonalNamespace; + for (int i = 1; i <= 3; i++) { + switch (i) { + case 1: + type = kPersonalNamespace; + break; + case 2: + type = kPublicNamespace; + break; + case 3: + type = kOtherUsersNamespace; + break; + default: + type = kPersonalNamespace; + break; + } + + int32_t numInNS = host->fNamespaceList->GetNumberOfNamespaces(type); + if (numInNS == 0) + SetNamespacesPrefForHost(aHost, type, ""); + else if (numInNS >= 1) { + char* pref = PR_smprintf(""); + for (int count = 1; count <= numInNS; count++) { + nsImapNamespace* ns = + host->fNamespaceList->GetNamespaceNumber(count, type); + if (ns) { + if (count > 1) { + // append the comma + char* tempPref = PR_smprintf("%s,", pref); + PR_FREEIF(pref); + pref = tempPref; + } + char* tempPref = PR_smprintf("%s\"%s\"", pref, ns->GetPrefix()); + PR_FREEIF(pref); + pref = tempPref; + } + } + if (pref) { + SetNamespacesPrefForHost(aHost, type, pref); + PR_Free(pref); + } + } + } + // clear, but don't delete the entries in, the temp namespace list + host->fTempNamespaceList->ClearNamespaces(true, true, false); + + // Now reset all of libmsg's namespace references. + // Did I mention this needs to be running in the mozilla thread? + aHost->ResetNamespaceReferences(); + } + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::FlushUncommittedNamespacesForHost( + const char* serverKey, bool& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fTempNamespaceList->ClearNamespaces(true, true, true); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +// Returns NULL if there is no personal namespace on the given host +NS_IMETHODIMP nsImapHostSessionList::GetOnlineInboxPathForHost( + const char* serverKey, nsString& result) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) { + nsImapNamespace* ns = NULL; + ns = host->fNamespaceList->GetDefaultNamespaceOfType(kPersonalNamespace); + if (ns) { + CopyASCIItoUTF16(nsDependentCString(ns->GetPrefix()), result); + result.AppendLiteral("INBOX"); + } + } else + result.Truncate(); + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::GetShouldAlwaysListInboxForHost( + const char* /*serverKey*/, bool& result) { + result = true; + + /* + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo *host = FindHost(serverKey); + if (host) + ret = host->fShouldAlwaysListInbox; + PR_ExitMonitor(gCachedHostInfoMonitor); + */ + return NS_OK; +} + +NS_IMETHODIMP nsImapHostSessionList::SetShouldAlwaysListInboxForHost( + const char* serverKey, bool shouldList) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) host->fShouldAlwaysListInbox = shouldList; + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; +} + +NS_IMETHODIMP +nsImapHostSessionList::SetNamespaceHierarchyDelimiterFromMailboxForHost( + const char* serverKey, const char* boxName, char delimiter) { + PR_EnterMonitor(gCachedHostInfoMonitor); + nsIMAPHostInfo* host = FindHost(serverKey); + if (host) { + nsImapNamespace* ns = host->fNamespaceList->GetNamespaceForMailbox(boxName); + if (ns && !ns->GetIsDelimiterFilledIn()) ns->SetDelimiter(delimiter, true); + } + PR_ExitMonitor(gCachedHostInfoMonitor); + return (host) ? NS_OK : NS_ERROR_ILLEGAL_VALUE; +} |