NS_IMETHODIMP ImportOEMailImpl::ImportMailbox(nsIImportMailboxDescriptor *pSource,
nsIMsgFolder *dstFolder,
PRUnichar **pErrorLog,
PRUnichar **pSuccessLog,
bool *fatalError)
{
NS_ENSURE_ARG_POINTER(pSource);
NS_ENSURE_ARG_POINTER(dstFolder);
NS_ENSURE_ARG_POINTER(fatalError);
nsString success;
nsString error;
bool abort = false;
nsString name;
nsString pName;
if (NS_SUCCEEDED(pSource->GetDisplayName(getter_Copies(pName))))
name = pName;
PRUint32 mailSize = 0;
pSource->GetSize(&mailSize);
if (mailSize == 0) {
ReportSuccess(name, 0, &success);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_OK;
}
nsCOMPtr <nsIFile> inFile;
if (NS_FAILED(pSource->GetFile(getter_AddRefs(inFile)))) {
ReportError(OEIMPORT_MAILBOX_BADSOURCEFILE, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_ERROR_FAILURE;
}
nsCString pPath;
inFile->GetNativePath(pPath);
IMPORT_LOG1("Importing Outlook Express mailbox: %s\n", pPath.get());
m_bytesDone = 0;
PRUint32 msgCount = 0;
nsresult rv;
if (nsOE5File::IsLocalMailFile(inFile)) {
IMPORT_LOG1("Importing OE5 mailbox: %s!\n", NS_LossyConvertUTF16toASCII(name.get()));
rv = nsOE5File::ImportMailbox( &m_bytesDone, &abort, name, inFile, dstFolder, &msgCount);
}
else {
if (CImportMailbox::ImportMailbox( &m_bytesDone, &abort, name, inFile, dstFolder, &msgCount))
rv = NS_OK;
else
rv = NS_ERROR_FAILURE;
}
if (NS_SUCCEEDED(rv))
ReportSuccess(name, msgCount, &success);
else
ReportError(OEIMPORT_MAILBOX_CONVERTERROR, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
return rv;
}
NS_IMETHODIMP ImportVCardAddressImpl::ImportAddressBook(
nsIImportABDescriptor *pSource,
nsIAddrDatabase *pDestination,
nsIImportFieldMap *fieldMap,
nsISupports *aSupportService,
PRUnichar ** pErrorLog,
PRUnichar ** pSuccessLog,
bool * fatalError)
{
NS_ENSURE_ARG_POINTER(pSource);
NS_ENSURE_ARG_POINTER(pDestination);
NS_ENSURE_ARG_POINTER(fatalError);
if (!m_notProxyBundle)
return NS_ERROR_FAILURE;
m_bytesImported = 0;
nsString success, error;
bool addrAbort = false;
nsString name;
pSource->GetPreferredName(name);
uint32_t addressSize = 0;
pSource->GetSize(&addressSize);
if (addressSize == 0) {
IMPORT_LOG0("Address book size is 0, skipping import.\n");
ReportSuccess(name, &success, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_OK;
}
nsCOMPtr<nsIFile> inFile;
if (NS_FAILED(pSource->GetAbFile(getter_AddRefs(inFile)))) {
ReportError("vCardImportAddressBadSourceFile", name, &error, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_ERROR_FAILURE;
}
if (!aSupportService) {
IMPORT_LOG0("Missing support service to import call\n");
return NS_ERROR_FAILURE;
}
nsresult rv = m_vCard.ImportAddresses(
&addrAbort, name.get(), inFile, pDestination, error, &m_bytesImported);
if (NS_SUCCEEDED(rv) && error.IsEmpty()) {
ReportSuccess(name, &success, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
}
else {
ReportError("vCardImportAddressConvertError", name, &error, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
}
IMPORT_LOG0("*** VCard address import done\n");
return rv;
}
NS_IMETHODIMP ImportOutlookMailImpl::ImportMailbox( nsIImportMailboxDescriptor *pSource,
nsIFile *pDestination,
PRUnichar **pErrorLog,
PRUnichar **pSuccessLog,
PRBool *fatalError)
{
NS_PRECONDITION(pSource != nsnull, "null ptr");
NS_PRECONDITION(pDestination != nsnull, "null ptr");
NS_PRECONDITION(fatalError != nsnull, "null ptr");
nsCOMPtr<nsIStringBundle> bundle( dont_AddRef( nsOutlookStringBundle::GetStringBundleProxy()));
nsString success;
nsString error;
if (!pSource || !pDestination || !fatalError) {
nsOutlookStringBundle::GetStringByID( OUTLOOKIMPORT_MAILBOX_BADPARAM, error, bundle);
if (fatalError)
*fatalError = PR_TRUE;
SetLogs( success, error, pErrorLog, pSuccessLog);
return NS_ERROR_NULL_POINTER;
}
PRBool abort = PR_FALSE;
nsString name;
PRUnichar * pName;
if (NS_SUCCEEDED( pSource->GetDisplayName( &pName))) {
name = pName;
NS_Free( pName);
}
PRUint32 mailSize = 0;
pSource->GetSize( &mailSize);
if (mailSize == 0) {
ReportSuccess( name, 0, &success);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( NS_OK);
}
PRUint32 index = 0;
pSource->GetIdentifier( &index);
PRInt32 msgCount = 0;
nsresult rv = NS_OK;
m_bytesDone = 0;
rv = m_mail.ImportMailbox( &m_bytesDone, &abort, (PRInt32)index, name.get(), pDestination, &msgCount);
if (NS_SUCCEEDED( rv))
ReportSuccess( name, msgCount, &success);
else
ReportError( OUTLOOKIMPORT_MAILBOX_CONVERTERROR, name, &error);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( rv);
}
NS_IMETHODIMP
ImportOutlookMailImpl::ImportMailbox(nsIImportMailboxDescriptor *pSource,
nsIMsgFolder *dstFolder,
PRUnichar **pErrorLog,
PRUnichar **pSuccessLog,
bool *fatalError)
{
NS_ENSURE_ARG_POINTER(pSource);
NS_ENSURE_ARG_POINTER(dstFolder);
NS_ENSURE_ARG_POINTER(fatalError);
nsString success;
nsString error;
bool abort = false;
nsString name;
PRUnichar *pName;
if (NS_SUCCEEDED( pSource->GetDisplayName( &pName))) {
name = pName;
NS_Free( pName);
}
PRUint32 mailSize = 0;
pSource->GetSize(&mailSize);
if (mailSize == 0) {
ReportSuccess(name, 0, &success);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_OK;
}
PRUint32 index = 0;
pSource->GetIdentifier(&index);
PRInt32 msgCount = 0;
nsresult rv = NS_OK;
m_bytesDone = 0;
rv = m_mail.ImportMailbox(&m_bytesDone, &abort, (PRInt32)index, name.get(),
dstFolder, &msgCount);
if (NS_SUCCEEDED(rv))
ReportSuccess(name, msgCount, &success);
else
ReportError(OUTLOOKIMPORT_MAILBOX_CONVERTERROR, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
return rv;
}
NS_IMETHODIMP nsImportGenericMail::BeginImport(nsISupportsString *successLog, nsISupportsString *errorLog, bool *_retval)
{
NS_PRECONDITION(_retval != nullptr, "null ptr");
if (!_retval)
return NS_ERROR_NULL_POINTER;
nsString success;
nsString error;
if (!m_doImport) {
nsImportStringBundle::GetStringByID(IMPORT_NO_MAILBOXES,
m_stringBundle, success);
SetLogs(success, error, successLog, errorLog);
*_retval = true;
return NS_OK;
}
if (!m_pInterface || !m_pMailboxes) {
IMPORT_LOG0("*** BeginImport: Either the interface or source mailbox is not set properly.");
nsImportStringBundle::GetStringByID(IMPORT_ERROR_MB_NOTINITIALIZED,
m_stringBundle, error);
SetLogs(success, error, successLog, errorLog);
*_retval = false;
return NS_OK;
}
if (!m_pDestFolder) {
IMPORT_LOG0("*** BeginImport: The destination mailbox is not set properly.");
nsImportStringBundle::GetStringByID(IMPORT_ERROR_MB_NODESTFOLDER,
m_stringBundle, error);
SetLogs(success, error, successLog, errorLog);
*_retval = false;
return NS_OK;
}
if (m_pThreadData) {
m_pThreadData->DriverAbort();
m_pThreadData = nullptr;
}
NS_IF_RELEASE(m_pSuccessLog);
NS_IF_RELEASE(m_pErrorLog);
m_pSuccessLog = successLog;
m_pErrorLog = errorLog;
NS_IF_ADDREF(m_pSuccessLog);
NS_IF_ADDREF(m_pErrorLog);
// kick off the thread to do the import!!!!
m_pThreadData = new ImportThreadData();
m_pThreadData->boxes = m_pMailboxes;
NS_ADDREF(m_pMailboxes);
m_pThreadData->mailImport = m_pInterface;
NS_ADDREF(m_pInterface);
m_pThreadData->errorLog = m_pErrorLog;
NS_IF_ADDREF(m_pErrorLog);
m_pThreadData->successLog = m_pSuccessLog;
NS_IF_ADDREF(m_pSuccessLog);
m_pThreadData->ownsDestRoot = m_deleteDestFolder;
m_pThreadData->destRoot = m_pDestFolder;
m_pThreadData->performingMigration = m_performingMigration;
NS_IF_ADDREF(m_pDestFolder);
NS_IF_ADDREF(m_pThreadData->stringBundle = m_stringBundle);
PRThread *pThread = PR_CreateThread(PR_USER_THREAD, &ImportMailThread, m_pThreadData,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_UNJOINABLE_THREAD,
0);
if (!pThread) {
m_pThreadData->ThreadDelete();
m_pThreadData->abort = true;
m_pThreadData->DriverAbort();
m_pThreadData = nullptr;
*_retval = false;
nsImportStringBundle::GetStringByID(IMPORT_ERROR_MB_NOTHREAD,
m_stringBundle, error);
SetLogs(success, error, successLog, errorLog);
}
else
*_retval = true;
return NS_OK;
}
NS_IMETHODIMP
ImportAddressImpl::ImportAddressBook(nsIImportABDescriptor *pSource,
nsIAddrDatabase *pDestination,
nsIImportFieldMap *fieldMap,
nsISupports *aSupportService,
PRUnichar ** pErrorLog,
PRUnichar ** pSuccessLog,
bool * fatalError)
{
NS_PRECONDITION(pSource != nsnull, "null ptr");
NS_PRECONDITION(pDestination != nsnull, "null ptr");
NS_PRECONDITION(fatalError != nsnull, "null ptr");
m_bytesImported = 0;
nsString success, error;
if (!pSource || !pDestination || !fatalError) {
IMPORT_LOG0("*** Bad param passed to text address import\n");
nsImportStringBundle::GetStringByID(TEXTIMPORT_ADDRESS_BADPARAM,
m_notProxyBundle,
error);
SetLogs(success, error, pErrorLog, pSuccessLog);
if (fatalError)
*fatalError = true;
return NS_ERROR_NULL_POINTER;
}
ClearSampleFile();
bool addrAbort = false;
nsString name;
pSource->GetPreferredName(name);
PRUint32 addressSize = 0;
pSource->GetSize(&addressSize);
if (addressSize == 0) {
IMPORT_LOG0("Address book size is 0, skipping import.\n");
ReportSuccess(name, &success, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_OK;
}
nsCOMPtr<nsIFile> inFile;
if (NS_FAILED(pSource->GetAbFile(getter_AddRefs(inFile)))) {
ReportError(TEXTIMPORT_ADDRESS_BADSOURCEFILE, name, &error, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_ERROR_FAILURE;
}
if (!aSupportService) {
IMPORT_LOG0("Missing support service to import call");
return NS_ERROR_FAILURE;
}
bool isLDIF = false;
nsresult rv;
nsCOMPtr<nsIAbLDIFService> ldifService(do_QueryInterface(aSupportService, &rv));
if (NS_SUCCEEDED(rv)) {
rv = ldifService->IsLDIFFile(inFile, &isLDIF);
if (NS_FAILED(rv)) {
IMPORT_LOG0("*** Error reading address file\n");
}
}
if (NS_FAILED(rv)) {
ReportError(TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
return rv;
}
if (isLDIF) {
if (ldifService)
rv = ldifService->ImportLDIFFile(pDestination, inFile, false, &m_bytesImported);
else
return NS_ERROR_FAILURE;
}
else {
rv = m_text.ImportAddresses(&addrAbort, name.get(), inFile, pDestination, fieldMap, error, &m_bytesImported);
SaveFieldMap(fieldMap);
}
if (NS_SUCCEEDED(rv) && error.IsEmpty()) {
ReportSuccess(name, &success, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
}
else {
ReportError(TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error, m_notProxyBundle);
SetLogs(success, error, pErrorLog, pSuccessLog);
}
IMPORT_LOG0("*** Text address import done\n");
return rv;
}
NS_IMETHODIMP nsAppleMailImportMail::ImportMailbox(nsIImportMailboxDescriptor *aMailbox, nsIFile *aDestination,
PRUnichar **aErrorLog, PRUnichar **aSuccessLog, bool *aFatalError)
{
nsAutoString errorLog, successLog;
// reset progress
mProgress = 0;
nsAutoString mailboxName;
aMailbox->GetDisplayName(getter_Copies(mailboxName));
nsCOMPtr<nsILocalFile> mboxFolder;
nsresult rv = aMailbox->GetFile(getter_AddRefs(mboxFolder));
if (NS_FAILED(rv) || !mboxFolder) {
ReportStatus(APPLEMAILIMPORT_MAILBOX_CONVERTERROR, mailboxName, errorLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_ERROR_FAILURE;
}
// if we're an account mailbox, nothing do. if we're a real mbox
// then we've got some messages to import!
PRUint32 mailboxIdentifier;
aMailbox->GetIdentifier(&mailboxIdentifier);
if (mailboxIdentifier != kAccountMailboxID) {
// move to the .mbox's Messages folder
nsCOMPtr<nsIFile> messagesFolder;
mboxFolder->Clone(getter_AddRefs(messagesFolder));
rv = messagesFolder->Append(NS_LITERAL_STRING("Messages"));
if (NS_FAILED(rv)) {
// even if there are no messages, it might still be a valid mailbox, or even
// a parent for other mailboxes.
//
// just indicate that we're done, using the same number that we used to estimate
// number of messages earlier.
PRUint32 finalSize;
aMailbox->GetSize(&finalSize);
mProgress = finalSize;
// report that we successfully imported this mailbox
ReportStatus(APPLEMAILIMPORT_MAILBOX_SUCCESS, mailboxName, successLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_OK;
}
// let's import the messages!
nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
rv = messagesFolder->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
if (NS_FAILED(rv)) {
ReportStatus(APPLEMAILIMPORT_MAILBOX_CONVERTERROR, mailboxName, errorLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_ERROR_FAILURE;
}
// prepare an outstream to the destination file
nsCOMPtr<nsIOutputStream> outStream;
rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outStream), aDestination);
if (!outStream || NS_FAILED(rv)) {
ReportStatus(APPLEMAILIMPORT_MAILBOX_CONVERTERROR, mailboxName, errorLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_ERROR_FAILURE;
}
bool hasMore = false;
while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) && hasMore) {
// get the next file entry
nsCOMPtr<nsILocalFile> currentEntry;
{
nsCOMPtr<nsISupports> rawSupports;
directoryEnumerator->GetNext(getter_AddRefs(rawSupports));
if (!rawSupports)
continue;
currentEntry = do_QueryInterface(rawSupports);
if (!currentEntry)
continue;
}
// make sure it's an .emlx file
bool isFile = false;
currentEntry->IsFile(&isFile);
if (!isFile)
continue;
nsAutoString leafName;
currentEntry->GetLeafName(leafName);
if (!StringEndsWith(leafName, NS_LITERAL_STRING(".emlx")))
continue;
// add the data to the mbox stream
if (NS_SUCCEEDED(nsEmlxHelperUtils::AddEmlxMessageToStream(currentEntry, outStream)))
mProgress++;
}
}
// just indicate that we're done, using the same number that we used to estimate
// number of messages earlier.
PRUint32 finalSize;
aMailbox->GetSize(&finalSize);
mProgress = finalSize;
// report that we successfully imported this mailbox
ReportStatus(APPLEMAILIMPORT_MAILBOX_SUCCESS, mailboxName, successLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_OK;
}
NS_IMETHODIMP
nsAppleMailImportMail::ImportMailbox(nsIImportMailboxDescriptor *aMailbox,
nsIMsgFolder *aDstFolder,
char16_t **aErrorLog,
char16_t **aSuccessLog, bool *aFatalError)
{
nsAutoString errorLog, successLog;
// reset progress
mProgress = 0;
nsAutoString mailboxName;
aMailbox->GetDisplayName(getter_Copies(mailboxName));
nsCOMPtr<nsIFile> mboxFolder;
nsresult rv = aMailbox->GetFile(getter_AddRefs(mboxFolder));
if (NS_FAILED(rv) || !mboxFolder) {
ReportStatus(MOZ_UTF16("ApplemailImportMailboxConverterror"), mailboxName, errorLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_ERROR_FAILURE;
}
// if we're an account mailbox, nothing do. if we're a real mbox
// then we've got some messages to import!
uint32_t mailboxIdentifier;
aMailbox->GetIdentifier(&mailboxIdentifier);
if (mailboxIdentifier != kAccountMailboxID) {
// move to the .mbox's Messages folder
nsCOMPtr<nsIFile> messagesFolder;
mboxFolder->Clone(getter_AddRefs(messagesFolder));
rv = messagesFolder->Append(NS_LITERAL_STRING("Messages"));
if (NS_FAILED(rv)) {
// even if there are no messages, it might still be a valid mailbox, or even
// a parent for other mailboxes.
//
// just indicate that we're done, using the same number that we used to estimate
// number of messages earlier.
uint32_t finalSize;
aMailbox->GetSize(&finalSize);
mProgress = finalSize;
// report that we successfully imported this mailbox
ReportStatus(MOZ_UTF16("ApplemailImportMailboxSuccess"), mailboxName, successLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_OK;
}
// let's import the messages!
nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
rv = messagesFolder->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
if (NS_FAILED(rv)) {
ReportStatus(MOZ_UTF16("ApplemailImportMailboxConvertError"), mailboxName, errorLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_ERROR_FAILURE;
}
// prepare an outstream to the destination file
nsCOMPtr<nsIMsgPluggableStore> msgStore;
rv = aDstFolder->GetMsgStore(getter_AddRefs(msgStore));
if (!msgStore || NS_FAILED(rv)) {
ReportStatus(MOZ_UTF16("ApplemailImportMailboxConverterror"), mailboxName, errorLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_ERROR_FAILURE;
}
bool hasMore = false;
nsCOMPtr<nsIOutputStream> outStream;
while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) && hasMore) {
// get the next file entry
nsCOMPtr<nsIFile> currentEntry;
{
nsCOMPtr<nsISupports> rawSupports;
directoryEnumerator->GetNext(getter_AddRefs(rawSupports));
if (!rawSupports)
continue;
currentEntry = do_QueryInterface(rawSupports);
if (!currentEntry)
continue;
}
// make sure it's an .emlx file
bool isFile = false;
currentEntry->IsFile(&isFile);
if (!isFile)
continue;
nsAutoString leafName;
currentEntry->GetLeafName(leafName);
if (!StringEndsWith(leafName, NS_LITERAL_STRING(".emlx")))
continue;
nsCOMPtr<nsIMsgDBHdr> msgHdr;
bool reusable;
rv = msgStore->GetNewMsgOutputStream(aDstFolder, getter_AddRefs(msgHdr),
&reusable,
getter_AddRefs(outStream));
if (NS_FAILED(rv))
break;
// add the data to the mbox stream
if (NS_SUCCEEDED(nsEmlxHelperUtils::AddEmlxMessageToStream(currentEntry, outStream))) {
mProgress++;
msgStore->FinishNewMessage(outStream, msgHdr);
}
else {
msgStore->DiscardNewMessage(outStream, msgHdr);
break;
}
if (!reusable)
outStream->Close();
}
if (outStream)
outStream->Close();
}
// just indicate that we're done, using the same number that we used to estimate
// number of messages earlier.
uint32_t finalSize;
aMailbox->GetSize(&finalSize);
mProgress = finalSize;
// report that we successfully imported this mailbox
ReportStatus(MOZ_UTF16("ApplemailImportMailboxSuccess"), mailboxName, successLog);
SetLogs(successLog, errorLog, aSuccessLog, aErrorLog);
return NS_OK;
}
NS_IMETHODIMP nsImportGenericAddressBooks::BeginImport(nsISupportsString *successLog, nsISupportsString *errorLog, bool *_retval)
{
NS_PRECONDITION(_retval != nullptr, "null ptr");
if (!_retval)
return NS_ERROR_NULL_POINTER;
nsString success;
nsString error;
if (!m_doImport) {
*_retval = true;
nsImportStringBundle::GetStringByID(IMPORT_NO_ADDRBOOKS, m_stringBundle,
success);
SetLogs(success, error, successLog, errorLog);
return NS_OK;
}
if (!m_pInterface || !m_Books) {
nsImportStringBundle::GetStringByID(IMPORT_ERROR_AB_NOTINITIALIZED,
m_stringBundle, error);
SetLogs(success, error, successLog, errorLog);
*_retval = false;
return NS_OK;
}
bool needsFieldMap = false;
if (NS_FAILED(m_pInterface->GetNeedsFieldMap(m_pLocation, &needsFieldMap)) ||
(needsFieldMap && !m_pFieldMap)) {
nsImportStringBundle::GetStringByID(IMPORT_ERROR_AB_NOTINITIALIZED,
m_stringBundle, error);
SetLogs(success, error, successLog, errorLog);
*_retval = false;
return NS_OK;
}
NS_IF_RELEASE(m_pSuccessLog);
NS_IF_RELEASE(m_pErrorLog);
m_pSuccessLog = successLog;
m_pErrorLog = errorLog;
NS_IF_ADDREF(m_pSuccessLog);
NS_IF_ADDREF(m_pErrorLog);
// create the info need to drive address book import. We're
// not going to create a new thread for this since address books
// don't tend to be large, and import is rare.
m_pThreadData = new AddressThreadData();
m_pThreadData->books = m_Books;
NS_ADDREF(m_Books);
m_pThreadData->addressImport = m_pInterface;
NS_ADDREF(m_pInterface);
m_pThreadData->fieldMap = m_pFieldMap;
NS_IF_ADDREF(m_pFieldMap);
m_pThreadData->errorLog = m_pErrorLog;
NS_IF_ADDREF(m_pErrorLog);
m_pThreadData->successLog = m_pSuccessLog;
NS_IF_ADDREF(m_pSuccessLog);
if (m_pDestinationUri)
m_pThreadData->pDestinationUri = strdup(m_pDestinationUri);
uint32_t count = 0;
m_Books->GetLength(&count);
// Create/obtain any address books that we need here, so that we don't need
// to do so inside the import thread which would just proxy the create
// operations back to the main thread anyway.
nsCOMPtr<nsIAddrDatabase> db = GetAddressBookFromUri(m_pDestinationUri);
for (uint32_t i = 0; i < count; ++i)
{
nsCOMPtr<nsIImportABDescriptor> book = do_QueryElementAt(m_Books, i);
if (book)
{
if (!db)
{
nsString name;
book->GetPreferredName(name);
db = GetAddressBook(name.get(), true);
}
m_DBs.AppendObject(db);
}
}
m_pThreadData->dBs = &m_DBs;
NS_IF_ADDREF(m_pThreadData->stringBundle = m_stringBundle);
nsresult rv;
m_pThreadData->ldifService = do_GetService(NS_ABLDIFSERVICE_CONTRACTID, &rv);
ImportAddressThread(m_pThreadData);
delete m_pThreadData;
m_pThreadData = nullptr;
*_retval = true;
return NS_OK;
}
NS_IMETHODIMP nsImportGenericAddressBooks::BeginImport(nsISupportsString *successLog, nsISupportsString *errorLog, PRBool isAddrLocHome, PRBool *_retval)
{
NS_PRECONDITION(_retval != nsnull, "null ptr");
if (!_retval)
return NS_ERROR_NULL_POINTER;
nsString success;
nsString error;
if (!m_doImport) {
*_retval = PR_TRUE;
nsImportStringBundle::GetStringByID(IMPORT_NO_ADDRBOOKS, m_stringBundle,
success);
SetLogs( success, error, successLog, errorLog);
return( NS_OK);
}
if (!m_pInterface || !m_pBooks) {
nsImportStringBundle::GetStringByID(IMPORT_ERROR_AB_NOTINITIALIZED,
m_stringBundle, error);
SetLogs( success, error, successLog, errorLog);
*_retval = PR_FALSE;
return( NS_OK);
}
PRBool needsFieldMap = PR_FALSE;
if (NS_FAILED(m_pInterface->GetNeedsFieldMap(m_pLocation, &needsFieldMap)) ||
(needsFieldMap && !m_pFieldMap)) {
nsImportStringBundle::GetStringByID(IMPORT_ERROR_AB_NOTINITIALIZED,
m_stringBundle, error);
SetLogs(success, error, successLog, errorLog);
*_retval = PR_FALSE;
return NS_OK;
}
if (m_pThreadData) {
m_pThreadData->DriverAbort();
m_pThreadData = nsnull;
}
NS_IF_RELEASE( m_pSuccessLog);
NS_IF_RELEASE( m_pErrorLog);
m_pSuccessLog = successLog;
m_pErrorLog = errorLog;
NS_IF_ADDREF( m_pSuccessLog);
NS_IF_ADDREF( m_pErrorLog);
// kick off the thread to do the import!!!!
m_pThreadData = new AddressThreadData();
m_pThreadData->books = m_pBooks;
NS_ADDREF( m_pBooks);
m_pThreadData->addressImport = m_pInterface;
NS_ADDREF( m_pInterface);
m_pThreadData->fieldMap = m_pFieldMap;
NS_IF_ADDREF( m_pFieldMap);
m_pThreadData->errorLog = m_pErrorLog;
NS_IF_ADDREF( m_pErrorLog);
m_pThreadData->successLog = m_pSuccessLog;
NS_IF_ADDREF( m_pSuccessLog);
if (m_pDestinationUri)
m_pThreadData->pDestinationUri = strdup( m_pDestinationUri);
m_pThreadData->bAddrLocInput = isAddrLocHome ;
NS_IF_ADDREF(m_pThreadData->stringBundle = m_stringBundle);
nsresult rv;
nsCOMPtr<nsIAbLDIFService> ldifService(do_GetService(NS_ABLDIFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIProxyObjectManager> proxyObjectManager =
do_GetService(NS_XPCOMPROXY_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbLDIFService> proxyLDIFService;
rv = proxyObjectManager->GetProxyForObject(NS_PROXY_TO_CURRENT_THREAD,
NS_GET_IID(nsIAbLDIFService),
ldifService,
NS_PROXY_SYNC | NS_PROXY_ALWAYS,
getter_AddRefs(proxyLDIFService));
NS_ENSURE_SUCCESS(rv, rv);
NS_IF_ADDREF(m_pThreadData->ldifService = proxyLDIFService);
PRThread *pThread = PR_CreateThread( PR_USER_THREAD, &ImportAddressThread, m_pThreadData,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_UNJOINABLE_THREAD,
0);
if (!pThread) {
m_pThreadData->ThreadDelete();
m_pThreadData->DriverDelete();
m_pThreadData = nsnull;
*_retval = PR_FALSE;
nsImportStringBundle::GetStringByID(IMPORT_ERROR_AB_NOTHREAD,
m_stringBundle, error);
SetLogs( success, error, successLog, errorLog);
}
else
*_retval = PR_TRUE;
return( NS_OK);
}
NS_IMETHODIMP ImportOEMailImpl::ImportMailbox(nsIImportMailboxDescriptor *pSource,
nsIFile *pDestination,
PRUnichar **pErrorLog,
PRUnichar **pSuccessLog,
bool *fatalError)
{
NS_PRECONDITION(pSource != nsnull, "null ptr");
NS_PRECONDITION(pDestination != nsnull, "null ptr");
NS_PRECONDITION(fatalError != nsnull, "null ptr");
nsString success;
nsString error;
if (!pSource || !pDestination || !fatalError) {
nsOEStringBundle::GetStringByID(OEIMPORT_MAILBOX_BADPARAM, error);
if (fatalError)
*fatalError = true;
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_ERROR_NULL_POINTER;
}
bool abort = false;
nsString name;
nsString pName;
if (NS_SUCCEEDED(pSource->GetDisplayName(getter_Copies(pName))))
name = pName;
PRUint32 mailSize = 0;
pSource->GetSize(&mailSize);
if (mailSize == 0) {
ReportSuccess(name, 0, &success);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_OK;
}
nsCOMPtr <nsILocalFile> inFile;
if (NS_FAILED(pSource->GetFile(getter_AddRefs(inFile)))) {
ReportError(OEIMPORT_MAILBOX_BADSOURCEFILE, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_ERROR_FAILURE;
}
nsCString pPath;
inFile->GetNativePath(pPath);
IMPORT_LOG1("Importing Outlook Express mailbox: %s\n", pPath.get());
m_bytesDone = 0;
PRUint32 msgCount = 0;
nsresult rv;
if (nsOE5File::IsLocalMailFile(inFile)) {
IMPORT_LOG1("Importing OE5 mailbox: %s!\n", NS_LossyConvertUTF16toASCII(name.get()));
rv = nsOE5File::ImportMailbox(&m_bytesDone, &abort, name, inFile, pDestination, &msgCount);
}
else {
if (CImportMailbox::ImportMailbox(&m_bytesDone, &abort, name, inFile, pDestination, &msgCount))
rv = NS_OK;
else
rv = NS_ERROR_FAILURE;
}
if (NS_SUCCEEDED(rv))
ReportSuccess(name, msgCount, &success);
else
ReportError(OEIMPORT_MAILBOX_CONVERTERROR, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
return rv;
}
NS_IMETHODIMP
ImportEudoraMailImpl::ImportMailbox(nsIImportMailboxDescriptor *pSource,
nsIMsgFolder *pDstFolder,
PRUnichar **pErrorLog,
PRUnichar **pSuccessLog,
bool *fatalError)
{
NS_ENSURE_ARG_POINTER(pSource);
NS_ENSURE_ARG_POINTER(pDstFolder);
NS_ENSURE_ARG_POINTER(fatalError);
nsString success;
nsString error;
bool abort = false;
nsString name;
PRUnichar * pName;
if (NS_SUCCEEDED(pSource->GetDisplayName(&pName)))
{
name = pName;
NS_Free(pName);
}
PRUint32 mailSize = 0;
pSource->GetSize(&mailSize);
if (mailSize == 0)
{
IMPORT_LOG0("Mailbox size is 0, skipping mailbox.\n");
ReportSuccess(name, 0, &success);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_OK;
}
nsCOMPtr <nsIFile> inFile;
if (NS_FAILED(pSource->GetFile(getter_AddRefs(inFile))))
{
ReportError(EUDORAIMPORT_MAILBOX_BADSOURCEFILE, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
return NS_ERROR_FAILURE;
}
#ifdef IMPORT_DEBUG
nsCString pPath;
inFile->GetNativePath(pPath);
IMPORT_LOG1("Import mailbox: %s\n", pPath.get());
#endif
PRInt32 msgCount = 0;
nsresult rv = NS_OK;
m_bytes = 0;
rv = m_eudora.ImportMailbox( &m_bytes, &abort, name.get(), inFile, pDstFolder, &msgCount);
if (NS_SUCCEEDED(rv))
ReportSuccess(name, msgCount, &success);
else
ReportError(EUDORAIMPORT_MAILBOX_CONVERTERROR, name, &error);
SetLogs(success, error, pErrorLog, pSuccessLog);
IMPORT_LOG0("*** Returning from eudora mailbox import\n");
return rv;
}
NS_IMETHODIMP ImportAddressImpl::ImportAddressBook( nsIImportABDescriptor *pSource,
nsIAddrDatabase * pDestination,
nsIImportFieldMap * fieldMap,
PRBool isAddrLocHome,
PRUnichar ** pErrorLog,
PRUnichar ** pSuccessLog,
PRBool * fatalError)
{
NS_PRECONDITION(pSource != nsnull, "null ptr");
NS_PRECONDITION(pDestination != nsnull, "null ptr");
NS_PRECONDITION(fatalError != nsnull, "null ptr");
nsCOMPtr<nsIStringBundle> bundle( dont_AddRef( nsTextStringBundle::GetStringBundleProxy()));
m_bytesImported = 0;
nsString success;
nsString error;
if (!pSource || !pDestination || !fatalError) {
IMPORT_LOG0( "*** Bad param passed to text address import\n");
nsTextStringBundle::GetStringByID( TEXTIMPORT_ADDRESS_BADPARAM, error, bundle);
if (fatalError)
*fatalError = PR_TRUE;
SetLogs( success, error, pErrorLog, pSuccessLog);
return( NS_ERROR_NULL_POINTER);
}
ClearSampleFile();
PRBool addrAbort = PR_FALSE;
nsString name;
PRUnichar * pName;
if (NS_SUCCEEDED( pSource->GetPreferredName( &pName))) {
name = pName;
nsCRT::free( pName);
}
PRUint32 addressSize = 0;
pSource->GetSize( &addressSize);
if (addressSize == 0) {
IMPORT_LOG0( "Address book size is 0, skipping import.\n");
ReportSuccess( name, &success);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( NS_OK);
}
nsIFileSpec * inFile;
if (NS_FAILED( pSource->GetFileSpec( &inFile))) {
ReportError( TEXTIMPORT_ADDRESS_BADSOURCEFILE, name, &error);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( NS_ERROR_FAILURE);
}
nsXPIDLCString pPath;
inFile->GetNativePath(getter_Copies(pPath));
IMPORT_LOG1( "Importing address book: %s\n", pPath.get());
nsresult rv = NS_OK;
PRBool isLDIF = PR_FALSE;
nsCOMPtr<nsIAbLDIFService> ldifService = do_GetService(NS_ABLDIFSERVICE_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = ldifService->IsLDIFFile(inFile, &isLDIF);
if (NS_FAILED(rv)) {
IMPORT_LOG0( "*** Error reading address file\n");
}
}
if (NS_FAILED( rv)) {
inFile->Release();
ReportError( TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( rv);
}
if (isLDIF) {
if (ldifService)
rv = ldifService->ImportLDIFFile(pDestination, inFile, PR_FALSE, &m_bytesImported);
else
return NS_ERROR_FAILURE;
}
else {
rv = m_text.ImportAddresses( &addrAbort, name.get(), inFile, pDestination, fieldMap, error, &m_bytesImported);
SaveFieldMap( fieldMap);
}
inFile->Release();
if (NS_SUCCEEDED( rv) && error.IsEmpty()) {
ReportSuccess( name, &success);
}
else {
ReportError( TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error);
}
SetLogs( success, error, pErrorLog, pSuccessLog);
IMPORT_LOG0( "*** Text address import done\n");
return rv;
}
NS_IMETHODIMP ImportEudoraMailImpl::ImportMailbox(nsIImportMailboxDescriptor *pSource,
nsIFile *pDestination,
PRUnichar **pErrorLog,
PRUnichar **pSuccessLog,
bool *fatalError)
{
NS_PRECONDITION(pSource != nsnull, "null ptr");
NS_PRECONDITION(pDestination != nsnull, "null ptr");
NS_PRECONDITION(fatalError != nsnull, "null ptr");
nsString success;
nsString error;
if (!pSource || !pDestination || !fatalError)
{
IMPORT_LOG0( "*** Bad param passed to eudora mailbox import\n");
nsEudoraStringBundle::GetStringByID( EUDORAIMPORT_MAILBOX_BADPARAM, error);
if (fatalError)
*fatalError = true;
SetLogs( success, error, pErrorLog, pSuccessLog);
return NS_ERROR_NULL_POINTER;
}
bool abort = false;
nsString name;
PRUnichar * pName;
if (NS_SUCCEEDED( pSource->GetDisplayName( &pName)))
{
name = pName;
NS_Free( pName);
}
PRUint32 mailSize = 0;
pSource->GetSize( &mailSize);
if (mailSize == 0)
{
IMPORT_LOG0( "Mailbox size is 0, skipping mailbox.\n");
ReportSuccess( name, 0, &success);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( NS_OK);
}
nsCOMPtr <nsILocalFile> inFile;
if (NS_FAILED(pSource->GetFile( getter_AddRefs(inFile))))
{
ReportError( EUDORAIMPORT_MAILBOX_BADSOURCEFILE, name, &error);
SetLogs( success, error, pErrorLog, pSuccessLog);
return( NS_ERROR_FAILURE);
}
#ifdef IMPORT_DEBUG
nsCString pPath;
inFile->GetNativePath(pPath);
IMPORT_LOG1( "Import mailbox: %s\n", pPath.get());
#endif
PRInt32 msgCount = 0;
nsresult rv = NS_OK;
m_bytes = 0;
rv = m_eudora.ImportMailbox( &m_bytes, &abort, name.get(), inFile, pDestination, &msgCount);
if (NS_SUCCEEDED( rv))
ReportSuccess( name, msgCount, &success);
else
ReportError( EUDORAIMPORT_MAILBOX_CONVERTERROR, name, &error);
SetLogs( success, error, pErrorLog, pSuccessLog);
IMPORT_LOG0( "*** Returning from eudora mailbox import\n");
return( rv);
}
