archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/inetcore/outlookexpress/migrate/upoe5.cpp

2857 lines
91 KiB
Raw Blame History

// --------------------------------------------------------------------------------
// upoe5.cpp
// --------------------------------------------------------------------------------
#include "pch.hxx"
#include "utility.h"
#include "migrate.h"
#include "migerror.h"
#include "structs.h"
#include "resource.h"
#define DEFINE_DIRECTDB
#include <shared.h>
#include <oestore.h>
#include <oerules.h>
#include <mimeole.h>
#include "msident.h"
// --------------------------------------------------------------------------------
// Linearly Incrementing Folder Id
// --------------------------------------------------------------------------------
static DWORD g_idFolderNext=1000;
extern BOOL g_fQuiet;
// --------------------------------------------------------------------------------
// FOLDERIDCHANGE
// --------------------------------------------------------------------------------
typedef struct tagFOLDERIDCHANGE {
FOLDERID idOld;
FOLDERID idNew;
} FOLDERIDCHANGE, *LPFOLDERIDCHANGE;
// --------------------------------------------------------------------------------
// Forward Declarations
// --------------------------------------------------------------------------------
HRESULT SetIMAPSpecialFldrType(LPSTR pszAcctID, LPSTR pszFldrName, SPECIALFOLDER *psfType);
// --------------------------------------------------------------------------------
// SplitMailCacheBlob
// --------------------------------------------------------------------------------
HRESULT SplitMailCacheBlob(IMimePropertySet *pNormalizer, LPBYTE pbCacheInfo,
DWORD cbCacheInfo, LPMESSAGEINFO pMsgInfo, LPSTR *ppszNormal, LPBLOB pOffsets)
{
// Locals
HRESULT hr=S_OK;
ULONG ib;
ULONG cbTree;
ULONG cbProps;
WORD wVersion;
DWORD dw;
DWORD cbMsg;
DWORD dwFlags;
WORD wPriority;
PROPVARIANT Variant;
// Invalid Arg
Assert(pbCacheInfo && cbCacheInfo && pMsgInfo);
// Init
ZeroMemory(pOffsets, sizeof(BLOB));
// Read Version
ib = 0;
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&wVersion, sizeof(wVersion)));
// Version Check
if (wVersion != MSG_HEADER_VERSISON)
{
hr = TraceResult(E_FAIL);
goto exit;
}
// Read Flags
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dwFlags, sizeof(dwFlags)));
// IMF_ATTACHMENTS
if (ISFLAGSET(dwFlags, IMF_ATTACHMENTS))
FLAGSET(pMsgInfo->dwFlags, ARF_HASATTACH);
// IMF_SIGNED
if (ISFLAGSET(dwFlags, IMF_SIGNED))
FLAGSET(pMsgInfo->dwFlags, ARF_SIGNED);
// IMF_ENCRYPTED
if (ISFLAGSET(dwFlags, IMF_ENCRYPTED))
FLAGSET(pMsgInfo->dwFlags, ARF_ENCRYPTED);
// IMF_VOICEMAIL
if (ISFLAGSET(dwFlags, IMF_VOICEMAIL))
FLAGSET(pMsgInfo->dwFlags, ARF_VOICEMAIL);
// IMF_NEWS
if (ISFLAGSET(dwFlags, IMF_NEWS))
FLAGSET(pMsgInfo->dwFlags, ARF_NEWSMSG);
// Read Reserved
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
// Read Message Size
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&cbMsg, sizeof(cbMsg)));
// Read Byte Count for the content list
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&cbTree, sizeof(cbTree)));
// Does the user want the tree ?
if (cbTree)
{
pOffsets->pBlobData = (pbCacheInfo + ib);
pOffsets->cbSize = cbTree;
}
// Increment passed the tree
ib += cbTree;
// Read Byte Count for the content list
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&cbProps, sizeof(cbProps)));
// Partial Number
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&pMsgInfo->dwPartial, sizeof(pMsgInfo->dwPartial)));
// Receive Time
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&pMsgInfo->ftReceived, sizeof(pMsgInfo->ftReceived)));
// Sent Time
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&pMsgInfo->ftSent, sizeof(pMsgInfo->ftSent)));
// Priority
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&wPriority, sizeof(wPriority)));
// Pritority
pMsgInfo->wPriority = wPriority;
// Subject
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszSubject = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Init the Normalizer
pNormalizer->InitNew();
// Set the Subject
Variant.vt = VT_LPSTR;
Variant.pszVal = pMsgInfo->pszSubject;
// Set the Property
IF_FAILEXIT(hr = pNormalizer->SetProp(PIDTOSTR(PID_HDR_SUBJECT), 0, &Variant));
// Get the Normalized Subject back out
if (SUCCEEDED(pNormalizer->GetProp(PIDTOSTR(PID_ATT_NORMSUBJ), 0, &Variant)))
*ppszNormal = pMsgInfo->pszNormalSubj = Variant.pszVal;
// Otherwise, just use the subject
else
pMsgInfo->pszNormalSubj = pMsgInfo->pszSubject;
// Display To
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszDisplayTo = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Display From
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszDisplayFrom = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Server
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszServer = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// UIDL
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszUidl = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// User Name
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
//pMsgInfo->pszUserName = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Account Name
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszAcctName = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Partial Id
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszPartialId = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Forward To
IF_FAILEXIT(hr = BlobReadData(pbCacheInfo, cbCacheInfo, &ib, (LPBYTE)&dw, sizeof(dw)));
pMsgInfo->pszForwardTo = (LPSTR)(pbCacheInfo + ib);
ib += dw;
// Sanity Check
Assert(ib == cbCacheInfo);
exit:
// Done
return hr;
}
//--------------------------------------------------------------------------
// GetMsgInfoFromPropertySet
//--------------------------------------------------------------------------
HRESULT GetMsgInfoFromPropertySet(
/* in */ IMimePropertySet *pPropertySet,
/* in,out */ LPMESSAGEINFO pMsgInfo)
{
// Locals
HRESULT hr=S_OK;
IMSGPRIORITY priority;
PROPVARIANT Variant;
SYSTEMTIME st;
FILETIME ftCurrent;
IMimeAddressTable *pAdrTable=NULL;
// Trace
TraceCall("GetMsgInfoFromPropertySet");
// Invalid Args
Assert(pPropertySet && pMsgInfo);
// Default Sent and Received Times...
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ftCurrent);
// Set Variant tyStore
Variant.vt = VT_UI4;
// Priority
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_PRIORITY), 0, &Variant)))
{
// Set Priority
pMsgInfo->wPriority = (WORD)Variant.ulVal;
}
// Partial Numbers...
if (pPropertySet->IsContentType(STR_CNT_MESSAGE, STR_SUB_PARTIAL) == S_OK)
{
// Locals
WORD cParts=0, iPart=0;
// Get Total
if (SUCCEEDED(pPropertySet->GetProp(STR_PAR_TOTAL, NOFLAGS, &Variant)))
cParts = (WORD)Variant.ulVal;
// Get Number
if (SUCCEEDED(pPropertySet->GetProp(STR_PAR_NUMBER, NOFLAGS, &Variant)))
iPart = (WORD)Variant.ulVal;
// Set Parts
pMsgInfo->dwPartial = MAKELONG(cParts, iPart);
}
// Otherwise, check for user property
else if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_COMBINED), NOFLAGS, &Variant)))
{
// Set the Partial Id
pMsgInfo->dwPartial = Variant.ulVal;
}
// Getting some file times
Variant.vt = VT_FILETIME;
// Get Received Time...
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_RECVTIME), 0, &Variant)))
pMsgInfo->ftReceived = Variant.filetime;
else
pMsgInfo->ftReceived = ftCurrent;
// Get Sent Time...
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_SENTTIME), 0, &Variant)))
pMsgInfo->ftSent = Variant.filetime;
else
pMsgInfo->ftSent = ftCurrent;
// Get Address Table
IF_FAILEXIT(hr = pPropertySet->BindToObject(IID_IMimeAddressTable, (LPVOID *)&pAdrTable));
// Display From
pAdrTable->GetFormat(IAT_FROM, AFT_DISPLAY_FRIENDLY, &pMsgInfo->pszDisplayFrom);
// Display To
pAdrTable->GetFormat(IAT_TO, AFT_DISPLAY_FRIENDLY, &pMsgInfo->pszDisplayTo);
// String Properties
Variant.vt = VT_LPSTR;
// pszDisplayFrom as newsgroups
if (NULL == pMsgInfo->pszDisplayFrom && SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_HDR_NEWSGROUPS), NOFLAGS, &Variant)))
pMsgInfo->pszDisplayFrom = Variant.pszVal;
// pszMessageId
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_HDR_MESSAGEID), NOFLAGS, &Variant)))
pMsgInfo->pszMessageId = Variant.pszVal;
// pszXref
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_HDR_XREF), NOFLAGS, &Variant)))
pMsgInfo->pszXref = Variant.pszVal;
// pszReferences
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(STR_HDR_REFS), NOFLAGS, &Variant)))
pMsgInfo->pszReferences = Variant.pszVal;
// pszSubject
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_HDR_SUBJECT), NOFLAGS, &Variant)))
pMsgInfo->pszSubject = Variant.pszVal;
// Normalized Subject
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_NORMSUBJ), NOFLAGS, &Variant)))
pMsgInfo->pszNormalSubj = Variant.pszVal;
// pszAccount
if (SUCCEEDED(pPropertySet->GetProp(STR_ATT_ACCOUNTNAME, NOFLAGS, &Variant)))
pMsgInfo->pszAcctName = Variant.pszVal;
// pszServer
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_SERVER), NOFLAGS, &Variant)))
pMsgInfo->pszServer = Variant.pszVal;
// pszUidl
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_UIDL), NOFLAGS, &Variant)))
pMsgInfo->pszUidl = Variant.pszVal;
// pszPartialId
if (pMsgInfo->dwPartial != 0 && SUCCEEDED(pPropertySet->GetProp(STR_PAR_ID, NOFLAGS, &Variant)))
pMsgInfo->pszPartialId = Variant.pszVal;
// ForwardTo
if (SUCCEEDED(pPropertySet->GetProp(PIDTOSTR(PID_ATT_FORWARDTO), NOFLAGS, &Variant)))
pMsgInfo->pszForwardTo = Variant.pszVal;
exit:
// Cleanup
SafeRelease(pAdrTable);
// Done
return hr;
}
//--------------------------------------------------------------------------
// GetMsgInfoFromMessage
//--------------------------------------------------------------------------
HRESULT GetMsgInfoFromMessage(IMimeMessage *pMessage, LPMESSAGEINFO pMsgInfo,
LPBLOB pOffsets)
{
// Locals
HRESULT hr=S_OK;
DWORD dwImf;
IMSGPRIORITY priority;
PROPVARIANT Variant;
SYSTEMTIME st;
FILETIME ftCurrent;
CByteStream cByteStm;
IMimePropertySet *pPropertySet=NULL;
// Trace
TraceCall("GetMsgInfoFromMessage");
// Invalid Args
Assert(pMessage && pMsgInfo);
// Get the Root Property Set from the Message
IF_FAILEXIT(hr = pMessage->BindToObject(HBODY_ROOT, IID_IMimePropertySet, (LPVOID *)&pPropertySet));
// File pMsgInfo from pPropertySet
IF_FAILEXIT(hr = GetMsgInfoFromPropertySet(pPropertySet, pMsgInfo));
// Get Message Flags
if (SUCCEEDED(pMessage->GetFlags(&dwImf)))
{
// IMF_ATTACHMENTS
if (ISFLAGSET(dwImf, IMF_ATTACHMENTS))
FLAGSET(pMsgInfo->dwFlags, ARF_HASATTACH);
// IMF_SIGNED
if (ISFLAGSET(dwImf, IMF_SIGNED))
FLAGSET(pMsgInfo->dwFlags, ARF_SIGNED);
// IMF_ENCRYPTED
if (ISFLAGSET(dwImf, IMF_ENCRYPTED))
FLAGSET(pMsgInfo->dwFlags, ARF_ENCRYPTED);
// IMF_VOICEMAIL
if (ISFLAGSET(dwImf, IMF_VOICEMAIL))
FLAGSET(pMsgInfo->dwFlags, ARF_VOICEMAIL);
// IMF_NEWS
if (ISFLAGSET(dwImf, IMF_NEWS))
FLAGSET(pMsgInfo->dwFlags, ARF_NEWSMSG);
}
// Get the Message Size
pMessage->GetMessageSize(&pMsgInfo->cbMessage, 0);
// Create the offset table
if (SUCCEEDED(pMessage->SaveOffsetTable(&cByteStm, 0)))
{
// pull the Bytes out of cByteStm
cByteStm.AcquireBytes(&pOffsets->cbSize, &pOffsets->pBlobData, ACQ_DISPLACE);
}
exit:
// Cleanup
SafeRelease(pPropertySet);
// Done
return hr;
}
//--------------------------------------------------------------------------
// FreeMsgInfo
//--------------------------------------------------------------------------
void FreeMsgInfo(
/* in,out */ LPMESSAGEINFO pMsgInfo)
{
// Trace
TraceCall("FreeMsgInfo");
// Invalid Args
Assert(pMsgInfo && NULL == pMsgInfo->pAllocated);
// Free The Dude
g_pMalloc->Free(pMsgInfo->pszMessageId);
g_pMalloc->Free(pMsgInfo->pszNormalSubj);
g_pMalloc->Free(pMsgInfo->pszSubject);
g_pMalloc->Free(pMsgInfo->pszFromHeader);
g_pMalloc->Free(pMsgInfo->pszReferences);
g_pMalloc->Free(pMsgInfo->pszXref);
g_pMalloc->Free(pMsgInfo->pszServer);
g_pMalloc->Free(pMsgInfo->pszDisplayFrom);
g_pMalloc->Free(pMsgInfo->pszEmailFrom);
g_pMalloc->Free(pMsgInfo->pszDisplayTo);
g_pMalloc->Free(pMsgInfo->pszUidl);
g_pMalloc->Free(pMsgInfo->pszPartialId);
g_pMalloc->Free(pMsgInfo->pszForwardTo);
g_pMalloc->Free(pMsgInfo->pszAcctName);
g_pMalloc->Free(pMsgInfo->pszAcctId);
// Zero It
ZeroMemory(pMsgInfo, sizeof(MESSAGEINFO));
}
// --------------------------------------------------------------------------------
// UpgradeLocalStoreFileV5
// --------------------------------------------------------------------------------
HRESULT UpgradeLocalStoreFileV5(LPFILEINFO pInfo, LPMEMORYFILE pFile,
IDatabase *pDB, LPPROGRESSINFO pProgress, BOOL *pfContinue)
{
// Locals
HRESULT hr=S_OK;
CHAR szIdxPath[MAX_PATH];
DWORD i;
LPBYTE pbStream;
LPBYTE pbCacheBlob;
SYSTEMTIME st;
MESSAGEINFO MsgInfo={0};
LPSTR pszNormal=NULL;
MESSAGEINFO MsgInfoFree={0};
DWORD faIdxRead;
IStream *pStream=NULL;
IMimeMessage *pMessage=NULL;
BLOB Offsets;
LPBYTE pbFree=NULL;
MEMORYFILE IdxFile;
LPMEMORYFILE pIdxFile=NULL;
LPMEMORYFILE pMbxFile=pFile;
LPMBXFILEHEADER pMbxHeader=NULL;
LPIDXFILEHEADER pIdxHeader=NULL;
LPIDXMESSAGEHEADER pIdxMessage=NULL;
LPMBXMESSAGEHEADER pMbxMessage=NULL;
IMimePropertySet *pNormalizer=NULL;
LARGE_INTEGER liOrigin={0,0};
// Trace
TraceCall("UpgradeLocalStoreFileV5");
// Get System Time
GetSystemTime(&st);
// Create a Property Set for Normalizing Subjects
IF_FAILEXIT(hr = CoCreateInstance(CLSID_IMimePropertySet, NULL, CLSCTX_INPROC_SERVER, IID_IMimePropertySet, (LPVOID *)&pNormalizer));
// Split the Path
ReplaceExtension(pInfo->szFilePath, ".idx", szIdxPath, ARRAYSIZE(szIdxPath));
// Open the memory file
hr = OpenMemoryFile(szIdxPath, &IdxFile);
if (FAILED(hr))
{
*pfContinue = TRUE;
TraceResult(hr);
goto exit;
}
// Set pIdxFile
pIdxFile = &IdxFile;
// Don't use pFile
pFile = NULL;
// Read the Mbx File Header
pMbxHeader = (LPMBXFILEHEADER)(pMbxFile->pView);
// Read the Idx File Header
pIdxHeader = (LPIDXFILEHEADER)(pIdxFile->pView);
// Validate the Version of th idx file
if (pIdxHeader->ver != CACHEFILE_VER || pIdxHeader->dwMagic != CACHEFILE_MAGIC)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_INVALIDIDXHEADER);
goto exit;
}
// Setup faIdxRead
faIdxRead = sizeof(IDXFILEHEADER);
// Prepare to Loop
for (i=0; i<pIdxHeader->cMsg; i++)
{
// Done
if (faIdxRead >= pIdxFile->cbSize)
break;
// Read an idx message header
pIdxMessage = (LPIDXMESSAGEHEADER)((LPBYTE)pIdxFile->pView + faIdxRead);
// If this message is not marked as deleted...
if (ISFLAGSET(pIdxMessage->dwState, MSG_DELETED))
goto NextMessage;
// Zero Out the MsgInfo Structure
ZeroMemory(&MsgInfo, sizeof(MESSAGEINFO));
// Start filling message
MsgInfo.idMessage = (MESSAGEID)IntToPtr(pIdxMessage->msgid);
// Fixup the Flags
if (FALSE == ISFLAGSET(pIdxMessage->dwState, MSG_UNREAD))
FLAGSET(MsgInfo.dwFlags, ARF_READ);
if (ISFLAGSET(pIdxMessage->dwState, MSG_VOICEMAIL))
FLAGSET(MsgInfo.dwFlags, ARF_VOICEMAIL);
if (ISFLAGSET(pIdxMessage->dwState, MSG_REPLIED))
FLAGSET(MsgInfo.dwFlags, ARF_REPLIED);
if (ISFLAGSET(pIdxMessage->dwState, MSG_FORWARDED))
FLAGSET(MsgInfo.dwFlags, ARF_FORWARDED);
if (ISFLAGSET(pIdxMessage->dwState, MSG_FLAGGED))
FLAGSET(MsgInfo.dwFlags, ARF_FLAGGED);
if (ISFLAGSET(pIdxMessage->dwState, MSG_RCPTSENT))
FLAGSET(MsgInfo.dwFlags, ARF_RCPTSENT);
if (ISFLAGSET(pIdxMessage->dwState, MSG_NOSECUI))
FLAGSET(MsgInfo.dwFlags, ARF_NOSECUI);
if (ISFLAGSET(pIdxMessage->dwState, MSG_NEWSMSG))
FLAGSET(MsgInfo.dwFlags, ARF_NEWSMSG);
if (ISFLAGSET(pIdxMessage->dwState, MSG_UNSENT))
FLAGSET(MsgInfo.dwFlags, ARF_UNSENT);
if (ISFLAGSET(pIdxMessage->dwState, MSG_SUBMITTED))
FLAGSET(MsgInfo.dwFlags, ARF_SUBMITTED);
if (ISFLAGSET(pIdxMessage->dwState, MSG_RECEIVED))
FLAGSET(MsgInfo.dwFlags, ARF_RECEIVED);
// Zero Offsets
ZeroMemory(&Offsets, sizeof(BLOB));
// Do the Blob
if (pIdxHeader->verBlob == MAIL_BLOB_VER)
{
// Get the blob
pbCacheBlob = (LPBYTE)((LPBYTE)pIdxFile->pView + (faIdxRead + (sizeof(IDXMESSAGEHEADER) - 4)));
// Split the Cache Blob
if (FAILED(SplitMailCacheBlob(pNormalizer, pbCacheBlob, pIdxMessage->dwHdrSize, &MsgInfo, &pszNormal, &Offsets)))
goto NextMessage;
// Save the Language
MsgInfo.wLanguage = LOWORD(pIdxMessage->dwLanguage);
// Save the Highlight
MsgInfo.wHighlight = HIWORD(pIdxMessage->dwLanguage);
}
// Bad
if (pIdxMessage->dwOffset > pMbxFile->cbSize)
goto NextMessage;
// Lets read the message header in the mbx file to validate the msgids
pMbxMessage = (LPMBXMESSAGEHEADER)((LPBYTE)pMbxFile->pView + pIdxMessage->dwOffset);
// Set Sizes
MsgInfo.cbMessage = pMbxMessage->dwBodySize;
// Validate the Message Ids
if (pMbxMessage->msgid != pIdxMessage->msgid)
goto NextMessage;
// Check for magic
if (pMbxMessage->dwMagic != MSGHDR_MAGIC)
goto NextMessage;
// Has a Body
FLAGSET(MsgInfo.dwFlags, ARF_HASBODY);
// Create a Virtual Stream
IF_FAILEXIT(hr = pDB->CreateStream(&MsgInfo.faStream));
// Open the Stream
IF_FAILEXIT(hr = pDB->OpenStream(ACCESS_WRITE, MsgInfo.faStream, &pStream));
// Get the stream pointer
pbStream = (LPBYTE)((LPBYTE)pMbxFile->pView + (pIdxMessage->dwOffset + sizeof(MBXMESSAGEHEADER)));
// Write this
IF_FAILEXIT(hr = pStream->Write(pbStream, pMbxMessage->dwBodySize, NULL));
// Commit
IF_FAILEXIT(hr = pStream->Commit(STGC_DEFAULT));
// If not an OE4+ blob, then generate the msginfo from the message
if (pIdxHeader->verBlob != MAIL_BLOB_VER)
{
// Create an IMimeMessage
IF_FAILEXIT(hr = CoCreateInstance(CLSID_IMimeMessage, NULL, CLSCTX_INPROC_SERVER, IID_IMimeMessage, (LPVOID *)&pMessage));
// Rewind
if (FAILED(pStream->Seek(liOrigin, STREAM_SEEK_SET, NULL)))
goto NextMessage;
// Load the Message
if (FAILED(pMessage->Load(pStream)))
goto NextMessage;
// Get MsgInfo from the Message
if (FAILED(GetMsgInfoFromMessage(pMessage, &MsgInfo, &Offsets)))
goto NextMessage;
// Free
pbFree = Offsets.pBlobData;
// Free This MsgInfo
CopyMemory(&MsgInfoFree, &MsgInfo, sizeof(MESSAGEINFO));
}
// Set MsgInfo Offsets
MsgInfo.Offsets = Offsets;
// Save Downloaded Time
SystemTimeToFileTime(&st, &MsgInfo.ftDownloaded);
// Lookup Account Id from the Account Name...
if (MsgInfo.pszAcctName)
{
// Loop through the Accounts
for (DWORD i=0; i<g_AcctTable.cAccounts; i++)
{
// Is this the Account
if (lstrcmpi(g_AcctTable.prgAccount[i].szAcctName, MsgInfo.pszAcctName) == 0)
{
MsgInfo.pszAcctId = g_AcctTable.prgAccount[i].szAcctId;
break;
}
}
}
// Count
pInfo->cMessages++;
if (!ISFLAGSET(MsgInfo.dwFlags, ARF_READ))
pInfo->cUnread++;
// Migrated
FLAGSET(MsgInfo.dwFlags, 0x00000010);
// Store the Record
IF_FAILEXIT(hr = pDB->InsertRecord(&MsgInfo));
NextMessage:
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pInfo);
// Cleanup
SafeRelease(pStream);
SafeRelease(pMessage);
SafeMemFree(pszNormal);
SafeMemFree(pbFree);
FreeMsgInfo(&MsgInfoFree);
// Goto Next Header
Assert(pIdxMessage);
// Update faIdxRead
faIdxRead += pIdxMessage->dwSize;
}
exit:
// Cleanup
SafeRelease(pStream);
SafeRelease(pMessage);
SafeRelease(pNormalizer);
SafeMemFree(pszNormal);
SafeMemFree(pbFree);
FreeMsgInfo(&MsgInfoFree);
if (pIdxFile)
CloseMemoryFile(pIdxFile);
// Done
return hr;
}
// --------------------------------------------------------------------------------
// GetRecordBlock
// --------------------------------------------------------------------------------
HRESULT GetRecordBlock(LPMEMORYFILE pFile, DWORD faRecord, LPRECORDBLOCKV5B1 *ppRecord,
LPBYTE *ppbData, BOOL *pfContinue)
{
// Locals
HRESULT hr=S_OK;
// Trace
TraceCall("GetRecordBlock");
// Bad Length
if (faRecord + sizeof(RECORDBLOCKV5B1) > pFile->cbSize)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_OUTOFRANGEADDRESS);
goto exit;
}
// Cast the Record
(*ppRecord) = (LPRECORDBLOCKV5B1)((LPBYTE)pFile->pView + faRecord);
// Invalid Record Signature
if (faRecord != (*ppRecord)->faRecord)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_BADRECORDSIGNATURE);
goto exit;
}
// Bad Length
if (faRecord + (*ppRecord)->cbRecord > pFile->cbSize)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_OUTOFRANGEADDRESS);
goto exit;
}
// Set pbData
*ppbData = (LPBYTE)((LPBYTE)(*ppRecord) + sizeof(RECORDBLOCKV5B1));
exit:
// Done
return hr;
}
// --------------------------------------------------------------------------------
// GetStreamBlock
// --------------------------------------------------------------------------------
HRESULT GetStreamBlock(LPMEMORYFILE pFile, DWORD faBlock, LPSTREAMBLOCK *ppBlock,
LPBYTE *ppbData, BOOL *pfContinue)
{
// Locals
HRESULT hr=S_OK;
// Trace
TraceCall("GetStreamBlock");
// Bad Length
if (faBlock + sizeof(STREAMBLOCK) > pFile->cbSize)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_OUTOFRANGEADDRESS);
goto exit;
}
// Cast the Record
(*ppBlock) = (LPSTREAMBLOCK)((LPBYTE)pFile->pView + faBlock);
// Invalid Record Signature
if (faBlock != (*ppBlock)->faThis)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_BADSTREAMBLOCKSIGNATURE);
goto exit;
}
// Bad Length
if (faBlock + (*ppBlock)->cbBlock > pFile->cbSize)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_OUTOFRANGEADDRESS);
goto exit;
}
// Set pbData
*ppbData = (LPBYTE)((LPBYTE)(*ppBlock) + sizeof(STREAMBLOCK));
exit:
// Done
return hr;
}
// --------------------------------------------------------------------------------
// UpgradePropTreeMessageFileV5
// --------------------------------------------------------------------------------
HRESULT UpgradePropTreeMessageFileV5(LPFILEINFO pInfo, LPMEMORYFILE pFile,
IDatabase *pDB, LPPROGRESSINFO pProgress, BOOL *pfContinue)
{
// Locals
HRESULT hr=S_OK;
LPBYTE pbStart;
LPBYTE pbData;
DWORD faRecord;
DWORD faStreamBlock;
FILEADDRESS faDstStream;
MESSAGEINFO MsgInfo;
IStream *pStream=NULL;
FILEADDRESS faStream;
LPFOLDERUSERDATAV4 pUserDataV4;
FOLDERUSERDATA UserDataV5;
LPSTREAMBLOCK pStmBlock;
LPRECORDBLOCKV5B1 pRecord;
LPTABLEHEADERV5B1 pHeader=(LPTABLEHEADERV5B1)pFile->pView;
// Trace
TraceCall("UpgradePropTreeMessageFileV5");
// Validate
Assert(sizeof(FOLDERUSERDATAV4) == sizeof(FOLDERUSERDATA));
// Get CacheInfo
if (sizeof(FOLDERUSERDATA) != pHeader->cbUserData)
{
*pfContinue = TRUE;
hr = TraceResult(MIGRATE_E_USERDATASIZEDIFF);
goto exit;
}
// Get V4 UserData
pUserDataV4 = (LPFOLDERUSERDATAV4)((LPBYTE)pFile->pView + sizeof(TABLEHEADERV5B1));
// If there is a Server Name and acctid is empty...
if ('\0' != *pUserDataV4->szServer && '\0' == *pInfo->szAcctId)
{
// Loop through the Accounts
for (DWORD i=0; i<g_AcctTable.cAccounts; i++)
{
// Is this the Account
if (lstrcmpi(g_AcctTable.prgAccount[i].szServer, pUserDataV4->szServer) == 0)
{
StrCpyN(pInfo->szAcctId, g_AcctTable.prgAccount[i].szAcctId, ARRAYSIZE(pInfo->szAcctId));
break;
}
}
}
// If there is a folder name, copy it
if ('\0' != *pUserDataV4->szGroup)
{
// Copy
StrCpyN(pInfo->szFolder, pUserDataV4->szGroup, ARRAYSIZE(pInfo->szFolder));
}
// Zero New
ZeroMemory(&UserDataV5, sizeof(FOLDERUSERDATA));
// Copy Over Relavent Stuff
UserDataV5.dwUIDValidity = pUserDataV4->dwUIDValidity;
// Set user data
IF_FAILEXIT(hr = pDB->SetUserData(&UserDataV5, sizeof(FOLDERUSERDATA)));
// Initialize faRecord to start
faRecord = pHeader->faFirstRecord;
// While we have a record
while(faRecord)
{
// Get the Record
IF_FAILEXIT(hr = GetRecordBlock(pFile, faRecord, &pRecord, &pbData, pfContinue));
// Set pbStart
pbStart = pbData;
// Clear MsgInfo
ZeroMemory(&MsgInfo, sizeof(MESSAGEINFO));
// DWORD - idMessage
CopyMemory(&MsgInfo.idMessage, pbData, sizeof(MsgInfo.idMessage));
pbData += sizeof(MsgInfo.idMessage);
// Null Message Id
if (0 == MsgInfo.idMessage)
{
// Generate
pDB->GenerateId((LPDWORD)&MsgInfo.idMessage);
}
// DWORD - dwFlags
CopyMemory(&MsgInfo.dwFlags, pbData, sizeof(MsgInfo.dwFlags));
pbData += sizeof(MsgInfo.dwFlags);
// News ?
if (FILE_IS_NEWS_MESSAGES == pInfo->tyFile)
FLAGSET(MsgInfo.dwFlags, ARF_NEWSMSG);
// Priority
if (ISFLAGSET(MsgInfo.dwFlags, 0x00000200))
{
MsgInfo.wPriority = (WORD)IMSG_PRI_HIGH;
FLAGCLEAR(MsgInfo.dwFlags, 0x00000200);
}
else if (ISFLAGSET(MsgInfo.dwFlags, 0x00000100))
{
MsgInfo.wPriority = (WORD)IMSG_PRI_LOW;
FLAGCLEAR(MsgInfo.dwFlags, 0x00000100);
}
else
MsgInfo.wPriority = (WORD)IMSG_PRI_NORMAL;
// DWORD - ftSent
CopyMemory(&MsgInfo.ftSent, pbData, sizeof(MsgInfo.ftSent));
pbData += sizeof(MsgInfo.ftSent);
MsgInfo.ftReceived = MsgInfo.ftSent;
// DWORD - cLines
CopyMemory(&MsgInfo.cLines, pbData, sizeof(MsgInfo.cLines));
pbData += sizeof(MsgInfo.cLines);
// DWORD - faStream
CopyMemory(&faStream, pbData, sizeof(faStream));
pbData += sizeof(faStream);
// Has a Body
if (faStream)
{
// It has a body
FLAGSET(MsgInfo.dwFlags, ARF_HASBODY);
}
// DWORD - cbArticle / cbMessage (VERSION)
CopyMemory(&MsgInfo.cbMessage, pbData, sizeof(MsgInfo.cbMessage));
pbData += sizeof(MsgInfo.cbMessage);
// DWORD - ftDownloaded
CopyMemory(&MsgInfo.ftDownloaded, pbData, sizeof(MsgInfo.ftDownloaded));
pbData += sizeof(MsgInfo.ftDownloaded);
// LPSTR - pszMessageId
MsgInfo.pszMessageId = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszMessageId) + 1);
// LPSTR - pszSubject
MsgInfo.pszSubject = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszSubject) + 1);
// VERSION
MsgInfo.pszNormalSubj = MsgInfo.pszSubject + HIBYTE(HIWORD(MsgInfo.dwFlags));
// LPSTR - pszFromHeader
MsgInfo.pszFromHeader = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszFromHeader) + 1);
// LPSTR - pszReferences
MsgInfo.pszReferences = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszReferences) + 1);
// LPSTR - pszXref
MsgInfo.pszXref = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszXref) + 1);
// LPSTR - pszServer
MsgInfo.pszServer = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszServer) + 1);
// LPSTR - pszDisplayFrom
MsgInfo.pszDisplayFrom = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszDisplayFrom) + 1);
// No Display From and we have a from header
if ('\0' == *MsgInfo.pszDisplayFrom && '\0' != MsgInfo.pszFromHeader)
MsgInfo.pszDisplayFrom = MsgInfo.pszFromHeader;
// LPSTR - pszEmailFrom
MsgInfo.pszEmailFrom = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszEmailFrom) + 1);
// Going to V4 ?
if (pRecord->cbRecord - (DWORD)(pbData - pbStart) - sizeof(RECORDBLOCKV5B1) > 40)
{
// WORD - wLanguage
CopyMemory(&MsgInfo.wLanguage, pbData, sizeof(MsgInfo.wLanguage));
pbData += sizeof(MsgInfo.wLanguage);
// WORD - wReserved
pbData += sizeof(WORD);
// DWORD - cbMessage
CopyMemory(&MsgInfo.cbMessage, pbData, sizeof(MsgInfo.cbMessage));
pbData += sizeof(MsgInfo.cbMessage);
// FILETIME - ftReceived
CopyMemory(&MsgInfo.ftReceived, pbData, sizeof(MsgInfo.ftReceived));
pbData += sizeof(MsgInfo.ftReceived);
// SBAILEY: Raid-76295: News store corrupted when system dates are changed, Find dialog returns dates of 1900, 00 or blank
if (0 == MsgInfo.ftReceived.dwLowDateTime && 0 == MsgInfo.ftReceived.dwHighDateTime)
CopyMemory(&MsgInfo.ftReceived, &MsgInfo.ftSent, sizeof(FILETIME));
// LPSTR - pszDisplayTo
MsgInfo.pszDisplayTo = (LPSTR)pbData;
pbData += (lstrlen(MsgInfo.pszDisplayTo) + 1);
}
// Otherwise
else
{
// Set ftReceived
CopyMemory(&MsgInfo.ftReceived, &MsgInfo.ftSent, sizeof(FILETIME));
}
// Copy over the stream...
if (0 != faStream)
{
// Allocate a new stream
IF_FAILEXIT(hr = pDB->CreateStream(&faDstStream));
// Open the stream
IF_FAILEXIT(hr = pDB->OpenStream(ACCESS_WRITE, faDstStream, &pStream));
// Start Copying Message
faStreamBlock = faStream;
// While we have a stream block
while(faStreamBlock)
{
// Get a stream block
IF_FAILEXIT(hr = GetStreamBlock(pFile, faStreamBlock, &pStmBlock, &pbData, pfContinue));
// Write into the stream
IF_FAILEXIT(hr = pStream->Write(pbData, pStmBlock->cbData, NULL));
// Goto Next Block
faStreamBlock = pStmBlock->faNext;
}
// Commit
IF_FAILEXIT(hr = pStream->Commit(STGC_DEFAULT));
// Set new stream location
MsgInfo.faStream = faDstStream;
// Release the Stream
SafeRelease(pStream);
}
// If No Account Id and we have a server
if ('\0' == *pInfo->szAcctId && '\0' != *MsgInfo.pszServer)
{
// Loop through the Accounts
for (DWORD i=0; i<g_AcctTable.cAccounts; i++)
{
// Is this the Account
if (lstrcmpi(g_AcctTable.prgAccount[i].szServer, MsgInfo.pszServer) == 0)
{
StrCpyN(pInfo->szAcctId, g_AcctTable.prgAccount[i].szAcctId, ARRAYSIZE(pInfo->szAcctId));
break;
}
}
}
// Default to szAcctId
MsgInfo.pszAcctId = pInfo->szAcctId;
// Lookup Account Id from the Account Name...
if (MsgInfo.pszAcctName)
{
// Loop through the Accounts
for (DWORD i=0; i<g_AcctTable.cAccounts; i++)
{
// Is this the Account
if (lstrcmpi(g_AcctTable.prgAccount[i].szAcctName, MsgInfo.pszAcctName) == 0)
{
MsgInfo.pszAcctId = g_AcctTable.prgAccount[i].szAcctId;
break;
}
}
}
// Otherwise, if we have an account Id, get the account name
else if ('\0' != *pInfo->szAcctId)
{
// Loop through the Accounts
for (DWORD i=0; i<g_AcctTable.cAccounts; i++)
{
// Is this the Account
if (lstrcmpi(g_AcctTable.prgAccount[i].szAcctId, MsgInfo.pszAcctId) == 0)
{
MsgInfo.pszAcctName = g_AcctTable.prgAccount[i].szAcctName;
break;
}
}
}
// Count
pInfo->cMessages++;
if (!ISFLAGSET(MsgInfo.dwFlags, ARF_READ))
pInfo->cUnread++;
// Migrated
FLAGSET(MsgInfo.dwFlags, 0x00000010);
// Insert the Record
IF_FAILEXIT(hr = pDB->InsertRecord(&MsgInfo));
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pInfo);
// Goto the Next Record
faRecord = pRecord->faNext;
}
exit:
// Cleanup
SafeRelease(pStream);
// Done
return hr;
}
// --------------------------------------------------------------------------------
// ParseFolderFileV5
// --------------------------------------------------------------------------------
HRESULT ParseFolderFileV5(LPMEMORYFILE pFile, LPFILEINFO pInfo,
LPPROGRESSINFO pProgress, LPDWORD pcFolders,
LPFLDINFO *pprgFolder)
{
// Locals
HRESULT hr=S_OK;
LPBYTE pbData;
DWORD faRecord;
LPFLDINFO pFolder;
LPFLDINFO prgFolder=NULL;
LPRECORDBLOCKV5B1 pRecord;
LPTABLEHEADERV5B1 pHeader;
BOOL fContinue;
DWORD cFolders=0;
// Trace
TraceCall("ParseFolderFileV5");
// De-ref the header
pHeader = (LPTABLEHEADERV5B1)pFile->pView;
// Get CacheInfo
if (sizeof(STOREUSERDATA) != pHeader->cbUserData)
{
hr = TraceResult(MIGRATE_E_USERDATASIZEDIFF);
goto exit;
}
// Allocate Folder Array
IF_NULLEXIT(prgFolder = (LPFLDINFO)ZeroAllocate(sizeof(FLDINFO) * pHeader->cRecords));
// Initialize faRecord to start
faRecord = pHeader->faFirstRecord;
// While we have a record
while(faRecord)
{
// Readability
pFolder = &prgFolder[cFolders];
// Get the Record
IF_FAILEXIT(hr = GetRecordBlock(pFile, faRecord, &pRecord, &pbData, &fContinue));
// DWORD - hFolder
CopyMemory(&pFolder->idFolder, pbData, sizeof(pFolder->idFolder));
pbData += sizeof(pFolder->idFolder);
// CHAR(MAX_FOLDER_NAME) - szFolder
CopyMemory(pFolder->szFolder, pbData, sizeof(pFolder->szFolder));
pbData += sizeof(pFolder->szFolder);
// CHAR(260) - szFile
CopyMemory(pFolder->szFile, pbData, sizeof(pFolder->szFile));
pbData += sizeof(pFolder->szFile);
// DWORD - idParent
CopyMemory(&pFolder->idParent, pbData, sizeof(pFolder->idParent));
pbData += sizeof(pFolder->idParent);
// DWORD - idChild
CopyMemory(&pFolder->idChild, pbData, sizeof(pFolder->idChild));
pbData += sizeof(pFolder->idChild);
// DWORD - idSibling
CopyMemory(&pFolder->idSibling, pbData, sizeof(pFolder->idSibling));
pbData += sizeof(pFolder->idSibling);
// DWORD - tySpecial
CopyMemory(&pFolder->tySpecial, pbData, sizeof(pFolder->tySpecial));
pbData += sizeof(pFolder->tySpecial);
// DWORD - cChildren
CopyMemory(&pFolder->cChildren, pbData, sizeof(pFolder->cChildren));
pbData += sizeof(pFolder->cChildren);
// DWORD - cMessages
CopyMemory(&pFolder->cMessages, pbData, sizeof(pFolder->cMessages));
pbData += sizeof(pFolder->cMessages);
// DWORD - cUnread
CopyMemory(&pFolder->cUnread, pbData, sizeof(pFolder->cUnread));
pbData += sizeof(pFolder->cUnread);
// DWORD - cbTotal
CopyMemory(&pFolder->cbTotal, pbData, sizeof(pFolder->cbTotal));
pbData += sizeof(pFolder->cbTotal);
// DWORD - cbUsed
CopyMemory(&pFolder->cbUsed, pbData, sizeof(pFolder->cbUsed));
pbData += sizeof(pFolder->cbUsed);
// DWORD - bHierarchy
CopyMemory(&pFolder->bHierarchy, pbData, sizeof(pFolder->bHierarchy));
pbData += sizeof(pFolder->bHierarchy);
// DWORD - dwImapFlags
CopyMemory(&pFolder->dwImapFlags, pbData, sizeof(pFolder->dwImapFlags));
pbData += sizeof(DWORD);
// BLOB - bListStamp
CopyMemory(&pFolder->bListStamp, pbData, sizeof(pFolder->bListStamp));
pbData += sizeof(BYTE);
// DWORD - bReserved[3]
pbData += (3 * sizeof(BYTE));
// DWORD - rgbReserved
pbData += 40;
// Increment Count
cFolders++;
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pInfo);
// Goto the Next Record
faRecord = pRecord->faNext;
}
// Return Folder Count
*pcFolders = cFolders;
// Return the Array
*pprgFolder = prgFolder;
// Don't Free It
prgFolder = NULL;
exit:
// Cleanup
SafeMemFree(prgFolder);
// Done
return hr;
}
// --------------------------------------------------------------------------------
// UpgradePop3UidlFileV5
// --------------------------------------------------------------------------------
HRESULT UpgradePop3UidlFileV5(LPFILEINFO pInfo, LPMEMORYFILE pFile,
IDatabase *pDB, LPPROGRESSINFO pProgress, BOOL *pfContinue)
{
// Locals
HRESULT hr=S_OK;
LPBYTE pbData;
DWORD faRecord;
UIDLRECORD UidlInfo;
LPRECORDBLOCKV5B1 pRecord;
LPTABLEHEADERV5B1 pHeader=(LPTABLEHEADERV5B1)pFile->pView;
// Trace
TraceCall("UpgradePop3UidlFileV5");
// Initialize faRecord to start
faRecord = pHeader->faFirstRecord;
// While we have a record
while(faRecord)
{
// Get the Record
IF_FAILEXIT(hr = GetRecordBlock(pFile, faRecord, &pRecord, &pbData, pfContinue));
// Clear UidlInfo
ZeroMemory(&UidlInfo, sizeof(UIDLRECORD));
// FILETIME - ftDownload
CopyMemory(&UidlInfo.ftDownload, pbData, sizeof(UidlInfo.ftDownload));
pbData += sizeof(UidlInfo.ftDownload);
// BYTE - fDownloaded
CopyMemory(&UidlInfo.fDownloaded, pbData, sizeof(UidlInfo.fDownloaded));
pbData += sizeof(UidlInfo.fDownloaded);
// BYTE - fDeleted
CopyMemory(&UidlInfo.fDeleted, pbData, sizeof(UidlInfo.fDeleted));
pbData += sizeof(UidlInfo.fDeleted);
// LPSTR - pszUidl
UidlInfo.pszUidl = (LPSTR)pbData;
pbData += (lstrlen(UidlInfo.pszUidl) + 1);
// LPSTR - pszServer
UidlInfo.pszServer = (LPSTR)pbData;
pbData += (lstrlen(UidlInfo.pszServer) + 1);
// Insert the Record
IF_FAILEXIT(hr = pDB->InsertRecord(&UidlInfo));
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pInfo);
// Goto the Next Record
faRecord = pRecord->faNext;
}
exit:
// Done
return hr;
}
// --------------------------------------------------------------------------------
// UpgradeFileV5
// --------------------------------------------------------------------------------
HRESULT UpgradeFileV5(IDatabaseSession *pSession, MIGRATETOTYPE tyMigrate,
LPFILEINFO pInfo, LPPROGRESSINFO pProgress, BOOL *pfContinue)
{
// Locals
HRESULT hr=S_OK;
MEMORYFILE File={0};
IDatabase *pDB=NULL;
// Trace
TraceCall("UpgradeFileV5");
// Local message file
if (FILE_IS_LOCAL_MESSAGES == pInfo->tyFile)
{
// Create an ObjectDatabase (upgrade only runs when OE5 is installed)
IF_FAILEXIT(hr = pSession->OpenDatabase(pInfo->szDstFile, 0, &g_MessageTableSchema, NULL, &pDB));
// Get the File Header
IF_FAILEXIT(hr = OpenMemoryFile(pInfo->szFilePath, &File));
// UpgradeLocalStoreFileV5
IF_FAILEXIT(hr = UpgradeLocalStoreFileV5(pInfo, &File, pDB, pProgress, pfContinue));
}
// Old News or Imap file
else if (FILE_IS_NEWS_MESSAGES == pInfo->tyFile || FILE_IS_IMAP_MESSAGES == pInfo->tyFile)
{
// Create an ObjectDatabase (upgrade only runs when OE5 is installed)
IF_FAILEXIT(hr = pSession->OpenDatabase(pInfo->szDstFile, 0, &g_MessageTableSchema, NULL, &pDB));
// Get the File Header
IF_FAILEXIT(hr = OpenMemoryFile(pInfo->szFilePath, &File));
// UpgradePropTreeMessageFileV5
IF_FAILEXIT(hr = UpgradePropTreeMessageFileV5(pInfo, &File, pDB, pProgress, pfContinue));
}
// pop3uidl file
else if (FILE_IS_POP3UIDL == pInfo->tyFile)
{
// Create an ObjectDatabase (upgrade only runs when OE5 is installed)
IF_FAILEXIT(hr = pSession->OpenDatabase(pInfo->szDstFile, 0, &g_UidlTableSchema, NULL, &pDB));
// Get the File Header
IF_FAILEXIT(hr = OpenMemoryFile(pInfo->szFilePath, &File));
// UpgradePop3UidlFileV5
IF_FAILEXIT(hr = UpgradePop3UidlFileV5(pInfo, &File, pDB, pProgress, pfContinue));
}
exit:
// Cleanup
SafeRelease(pDB);
CloseMemoryFile(&File);
// Done
return hr;
}
// --------------------------------------------------------------------------------
// UpgradeProcessFileListV5
// --------------------------------------------------------------------------------
HRESULT UpgradeProcessFileListV5(LPCSTR pszStoreSrc, LPCSTR pszStoreDst,
LPFILEINFO pHead, LPDWORD pcMax, LPDWORD pcbNeeded)
{
// Locals
HRESULT hr=S_OK;
MEMORYFILE File={0};
LPFILEINFO pCurrent;
LPTABLEHEADERV5B1 pHeader;
// Trace
TraceCall("UpgradeProcessFileListV5");
// Init
*pcMax = 0;
*pcbNeeded = 0;
// Loop
for (pCurrent=pHead; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Get the File Header
hr = OpenMemoryFile(pCurrent->szFilePath, &File);
// Failure ?
if (FAILED(hr) || 0 == File.cbSize)
{
// Don't Migrate
pCurrent->fMigrate = FALSE;
// Set hrMigrate
pCurrent->hrMigrate = (0 == File.cbSize ? S_OK : hr);
// Reset hr
hr = S_OK;
// Get the LastError
pCurrent->dwLastError = GetLastError();
// Goto Next
goto NextFile;
}
// Local message file
if (FILE_IS_LOCAL_MESSAGES == pCurrent->tyFile)
{
// Cast the Header
LPMBXFILEHEADER pMbxHeader=(LPMBXFILEHEADER)File.pView;
// Bad Version
if (File.cbSize < sizeof(MBXFILEHEADER) || pMbxHeader->dwMagic != MSGFILE_MAGIC || pMbxHeader->ver != MSGFILE_VER)
{
// Not a file that should be migrate
pCurrent->fMigrate = FALSE;
// Set hrMigrate
pCurrent->hrMigrate = MIGRATE_E_BADVERSION;
// Goto Next
goto NextFile;
}
// Save the Number of record
pCurrent->cRecords = pMbxHeader->cMsg;
}
// Otherwise, if its a news group list
else if (FILE_IS_NEWS_SUBLIST == pCurrent->tyFile)
{
// De-Ref the header
LPSUBLISTHEADER pSubList = (LPSUBLISTHEADER)File.pView;
// Check the Signature...
if (File.cbSize < sizeof(SUBLISTHEADER) ||
(SUBFILE_VERSION5 != pSubList->dwVersion &&
SUBFILE_VERSION4 != pSubList->dwVersion &&
SUBFILE_VERSION3 != pSubList->dwVersion &&
SUBFILE_VERSION2 != pSubList->dwVersion))
{
// Not a file that should be migrate
pCurrent->fMigrate = FALSE;
// Set hrMigrate
pCurrent->hrMigrate = MIGRATE_E_BADVERSION;
// Goto Next
goto NextFile;
}
// Save the Number of record
pCurrent->cRecords = pSubList->cSubscribed;
}
// Otherwise, if its a news sub list
else if (FILE_IS_NEWS_GRPLIST == pCurrent->tyFile)
{
// De-Ref the header
LPGRPLISTHEADER pGrpList = (LPGRPLISTHEADER)File.pView;
// Check the Signature...
if (File.cbSize < sizeof(GRPLISTHEADER) || GROUPLISTVERSION != pGrpList->dwVersion)
{
// Not a file that should be migrate
pCurrent->fMigrate = FALSE;
// Set hrMigrate
pCurrent->hrMigrate = MIGRATE_E_BADVERSION;
// Goto Next
goto NextFile;
}
// Save the Number of record
pCurrent->cRecords = pGrpList->cGroups;
}
// Otherwise, objectdb file
else
{
// De-Ref the header
pHeader = (LPTABLEHEADERV5B1)File.pView;
// Check the Signature...
if (File.cbSize < sizeof(TABLEHEADERV5B1) || OBJECTDB_SIGNATURE != pHeader->dwSignature || OBJECTDB_VERSION_PRE_V5 != pHeader->wMajorVersion)
{
// Not a file that should be migrate
pCurrent->fMigrate = FALSE;
// Set hrMigrate
pCurrent->hrMigrate = MIGRATE_E_BADVERSION;
// Goto Next
goto NextFile;
}
// Save the Number of record
pCurrent->cRecords = pHeader->cRecords;
}
// Special Case pop3uidl.dat
if (FILE_IS_POP3UIDL == pCurrent->tyFile)
{
// Compute Real Destination File
wnsprintf(pCurrent->szDstFile, ARRAYSIZE(pCurrent->szDstFile),"%s\\pop3uidl.dbx", pszStoreDst);
}
// Otherwise, generate a unqiue message file name
else
{
// Save the Folder Id
pCurrent->idFolder = g_idFolderNext;
// Build New Path
wnsprintf(pCurrent->szDstFile, ARRAYSIZE(pCurrent->szDstFile), "%s\\%08d.dbx", pszStoreDst, g_idFolderNext);
// Increment id
g_idFolderNext++;
}
// Initialize counters
InitializeCounters(&File, pCurrent, pcMax, pcbNeeded, TRUE);
// Yes, Migrate
pCurrent->fMigrate = TRUE;
NextFile:
// Close the File
CloseMemoryFile(&File);
}
// Done
return hr;
}
// --------------------------------------------------------------------------------
// UpgradeDeleteFilesV5
// --------------------------------------------------------------------------------
void UpgradeDeleteFilesV5(LPCSTR pszStoreDst)
{
// Locals
CHAR szSearch[MAX_PATH + MAX_PATH];
CHAR szFilePath[MAX_PATH + MAX_PATH];
HANDLE hFind=INVALID_HANDLE_VALUE;
WIN32_FIND_DATA fd;
// Trace
TraceCall("UpgradeDeleteFilesV5");
// Do we have a sub dir
wnsprintf(szSearch, ARRAYSIZE(szSearch),"%s\\*.dbx", pszStoreDst);
// Find first file
hFind = FindFirstFile(szSearch, &fd);
// Did we find something
if (INVALID_HANDLE_VALUE == hFind)
goto exit;
// Loop for ever
while(1)
{
// Make File Path
MakeFilePath(pszStoreDst, fd.cFileName, "", szFilePath, ARRAYSIZE(szFilePath));
// Delete
DeleteFile(szFilePath);
// Find the Next File
if (!FindNextFile(hFind, &fd))
break;
}
exit:
// Cleanup
if (hFind)
FindClose(hFind);
}
// --------------------------------------------------------------------------------
// UpgradeDeleteIdxMbxNchDatFilesV5
// --------------------------------------------------------------------------------
void UpgradeDeleteIdxMbxNchDatFilesV5(LPFILEINFO pHeadFile)
{
// Locals
CHAR szDstFile[MAX_PATH + MAX_PATH];
LPFILEINFO pCurrent;
// Trace
TraceCall("UpgradeDeleteOdbFilesV5");
// Delete all old files
for (pCurrent=pHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Succeeded
Assert(SUCCEEDED(pCurrent->hrMigrate));
// Delete the file
// DeleteFile(pCurrent->szFilePath);
// If local message file, need to delete the idx file
if (FILE_IS_LOCAL_MESSAGES == pCurrent->tyFile)
{
// Replace file extension
ReplaceExtension(pCurrent->szFilePath, ".idx", szDstFile, ARRAYSIZE(szDstFile));
// Delete the file
// DeleteFile(szDstFile);
}
}
// Done
return;
}
// --------------------------------------------------------------------------------
// GetSpecialFolderInfo
// --------------------------------------------------------------------------------
HRESULT GetSpecialFolderInfo(LPCSTR pszFilePath, LPSTR pszFolder,
DWORD cchFolder, DWORD *ptySpecial)
{
// Locals
CHAR szPath[_MAX_PATH];
CHAR szDrive[_MAX_DRIVE];
CHAR szDir[_MAX_DIR];
CHAR szFile[_MAX_FNAME];
CHAR szExt[_MAX_EXT];
CHAR szRes[255];
DWORD i;
// Trace
TraceCall("GetSpecialFolderInfo");
// Initialize
*ptySpecial = 0xffffffff;
// Split the Path
_splitpath(pszFilePath, szDrive, szDir, szFile, szExt);
// Set Folder Name
StrCpyN(pszFolder, szFile, cchFolder);
// Loop through special folder
for (i=FOLDER_INBOX; i<FOLDER_MAX; i++)
{
// Load the Special Folder Name
LoadString(g_hInst, IDS_INBOX + (i - 1), szRes, ARRAYSIZE(szRes));
// Compare with szFile
if (lstrcmpi(szFile, szRes) == 0)
{
// Copy the Folder Name
StrCpyN(pszFolder, szRes, cchFolder);
// Return special folder type
*ptySpecial = (i - 1);
// Success
return(S_OK);
}
}
// Done
return(E_FAIL);
}
// --------------------------------------------------------------------------------
// FixupFolderUserData
// --------------------------------------------------------------------------------
HRESULT FixupFolderUserData(IDatabaseSession *pSession, FOLDERID idFolder,
LPCSTR pszName, SPECIALFOLDER tySpecial, LPFILEINFO pCurrent)
{
// Locals
HRESULT hr=S_OK;
FOLDERUSERDATA UserData;
IDatabase *pDB=NULL;
// Trace
TraceCall("FixupFolderUserData");
// Better not be in the store yet
Assert(FALSE == pCurrent->fInStore);
// Its in the store
pCurrent->fInStore = TRUE;
// Create an Ojbect Database
IF_FAILEXIT(hr = pSession->OpenDatabase(pCurrent->szDstFile, 0, &g_MessageTableSchema, NULL, &pDB));
// Store the User Data
IF_FAILEXIT(hr = pDB->GetUserData(&UserData, sizeof(FOLDERUSERDATA)));
// Its Initialized
UserData.fInitialized = TRUE;
// UserData.clsidType
if (ISFLAGSET(pCurrent->dwServer, SRV_POP3))
UserData.tyFolder = FOLDER_LOCAL;
else if (ISFLAGSET(pCurrent->dwServer, SRV_NNTP))
UserData.tyFolder = FOLDER_NEWS;
else if (ISFLAGSET(pCurrent->dwServer, SRV_IMAP))
UserData.tyFolder = FOLDER_IMAP;
// Copy the Account Id
StrCpyN(UserData.szAcctId, pCurrent->szAcctId, ARRAYSIZE(UserData.szAcctId));
// Save Folder Id
UserData.idFolder = idFolder;
// Save Special Folder Type
UserData.tySpecial = tySpecial;
// Copy the Folder name
StrCpyN(UserData.szFolder, pszName, ARRAYSIZE(UserData.szFolder));
// Must be Subscribed
UserData.fSubscribed = TRUE;
// Set the Sort Index Information
UserData.idSort = COLUMN_RECEIVED;
// Not Ascending
UserData.fAscending = FALSE;
// Not threaded
UserData.fThreaded = FALSE;
// Basic Filter
UserData.ridFilter = RULEID_VIEW_ALL;
// Add Welcome Message Again
UserData.fWelcomeAdded = FALSE;
// Show Deleted
UserData.fShowDeleted = TRUE;
// New thread model
UserData.fNewThreadModel = TRUE;
UserData.fTotalWatched = TRUE;
UserData.fWatchedCounts = TRUE;
// Store the User Data
IF_FAILEXIT(hr = pDB->SetUserData(&UserData, sizeof(FOLDERUSERDATA)));
exit:
// Cleanup
SafeRelease(pDB);
// Done
return(hr);
}
// --------------------------------------------------------------------------------
// SetIMAPSpecialFldrType
// --------------------------------------------------------------------------------
HRESULT SetIMAPSpecialFldrType(LPSTR pszAcctID, LPSTR pszFldrName, SPECIALFOLDER *psfType)
{
char szPath[MAX_PATH + 1];
SPECIALFOLDER sfResult = FOLDER_NOTSPECIAL;
TraceCall("SetIMAPSpecialFldrType");
Assert(NULL != psfType);
Assert(FOLDER_NOTSPECIAL == *psfType);
LoadString(g_hInst, IDS_SENTITEMS, szPath, sizeof(szPath));
if (0 == lstrcmp(szPath, pszFldrName))
{
sfResult = FOLDER_SENT;
goto exit;
}
LoadString(g_hInst, IDS_DRAFT, szPath, sizeof(szPath));
if (0 == lstrcmp(szPath, pszFldrName))
{
sfResult = FOLDER_DRAFT;
goto exit;
}
exit:
*psfType = sfResult;
return S_OK;
}
// --------------------------------------------------------------------------------
// InsertFolderIntoStore
// --------------------------------------------------------------------------------
HRESULT InsertFolderIntoStore(IDatabaseSession *pSession, IMessageStore *pStore,
LPFLDINFO pThis, DWORD cFolders, LPFLDINFO prgFolder, FOLDERID idParentNew,
LPFILEINFO pInfo, LPFILEINFO pFileHead, LPFOLDERID pidNew)
{
// Locals
HRESULT hr=S_OK;
DWORD i;
CHAR szPath[_MAX_PATH];
CHAR szDrive[_MAX_DRIVE];
CHAR szDir[_MAX_DIR];
CHAR szFile[_MAX_FNAME];
CHAR szExt[_MAX_EXT];
CHAR szFilePath[MAX_PATH];
CHAR szInbox[MAX_PATH];
BOOL fFound=FALSE;
LPFILEINFO pCurrent=NULL;
FOLDERINFO Folder={0};
// Trace
TraceCall("InsertFolderIntoStore");
// Invalid Arg
//Assert(FILE_IS_LOCAL_FOLDERS == pInfo->tyFile || FILE_IS_IMAP_FOLDERS == pInfo->tyFile);
// Copy Stuff Over to Folder
Folder.pszName = pThis->szFolder;
Folder.idParent = idParentNew;
Folder.bHierarchy = pThis->bHierarchy;
Folder.dwFlags = FOLDER_SUBSCRIBED; // $$TODO$$ May need to adjust and map to new flags
Folder.tySpecial = (0xffffffff == pThis->tySpecial) ? FOLDER_NOTSPECIAL : (BYTE)(pThis->tySpecial + 1);
Folder.cMessages = pThis->cMessages;
Folder.cUnread = pThis->cUnread;
Folder.pszFile = pThis->szFile;
Folder.dwListStamp = pThis->bListStamp;
// For IMAP folders, we have to set tySpecial based on registry folder paths
if (pInfo && FILE_IS_IMAP_FOLDERS == pInfo->tyFile && NULL != pThis &&
FOLDERID_ROOT == (FOLDERID)IntToPtr(pThis->idParent))
{
HRESULT hrTemp;
if (FOLDER_NOTSPECIAL == Folder.tySpecial)
{
hrTemp = SetIMAPSpecialFldrType(pInfo->szAcctId, Folder.pszName, &Folder.tySpecial);
TraceError(hrTemp);
Assert(SUCCEEDED(hrTemp) || FOLDER_NOTSPECIAL == Folder.tySpecial);
}
else if (FOLDER_INBOX == Folder.tySpecial)
{
LoadString(g_hInst, IDS_INBOX, szInbox, ARRAYSIZE(szInbox));
Folder.pszName = szInbox;
}
}
// Look for Current
if (pInfo && pFileHead)
{
// Locate the file...
for (pCurrent=pFileHead; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Migrate
if (pCurrent->fMigrate)
{
// Local Folder ?
if (FILE_IS_LOCAL_FOLDERS == pInfo->tyFile && FILE_IS_LOCAL_MESSAGES == pCurrent->tyFile)
{
// Get the File Name
_splitpath(pCurrent->szFilePath, szDrive, szDir, szFile, szExt);
// Test For File Name
if (lstrcmpi(szFile, pThis->szFile) == 0)
{
// This is It
fFound = TRUE;
// Adjust the Flags
FLAGSET(Folder.dwFlags, FOLDER_SUBSCRIBED);
}
}
// IMAP Folders ?
else if (FILE_IS_IMAP_FOLDERS == pInfo->tyFile && FILE_IS_IMAP_MESSAGES == pCurrent->tyFile)
{
// Same Account
if (lstrcmpi(pCurrent->szAcctId, pInfo->szAcctId) == 0)
{
// Get the File Name
_splitpath(pCurrent->szFilePath, szDrive, szDir, szFile, szExt);
// Build File
wnsprintf(szFilePath, ARRAYSIZE(szFilePath), "%s.nch", szFile);
// Test For File Name
if (lstrcmpi(szFilePath, pThis->szFile) == 0)
{
// This is It
fFound = TRUE;
}
}
}
// Found
if (fFound)
{
// Get the File Name
_splitpath(pCurrent->szDstFile, szDrive, szDir, szFile, szExt);
// Build File
wnsprintf(szFilePath, ARRAYSIZE(szFilePath), "%s.dbx", szFile);
// Local the File for this folder and set
Folder.pszFile = szFilePath;
// Set Folder Counts
Folder.cMessages = pCurrent->cMessages;
Folder.cUnread = pCurrent->cUnread;
// Done
break;
}
}
}
}
// If this is a special folder, then lets try to see if it already exists...
if (FOLDER_NOTSPECIAL != Folder.tySpecial)
{
// Locals
FOLDERINFO Special;
// pThis Parent should be invalid
Assert(FOLDERID_ROOT == (FOLDERID)IntToPtr(pThis->idParent));
// Try to get the special folder info
if (FAILED(pStore->GetSpecialFolderInfo(idParentNew, Folder.tySpecial, &Special)))
{
// Create the Folder
IF_FAILEXIT(hr = pStore->CreateFolder(NOFLAGS, &Folder, NOSTORECALLBACK));
// Update pThis->dwServerHigh with new folderid
pThis->idNewFolderId = (DWORD_PTR)Folder.idFolder;
}
// Otherwise...
else
{
// Update pThis->dwServerHigh with new folderid
pThis->idNewFolderId = (DWORD_PTR)Special.idFolder;
// Update the Special folder
Folder.idFolder = Special.idFolder;
// Update Special
Special.bHierarchy = Folder.bHierarchy;
Special.dwFlags = Folder.dwFlags; // $$TODO$$ May need to adjust and map to new flags
Special.cMessages = Folder.cMessages;
Special.cUnread = Folder.cUnread;
Special.pszFile = Folder.pszFile;
Special.dwListStamp = Folder.dwListStamp;
// Update the Record
IF_FAILEXIT(hr = pStore->UpdateRecord(&Special));
// Free Special
pStore->FreeRecord(&Special);
}
}
// Otherwise, just try to create the folder
else
{
// Create the Folder
IF_FAILEXIT(hr = pStore->CreateFolder(NOFLAGS, &Folder, NOSTORECALLBACK));
// Update pThis->dwServerHigh with new folderid
pThis->idNewFolderId = (DWORD_PTR)Folder.idFolder;
}
// If We Found a folder...
if (pCurrent)
{
// Update the Folder's UserData
IF_FAILEXIT(hr = FixupFolderUserData(pSession, Folder.idFolder, pThis->szFolder, Folder.tySpecial, pCurrent));
}
// Walk Insert the children of pThis
for (i=0; i<cFolders; i++)
{
// If Parent is equal to idParent, then lets insert this node under the new parent
if (prgFolder[i].idParent == pThis->idFolder)
{
// Can't be null
Assert(prgFolder[i].idFolder);
// InsertFolderIntoStore
IF_FAILEXIT(hr = InsertFolderIntoStore(pSession, pStore, &prgFolder[i], cFolders, prgFolder, Folder.idFolder, pInfo, pFileHead, NULL));
}
}
// Return the New Folder
if (pidNew)
*pidNew = Folder.idFolder;
exit:
// Done
return(hr);
}
// --------------------------------------------------------------------------------
// MergeFolderCacheIntoStore
// --------------------------------------------------------------------------------
HRESULT MergeFolderCacheIntoStore(IDatabaseSession *pSession, IMessageStore *pStore,
LPFILEINFO pInfo, LPFILEINFO pHeadFile, LPPROGRESSINFO pProgress)
{
// Locals
HRESULT hr=S_OK;
MEMORYFILE File={0};
FOLDERID idServer;
DWORD cFolders;
DWORD i;
LPFLDINFO prgFolder=NULL;
LPFLDINFO pFolder;
HKEY hKey=NULL;
DWORD cbLength;
LPBYTE pbChange=NULL;
LPFOLDERIDCHANGE prgidChange;
IUserIdentityManager *pManager = NULL;
IUserIdentity *pIdentity = NULL;
HKEY hkeyID = NULL;
// Trace
TraceCall("MergeFolderCacheIntoStore");
// Find the Server Id
if (FAILED(pStore->FindServerId(pInfo->szAcctId, &idServer)))
goto exit;
// Open the File
IF_FAILEXIT(hr = OpenMemoryFile(pInfo->szFilePath, &File));
// Parse the file
IF_FAILEXIT(hr = ParseFolderFileV5(&File, pInfo, pProgress, &cFolders, &prgFolder));
// Loop through the folders
for (i=0; i<cFolders; i++)
{
// If this is the root folder node (OE4), remember to migrate the root hierarchy char
if ((FOLDERID)IntToPtr(prgFolder[i].idFolder) == FOLDERID_ROOT)
{
FOLDERINFO fiFolderInfo;
IF_FAILEXIT(hr = pStore->GetFolderInfo(idServer, &fiFolderInfo));
fiFolderInfo.bHierarchy = prgFolder[i].bHierarchy;
hr = pStore->UpdateRecord(&fiFolderInfo);
pStore->FreeRecord(&fiFolderInfo);
IF_FAILEXIT(hr);
}
// If Parent is equal to idParent, then lets insert this node under the new parent
else if ((FOLDERID)IntToPtr(prgFolder[i].idParent) == FOLDERID_ROOT)
{
// InsertFolderIntoStore
IF_FAILEXIT(hr = InsertFolderIntoStore(pSession, pStore, &prgFolder[i], cFolders, prgFolder, idServer, pInfo, pHeadFile, NULL));
}
}
// Local Folders
if (FILE_IS_LOCAL_FOLDERS == pInfo->tyFile)
{
// cbLength
cbLength = (sizeof(DWORD) + (sizeof(FOLDERIDCHANGE) * cFolders));
// Allocate a folderidchange array
IF_NULLEXIT(pbChange = (LPBYTE)g_pMalloc->Alloc(cbLength));
// Store cLocalFolders
CopyMemory(pbChange, &cFolders, sizeof(DWORD));
// Set prgidChange
prgidChange = (LPFOLDERIDCHANGE)(pbChange + sizeof(DWORD));
// Walk through the list of files and merge the folders, sublist, group lists into pFolder
for (i=0; i<cFolders; i++)
{
prgidChange[i].idOld = (FOLDERID)IntToPtr(prgFolder[i].idFolder);
prgidChange[i].idNew = (FOLDERID)prgFolder[i].idNewFolderId;
}
// Get a user manager
if (FAILED(CoCreateInstance(CLSID_UserIdentityManager, NULL, CLSCTX_INPROC_SERVER,
IID_IUserIdentityManager, (void **)&pManager)))
goto exit;
Assert(pManager);
// Get Default Identity
if (FAILED(pManager->GetIdentityByCookie((GUID*)&UID_GIBC_DEFAULT_USER, &pIdentity)))
goto exit;
Assert(pIdentity);
// Ensure that we have an identity and can get to its registry
if (FAILED(pIdentity->OpenIdentityRegKey(KEY_WRITE, &hkeyID)))
goto exit;
Assert(hkeyID);
// Open the HKCU
if (ERROR_SUCCESS != RegOpenKeyEx(hkeyID, "Software\\Microsoft\\Outlook Express\\5.0", 0, KEY_ALL_ACCESS, &hKey))
{
hr = TraceResult(MIGRATE_E_REGOPENKEY);
goto exit;
}
// Write it to the registry
if (ERROR_SUCCESS != RegSetValueEx(hKey, "FolderIdChange", 0, REG_BINARY, pbChange, cbLength))
{
hr = TraceResult(MIGRATE_E_REGSETVALUE);
goto exit;
}
}
exit:
// Cleanup
if (hKey)
RegCloseKey(hKey);
if (hkeyID)
RegCloseKey(hkeyID);
SafeMemFree(pbChange);
SafeMemFree(prgFolder);
SafeRelease(pIdentity);
SafeRelease(pManager);
CloseMemoryFile(&File);
// Done
return(hr);
}
// --------------------------------------------------------------------------------
// MergeNewsGroupList
// --------------------------------------------------------------------------------
HRESULT MergeNewsGroupList(IDatabaseSession *pSession, IMessageStore *pStore,
LPFILEINFO pInfo, LPFILEINFO pHeadFile, LPPROGRESSINFO pProgress)
{
// Locals
HRESULT hr=S_OK;
DWORD i;
FOLDERINFO Folder={0};
MEMORYFILE File={0};
FOLDERID idServer;
DWORD cbRead;
LPSTR pszT;
LPSTR pszGroup;
LPSTR pszDescription;
FOLDERID idFolder;
LPFILEINFO pSubList=NULL;
LPFILEINFO pCurrent;
LPSUBLISTHEADER pSubListHeader;
IDatabase *pDB=NULL;
CHAR szPath[_MAX_PATH];
CHAR szDrive[_MAX_DRIVE];
CHAR szDir[_MAX_DIR];
CHAR szFile[_MAX_FNAME];
CHAR szExt[_MAX_EXT];
LPGRPLISTHEADER pHeader;
// Trace
TraceCall("MergeNewsGroupList");
// Find the Server Id
if (FAILED(pStore->FindServerId(pInfo->szAcctId, &idServer)))
goto exit;
// Set Progress File
SetProgressFile(pProgress, pInfo);
// Open the Group List File
IF_FAILEXIT(hr = OpenMemoryFile(pInfo->szFilePath, &File));
// Get the Header
pHeader = (LPGRPLISTHEADER)File.pView;
// Initialize cb
cbRead = sizeof(GRPLISTHEADER);
// Loop
for (i=0; i<pHeader->cGroups; i++)
{
// Set pszGroup
pszT = pszGroup = (LPSTR)((LPBYTE)File.pView + cbRead);
// Increment to end of pszGroup or end of file
while (*pszT && cbRead < File.cbSize)
{
// Increment cb
cbRead++;
// End of String
pszT = (LPSTR)((LPBYTE)File.pView + cbRead);
}
// Done
if (cbRead >= File.cbSize)
break;
// Step Over the Null
cbRead++;
// Set pszDescription
pszT = pszDescription = (LPSTR)((LPBYTE)File.pView + cbRead);
// Increment to end of pszGroup or end of file
while (*pszT && cbRead < File.cbSize)
{
// Increment cb
cbRead++;
// End of String
pszT = (LPSTR)((LPBYTE)File.pView + cbRead);
}
// Done
if (cbRead >= File.cbSize)
break;
// Increment over the null
cbRead++;
// Step over group type
cbRead += sizeof(DWORD);
// Not Empyt
if ('\0' == *pszGroup)
break;
// Set the Folder Info
Folder.pszName = pszGroup;
Folder.pszDescription = pszDescription;
Folder.idParent = idServer;
Folder.tySpecial = FOLDER_NOTSPECIAL;
// Create the Folder
pStore->CreateFolder(0, &Folder, NOSTORECALLBACK);
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pInfo);
}
// Walk through news message files and create folders for them.
for (pCurrent=pHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Find the Sublist for this group
if (FILE_IS_NEWS_SUBLIST == pCurrent->tyFile && lstrcmpi(pCurrent->szAcctId, pInfo->szAcctId) == 0)
{
// Set pSubList
pSubList = pCurrent;
// Done
break;
}
}
// No Sub List
if (NULL == pSubList)
goto exit;
// Close the File
CloseMemoryFile(&File);
// Set Progress File
SetProgressFile(pProgress, pSubList);
// Open the Group List File
IF_FAILEXIT(hr = OpenMemoryFile(pSubList->szFilePath, &File));
// De-Ref the header
pSubListHeader = (LPSUBLISTHEADER)File.pView;
// SUBFILE_VERSION5
if (SUBFILE_VERSION5 == pSubListHeader->dwVersion)
{
// Locals
PGROUPSTATUS5 pStatus;
DWORD cbRead;
// Initialize cbRead
cbRead = sizeof(SUBLISTHEADER) + sizeof(DWORD);
// PGROUPSTATUS5
for (i=0; i<pSubListHeader->cSubscribed; i++)
{
// De-Ref the Group Status
pStatus = (PGROUPSTATUS5)((LPBYTE)File.pView + cbRead);
// Increment cbRead
cbRead += sizeof(GROUPSTATUS5);
// Read the Name
pszGroup = (LPSTR)((LPBYTE)File.pView + cbRead);
// Increment cbRead
cbRead += pStatus->cbName + pStatus->cbReadRange + pStatus->cbKnownRange + pStatus->cbMarkedRange + pStatus->cbRequestedRange;
// Find The Folder...
Folder.idParent = idServer;
Folder.pszName = pszGroup;
// Try to find this folder
if (DB_S_FOUND == pStore->FindRecord(IINDEX_ALL, COLUMNS_ALL, &Folder, NULL))
{
// Locals
CHAR szSrcFile[MAX_PATH];
// Subscribe to It
if (ISFLAGSET(pStatus->dwFlags, GSF_SUBSCRIBED))
{
// Its SubScribed
FLAGSET(Folder.dwFlags, FOLDER_SUBSCRIBED);
}
// Format the original file name
wnsprintf(szSrcFile, ARRAYSIZE(szSrcFile), "%08x", pStatus->dwCacheFileIndex);
// Try to find the folder in the list of files
for (pCurrent=pHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Find the Sublist for this group
if (pCurrent->fMigrate && FILE_IS_NEWS_MESSAGES == pCurrent->tyFile && lstrcmpi(pCurrent->szAcctId, pInfo->szAcctId) == 0)
{
// Get the File Name
_splitpath(pCurrent->szFilePath, szDrive, szDir, szFile, szExt);
// Correct file name
if (lstrcmpi(szFile, szSrcFile) == 0)
{
// Get the File Name
_splitpath(pCurrent->szDstFile, szDrive, szDir, szFile, szExt);
// Format the original file name
wnsprintf(szSrcFile, ARRAYSIZE(szSrcFile), "%s%s", szFile, szExt);
// Set the File Path
Folder.pszFile = szSrcFile;
// Set Folder Counts
Folder.cMessages = pCurrent->cMessages;
Folder.cUnread = pCurrent->cUnread;
// FixupFolderUserData(
FixupFolderUserData(pSession, Folder.idFolder, pszGroup, FOLDER_NOTSPECIAL, pCurrent);
// Done
break;
}
}
}
// Update the Record
pStore->UpdateRecord(&Folder);
// Free This
pStore->FreeRecord(&Folder);
}
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pSubList);
}
}
// SUBFILE_VERSION4
else if (SUBFILE_VERSION4 == pSubListHeader->dwVersion)
{
// Locals
PGROUPSTATUS4 pStatus;
DWORD cbRead;
// Initialize cbRead
cbRead = sizeof(SUBLISTHEADER);
// PGROUPSTATUS5
for (i=0; i<pSubListHeader->cSubscribed; i++)
{
// De-Ref the Group Status
pStatus = (PGROUPSTATUS4)((LPBYTE)File.pView + cbRead);
// Increment cbRead
cbRead += sizeof(GROUPSTATUS4);
// Read the Name
pszGroup = (LPSTR)((LPBYTE)File.pView + cbRead);
// Increment cbRead
cbRead += pStatus->cbName + pStatus->cbReadRange + pStatus->cbKnownRange + pStatus->cbMarkedRange + pStatus->cbRequestedRange;
// Find The Folder...
Folder.idParent = idServer;
Folder.pszName = pszGroup;
// Try to find this folder
if (DB_S_FOUND == pStore->FindRecord(IINDEX_ALL, COLUMNS_ALL, &Folder, NULL))
{
// Locals
CHAR szSrcFile[MAX_PATH];
// Subscribe to It
if (ISFLAGSET(pStatus->dwFlags, GSF_SUBSCRIBED))
{
// Its SubScribed
FLAGSET(Folder.dwFlags, FOLDER_SUBSCRIBED);
}
// Try to find the folder in the list of files
for (pCurrent=pHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Find the Sublist for this group
if (pCurrent->fMigrate && FILE_IS_NEWS_MESSAGES == pCurrent->tyFile && lstrcmpi(pCurrent->szAcctId, pInfo->szAcctId) == 0)
{
// Correct file name
if (lstrcmpi(pszGroup, pCurrent->szFolder) == 0)
{
// Get the File Name
_splitpath(pCurrent->szDstFile, szDrive, szDir, szFile, szExt);
// Format the original file name
wnsprintf(szSrcFile, ARRAYSIZE(szSrcFile), "%s%s", szFile, szExt);
// Set the File Path
Folder.pszFile = szSrcFile;
// Set Folder Counts
Folder.cMessages = pCurrent->cMessages;
Folder.cUnread = pCurrent->cUnread;
// FixupFolderUserData(
FixupFolderUserData(pSession, Folder.idFolder, pszGroup, FOLDER_NOTSPECIAL, pCurrent);
// Done
break;
}
}
}
// Update the Record
pStore->UpdateRecord(&Folder);
// Free This
pStore->FreeRecord(&Folder);
}
// Bump Progress
if(!g_fQuiet)
IncrementProgress(pProgress, pSubList);
}
}
// SUBFILE_VERSION3
else if (SUBFILE_VERSION3 == pSubListHeader->dwVersion)
{
Assert(FALSE);
}
// SUBFILE_VERSION2
else if (SUBFILE_VERSION2 == pSubListHeader->dwVersion)
{
Assert(FALSE);
}
exit:
// Close the File
CloseMemoryFile(&File);
// Done
return(hr);
}
// --------------------------------------------------------------------------------
// BuildUnifiedFolderManager
// --------------------------------------------------------------------------------
HRESULT BuildUnifiedFolderManager(IDatabaseSession *pSession, IMessageStore *pStore,
LPFILEINFO pHeadFile, LPPROGRESSINFO pProgress)
{
// Locals
HRESULT hr=S_OK;
LPFILEINFO pCurrent;
// Trace
TraceCall("BuildUnifiedFolderManager");
// Walk through the list of files and merge the folders, sublist, group lists into pFolder
for (pCurrent=pHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Handle Folders Type
if (FILE_IS_LOCAL_FOLDERS == pCurrent->tyFile)
{
// Merge Local Folder Cache into new Folder Manager
IF_FAILEXIT(hr = MergeFolderCacheIntoStore(pSession, pStore, pCurrent, pHeadFile, pProgress));
}
// IMAP Folder
else if (FILE_IS_IMAP_FOLDERS == pCurrent->tyFile)
{
// Merge IMAP Folder Cache into new Folder Manager
IF_FAILEXIT(hr = MergeFolderCacheIntoStore(pSession, pStore, pCurrent, pHeadFile, pProgress));
}
// News Group List
else if (FILE_IS_NEWS_GRPLIST == pCurrent->tyFile)
{
// Merge IMAP Folder Cache into new Folder Manager
IF_FAILEXIT(hr = MergeNewsGroupList(pSession, pStore, pCurrent, pHeadFile, pProgress));
}
}
// Walk through any files that were not merged into the store
for (pCurrent=pHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Find the Sublist for this group
if (TRUE == pCurrent->fMigrate && FALSE == pCurrent->fInStore)
{
// Local Message File...
if (FILE_IS_LOCAL_MESSAGES == pCurrent->tyFile)
{
// Locals
FLDINFO Folder={0};
SPECIALFOLDER tySpecial;
CHAR szFolder[255];
CHAR szPath[_MAX_PATH];
CHAR szDrive[_MAX_DRIVE];
CHAR szDir[_MAX_DIR];
CHAR szFile[_MAX_FNAME];
CHAR szExt[_MAX_EXT];
// Get Special Folder Info
GetSpecialFolderInfo(pCurrent->szFilePath, szFolder, ARRAYSIZE(szFolder), &Folder.tySpecial);
// Special Case for News Special Folders from v1
if (0xffffffff == Folder.tySpecial && strstr(szFolder, "special folders") != NULL)
{
// Locals
CHAR szRes[255];
// News Outbox
LoadString(g_hInst, IDS_POSTEDITEMS, szRes, ARRAYSIZE(szRes));
// Contains "Posted Items"
if (strstr(szFolder, szRes) != NULL)
LoadString(g_hInst, IDS_NEWSPOSTED, szFolder, ARRAYSIZE(szFolder));
// Contains "Saved Items"
else
{
// News Saved Items
LoadString(g_hInst, IDS_SAVEDITEMS, szRes, ARRAYSIZE(szRes));
// Contains "Saved Items"
if (strstr(szFolder, szRes) != NULL)
LoadString(g_hInst, IDS_NEWSSAVED, szFolder, ARRAYSIZE(szFolder));
// Otherwise
else
{
// News Outbox
LoadString(g_hInst, IDS_OUTBOX, szRes, ARRAYSIZE(szRes));
// Contains Outbox
if (strstr(szFolder, szRes) != NULL)
LoadString(g_hInst, IDS_NEWSOUTBOX, szFolder, ARRAYSIZE(szFolder));
}
}
}
// Compute the File Name
_splitpath(pCurrent->szDstFile, szDrive, szDir, szFile, szExt);
wnsprintf(Folder.szFile, ARRAYSIZE(Folder.szFile), "%s.dbx", szFile);
// Set the Name
if ('\0' != *pCurrent->szFolder)
StrCpyN(Folder.szFolder, pCurrent->szFolder, ARRAYSIZE(Folder.szFolder));
else if ('\0' != *szFolder)
StrCpyN(Folder.szFolder, szFolder, ARRAYSIZE(Folder.szFolder));
else
StrCpyN(Folder.szFolder, szFile, ARRAYSIZE(Folder.szFolder));
// Set Message and Unread Count
Folder.cMessages = pCurrent->cMessages;
Folder.cUnread = pCurrent->cUnread;
// Insert into Local Store
InsertFolderIntoStore(pSession, pStore, &Folder, 0, NULL, FOLDERID_LOCAL_STORE, NULL, NULL, (LPFOLDERID)&Folder.idFolder);
// Fixup special
tySpecial = (Folder.tySpecial == 0xffffffff) ? FOLDER_NOTSPECIAL : (BYTE)(Folder.tySpecial + 1);
// Update the Folder's UserData
FixupFolderUserData(pSession, (FOLDERID)IntToPtr(Folder.idFolder), Folder.szFolder, tySpecial, pCurrent);
}
// Otherwise, just delete the file
else if (FILE_IS_POP3UIDL != pCurrent->tyFile)
DeleteFile(pCurrent->szDstFile);
}
}
exit:
// Done
return(hr);
}
// --------------------------------------------------------------------------------
// CleanupMessageStore
// --------------------------------------------------------------------------------
HRESULT CleanupMessageStore(LPCSTR pszStoreRoot, IMessageStore *pStore)
{
// Locals
HRESULT hr=S_OK;
FOLDERINFO Folder={0};
HROWSET hRowset=NULL;
CHAR szFilePath[MAX_PATH + MAX_PATH];
// Trace
TraceCall("CleanupMessageStore");
// Create a Rowset
IF_FAILEXIT(hr = pStore->CreateRowset(IINDEX_PRIMARY, 0, &hRowset));
// Walk the Rowset
while(S_OK == pStore->QueryRowset(hRowset, 1, (LPVOID *)&Folder, NULL))
{
// If it has a file and no messags.
if (Folder.pszFile && 0 == Folder.cMessages)
{
// Delete the file...
IF_FAILEXIT(hr = MakeFilePath(pszStoreRoot, Folder.pszFile, "", szFilePath, ARRAYSIZE(szFilePath)));
// Delete the File
DeleteFile(szFilePath);
// Reset the filename
Folder.pszFile = NULL;
// Update the Record
IF_FAILEXIT(hr = pStore->UpdateRecord(&Folder));
}
// Otherwise, if there is a file, force a folder rename
else if (Folder.pszFile)
{
// Rename the folder
pStore->RenameFolder(Folder.idFolder, Folder.pszName, 0, NULL);
}
// Cleanup
pStore->FreeRecord(&Folder);
}
exit:
// Cleanup
pStore->FreeRecord(&Folder);
pStore->CloseRowset(&hRowset);
// Done
return(hr);
}
// --------------------------------------------------------------------------------
// UpgradeV5
// --------------------------------------------------------------------------------
HRESULT UpgradeV5(MIGRATETOTYPE tyMigrate, LPCSTR pszStoreSrc, LPCSTR pszStoreDst,
LPPROGRESSINFO pProgress, LPFILEINFO *ppHeadFile)
{
// Locals
HRESULT hr=S_OK;
ENUMFILEINFO EnumInfo;
LPFILEINFO pCurrent;
DWORD cbNeeded;
DWORDLONG dwlFree;
BOOL fContinue;
CHAR szFolders[MAX_PATH + MAX_PATH];
CHAR szMsg[512];
IMessageStore *pStore=NULL;
IDatabaseSession *pSession=NULL;
// Trace
TraceCall("UpgradeV5");
// Initialize
*ppHeadFile = NULL;
// Setup the EnumFile Info
ZeroMemory(&EnumInfo, sizeof(ENUMFILEINFO));
EnumInfo.pszExt = ".nch";
EnumInfo.pszFoldFile = "folders.nch";
EnumInfo.pszUidlFile = "pop3uidl.dat";
EnumInfo.pszSubList = "sublist.dat";
EnumInfo.pszGrpList = "grplist.dat";
EnumInfo.fFindV1News = TRUE;
// Enumerate All ODB files in szStoreRoot...
IF_FAILEXIT(hr = EnumerateStoreFiles(pszStoreSrc, DIR_IS_ROOT, NULL, &EnumInfo, ppHeadFile));
// Setup the EnumFile Info
ZeroMemory(&EnumInfo, sizeof(ENUMFILEINFO));
EnumInfo.pszExt = ".mbx";
EnumInfo.pszFoldFile = NULL;
EnumInfo.pszUidlFile = NULL;
// Enumerate All ODB files in szStoreRoot...
IF_FAILEXIT(hr = EnumerateStoreFiles(pszStoreSrc, DIR_IS_ROOT, NULL, &EnumInfo, ppHeadFile));
// Nothing to upgrade
if (NULL == *ppHeadFile)
goto exit;
// Compute some Counts, and validate that the files are valid to migrate...
IF_FAILEXIT(hr = UpgradeProcessFileListV5(pszStoreSrc, pszStoreDst, *ppHeadFile, &pProgress->cMax, &cbNeeded));
// Message
LoadString(g_hInst, IDS_UPGRADEMESSAGE, szMsg, ARRAYSIZE(szMsg));
// Message
if(!g_fQuiet)
MigrateMessageBox(szMsg, MB_OK | MB_ICONINFORMATION | MB_SETFOREGROUND);
// Delete fles
UpgradeDeleteFilesV5(pszStoreDst);
// Create an Ojbect Database
IF_FAILEXIT(hr = CoCreateInstance(CLSID_DatabaseSession, NULL, CLSCTX_INPROC_SERVER, IID_IDatabaseSession, (LPVOID *)&pSession));
// Create an Ojbect Database
IF_FAILEXIT(hr = CoCreateInstance(CLSID_MigrateMessageStore, NULL, CLSCTX_INPROC_SERVER, IID_IMessageStore, (LPVOID *)&pStore));
// Build the Folders.odb File Path
wnsprintf(szFolders, ARRAYSIZE(szFolders), "%s\\folders.dbx", pszStoreDst);
// Delete It First
DeleteFile(szFolders);
// Initialize the Store
IF_FAILEXIT(hr = pStore->Initialize(pszStoreDst));
// Initialize the Store
IF_FAILEXIT(hr = pStore->Validate(0));
// Enought DiskSpace ?
IF_FAILEXIT(hr = GetAvailableDiskSpace(pszStoreDst, &dwlFree));
// Not Enought Diskspace
if (((DWORDLONG) cbNeeded) > dwlFree)
{
// cbNeeded is DWORD and in this case we can downgrade dwlFree to DWORD
g_cbDiskNeeded = cbNeeded; g_cbDiskFree = ((DWORD) dwlFree);
hr = TraceResult(MIGRATE_E_NOTENOUGHDISKSPACE);
goto exit;
}
// Loop through the files and migrate each one
for (pCurrent=*ppHeadFile; pCurrent!=NULL; pCurrent=pCurrent->pNext)
{
// Migrate this file ?
if (pCurrent->fMigrate)
{
// Set Progress File
SetProgressFile(pProgress, pCurrent);
// Assume we will continue
fContinue = FALSE;
// Downgrade the file
hr = pCurrent->hrMigrate = UpgradeFileV5(pSession, tyMigrate, pCurrent, pProgress, &fContinue);
// Failure ?
if (FAILED(pCurrent->hrMigrate))
{
// Set Last Error
pCurrent->dwLastError = GetLastError();
// Stop
if (FALSE == fContinue)
break;
if(!g_fQuiet) {
// Fixup the progress
while (pCurrent->cProgCur < pCurrent->cProgMax)
{
IncrementProgress(pProgress, pCurrent);
}
}
// We are ok
hr = S_OK;
}
}
}
// Process Folder Lists
hr = BuildUnifiedFolderManager(pSession, pStore, *ppHeadFile, pProgress);
// Failure, delete all destination files
if (FAILED(hr))
{
// Delete fles
UpgradeDeleteFilesV5(pszStoreDst);
}
// Otherwise, lets force a folder rename to build friendly file names
else
{
// Rename all the folders...
CleanupMessageStore(pszStoreDst, pStore);
}
#if 0
// Otherwise, delete source files
else
{
// Delete all source files
UpgradeDeleteIdxMbxNchDatFilesV5(*ppHeadFile);
}
#endif
exit:
// Cleanup
SafeRelease(pStore);
// Done
return hr;
}