Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "nsMsgCopyService.h"
#include "nsCOMArray.h"
#include "nspr.h"
#include "nsIFile.h"
#include "nsIMsgFolderNotificationService.h"
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"
#include "nsMsgUtils.h"
#include "mozilla/Logging.h"
static mozilla::LazyLogModule gCopyServiceLog("MsgCopyService");
// ******************** nsCopySource ******************
nsCopySource::nsCopySource() : m_processed(false) {
MOZ_COUNT_CTOR(nsCopySource);
}
nsCopySource::nsCopySource(nsIMsgFolder* srcFolder) : m_processed(false) {
MOZ_COUNT_CTOR(nsCopySource);
m_msgFolder = srcFolder;
}
nsCopySource::~nsCopySource() { MOZ_COUNT_DTOR(nsCopySource); }
void nsCopySource::AddMessage(nsIMsgDBHdr* aMsg) {
m_messageArray.AppendElement(aMsg);
}
// ************ nsCopyRequest *****************
//
nsCopyRequest::nsCopyRequest()
: m_requestType(nsCopyMessagesType),
m_isMoveOrDraftOrTemplate(false),
m_processed(false),
m_newMsgFlags(0) {
MOZ_COUNT_CTOR(nsCopyRequest);
}
nsCopyRequest::~nsCopyRequest() {
MOZ_COUNT_DTOR(nsCopyRequest);
int32_t j = m_copySourceArray.Length();
while (j-- > 0) delete m_copySourceArray.ElementAt(j);
}
nsresult nsCopyRequest::Init(nsCopyRequestType type, nsISupports* aSupport,
nsIMsgFolder* dstFolder, bool bVal,
uint32_t newMsgFlags,
const nsACString& newMsgKeywords,
nsIMsgCopyServiceListener* listener,
nsIMsgWindow* msgWindow, bool allowUndo) {
nsresult rv = NS_OK;
m_requestType = type;
m_srcSupport = aSupport;
m_dstFolder = dstFolder;
m_isMoveOrDraftOrTemplate = bVal;
m_allowUndo = allowUndo;
m_newMsgFlags = newMsgFlags;
m_newMsgKeywords = newMsgKeywords;
if (listener) m_listener = listener;
if (msgWindow) {
m_msgWindow = msgWindow;
if (m_allowUndo) msgWindow->GetTransactionManager(getter_AddRefs(m_txnMgr));
}
if (type == nsCopyFoldersType) {
// To support multiple copy folder operations to the same destination, we
// need to save the leaf name of the src file spec so that FindRequest() is
// able to find the right request when copy finishes.
nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryInterface(aSupport, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsString folderName;
rv = srcFolder->GetName(folderName);
NS_ENSURE_SUCCESS(rv, rv);
m_dstFolderName = folderName;
}
return rv;
}
nsCopySource* nsCopyRequest::AddNewCopySource(nsIMsgFolder* srcFolder) {
nsCopySource* newSrc = new nsCopySource(srcFolder);
if (newSrc) {
m_copySourceArray.AppendElement(newSrc);
if (srcFolder == m_dstFolder) newSrc->m_processed = true;
}
return newSrc;
}
// ************* nsMsgCopyService ****************
//
nsMsgCopyService::nsMsgCopyService() {}
nsMsgCopyService::~nsMsgCopyService() {
int32_t i = m_copyRequests.Length();
while (i-- > 0) ClearRequest(m_copyRequests.ElementAt(i), NS_ERROR_FAILURE);
}
void nsMsgCopyService::LogCopyCompletion(nsISupports* aSrc,
nsIMsgFolder* aDest) {
nsCString srcFolderUri, destFolderUri;
nsCOMPtr<nsIMsgFolder> srcFolder(do_QueryInterface(aSrc));
if (srcFolder) srcFolder->GetURI(srcFolderUri);
aDest->GetURI(destFolderUri);
MOZ_LOG(gCopyServiceLog, mozilla::LogLevel::Info,
("NotifyCompletion - src %s dest %s\n", srcFolderUri.get(),
destFolderUri.get()));
}
void nsMsgCopyService::LogCopyRequest(const char* logMsg,
nsCopyRequest* aRequest) {
nsCString srcFolderUri, destFolderUri;
nsCOMPtr<nsIMsgFolder> srcFolder(do_QueryInterface(aRequest->m_srcSupport));
if (srcFolder) srcFolder->GetURI(srcFolderUri);
aRequest->m_dstFolder->GetURI(destFolderUri);
uint32_t numMsgs = 0;
if (aRequest->m_requestType == nsCopyMessagesType &&
aRequest->m_copySourceArray.Length() > 0) {
numMsgs = aRequest->m_copySourceArray[0]->m_messageArray.Length();
}
MOZ_LOG(gCopyServiceLog, mozilla::LogLevel::Info,
("request %p %s - src %s dest %s numItems %d type=%d", aRequest,
logMsg, srcFolderUri.get(), destFolderUri.get(), numMsgs,
aRequest->m_requestType));
}
nsresult nsMsgCopyService::ClearRequest(nsCopyRequest* aRequest, nsresult rv) {
if (aRequest) {
if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
LogCopyRequest(
NS_SUCCEEDED(rv) ? "Clearing OK request" : "Clearing failed request",
aRequest);
if (NS_SUCCEEDED(rv) && aRequest->m_requestType == nsCopyFoldersType) {
// Send folder copy/move notifications to nsIMsgFolderListeners.
// BAD SMELL ALERT: Seems odd that this is the only place the folder
// notification is invoked from the copyService.
// For message copy/move operations, the folder code handles the
// notification (to take one example).
// This suggests lack of clarity of responsibility.
nsCOMPtr<nsIMsgFolderNotificationService> notifier(
do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
if (notifier) {
for (nsCopySource* copySource : aRequest->m_copySourceArray) {
notifier->NotifyFolderMoveCopyCompleted(
aRequest->m_isMoveOrDraftOrTemplate, copySource->m_msgFolder,
aRequest->m_dstFolder);
}
}
}
// undo stuff
if (aRequest->m_allowUndo && aRequest->m_copySourceArray.Length() > 1 &&
aRequest->m_txnMgr)
aRequest->m_txnMgr->EndBatch(false);
m_copyRequests.RemoveElement(aRequest);
if (aRequest->m_listener) aRequest->m_listener->OnStopCopy(rv);
delete aRequest;
}
return rv;
}
nsresult nsMsgCopyService::QueueRequest(nsCopyRequest* aRequest,
bool* aCopyImmediately) {
NS_ENSURE_ARG_POINTER(aRequest);
NS_ENSURE_ARG_POINTER(aCopyImmediately);
*aCopyImmediately = true;
nsCopyRequest* copyRequest;
// Check through previous requests to see if the copy can start immediately.
uint32_t cnt = m_copyRequests.Length();
for (uint32_t i = 0; i < cnt; i++) {
copyRequest = m_copyRequests.ElementAt(i);
if (aRequest->m_requestType == nsCopyFoldersType) {
// For copy folder, see if both destination folder (root)
// (ie, Local Folder) and folder name (ie, abc) are the same.
if (copyRequest->m_dstFolderName == aRequest->m_dstFolderName &&
SameCOMIdentity(copyRequest->m_dstFolder, aRequest->m_dstFolder)) {
*aCopyImmediately = false;
break;
}
} else if (SameCOMIdentity(copyRequest->m_dstFolder,
aRequest->m_dstFolder)) {
// If dst are same and we already have a request, we cannot copy
// immediately.
*aCopyImmediately = false;
break;
}
}
// Queue it.
m_copyRequests.AppendElement(aRequest);
return NS_OK;
}
nsresult nsMsgCopyService::DoCopy(nsCopyRequest* aRequest) {
NS_ENSURE_ARG(aRequest);
bool copyImmediately;
QueueRequest(aRequest, ©Immediately);
if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
LogCopyRequest(copyImmediately ? "DoCopy" : "QueueRequest", aRequest);
// if no active request for this dest folder then we can copy immediately
if (copyImmediately) return DoNextCopy();
return NS_OK;
}
nsresult nsMsgCopyService::DoNextCopy() {
nsresult rv = NS_OK;
nsCopyRequest* copyRequest = nullptr;
nsCopySource* copySource = nullptr;
uint32_t i, j, scnt;
uint32_t cnt = m_copyRequests.Length();
if (cnt > 0) {
nsCOMArray<nsIMsgFolder> activeTargets;
// ** jt -- always FIFO
for (i = 0; i < cnt; i++) {
copyRequest = m_copyRequests.ElementAt(i);
copySource = nullptr;
scnt = copyRequest->m_copySourceArray.Length();
if (!copyRequest->m_processed) {
// if the target folder of this request already has an active
// copy request, skip this request for now.
if (activeTargets.ContainsObject(copyRequest->m_dstFolder)) {
copyRequest = nullptr;
continue;
}
if (scnt <= 0) goto found; // must be CopyFileMessage
for (j = 0; j < scnt; j++) {
copySource = copyRequest->m_copySourceArray.ElementAt(j);
if (!copySource->m_processed) goto found;
}
if (j >= scnt) // all processed set the value
copyRequest->m_processed = true;
}
if (copyRequest->m_processed) {
// Keep track of folders actively getting copied to.
activeTargets.AppendObject(copyRequest->m_dstFolder);
}
}
found:
if (copyRequest && !copyRequest->m_processed) {
if (copyRequest->m_listener) copyRequest->m_listener->OnStartCopy();
if (copyRequest->m_requestType == nsCopyMessagesType && copySource) {
copySource->m_processed = true;
rv = copyRequest->m_dstFolder->CopyMessages(
copySource->m_msgFolder, copySource->m_messageArray,
copyRequest->m_isMoveOrDraftOrTemplate, copyRequest->m_msgWindow,
copyRequest->m_listener, false,
copyRequest->m_allowUndo); // isFolder operation false
} else if (copyRequest->m_requestType == nsCopyFoldersType) {
NS_ENSURE_STATE(copySource);
copySource->m_processed = true;
nsCOMPtr<nsIMsgFolder> dstFolder = copyRequest->m_dstFolder;
nsCOMPtr<nsIMsgFolder> srcFolder = copySource->m_msgFolder;
// If folder transfer is not within the same server and if a folder
// move was requested, set the request move flag false to avoid
// removing the list of marked deleted messages in the source folder.
bool isMove = copyRequest->m_isMoveOrDraftOrTemplate;
if (copyRequest->m_isMoveOrDraftOrTemplate) {
bool sameServer;
IsOnSameServer(dstFolder, srcFolder, &sameServer);
if (!sameServer) copyRequest->m_isMoveOrDraftOrTemplate = false;
}
// NOTE: The folder invokes NotifyCompletion() when the operation is
// complete. Some folders (localfolder!) invoke it before CopyFolder()
// even returns. This will likely delete the request object, so
// you have to assume that copyRequest is invalid when CopyFolder()
// returns.
rv = dstFolder->CopyFolder(srcFolder, isMove, copyRequest->m_msgWindow,
copyRequest->m_listener);
// If CopyFolder() fails (e.g. destination folder already exists),
// it won't send a completion notification (NotifyCompletion()).
// So copyRequest will still exist, and we need to ditch it.
if (NS_FAILED(rv)) {
ClearRequest(copyRequest, rv);
}
} else if (copyRequest->m_requestType == nsCopyFileMessageType) {
nsCOMPtr<nsIFile> aFile(
do_QueryInterface(copyRequest->m_srcSupport, &rv));
if (NS_SUCCEEDED(rv)) {
// ** in case of saving draft/template; the very first
// time we may not have the original message to replace
// with; if we do we shall have an instance of copySource
nsCOMPtr<nsIMsgDBHdr> aMessage;
if (copySource) {
aMessage = copySource->m_messageArray[0];
copySource->m_processed = true;
}
copyRequest->m_processed = true;
rv = copyRequest->m_dstFolder->CopyFileMessage(
aFile, aMessage, copyRequest->m_isMoveOrDraftOrTemplate,
copyRequest->m_newMsgFlags, copyRequest->m_newMsgKeywords,
copyRequest->m_msgWindow, copyRequest->m_listener);
}
}
}
}
return rv;
}
/**
* Find a request in m_copyRequests which matches the passed in source
* and destination folders.
*
* @param aSupport the iSupports of the source folder.
* @param dstFolder the destination folder of the copy request.
*/
nsCopyRequest* nsMsgCopyService::FindRequest(nsISupports* aSupport,
nsIMsgFolder* dstFolder) {
nsCopyRequest* copyRequest = nullptr;
uint32_t cnt = m_copyRequests.Length();
for (uint32_t i = 0; i < cnt; i++) {
copyRequest = m_copyRequests.ElementAt(i);
if (SameCOMIdentity(copyRequest->m_srcSupport, aSupport) &&
SameCOMIdentity(copyRequest->m_dstFolder.get(), dstFolder))
break;
// When copying folders the notification of the message copy serves as a
// proxy for the folder copy. Check for that here.
if (copyRequest->m_requestType == nsCopyFoldersType) {
// If the src is different then check next request.
if (!SameCOMIdentity(copyRequest->m_srcSupport, aSupport)) {
copyRequest = nullptr;
continue;
}
// See if the parent of the copied folder is the same as the one when the
// request was made. Note if the destination folder is already a server
// folder then no need to get parent.
nsCOMPtr<nsIMsgFolder> parentMsgFolder;
nsresult rv = NS_OK;
bool isServer = false;
dstFolder->GetIsServer(&isServer);
if (!isServer) rv = dstFolder->GetParent(getter_AddRefs(parentMsgFolder));
if ((NS_FAILED(rv)) || (!parentMsgFolder && !isServer) ||
(copyRequest->m_dstFolder.get() != parentMsgFolder)) {
copyRequest = nullptr;
continue;
}
// Now checks if the folder name is the same.
nsString folderName;
rv = dstFolder->GetName(folderName);
if (NS_FAILED(rv)) {
copyRequest = nullptr;
continue;
}
if (copyRequest->m_dstFolderName == folderName) break;
} else
copyRequest = nullptr;
}
return copyRequest;
}
NS_IMPL_ISUPPORTS(nsMsgCopyService, nsIMsgCopyService)
MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP nsMsgCopyService::CopyMessages(
nsIMsgFolder* srcFolder, /* UI src folder */
nsTArray<RefPtr<nsIMsgDBHdr>> const& messages, nsIMsgFolder* dstFolder,
bool isMove, nsIMsgCopyServiceListener* listener, nsIMsgWindow* window,
bool allowUndo) {
NS_ENSURE_ARG_POINTER(srcFolder);
NS_ENSURE_ARG_POINTER(dstFolder);
MOZ_LOG(gCopyServiceLog, mozilla::LogLevel::Debug, ("CopyMessages"));
if (srcFolder == dstFolder) {
NS_ERROR("src and dest folders for msg copy can't be the same");
return NS_ERROR_FAILURE;
}
nsCopyRequest* copyRequest;
nsCopySource* copySource = nullptr;
nsIMsgDBHdr* msg;
nsCOMPtr<nsIMsgFolder> curFolder;
nsCOMPtr<nsISupports> aSupport;
int cnt;
nsresult rv;
// XXX TODO
// JUNK MAIL RELATED
// make sure dest folder exists
// and has proper flags, before we start copying?
// bail early if nothing to do
if (messages.IsEmpty()) {
if (listener) {
listener->OnStartCopy();
listener->OnStopCopy(NS_OK);
}
return NS_OK;
}
copyRequest = new nsCopyRequest();
if (!copyRequest) return NS_ERROR_OUT_OF_MEMORY;
nsTArray<RefPtr<nsIMsgDBHdr>> unprocessed = messages.Clone();
aSupport = srcFolder;
rv = copyRequest->Init(nsCopyMessagesType, aSupport, dstFolder, isMove,
0 /* new msg flags, not used */, EmptyCString(),
listener, window, allowUndo);
if (NS_FAILED(rv)) goto done;
if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
LogCopyRequest("CopyMessages request", copyRequest);
// Build up multiple nsCopySource objects. Each holds a single source folder
// and all the messages in the folder that are to be copied.
cnt = unprocessed.Length();
while (cnt-- > 0) {
msg = unprocessed[cnt];
rv = msg->GetFolder(getter_AddRefs(curFolder));
if (NS_FAILED(rv)) goto done;
if (!copySource) {
// Begin a folder grouping.
copySource = copyRequest->AddNewCopySource(curFolder);
if (!copySource) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto done;
}
}
// Stash message if in the current folder grouping.
if (curFolder == copySource->m_msgFolder) {
copySource->AddMessage(msg);
unprocessed.RemoveElementAt((size_t)cnt);
}
if (cnt == 0) {
// Finished a folder. Start a new pass to handle any remaining messages
// in other folders.
cnt = unprocessed.Length();
if (cnt > 0) {
// Force to create a new one and continue grouping the messages.
copySource = nullptr;
}
}
}
// undo stuff
if (NS_SUCCEEDED(rv) && copyRequest->m_allowUndo &&
copyRequest->m_copySourceArray.Length() > 1 && copyRequest->m_txnMgr) {
nsCOMPtr<nsITransactionManager> txnMgr = copyRequest->m_txnMgr;
txnMgr->BeginBatch(nullptr);
}
done:
if (NS_FAILED(rv))
delete copyRequest;
else
rv = DoCopy(copyRequest);
return rv;
}
NS_IMETHODIMP
nsMsgCopyService::CopyFolder(nsIMsgFolder* srcFolder, nsIMsgFolder* dstFolder,
bool isMove, nsIMsgCopyServiceListener* listener,
nsIMsgWindow* window) {
NS_ENSURE_ARG_POINTER(srcFolder);
NS_ENSURE_ARG_POINTER(dstFolder);
nsCopyRequest* copyRequest;
nsresult rv;
nsCOMPtr<nsIMsgFolder> curFolder;
copyRequest = new nsCopyRequest();
rv = copyRequest->Init(nsCopyFoldersType, srcFolder, dstFolder, isMove,
0 /* new msg flags, not used */, EmptyCString(),
listener, window, false);
NS_ENSURE_SUCCESS(rv, rv);
copyRequest->AddNewCopySource(srcFolder);
return DoCopy(copyRequest);
}
NS_IMETHODIMP
nsMsgCopyService::CopyFileMessage(nsIFile* file, nsIMsgFolder* dstFolder,
nsIMsgDBHdr* msgToReplace, bool isDraft,
uint32_t aMsgFlags,
const nsACString& aNewMsgKeywords,
nsIMsgCopyServiceListener* listener,
nsIMsgWindow* window) {
nsresult rv = NS_ERROR_NULL_POINTER;
nsCopyRequest* copyRequest;
nsCopySource* copySource = nullptr;
NS_ENSURE_ARG_POINTER(file);
NS_ENSURE_ARG_POINTER(dstFolder);
copyRequest = new nsCopyRequest();
if (!copyRequest) return rv;
rv = copyRequest->Init(nsCopyFileMessageType, file, dstFolder, isDraft,
aMsgFlags, aNewMsgKeywords, listener, window, false);
if (NS_FAILED(rv)) goto done;
if (msgToReplace) {
// The actual source of the message is a file not a folder, but
// we still need an nsCopySource to reference the old message header
// which will be used to recover message metadata.
copySource = copyRequest->AddNewCopySource(nullptr);
if (!copySource) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto done;
}
copySource->AddMessage(msgToReplace);
}
done:
if (NS_FAILED(rv)) {
delete copyRequest;
} else {
rv = DoCopy(copyRequest);
}
return rv;
}
NS_IMETHODIMP
nsMsgCopyService::NotifyCompletion(nsISupports* aSupport,
nsIMsgFolder* dstFolder, nsresult result) {
if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
LogCopyCompletion(aSupport, dstFolder);
nsCopyRequest* copyRequest = nullptr;
uint32_t numOrigRequests = m_copyRequests.Length();
do {
// loop for copy requests, because if we do a cross server folder copy,
// we'll have a copy request for the folder copy, which will in turn
// generate a copy request for the messages in the folder, which
// will have the same src support.
copyRequest = FindRequest(aSupport, dstFolder);
if (copyRequest) {
// ClearRequest can cause a new request to get added to m_copyRequests
// with matching source and dest folders if the copy listener starts
// a new copy. We want to ignore any such request here, because it wasn't
// the one that was completed. So we keep track of how many original
// requests there were.
if (m_copyRequests.IndexOf(copyRequest) >= numOrigRequests) break;
// check if this copy request is done by making sure all the
// sources have been processed.
int32_t sourceIndex, sourceCount;
sourceCount = copyRequest->m_copySourceArray.Length();
for (sourceIndex = 0; sourceIndex < sourceCount;) {
if (!(copyRequest->m_copySourceArray.ElementAt(sourceIndex))
->m_processed)
break;
sourceIndex++;
}
// if all sources processed, mark the request as processed
if (sourceIndex >= sourceCount) copyRequest->m_processed = true;
// if this request is done, or failed, clear it.
if (copyRequest->m_processed || NS_FAILED(result)) {
ClearRequest(copyRequest, result);
numOrigRequests--;
} else
break;
} else
break;
} while (copyRequest);
return DoNextCopy();
}