summaryrefslogtreecommitdiffstats
path: root/mailnews/import/oexpress/nsOEScanBoxes.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'mailnews/import/oexpress/nsOEScanBoxes.cpp')
-rw-r--r--mailnews/import/oexpress/nsOEScanBoxes.cpp859
1 files changed, 859 insertions, 0 deletions
diff --git a/mailnews/import/oexpress/nsOEScanBoxes.cpp b/mailnews/import/oexpress/nsOEScanBoxes.cpp
new file mode 100644
index 000000000..7c30aa68d
--- /dev/null
+++ b/mailnews/import/oexpress/nsOEScanBoxes.cpp
@@ -0,0 +1,859 @@
+/* -*- Mode: C++; tab-width: 4; 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 "nsOEScanBoxes.h"
+#include "nsMsgUtils.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIImportService.h"
+#include "nsIFile.h"
+#include "nsIImportMailboxDescriptor.h"
+#include "nsOERegUtil.h"
+#include "nsOE5File.h"
+#include "nsNetUtil.h"
+#include "OEDebugLog.h"
+#include "nsIInputStream.h"
+#include "nsISeekableStream.h"
+#include "plstr.h"
+#include <windows.h>
+#include "nsIWindowsRegKey.h"
+
+#ifdef MOZILLA_INTERNAL_API
+#include "nsNativeCharsetUtils.h"
+#else
+#include "nsMsgI18N.h"
+#define NS_CopyNativeToUnicode(source, dest) \
+ nsMsgI18NConvertToUnicode(nsMsgI18NFileSystemCharset(), source, dest)
+#define NS_CopyUnicodeToNative(source, dest) \
+ nsMsgI18NConvertFromUnicode(nsMsgI18NFileSystemCharset(), source, dest)
+#endif
+
+/*
+ .nch file format???
+
+ offset 20 - long = offset to first record
+
+*/
+
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
+
+nsOEScanBoxes::nsOEScanBoxes()
+{
+ m_pFirst = nullptr;
+}
+
+nsOEScanBoxes::~nsOEScanBoxes()
+{
+ int i, max;
+ MailboxEntry *pEntry;
+ for (i = 0, max = m_entryArray.Length(); i < max; i++) {
+ pEntry = m_entryArray.ElementAt(i);
+ delete pEntry;
+ }
+ // Now free the unprocessed child entries (ie, those without parents for some reason).
+ for (i = 0, max = m_pendingChildArray.Length(); i < max; i++)
+ {
+ pEntry = m_pendingChildArray.ElementAt(i);
+ if (!pEntry->processed)
+ delete pEntry;
+ }
+}
+
+/*
+ 3.x & 4.x registry
+ Software/Microsoft/Outlook Express/
+
+ 5.0 registry
+ Identies - value of "Default User ID" is {GUID}
+ Identities/{GUID}/Software/Microsoft/Outlook Express/5.0/
+*/
+
+bool nsOEScanBoxes::Find50Mail(nsIFile *pWhere)
+{
+ nsAutoString userId;
+ nsresult rv = nsOERegUtil::GetDefaultUserId(userId);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ nsAutoString path(NS_LITERAL_STRING("Identities\\"));
+ path.Append(userId);
+ path.AppendLiteral("\\Software\\Microsoft\\Outlook Express\\5.0");
+
+ nsCOMPtr<nsIWindowsRegKey> key =
+ do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ rv = key->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
+ path,
+ nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ nsAutoString storeRoot;
+ key->ReadStringValue(NS_LITERAL_STRING("Store Root"), storeRoot);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ nsCOMPtr<nsIFile> localWhere = do_QueryInterface(pWhere);
+ localWhere->InitWithPath(storeRoot);
+
+ nsAutoCString nativeStoreRoot;
+ NS_CopyUnicodeToNative(storeRoot, nativeStoreRoot);
+ IMPORT_LOG1("Setting native path: %s\n", nativeStoreRoot.get());
+
+ bool isDir = false;
+ rv = localWhere->IsDirectory(&isDir);
+ return isDir;
+}
+
+bool nsOEScanBoxes::FindMail(nsIFile *pWhere)
+{
+ if (Find50Mail(pWhere))
+ return true;
+
+ nsresult rv;
+ nsCOMPtr<nsIWindowsRegKey> key =
+ do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ rv = key->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
+ NS_LITERAL_STRING("Software\\Microsoft\\Outlook Express"),
+ nsIWindowsRegKey::ACCESS_QUERY_VALUE);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ nsAutoString storeRoot;
+ key->ReadStringValue(NS_LITERAL_STRING("Store Root"), storeRoot);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ nsCOMPtr<nsIFile> localWhere = do_QueryInterface(pWhere);
+ localWhere->InitWithPath(storeRoot);
+ localWhere->AppendNative(NS_LITERAL_CSTRING("Mail"));
+
+ bool isDir = false;
+ localWhere->IsDirectory(&isDir);
+
+ return isDir;
+}
+
+bool nsOEScanBoxes::GetMailboxes(nsIFile *pWhere, nsIArray **pArray)
+{
+ nsCString path;
+ pWhere->GetNativePath(path);
+ if (!path.IsEmpty()) {
+ IMPORT_LOG1("Looking for mail in: %s\n", path.get());
+ }
+ else {
+ pWhere->GetNativeLeafName(path);
+ if (!path.IsEmpty())
+ IMPORT_LOG1("Looking for mail in: %s\n", path.get());
+ else
+ IMPORT_LOG0("Unable to get info about where to look for mail\n");
+ }
+
+ nsCOMPtr <nsIFile> location;
+ pWhere->Clone(getter_AddRefs(location));
+ // 1. Look for 5.0 folders.dbx
+ // 2. Look for 3.x & 4.x folders.nch
+ // 3. Look for 5.0 *.dbx mailboxes
+ // 4. Look for 3.x & 4.x *.mbx mailboxes
+
+ bool result;
+
+ location->AppendNative(NS_LITERAL_CSTRING("folders.dbx"));
+ if (Find50MailBoxes(location)) {
+ result = GetMailboxList(pWhere, pArray);
+ }
+ else {
+ // 2. Look for 4.x mailboxes
+ pWhere->Clone(getter_AddRefs(location));
+ location->AppendNative(NS_LITERAL_CSTRING("folders.nch"));
+
+ if (FindMailBoxes(location)) {
+ result = GetMailboxList(pWhere, pArray);
+ }
+ else {
+ // 3 & 4, look for the specific mailbox files.
+ pWhere->Clone(getter_AddRefs(location));
+ ScanMailboxDir(location);
+ result = GetMailboxList(pWhere, pArray);
+ }
+ }
+
+ return result;
+}
+
+
+
+void nsOEScanBoxes::Reset(void)
+{
+ int max = m_entryArray.Length();
+ for (int i = 0; i < max; i++) {
+ MailboxEntry *pEntry = m_entryArray.ElementAt(i);
+ delete pEntry;
+ }
+ m_entryArray.Clear();
+ m_pFirst = nullptr;
+}
+
+
+bool nsOEScanBoxes::FindMailBoxes(nsIFile* descFile)
+{
+ Reset();
+
+ nsresult rv;
+ bool isFile = false;
+
+ rv = descFile->IsFile(&isFile);
+ if (NS_FAILED(rv) || !isFile)
+ return false;
+
+ nsCOMPtr <nsIInputStream> descInputStream;
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(descInputStream), descFile);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ IMPORT_LOG0("Reading the folders.nch file\n");
+
+ uint32_t curRec;
+ if (!ReadLong(descInputStream, curRec, 20)) {
+ return false;
+ }
+
+ // Now for each record
+ bool done = false;
+ uint32_t equal;
+ uint32_t size;
+ uint32_t previous;
+ uint32_t next;
+ MailboxEntry * pEntry;
+ bool failed;
+
+ while (!done) {
+ if (!ReadLong(descInputStream, equal, curRec)) return false;
+ if (curRec != equal) {
+ IMPORT_LOG1("Record start invalid: %ld\n", curRec);
+ break;
+ }
+ if (!ReadLong(descInputStream, size, curRec + 4)) return false;
+ if (!ReadLong(descInputStream, previous, curRec + 8)) return false;
+ if (!ReadLong(descInputStream, next, curRec + 12)) return false;
+ failed = false;
+ pEntry = new MailboxEntry;
+ if (!ReadLong(descInputStream, pEntry->index, curRec + 16)) failed = true;
+ if (!ReadString(descInputStream, pEntry->mailName, curRec + 20)) failed = true;
+ if (!ReadString(descInputStream, pEntry->fileName, curRec + 279)) failed = true;
+ if (!ReadLong(descInputStream, pEntry->parent, curRec + 539)) failed = true;
+ if (!ReadLong(descInputStream, pEntry->child, curRec + 543)) failed = true;
+ if (!ReadLong(descInputStream, pEntry->sibling, curRec + 547)) failed = true;
+ if (!ReadLong(descInputStream, pEntry->type, curRec + 551)) failed = true;
+ if (failed) {
+ delete pEntry;
+ return false;
+ }
+
+ #ifdef _TRACE_MAILBOX_ENTRIES
+ IMPORT_LOG0("------------\n");
+ IMPORT_LOG2(" Offset: %lx, index: %ld\n", curRec, pEntry->index);
+ IMPORT_LOG2(" previous: %lx, next: %lx\n", previous, next);
+ IMPORT_LOG2(" Name: %S, File: %s\n", (char16_t *) pEntry->mailName, (const char *) pEntry->fileName);
+ IMPORT_LOG3(" Parent: %ld, Child: %ld, Sibling: %ld\n", pEntry->parent, pEntry->child, pEntry->sibling);
+ #endif
+
+ if (!StringEndsWith(pEntry->fileName, NS_LITERAL_CSTRING(".mbx")))
+ pEntry->fileName.Append(".mbx");
+
+ m_entryArray.AppendElement(pEntry);
+
+ curRec = next;
+ if (!next)
+ done = true;
+ }
+
+ MailboxEntry *pZero = GetIndexEntry(0);
+ if (pZero)
+ m_pFirst = GetIndexEntry(pZero->child);
+
+ IMPORT_LOG1("Read the folders.nch file, found %ld mailboxes\n", (long) m_entryArray.Length());
+
+ return true;
+}
+
+bool nsOEScanBoxes::Find50MailBoxes(nsIFile* descFile)
+{
+ Reset();
+
+ nsresult rv;
+ bool isFile = false;
+
+ rv = descFile->IsFile(&isFile);
+ if (NS_FAILED(rv) || !isFile)
+ return false;
+
+ nsCOMPtr <nsIInputStream> descInputStream;
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(descInputStream), descFile);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ IMPORT_LOG0("Reading the folders.dbx file\n");
+
+ uint32_t *pIndex;
+ uint32_t indexSize = 0;
+ if (!nsOE5File::ReadIndex(descInputStream, &pIndex, &indexSize)) {
+ IMPORT_LOG0("*** NOT USING FOLDERS.DBX!!!\n");
+ return false;
+ }
+
+ uint32_t marker;
+ uint32_t size;
+ char *pBytes;
+ uint32_t cntRead;
+ int32_t recordId;
+ int32_t strOffset;
+
+ uint8_t tag;
+ uint32_t data;
+ int32_t dataOffset;
+
+ uint32_t id;
+ uint32_t parent;
+ uint32_t numMessages;
+ char * pFileName;
+ char * pDataSource;
+
+ MailboxEntry * pEntry;
+ MailboxEntry * pLastEntry = nullptr;
+
+ uint32_t localStoreId = 0;
+
+ for (uint32_t i = 0; i < indexSize; i++) {
+ if (!ReadLong(descInputStream, marker, pIndex[i])) continue;
+ if (marker != pIndex[i]) continue;
+ if (!ReadLong(descInputStream, size, pIndex[i] + 4)) continue;
+ size += 4;
+ pBytes = new char[size];
+ rv = descInputStream->Read(pBytes, size, &cntRead);
+ if (NS_FAILED(rv) || ((uint32_t)cntRead != size)) {
+ delete [] pBytes;
+ continue;
+ }
+ recordId = pBytes[2];
+ strOffset = (recordId * 4) + 4;
+ if (recordId == 4)
+ strOffset += 4;
+
+ id = 0;
+ parent = 0;
+ numMessages = 0;
+ pFileName = nullptr;
+ pDataSource = nullptr;
+ dataOffset = 4;
+ while (dataOffset < strOffset) {
+ tag = (uint8_t) pBytes[dataOffset];
+
+ data = 0; // make sure all bytes are 0 before copying 3 bytes over.
+ memcpy(&data, &(pBytes[dataOffset + 1]), 3);
+ switch(tag) {
+ case 0x80: // id record
+ id = data;
+ break;
+ case 0x81: // parent id
+ parent = data;
+ break;
+ case 0x87: // number of messages in this mailbox
+ numMessages = data;
+ break;
+ case 0x03: // file name for this mailbox
+ if (((uint32_t)strOffset + data) < size)
+ pFileName = (char *)(pBytes + strOffset + data);
+ break;
+ case 0x05: // data source for this record (this is not a mailbox!)
+ if (((uint32_t)strOffset + data) < size)
+ pDataSource = (char *) (pBytes + strOffset + data);
+ break;
+ }
+ dataOffset += 4;
+ }
+
+ // now build an entry if necessary!
+ if (pDataSource) {
+ if (!PL_strcasecmp(pDataSource, "LocalStore"))
+ {
+ localStoreId = id;
+ // See if we have any child folders that need to be added/processed for this top level parent.
+ ProcessPendingChildEntries(localStoreId, localStoreId, m_pendingChildArray);
+ // Clean up the pending list.
+ RemoveProcessedChildEntries();
+ }
+ }
+ else if (id && localStoreId && parent) {
+ // veryify that this mailbox is in the local store
+ data = parent;
+ while (data && (data != localStoreId)) {
+ pEntry = GetIndexEntry(data);
+ if (pEntry)
+ data = pEntry->parent;
+ else
+ data = 0;
+ }
+ if (data == localStoreId) {
+ // Create an entry for this bugger
+ pEntry = NewMailboxEntry(id, parent, (const char *) (pBytes + strOffset), pFileName);
+ if (pEntry)
+ {
+ AddChildEntry(pEntry, localStoreId);
+ pEntry->processed = true;
+ // See if we have any child folders that need to be added/processed.
+ ProcessPendingChildEntries(id, localStoreId, m_pendingChildArray);
+ // Clean up the pending list.
+ RemoveProcessedChildEntries();
+ }
+ }
+ else
+ {
+ // Put this folder into child array and process it when its parent shows up.
+ pEntry = NewMailboxEntry(id, parent, (const char *) (pBytes + strOffset), pFileName);
+ if (pEntry)
+ m_pendingChildArray.AppendElement(pEntry);
+ }
+ }
+ else if (pFileName)
+ {
+ // Put this folder into child array and process it when its parent shows up.
+ // For some reason, it's likely that child folders come before their parents.
+ pEntry = NewMailboxEntry(id, parent, (const char *) (pBytes + strOffset), pFileName);
+ if (pEntry)
+ m_pendingChildArray.AppendElement(pEntry);
+ }
+
+ delete [] pBytes;
+ }
+
+
+ delete [] pIndex;
+
+ return m_entryArray.Length();
+}
+
+nsOEScanBoxes::MailboxEntry *nsOEScanBoxes::NewMailboxEntry(uint32_t id, uint32_t parent, const char *prettyName, char *pFileName)
+{
+ MailboxEntry *pEntry = new MailboxEntry();
+ if (!pEntry)
+ return nullptr;
+
+ pEntry->index = id;
+ pEntry->parent = parent;
+ pEntry->child = 0;
+ pEntry->type = 0;
+ pEntry->sibling = -1;
+ pEntry->processed = false;
+ NS_CopyNativeToUnicode(nsDependentCString(prettyName), pEntry->mailName);
+ if (pFileName)
+ pEntry->fileName = pFileName;
+ return pEntry;
+}
+
+void nsOEScanBoxes::ProcessPendingChildEntries(uint32_t parent, uint32_t rootIndex, nsTArray<MailboxEntry*> &childArray)
+{
+ int32_t i, max;
+ MailboxEntry *pEntry;
+ for (i = 0, max = childArray.Length(); i < max; i++)
+ {
+ pEntry = childArray.ElementAt(i);
+ if ((!pEntry->processed) && (pEntry->parent == parent))
+ {
+ AddChildEntry(pEntry, rootIndex);
+ pEntry->processed = true; // indicate it's been processed.
+ // See if there are unprocessed child folders for this child in the
+ // array as well (ie, both child and grand-child are on the list).
+ ProcessPendingChildEntries(pEntry->index, rootIndex, childArray);
+ }
+ }
+}
+
+void nsOEScanBoxes::RemoveProcessedChildEntries()
+{
+ // Remove already processed entries from the pending list. Note that these entries are also
+ // on 'm_entryArray' list so we don't want to deallocate the space for the entries now.
+ MailboxEntry * pEntry;
+ int32_t i;
+ for (i = m_pendingChildArray.Length()-1; i >= 0; i--)
+ {
+ pEntry = m_pendingChildArray.ElementAt(i);
+ if (pEntry->processed)
+ m_pendingChildArray.RemoveElementAt(i);
+ }
+}
+
+void nsOEScanBoxes::AddChildEntry(MailboxEntry *pEntry, uint32_t rootIndex)
+{
+ if (!m_pFirst) {
+ if (pEntry->parent == rootIndex) {
+ m_pFirst = pEntry;
+ m_entryArray.AppendElement(pEntry);
+ }
+ else {
+ delete pEntry;
+ }
+ return;
+ }
+
+ MailboxEntry * pParent = nullptr;
+ MailboxEntry * pSibling = nullptr;
+ if (pEntry->parent == rootIndex) {
+ pSibling = m_pFirst;
+ }
+ else {
+ pParent = GetIndexEntry(pEntry->parent);
+ }
+
+ if (!pParent && !pSibling) {
+ delete pEntry;
+ return;
+ }
+
+ if (pParent && (pParent->child == 0)) {
+ pParent->child = pEntry->index;
+ m_entryArray.AppendElement(pEntry);
+ return;
+ }
+
+ if (!pSibling)
+ pSibling = GetIndexEntry(pParent->child);
+
+ while (pSibling && (pSibling->sibling != -1)) {
+ pSibling = GetIndexEntry(pSibling->sibling);
+ }
+
+ if (!pSibling) {
+ delete pEntry;
+ return;
+ }
+
+ pSibling->sibling = pEntry->index;
+ m_entryArray.AppendElement(pEntry);
+}
+
+bool nsOEScanBoxes::Scan50MailboxDir(nsIFile * srcDir)
+{
+ Reset();
+
+ MailboxEntry *pEntry;
+ int32_t index = 1;
+ char *pLeaf;
+
+ bool hasMore;
+ nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
+ nsresult rv = srcDir->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
+ NS_ENSURE_SUCCESS(rv, false);
+
+ directoryEnumerator->HasMoreElements(&hasMore);
+ bool isFile;
+ nsCOMPtr<nsIFile> entry;
+ nsCString fName;
+
+ while (hasMore && NS_SUCCEEDED(rv))
+ {
+ nsCOMPtr<nsISupports> aSupport;
+ rv = directoryEnumerator->GetNext(getter_AddRefs(aSupport));
+ nsCOMPtr<nsIFile> entry(do_QueryInterface(aSupport, &rv));
+ directoryEnumerator->HasMoreElements(&hasMore);
+
+ isFile = false;
+ rv = entry->IsFile(&isFile);
+ if (NS_SUCCEEDED(rv) && isFile) {
+ pLeaf = nullptr;
+ rv = entry->GetNativeLeafName(fName);
+ if (NS_SUCCEEDED(rv) &&
+ (StringEndsWith(fName, NS_LITERAL_CSTRING(".dbx")))) {
+ // This is a *.dbx file in the mail directory
+ if (nsOE5File::IsLocalMailFile(entry)) {
+ pEntry = new MailboxEntry;
+ pEntry->index = index;
+ index++;
+ pEntry->parent = 0;
+ pEntry->child = 0;
+ pEntry->sibling = index;
+ pEntry->type = -1;
+ fName.SetLength(fName.Length() - 4);
+ pEntry->fileName = fName.get();
+ NS_CopyNativeToUnicode(fName, pEntry->mailName);
+ m_entryArray.AppendElement(pEntry);
+ }
+ }
+ }
+ }
+
+ if (m_entryArray.Length() > 0) {
+ pEntry = m_entryArray.ElementAt(m_entryArray.Length() - 1);
+ pEntry->sibling = -1;
+ return true;
+ }
+
+ return false;
+}
+
+void nsOEScanBoxes::ScanMailboxDir(nsIFile * srcDir)
+{
+ if (Scan50MailboxDir(srcDir))
+ return;
+
+ Reset();
+
+ MailboxEntry * pEntry;
+ int32_t index = 1;
+ nsAutoCString pLeaf;
+ uint32_t sLen;
+
+ bool hasMore;
+ nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
+ nsresult rv = srcDir->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ directoryEnumerator->HasMoreElements(&hasMore);
+ bool isFile;
+ nsCOMPtr<nsIFile> entry;
+ nsCString fName;
+ nsCString ext;
+ nsCString name;
+
+ while (hasMore && NS_SUCCEEDED(rv))
+ {
+ nsCOMPtr<nsISupports> aSupport;
+ rv = directoryEnumerator->GetNext(getter_AddRefs(aSupport));
+ nsCOMPtr<nsIFile> entry(do_QueryInterface(aSupport, &rv));
+ directoryEnumerator->HasMoreElements(&hasMore);
+
+ isFile = false;
+ rv = entry->IsFile(&isFile);
+ if (NS_SUCCEEDED(rv) && isFile)
+ {
+ rv = entry->GetNativeLeafName(pLeaf);
+ if (NS_SUCCEEDED(rv) && !pLeaf.IsEmpty() &&
+ ((sLen = pLeaf.Length()) > 4) &&
+ (!PL_strcasecmp(pLeaf.get() + sLen - 3, "mbx")))
+ {
+ // This is a *.mbx file in the mail directory
+ pEntry = new MailboxEntry;
+ pEntry->index = index;
+ index++;
+ pEntry->parent = 0;
+ pEntry->child = 0;
+ pEntry->sibling = index;
+ pEntry->type = -1;
+ pEntry->fileName = pLeaf;
+ pLeaf.SetLength(sLen - 4);
+ NS_CopyNativeToUnicode(pLeaf, pEntry->mailName);
+ m_entryArray.AppendElement(pEntry);
+ }
+ }
+ }
+
+ if (m_entryArray.Length() > 0) {
+ pEntry = m_entryArray.ElementAt(m_entryArray.Length() - 1);
+ pEntry->sibling = -1;
+ }
+}
+
+uint32_t nsOEScanBoxes::CountMailboxes(MailboxEntry *pBox)
+{
+ if (pBox == nullptr) {
+ if (m_pFirst != nullptr)
+ pBox = m_pFirst;
+ else {
+ if (m_entryArray.Length() > 0)
+ pBox = m_entryArray.ElementAt(0);
+ }
+ }
+ uint32_t count = 0;
+
+ MailboxEntry * pChild;
+ while (pBox) {
+ count++;
+ if (pBox->child) {
+ pChild = GetIndexEntry(pBox->child);
+ if (pChild != nullptr)
+ count += CountMailboxes(pChild);
+ }
+ if (pBox->sibling != -1) {
+ pBox = GetIndexEntry(pBox->sibling);
+ }
+ else
+ pBox = nullptr;
+ }
+
+ return count;
+}
+
+bool nsOEScanBoxes::GetMailboxList(nsIFile * root, nsIArray **pArray)
+{
+ nsresult rv;
+ nsCOMPtr<nsIMutableArray> array(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+ if (NS_FAILED(rv)) {
+ IMPORT_LOG0("FAILED to allocate the nsIArray\n");
+ return false;
+ }
+
+ BuildMailboxList(nullptr, root, 1, array);
+ array.forget(pArray);
+
+ return true;
+}
+
+void nsOEScanBoxes::BuildMailboxList(MailboxEntry *pBox, nsIFile * root, int32_t depth, nsIMutableArray *pArray)
+{
+ if (pBox == nullptr) {
+ if (m_pFirst != nullptr) {
+ pBox = m_pFirst;
+
+ IMPORT_LOG0("Assigning start of mailbox list to m_pFirst\n");
+ }
+ else {
+ if (m_entryArray.Length() > 0) {
+ pBox = m_entryArray.ElementAt(0);
+
+ IMPORT_LOG0("Assigning start of mailbox list to entry at index 0\n");
+ }
+ }
+
+ if (pBox == nullptr) {
+ IMPORT_LOG0("ERROR ASSIGNING STARTING MAILBOX\n");
+ }
+
+ }
+
+ nsresult rv;
+ nsCOMPtr<nsIFile> file;
+ MailboxEntry *pChild;
+ nsIImportMailboxDescriptor *pID;
+ nsISupports *pInterface;
+ int64_t size;
+
+ nsCOMPtr<nsIImportService> impSvc(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ while (pBox) {
+ rv = impSvc->CreateNewMailboxDescriptor(&pID);
+ if (NS_SUCCEEDED(rv)) {
+ pID->SetDepth(depth);
+ pID->SetIdentifier(pBox->index);
+ pID->SetDisplayName((char16_t *)pBox->mailName.get());
+ if (!pBox->fileName.IsEmpty()) {
+ pID->GetFile(getter_AddRefs(file));
+ file->InitWithFile(root);
+ file->AppendNative(pBox->fileName);
+ size = 0;
+ file->GetFileSize(&size);
+ pID->SetSize(size);
+ }
+ rv = pID->QueryInterface(kISupportsIID, (void **) &pInterface);
+ pArray->AppendElement(pInterface, false);
+ pInterface->Release();
+ pID->Release();
+ }
+
+ if (pBox->child) {
+ pChild = GetIndexEntry(pBox->child);
+ if (pChild != nullptr)
+ BuildMailboxList(pChild, root, depth + 1, pArray);
+ }
+ if (pBox->sibling != -1) {
+ pBox = GetIndexEntry(pBox->sibling);
+ }
+ else
+ pBox = nullptr;
+ }
+
+}
+
+nsOEScanBoxes::MailboxEntry * nsOEScanBoxes::GetIndexEntry(uint32_t index)
+{
+ int32_t max = m_entryArray.Length();
+ for (int32_t i = 0; i < max; i++) {
+ MailboxEntry *pEntry = m_entryArray.ElementAt(i);
+ if (pEntry->index == index)
+ return pEntry;
+ }
+
+ return nullptr;
+}
+
+
+// -------------------------------------------------------
+// File utility routines
+// -------------------------------------------------------
+
+bool nsOEScanBoxes::ReadLong(nsIInputStream * stream, int32_t& val, uint32_t offset)
+{
+ nsresult rv;
+ nsCOMPtr <nsISeekableStream> seekStream = do_QueryInterface(stream, &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, offset);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ uint32_t cntRead;
+ char * pReadTo = (char *)&val;
+ rv = stream->Read(pReadTo, sizeof(val), &cntRead);
+
+ return NS_SUCCEEDED(rv) && cntRead == sizeof(val);
+}
+
+bool nsOEScanBoxes::ReadLong(nsIInputStream * stream, uint32_t& val, uint32_t offset)
+{
+ nsresult rv;
+ nsCOMPtr <nsISeekableStream> seekStream = do_QueryInterface(stream, &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+ rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, offset);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ uint32_t cntRead;
+ char * pReadTo = (char *)&val;
+ rv = stream->Read(pReadTo, sizeof(val), &cntRead);
+ if (NS_FAILED(rv) || (cntRead != sizeof(val)))
+ return false;
+
+ return true;
+}
+
+// It appears as though the strings for file name and mailbox
+// name are at least 254 chars - verified - they are probably 255
+// but why bother going that far! If a file name is that long then
+// the heck with it.
+#define kOutlookExpressStringLength 252
+bool nsOEScanBoxes::ReadString(nsIInputStream * stream, nsString& str, uint32_t offset)
+{
+ nsresult rv;
+ nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(stream, &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, offset);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ uint32_t cntRead;
+ char buffer[kOutlookExpressStringLength];
+ char *pReadTo = buffer;
+ rv = stream->Read(pReadTo, kOutlookExpressStringLength, &cntRead);
+ if (NS_FAILED(rv) || (cntRead != kOutlookExpressStringLength))
+ return false;
+
+ buffer[kOutlookExpressStringLength - 1] = 0;
+ str.AssignASCII(buffer);
+ return true;
+}
+
+bool nsOEScanBoxes::ReadString(nsIInputStream * stream, nsCString& str, uint32_t offset)
+{
+ nsresult rv;
+ nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(stream, &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, offset);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ uint32_t cntRead;
+ char buffer[kOutlookExpressStringLength];
+ char *pReadTo = buffer;
+ rv = stream->Read(pReadTo, kOutlookExpressStringLength, &cntRead);
+ if (NS_FAILED(rv) || (cntRead != kOutlookExpressStringLength))
+ return false;
+
+ buffer[kOutlookExpressStringLength - 1] = 0;
+ str = buffer;
+ return true;
+}