diff options
Diffstat (limited to 'mailnews/news/src/nsNntpIncomingServer.cpp')
-rw-r--r-- | mailnews/news/src/nsNntpIncomingServer.cpp | 2162 |
1 files changed, 2162 insertions, 0 deletions
diff --git a/mailnews/news/src/nsNntpIncomingServer.cpp b/mailnews/news/src/nsNntpIncomingServer.cpp new file mode 100644 index 0000000000..7c3fcad4be --- /dev/null +++ b/mailnews/news/src/nsNntpIncomingServer.cpp @@ -0,0 +1,2162 @@ +/* -*- 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 "nsNntpIncomingServer.h" +#include "nsIPrefBranch.h" +#include "nsIPrefService.h" +#include "nsNewsFolder.h" +#include "nsIMsgFolder.h" +#include "nsIFile.h" +#include "nsCOMPtr.h" +#include "nsINntpService.h" +#include "nsINNTPProtocol.h" +#include "nsMsgNewsCID.h" +#include "nsNNTPProtocol.h" +#include "nsIDirectoryService.h" +#include "nsMailDirServiceDefs.h" +#include "nsMsgUtils.h" +#include "nsIPrompt.h" +#include "nsIStringBundle.h" +#include "nntpCore.h" +#include "nsIWindowWatcher.h" +#include "nsITreeColumns.h" +#include "nsIDOMElement.h" +#include "nsMsgFolderFlags.h" +#include "nsMsgI18N.h" +#include "nsUnicharUtils.h" +#include "nsILineInputStream.h" +#include "nsNetUtil.h" +#include "nsISimpleEnumerator.h" +#include "nsMsgUtils.h" +#include "mozilla/Services.h" +#include "nsITreeBoxObject.h" + +#define INVALID_VERSION 0 +#define VALID_VERSION 2 +#define NEW_NEWS_DIR_NAME "News" +#define PREF_MAIL_NEWSRC_ROOT "mail.newsrc_root" +#define PREF_MAIL_NEWSRC_ROOT_REL "mail.newsrc_root-rel" +#define PREF_MAILNEWS_VIEW_DEFAULT_CHARSET "mailnews.view_default_charset" +#define HOSTINFO_FILE_NAME "hostinfo.dat" + +#define NEWS_DELIMITER '.' + +// this platform specific junk is so the newsrc filenames we create +// will resemble the migrated newsrc filenames. +#if defined(XP_UNIX) +#define NEWSRC_FILE_PREFIX "newsrc-" +#define NEWSRC_FILE_SUFFIX "" +#else +#define NEWSRC_FILE_PREFIX "" +#define NEWSRC_FILE_SUFFIX ".rc" +#endif /* XP_UNIX */ + +// ###tw This really ought to be the most +// efficient file reading size for the current +// operating system. +#define HOSTINFO_FILE_BUFFER_SIZE 1024 + +#include "nsMsgUtils.h" + +/** + * A comparator class to do cases insensitive comparisons for nsTArray.Sort() + */ +class nsCStringLowerCaseComparator +{ +public: + bool Equals(const nsCString &a, const nsCString &b) const + { + return a.Equals(b, nsCaseInsensitiveCStringComparator()); + } + + bool LessThan(const nsCString &a, const nsCString &b) const + { + return Compare(a, b, nsCaseInsensitiveCStringComparator()) < 0; + } +}; + +static NS_DEFINE_CID(kSubscribableServerCID, NS_SUBSCRIBABLESERVER_CID); + +NS_IMPL_ADDREF_INHERITED(nsNntpIncomingServer, nsMsgIncomingServer) +NS_IMPL_RELEASE_INHERITED(nsNntpIncomingServer, nsMsgIncomingServer) + +NS_INTERFACE_MAP_BEGIN(nsNntpIncomingServer) + NS_INTERFACE_MAP_ENTRY(nsINntpIncomingServer) + NS_INTERFACE_MAP_ENTRY(nsIUrlListener) + NS_INTERFACE_MAP_ENTRY(nsISubscribableServer) + NS_INTERFACE_MAP_ENTRY(nsITreeView) +NS_INTERFACE_MAP_END_INHERITING(nsMsgIncomingServer) + +nsNntpIncomingServer::nsNntpIncomingServer() +{ + mNewsrcHasChanged = false; + + mGetOnlyNew = true; + + mHostInfoLoaded = false; + mHostInfoHasChanged = false; + mVersion = INVALID_VERSION; + + mLastGroupDate = 0; + mUniqueId = 0; + mHasSeenBeginGroups = false; + mPostingAllowed = false; + mLastUpdatedTime = 0; + + // these atoms are used for subscribe search + mSubscribedAtom = MsgGetAtom("subscribed"); + mNntpAtom = MsgGetAtom("nntp"); + + // we have server wide and per group filters + m_canHaveFilters = true; + + SetupNewsrcSaveTimer(); +} + +nsNntpIncomingServer::~nsNntpIncomingServer() +{ + mozilla::DebugOnly<nsresult> rv; + + if (mNewsrcSaveTimer) { + mNewsrcSaveTimer->Cancel(); + mNewsrcSaveTimer = nullptr; + } + rv = ClearInner(); + NS_ASSERTION(NS_SUCCEEDED(rv), "ClearInner failed"); + + rv = CloseCachedConnections(); + NS_ASSERTION(NS_SUCCEEDED(rv), "CloseCachedConnections failed"); +} + +NS_IMPL_SERVERPREF_BOOL(nsNntpIncomingServer, NotifyOn, "notify.on") +NS_IMPL_SERVERPREF_BOOL(nsNntpIncomingServer, MarkOldRead, "mark_old_read") +NS_IMPL_SERVERPREF_BOOL(nsNntpIncomingServer, Abbreviate, "abbreviate") +NS_IMPL_SERVERPREF_BOOL(nsNntpIncomingServer, PushAuth, "always_authenticate") +NS_IMPL_SERVERPREF_BOOL(nsNntpIncomingServer, SingleSignon, "singleSignon") +NS_IMPL_SERVERPREF_INT(nsNntpIncomingServer, MaxArticles, "max_articles") + +nsresult +nsNntpIncomingServer::CreateRootFolderFromUri(const nsCString &serverUri, + nsIMsgFolder **rootFolder) +{ + nsMsgNewsFolder *newRootFolder = new nsMsgNewsFolder; + if (!newRootFolder) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(*rootFolder = newRootFolder); + newRootFolder->Init(serverUri.get()); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetNewsrcFilePath(nsIFile **aNewsrcFilePath) +{ + nsresult rv; + if (mNewsrcFilePath) + { + *aNewsrcFilePath = mNewsrcFilePath; + NS_IF_ADDREF(*aNewsrcFilePath); + return NS_OK; + } + + rv = GetFileValue("newsrc.file-rel", "newsrc.file", aNewsrcFilePath); + if (NS_SUCCEEDED(rv) && *aNewsrcFilePath) + { + mNewsrcFilePath = *aNewsrcFilePath; + return rv; + } + + rv = GetNewsrcRootPath(getter_AddRefs(mNewsrcFilePath)); + if (NS_FAILED(rv)) return rv; + + nsCString hostname; + rv = GetHostName(hostname); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString newsrcFileName(NEWSRC_FILE_PREFIX); + newsrcFileName.Append(hostname); + newsrcFileName.Append(NEWSRC_FILE_SUFFIX); + rv = mNewsrcFilePath->AppendNative(newsrcFileName); + rv = mNewsrcFilePath->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0644); + NS_ENSURE_SUCCESS(rv, rv); + + rv = SetNewsrcFilePath(mNewsrcFilePath); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ADDREF(*aNewsrcFilePath = mNewsrcFilePath); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetNewsrcFilePath(nsIFile *aFile) +{ + NS_ENSURE_ARG_POINTER(aFile); + + bool exists; + nsresult rv = aFile->Exists(&exists); + if (!exists) + { + rv = aFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0664); + if (NS_FAILED(rv)) return rv; + } + return SetFileValue("newsrc.file-rel", "newsrc.file", aFile); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetLocalStoreType(nsACString& type) +{ + type.AssignLiteral("news"); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetLocalDatabaseType(nsACString& type) +{ + type.AssignLiteral("news"); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetNewsrcRootPath(nsIFile *aNewsrcRootPath) +{ + NS_ENSURE_ARG(aNewsrcRootPath); + return NS_SetPersistentFile(PREF_MAIL_NEWSRC_ROOT_REL, PREF_MAIL_NEWSRC_ROOT, aNewsrcRootPath); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetNewsrcRootPath(nsIFile **aNewsrcRootPath) +{ + NS_ENSURE_ARG_POINTER(aNewsrcRootPath); + *aNewsrcRootPath = nullptr; + + bool havePref; + nsresult rv = NS_GetPersistentFile(PREF_MAIL_NEWSRC_ROOT_REL, + PREF_MAIL_NEWSRC_ROOT, + NS_APP_NEWS_50_DIR, + havePref, + aNewsrcRootPath); + + NS_ENSURE_SUCCESS(rv, rv); + + bool exists; + rv = (*aNewsrcRootPath)->Exists(&exists); + if (NS_SUCCEEDED(rv) && !exists) + rv = (*aNewsrcRootPath)->Create(nsIFile::DIRECTORY_TYPE, 0775); + NS_ENSURE_SUCCESS(rv, rv); + + if (!havePref || !exists) + { + rv = NS_SetPersistentFile(PREF_MAIL_NEWSRC_ROOT_REL, PREF_MAIL_NEWSRC_ROOT, *aNewsrcRootPath); + NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to set root dir pref."); + } + return rv; +} + +/* static */ void nsNntpIncomingServer::OnNewsrcSaveTimer(nsITimer *timer, void *voidIncomingServer) +{ + nsNntpIncomingServer *incomingServer = (nsNntpIncomingServer*)voidIncomingServer; + incomingServer->WriteNewsrcFile(); +} + +nsresult nsNntpIncomingServer::SetupNewsrcSaveTimer() +{ + int64_t ms(300000); // hard code, 5 minutes. + //Convert biffDelay into milliseconds + uint32_t timeInMSUint32 = (uint32_t)ms; + //Can't currently reset a timer when it's in the process of + //calling Notify. So, just release the timer here and create a new one. + if(mNewsrcSaveTimer) + mNewsrcSaveTimer->Cancel(); + mNewsrcSaveTimer = do_CreateInstance("@mozilla.org/timer;1"); + mNewsrcSaveTimer->InitWithFuncCallback(OnNewsrcSaveTimer, (void*)this, timeInMSUint32, + nsITimer::TYPE_REPEATING_SLACK); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetCharset(const nsACString & aCharset) +{ + return SetCharValue("charset", aCharset); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCharset(nsACString & aCharset) +{ + //first we get the per-server settings mail.server.<serverkey>.charset + nsresult rv = GetCharValue("charset", aCharset); + NS_ENSURE_SUCCESS(rv, rv); + + //if the per-server setting is empty,we get the default charset from + //mailnews.view_default_charset setting and set it as per-server preference. + if (aCharset.IsEmpty()) { + nsString defaultCharset; + rv = NS_GetLocalizedUnicharPreferenceWithDefault(nullptr, + PREF_MAILNEWS_VIEW_DEFAULT_CHARSET, + NS_LITERAL_STRING("ISO-8859-1"), defaultCharset); + NS_ENSURE_SUCCESS(rv, rv); + LossyCopyUTF16toASCII(defaultCharset, aCharset); + SetCharset(aCharset); + } + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::WriteNewsrcFile() +{ + nsresult rv; + + bool newsrcHasChanged; + rv = GetNewsrcHasChanged(&newsrcHasChanged); + if (NS_FAILED(rv)) return rv; + +#ifdef DEBUG_NEWS + nsCString hostname; + rv = GetHostName(hostname); + if (NS_FAILED(rv)) return rv; +#endif /* DEBUG_NEWS */ + + if (newsrcHasChanged) { +#ifdef DEBUG_NEWS + printf("write newsrc file for %s\n", hostname.get()); +#endif + nsCOMPtr <nsIFile> newsrcFile; + rv = GetNewsrcFilePath(getter_AddRefs(newsrcFile)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIOutputStream> newsrcStream; + nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(newsrcStream), newsrcFile, -1, 00600); + if (NS_FAILED(rv)) + return rv; + + nsCOMPtr<nsISimpleEnumerator> subFolders; + nsCOMPtr<nsIMsgFolder> rootFolder; + rv = GetRootFolder(getter_AddRefs(rootFolder)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr <nsIMsgNewsFolder> newsFolder = do_QueryInterface(rootFolder, &rv); + if (NS_FAILED(rv)) return rv; + + uint32_t bytesWritten; + nsCString optionLines; + rv = newsFolder->GetOptionLines(optionLines); + if (NS_SUCCEEDED(rv) && !optionLines.IsEmpty()) { + newsrcStream->Write(optionLines.get(), optionLines.Length(), &bytesWritten); +#ifdef DEBUG_NEWS + printf("option lines:\n%s", optionLines.get()); +#endif /* DEBUG_NEWS */ + } +#ifdef DEBUG_NEWS + else { + printf("no option lines to write out\n"); + } +#endif /* DEBUG_NEWS */ + + nsCString unsubscribedLines; + rv = newsFolder->GetUnsubscribedNewsgroupLines(unsubscribedLines); + if (NS_SUCCEEDED(rv) && !unsubscribedLines.IsEmpty()) { + newsrcStream->Write(unsubscribedLines.get(), unsubscribedLines.Length(), &bytesWritten); +#ifdef DEBUG_NEWS + printf("unsubscribedLines:\n%s", unsubscribedLines.get()); +#endif /* DEBUG_NEWS */ + } +#ifdef DEBUG_NEWS + else { + printf("no unsubscribed lines to write out\n"); + } +#endif /* DEBUG_NEWS */ + + rv = rootFolder->GetSubFolders(getter_AddRefs(subFolders)); + if (NS_FAILED(rv)) return rv; + + bool moreFolders; + + while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) && + moreFolders) { + nsCOMPtr<nsISupports> child; + rv = subFolders->GetNext(getter_AddRefs(child)); + if (NS_SUCCEEDED(rv) && child) { + newsFolder = do_QueryInterface(child, &rv); + if (NS_SUCCEEDED(rv) && newsFolder) { + nsCString newsrcLine; + rv = newsFolder->GetNewsrcLine(newsrcLine); + if (NS_SUCCEEDED(rv) && !newsrcLine.IsEmpty()) { + // write the line to the newsrc file + newsrcStream->Write(newsrcLine.get(), newsrcLine.Length(), &bytesWritten); + } + } + } + } + + newsrcStream->Close(); + + rv = SetNewsrcHasChanged(false); + if (NS_FAILED(rv)) return rv; + } +#ifdef DEBUG_NEWS + else { + printf("no need to write newsrc file for %s, it was not dirty\n", (hostname.get())); + } +#endif /* DEBUG_NEWS */ + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetNewsrcHasChanged(bool aNewsrcHasChanged) +{ + mNewsrcHasChanged = aNewsrcHasChanged; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetNewsrcHasChanged(bool *aNewsrcHasChanged) +{ + if (!aNewsrcHasChanged) return NS_ERROR_NULL_POINTER; + + *aNewsrcHasChanged = mNewsrcHasChanged; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::CloseCachedConnections() +{ + nsresult rv; + nsCOMPtr<nsINNTPProtocol> connection; + + // iterate through the connection cache and close the connections. + int32_t cnt = mConnectionCache.Count(); + + for (int32_t i = 0; i < cnt; ++i) + { + connection = mConnectionCache[0]; + if (connection) + { + rv = connection->CloseConnection(); + // We need to do this instead of RemoveObjectAt(0) because the + // above call will likely cause the object to be removed from the + // array anyway + mConnectionCache.RemoveObject(connection); + } + } + + rv = WriteNewsrcFile(); + if (NS_FAILED(rv)) return rv; + + if (!mGetOnlyNew && !mHostInfoLoaded) + { + rv = WriteHostInfoFile(); + NS_ENSURE_SUCCESS(rv,rv); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetMaximumConnectionsNumber(int32_t *aMaxConnections) +{ + NS_ENSURE_ARG_POINTER(aMaxConnections); + + nsresult rv = GetIntValue("max_cached_connections", aMaxConnections); + // Get our maximum connection count. We need at least 1. If the value is 0, + // we use the default. If it's negative, we treat that as 1. + if (NS_SUCCEEDED(rv) && *aMaxConnections > 0) + return NS_OK; + + *aMaxConnections = (NS_FAILED(rv) || (*aMaxConnections == 0)) ? 2 : 1; + (void)SetMaximumConnectionsNumber(*aMaxConnections); + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetMaximumConnectionsNumber(int32_t aMaxConnections) +{ + return SetIntValue("max_cached_connections", aMaxConnections); +} + +bool +nsNntpIncomingServer::ConnectionTimeOut(nsINNTPProtocol* aConnection) +{ + bool retVal = false; + if (!aConnection) + return retVal; + + PRTime lastActiveTimeStamp; + if (NS_FAILED(aConnection->GetLastActiveTimeStamp(&lastActiveTimeStamp))) + return retVal; + + if (PR_Now() - lastActiveTimeStamp >= PRTime(170) * PR_USEC_PER_SEC) + { +#ifdef DEBUG_seth + printf("XXX connection timed out, close it, and remove it from the connection cache\n"); +#endif + aConnection->CloseConnection(); + mConnectionCache.RemoveObject(aConnection); + retVal = true; + } + return retVal; +} + + +nsresult +nsNntpIncomingServer::CreateProtocolInstance(nsINNTPProtocol ** aNntpConnection, nsIURI *url, + nsIMsgWindow *aMsgWindow) +{ + // create a new connection and add it to the connection cache + // we may need to flag the protocol connection as busy so we don't get + // a race + // condition where someone else goes through this code + nsNNTPProtocol *protocolInstance = new nsNNTPProtocol(this, url, aMsgWindow); + if (!protocolInstance) + return NS_ERROR_OUT_OF_MEMORY; + + nsresult rv = protocolInstance->QueryInterface(NS_GET_IID(nsINNTPProtocol), (void **) aNntpConnection); + // take the protocol instance and add it to the connectionCache + if (NS_SUCCEEDED(rv) && *aNntpConnection) + mConnectionCache.AppendObject(*aNntpConnection); + return rv; +} + + +nsresult +nsNntpIncomingServer::GetNntpConnection(nsIURI * aUri, nsIMsgWindow *aMsgWindow, + nsINNTPProtocol ** aNntpConnection) +{ + int32_t maxConnections; + (void)GetMaximumConnectionsNumber(&maxConnections); + + // Find a non-busy connection + nsCOMPtr<nsINNTPProtocol> connection; + int32_t cnt = mConnectionCache.Count(); + for (int32_t i = 0; i < cnt; i++) + { + connection = mConnectionCache[i]; + if (connection) + { + bool isBusy; + connection->GetIsBusy(&isBusy); + if (!isBusy) + break; + connection = nullptr; + } + } + + if (ConnectionTimeOut(connection)) + { + connection = nullptr; + // We have one less connection, since we closed this one. + --cnt; + } + + if (connection) + { + NS_IF_ADDREF(*aNntpConnection = connection); + connection->SetIsCachedConnection(true); + } + else if (cnt < maxConnections) + { + // We have room for another connection. Create this connection and return + // it to the caller. + nsresult rv = CreateProtocolInstance(aNntpConnection, aUri, aMsgWindow); + NS_ENSURE_SUCCESS(rv, rv); + } + else + { + // We maxed out our connection count. The caller must therefore enqueue the + // call. + *aNntpConnection = nullptr; + return NS_OK; + } + + // Initialize the URI here and now. + return (*aNntpConnection)->Initialize(aUri, aMsgWindow); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetNntpChannel(nsIURI *aURI, nsIMsgWindow *aMsgWindow, + nsIChannel **aChannel) +{ + NS_ENSURE_ARG_POINTER(aChannel); + + nsCOMPtr<nsINNTPProtocol> protocol; + nsresult rv = GetNntpConnection(aURI, aMsgWindow, getter_AddRefs(protocol)); + NS_ENSURE_SUCCESS(rv, rv); + + if (protocol) + return CallQueryInterface(protocol, aChannel); + + // No protocol? We need our mock channel. + nsNntpMockChannel *channel = new nsNntpMockChannel(aURI, aMsgWindow); + if (!channel) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(*aChannel = channel); + + m_queuedChannels.AppendElement(channel); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::LoadNewsUrl(nsIURI *aURI, nsIMsgWindow *aMsgWindow, + nsISupports *aConsumer) +{ + nsCOMPtr<nsINNTPProtocol> protocol; + nsresult rv = GetNntpConnection(aURI, aMsgWindow, getter_AddRefs(protocol)); + NS_ENSURE_SUCCESS(rv, rv); + + if (protocol) + return protocol->LoadNewsUrl(aURI, aConsumer); + + // No protocol? We need our mock channel. + nsNntpMockChannel *channel = new nsNntpMockChannel(aURI, aMsgWindow, + aConsumer); + if (!channel) + return NS_ERROR_OUT_OF_MEMORY; + + m_queuedChannels.AppendElement(channel); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::PrepareForNextUrl(nsNNTPProtocol *aConnection) +{ + NS_ENSURE_ARG(aConnection); + + // Start the connection on the next URL in the queue. If it can't get a URL to + // work, drop that URL (the channel will handle failure notification) and move + // on. + while (m_queuedChannels.Length() > 0) + { + RefPtr<nsNntpMockChannel> channel = m_queuedChannels[0]; + m_queuedChannels.RemoveElementAt(0); + nsresult rv = channel->AttachNNTPConnection(*aConnection); + // If this succeeded, the connection is now running the URL. + if (NS_SUCCEEDED(rv)) + return NS_OK; + } + + // No queued uris. + return NS_OK; +} + +/* void RemoveConnection (in nsINNTPProtocol aNntpConnection); */ +NS_IMETHODIMP nsNntpIncomingServer::RemoveConnection(nsINNTPProtocol *aNntpConnection) +{ + if (aNntpConnection) + mConnectionCache.RemoveObject(aNntpConnection); + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::PerformExpand(nsIMsgWindow *aMsgWindow) +{ + // Get news.update_unread_on_expand pref + nsresult rv; + bool updateUnreadOnExpand = true; + nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); + if (NS_SUCCEEDED(rv)) + prefBranch->GetBoolPref("news.update_unread_on_expand", &updateUnreadOnExpand); + + // Only if news.update_unread_on_expand is true do we update the unread counts + if (updateUnreadOnExpand) + return DownloadMail(aMsgWindow); + return NS_OK; +} + +nsresult +nsNntpIncomingServer::DownloadMail(nsIMsgWindow *aMsgWindow) +{ + nsCOMPtr<nsIMsgFolder> rootFolder; + nsresult rv = GetRootFolder(getter_AddRefs(rootFolder)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsISimpleEnumerator> groups; + rv = rootFolder->GetSubFolders(getter_AddRefs(groups)); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasNext; + while (NS_SUCCEEDED(rv = groups->HasMoreElements(&hasNext)) && hasNext) + { + nsCOMPtr<nsISupports> nextGroup; + rv = groups->GetNext(getter_AddRefs(nextGroup)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIMsgFolder> group(do_QueryInterface(nextGroup)); + rv = group->GetNewMessages(aMsgWindow, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + } + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::DisplaySubscribedGroup(nsIMsgNewsFolder *aMsgFolder, int32_t aFirstMessage, int32_t aLastMessage, int32_t aTotalMessages) +{ + nsresult rv; + + if (!aMsgFolder) return NS_ERROR_NULL_POINTER; +#ifdef DEBUG_NEWS + printf("DisplaySubscribedGroup(...,%ld,%ld,%ld)\n",aFirstMessage,aLastMessage,aTotalMessages); +#endif + rv = aMsgFolder->UpdateSummaryFromNNTPInfo(aFirstMessage,aLastMessage,aTotalMessages); + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::PerformBiff(nsIMsgWindow *aMsgWindow) +{ + // Biff will force a download of the messages. If the user doesn't want this + // (e.g., there is a lot of high-traffic newsgroups), the better option is to + // just ignore biff. + return PerformExpand(aMsgWindow); +} + +NS_IMETHODIMP nsNntpIncomingServer::GetServerRequiresPasswordForBiff(bool *aServerRequiresPasswordForBiff) +{ + NS_ENSURE_ARG_POINTER(aServerRequiresPasswordForBiff); + *aServerRequiresPasswordForBiff = false; // for news, biff is getting the unread counts + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::OnStartRunningUrl(nsIURI *url) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::OnStopRunningUrl(nsIURI *url, nsresult exitCode) +{ + nsresult rv; + rv = UpdateSubscribed(); + if (NS_FAILED(rv)) return rv; + + rv = StopPopulating(mMsgWindow); + if (NS_FAILED(rv)) return rv; + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::ContainsNewsgroup(const nsACString &aName, + bool *containsGroup) +{ + NS_ENSURE_ARG_POINTER(containsGroup); + NS_ENSURE_FALSE(aName.IsEmpty(), NS_ERROR_FAILURE); + + if (mSubscribedNewsgroups.Length() == 0) + { + // If this is empty, we may need to discover folders + nsCOMPtr<nsIMsgFolder> rootFolder; + GetRootFolder(getter_AddRefs(rootFolder)); + if (rootFolder) + { + nsCOMPtr<nsISimpleEnumerator> subfolders; + rootFolder->GetSubFolders(getter_AddRefs(subfolders)); + } + } + nsAutoCString unescapedName; + MsgUnescapeString(aName, 0, unescapedName); + *containsGroup = mSubscribedNewsgroups.Contains(aName); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SubscribeToNewsgroup(const nsACString &aName) +{ + NS_ASSERTION(!aName.IsEmpty(), "no name"); + NS_ENSURE_FALSE(aName.IsEmpty(), NS_ERROR_FAILURE); + + // If we already have this newsgroup, do nothing and report success. + bool containsGroup = false; + nsresult rv = ContainsNewsgroup(aName, &containsGroup); + NS_ENSURE_SUCCESS(rv, rv); + if (containsGroup) + return NS_OK; + + nsCOMPtr<nsIMsgFolder> msgfolder; + rv = GetRootMsgFolder(getter_AddRefs(msgfolder)); + NS_ENSURE_SUCCESS(rv, rv); + NS_ENSURE_TRUE(msgfolder, NS_ERROR_FAILURE); + + return msgfolder->CreateSubfolder(NS_ConvertUTF8toUTF16(aName), nullptr); +} + +bool +writeGroupToHostInfoFile(nsCString &aElement, void *aData) +{ + nsIOutputStream *stream; + stream = (nsIOutputStream *)aData; + NS_ASSERTION(stream, "no stream"); + if (!stream) { + // stop, something is bad. + return false; + } + return true; +} + +void nsNntpIncomingServer::WriteLine(nsIOutputStream *stream, nsCString &str) +{ + uint32_t bytesWritten; + str.Append(MSG_LINEBREAK); + stream->Write(str.get(), str.Length(), &bytesWritten); +} +nsresult +nsNntpIncomingServer::WriteHostInfoFile() +{ + if (!mHostInfoHasChanged) + return NS_OK; + + mLastUpdatedTime = uint32_t(PR_Now() / PR_USEC_PER_SEC); + + nsCString hostname; + nsresult rv = GetHostName(hostname); + NS_ENSURE_SUCCESS(rv,rv); + + if (!mHostInfoFile) + return NS_ERROR_UNEXPECTED; + nsCOMPtr<nsIOutputStream> hostInfoStream; + rv = MsgNewBufferedFileOutputStream(getter_AddRefs(hostInfoStream), mHostInfoFile, -1, 00600); + NS_ENSURE_SUCCESS(rv, rv); + + // XXX TODO: missing some formatting, see the 4.x code + nsAutoCString header("# News host information file."); + WriteLine(hostInfoStream, header); + header.Assign("# This is a generated file! Do not edit."); + WriteLine(hostInfoStream, header); + header.Truncate(); + WriteLine(hostInfoStream, header); + nsAutoCString version("version="); + version.AppendInt(VALID_VERSION); + WriteLine(hostInfoStream, version); + nsAutoCString newsrcname("newsrcname="); + newsrcname.Append(hostname); + WriteLine(hostInfoStream, hostname); + nsAutoCString dateStr("lastgroupdate="); + dateStr.AppendInt(mLastUpdatedTime); + WriteLine(hostInfoStream, dateStr); + dateStr = "uniqueid="; + dateStr.AppendInt(mUniqueId); + WriteLine(hostInfoStream, dateStr); + header.Assign(MSG_LINEBREAK"begingroups"); + WriteLine(hostInfoStream, header); + + // XXX TODO: sort groups first? + uint32_t length = mGroupsOnServer.Length(); + for (uint32_t i = 0; i < length; ++i) + { + uint32_t bytesWritten; + hostInfoStream->Write(mGroupsOnServer[i].get(), mGroupsOnServer[i].Length(), + &bytesWritten); + hostInfoStream->Write(MSG_LINEBREAK, MSG_LINEBREAK_LEN, &bytesWritten); + } + + hostInfoStream->Close(); + mHostInfoHasChanged = false; + return NS_OK; +} + +nsresult +nsNntpIncomingServer::LoadHostInfoFile() +{ + nsresult rv; + // we haven't loaded it yet + mHostInfoLoaded = false; + + rv = GetLocalPath(getter_AddRefs(mHostInfoFile)); + if (NS_FAILED(rv)) return rv; + if (!mHostInfoFile) return NS_ERROR_FAILURE; + + rv = mHostInfoFile->AppendNative(NS_LITERAL_CSTRING(HOSTINFO_FILE_NAME)); + if (NS_FAILED(rv)) return rv; + + bool exists; + rv = mHostInfoFile->Exists(&exists); + if (NS_FAILED(rv)) return rv; + + // it is ok if the hostinfo.dat file does not exist. + if (!exists) return NS_OK; + + nsCOMPtr<nsIInputStream> fileStream; + rv = NS_NewLocalFileInputStream(getter_AddRefs(fileStream), mHostInfoFile); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsILineInputStream> lineInputStream(do_QueryInterface(fileStream, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + bool more = true; + nsCString line; + + while (more && NS_SUCCEEDED(rv)) + { + rv = lineInputStream->ReadLine(line, &more); + if (line.IsEmpty()) + continue; + HandleLine(line.get(), line.Length()); + } + mHasSeenBeginGroups = false; + fileStream->Close(); + + return UpdateSubscribed(); +} + +NS_IMETHODIMP +nsNntpIncomingServer::StartPopulatingWithUri(nsIMsgWindow *aMsgWindow, bool aForceToServer, const char *uri) +{ +#ifdef DEBUG_seth + printf("StartPopulatingWithUri(%s)\n",uri); +#endif + + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + rv = mInner->StartPopulatingWithUri(aMsgWindow, aForceToServer, uri); + NS_ENSURE_SUCCESS(rv,rv); + + rv = StopPopulating(mMsgWindow); + if (NS_FAILED(rv)) return rv; + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SubscribeCleanup() +{ + nsresult rv = NS_OK; + rv = ClearInner(); + NS_ENSURE_SUCCESS(rv,rv); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::StartPopulating(nsIMsgWindow *aMsgWindow, bool aForceToServer, bool aGetOnlyNew) +{ + mMsgWindow = aMsgWindow; + + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + + rv = mInner->StartPopulating(aMsgWindow, aForceToServer, aGetOnlyNew); + NS_ENSURE_SUCCESS(rv,rv); + + rv = SetDelimiter(NEWS_DELIMITER); + if (NS_FAILED(rv)) return rv; + + rv = SetShowFullName(true); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsINntpService> nntpService = do_GetService(NS_NNTPSERVICE_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv,rv); + + mHostInfoLoaded = false; + mVersion = INVALID_VERSION; + mGroupsOnServer.Clear(); + mGetOnlyNew = aGetOnlyNew; + + if (!aForceToServer) { + rv = LoadHostInfoFile(); + if (NS_FAILED(rv)) return rv; + } + + // mHostInfoLoaded can be false if we failed to load anything + if (aForceToServer || !mHostInfoLoaded || (mVersion != VALID_VERSION)) { + // set these to true, so when we are done and we call WriteHostInfoFile() + // we'll write out to hostinfo.dat + mHostInfoHasChanged = true; + mVersion = VALID_VERSION; + + mGroupsOnServer.Clear(); + rv = nntpService->GetListOfGroupsOnServer(this, aMsgWindow, aGetOnlyNew); + if (NS_FAILED(rv)) return rv; + } + else { + rv = StopPopulating(aMsgWindow); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +/** + * This method is the entry point for |nsNNTPProtocol| class. |aName| is now + * encoded in the serverside character encoding, but we need to handle + * newsgroup names in UTF-8 internally, So we convert |aName| to + * UTF-8 here for later use. + **/ +NS_IMETHODIMP +nsNntpIncomingServer::AddNewsgroupToList(const char *aName) +{ + nsresult rv; + + nsAutoString newsgroupName; + nsAutoCString dataCharset; + rv = GetCharset(dataCharset); + NS_ENSURE_SUCCESS(rv,rv); + + rv = nsMsgI18NConvertToUnicode(dataCharset.get(), + nsDependentCString(aName), + newsgroupName); +#ifdef DEBUG_jungshik + NS_ASSERTION(NS_SUCCEEDED(rv), "newsgroup name conversion failed"); +#endif + if (NS_FAILED(rv)) { + CopyASCIItoUTF16(nsDependentCString(aName), newsgroupName); + } + + rv = AddTo(NS_ConvertUTF16toUTF8(newsgroupName), + false, true, true); + if (NS_FAILED(rv)) return rv; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetIncomingServer(nsIMsgIncomingServer *aServer) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->SetIncomingServer(aServer); +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetShowFullName(bool showFullName) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->SetShowFullName(showFullName); +} + +nsresult +nsNntpIncomingServer::ClearInner() +{ + nsresult rv = NS_OK; + + if (mInner) { + rv = mInner->SetSubscribeListener(nullptr); + NS_ENSURE_SUCCESS(rv,rv); + + rv = mInner->SetIncomingServer(nullptr); + NS_ENSURE_SUCCESS(rv,rv); + + mInner = nullptr; + } + return NS_OK; +} + +nsresult +nsNntpIncomingServer::EnsureInner() +{ + nsresult rv = NS_OK; + + if (mInner) + return NS_OK; + + mInner = do_CreateInstance(kSubscribableServerCID,&rv); + NS_ENSURE_SUCCESS(rv,rv); + if (!mInner) + return NS_ERROR_FAILURE; + + rv = SetIncomingServer(this); + NS_ENSURE_SUCCESS(rv,rv); + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetDelimiter(char *aDelimiter) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->GetDelimiter(aDelimiter); +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetDelimiter(char aDelimiter) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->SetDelimiter(aDelimiter); +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetAsSubscribed(const nsACString &path) +{ + mTempSubscribed.AppendElement(path); + if (mGetOnlyNew && (!mGroupsOnServer.Contains(path))) + return NS_OK; + + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->SetAsSubscribed(path); +} + +NS_IMETHODIMP +nsNntpIncomingServer::UpdateSubscribed() +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + mTempSubscribed.Clear(); + uint32_t length = mSubscribedNewsgroups.Length(); + for (uint32_t i = 0; i < length; ++i) + SetAsSubscribed(mSubscribedNewsgroups[i]); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::AddTo(const nsACString &aName, bool addAsSubscribed, + bool aSubscribable, bool changeIfExists) +{ + NS_ASSERTION(MsgIsUTF8(aName), "Non-UTF-8 newsgroup name"); + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + + rv = AddGroupOnServer(aName); + NS_ENSURE_SUCCESS(rv,rv); + + rv = mInner->AddTo(aName, addAsSubscribed, aSubscribable, changeIfExists); + NS_ENSURE_SUCCESS(rv,rv); + + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::StopPopulating(nsIMsgWindow *aMsgWindow) +{ + nsresult rv = NS_OK; + + nsCOMPtr<nsISubscribeListener> listener; + rv = GetSubscribeListener(getter_AddRefs(listener)); + NS_ENSURE_SUCCESS(rv,rv); + + if (!listener) + return NS_ERROR_FAILURE; + + rv = listener->OnDonePopulating(); + NS_ENSURE_SUCCESS(rv,rv); + + rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + rv = mInner->StopPopulating(aMsgWindow); + NS_ENSURE_SUCCESS(rv,rv); + + if (!mGetOnlyNew && !mHostInfoLoaded) + { + rv = WriteHostInfoFile(); + NS_ENSURE_SUCCESS(rv,rv); + } + + // XXX TODO: when do I set this to null? + // rv = ClearInner(); + // NS_ENSURE_SUCCESS(rv,rv); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetSubscribeListener(nsISubscribeListener *aListener) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->SetSubscribeListener(aListener); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSubscribeListener(nsISubscribeListener **aListener) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->GetSubscribeListener(aListener); +} + +NS_IMETHODIMP +nsNntpIncomingServer::Subscribe(const char16_t *aUnicharName) +{ + return SubscribeToNewsgroup(NS_ConvertUTF16toUTF8(aUnicharName)); +} + +NS_IMETHODIMP +nsNntpIncomingServer::Unsubscribe(const char16_t *aUnicharName) +{ + NS_ENSURE_ARG_POINTER(aUnicharName); + + nsresult rv; + + nsCOMPtr <nsIMsgFolder> serverFolder; + rv = GetRootMsgFolder(getter_AddRefs(serverFolder)); + if (NS_FAILED(rv)) + return rv; + + if (!serverFolder) + return NS_ERROR_FAILURE; + + // to handle non-ASCII newsgroup names, we store them internally as escaped. + // so we need to escape and encode the name, in order to find it. + nsAutoCString escapedName; + rv = NS_MsgEscapeEncodeURLPath(nsDependentString(aUnicharName), escapedName); + + nsCOMPtr <nsIMsgFolder> newsgroupFolder; + rv = serverFolder->FindSubFolder(escapedName, + getter_AddRefs(newsgroupFolder)); + + if (NS_FAILED(rv)) + return rv; + + if (!newsgroupFolder) + return NS_ERROR_FAILURE; + + rv = serverFolder->PropagateDelete(newsgroupFolder, true /* delete storage */, nullptr); + if (NS_FAILED(rv)) + return rv; + + // since we've unsubscribed to a newsgroup, the newsrc needs to be written out + rv = SetNewsrcHasChanged(true); + if (NS_FAILED(rv)) + return rv; + + return NS_OK; +} + +nsresult +nsNntpIncomingServer::HandleLine(const char* line, uint32_t line_size) +{ + NS_ASSERTION(line, "line is null"); + if (!line) + return NS_OK; + + // skip blank lines and comments + if (line[0] == '#' || line[0] == '\0') + return NS_OK; + // XXX TODO: make this truly const, maybe pass in an nsCString & + + if (mHasSeenBeginGroups) { + // v1 hostinfo files had additional data fields delimited by commas. + // with v2 hostinfo files, the additional data fields are removed. + char *commaPos = (char *) PL_strchr(line,','); + if (commaPos) *commaPos = 0; + + // newsrc entries are all in UTF-8 +#ifdef DEBUG_jungshik + NS_ASSERTION(MsgIsUTF8(nsDependentCString(line)), "newsrc line is not utf-8"); +#endif + nsresult rv = AddTo(nsDependentCString(line), false, true, true); + NS_ASSERTION(NS_SUCCEEDED(rv),"failed to add line"); + if (NS_SUCCEEDED(rv)) { + // since we've seen one group, we can claim we've loaded the + // hostinfo file + mHostInfoLoaded = true; + } + } + else { + if (PL_strncmp(line,"begingroups", 11) == 0) { + mHasSeenBeginGroups = true; + } + char*equalPos = (char *) PL_strchr(line, '='); + if (equalPos) { + *equalPos++ = '\0'; + if (PL_strcmp(line, "lastgroupdate") == 0) { + mLastUpdatedTime = strtoul(equalPos, nullptr, 10); + } else if (PL_strcmp(line, "uniqueid") == 0) { + mUniqueId = strtol(equalPos, nullptr, 16); + } else if (PL_strcmp(line, "version") == 0) { + mVersion = strtol(equalPos, nullptr, 16); + } + } + } + + return NS_OK; +} + +nsresult +nsNntpIncomingServer::AddGroupOnServer(const nsACString &aName) +{ + mGroupsOnServer.AppendElement(aName); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::AddNewsgroup(const nsAString &aName) +{ + // handle duplicates? + mSubscribedNewsgroups.AppendElement(NS_ConvertUTF16toUTF8(aName)); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::RemoveNewsgroup(const nsAString &aName) +{ + // handle duplicates? + mSubscribedNewsgroups.RemoveElement(NS_ConvertUTF16toUTF8(aName)); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetState(const nsACString &path, bool state, + bool *stateChanged) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + + rv = mInner->SetState(path, state, stateChanged); + if (*stateChanged) { + if (state) + mTempSubscribed.AppendElement(path); + else + mTempSubscribed.RemoveElement(path); + } + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::HasChildren(const nsACString &path, bool *aHasChildren) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->HasChildren(path, aHasChildren); +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsSubscribed(const nsACString &path, + bool *aIsSubscribed) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->IsSubscribed(path, aIsSubscribed); +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsSubscribable(const nsACString &path, + bool *aIsSubscribable) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->IsSubscribable(path, aIsSubscribable); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetLeafName(const nsACString &path, nsAString &aLeafName) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->GetLeafName(path, aLeafName); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetFirstChildURI(const nsACString &path, nsACString &aResult) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->GetFirstChildURI(path, aResult); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetChildren(const nsACString &aPath, + nsISimpleEnumerator **aResult) +{ + nsresult rv = EnsureInner(); + NS_ENSURE_SUCCESS(rv,rv); + return mInner->GetChildren(aPath, aResult); +} + +NS_IMETHODIMP +nsNntpIncomingServer::CommitSubscribeChanges() +{ + // we force the newrc to be dirty, so it will get written out when + // we call WriteNewsrcFile() + nsresult rv = SetNewsrcHasChanged(true); + NS_ENSURE_SUCCESS(rv,rv); + return WriteNewsrcFile(); +} + +NS_IMETHODIMP +nsNntpIncomingServer::ForgetPassword() +{ + // clear password of root folder (for the news account) + nsCOMPtr<nsIMsgFolder> rootFolder; + nsresult rv = GetRootFolder(getter_AddRefs(rootFolder)); + NS_ENSURE_SUCCESS(rv,rv); + if (!rootFolder) return NS_ERROR_FAILURE; + + nsCOMPtr <nsIMsgNewsFolder> newsFolder = do_QueryInterface(rootFolder, &rv); + NS_ENSURE_SUCCESS(rv,rv); + if (!newsFolder) return NS_ERROR_FAILURE; + + rv = newsFolder->ForgetAuthenticationCredentials(); + NS_ENSURE_SUCCESS(rv,rv); + + // clear password of all child folders + nsCOMPtr<nsISimpleEnumerator> subFolders; + + rv = rootFolder->GetSubFolders(getter_AddRefs(subFolders)); + NS_ENSURE_SUCCESS(rv,rv); + + bool moreFolders = false; + + nsresult return_rv = NS_OK; + + while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) && + moreFolders) { + nsCOMPtr<nsISupports> child; + rv = subFolders->GetNext(getter_AddRefs(child)); + if (NS_SUCCEEDED(rv) && child) { + newsFolder = do_QueryInterface(child, &rv); + if (NS_SUCCEEDED(rv) && newsFolder) { + rv = newsFolder->ForgetAuthenticationCredentials(); + if (NS_FAILED(rv)) + return_rv = rv; + } + else { + return_rv = NS_ERROR_FAILURE; + } + } + } + + return return_rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSupportsExtensions(bool *aSupportsExtensions) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetSupportsExtensions(bool aSupportsExtensions) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::AddExtension(const char *extension) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::QueryExtension(const char *extension, bool *result) +{ +#ifdef DEBUG_seth + printf("no extension support yet\n"); +#endif + *result = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetPostingAllowed(bool *aPostingAllowed) +{ + *aPostingAllowed = mPostingAllowed; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetPostingAllowed(bool aPostingAllowed) +{ + mPostingAllowed = aPostingAllowed; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetLastUpdatedTime(uint32_t *aLastUpdatedTime) +{ + *aLastUpdatedTime = mLastUpdatedTime; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetLastUpdatedTime(uint32_t aLastUpdatedTime) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::AddPropertyForGet(const char *name, const char *value) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::QueryPropertyForGet(const char *name, char **value) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::AddSearchableGroup(const nsAString &name) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::QuerySearchableGroup(const nsAString &name, bool *result) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::AddSearchableHeader(const char *name) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::QuerySearchableHeader(const char *name, bool *result) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::FindGroup(const nsACString &name, nsIMsgNewsFolder **result) +{ + NS_ENSURE_ARG_POINTER(result); + + nsresult rv; + nsCOMPtr <nsIMsgFolder> serverFolder; + rv = GetRootMsgFolder(getter_AddRefs(serverFolder)); + NS_ENSURE_SUCCESS(rv,rv); + + if (!serverFolder) return NS_ERROR_FAILURE; + + // Escape the name for using FindSubFolder + nsAutoCString escapedName; + rv = MsgEscapeString(name, nsINetUtil::ESCAPE_URL_PATH, escapedName); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr <nsIMsgFolder> subFolder; + rv = serverFolder->FindSubFolder(escapedName, getter_AddRefs(subFolder)); + NS_ENSURE_SUCCESS(rv,rv); + if (!subFolder) return NS_ERROR_FAILURE; + + rv = subFolder->QueryInterface(NS_GET_IID(nsIMsgNewsFolder), (void**)result); + NS_ENSURE_SUCCESS(rv,rv); + if (!*result) return NS_ERROR_FAILURE; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetFirstGroupNeedingExtraInfo(nsACString &result) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetGroupNeedsExtraInfo(const nsACString &name, + bool needsExtraInfo) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GroupNotFound(nsIMsgWindow *aMsgWindow, + const nsAString &aName, bool aOpening) +{ + nsresult rv; + nsCOMPtr <nsIPrompt> prompt; + + if (aMsgWindow) { + rv = aMsgWindow->GetPromptDialog(getter_AddRefs(prompt)); + NS_ASSERTION(NS_SUCCEEDED(rv), "no prompt from the msg window"); + } + + if (!prompt) { + nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); + rv = wwatch->GetNewPrompter(nullptr, getter_AddRefs(prompt)); + NS_ENSURE_SUCCESS(rv,rv); + } + + nsCOMPtr <nsIStringBundleService> bundleService = + mozilla::services::GetStringBundleService(); + NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED); + + nsCOMPtr <nsIStringBundle> bundle; + rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle)); + NS_ENSURE_SUCCESS(rv,rv); + + nsCString hostname; + rv = GetRealHostName(hostname); + NS_ENSURE_SUCCESS(rv,rv); + + NS_ConvertUTF8toUTF16 hostStr(hostname); + + nsString groupName(aName); + const char16_t *formatStrings[2] = { groupName.get(), hostStr.get() }; + nsString confirmText; + rv = bundle->FormatStringFromName( + u"autoUnsubscribeText", + formatStrings, 2, + getter_Copies(confirmText)); + NS_ENSURE_SUCCESS(rv,rv); + + bool confirmResult = false; + rv = prompt->Confirm(nullptr, confirmText.get(), &confirmResult); + NS_ENSURE_SUCCESS(rv,rv); + + if (confirmResult) { + rv = Unsubscribe(groupName.get()); + NS_ENSURE_SUCCESS(rv,rv); + } + + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetPrettyNameForGroup(const nsAString &name, + const nsAString &prettyName) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCanSearchMessages(bool *canSearchMessages) +{ + NS_ENSURE_ARG_POINTER(canSearchMessages); + *canSearchMessages = true; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetOfflineSupportLevel(int32_t *aSupportLevel) +{ + NS_ENSURE_ARG_POINTER(aSupportLevel); + nsresult rv; + + rv = GetIntValue("offline_support_level", aSupportLevel); + if (*aSupportLevel != OFFLINE_SUPPORT_LEVEL_UNDEFINED) return rv; + + // set default value + *aSupportLevel = OFFLINE_SUPPORT_LEVEL_EXTENDED; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetDefaultCopiesAndFoldersPrefsToServer(bool *aCopiesAndFoldersOnServer) +{ + NS_ENSURE_ARG_POINTER(aCopiesAndFoldersOnServer); + + /** + * When a news account is created, the copies and folder prefs for the + * associated identity don't point to folders on the server. + * This makes sense, since there is no "Drafts" folder on a news server. + * They'll point to the ones on "Local Folders" + */ + + *aCopiesAndFoldersOnServer = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCanCreateFoldersOnServer(bool *aCanCreateFoldersOnServer) +{ + NS_ENSURE_ARG_POINTER(aCanCreateFoldersOnServer); + + // No folder creation on news servers. Return false. + *aCanCreateFoldersOnServer = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetSearchValue(const nsAString &aSearchValue) +{ + nsCString searchValue = NS_ConvertUTF16toUTF8(aSearchValue); + MsgCompressWhitespace(searchValue); + + if (mTree) { + mTree->BeginUpdateBatch(); + mTree->RowCountChanged(0, -static_cast<int32_t>(mSubscribeSearchResult.Length())); + } + + nsTArray<nsCString> searchStringParts; + if (!searchValue.IsEmpty()) + ParseString(searchValue, ' ', searchStringParts); + + mSubscribeSearchResult.Clear(); + uint32_t length = mGroupsOnServer.Length(); + for (uint32_t i = 0; i < length; i++) + { + // check that all parts of the search string occur + bool found = true; + for (uint32_t j = 0; j < searchStringParts.Length(); ++j) { + if (MsgFind(mGroupsOnServer[i], searchStringParts[j], true, 0) == kNotFound) { + found = false; + break; + } + } + + if (found) + mSubscribeSearchResult.AppendElement(mGroupsOnServer[i]); + } + + nsCStringLowerCaseComparator comparator; + mSubscribeSearchResult.Sort(comparator); + + if (mTree) + { + mTree->RowCountChanged(0, mSubscribeSearchResult.Length()); + mTree->EndUpdateBatch(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSupportsSubscribeSearch(bool *retVal) +{ + *retVal = true; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetRowCount(int32_t *aRowCount) +{ + *aRowCount = mSubscribeSearchResult.Length(); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSelection(nsITreeSelection * *aSelection) +{ + *aSelection = mTreeSelection; + NS_IF_ADDREF(*aSelection); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetSelection(nsITreeSelection * aSelection) +{ + mTreeSelection = aSelection; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetRowProperties(int32_t index, nsAString& properties) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCellProperties(int32_t row, nsITreeColumn* col, nsAString& properties) +{ + if (!IsValidRow(row)) + return NS_ERROR_UNEXPECTED; + + NS_ENSURE_ARG_POINTER(col); + + const char16_t* colID; + col->GetIdConst(&colID); + if (colID[0] == 's') { + // if <name> is in our temporary list of subscribed groups + // add the "subscribed" property so the check mark shows up + // in the "subscribedCol" + if (mSearchResultSortDescending) + row = mSubscribeSearchResult.Length() - 1 - row; + if (mTempSubscribed.Contains(mSubscribeSearchResult.ElementAt(row))) { + properties.AssignLiteral("subscribed"); + } + } + else if (colID[0] == 'n') { + // add the "nntp" property to the "nameCol" + // so we get the news folder icon in the search view + properties.AssignLiteral("nntp"); + } + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetColumnProperties(nsITreeColumn* col, nsAString& properties) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsContainer(int32_t index, bool *_retval) +{ + *_retval = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsContainerOpen(int32_t index, bool *_retval) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsContainerEmpty(int32_t index, bool *_retval) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsSeparator(int32_t index, bool *_retval) +{ + *_retval = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsSorted(bool *_retval) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::CanDrop(int32_t index, + int32_t orientation, + nsIDOMDataTransfer *dataTransfer, + bool *_retval) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::Drop(int32_t row, + int32_t orientation, + nsIDOMDataTransfer *dataTransfer) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetParentIndex(int32_t rowIndex, int32_t *_retval) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::HasNextSibling(int32_t rowIndex, int32_t afterIndex, bool *_retval) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetLevel(int32_t index, int32_t *_retval) +{ + *_retval = 0; + return NS_OK; +} + +bool +nsNntpIncomingServer::IsValidRow(int32_t row) +{ + return ((row >= 0) && (row < (int32_t)mSubscribeSearchResult.Length())); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetImageSrc(int32_t row, nsITreeColumn* col, nsAString& _retval) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetProgressMode(int32_t row, nsITreeColumn* col, int32_t* _retval) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCellValue(int32_t row, nsITreeColumn* col, nsAString& _retval) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCellText(int32_t row, nsITreeColumn* col, nsAString& _retval) +{ + if (!IsValidRow(row)) + return NS_ERROR_UNEXPECTED; + + NS_ENSURE_ARG_POINTER(col); + + const char16_t* colID; + col->GetIdConst(&colID); + + nsresult rv = NS_OK; + if (colID[0] == 'n') { + nsAutoCString str; + if (mSearchResultSortDescending) + row = mSubscribeSearchResult.Length() - 1 - row; + // some servers have newsgroup names that are non ASCII. we store + // those as escaped. unescape here so the UI is consistent + rv = NS_MsgDecodeUnescapeURLPath(mSubscribeSearchResult.ElementAt(row), _retval); + } + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetTree(nsITreeBoxObject *tree) +{ + mTree = tree; + if (!tree) + return NS_OK; + + nsCOMPtr<nsITreeColumns> cols; + tree->GetColumns(getter_AddRefs(cols)); + if (!cols) + return NS_OK; + + nsCOMPtr<nsITreeColumn> col; + cols->GetKeyColumn(getter_AddRefs(col)); + if (!col) + return NS_OK; + + nsCOMPtr<nsIDOMElement> element; + col->GetElement(getter_AddRefs(element)); + if (!element) + return NS_OK; + + nsAutoString dir; + element->GetAttribute(NS_LITERAL_STRING("sortDirection"), dir); + mSearchResultSortDescending = dir.EqualsLiteral("descending"); + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::ToggleOpenState(int32_t index) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::CycleHeader(nsITreeColumn* col) +{ + NS_ENSURE_ARG_POINTER(col); + + bool cycler; + col->GetCycler(&cycler); + if (!cycler) { + NS_NAMED_LITERAL_STRING(dir, "sortDirection"); + nsCOMPtr<nsIDOMElement> element; + col->GetElement(getter_AddRefs(element)); + mSearchResultSortDescending = !mSearchResultSortDescending; + element->SetAttribute(dir, mSearchResultSortDescending ? + NS_LITERAL_STRING("descending") : NS_LITERAL_STRING("ascending")); + mTree->Invalidate(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SelectionChanged() +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::CycleCell(int32_t row, nsITreeColumn* col) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsEditable(int32_t row, nsITreeColumn* col, bool *_retval) +{ + *_retval = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::IsSelectable(int32_t row, nsITreeColumn* col, bool *_retval) +{ + *_retval = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetCellValue(int32_t row, nsITreeColumn* col, const nsAString& value) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetCellText(int32_t row, nsITreeColumn* col, const nsAString& value) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::PerformAction(const char16_t *action) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::PerformActionOnRow(const char16_t *action, int32_t row) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::PerformActionOnCell(const char16_t *action, int32_t row, nsITreeColumn* col) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetCanFileMessagesOnServer(bool *aCanFileMessagesOnServer) +{ + NS_ENSURE_ARG_POINTER(aCanFileMessagesOnServer); + + // No folder creation on news servers. Return false. + *aCanFileMessagesOnServer = false; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetFilterScope(nsMsgSearchScopeValue *filterScope) +{ + NS_ENSURE_ARG_POINTER(filterScope); + + *filterScope = nsMsgSearchScope::newsFilter; + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSearchScope(nsMsgSearchScopeValue *searchScope) +{ + NS_ENSURE_ARG_POINTER(searchScope); + + if (WeAreOffline()) { + // This value is set to the localNewsBody scope to be compatible with + // the legacy default value. + *searchScope = nsMsgSearchScope::localNewsBody; + } + else { + *searchScope = nsMsgSearchScope::news; + } + return NS_OK; +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSocketType(int32_t *aSocketType) +{ + NS_ENSURE_ARG_POINTER(aSocketType); + if (!mPrefBranch) + return NS_ERROR_NOT_INITIALIZED; + + nsresult rv = mPrefBranch->GetIntPref("socketType", aSocketType); + if (NS_FAILED(rv)) + { + if (!mDefPrefBranch) + return NS_ERROR_NOT_INITIALIZED; + rv = mDefPrefBranch->GetIntPref("socketType", aSocketType); + if (NS_FAILED(rv)) + *aSocketType = nsMsgSocketType::plain; + } + + // nsMsgIncomingServer::GetSocketType migrates old isSecure to socketType + // style for mail. Unfortunately, a bug caused news socketType 0 to be stored + // in the prefs even for isSecure true, so the migration wouldn't happen :( + + // Now that we know the socket, make sure isSecure true + socketType 0 + // doesn't mix. Migrate if that's the case here. + if (*aSocketType == nsMsgSocketType::plain) + { + bool isSecure = false; + nsresult rv2 = mPrefBranch->GetBoolPref("isSecure", &isSecure); + if (NS_SUCCEEDED(rv2) && isSecure) + { + *aSocketType = nsMsgSocketType::SSL; + // Don't call virtual method in case overrides call GetSocketType. + nsMsgIncomingServer::SetSocketType(*aSocketType); + } + } + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::SetSocketType(int32_t aSocketType) +{ + if (!mPrefBranch) + return NS_ERROR_NOT_INITIALIZED; + nsresult rv = nsMsgIncomingServer::SetSocketType(aSocketType); + if (NS_SUCCEEDED(rv)) + { + bool isSecure = false; + if (NS_SUCCEEDED(mPrefBranch->GetBoolPref("isSecure", &isSecure))) + { + // Must keep isSecure in sync since we migrate based on it... if it's set. + rv = mPrefBranch->SetBoolPref("isSecure", + aSocketType == nsMsgSocketType::SSL); + NS_ENSURE_SUCCESS(rv, rv); + } + } + return rv; +} + +NS_IMETHODIMP +nsNntpIncomingServer::OnUserOrHostNameChanged(const nsACString& oldName, + const nsACString& newName, + bool hostnameChanged) +{ + nsresult rv; + // 1. Do common things in the base class. + rv = nsMsgIncomingServer::OnUserOrHostNameChanged(oldName, newName, hostnameChanged); + NS_ENSURE_SUCCESS(rv,rv); + + // 2. Remove file hostinfo.dat so that the new subscribe + // list will be reloaded from the new server. + nsCOMPtr <nsIFile> hostInfoFile; + rv = GetLocalPath(getter_AddRefs(hostInfoFile)); + NS_ENSURE_SUCCESS(rv, rv); + rv = hostInfoFile->AppendNative(NS_LITERAL_CSTRING(HOSTINFO_FILE_NAME)); + NS_ENSURE_SUCCESS(rv, rv); + hostInfoFile->Remove(false); + + // 3.Unsubscribe and then subscribe the existing groups to clean up the article numbers + // in the rc file (this is because the old and new servers may maintain different + // numbers for the same articles if both servers handle the same groups). + nsCOMPtr <nsIMsgFolder> serverFolder; + rv = GetRootMsgFolder(getter_AddRefs(serverFolder)); + NS_ENSURE_SUCCESS(rv,rv); + + nsCOMPtr<nsISimpleEnumerator> subFolders; + rv = serverFolder->GetSubFolders(getter_AddRefs(subFolders)); + NS_ENSURE_SUCCESS(rv,rv); + + nsTArray<nsString> groupList; + nsString folderName; + + // Prepare the group list + bool hasMore; + while (NS_SUCCEEDED(subFolders->HasMoreElements(&hasMore)) && hasMore) + { + nsCOMPtr<nsISupports> item; + subFolders->GetNext(getter_AddRefs(item)); + nsCOMPtr<nsIMsgFolder> newsgroupFolder(do_QueryInterface(item)); + if (!newsgroupFolder) + continue; + + rv = newsgroupFolder->GetName(folderName); + NS_ENSURE_SUCCESS(rv,rv); + groupList.AppendElement(folderName); + } + + // If nothing subscribed then we're done. + if (groupList.Length() == 0) + return NS_OK; + + // Now unsubscribe & subscribe. + uint32_t i; + uint32_t cnt = groupList.Length(); + nsAutoCString cname; + for (i = 0; i < cnt; i++) + { + // unsubscribe. + rv = Unsubscribe(groupList[i].get()); + NS_ENSURE_SUCCESS(rv,rv); + } + + for (i = 0; i < cnt; i++) + { + // subscribe. + rv = SubscribeToNewsgroup(NS_ConvertUTF16toUTF8(groupList[i])); + NS_ENSURE_SUCCESS(rv,rv); + } + + // Force updating the rc file. + return CommitSubscribeChanges(); +} + +NS_IMETHODIMP +nsNntpIncomingServer::GetSortOrder(int32_t* aSortOrder) +{ + NS_ENSURE_ARG_POINTER(aSortOrder); + *aSortOrder = 500000000; + return NS_OK; +} |