windows-server-2003/inetcore/outlookexpress/wabw/wabapi/mpsmisc.c

////////////////////////////////////////////////////////////////////////////////
///
///
/// MPSMisc.C
///
/// Microsoft Property Store - WAB Dll - miscellaneous helper functions
///
/// binSearchStr
/// binSearchEID
/// LoadIndex
/// SizeOfSinglePropData
/// SizeOfMultiPropData
/// UnlockFileAccess
/// LockFileAccess
/// LocalFreePropArray
/// FreePcontentlist
/// ReadRecordWithoutLocking
/// GetWABBackupFileName
/// CopySrcFileToDestFile
/// bIsValidRecord
/// TagWABFileError
/// ReloadMPSWabFileInfo
///
/// CreateMPSWabFile
/// CompressFile
/// HrDoQuickWABIntegrityCheck
/// HrResetWABFileContents
/// HrRestoreFromBackup
/// HrDoDetailedWABIntegrityCheck
/////////////////////////////////////////////////////////////////////////////////
#include "_apipch.h"

extern BOOL fTrace;							// Set TRUE if you want debug traces
extern BOOL fDebugTrap;						// Set TRUE to get int3's
extern TCHAR szDebugOutputFile[MAX_PATH];	// the name of the debug output file
extern BOOL SubstringSearch(LPTSTR pszTarget, LPTSTR pszSearch);

BOOL CopySrcFileToDestFile(HANDLE hSrc, ULONG ulSrcStartOffset,
                           HANDLE hDest,ULONG ulDestStartOffset);



//$$////////////////////////////////////////////////////////////////////////////
//
// Gets us a WAB specific temp file name to play with
//
//
////////////////////////////////////////////////////////////////////////////////
void GetWABTempFileName(LPTSTR szFileName)
{
    TCHAR   szBuf[MAX_PATH];
    TCHAR   szBufPath[MAX_PATH];
    szBufPath[0]='\0';
    GetTempPath(MAX_PATH,szBufPath);
    LoadString(hinstMapiX, IDS_WAB_TEMP_FILE_PREFIX, szBuf, CharSizeOf(szBuf));
    GetTempFileName(szBufPath,                   /* dir. for temp. files            */
                    szBuf, //"MPS",                /* temp. filename prefix           */
                    0,                    /* create unique name w/ sys. time */
                    (LPTSTR) szFileName); /* buffer for name                 */

    return;
}

//$$//////////////////////////////////////////////////////////////////////////////////
//
//  BOOL binSearchStr - binary search routine for scanning string indexes
//
// IN  struct _tagIndexOffset * Index - Index Array to Search in
// IN  LPTSTR lpszValue - value to search for
// IN  ULONG nArraySize - number of elements in array
// OUT ULONG lpulMatchIndex - array index of matched item
//
// Returns:
//      Nothing found: FALSE - lpulMatchIndex contains array position at which this entry
//                              this entry would hypothetically exist, were it a part of the array
//      Match found: TRUE - lpulMatchIndex contains array position of matched entry
//
// Comments:
//      Algorithm from "Data Structures" by Reingold & Hansen, pg. 278.
//
////////////////////////////////////////////////////////////////////////////////////
BOOL BinSearchStr(  IN  struct  _tagMPSWabIndexEntryDataString * lpIndexStr,
                    IN  LPTSTR  lpszValue,   //used for searching strings
                    IN  ULONG   nArraySize,
                    OUT ULONG * lpulMatchIndex)
{
    LONG    low = 0;
    LONG    high = nArraySize - 1;
    LONG    mid = (low + high) / 2;
    int     comp = 0;
    BOOL    bRet = FALSE;

    *lpulMatchIndex = 0;

    if (nArraySize == 0) return FALSE;

    while (low <= high && ! bRet) {
        mid = (low + high) / 2;
        comp = lstrcmpi(lpIndexStr[mid].szIndex, lpszValue);
        if (comp < 0) {
            low = mid + 1;
        } else if (comp > 0) {
            high = mid - 1;
        } else {
            bRet = TRUE;
        }
    }

    // Calculate found or insert position
    (ULONG)*lpulMatchIndex = bRet ? mid : low;

    // DebugTrace(TEXT("\tBinSearchSTR: Exit\n"));

    return bRet;
}

//$$//////////////////////////////////////////////////////////////////////////////////
//
//  BOOL binSearchEID - binary search routine for scanning EntryID index
//
// IN  lpIndexEID - Index Array to Search in
// IN  LPTSTR dwValue - value to search for
// IN  ULONG nArraySize - number of elements in array
// OUT ULONG lpulMatchIndex - array index of matched item
//
// Returns:
//      Nothing found: FALSE - lpulMatchIndex contains array position at which this entry
//                              this entry would hypothetically exist, were it a part of the array
//      Match found: TRUE - lpulMatchIndex contains array position of matched entry
//
////////////////////////////////////////////////////////////////////////////////////
BOOL BinSearchEID(  IN  struct  _tagMPSWabIndexEntryDataEntryID * lpIndexEID,
                    IN  DWORD   dwValue,     //used for comparing DWORDs
                    IN  ULONG   nArraySize,
                    OUT ULONG * lpulMatchIndex)
{
    LONG    low = 0;
    LONG    high = nArraySize - 1;
    LONG    mid = (low + high) / 2;
    BOOL    bRet = FALSE;

    *lpulMatchIndex = 0;


    // The special cases for this algorithm are
    // nArraySize == 0
    if (nArraySize == 0) return FALSE;

    while (low <= high && ! bRet) {
        mid = (low + high) / 2;

        if (lpIndexEID[mid].dwEntryID < dwValue) 
            low = mid+1;
        else if (lpIndexEID[mid].dwEntryID > dwValue) 
            high = mid - 1;
        else //equal 
            bRet = TRUE;
    }

    // Calculate found or insert position
    (ULONG)*lpulMatchIndex = bRet ? mid : low;

    return bRet;
}




//$$//////////////////////////////////////////////////////////////////////////////////
//
//  CreateMPSWabFile
//
//  Internal function for creating the MPS Wab File - called from several places
//
//  IN ulcMaxEntries - this number determines how much space we put aside for
//                      the indexes when we create the file. From time to time
//                      we will need to grow the file so we can call this CreateFile
//                      function to create the new file with the new size...
//
////////////////////////////////////////////////////////////////////////////////////
BOOL CreateMPSWabFile(IN    struct  _tagMPSWabFileHeader * lpMPSWabFileHeader,
                      IN    LPTSTR  lpszFileName,
                      IN    ULONG   ulcMaxEntries,
                      IN    ULONG   ulNamedPropSize)
{

        HRESULT hr = E_FAIL;
        HANDLE  hMPSWabFile = NULL;
        DWORD   dwNumofBytesWritten;
        LPVOID  lpszBuffer = NULL;
        int     i = 0;

        DebugTrace(TEXT("\tCreateMPSWabFile: Entry\n"));


        //
        // Create the file - its assumed that calling function has worked out all the
        // logic for whether or not old file should be left alone or not.
        //
        hMPSWabFile = CreateFile(   lpszFileName,
                                    GENERIC_WRITE,
                                    0,
                                    (LPSECURITY_ATTRIBUTES) NULL,
                                    CREATE_ALWAYS,
                                    FILE_ATTRIBUTE_NORMAL,
                                    (HANDLE) NULL);

        if (hMPSWabFile == INVALID_HANDLE_VALUE)
        {
            DebugPrintError(( TEXT("Could not create file.\nExiting ...\n")));
            goto out;
        }


        lpMPSWabFileHeader->ulModificationCount = 0;
        lpMPSWabFileHeader->MPSWabGuid = MPSWab_GUID;
        lpMPSWabFileHeader->ulcNumEntries = 0;
        lpMPSWabFileHeader->ulcMaxNumEntries = ulcMaxEntries;
        lpMPSWabFileHeader->ulFlags = WAB_CLEAR;
        lpMPSWabFileHeader->ulReserved1 = 0;
        lpMPSWabFileHeader->ulReserved2 = 0;
        lpMPSWabFileHeader->ulReserved3 = 0;
        lpMPSWabFileHeader->ulReserved4 = 0;
        lpMPSWabFileHeader->dwNextEntryID = 1;


        // We will squeeze in the space to save the named property data betweeen th
        // File header and the First Index
        lpMPSWabFileHeader->NamedPropData.ulOffset = sizeof(MPSWab_FILE_HEADER);
        lpMPSWabFileHeader->NamedPropData.UtilizedBlockSize = 0;
        lpMPSWabFileHeader->NamedPropData.ulcNumEntries = 0;
        lpMPSWabFileHeader->NamedPropData.AllocatedBlockSize = ulNamedPropSize;

        // its important that this order matches  TEXT("enum _IndexType") in mpswab.h
        // or we'll have major read-write problems
        for(i=0;i<indexMax;i++)
        {

            lpMPSWabFileHeader->IndexData[i].UtilizedBlockSize = 0;
            lpMPSWabFileHeader->IndexData[i].ulcNumEntries = 0;
            if(i==indexEntryID)
            {
                lpMPSWabFileHeader->IndexData[i].ulOffset = lpMPSWabFileHeader->NamedPropData.AllocatedBlockSize + lpMPSWabFileHeader->NamedPropData.ulOffset;
                lpMPSWabFileHeader->IndexData[i].AllocatedBlockSize = ulcMaxEntries * sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID);
            }
            else
            {
                lpMPSWabFileHeader->IndexData[i].ulOffset = lpMPSWabFileHeader->IndexData[i-1].ulOffset + lpMPSWabFileHeader->IndexData[i-1].AllocatedBlockSize;
                lpMPSWabFileHeader->IndexData[i].AllocatedBlockSize = ulcMaxEntries * sizeof(MPSWab_INDEX_ENTRY_DATA_STRING);
            }
        }


        //Now we write this dummy structure to the file
        if(!WriteFile(  hMPSWabFile,
                        (LPCVOID) lpMPSWabFileHeader,
                        (DWORD) sizeof(MPSWab_FILE_HEADER),
                        &dwNumofBytesWritten,
                        NULL))
        {
            DebugPrintError(( TEXT("Writing FileHeader failed.\n")));
            goto out;
        }


        //Assuming that the entryid index is always smaller than the display name index
        // allocate enough empty space for a display name index and
        lpszBuffer = LocalAlloc(LMEM_ZEROINIT, lpMPSWabFileHeader->IndexData[indexDisplayName].AllocatedBlockSize);
        if(!lpszBuffer)
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            hr = MAPI_E_NOT_ENOUGH_MEMORY;
            goto out;
        }

        // Write the dummy blank Named Prop data into the file
        // (this ensures that there are all zeros in the blank space)
        // Assumes that the NamedPropData will be less than the index space
        if(!WriteFile(  hMPSWabFile,
                        (LPCVOID) lpszBuffer,
                        (DWORD) lpMPSWabFileHeader->NamedPropData.AllocatedBlockSize,
                        &dwNumofBytesWritten,
                        NULL))
        {
            DebugPrintError(( TEXT("Writing Index No. %d failed.\n"),i));
            goto out;
        }

        for (i=0;i<indexMax;i++)
        {
            if(!WriteFile(  hMPSWabFile,
                            (LPCVOID) lpszBuffer,
                            (DWORD) lpMPSWabFileHeader->IndexData[i].AllocatedBlockSize,
                            &dwNumofBytesWritten,
                            NULL))
            {
                DebugPrintError(( TEXT("Writing Index No. %d failed.\n"),i));
                goto out;
            }
        }

        LocalFreeAndNull(&lpszBuffer);

        IF_WIN32(CloseHandle(hMPSWabFile);) IF_WIN16(CloseFile(hMPSWabFile);)
        hMPSWabFile = NULL;

        hr = S_OK;


out:
        LocalFreeAndNull(&lpszBuffer);

        DebugTrace(TEXT("\tCreateMPSWabFile: Exit\n"));

        return( (FAILED(hr)) ? FALSE : TRUE);

}



//$$//////////////////////////////////////////////////////////////////////////////////
//
//  LoadIndex - Only one of the string indexes is loaded at any given time
//      If we need some other index in memory, we have to reload it from the file ...
//
//  This assumes that the ulcNumEntries and UtilizedBlockData for each index in the file header is up to date
//  because that value is used to allocate memory for the index
//
//  We use this function as a generic load index function too
//
//
////////////////////////////////////////////////////////////////////////////////////
BOOL LoadIndex( IN  struct  _tagMPSWabFileInfo * lpMPSWabFileInfo,
                IN  ULONG   nIndexType,
                IN  HANDLE  hMPSWabFile)
{
    BOOL    bRet = FALSE;
    DWORD   dwNumofBytes = 0;

    // DebugTrace(TEXT("\tLoadIndex: Entry\n"));

    if (!lpMPSWabFileInfo) goto out;

    if (lpMPSWabFileInfo->lpMPSWabFileHeader->ulcNumEntries==0) //assumes this is an accurate value
    {
        LocalFreeAndNull(&lpMPSWabFileInfo->lpMPSWabIndexEID);
        LocalFreeAndNull(&lpMPSWabFileInfo->lpMPSWabIndexStr);

        bRet = TRUE;
        goto out;
    }

    //otherwise we have to reload the index from file

    //
    //First free the existing index
    //
    if (nIndexType == indexEntryID)
    {
        LocalFreeAndNull(&lpMPSWabFileInfo->lpMPSWabIndexEID);
    }
    else
    {
        LocalFreeAndNull(&lpMPSWabFileInfo->lpMPSWabIndexStr);
    }


    //Load the index into memory
    if(0xFFFFFFFF == SetFilePointer ( hMPSWabFile,
                                      lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[nIndexType].ulOffset,
                                      NULL,
                                      FILE_BEGIN))
    {
        DebugPrintError(( TEXT("SetFilePointer Failed\n")));
        goto out;
    }

    if (nIndexType == indexEntryID)
    {
        lpMPSWabFileInfo->lpMPSWabIndexEID = LocalAlloc(LMEM_ZEROINIT, lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[nIndexType].UtilizedBlockSize);
        if(!(lpMPSWabFileInfo->lpMPSWabIndexEID))
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            goto out;
        }
        if(!ReadFile(   hMPSWabFile,
                        (LPVOID) lpMPSWabFileInfo->lpMPSWabIndexEID,
                        (DWORD) lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[nIndexType].UtilizedBlockSize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("Reading Index failed.\n")));
            goto out;
        }
    }
    else
    {
        lpMPSWabFileInfo->lpMPSWabIndexStr = LocalAlloc(LMEM_ZEROINIT, lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[nIndexType].UtilizedBlockSize);
        if(!(lpMPSWabFileInfo->lpMPSWabIndexStr))
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            goto out;
        }
        if(!ReadFile(   hMPSWabFile,
                        (LPVOID) lpMPSWabFileInfo->lpMPSWabIndexStr,
                        (DWORD) lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[nIndexType].UtilizedBlockSize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("Reading Index failed.\n")));
            goto out;
        }
    }

    if (nIndexType != indexEntryID)
        lpMPSWabFileInfo->nCurrentlyLoadedStrIndexType = nIndexType;

    bRet = TRUE;

out:

    // DebugTrace(TEXT( TEXT("\tLoadIndex: Exit\n")));
    return bRet;
}



//$$//////////////////////////////////////////////////////////////////////////////////
//
//  SizeOfSinglePropData - returns the number of bytes of data in a given SPropValue ...
//
//
////////////////////////////////////////////////////////////////////////////////////
ULONG SizeOfSinglePropData(SPropValue Prop)
{

    ULONG   i = 0;
    ULONG   ulDataSize = 0;

    switch(PROP_TYPE(Prop.ulPropTag))
    {
    case PT_I2:
        ulDataSize = sizeof(short int);
        break;
    case PT_LONG:
        ulDataSize = sizeof(LONG);
        break;
    case PT_R4:
        ulDataSize = sizeof(float);
        break;
    case PT_DOUBLE:
        ulDataSize = sizeof(double);
        break;
    case PT_BOOLEAN:
        ulDataSize = sizeof(unsigned short int);
        break;
    case PT_CURRENCY:
        ulDataSize = sizeof(CURRENCY);
        break;
    case PT_APPTIME:
        ulDataSize = sizeof(double);
        break;
    case PT_SYSTIME:
        ulDataSize = sizeof(FILETIME);
        break;
    case PT_STRING8:
        ulDataSize = lstrlenA(Prop.Value.lpszA)+1;
        break;
    case PT_UNICODE:
        ulDataSize = sizeof(TCHAR)*(lstrlenW(Prop.Value.lpszW)+1);
        break;
    case PT_BINARY:
        ulDataSize = Prop.Value.bin.cb;
        break;
    case PT_CLSID:
        ulDataSize = sizeof(GUID);
        break;
    case PT_I8:
        ulDataSize = sizeof(LARGE_INTEGER);
        break;
    case PT_ERROR:
        ulDataSize = sizeof(SCODE);
        break;
    case PT_NULL:
        ulDataSize = sizeof(LONG);
        break;
    }

    return ulDataSize;

}


//$$//////////////////////////////////////////////////////////////////////////////////
//
//  SizeOfMultiPropData - returns the number of bytes of data in a given SPropValue ...
//
//
////////////////////////////////////////////////////////////////////////////////////
ULONG SizeOfMultiPropData(SPropValue Prop)
{

    ULONG   i = 0;
    ULONG   ulDataSize = 0;

    switch(PROP_TYPE(Prop.ulPropTag))
    {
    case PT_MV_I2:
        ulDataSize = sizeof(short int) * Prop.Value.MVi.cValues;
        break;
    case PT_MV_LONG:
        ulDataSize = sizeof(LONG) * Prop.Value.MVl.cValues;
        break;
    case PT_MV_R4:
        ulDataSize = sizeof(float) * Prop.Value.MVflt.cValues;
        break;
    case PT_MV_DOUBLE:
        ulDataSize = sizeof(double) * Prop.Value.MVdbl.cValues;
        break;
    case PT_MV_CURRENCY:
        ulDataSize = sizeof(CURRENCY) * Prop.Value.MVcur.cValues;
        break;
    case PT_MV_APPTIME:
        ulDataSize =  sizeof(double) * Prop.Value.MVat.cValues;
        break;
    case PT_MV_SYSTIME:
        ulDataSize = sizeof(FILETIME) * Prop.Value.MVft.cValues;
        break;
    case PT_MV_BINARY:
        ulDataSize = 0;
        // Note this data size includes, for each array entry, the sizeof(ULONG) that
        // contains the actual datasize (i.e cb)
        for(i=0;i<Prop.Value.MVbin.cValues;i++)
        {
            ulDataSize += sizeof(ULONG) + Prop.Value.MVbin.lpbin[i].cb;
        }
        break;
    case PT_MV_STRING8:
        ulDataSize = 0;
        DebugTrace(TEXT("where the heck are we getting ANSI data from\n"));
        // Note this data size includes, for each array entry, the sizeof(ULONG) that
        // contains the actual datasize (i.e cb)
        for(i=0;i<Prop.Value.MVszA.cValues;i++)
        {
            // Note the strlen is incremented by '+1' to include the terminating NULL for
            // each string
            ulDataSize += sizeof(ULONG) + lstrlenA(Prop.Value.MVszA.lppszA[i])+1;
        }
        break;
    case PT_MV_UNICODE:
        ulDataSize = 0;
        // Note this data size includes, for each array entry, the sizeof(ULONG) that
        // contains the actual datasize (i.e cb)
        for(i=0;i<Prop.Value.MVszW.cValues;i++)
        {
            // Note the strlen is incremented by '+1' to include the terminating NULL for
            // each string
            ulDataSize += sizeof(ULONG) + sizeof(TCHAR)*(lstrlenW(Prop.Value.MVszW.lppszW[i])+1);
        }
        break;
    case PT_MV_CLSID:
        ulDataSize = sizeof(GUID) * Prop.Value.MVguid.cValues;
        break;
    case PT_MV_I8:
        ulDataSize = sizeof(LARGE_INTEGER) * Prop.Value.MVli.cValues;
        break;
    }

    return ulDataSize;

}

//$$//////////////////////////////////////////////////////////////////////////////////
//
//  ReloadMPSWabFileInfo - Reloads the MPSWabFileHeader and reloads the
//      memory indexes. This is a performance hit but cant be helped since it
//      is the most reliable way to ensure we are working with the latest
//      valid information
//
//  Thus a write by one program cannot mess up the read by another program
//
////////////////////////////////////////////////////////////////////////////////////
BOOL ReloadMPSWabFileInfo(
                    IN  struct  _tagMPSWabFileInfo * lpMPSWabFileInfo,
                    IN  HANDLE  hMPSWabFile)
{
    BOOL bRet = TRUE;
    ULONG i = 0;
    DWORD dwNumofBytes = 0;

    if(!ReadDataFromWABFile(hMPSWabFile,
                            0,
                            (LPVOID) lpMPSWabFileInfo->lpMPSWabFileHeader,
                            sizeof(MPSWab_FILE_HEADER)))
       goto out;



    if(lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[indexEntryID].ulcNumEntries != lpMPSWabFileInfo->lpMPSWabFileHeader->ulcNumEntries)
            lpMPSWabFileInfo->lpMPSWabFileHeader->ulFlags |= WAB_ERROR_DETECTED;

    for(i=indexDisplayName;i<indexMax;i++)
    {
        if(lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[i].ulcNumEntries > lpMPSWabFileInfo->lpMPSWabFileHeader->ulcNumEntries)
            lpMPSWabFileInfo->lpMPSWabFileHeader->ulFlags |= WAB_ERROR_DETECTED;
    }

    if(lpMPSWabFileInfo->lpMPSWabFileHeader->ulFlags & WAB_ERROR_DETECTED)
    {
        if(!WriteFile(  hMPSWabFile,
                        (LPCVOID) lpMPSWabFileInfo->lpMPSWabFileHeader,
                        (DWORD) sizeof(MPSWab_FILE_HEADER),
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("Writing FileHeader failed.\n")));
            goto out;
        }

    }


    //
    // Get the Entry iD index
    //
    if (!LoadIndex( IN  lpMPSWabFileInfo,
                    IN  indexEntryID,
                    IN  hMPSWabFile) )
    {
        DebugPrintError(( TEXT("Error Loading EntryID Index!\n")));
        goto out;
    }

    //
    // Get the current string index
    //
    if (!LoadIndex( IN  lpMPSWabFileInfo,
                    IN  lpMPSWabFileInfo->nCurrentlyLoadedStrIndexType,
                    IN  hMPSWabFile) )
    {
        DebugPrintError(( TEXT("Error Loading String Index!\n")));
        goto out;
    }

    bRet = TRUE;

out:

    return bRet;

}


//$$//////////////////////////////////////////////////////////////////////////////////
//
//  UnlockFileAccess - UnLocks Exclusive Access to the property store
//
////////////////////////////////////////////////////////////////////////////////////
BOOL UnLockFileAccess(LPMPSWab_FILE_INFO lpMPSWabFileInfo)
{
    BOOL bRet = FALSE;

    //DebugTrace(TEXT( TEXT("\t\tUnlockFileAccess\n")));

    if(lpMPSWabFileInfo)
    {
        bRet = ReleaseMutex(lpMPSWabFileInfo->hDataAccessMutex);
    }

    return bRet;
}



//$$//////////////////////////////////////////////////////////////////////////////////
//
//  LockFileAccess - Gives exclusive access to the Property Store
//
////////////////////////////////////////////////////////////////////////////////////
BOOL LockFileAccess(LPMPSWab_FILE_INFO lpMPSWabFileInfo)
{
    BOOL bRet = FALSE;
    DWORD dwWait = 0;

    //DebugTrace(TEXT( TEXT("\t\tLockFileAccess\n")));

    if(lpMPSWabFileInfo)
    {
        dwWait = WaitForSingleObject(lpMPSWabFileInfo->hDataAccessMutex,MAX_LOCK_FILE_TIMEOUT);

        if ((dwWait == WAIT_TIMEOUT) || (dwWait == WAIT_FAILED))
        {
            DebugPrintError(( TEXT("Thread:%x\tWaitForSingleObject failed.\n"),GetCurrentThreadId()));
            bRet = FALSE;
        }
        else
            bRet = TRUE;
    }

    return(bRet);

}



//$$//////////////////////////////////////////////////////////////////////////////////
//
//  CompressFile - Creates a compressed version of the property store
//      file that removes all the invlaid records.
//
//  The compressiong function is very similar to creating a backup and hence
//  the exported Backup function calls CompressFile. The difference being that
//  in Backup, a new file is created with a new name and in CompressFile, the
//  newfile is renamed to the property store
//
//  Similarly, growing the file is very similar and the internal call to Growing
//  the file calls CompressFile too
//
//
//  IN  lpMPSWabFileInfo
//  IN  lpsznewFileName - supplied by backup. if NULL, means that CompressFile
//      should rename the new file as the property store
//  IN BOOL bGrowFile - if specified, the new file is created with space for
//      an additional MAX_INITIAL_INDEX_ENTRIES
//  IN ULONG ulFlags - there are 2 things that can grow here - the index size and
//              the named property storage size. Hence we have the following flags
//              one or more of which can be used simultaneously
//              AB_GROW_INDEX | AB_GROW_NAMEDPROP
//
//  Returns
//      Success:    TRUE
//      Failure:    FALSE
//
////////////////////////////////////////////////////////////////////////////////////
BOOL CompressFile(  IN  struct  _tagMPSWabFileInfo * lpMPSWabFileInfo,
                    IN  HANDLE  hMPSWabFile,
                    IN  LPTSTR  lpszFileName,
                    IN  BOOL    bGrowFile,
                    IN  ULONG   ulFlags)
{
    BOOL    bRet = FALSE;
    BOOL    bBackup = FALSE;
    BOOL    bRFileLocked = FALSE;
    BOOL    bWFileLocked = FALSE;
    HANDLE  hTempFile = NULL;
    struct  _tagMPSWabFileHeader NewFileHeader = {0};
    ULONG   ulNewFileMaxEntries = 0;
    ULONG   ulNamedPropSize = 0;
    DWORD   dwNumofBytes = 0;
    struct  _tagMPSWabIndexEntryDataString * lpIndexStr = NULL;
    struct  _tagMPSWabIndexEntryDataEntryID NewMPSWabIndexEID;
    ULONG   ulNewRecordOffset = 0;
    ULONG   ulNewEIDIndexElementOffset = 0;
    ULONG   i = 0;
    LPULONG lpPropTagArray = NULL;
    struct  _tagMPSWabRecordHeader RecordHeader;
    LPVOID  lpRecordData = NULL;

    ULONG   ulBytesLeftToCopy = 0;
    ULONG   ulChunkSize = 8192; //copy 8k at a time
    LPVOID  lpv = NULL;
    TCHAR   szFileName[MAX_PATH];

    ULONG   ulFileSize = 0;


    DebugTrace(TEXT("----Thread:%x\tCompressFile: Entry\n"),GetCurrentThreadId());

    // if this is a backup operation we first backup to a temp file and
    // then rename the temp file to the backup - this way if the process
    // fails we dont lose our last made backup ...

    if (lpszFileName != NULL)
    {
        if (!lstrcmpi(lpszFileName,lpMPSWabFileInfo->lpszMPSWabFileName))
        {
            DebugPrintError(( TEXT("Cannot backup a file over itself. Please specify new backup file name.")));
            goto out;
        }
        bBackup = TRUE;
    }
    else
        bBackup = FALSE;

    GetWABTempFileName(szFileName);

    // Find the least multiple of MAX_INITIAL_INDEX_ENTRIES that can accomodate the
    // existing entries in the file and set ulNewFilMaxEntries to that number

    ulNewFileMaxEntries = 0;

    {
        int j=0;
        for( j = (lpMPSWabFileInfo->lpMPSWabFileHeader->ulcMaxNumEntries/MAX_INITIAL_INDEX_ENTRIES);j >= 0; j--)
        {
            if (lpMPSWabFileInfo->lpMPSWabFileHeader->ulcNumEntries >= (ULONG) j*MAX_INITIAL_INDEX_ENTRIES)
            {
                ulNewFileMaxEntries = (j+1)*MAX_INITIAL_INDEX_ENTRIES;
                break;
            }
        }

        if (ulNewFileMaxEntries == 0) //this shouldnt happen
            ulNewFileMaxEntries = lpMPSWabFileInfo->lpMPSWabFileHeader->ulcMaxNumEntries;

        ulNamedPropSize = lpMPSWabFileInfo->lpMPSWabFileHeader->NamedPropData.AllocatedBlockSize;
    }

    if (bGrowFile)
    {
        if(ulFlags & AB_GROW_INDEX)
            ulNewFileMaxEntries += MAX_INITIAL_INDEX_ENTRIES;

        if(ulFlags & AB_GROW_NAMEDPROP)
            ulNamedPropSize += NAMEDPROP_STORE_INCREMENT_SIZE;
    }

    if (!CreateMPSWabFile(  IN  &NewFileHeader,
                            IN  szFileName,
                            IN  ulNewFileMaxEntries,
                            IN  ulNamedPropSize))
    {
        DebugPrintError(( TEXT("Could Not Create File %s!\n"),szFileName));
        goto out;
    }

    if (hMPSWabFile == INVALID_HANDLE_VALUE)
    {
        DebugPrintError(( TEXT("Could not open file.\nExiting ...\n")));
        goto out;
    }


    hTempFile = CreateFile(     szFileName,
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                (LPSECURITY_ATTRIBUTES) NULL,
                                OPEN_EXISTING,
                                FILE_FLAG_RANDOM_ACCESS,
                                (HANDLE) NULL);

    if (hTempFile == INVALID_HANDLE_VALUE)
    {
        DebugPrintError(( TEXT("Could not open file.\nExiting ...\n")));
        goto out;
    }


    ulFileSize = GetFileSize(hMPSWabFile, NULL);

    NewFileHeader.ulcNumEntries = lpMPSWabFileInfo->lpMPSWabFileHeader->ulcNumEntries;
    NewFileHeader.ulModificationCount = 0;
    NewFileHeader.dwNextEntryID = lpMPSWabFileInfo->lpMPSWabFileHeader->dwNextEntryID;
    NewFileHeader.ulFlags = lpMPSWabFileInfo->lpMPSWabFileHeader->ulFlags;

    NewFileHeader.NamedPropData.UtilizedBlockSize = lpMPSWabFileInfo->lpMPSWabFileHeader->NamedPropData.UtilizedBlockSize;
    NewFileHeader.NamedPropData.ulcNumEntries = lpMPSWabFileInfo->lpMPSWabFileHeader->NamedPropData.ulcNumEntries;

    NewFileHeader.ulReserved1 = lpMPSWabFileInfo->lpMPSWabFileHeader->ulReserved1;
    NewFileHeader.ulReserved2 = lpMPSWabFileInfo->lpMPSWabFileHeader->ulReserved2;
    NewFileHeader.ulReserved3 = lpMPSWabFileInfo->lpMPSWabFileHeader->ulReserved3;
    NewFileHeader.ulReserved4 = lpMPSWabFileInfo->lpMPSWabFileHeader->ulReserved4;


    for(i=indexEntryID; i<indexMax; i++)
    {
        NewFileHeader.IndexData[i].UtilizedBlockSize = lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[i].UtilizedBlockSize;
        NewFileHeader.IndexData[i].ulcNumEntries = lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[i].ulcNumEntries;
    }


    // write the header info
    //
    if(!WriteDataToWABFile( hTempFile,
                            0,
                            (LPVOID) &NewFileHeader,
                            sizeof(MPSWab_FILE_HEADER)))
        goto out;


    //
    // Copy over Named Prop Data
    //
    {
        lpv = NULL;
        lpv = LocalAlloc(LMEM_ZEROINIT, NewFileHeader.NamedPropData.UtilizedBlockSize);
        if(!lpv)
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            goto out;
        }

        if (0xFFFFFFFF == SetFilePointer ( hMPSWabFile,
                                           lpMPSWabFileInfo->lpMPSWabFileHeader->NamedPropData.ulOffset,
                                           NULL,
                                           FILE_BEGIN))
        {
            DebugPrintError(( TEXT("SetFilePointer Failed\n")));
            goto out;
        }

        if (0xFFFFFFFF == SetFilePointer ( hTempFile,
                                           NewFileHeader.NamedPropData.ulOffset,
                                           NULL,
                                           FILE_BEGIN)  )
        {
            DebugPrintError(( TEXT("SetFilePointer Failed\n")));
            goto out;
        }

        if(!ReadFile(hMPSWabFile,
                     (LPVOID) lpv,
                     (DWORD) NewFileHeader.NamedPropData.UtilizedBlockSize,
                     &dwNumofBytes,
                      NULL) )
        {
            DebugPrintError(( TEXT("read file failed.\n")));
            goto out;
        }

        if(!WriteFile(   hTempFile,
                        (LPCVOID) lpv,
                        (DWORD) NewFileHeader.NamedPropData.UtilizedBlockSize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("write file failed.\n")));
            goto out;
        }

        LocalFreeAndNull(&lpv);

    } // Copy over named prop data


    //
    // Then copy over the string indexes
    //
    for(i=indexDisplayName; i<indexMax;i++)
    {
        LocalFreeAndNull(&lpIndexStr);

        lpIndexStr = LocalAlloc(LMEM_ZEROINIT, NewFileHeader.IndexData[i].UtilizedBlockSize);
        if(!lpIndexStr)
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            goto out;
        }

        if (0xFFFFFFFF == SetFilePointer ( hMPSWabFile,
                                           lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[i].ulOffset,
                                           NULL,
                                           FILE_BEGIN))
        {
            DebugPrintError(( TEXT("SetFilePointer Failed\n")));
            goto out;
        }

        if (0xFFFFFFFF == SetFilePointer ( hTempFile,
                                           NewFileHeader.IndexData[i].ulOffset,
                                           NULL,
                                           FILE_BEGIN)  )
        {
            DebugPrintError(( TEXT("SetFilePointer Failed\n")));
            goto out;
        }

        if(!ReadFile(hMPSWabFile,
                     (LPVOID) lpIndexStr,
                     (DWORD) NewFileHeader.IndexData[i].UtilizedBlockSize,
                     &dwNumofBytes,
                      NULL) )
        {
            DebugPrintError(( TEXT("read file failed.\n")));
            goto out;
        }

        if(!WriteFile(   hTempFile,
                        (LPCVOID) lpIndexStr,
                        (DWORD) NewFileHeader.IndexData[i].UtilizedBlockSize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("write file failed.\n")));
            goto out;
        }

        LocalFreeAndNull(&lpIndexStr);
    }

    //
    // now load the entryid index from the old file
    //
    if (!LoadIndex( IN  lpMPSWabFileInfo,
                    IN  indexEntryID,
                    IN  hMPSWabFile) )
    {
        DebugPrintError(( TEXT("Error Loading EntryID Index!\n")));
        goto out;
    }

    ulNewRecordOffset = NewFileHeader.IndexData[indexMax - 1].ulOffset + NewFileHeader.IndexData[indexMax - 1].AllocatedBlockSize;
    ulNewEIDIndexElementOffset = NewFileHeader.IndexData[indexEntryID].ulOffset;


    //
    // Walk through the old file entry ID index reading the
    // valid records one by one and writing them to the new file. Also write the
    // new record offset and the new EID entry into the new file (so that if we
    // crash we have as up to date data in the new file as possible
    //
    for(i=0;i<NewFileHeader.IndexData[indexEntryID].ulcNumEntries;i++)
    {
        NewMPSWabIndexEID.dwEntryID = lpMPSWabFileInfo->lpMPSWabIndexEID[i].dwEntryID;
        NewMPSWabIndexEID.ulOffset = ulNewRecordOffset;

        if(!ReadDataFromWABFile(hMPSWabFile,
                                lpMPSWabFileInfo->lpMPSWabIndexEID[i].ulOffset,
                                (LPVOID) &RecordHeader,
                                (DWORD) sizeof(MPSWab_RECORD_HEADER)))
           goto out;


        // if for some reason this was an invalid record .. skip it and go to next
        if(!bIsValidRecord( RecordHeader,
                            lpMPSWabFileInfo->lpMPSWabFileHeader->dwNextEntryID,
                            lpMPSWabFileInfo->lpMPSWabIndexEID[i].ulOffset,
                            ulFileSize))
            continue;


        LocalFreeAndNull(&lpPropTagArray);

        lpPropTagArray = LocalAlloc(LMEM_ZEROINIT, RecordHeader.ulPropTagArraySize);
        if(!lpPropTagArray)
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            goto out;
        }


        if(!ReadFile(   hMPSWabFile,
                        (LPVOID) lpPropTagArray,
                        (DWORD) RecordHeader.ulPropTagArraySize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("read file failed.\n")));
            goto out;
        }

        LocalFreeAndNull(&lpRecordData);

        lpRecordData = LocalAlloc(LMEM_ZEROINIT, RecordHeader.ulRecordDataSize);
        if(!lpRecordData)
        {
            DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
            goto out;
        }


        if(!ReadFile(   hMPSWabFile,
                        (LPVOID) lpRecordData,
                        (DWORD) RecordHeader.ulRecordDataSize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("read file failed.\n")));
            goto out;
        }




        if(!WriteDataToWABFile(hTempFile,
                                ulNewRecordOffset,
                                (LPVOID) &RecordHeader,
                                (DWORD) sizeof(MPSWab_RECORD_HEADER)))
           goto out;

        // assumes that file pointer will be at the correct spot
        if(!WriteFile(   hTempFile,
                        (LPCVOID) lpPropTagArray,
                        (DWORD) RecordHeader.ulPropTagArraySize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("write file failed.\n")));
            goto out;
        }

        // assumes that file pointer will be at the correct spot
        if(!WriteFile(  hTempFile,
                        (LPCVOID) lpRecordData,
                        (DWORD) RecordHeader.ulRecordDataSize,
                        &dwNumofBytes,
                        NULL))
        {
            DebugPrintError(( TEXT("write file failed.\n")));
            goto out;
        }

        ulNewRecordOffset += sizeof(MPSWab_RECORD_HEADER) + RecordHeader.ulPropTagArraySize + RecordHeader.ulRecordDataSize;


        LocalFreeAndNull(&lpPropTagArray);
        LocalFreeAndNull(&lpRecordData);


        //
        // Write the new entryID index element
        //
        if(!WriteDataToWABFile( hTempFile,
                                ulNewEIDIndexElementOffset,
                                (LPVOID) &NewMPSWabIndexEID,
                                sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID)))
            goto out;


        ulNewEIDIndexElementOffset += sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID);

        // loop for next record

    }

    //
    // At this point in the process we have successfuly copied over all the
    // records from the old file to the new file
    //

    // If this is a backup operation - we delete the old backup and copy the new temp file
    // as the new backup ...

    //
    // If this is not a backup operation, we want to basically delete the old file
    // and rename the new temp file as the property store ..
    //
    // However, if we release our access to the property store, there is no gaurentee that
    // some other process will not grab up exclusive access to the store and we will fail in
    // our attempt to gain control and modify ...
    //
    // Hence the options are
    // (a) give up control and then hope we can regain control before someone else does something
    //      to the file
    // (b) copy in the new file contents and overwrite the existing file contents - this is going
    //      to be slower than rewriting the file but it will give us exclusive control on the
    //      modifications and makes the process much more robust ...
    //

    if (!bBackup) // Not a backup operation
    {
        //
        // Save the header in the new file
        //
        if(!WriteDataToWABFile( hTempFile,
                                0,
                                (LPVOID) &NewFileHeader,
                                sizeof(MPSWab_FILE_HEADER)))
            goto out;

        //
        // Copy the New file into this WAB file thus replacing the old contents
        // and hope this never fails
        //
        if(!CopySrcFileToDestFile(hTempFile, 0, hMPSWabFile, 0))
        {
            DebugPrintError(( TEXT("Unable to copy files\n")));
            goto out;
        }


        //
        // Reload this so we have the new fileheader info in our structures
        //
        if(!ReloadMPSWabFileInfo(
                        lpMPSWabFileInfo,
                         hMPSWabFile))
        {
            DebugPrintError(( TEXT("Reading file info failed.\n")));
            goto out;
        }



        //
        // Thats it ..  we can close the files and party on ..
        //
    }
    else
    {
        //this is a backup operation ...

        // Close the temp file
        if (hTempFile)
        {
            IF_WIN32(CloseHandle(hTempFile);) IF_WIN16(CloseFile(hTempFile);)
            hTempFile = NULL;
        }

        if(!CopyFile( szFileName,
                      lpszFileName,
                      FALSE))
        {
            DebugPrintError(( TEXT("CopyFile %s to %s failed: %d\n"),szFileName,lpszFileName, GetLastError()));
            goto out;
        }
    }

    bRet = TRUE;



out:

    if (hTempFile)
        IF_WIN32(CloseHandle(hTempFile);) IF_WIN16(CloseFile(hTempFile);)

    if( szFileName != NULL)
        DeleteFile(szFileName);

    LocalFreeAndNull(&lpv);

    LocalFreeAndNull(&lpPropTagArray);

    LocalFreeAndNull(&lpRecordData);


    DebugTrace(TEXT("----Thread:%x\tCompressFile: Exit\n"),GetCurrentThreadId());

    return bRet;
}



//$$//////////////////////////////////////////////////////////////////////////////////
//
//  ReadRecordWithoutLocking
//
//  IN  lpMPSWabFileInfo
//  IN  dwEntryID - EntryID of record to read
//  OUT ulcPropCount - number of props returned
//  OUT lpPropArray - Array of Property values
//
//  Returns
//      Success:    S_OK
//      Failure:    E_FAIL
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT ReadRecordWithoutLocking(
                    IN  HANDLE hMPSWabFile,
                    IN  struct _tagMPSWabFileInfo * lpMPSWabFileInfo,
                    IN  DWORD   dwEntryID,
                    OUT LPULONG lpulcPropCount,
                    OUT LPPROPERTY_ARRAY * lppPropArray)
{
    HRESULT hr = E_FAIL;
    ULONG ulRecordOffset = 0;
    BOOL bErrorDetected = FALSE;
    ULONG nIndexPos = 0;
    ULONG ulObjType = 0;

    *lpulcPropCount = 0;
    *lppPropArray = NULL;

    //
    // First check if this is a valid entryID
    //
    if (!BinSearchEID(  IN  lpMPSWabFileInfo->lpMPSWabIndexEID,
                        IN  dwEntryID,
                        IN  lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[indexEntryID].ulcNumEntries,
                        OUT &nIndexPos))
    {
        DebugPrintError(( TEXT("Specified EntryID doesnt exist!\n")));
        hr = MAPI_E_INVALID_ENTRYID;
        goto out;
    }

    //if entryid exists, we can start reading the record
    ulRecordOffset = lpMPSWabFileInfo->lpMPSWabIndexEID[nIndexPos].ulOffset;

    hr = HrGetPropArrayFromFileRecord(hMPSWabFile,
                                      ulRecordOffset,
                                      &bErrorDetected,
                                      &ulObjType,
                                      NULL,
                                      lpulcPropCount,
                                      lppPropArray);

    if(!HR_FAILED(hr))
    {
        // reset the backward compatibility thing-um-a-jig we did between
        // MAPI_ABCONT and MAPI_MAILUSER
        if(ulObjType == RECORD_CONTAINER)
            SetContainerObjectType(*lpulcPropCount, *lppPropArray, FALSE);
    }

out:

    //a little cleanup on failure
    if (FAILED(hr))
    {
        if(bErrorDetected)
        {
            TagWABFileError(lpMPSWabFileInfo->lpMPSWabFileHeader,
                            hMPSWabFile);
        }

        if ((*lppPropArray) && (*lpulcPropCount > 0))
        {
            LocalFreePropArray(NULL, *lpulcPropCount, lppPropArray);
            *lppPropArray = NULL;
        }
    }

    return(hr);
}

//$$//////////////////////////////////////////////////////////////////////////////
//
// GetWABBackupFileName - derives the backup file name from the WAB file by changing
//              the extension from WAB to BWB
//
// lpszWabFileName - WAB file name
// lpszBackupFileName - Backup File name - points to a preallocated buffer big enough to
//                  hold the backup file name
//
// This generates a backup name in which the last character is turned into a ~
////////////////////////////////////////////////////////////////////////////////////
void GetWABBackupFileName(LPTSTR lpszWab, LPTSTR lpszBackup, ULONG cchBackup)
{
    ULONG nLen;

    if(!lpszWab || !lpszBackup)
        goto out;

    nLen = lstrlen(lpszWab);

//    if((nLen < 4) || (lpszWab[nLen-4] != '.'))
//        goto out;

    StrCpyN(lpszBackup,lpszWab, cchBackup);

    lpszBackup[nLen-1]='\0';

    StrCpyN(lpszBackup,TEXT("~"), cchBackup);

out:

    return;
}


//$$//////////////////////////////////////////////////////////////////////////////
//
// HrDoQuickWABIntegrityCheck - does a quick integrity check of the WAB indexes
//              Verifies that:
//
//  - Indexes contain the correct number of entries which is equal to or less than
//      the max number of entries
//  - Indexes dont contain duplicate entry-ids
//  - Indexes point to valid and existing data ...
//
//  If there are problems, this function attempts to fix them - if it cant fix them
//  we fail and caller should call HrDoDetailedWABIntegrityCheck which will rebuild
//  the indexes from the actual WAB data.
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrDoQuickWABIntegrityCheck(LPMPSWab_FILE_INFO lpMPSWabFileInfo, HANDLE hMPSWabFile)
{
    HRESULT hr = E_FAIL;
    BOOL bError = FALSE;
    ULONG ulcNumWABEntries = 0,ulcNumIndexEntries = 0;
    LPMPSWab_FILE_HEADER lpMPSWabFileHeader = NULL;
    MPSWab_RECORD_HEADER MPSWabRecordHeader = {0};
    ULONG i=0,j=0;
    DWORD dwNumofBytes = 0;
    ULONG ulFileSize = GetFileSize(hMPSWabFile,NULL);

    lpMPSWabFileHeader = lpMPSWabFileInfo->lpMPSWabFileHeader;
    ulcNumWABEntries = lpMPSWabFileHeader->ulcNumEntries;

    //
    // First check the EntryID index
    //
    if (!LoadIndex( IN  lpMPSWabFileInfo,
                    IN  indexEntryID,
                    IN  hMPSWabFile) )
    {
        DebugPrintError(( TEXT("Error Loading Index!\n")));
        goto out;
    }

    ulcNumIndexEntries = lpMPSWabFileHeader->IndexData[indexEntryID].ulcNumEntries;

    if(ulcNumIndexEntries != ulcNumWABEntries)
    {
        hr = MAPI_E_INVALID_ENTRYID;
        DebugPrintError(( TEXT("EntryID index has incorrect number of elements\n")));
        goto out;
    }

    if(ulcNumIndexEntries > 0)
    {
        for(i=0;i<ulcNumIndexEntries-1;i++)
        {
            // Since this is a sorted array, the indexes will be in sorted order
            // So we just compare one with the next
            if(lpMPSWabFileInfo->lpMPSWabIndexEID[i].dwEntryID == lpMPSWabFileInfo->lpMPSWabIndexEID[i+1].dwEntryID)
            {
                hr = MAPI_E_INVALID_ENTRYID;
                DebugPrintError(( TEXT("EntryID index has duplicate elements\n")));
                goto out;
            }
        }
    }

/* 
// This is painfully slowing things down
// Comment out for now
//
    // Now we walk through the index and verify that each entry is a valid entry ....
    for(i=0;i<ulcNumIndexEntries;i++)
    {
        ULONG ulOffset = lpMPSWabFileInfo->lpMPSWabIndexEID[i].ulOffset;

        MPSWab_RECORD_HEADER MPSWabRecordHeader = {0};

        if(!ReadDataFromWABFile(hMPSWabFile,
                                ulOffset,
                                (LPVOID) &MPSWabRecordHeader,
                                (DWORD) sizeof(MPSWab_RECORD_HEADER)))
           goto out;


        if(!bIsValidRecord( MPSWabRecordHeader,
                            lpMPSWabFileInfo->lpMPSWabFileHeader->dwNextEntryID,
                            ulOffset,
                            ulFileSize))
        {
            DebugPrintError(( TEXT("Index points to an invalid record\n")));
            hr = MAPI_E_INVALID_ENTRYID;
            goto out;
        }

    }
*/

    // if we're here, then the entry id index checks out ok ...

    //
    // Check out the other indexes also ... we will start backwards since we want to fix potential
    // problems in the First/Last name indexes before we do the more stringent display name case
    //
    for(j=indexMax-1;j>=indexDisplayName;j--)
    {
        if (!LoadIndex( IN  lpMPSWabFileInfo,
                        IN  j,
                        IN  hMPSWabFile) )
        {
            DebugPrintError(( TEXT("Error Loading Index!\n")));
            goto out;
        }


        ulcNumIndexEntries = lpMPSWabFileHeader->IndexData[j].ulcNumEntries;

        if(j == indexDisplayName)
        {
            if(ulcNumIndexEntries != ulcNumWABEntries)
            {
                DebugPrintError(( TEXT("Display Name index has incorrect number of elements\n")));
                goto out;
            }
        }
        else if(ulcNumIndexEntries > ulcNumWABEntries)
        {
            bError = TRUE;
            goto endloop;
        }

        if(ulcNumIndexEntries > 0)
        {
            for(i=0;i<ulcNumIndexEntries-1;i++)
            {
                // Since this is a sorted array, the indexes will be in sorted order
                // So we just compare one with the next
                if(lpMPSWabFileInfo->lpMPSWabIndexStr[i].dwEntryID == lpMPSWabFileInfo->lpMPSWabIndexStr[i+1].dwEntryID)
                {
                    DebugPrintError(( TEXT("String index has duplicate elements\n")));
                    if(j == indexDisplayName)
                        goto out;
                    else
                    {
                        bError = TRUE;
                        goto endloop;
                    }
                }
            }
        }

        // Now we walk through the index and verify that each entry is a valid entry ....
        for(i=0;i<ulcNumIndexEntries;i++)
        {
            DWORD dwEntryID = lpMPSWabFileInfo->lpMPSWabIndexStr[i].dwEntryID;
            ULONG nIndexPos;

            // All we need to do is to check that the entry id exists in the EntryID index since we
            // have already verified the entryid index
            if (!BinSearchEID(  IN  lpMPSWabFileInfo->lpMPSWabIndexEID,
                                IN  dwEntryID,
                                IN  lpMPSWabFileInfo->lpMPSWabFileHeader->IndexData[indexEntryID].ulcNumEntries, //IndexEntries,
                                OUT &nIndexPos))
            {
                DebugPrintError(( TEXT("Specified EntryID: %d doesnt exist!\n"),dwEntryID));
                hr = MAPI_E_NOT_FOUND;
                if(j == indexDisplayName)
                    goto out;
                else
                {
                    bError = TRUE;
                    goto endloop;
                }
            }

        }

endloop:
        if(bError &&
           ( (j==indexFirstName) || (j==indexLastName) ))
        {
            // if the problem is in the first/last indexes, we can reset these indexes safely
            //Assert(FALSE);
            ulcNumIndexEntries = 0;
            lpMPSWabFileHeader->IndexData[j].ulcNumEntries = 0;
            lpMPSWabFileHeader->IndexData[j].ulcNumEntries = 0;

            if(!WriteDataToWABFile( hMPSWabFile,
                                    0,
                                    (LPVOID) lpMPSWabFileInfo->lpMPSWabFileHeader,
                                    sizeof(MPSWab_FILE_HEADER)))
                goto out;

        }

    }

    hr = hrSuccess;

out:

    return hr;
}

//$$///////////////////////////////////////////////////////////////////////////////////////////
//
// CopySrcFileToDestFile - replaces contents of Dest file with contents of source file
//                  starting at the ulsrcStartOffset and ulDestStartOffset respectively
// hSrc, hDest - handles to already open files
// ulSrcStartOffset - start copying from this offset
// ulDestStartOffset - start copying to this offset
//
//////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CopySrcFileToDestFile(HANDLE hSrc, ULONG ulSrcStartOffset,
                           HANDLE hDest,ULONG ulDestStartOffset)
{
    BOOL bRet = FALSE;
    ULONG ulBytesLeftToCopy = 0;
    DWORD dwNumofBytes = 0;
    ULONG ulChunkSize = 8192; //size of block of bytes to copy from one file into the other
    LPVOID lpv = NULL;

    // copy contents of hSrc into hDest
    //
    // Set the hDest File to 0 length
    //
    if (0xFFFFFFFF == SetFilePointer (  hDest,
                                        ulDestStartOffset,
                                        NULL,
                                        FILE_BEGIN))
    {
        DebugPrintError(( TEXT("SetFilePointer Failed\n")));
        goto out;
    }

    //
    // Set end of file to the current file pointer position to discard everything
    // in the file after this point
    //
    if (!SetEndOfFile(hDest))
    {
        DebugPrintError(( TEXT("SetEndofFile Failed\n")));
        goto out;
    }


    //
    // Go to beginning of the source File
    //
    if (0xFFFFFFFF == SetFilePointer(   hSrc,
                                        ulSrcStartOffset,
                                        NULL,
                                        FILE_BEGIN))
    {
        DebugPrintError(( TEXT("SetFilePointer Failed\n")));
        goto out;
    }


    //
    // figure out how many bytes to read ...
    //
    ulBytesLeftToCopy = GetFileSize(hSrc, NULL);

    if (0xFFFFFFFF == ulBytesLeftToCopy)
    {
        DebugPrintError(( TEXT("GetFileSize Failed: %d\n"),GetLastError()));
        goto out;
    }

    if(ulSrcStartOffset > ulBytesLeftToCopy)
    {
        DebugPrintError(( TEXT("Error in File Sizes\n")));
        goto out;
    }

    ulBytesLeftToCopy -= ulSrcStartOffset;

    lpv = LocalAlloc(LMEM_ZEROINIT, ulChunkSize);

    if(!lpv)
    {
        DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n")));
        goto out;
    }


    //
    // Loop copying bytes from one file to the other
    while(ulBytesLeftToCopy > 0)
    {
        if (ulBytesLeftToCopy < ulChunkSize)
            ulChunkSize = ulBytesLeftToCopy;

        if(!ReadFile(hSrc,(LPVOID) lpv,(DWORD) ulChunkSize,&dwNumofBytes,NULL))
        {
            DebugPrintError(( TEXT("Read file failed.\n")));
            goto out;
        }

        if (dwNumofBytes != ulChunkSize)
        {
            DebugPrintError(( TEXT("Read file failed.\n")));
            goto out;
        }

        if(!WriteFile(hDest,(LPVOID) lpv,(DWORD) ulChunkSize,&dwNumofBytes,NULL))
        {
            DebugPrintError(( TEXT("Write file failed.\n")));
            goto out;
        }

        if (dwNumofBytes != ulChunkSize)
        {
            DebugPrintError(( TEXT("Write file failed.\n")));
            goto out;
        }

        ulBytesLeftToCopy -= ulChunkSize;

    }



    bRet = TRUE;

out:

    LocalFreeAndNull(&lpv);

    return bRet;
}

//$$//////////////////////////////////////////////////////////////////////////////
//
// HrResetWABFileContents - This is called as a last ditch error recovery attempt at
//  deleting the file and reseting its contents in the event that a recovery from
//  backup also failed...
//
//
 ////////////////////////////////////////////////////////////////////////////////////
HRESULT HrResetWABFileContents(LPMPSWab_FILE_INFO lpMPSWabFileInfo, HANDLE hMPSWabFile)
{
    HRESULT hr = E_FAIL;
    TCHAR szFileName[MAX_PATH];
    MPSWab_FILE_HEADER NewFileHeader;
    HANDLE hTempFile = NULL;

    DebugTrace(TEXT("#####HrResetWABFileContents Entry\n"));

    // Get a temporary file name ...
    GetWABTempFileName(szFileName);

    if (!CreateMPSWabFile(  IN  &NewFileHeader,
                            IN  szFileName,
                            IN  MAX_INITIAL_INDEX_ENTRIES,
                            IN  NAMEDPROP_STORE_SIZE))
    {
        DebugTrace(TEXT("Could Not Create File %s!\n"),szFileName);
        goto out;
    }


    hTempFile = CreateFile(     szFileName,
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                (LPSECURITY_ATTRIBUTES) NULL,
                                OPEN_EXISTING,
                                FILE_FLAG_RANDOM_ACCESS,
                                (HANDLE) NULL);

    if (hTempFile == INVALID_HANDLE_VALUE)
    {
        DebugTrace(TEXT("Could not open file.\nExiting ...\n"));
        goto out;
    }


    if(!CopySrcFileToDestFile(hTempFile, 0, hMPSWabFile, 0))
    {
        DebugTrace(TEXT("Unable to copy files\n"));
        goto out;
    }

    //
    // Reload this so we have the new fileheader info in our structures
    //
    if(!ReloadMPSWabFileInfo(
                    lpMPSWabFileInfo,
                     hMPSWabFile))
    {
        DebugTrace(TEXT("Reading file info failed.\n"));
        goto out;
    }

    hr = hrSuccess;

out:

    if(HR_FAILED(hr))
    {
        // This is totally unexpected and basically we couldnt even fix the file so tell
        // the user to restart the application - meanwhile we will delete the file
        ShowMessageBox(NULL, idsWABUnexpectedError, MB_ICONHAND | MB_OK);
        // Hope that no one comes and locks this file between the next 2 calls
        IF_WIN32(CloseHandle(hMPSWabFile);) IF_WIN16(CloseFile(hMPSWabFile);)
        hMPSWabFile = NULL;
        DeleteFile(lpMPSWabFileInfo->lpszMPSWabFileName);
    }

    if(hTempFile)
        IF_WIN32(CloseHandle(hTempFile);) IF_WIN16(CloseFile(hTempFile);)

    DebugTrace(TEXT("#####HrResetWABFileContents Exit\n"));

    return hr;

}

//$$//////////////////////////////////////////////////////////////////////////////
//
// HrRestoreFromBackup - attempts to replace WAB file contents from contents of
// Backup file
//
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrRestoreFromBackup(LPMPSWab_FILE_INFO lpMPSWabFileInfo, HANDLE hMPSWabFile)
{
    HRESULT hr = E_FAIL;
    HANDLE hBackupFile = NULL;
    TCHAR szBackupFileName[MAX_PATH];
    HCURSOR hOldCursor = SetCursor(LoadCursor(NULL,IDC_WAIT));

    // Steps to this process are:
    // - Open Backup File
    // - Reset contents of WABFile
    // - Copy Backup into WAB
    // - Close BackupFile
    // - Reload WAB Indexes

    DebugTrace(TEXT("+++++HrRestoreFromBackup Entry\n"));

    // Get the backup file name
    szBackupFileName[0]='\0';
    GetWABBackupFileName(lpMPSWabFileInfo->lpszMPSWabFileName, szBackupFileName, ARRAYSIZE(szBackupFileName));

    hBackupFile = CreateFile(   szBackupFileName,
                                GENERIC_READ,
                                FILE_SHARE_READ,
                                (LPSECURITY_ATTRIBUTES) NULL,
                                OPEN_EXISTING,
                                FILE_FLAG_SEQUENTIAL_SCAN, //FILE_FLAG_RANDOM_ACCESS,
                                (HANDLE) NULL);

    if (hBackupFile == INVALID_HANDLE_VALUE)
    {
        DebugTrace(TEXT("Could not open backup file.\nExiting ...\n"));
        hr = MAPI_E_DISK_ERROR;
        goto out;
    }

    if(!CopySrcFileToDestFile(hBackupFile, 0, hMPSWabFile, 0))
    {
        DebugTrace(TEXT("Unable to copy files\n"));
        goto out;
    }


    //
    // Reload this so we have the new fileheader info in our structures
    //
    if(!ReloadMPSWabFileInfo(
                    lpMPSWabFileInfo,
                     hMPSWabFile))
    {
        DebugTrace(TEXT("Reading file info failed.\n"));
        goto out;
    }


    hr = hrSuccess;

out:

    // close the backup file
    if(hBackupFile)
        IF_WIN32(CloseHandle(hBackupFile);) IF_WIN16(CloseFile(hBackupFile);)

    SetCursor(hOldCursor);

    DebugTrace(TEXT("+++++HrRestoreFromBackup Exit\n"));

    return hr;
}



//$$//////////////////////////////////////////////////////////////////////////////
//
// HrDoDetailedWABIntegrityCheck - does a thorough integrity check
//  This is triggered only when an index error was detected or if a write
//  transaction failed.
//
//  - We step through all the records validating them and their size data
//  - From each valid record we create the sorted entryid index
//  - From the sorted entryid index we read the records and create the
//  - display name index and reset the first last name indexes for now
//
// This function should not fail but should try to recover from errors
// If this function fails we need to break out the backup of the wab file
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrDoDetailedWABIntegrityCheck(LPMPSWab_FILE_INFO lpMPSWabFileInfo, HANDLE hMPSWabFile)
{
    HRESULT hr = E_FAIL;
    BOOL bEID = FALSE;
    ULONG ulcNumWABEntries = 0,ulcNumIndexEntries = 0;
    MPSWab_FILE_HEADER MPSWabFileHeader = {0};
    MPSWab_FILE_HEADER NewMPSWabFileHeader = {0};
    MPSWab_RECORD_HEADER MPSWabRecordHeader = {0};
    ULONG i=0,j=0;
    DWORD dwNumofBytes = 0;
    DWORD dwEntryID = 0;
    ULONG ulcPropCount = 0;
    LPSPropValue lpPropArray = NULL;


    ULONG ulRecordOffset = 0;
    ULONG ulFileSize = 0;
    ULONG ulcWABEntryCount = 0;
    ULONG nIndexPos = 0;

    MPSWab_INDEX_ENTRY_DATA_ENTRYID MPSWabIndexEID = {0};
    LPMPSWab_INDEX_ENTRY_DATA_ENTRYID lpIndexEID = NULL;

    MPSWab_INDEX_ENTRY_DATA_STRING  MPSWabIndexString = {0};
    LPMPSWab_INDEX_ENTRY_DATA_STRING  lpIndexString = NULL;

    LPVOID lpTmp = NULL;

    HCURSOR hOldCur = SetCursor(LoadCursor(NULL,IDC_WAIT));

    DebugTrace(TEXT("---DoDetailedWABIntegrityCheck Entry\n"));
    //
    // We will go with the assumption that this WAB is currently a proper wab file
    // otherwise OpenPropertyStore would have failed while opening it.
    //
    // Consequently, we should be able to read the header of the file
    // update the file header
    if(!ReadDataFromWABFile(hMPSWabFile,
                            0,
                            (LPVOID) &MPSWabFileHeader,
                            (DWORD) sizeof(MPSWab_FILE_HEADER)))
       goto out;


    // We are going to reset the file header for now so that if this process fails,
    // this file will think that there is nothing in the file rather than crashing
    NewMPSWabFileHeader = MPSWabFileHeader;
    NewMPSWabFileHeader.ulModificationCount = 0;
    NewMPSWabFileHeader.ulcNumEntries = 0;

    for(i=0;i<indexMax;i++)
    {
        if(i != indexDisplayName)// Temp Temp TBD TBD
        {
            NewMPSWabFileHeader.IndexData[i].UtilizedBlockSize = 0;
            NewMPSWabFileHeader.IndexData[i].ulcNumEntries = 0;
        }
    }

    //
    // Write this NewMPSWabFileHeader to the file
    //
    if(!WriteDataToWABFile( hMPSWabFile,
                            0,
                            (LPVOID) &NewMPSWabFileHeader,
                            sizeof(MPSWab_FILE_HEADER)))
        goto out;


    ulFileSize = GetFileSize(hMPSWabFile, NULL);

    if(ulFileSize == 0xFFFFFFFF)
    {
        DebugTrace(TEXT("Error retrieving file size: %d"),GetLastError());
        hr = MAPI_E_DISK_ERROR;
        goto out;
    }
    //
    // Allocate some working space
    //
    lpIndexEID = LocalAlloc(LMEM_ZEROINIT,
                            MPSWabFileHeader.IndexData[indexEntryID].AllocatedBlockSize);
    if(!lpIndexEID)
    {
        DebugTrace(TEXT("Error allocating memory\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }
    lpTmp = LocalAlloc(LMEM_ZEROINIT,
                       MPSWabFileHeader.IndexData[indexEntryID].AllocatedBlockSize);
    if(!lpTmp)
    {
        DebugTrace(TEXT("Error allocating memory\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }

    //
    // Now start reading the records 1 by one
    //

    ulRecordOffset = MPSWabFileHeader.IndexData[indexMax-1].ulOffset +
                     MPSWabFileHeader.IndexData[indexMax-1].AllocatedBlockSize;

    ulcWABEntryCount = 0;

    while(ulRecordOffset < ulFileSize)
    {
        if(!ReadDataFromWABFile(hMPSWabFile,
                                ulRecordOffset,
                                (LPVOID) &MPSWabRecordHeader,
                                (DWORD) sizeof(MPSWab_RECORD_HEADER)))
           goto out;

        //
        // if this is an invalid record ignore it
        //
        if( (MPSWabRecordHeader.bValidRecord != FALSE) &&
            (!bIsValidRecord(   MPSWabRecordHeader,
                                lpMPSWabFileInfo->lpMPSWabFileHeader->dwNextEntryID,
                                ulRecordOffset,
                                ulFileSize)))
        {
            DebugTrace(TEXT("Something seriously screwed up in the file\n"));
            hr = MAPI_E_CORRUPT_DATA;
            goto out;
        }
        else if(MPSWabRecordHeader.bValidRecord == FALSE)
        {
            // if this is a deleted obsolete record, ignore it
            ulRecordOffset +=   sizeof(MPSWab_RECORD_HEADER) +
                                MPSWabRecordHeader.ulPropTagArraySize +
                                MPSWabRecordHeader.ulRecordDataSize;
            continue;
        }

        //
        // We have a live one ... create an entryid index structure for this
        //
        MPSWabIndexEID.dwEntryID = MPSWabRecordHeader.dwEntryID;
        MPSWabIndexEID.ulOffset = ulRecordOffset;

        //
        // We are creating a shadow index in memory in the lpIndexEID block
        // We then write this index into the file ..
        //

        //
        // Find the position in the index where this entry will go
        //
        bEID = BinSearchEID(lpIndexEID,
                     MPSWabIndexEID.dwEntryID,
                     ulcWABEntryCount,
                     &nIndexPos);

        if(bEID)
        {
            //
            // This means that the entryid exists in the index which is messed up
            // since we dont support duplicate entryids ...
            // In this case, just ignore this entry and continue
            ulRecordOffset +=   sizeof(MPSWab_RECORD_HEADER) +
                                MPSWabRecordHeader.ulPropTagArraySize +
                                MPSWabRecordHeader.ulRecordDataSize;
            continue;
        }

        if(nIndexPos != ulcWABEntryCount)
        {
            CopyMemory( lpTmp,
                        &(lpIndexEID[nIndexPos]),
                        sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID) * (ulcWABEntryCount - nIndexPos));
        }

        CopyMemory( &(lpIndexEID[nIndexPos]),
                    &(MPSWabIndexEID),
                    sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID));

        if(nIndexPos != ulcWABEntryCount)
        {
            CopyMemory( &(lpIndexEID[nIndexPos+1]),
                        lpTmp,
                        sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID) * (ulcWABEntryCount - nIndexPos));
        }

        ulcWABEntryCount++;

        // Write this entry id index from memory to file
        //
        if(!WriteDataToWABFile( hMPSWabFile,
                                MPSWabFileHeader.IndexData[indexEntryID].ulOffset,
                                (LPVOID) lpIndexEID,
                                sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID)*ulcWABEntryCount))
            goto out;


        NewMPSWabFileHeader.ulcNumEntries = ulcWABEntryCount;
        NewMPSWabFileHeader.IndexData[indexEntryID].UtilizedBlockSize = sizeof(MPSWab_INDEX_ENTRY_DATA_ENTRYID)*ulcWABEntryCount;
        NewMPSWabFileHeader.IndexData[indexEntryID].ulcNumEntries = ulcWABEntryCount;

        //
        // Write this NewMPSWabFileHeader to the file
        //
        if(!WriteDataToWABFile( hMPSWabFile,
                                0,
                                (LPVOID) &NewMPSWabFileHeader,
                                sizeof(MPSWab_FILE_HEADER)))
            goto out;


        // go onto next record
            ulRecordOffset +=   sizeof(MPSWab_RECORD_HEADER) +
                                MPSWabRecordHeader.ulPropTagArraySize +
                                MPSWabRecordHeader.ulRecordDataSize;

    } // while loop

    // Now we have the correct entryid index,
    // we want to build the display name index from scratch ...
    LocalFreeAndNull(&lpTmp);

    lpTmp = LocalAlloc( LMEM_ZEROINIT,
                        MPSWabFileHeader.IndexData[indexDisplayName].AllocatedBlockSize);
    if(!lpTmp)
    {
        DebugTrace(TEXT("LocalAlloc failed\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }

    lpIndexString = LocalAlloc( LMEM_ZEROINIT,
                        MPSWabFileHeader.IndexData[indexDisplayName].AllocatedBlockSize);
    if(!lpIndexString)
    {
        DebugTrace(TEXT("LocalAlloc failed\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }


    //
    // Get the Entry iD index
    //
    if (!LoadIndex( IN  lpMPSWabFileInfo,
                    IN  indexEntryID,
                    IN  hMPSWabFile) )
    {
        DebugTrace(TEXT("Error Loading EntryID Index!\n"));
        goto out;
    }

    if(!ReadDataFromWABFile(hMPSWabFile,
                            0,
                            (LPVOID) lpMPSWabFileInfo->lpMPSWabFileHeader,
                            (DWORD) sizeof(MPSWab_FILE_HEADER)))
       goto out;

    for(i=0;i<ulcWABEntryCount;i++)
    {
        DWORD dwEntryID = lpIndexEID[i].dwEntryID;
        ULONG j = 0;
        LPTSTR lpszDisplayName = NULL;

        hr = ReadRecordWithoutLocking(  hMPSWabFile,
                                        lpMPSWabFileInfo,
                                        dwEntryID,
                                        &ulcPropCount,
                                        &lpPropArray);

        if (HR_FAILED(hr))
        {
            // Since there are a lot of implicit expectations in the WAB that the
            // EntryID and DisplayName indexes should have a one to one correspondence,
            // we cant really have an entry in the EntryID index and not have it in
            // the display name index. Hence an error in reading the record is serious
            // and we should either
            // - remove the corresponding entry from the EID index; or
            // - fail and restore from backup;

            // For the time being we will do (a)
            hr = MAPI_E_CORRUPT_DATA;
            goto out;
        }

        //reset hr
        hr = E_FAIL;

        for(j=0;j<ulcPropCount;j++)
        {
            if (lpPropArray[j].ulPropTag == PR_DISPLAY_NAME)
            {
                lpszDisplayName = lpPropArray[j].Value.LPSZ;
                break;
            }
        }

        if(!lpszDisplayName)
        {
            //we should remove this index from the EID index since this record
            //seems to have some errors <TBD>
            hr = MAPI_E_CORRUPT_DATA;
            goto out;
        }
        else
        {
            // We have a display name so create an index and write it to file ..

            ULONG nLen = TruncatePos(lpszDisplayName, MAX_INDEX_STRING-1);
            CopyMemory(MPSWabIndexString.szIndex,lpszDisplayName,sizeof(TCHAR)*nLen);
            MPSWabIndexString.szIndex[nLen]='\0';

            MPSWabIndexString.dwEntryID = dwEntryID;

            //
            // We are cerating a shadow index in memory in the lpIndexEID block
            // We then write this index into the file ..
            //

            //
            // Find the position in the index where this entry will go
            //
            bEID = BinSearchStr(lpIndexString,
                         MPSWabIndexString.szIndex,
                         i,
                         &nIndexPos);

            if(nIndexPos != i)
            {
                CopyMemory( lpTmp,
                            &(lpIndexString[nIndexPos]),
                            sizeof(MPSWab_INDEX_ENTRY_DATA_STRING) * (i - nIndexPos));
            }

            CopyMemory( &(lpIndexString[nIndexPos]),
                        &(MPSWabIndexString),
                        sizeof(MPSWab_INDEX_ENTRY_DATA_STRING));

            if(nIndexPos != i)
            {
                CopyMemory( &(lpIndexString[nIndexPos+1]),
                            lpTmp,
                            sizeof(MPSWab_INDEX_ENTRY_DATA_STRING) * (i - nIndexPos));
            }

            if(!WriteDataToWABFile( hMPSWabFile,
                                    MPSWabFileHeader.IndexData[indexDisplayName].ulOffset,
                                    (LPVOID) lpIndexString,
                                    sizeof(MPSWab_INDEX_ENTRY_DATA_STRING)*(i+1)))
                goto out;

            NewMPSWabFileHeader.IndexData[indexDisplayName].UtilizedBlockSize = sizeof(MPSWab_INDEX_ENTRY_DATA_STRING)*(i+1);
            NewMPSWabFileHeader.IndexData[indexDisplayName].ulcNumEntries = (i+1);

            //
            // Write this NewMPSWabFileHeader to the file
            //
            if(!WriteDataToWABFile( hMPSWabFile,
                                    0,
                                    (LPVOID) &NewMPSWabFileHeader,
                                    sizeof(MPSWab_FILE_HEADER)))
                goto out;

        }

        LocalFreePropArray(NULL, ulcPropCount,&lpPropArray);

        lpPropArray = NULL;
        ulcPropCount = 0;

    } //for loop

    // check that we have the correct number of entries in the both indexes
    //
    if (NewMPSWabFileHeader.IndexData[indexDisplayName].ulcNumEntries != NewMPSWabFileHeader.ulcNumEntries)
    {
        // If the 2 indexes dont contain the same number of elements, something failed above
        // Big problem ... cant recover
        hr = MAPI_E_CORRUPT_DATA;
        goto out;
    }

    //
    // Clear out the error tag from the File Header so we dont keep falling back
    // into this function ...
    //

    NewMPSWabFileHeader.ulFlags = WAB_CLEAR;

    //
    // Write this NewMPSWabFileHeader to the file
    //
    if(!WriteDataToWABFile( hMPSWabFile,
                            0,
                            (LPVOID) &NewMPSWabFileHeader,
                            sizeof(MPSWab_FILE_HEADER)))
        goto out;

    hr = hrSuccess;

out:
    LocalFreeAndNull(&lpTmp);

    LocalFreeAndNull(&lpIndexEID);

    LocalFreeAndNull(&lpIndexString);

    LocalFreePropArray(NULL, ulcPropCount,&lpPropArray);

    // fix the return error code
    switch(hr)
    {
    case MAPI_E_NOT_ENOUGH_MEMORY:
    case MAPI_E_DISK_ERROR:
    case S_OK:
        break;
    default:
        hr = MAPI_E_CORRUPT_DATA;
        break;
    }

    DebugTrace(TEXT("---DoDetailedWABIntegrityCheck Exit: %x\n"),hr);

    SetCursor(hOldCur);

    return hr;
}


//$$////////////////////////////////////////////////////////////////////////////////
//
// bIsValidRecord - This function looks at the Record Header components to determine if
// the record is valid or not
//
// It follows some very simple rules that can detect record header corruptions
//
// dwNextEntryID value will not be used if it is 0xFFFFFFFF
////////////////////////////////////////////////////////////////////////////////////////
BOOL bIsValidRecord(MPSWab_RECORD_HEADER rh,
                    DWORD dwNextEntryID,
                    ULONG ulRecordOffset,
                    ULONG ulFileSize)
{
    BOOL bRet = FALSE;

    // is this tagged as an invalid record (or something else)
    if ((rh.bValidRecord == FALSE) && (rh.bValidRecord != TRUE))
        goto out;

    // is this entry id value acceptable and correct
    if(dwNextEntryID != 0xFFFFFFFF)
    {
        if (rh.dwEntryID > dwNextEntryID)
            goto out;
    }

    // are the offsets in the header correct
    if (rh.ulPropTagArraySize != rh.ulcPropCount * sizeof(ULONG))
        goto out;

    if (rh.ulRecordDataOffset != rh.ulPropTagArraySize)
        goto out;

    if (rh.ulPropTagArrayOffset != 32) /***TBD - this is dependent on the struct elements***/
        goto out;

    if (ulRecordOffset + rh.ulRecordDataOffset + rh.ulRecordDataSize > ulFileSize)
        goto out;

    bRet = TRUE;

out:

    if(!bRet)
        DebugTrace(TEXT("\n@@@@@@@@@@\n@@@Invalid Record Detected\n@@@@@@@@@@\n"));

    return bRet;
}


//$$////////////////////////////////////////////////////////////////////////
//
// TagWABFileError -
//
// If an error is detected while reading a files contents, we can tag the error
// in the file so that the next access will attempt to fix it
//
////////////////////////////////////////////////////////////////////////////
BOOL TagWABFileError( LPMPSWab_FILE_HEADER lpMPSWabFileHeader,
                      HANDLE hMPSWabFile)
{
    BOOL bRet = FALSE;
    DWORD dwNumofBytes = 0;

    if(!lpMPSWabFileHeader || !hMPSWabFile)
    {
        DebugTrace(TEXT("Invalid Parameter\n"));
        goto out;
    }

    lpMPSWabFileHeader->ulFlags |= WAB_ERROR_DETECTED;

    // update the file header
    if(!WriteDataToWABFile( hMPSWabFile,
                            0,
                            (LPVOID) lpMPSWabFileHeader,
                            sizeof(MPSWab_FILE_HEADER)))
        goto out;


    bRet = TRUE;

out:
    return bRet;
}

/*
-
-   SetNextEntryID - sets the next entryid to use in a file. Called durimg migration
*
*/
void SetNextEntryID(HANDLE hPropertyStoreTemp, DWORD dwEID)
{
    MPSWab_FILE_HEADER WABHeader = {0};
    HANDLE hWABFile = NULL;
    LPMPSWab_FILE_INFO lpMPSWabFI = hPropertyStoreTemp;

    // First read the header from the existing file
    if(!HR_FAILED(OpenWABFile(lpMPSWabFI->lpszMPSWabFileName, NULL, &hWABFile)))
    {
        if(!ReadDataFromWABFile(hWABFile, 0, (LPVOID) &WABHeader, sizeof(MPSWab_FILE_HEADER)))
            goto out;

        WABHeader.dwNextEntryID = dwEID;

        if(!WriteDataToWABFile(hWABFile, 0, (LPVOID) &WABHeader, sizeof(MPSWab_FILE_HEADER)))
            goto out;
    }
out:
    if ((hWABFile != NULL) && (hWABFile != INVALID_HANDLE_VALUE))
        CloseHandle(hWABFile);

    return;
}


enum WABVersion
{
    W05 =0,
    W2,
    W3,
    W4,
};


//$$////////////////////////////////////////////////////////////////////////////
//
//  HrMigrateFromOldWABtoNew - Migrates older versions of the wab into current ones
//
//  IN hMPSWabFile
//  IN lpMPSWabFileInfo
//  hWnd .. used for displaying a "Please wait" dialog
//  returns:
//      E_FAIL or S_OK
//      MAPI_E_CORRUPT_DATA if GUID is unrecognizable
//
////////////////////////////////////////////////////////////////////////////////
HRESULT HrMigrateFromOldWABtoNew(HWND hWnd, HANDLE hMPSWabFile, LPMPSWab_FILE_INFO lpMPSWabFileInfo, GUID WabGUID)
{
    HRESULT hr = E_FAIL;
    int WABVersion;
    HANDLE hTempFile = NULL;
    MPSWab_FILE_HEADER NewFileHeader = {0};
    ULONG ulcMaxEntries = 0;
    MPSWab_FILE_HEADER_W2 MPSWabFileHeaderW2 = {0};
    MPSWab_FILE_HEADER MPSWabFileHeader = {0};
    TCHAR szFileName[MAX_PATH];
    ULONG ulAdditionalRecordOffset=0;
    LPVOID lpv = NULL;
    LPMPSWab_INDEX_ENTRY_DATA_ENTRYID lpeid = NULL;
    ULONG i = 0;
    DWORD dwOldEID = 0, dwNextEID = 0;

    HCURSOR hOldC = SetCursor(LoadCursor(NULL, IDC_WAIT));

    if (IsEqualGUID(&WabGUID,&MPSWab_OldBeta1_GUID))
    {
        WABVersion = W05;
    }
    else if (IsEqualGUID(&WabGUID,&MPSWab_W2_GUID))
    {
        WABVersion = W2;
    }
    else if (IsEqualGUID(&WabGUID,&MPSWab_GUID_V4))
    {
        WABVersion = W4;
    }

    // For WABVersion 1 and 2, we will read in the file header and 
    // save it to the new file. We will then read in the records one by 
    // one and write them to the file through the interface retaining the
    // old entryid. Version 1 and 2 did not have named prop support and also
    // had lesser numbers of indices. The individual record layour was the same as before

    // WABVersion 4 is the conversion from the ANSI store to the Unicode store ..
    // We can copy the file header and the named prop info as it is but we'll need
    // to read the records one by one, convert them to Unicode and then write it to the
    // new file so that all the indexes etc are rebuild correctly ...
    //

    // As long as all the entryids are retained, the relationship between the address
    // book data elements is the same.


    // Get a temp file name
    szFileName[0]='\0';
    GetWABTempFileName(szFileName);

    if(WABVersion <= W2)
    {
        // First read the header from the existing file
        if(!ReadDataFromWABFile(hMPSWabFile,
                                0,
                                (LPVOID) &MPSWabFileHeaderW2,
                                sizeof(MPSWab_FILE_HEADER_W2)))
            goto out;

        // Create a new Temp WAB File
        if (!CreateMPSWabFile(  IN  &NewFileHeader,
                                IN  szFileName,
                                IN  MPSWabFileHeaderW2.ulcMaxNumEntries,
                                IN  NAMEDPROP_STORE_SIZE))
        {
            DebugTrace(TEXT("Error creating new file\n"));
            goto out;
        }

        //Update header information
        NewFileHeader.ulModificationCount = MPSWabFileHeaderW2.ulModificationCount;
        dwNextEID = NewFileHeader.dwNextEntryID = MPSWabFileHeaderW2.dwNextEntryID;
        NewFileHeader.ulcNumEntries = MPSWabFileHeaderW2.ulcNumEntries;
        NewFileHeader.ulFlags = MPSWabFileHeaderW2.ulFlags;
        NewFileHeader.ulReserved1 = MPSWabFileHeaderW2.ulReserved;
    }
    else
    {
        // First read the header from the existing file
        if(!ReadDataFromWABFile(hMPSWabFile,
                                0,
                                (LPVOID) &MPSWabFileHeader,
                                sizeof(MPSWab_FILE_HEADER)))
            goto out;

        // Create a new Temp WAB File
        if (!CreateMPSWabFile(  IN  &NewFileHeader,
                                IN  szFileName,
                                IN  MPSWabFileHeader.ulcMaxNumEntries,
                                IN  MPSWabFileHeader.NamedPropData.AllocatedBlockSize))
        {
            DebugTrace(TEXT("Error creating new file\n"));
            goto out;
        }
        //Update header information
        dwOldEID = dwNextEID = NewFileHeader.dwNextEntryID = MPSWabFileHeader.dwNextEntryID;
    }

    {
        // Update the file header info from current file to the new file
        // now we open the new temp file and get a handle to it
        hTempFile = CreateFile( szFileName,
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                (LPSECURITY_ATTRIBUTES) NULL,
                                OPEN_EXISTING,
                                FILE_FLAG_RANDOM_ACCESS,
                                (HANDLE) NULL);
        if (hTempFile == INVALID_HANDLE_VALUE)
        {
            DebugTrace(TEXT("Could not open Temp file.\nExiting ...\n"));
            goto out;
        }

        if(WABVersion == W4)
        {
            DWORD dwNP = MPSWabFileHeader.NamedPropData.AllocatedBlockSize;
            LPBYTE  lpNP = LocalAlloc(LMEM_ZEROINIT, dwNP);
            LPGUID_NAMED_PROPS lpgnp = NULL;

            if(lpNP)
            {
                if(!ReadDataFromWABFile(hMPSWabFile,
                                        MPSWabFileHeader.NamedPropData.ulOffset,
                                        (LPVOID) lpNP,
                                        dwNP))
                    goto out;

                if(GetNamedPropsFromBuffer(lpNP, MPSWabFileHeader.NamedPropData.ulcNumEntries,
                                           TRUE, &lpgnp))
                {
                    LocalFreeAndNull(&lpNP);
                    if(SetNamedPropsToBuffer(   MPSWabFileHeader.NamedPropData.ulcNumEntries,
                                                lpgnp, &dwNP, &lpNP))
                    {
                        if(!WriteDataToWABFile(hTempFile, 
                                                NewFileHeader.NamedPropData.ulOffset,
                                                (LPVOID) lpNP,
                                                dwNP))
                            goto out;
    
                        LocalFreeAndNull(&lpNP);
                    }

                    NewFileHeader.NamedPropData.UtilizedBlockSize = MPSWabFileHeader.NamedPropData.UtilizedBlockSize;
                    NewFileHeader.NamedPropData.ulcNumEntries = MPSWabFileHeader.NamedPropData.ulcNumEntries;

                    if(lpgnp)
                        FreeGuidnamedprops(MPSWabFileHeader.NamedPropData.ulcNumEntries, lpgnp);
                }

            }

        }

        //Save this fileheader information
        if(!WriteDataToWABFile(hTempFile, 0, (LPVOID) &NewFileHeader, sizeof(MPSWab_FILE_HEADER)))
            goto out;

        CloseHandle(hTempFile);
        hTempFile = NULL;
    }

    {
        HANDLE hPropertyStoreTemp = NULL;
        ULONG ulOldRecordOffset = 0;
        ULONG ulWABFileSize = GetFileSize(hMPSWabFile,NULL);
        LPSPropValue lpPropArray = NULL;
        ULONG ulcValues = 0;

        hr = OpenPropertyStore( szFileName,
                                AB_OPEN_EXISTING | AB_DONT_RESTORE,
                                NULL,
                                &hPropertyStoreTemp);
        if(HR_FAILED(hr))
        {
            DebugTrace(TEXT("Could not open Temp PropStore\n"));
            goto endW05;
        }

        // Get the start of the record data from this file
        if(WABVersion <= W2)
        {
            ulOldRecordOffset = MPSWabFileHeaderW2.IndexData[indexFirstName].ulOffset +
                                MPSWabFileHeaderW2.IndexData[indexFirstName].AllocatedBlockSize;
        }
        else
        {
            ulOldRecordOffset = MPSWabFileHeader.IndexData[indexAlias].ulOffset +
                                MPSWabFileHeader.IndexData[indexAlias].AllocatedBlockSize;
        }

        // walk the file record by record
        while (ulOldRecordOffset < ulWABFileSize)
        {
            ULONG ulRecordSize = 0;
            ULONG ulObjType = 0;

            //Read the record prop array from the old WAB file
            hr = HrGetPropArrayFromFileRecord(hMPSWabFile,
                                              ulOldRecordOffset,
                                              NULL,
                                              &ulObjType,
                                              &ulRecordSize,
                                              &ulcValues,
                                              &lpPropArray);

            if(ulRecordSize == 0)
            {
                // If this happens we will get caught in a loop
                // Better to exit.
                DebugTrace(TEXT("Zero-lengthrecord found\n"));
                goto endW05;
            }

            if(!HR_FAILED(hr))
            {
                LPSBinary lpsbEID = NULL;
                ULONG i = 0, iEID = 0;
                DWORD dwEID = 0;

                // The above PropArray has a PR_ENTRY_ID that has a value
                // from the old store. We want to retain this entryid value
                for(i=0;i<ulcValues;i++)
                {
                    if(lpPropArray[i].ulPropTag == PR_ENTRYID)
                    {
                        lpsbEID = &lpPropArray[i].Value.bin;
                        iEID = i;
                        break;
                    }
                }

                // However, when we save this entry to the new store, the new
                // store does not have an index and so the entryid will be rejected and
                // a new one assigned .. so to trick the WAB into reusing the entryid, we will
                // just set the entryid in the file header as the next one to use ..
                {
                    AssertSz(lpsbEID->cb == SIZEOF_WAB_ENTRYID, TEXT("Entryid has unknown size!"));

                    CopyMemory(&dwEID, lpsbEID->lpb, sizeof(DWORD));

                    if(dwNextEID <= dwEID)
                        dwNextEID = dwEID + 1;

                    SetNextEntryID(hPropertyStoreTemp, dwEID);

                    //lpPropArray[iEID].ulPropTag = PR_NULL;
                    //lpsbEID->cb = 0;
                    //LocalFreeAndNull(&lpsbEID->lpb);
                    //lpsbEID = NULL;
                }

                // Convert any A props read in into W props
                ConvertAPropsToWCLocalAlloc(lpPropArray, ulcValues);

                // We have a valid record (otherwise ignore it)
                hr = WriteRecord(IN hPropertyStoreTemp,
									NULL,
                                    &lpsbEID,
                                    0,
                                    ulObjType,
                                    ulcValues,
                                    lpPropArray);
                if(HR_FAILED(hr))
                {
                    DebugTrace(TEXT("WriteRecord failed\n"));
                    goto endW05;
                }

                //if(lpsbEID)
                //    FreeEntryIDs(NULL, 1, lpsbEID);
            }

            ulOldRecordOffset += ulRecordSize;

            LocalFreePropArray(NULL, ulcValues, &lpPropArray);

        }

        if(hr == MAPI_E_INVALID_OBJECT)
            hr = S_OK;

        // Just in case the Next Entryid value has changed (for whatever reason)(though this shouldnt happen)
        // update the value in the file .. 
        if(dwOldEID != dwNextEID)
            SetNextEntryID(hPropertyStoreTemp, dwNextEID);

endW05:
        LocalFreePropArray(NULL, ulcValues, &lpPropArray);

        if(hPropertyStoreTemp)
            ClosePropertyStore(hPropertyStoreTemp, AB_DONT_BACKUP);

        if(!HR_FAILED(hr))
        {
            hr = E_FAIL;

            hTempFile = CreateFile( szFileName,
                                    GENERIC_READ | GENERIC_WRITE,
                                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                                    (LPSECURITY_ATTRIBUTES) NULL,
                                    OPEN_EXISTING,
                                    FILE_FLAG_RANDOM_ACCESS,
                                    (HANDLE) NULL);
            if (hTempFile == INVALID_HANDLE_VALUE)
            {
                DebugTrace(TEXT("Could not open Temp file.\nExiting ...\n"));
                goto out;
            }

            if(!CopySrcFileToDestFile(hTempFile, 0, hMPSWabFile, 0))
            {
                DebugTrace(TEXT("Could not copy file\n"));
                goto out;
            }


            hr = S_OK;
        }
    }

out:
    LocalFreeAndNull(&lpv);

    LocalFreeAndNull(&lpeid);

    if(hTempFile)
        IF_WIN32(CloseHandle(hTempFile);) IF_WIN16(CloseFile(hTempFile);)

    if(lstrlen(szFileName))
        DeleteFile(szFileName);

    if(hOldC)
        SetCursor(hOldC);

    return hr;
}

//$$////////////////////////////////////////////////////////////////////////////
//
//  HrVerifyWABVersionAndUpdate - Looks at the WAB File version and migrates
//              older versions into newer versions
//
//  IN hMPSWabFile
//  IN lpMPSWabFileInfo
//      hWnd - used for displaying some kind of dialog if necessary
//
//  BUG 16681:
//  In randomly occuring cases, the wab file seems to get totally wiped and turned
//      into 0's ... In such events, we will rename the file and try again .. we
//      indicate this condition to the OpenPropertyStore function by returning
//      MAPI_E_VERSION ..
//
//  returns:
//      E_FAIL or S_OK
//      MAPI_E_CORRUPT_DATA if GUID is unrecognizable
//
////////////////////////////////////////////////////////////////////////////////
HRESULT HrVerifyWABVersionAndUpdate(HWND hWnd,
                                    HANDLE hMPSWabFile,
                                    LPMPSWab_FILE_INFO lpMPSWabFileInfo)
{
    GUID TmpGuid = {0};
    HRESULT hr = E_FAIL;
    DWORD dwNumofBytes = 0;


    // First read the GUID from the file
    //
    if(!ReadDataFromWABFile(hMPSWabFile,
                            0,
                            (LPVOID) &TmpGuid,
                            (DWORD) sizeof(GUID)))
       goto out;


    //
    // Check if this is a Microsoft Property Store by looking for MPSWab GUID in header
    // (If this was an old file it should have been updated above)(If not, we should
    // avoid an error and go ahead and open it)
    // However if the guids dont match, we cant tell if this is a WAB file or not
    // because it could also be a valid corrupt wab file ... so when the guids dont
    // match, we will assume that the file is a corrupt wab file.
    //
    if ( (!IsEqualGUID(&TmpGuid,&MPSWab_GUID)) &&
         (!IsEqualGUID(&TmpGuid,&MPSWab_GUID_V4)) &&
         (!IsEqualGUID(&TmpGuid,&MPSWab_W2_GUID)) &&
         (!IsEqualGUID(&TmpGuid,&MPSWab_OldBeta1_GUID)) )
    {
        DebugTrace(TEXT("%s is not a Microsoft Property Store File. GUIDS don't match\n"),lpMPSWabFileInfo->lpszMPSWabFileName);
        hr = MAPI_E_INVALID_OBJECT;

        //Bug 16681:
        //Check the special condition where everything is all zero's
        {
            if (    (TmpGuid.Data1 == 0) &&
                    (TmpGuid.Data2 == 0) &&
                    (TmpGuid.Data3 == 0) &&
                    (lstrlen((LPTSTR)TmpGuid.Data4) == 0) )
            {
                hr = MAPI_E_VERSION;
            }
        }

        goto out;
    }


    //
    // If this is an older version of the file, update it to a more current
    // store format.
    //
    if (    (IsEqualGUID(&TmpGuid,&MPSWab_GUID_V4)) ||
            (IsEqualGUID(&TmpGuid,&MPSWab_OldBeta1_GUID)) ||
            (IsEqualGUID(&TmpGuid,&MPSWab_W2_GUID))   )
    {
        // We will basically scavenge the old file for records out of the
        // file (ignoring the indexes so we can avoid all errors)
        // and put them in a new prop store file which we will then
        // populate with the old records and finally use to replace the
        // current file - very similar to how CompressFile works
        DebugTrace(TEXT("Old WAB File Found. Migrating to new ...\n"));
        hr = HrMigrateFromOldWABtoNew(  hWnd, hMPSWabFile,
                                        lpMPSWabFileInfo,
                                        TmpGuid);
        if(HR_FAILED(hr))
        {
            DebugTrace(TEXT("MPSWabUpdateAndVerifyOldWAB: %x\n"));
            goto out;
        }
    }


    //reset hr
    hr = E_FAIL;

    lpMPSWabFileInfo->nCurrentlyLoadedStrIndexType = indexDisplayName;

    // Reload whatever new info we added as a result of the above.
    if(!ReloadMPSWabFileInfo(
                    lpMPSWabFileInfo,
                     hMPSWabFile))
    {
        DebugTrace(TEXT("Reading file info failed.\n"));
        goto out;
    }


    hr = S_OK;

out:
    return hr;
}



//$$////////////////////////////////////////////////////////////////////////////////
//
// HrGetBufferFromPropArray - translates a prop array into a flat buffer.
//          The format of the data in the buffer is the same as
//          the format of data in the .wab file
//
//
//  Params: 
//          ulcPropCount- # of props in array
//          lpPropArray - prop array
//          lpcbBuf       - size of returned buffer
//          lppBuf       - returned buffer
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrGetBufferFromPropArray(   ULONG ulcPropCount, 
                                    LPSPropValue lpPropArray,
                                    ULONG * lpcbBuf,
                                    LPBYTE * lppBuf)
{
    HRESULT hr = E_FAIL;
    LPULONG lpulrgPropDataSize = NULL;
    ULONG ulRecordDataSize = 0;
    LPBYTE lp = NULL;
    LPBYTE szBuf = NULL;
    ULONG   i=0,j=0,k=0;

    if(!lpcbBuf || !lppBuf)
        goto out;

    *lpcbBuf = 0;
    *lppBuf = NULL;


//    _DebugProperties(lpPropArray, ulcPropCount, TEXT("GetBufferFromPropArray"));
    //
    // We will go through the given data and determine how much space we need for each
    // property. lpulrgPropDataSize is an array of ULONGs in which we store the calculated sizes
    // temporarily.
    //
    lpulrgPropDataSize = LocalAlloc(LMEM_ZEROINIT, ulcPropCount * sizeof(ULONG));

    if (!lpulrgPropDataSize)
    {
        DebugTrace(TEXT("Error allocating memory\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }

    //
    // Get an estimate of how big the data portion of this record will be ...
    // We need this estimate to allocate a block of memory into which we will
    // write the data and then blt the block into the file
    //
    for(i=0;i<ulcPropCount;i++)
    {
        // This is the eventual data format:
        //
        //  If (SingleValued)
        //      <PropTag><DataSize><Data>
        //  else
        //      <MultiPropTag><cValues><DataSize><data>
        //  unless PropType is MV_BINARY or MV_TSTRING in which case we need a
        //  more flexible data storage
        //      <MultiPropTag><cValues><DataSize>
        //                                  <cb/strlen><Data>
        //                                  <cb/strlen><Data> ...
        //

        ulRecordDataSize += sizeof(ULONG);   // holds <PropTag>
        if ((lpPropArray[i].ulPropTag & MV_FLAG))
        {
            //
            // multi-valued
            //
            lpulrgPropDataSize[i] = SizeOfMultiPropData(lpPropArray[i]); //Data
            ulRecordDataSize += sizeof(ULONG); // holds <CValues>
        }
        else
        {
            //
            // single-valued
            //
            lpulrgPropDataSize[i] = SizeOfSinglePropData(lpPropArray[i]); //Data
        }
        ulRecordDataSize += sizeof(ULONG)   // holds <DataSize>
                            + lpulrgPropDataSize[i]; //holds <Data>
    }


    lp = LocalAlloc(LMEM_ZEROINIT, ulRecordDataSize);

    if (!lp)
    {
        DebugTrace(TEXT("Error allocating memory\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }

    szBuf = lp;

    for (i = 0; i<ulcPropCount; i++)
    {
        //
        // copy the prop tag
        //
        CopyMemory(szBuf,&lpPropArray[i].ulPropTag, sizeof(ULONG));
        szBuf += sizeof(ULONG);

        //
        // difference between handling of multivalued and singlevalued
        //
        if (!(lpPropArray[i].ulPropTag & MV_FLAG))
        {
            // Single Valued

            //
            // Record the size of data
            //
            CopyMemory(szBuf,&lpulrgPropDataSize[i], sizeof(ULONG));
            szBuf += sizeof(ULONG);

            ////DebugTrace(TEXT("%x: "),lpPropArray[i].ulPropTag);

            switch(PROP_TYPE(lpPropArray[i].ulPropTag))
            {
            case(PT_STRING8):
                //
                // Record the data ...
                //
                CopyMemory(szBuf,lpPropArray[i].Value.lpszA, lpulrgPropDataSize[i]);
                ////DebugTrace(TEXT("%s\n"),lpPropArray[i].Value.LPSZ);
                break;

            case(PT_UNICODE):
                //
                // Record the data ...
                //
                CopyMemory(szBuf,lpPropArray[i].Value.lpszW, lpulrgPropDataSize[i]);
                ////DebugTrace(TEXT("%s\n"),lpPropArray[i].Value.LPSZ);
                break;

            case(PT_CLSID):
                //
                // Record the data ...
                //
                CopyMemory(szBuf,lpPropArray[i].Value.lpguid, lpulrgPropDataSize[i]);
                ////DebugTrace(TEXT("%x-%x-%x-%x\n"),lpPropArray[i].Value.lpguid->Data1,lpPropArray[i].Value.lpguid->Data2,lpPropArray[i].Value.lpguid->Data3,lpPropArray[i].Value.lpguid->Data4);
                break;

            case(PT_BINARY):
                //
                // Record the data ...
                //
                CopyMemory(szBuf,lpPropArray[i].Value.bin.lpb, lpulrgPropDataSize[i]);
                break;

            case(PT_SHORT):
                //Record the data ...
                CopyMemory(szBuf,&lpPropArray[i].Value.i, lpulrgPropDataSize[i]);
                ////DebugTrace(TEXT("%d\n"),lpPropArray[i].Value.i);
                break;

            case(PT_LONG):
            case(PT_R4):
            case(PT_DOUBLE):
            case(PT_BOOLEAN):
            case(PT_APPTIME):
            case(PT_CURRENCY):
                //Record the data ...
                CopyMemory(szBuf,&lpPropArray[i].Value.i, lpulrgPropDataSize[i]);
                ////DebugTrace(TEXT("%d\n"),lpPropArray[i].Value.l);
                break;

            case(PT_SYSTIME):
                //Record the data ...
                CopyMemory(szBuf,&lpPropArray[i].Value.ft, lpulrgPropDataSize[i]);
                ////DebugTrace(TEXT("%d,%d\n"),lpPropArray[i].Value.ft.dwLowDateTime,lpPropArray[i].Value.ft.dwHighDateTime);
                break;

            default:
                DebugTrace(TEXT("Unknown PropTag !!\n"));
                break;


            }
            szBuf += lpulrgPropDataSize[i];

        }
        else
        {
            //multivalued

            //copy the # of multi-values
            CopyMemory(szBuf,&lpPropArray[i].Value.MVi.cValues, sizeof(ULONG));
            szBuf += sizeof(ULONG);

            //Record the size of data
            CopyMemory(szBuf,&lpulrgPropDataSize[i], sizeof(ULONG));
            szBuf += sizeof(ULONG);

            ////DebugTrace(TEXT("%x: MV_PROP\n"),lpPropArray[i].ulPropTag);


            switch(PROP_TYPE(lpPropArray[i].ulPropTag))
            {
            case(PT_MV_I2):
            case(PT_MV_LONG):
            case(PT_MV_R4):
            case(PT_MV_DOUBLE):
            case(PT_MV_CURRENCY):
            case(PT_MV_APPTIME):
            case(PT_MV_SYSTIME):
                CopyMemory(szBuf,lpPropArray[i].Value.MVft.lpft, lpulrgPropDataSize[i]);
                szBuf += lpulrgPropDataSize[i];
                break;

            case(PT_MV_I8):
                CopyMemory(szBuf,lpPropArray[i].Value.MVli.lpli, lpulrgPropDataSize[i]);
                szBuf += lpulrgPropDataSize[i];
                break;

            case(PT_MV_BINARY):
                for (j=0;j<lpPropArray[i].Value.MVbin.cValues;j++)
                {
                    CopyMemory(szBuf,&lpPropArray[i].Value.MVbin.lpbin[j].cb, sizeof(ULONG));
                    szBuf += sizeof(ULONG);
                    CopyMemory(szBuf,lpPropArray[i].Value.MVbin.lpbin[j].lpb, lpPropArray[i].Value.MVbin.lpbin[j].cb);
                    szBuf += lpPropArray[i].Value.MVbin.lpbin[j].cb;
                }
                break;

            case(PT_MV_STRING8):
                for (j=0;j<lpPropArray[i].Value.MVszA.cValues;j++)
                {
                    ULONG nLen;
                    nLen = lstrlenA(lpPropArray[i].Value.MVszA.lppszA[j])+1;
                    CopyMemory(szBuf,&nLen, sizeof(ULONG));
                    szBuf += sizeof(ULONG);
                    CopyMemory(szBuf,lpPropArray[i].Value.MVszA.lppszA[j], nLen);
                    szBuf += nLen;
                }
                break;

            case(PT_MV_UNICODE):
                for (j=0;j<lpPropArray[i].Value.MVszW.cValues;j++)
                {
                    ULONG nLen;
                    nLen = sizeof(TCHAR)*(lstrlenW(lpPropArray[i].Value.MVszW.lppszW[j])+1);
                    CopyMemory(szBuf,&nLen, sizeof(ULONG));
                    szBuf += sizeof(ULONG);
                    CopyMemory(szBuf,lpPropArray[i].Value.MVszW.lppszW[j], nLen);
                    szBuf += nLen;
                }
                break;

            case(PT_MV_CLSID):
                CopyMemory(szBuf,lpPropArray[i].Value.MVguid.lpguid, lpulrgPropDataSize[i]);
                szBuf += lpulrgPropDataSize[i];
                break;

            } //switch
        } //if
    } //for

    *lpcbBuf = ulRecordDataSize;
    *lppBuf = lp;
    
    hr = S_OK;

out:
    
    LocalFreeAndNull(&lpulrgPropDataSize);
    
    return hr;
}

//$$////////////////////////////////////////////////////////////////////////////////
//
// HrGetPropArrayFromBuffer - translates a buffer (from file or memory) into 
//          a prop array. The format of the data in the buffer is the same as
//          the format of data in the .wab file
//
//
//  Params: char * szBuf- buffer to interpret 
//          cbBuf       - sizeof buffer
//          ulcPropCount- # of props in buffer
//          lppPropArray - returned prop array
//
//          ulcNumExtraProps - an extra number of props to add to the PropArray
//                      during allocation. These blank props are later used for
//                      extending the prop array easily ..
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrGetPropArrayFromBuffer(   LPBYTE szBuf, 
                                    ULONG cbBuf, 
                                    ULONG ulcPropCount,
                                    ULONG ulcNumExtraProps,
                                    LPSPropValue * lppPropArray)
{
    HRESULT hr = S_OK;
    LPBYTE lp = NULL;
    ULONG i = 0,j=0, k=0;
    DWORD cbBufLeft = cbBuf;

    if(!lppPropArray)
    {
        hr = MAPI_E_INVALID_PARAMETER;
        goto out;
    }

    *lppPropArray = NULL;

    *lppPropArray = LocalAlloc(LMEM_ZEROINIT, (ulcPropCount+ulcNumExtraProps) * sizeof(SPropValue));

    if (!(*lppPropArray))
    {
        DebugTrace(TEXT("Error allocating memory\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }

    for(i=0;i<(ulcPropCount+ulcNumExtraProps);i++)
        (*lppPropArray)[i].ulPropTag = PR_NULL;

    lp = szBuf;

    for(i=0;i<ulcPropCount;i++)
    {
        ULONG ulDataSize = 0;
        ULONG ulcValues = 0;

        // Copy PropTag
        CopyMemory(&((*lppPropArray)[i].ulPropTag),lp,sizeof(ULONG));
        lp+=sizeof(ULONG);

        AssertSz((*lppPropArray)[i].ulPropTag, TEXT("Null PropertyTag"));

        if(ulDataSize > cbBuf)
        {
            hr = MAPI_E_CORRUPT_DATA;
            goto out;
        }

        if (((*lppPropArray)[i].ulPropTag & MV_FLAG))
        {
            //multi-valued
            //DebugTrace(TEXT("MV_PROP\n"));

            //Copy cValues
            CopyMemory(&ulcValues,lp,sizeof(ULONG));
            lp+=sizeof(ULONG);

            //Copy DataSize
            CopyMemory(&ulDataSize,lp,sizeof(ULONG));
            lp+=sizeof(ULONG);

            switch(PROP_TYPE((*lppPropArray)[i].ulPropTag))
            {
            case(PT_MV_I2):
            case(PT_MV_LONG):
            case(PT_MV_R4):
            case(PT_MV_DOUBLE):
            case(PT_MV_CURRENCY):
            case(PT_MV_APPTIME):
            case(PT_MV_SYSTIME):
            case(PT_MV_CLSID):
            case(PT_MV_I8):
                (*lppPropArray)[i].Value.MVi.lpi = LocalAlloc(LMEM_ZEROINIT,ulDataSize);
                if (!((*lppPropArray)[i].Value.MVi.lpi))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                (*lppPropArray)[i].Value.MVi.cValues = ulcValues;
                CopyMemory((*lppPropArray)[i].Value.MVi.lpi, lp, ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_MV_BINARY):
                (*lppPropArray)[i].Value.MVbin.lpbin = LocalAlloc(LMEM_ZEROINIT, ulcValues * sizeof(SBinary));
                if (!((*lppPropArray)[i].Value.MVbin.lpbin))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                (*lppPropArray)[i].Value.MVbin.cValues = ulcValues;
                for (j=0;j<ulcValues;j++)
                {
                    ULONG nLen;
                    CopyMemory(&nLen, lp, sizeof(ULONG));
                    lp += sizeof(ULONG);
                    (*lppPropArray)[i].Value.MVbin.lpbin[j].cb = nLen;
                    (*lppPropArray)[i].Value.MVbin.lpbin[j].lpb = LocalAlloc(LMEM_ZEROINIT, nLen);
                    if (!((*lppPropArray)[i].Value.MVbin.lpbin[j].lpb))
                    {
                        DebugTrace(TEXT("Error allocating memory\n"));
                        hr = MAPI_E_NOT_ENOUGH_MEMORY;
                        goto out;
                    }
                    CopyMemory((*lppPropArray)[i].Value.MVbin.lpbin[j].lpb, lp, nLen);
                    lp += nLen;
                }
                // hack: we want to upgrade the old WAB_FOLDER_PARENT_OLDPROP props to a new WAB_FOLDER_PARENT
                // This is the best place to do it and the check only happens on contacts with MV_BINARY props
                if((*lppPropArray)[i].ulPropTag == PR_WAB_FOLDER_PARENT_OLDPROP && PR_WAB_FOLDER_PARENT)
                    (*lppPropArray)[i].ulPropTag = PR_WAB_FOLDER_PARENT;
                break;

            case(PT_MV_STRING8):
                (*lppPropArray)[i].Value.MVszA.lppszA = LocalAlloc(LMEM_ZEROINIT, ulcValues * sizeof(LPSTR));
                if (!((*lppPropArray)[i].Value.MVszA.lppszA))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                for (j=0;j<ulcValues;j++)
                {
                    ULONG nLen;
                    CopyMemory(&nLen, lp, sizeof(ULONG));
                    lp += sizeof(ULONG);
                    (*lppPropArray)[i].Value.MVszA.lppszA[j] = LocalAlloc(LMEM_ZEROINIT, nLen);
                    if (!((*lppPropArray)[i].Value.MVszA.lppszA[j]))
                    {
                        DebugTrace(TEXT("Error allocating memory\n"));
                        hr = MAPI_E_NOT_ENOUGH_MEMORY;
                        goto out;
                    }
                    CopyMemory((*lppPropArray)[i].Value.MVszA.lppszA[j], lp, nLen);
                    lp += nLen;
                }
                (*lppPropArray)[i].Value.MVszA.cValues = ulcValues;
                break;

            case(PT_MV_UNICODE):
                (*lppPropArray)[i].Value.MVszW.lppszW = LocalAlloc(LMEM_ZEROINIT, ulcValues * sizeof(LPTSTR));
                if (!((*lppPropArray)[i].Value.MVszW.lppszW))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                for (j=0;j<ulcValues;j++)
                {
                    ULONG nLen;
                    CopyMemory(&nLen, lp, sizeof(ULONG));
                    lp += sizeof(ULONG);
                    (*lppPropArray)[i].Value.MVszW.lppszW[j] = LocalAlloc(LMEM_ZEROINIT, nLen);
                    if (!((*lppPropArray)[i].Value.MVszW.lppszW[j]))
                    {
                        DebugTrace(TEXT("Error allocating memory\n"));
                        hr = MAPI_E_NOT_ENOUGH_MEMORY;
                        goto out;
                    }
                    CopyMemory((*lppPropArray)[i].Value.MVszW.lppszW[j], lp, nLen);
                    lp += nLen;
                }
                (*lppPropArray)[i].Value.MVszW.cValues = ulcValues;
                break;

            default:
                DebugTrace(TEXT("Unknown Prop Type\n"));
                break;
            }
        }
        else
        {
            //Single Valued

            CopyMemory(&ulDataSize,lp,sizeof(ULONG));
            lp+=sizeof(ULONG);

            if(ulDataSize > cbBuf)
            {
                hr = MAPI_E_CORRUPT_DATA;
                goto out;
            }

            switch(PROP_TYPE((*lppPropArray)[i].ulPropTag))
            {
            case(PT_CLSID):
                (*lppPropArray)[i].Value.lpguid = (LPGUID) LocalAlloc(LMEM_ZEROINIT,ulDataSize);
                if (!((*lppPropArray)[i].Value.lpguid))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                CopyMemory((*lppPropArray)[i].Value.lpguid, lp, ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_STRING8):
                (*lppPropArray)[i].Value.lpszA = (LPSTR) LocalAlloc(LMEM_ZEROINIT,ulDataSize);
                if (!((*lppPropArray)[i].Value.lpszA))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                CopyMemory((*lppPropArray)[i].Value.lpszA, lp, ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_UNICODE):
                (*lppPropArray)[i].Value.lpszW = (LPTSTR) LocalAlloc(LMEM_ZEROINIT,ulDataSize);
                if (!((*lppPropArray)[i].Value.lpszW))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                CopyMemory((*lppPropArray)[i].Value.lpszW, lp, ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_BINARY):
                (*lppPropArray)[i].Value.bin.lpb = LocalAlloc(LMEM_ZEROINIT,ulDataSize);
                if (!((*lppPropArray)[i].Value.bin.lpb))
                {
                    DebugTrace(TEXT("Error allocating memory\n"));
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                (*lppPropArray)[i].Value.bin.cb = ulDataSize;
                CopyMemory((*lppPropArray)[i].Value.bin.lpb, lp, ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_SHORT):
                CopyMemory(&((*lppPropArray)[i].Value.i),lp,ulDataSize);
                lp += ulDataSize;
                break;


            case(PT_LONG):
                CopyMemory(&((*lppPropArray)[i].Value.l),lp,ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_R4):
                CopyMemory(&((*lppPropArray)[i].Value.flt),lp,ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_DOUBLE):
            case(PT_APPTIME):
                CopyMemory(&((*lppPropArray)[i].Value.dbl),lp,ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_BOOLEAN):
                CopyMemory(&((*lppPropArray)[i].Value.b),lp,ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_SYSTIME):
                CopyMemory(&((*lppPropArray)[i].Value.ft),lp,ulDataSize);
                lp += ulDataSize;
                break;

            case(PT_CURRENCY):
                CopyMemory(&((*lppPropArray)[i].Value.cur),lp,ulDataSize);
                lp += ulDataSize;
                break;

            default:
                DebugTrace(TEXT("Unknown Prop Type\n"));
                CopyMemory(&((*lppPropArray)[i].Value.i),lp,ulDataSize);
                lp += ulDataSize;
                break;
            }

        }
    }


    hr = S_OK;

out:

    if (FAILED(hr))
    {
        if ((*lppPropArray) && (ulcPropCount > 0))
        {
            LocalFreePropArray(NULL, ulcPropCount, lppPropArray);
            *lppPropArray = NULL;
        }
    }

//    _DebugProperties(*lppPropArray, ulcPropCount, TEXT("GetPropArrayFromBuffer"));

    return hr;

}


//$$////////////////////////////////////////////////////////////////////////////////
//
// HrGetPropArrayFromFileRecord - goes into a file, reads the record at the
//      given offset, and turns the record data into a lpPropArray
//
// IN
// hFile - the WAB file to read from
// ulOffset - the record offset within the file
//
// OUT
// ulcValues - # of props in the prop array
// lpPropArray - the prop array from the record
//
// Returns
//      E_FAIL, S_OK,
//      MAPI_E_INVALID_OBJECT
//      MAPI_E_CORRUPT_DATA
//      MAPI_E_NOT_ENOUGH_MEMORY
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrGetPropArrayFromFileRecord(HANDLE hMPSWabFile,
                                     ULONG ulRecordOffset,
                                     BOOL * lpbErrorDetected,
                                     ULONG * lpulObjType,
                                     ULONG * lpulRecordSize,
                                     ULONG * lpulcPropCount,
                                     LPSPropValue * lppPropArray)
{
    HRESULT hr = S_OK;
    MPSWab_RECORD_HEADER MPSWabRecordHeader = {0};
    DWORD dwNumofBytes = 0;
    LPBYTE szBuf = NULL;
    LPBYTE lp = NULL;
    ULONG i = 0,j=0, k=0;
    ULONG nIndexPos = 0;
    BOOL bErrorDetected = FALSE;

    if(!ReadDataFromWABFile(hMPSWabFile,
                            ulRecordOffset,
                            (LPVOID) &MPSWabRecordHeader,
                            (DWORD) sizeof(MPSWab_RECORD_HEADER)))
       goto out;


    // Its important that we get the record size first because a
    // calling client may depend on the size to move to the
    // next record if they want to skip invalid ones.
    if(lpulRecordSize)
    {
        *lpulRecordSize = sizeof(MPSWab_RECORD_HEADER) +
                            MPSWabRecordHeader.ulPropTagArraySize +
                            MPSWabRecordHeader.ulRecordDataSize;
    }

    if(lpulObjType)
    {
        *lpulObjType = MPSWabRecordHeader.ulObjType;
    }

    if(!bIsValidRecord( MPSWabRecordHeader,
                        0xFFFFFFFF,
                        ulRecordOffset,
                        GetFileSize(hMPSWabFile,NULL)))
    {
        //this should never happen but who knows
        DebugTrace(TEXT("Error: Obtained an invalid record ...\n"));
        hr = MAPI_E_INVALID_OBJECT;
        goto out;
    }

    szBuf = LocalAlloc(LMEM_ZEROINIT, MPSWabRecordHeader.ulRecordDataSize);
    if (!szBuf)
    {
        DebugTrace(TEXT("Error allocating memory\n"));
        hr = MAPI_E_NOT_ENOUGH_MEMORY;
        goto out;
    }


    // Set File Pointer to beginning of Data Section
    if (0xFFFFFFFF == SetFilePointer (  hMPSWabFile,
                                        MPSWabRecordHeader.ulPropTagArraySize,
                                        NULL,
                                        FILE_CURRENT))
    {
        DebugTrace(TEXT("SetFilePointer Failed\n"));
        goto out;
    }

    //Read in the data
    // Read record header
    if(!ReadFile(   hMPSWabFile,
                    (LPVOID) szBuf,
                    (DWORD) MPSWabRecordHeader.ulRecordDataSize,
                    &dwNumofBytes,
                    NULL))
    {
        DebugTrace(TEXT("Reading Record Header failed.\n"));
        goto out;
    }

    if(HR_FAILED(hr = HrGetPropArrayFromBuffer( szBuf, 
                                                MPSWabRecordHeader.ulRecordDataSize, 
                                                MPSWabRecordHeader.ulcPropCount, 0,
                                                lppPropArray) ))
    {
        goto out;
    }

    *lpulcPropCount = MPSWabRecordHeader.ulcPropCount;

    hr = S_OK;

out:

    // if this is a container, make sure its object type is correct
    if(!HR_FAILED(hr) && MPSWabRecordHeader.ulObjType == RECORD_CONTAINER)
        SetContainerObjectType(*lpulcPropCount, *lppPropArray, FALSE);

    if(hr == MAPI_E_CORRUPT_DATA)
        bErrorDetected = TRUE;

    if (lpbErrorDetected)
        *lpbErrorDetected = bErrorDetected;

    LocalFreeAndNull(&szBuf);

    return hr;
}


//$$////////////////////////////////////////////////////////////////////////////
//
// Space saver function for writing data to the file
//
////////////////////////////////////////////////////////////////////////////////
BOOL WriteDataToWABFile(HANDLE hMPSWabFile,
                           ULONG ulOffset,
                           LPVOID lpData,
                           ULONG ulDataSize)
{
    DWORD dwNumofBytes = 0;

    if (0xFFFFFFFF != SetFilePointer (  hMPSWabFile,
                                        ulOffset,
                                        NULL,
                                        FILE_BEGIN))
    {
         return WriteFile(  hMPSWabFile,
                        lpData,
                        (DWORD) ulDataSize,
                        &dwNumofBytes,
                        NULL);
    }

    return FALSE;
}

//$$////////////////////////////////////////////////////////////////////////////////
//
// Space saver function for reading data from the file
//
////////////////////////////////////////////////////////////////////////////////////
BOOL ReadDataFromWABFile(HANDLE hMPSWabFile,
                           ULONG ulOffset,
                           LPVOID lpData,
                           ULONG ulDataSize)
{
    DWORD dwNumofBytes = 0;

    if (0xFFFFFFFF != SetFilePointer (  hMPSWabFile,
                                        ulOffset,
                                        NULL,
                                        FILE_BEGIN))
    {
        return ReadFile(hMPSWabFile,
                        lpData,
                        (DWORD) ulDataSize,
                        &dwNumofBytes,
                        NULL);
    }

    return FALSE;
}


//$$****************************************************************************
//
// FreeGuidnamedprops - frees a GUID_NAMED_PROPS array
//
// ulcGUIDCount - number of elements in the lpgnp array
// lpgnp - arry of GUID_NAMED_PROPS
//****************************************************************************//
void FreeGuidnamedprops(ULONG ulcGUIDCount,
                        LPGUID_NAMED_PROPS lpgnp)
{
    ULONG i=0,j=0;

    if(lpgnp)
    {
//        for(i=ulcGUIDCount;i>0;--i)
        for (i = 0; i < ulcGUIDCount; i++)
        {
            if(lpgnp[i].lpnm)
            {
//                for(j=lpgnp[i].cValues;j>0;--j)
                for (j = 0; j < lpgnp[i].cValues; j++)
                {
                    LocalFreeAndNull(&lpgnp[i].lpnm[j].lpsz);
                }
                LocalFreeAndNull(&lpgnp[i].lpnm);
            }
            LocalFreeAndNull(&lpgnp[i].lpGUID);
        }
        LocalFreeAndNull(&lpgnp);
    }
    return;
}


//$$////////////////////////////////////////////////////////////////////////////////////////////////
//
// OpenWABFile - Opens the WAB file. If file is missing, restores from backup. If backup is missing
//                  creates a new file
//
//  hWndParent - parent for opening message boxes - no message boxesif null
//  lphMPSWabFile - returned file pointer
//
////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT OpenWABFile(LPTSTR lpszFileName, HWND hWndParent, HANDLE * lphMPSWabFile)
{
    HANDLE hMPSWabFile = NULL;
    TCHAR szBackupFileName[MAX_PATH];
    WIN32_FIND_DATA wfd = {0};
    HANDLE hff = NULL;
    HRESULT hr = E_FAIL;
    DWORD dwErr = 0;

    hMPSWabFile = CreateFile(   lpszFileName,
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                (LPSECURITY_ATTRIBUTES) NULL,
                                OPEN_EXISTING,
                                FILE_FLAG_RANDOM_ACCESS,
                                (HANDLE) NULL);

    if(hMPSWabFile != INVALID_HANDLE_VALUE)
    {
        hr = S_OK;
        goto out;
    }

    // Something happened find out what..
    dwErr = GetLastError();

    if(dwErr == ERROR_ACCESS_DENIED)
    {
        hr = MAPI_E_NO_ACCESS;
        goto out;
    }

    if(dwErr != ERROR_FILE_NOT_FOUND)
    {
        hr = E_FAIL;
        goto out;
    }

    // Get the backup file name
    szBackupFileName[0]='\0';
    GetWABBackupFileName(lpszFileName, szBackupFileName, ARRAYSIZE(szBackupFileName));

    hff = FindFirstFile(szBackupFileName,&wfd);

    if(hff != INVALID_HANDLE_VALUE)
    {
        // we found the backup file
        // copy it into the wab file name
        CopyFile(szBackupFileName, lpszFileName, FALSE);

        hMPSWabFile = CreateFile(   lpszFileName,
                                    GENERIC_READ | GENERIC_WRITE,
                                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                                    (LPSECURITY_ATTRIBUTES) NULL,
                                    OPEN_EXISTING,
                                    FILE_FLAG_RANDOM_ACCESS,
                                    (HANDLE) NULL);

        if(hMPSWabFile != INVALID_HANDLE_VALUE)
        {
            hr = S_OK;
            goto out;
        }

    }

    // if we're still here .. nothing worked .. so create a new file
    {
        MPSWab_FILE_HEADER MPSWabFileHeader;

        if(CreateMPSWabFile(IN &MPSWabFileHeader,
                            lpszFileName,
                            MAX_INITIAL_INDEX_ENTRIES,
                            NAMEDPROP_STORE_SIZE))
        {
            hMPSWabFile = CreateFile(   lpszFileName,
                                        GENERIC_READ | GENERIC_WRITE,
                                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                                        (LPSECURITY_ATTRIBUTES) NULL,
                                        OPEN_EXISTING,
                                        FILE_FLAG_RANDOM_ACCESS,
                                        (HANDLE) NULL);

            if(hMPSWabFile != INVALID_HANDLE_VALUE)
                hr = S_OK;
        }
    }


out:
    *lphMPSWabFile = hMPSWabFile;

    if(hff)
        FindClose(hff);

    return hr;
}

//$$/////////////////////////////////////////////////////////////////////////////////
//
//
// nCountSubStrings - counts space-delimted substrings in a given string
//
//
/////////////////////////////////////////////////////////////////////////////////////
int nCountSubStrings(LPTSTR lpszSearchStr)
{
    int nSubStr = 0;
    LPTSTR lpTemp = lpszSearchStr;
    LPTSTR lpStart = lpszSearchStr;

    if (!lpszSearchStr)
        goto out;

    if (!lstrlen(lpszSearchStr))
        goto out;

    TrimSpaces(lpszSearchStr);

    // Count the spaces
    while(*lpTemp)
    {
        if (IsSpace(lpTemp) &&
          ! IsSpace(CharNext(lpTemp))) {
            nSubStr++;
        }
        lpTemp = CharNext(lpTemp);
    }

    // Number of substrings is 1 more than number of spaces
    nSubStr++;

out:
    return nSubStr;
}

#define DONTFIND 0
#define DOFIND   1
#define NOTFOUND 0
#define FOUND    1

extern BOOL SubstringSearchEx(LPTSTR pszTarget, LPTSTR pszSearch, LCID lcid);
extern int my_atoi(LPTSTR lpsz);
//$$////////////////////////////////////////////////////////////////////////////////
//
// HrDoLocalWABSearch
//
//
//
//
//
////////////////////////////////////////////////////////////////////////////////////
HRESULT HrDoLocalWABSearch( IN  HANDLE hPropertyStore,
                            IN  LPSBinary lpsbCont, //container entryid for Outlook stores
                            IN  LDAP_SEARCH_PARAMS LDAPsp,
                            OUT LPULONG lpulFoundCount,
                            OUT LPSBinary * lprgsbEntryIDs )
{

    int bFindName = DONTFIND;
    int bFindEmail = DONTFIND;
    int bFindAddress = DONTFIND;
    int bFindPhone = DONTFIND;
    int bFindOther = DONTFIND;

    LCID lcid = 0;
    int nUseLCID = 0;
    TCHAR szUseLCID[2];

    int bFoundName = NOTFOUND;
    int bFoundEmail = NOTFOUND;
    int bFoundAddress = NOTFOUND;
    int bFoundPhone = NOTFOUND;
    int bFoundOther = NOTFOUND;

    ULONG nSubStr[ldspMAX];
    LPTSTR * lppszSubStr[ldspMAX];

    HRESULT hr = E_FAIL;
    SPropertyRestriction PropRes;
    ULONG   ulPropCount = 0;
    ULONG   ulEIDCount = 0;
    LPSBinary rgsbEntryIDs = NULL;

    LPSPropValue lpPropArray = NULL;
    ULONG ulcPropCount = 0;

    ULONG i,j,k;
    ULONG ulFoundIndex = 0;
    BOOL bFileLocked = FALSE;
    BOOL bFound = FALSE;

    LPMPSWab_FILE_INFO lpMPSWabFileInfo = (LPMPSWab_FILE_INFO) hPropertyStore;
    HANDLE hMPSWabFile = NULL;

    LPPTGDATA lpPTGData=GetThreadStoragePointer();
    ULONG cchSize;

    if(!lpulFoundCount || !lprgsbEntryIDs)
        goto out;

    *lpulFoundCount = 0;
    *lprgsbEntryIDs = NULL;

    LoadString(hinstMapiX, idsUseLCID, szUseLCID, CharSizeOf(szUseLCID));
    nUseLCID = my_atoi(szUseLCID);
    if(nUseLCID)
        lcid = GetUserDefaultLCID();

    if(lstrlen(LDAPsp.szData[ldspDisplayName]))
        bFindName = DOFIND;
    if(lstrlen(LDAPsp.szData[ldspEmail]))
        bFindEmail = DOFIND;
    if(lstrlen(LDAPsp.szData[ldspAddress]))
        bFindAddress = DOFIND;
    if(lstrlen(LDAPsp.szData[ldspPhone]))
        bFindPhone = DOFIND;
    if(lstrlen(LDAPsp.szData[ldspOther]))
        bFindOther = DOFIND;

    if (bFindName +bFindEmail +bFindPhone +bFindAddress +bFindOther == 0)
        goto out;

    for(i=0;i<ldspMAX;i++)
    {

        nSubStr[i] = (ULONG) nCountSubStrings(LDAPsp.szData[i]);

        if(!nSubStr[i])
        {
            lppszSubStr[i] = NULL;
            continue;
        }

        lppszSubStr[i] = LocalAlloc(LMEM_ZEROINIT, sizeof(LPTSTR) * nSubStr[i]);
        if(!lppszSubStr[i])
        {
            hr = MAPI_E_NOT_ENOUGH_MEMORY;
            goto out;
        }

        {
            // Fill in the substrings
            ULONG nIndex = 0;
            LPTSTR lpTemp = NULL;
            LPTSTR lpStart = NULL;
            TCHAR szBuf[MAX_UI_STR];

            StrCpyN(szBuf, LDAPsp.szData[i], ARRAYSIZE(szBuf));
            lpTemp = szBuf;
            lpStart = szBuf;

            // Bug 2558 - filter out commas from display name
            if(i == ldspDisplayName)
            {
                while(lpTemp && *lpTemp)
                {
                    if(*lpTemp == ',')
                        *lpTemp = ' ';
                    lpTemp++;
                }
                lpTemp = szBuf;
            }

            while(*lpTemp)
            {
                if (IsSpace(lpTemp) &&
                  ! IsSpace(CharNext(lpTemp))) {
                    LPTSTR lpNextString = CharNext(lpTemp);
                    *lpTemp = '\0';
                    lpTemp = lpNextString;

                    cchSize = lstrlen(lpStart)+1;
                    lppszSubStr[i][nIndex] = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize);
                    if(!lppszSubStr[i][nIndex])
                    {
                        hr = MAPI_E_NOT_ENOUGH_MEMORY;
                        goto out;
                    }
                    StrCpyN(lppszSubStr[i][nIndex], lpStart, cchSize);
                    lpStart = lpTemp;
                    nIndex++;
                }
                else
                    lpTemp = CharNext(lpTemp);
            }

            if(nIndex==nSubStr[i]-1)
            {
                //we're off by one
                cchSize = lstrlen(lpStart)+1;
                lppszSubStr[i][nIndex] = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize);
                if(!lppszSubStr[i][nIndex])
                {
                    hr = MAPI_E_NOT_ENOUGH_MEMORY;
                    goto out;
                }
                StrCpyN(lppszSubStr[i][nIndex], lpStart, cchSize);
            }

            for(j=0;j<nSubStr[i];j++)
                TrimSpaces(lppszSubStr[i][j]);

        }
    } // for i ...


    if(!pt_bIsWABOpenExSession)
    {
        // Lock the file
        if(!LockFileAccess(lpMPSWabFileInfo))
        {
            DebugTrace(TEXT("LockFileAccess Failed\n"));
            hr = MAPI_E_NO_ACCESS;
            goto out;
        }
        else
        {
            bFileLocked = TRUE;
        }
    }

    // Get an index of all entries in the WAB
    PropRes.ulPropTag = PR_DISPLAY_NAME;
    PropRes.relop = RELOP_EQ;
    PropRes.lpProp = NULL;


    hr = FindRecords(   IN  hPropertyStore,
						IN  lpsbCont,
                        IN  AB_MATCH_PROP_ONLY,
                        FALSE,
                        &PropRes,
                        &ulEIDCount,
                        &rgsbEntryIDs);

    ulFoundIndex = 0;

    if(!pt_bIsWABOpenExSession)
    {
        hr = OpenWABFile(lpMPSWabFileInfo->lpszMPSWabFileName, NULL, &hMPSWabFile);

        if (    (hMPSWabFile == INVALID_HANDLE_VALUE) ||
                HR_FAILED(hr))
        {
            DebugTrace(TEXT("Could not open file.\nExiting ...\n"));
            goto out;
        }
    }

    for(i=0;i<ulEIDCount;i++)
    {
        if(!pt_bIsWABOpenExSession)
        {
            DWORD dwEID = 0;
            CopyMemory(&dwEID, rgsbEntryIDs[i].lpb, rgsbEntryIDs[i].cb);
            hr = ReadRecordWithoutLocking(
                            hMPSWabFile,
                            lpMPSWabFileInfo,
                            dwEID,
                            &ulcPropCount,
                            &lpPropArray);
        }
        else
        {
            hr = ReadRecord(hPropertyStore,
                            &rgsbEntryIDs[i],
                            0,
                            &ulcPropCount,
                            &lpPropArray);
        }

        if(HR_FAILED(hr))
            goto endloop;

        bFoundName = NOTFOUND;
        bFoundEmail = NOTFOUND;
        bFoundAddress = NOTFOUND;
        bFoundPhone = NOTFOUND;
        bFoundOther = NOTFOUND;

        for(j=0;j<ulcPropCount;j++)
        {
            switch(lpPropArray[j].ulPropTag)
            {
            case PR_DISPLAY_NAME:
            case PR_GIVEN_NAME:
            case PR_SURNAME:
            case PR_NICKNAME:
            case PR_MIDDLE_NAME:
            case PR_COMPANY_NAME:
                if(bFindName == DONTFIND)
                    continue;
                if(bFoundName == FOUND)
                    continue;
                bFound = TRUE;
                for(k=0;k<nSubStr[ldspDisplayName];k++)
                {
                    if(!SubstringSearchEx(lpPropArray[j].Value.LPSZ, lppszSubStr[ldspDisplayName][k],lcid))
                    {
                        bFound = FALSE;
                        break;
                    }
                }
                if(bFound)
                {
                    bFoundName = FOUND;
                    continue;
                }
                break;

            case PR_EMAIL_ADDRESS:
            case PR_ADDRTYPE:
                if(bFindEmail == DONTFIND)
                    continue;
                if(bFoundEmail == FOUND)
                    continue;
                bFound = TRUE;
                for(k=0;k<nSubStr[ldspEmail];k++)
                {
                    if(!SubstringSearchEx(lpPropArray[j].Value.LPSZ, lppszSubStr[ldspEmail][k],lcid))
                    {
                        bFound = FALSE;
                        break;
                    }
                }
                if(bFound)
                {
                    bFoundEmail = FOUND;
                    continue;
                }
                break;

            case PR_HOME_ADDRESS_STREET:
            case PR_HOME_ADDRESS_CITY:
            case PR_HOME_ADDRESS_POSTAL_CODE:
            case PR_HOME_ADDRESS_STATE_OR_PROVINCE:
            case PR_HOME_ADDRESS_COUNTRY:
            case PR_BUSINESS_ADDRESS_STREET:
            case PR_BUSINESS_ADDRESS_CITY:
            case PR_BUSINESS_ADDRESS_POSTAL_CODE:
            case PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE:
            case PR_BUSINESS_ADDRESS_COUNTRY:
                if(bFindAddress == DONTFIND)
                    continue;
                if(bFoundAddress == FOUND)
                    continue;
                bFound = TRUE;
                for(k=0;k<nSubStr[ldspAddress];k++)
                {
                    if(!SubstringSearchEx(lpPropArray[j].Value.LPSZ, lppszSubStr[ldspAddress][k],lcid))
                    {
                        bFound = FALSE;
                        break;
                    }
                }
                if(bFound)
                {
                    bFoundAddress = FOUND;
                    continue;
                }
                break;

            case PR_HOME_TELEPHONE_NUMBER:
            case PR_HOME_FAX_NUMBER:
            case PR_CELLULAR_TELEPHONE_NUMBER:
            case PR_BUSINESS_TELEPHONE_NUMBER:
            case PR_BUSINESS_FAX_NUMBER:
            case PR_PAGER_TELEPHONE_NUMBER:
                if(bFindPhone == DONTFIND)
                    continue;
                if(bFoundPhone == FOUND)
                    continue;
                bFound = TRUE;
                for(k=0;k<nSubStr[ldspPhone];k++)
                {
                    if(!SubstringSearchEx(lpPropArray[j].Value.LPSZ, lppszSubStr[ldspPhone][k],lcid))
                    {
                        bFound = FALSE;
                        break;
                    }
                }
                if(bFound)
                {
                    bFoundPhone = FOUND;
                    continue;
                }
                break;
            case PR_TITLE:
            case PR_DEPARTMENT_NAME:
            case PR_OFFICE_LOCATION:
            case PR_COMMENT:
            case PR_BUSINESS_HOME_PAGE:
            case PR_PERSONAL_HOME_PAGE:
                if(bFindOther == DONTFIND)
                    continue;
                if(bFoundOther == FOUND)
                    continue;
                bFound = TRUE;
                for(k=0;k<nSubStr[ldspOther];k++)
                {
                    if(!SubstringSearchEx(lpPropArray[j].Value.LPSZ, lppszSubStr[ldspOther][k],lcid))
                    {
                        bFound = FALSE;
                        break;
                    }
                }
                if(bFound)
                {
                    bFoundOther = FOUND;
                    continue;
                }
                break;
            } //switch
        }// for j

        if ((bFindName +bFindEmail +bFindPhone +bFindAddress +bFindOther) !=
            (bFoundName+bFoundEmail+bFoundPhone+bFoundAddress+bFoundOther))
            goto endloop;

        // doublecheck that we didnt get a container entry here
        for(j=0;j<ulcPropCount;j++)
        {
            if( lpPropArray[j].ulPropTag == PR_OBJECT_TYPE)
            {
                if(lpPropArray[j].Value.l == MAPI_ABCONT)
                    goto endloop;
                break;
            }
        }

        // match!
        CopyMemory(rgsbEntryIDs[ulFoundIndex].lpb, rgsbEntryIDs[i].lpb, rgsbEntryIDs[i].cb);
        ulFoundIndex++;

endloop:
        if(ulcPropCount && lpPropArray)
        {
            ReadRecordFreePropArray(hPropertyStore, ulcPropCount, &lpPropArray);
            lpPropArray = NULL;
        }
    } // for i


    if(ulFoundIndex)
    {
        *lpulFoundCount = ulFoundIndex;
        *lprgsbEntryIDs = rgsbEntryIDs;
    }

    hr = S_OK;

out:

    ReadRecordFreePropArray(hPropertyStore, ulcPropCount, &lpPropArray);

    for(i=0;i<ldspMAX;i++)
    {
        if(lppszSubStr[i])
        {
            for(j=0;j<nSubStr[i];j++)
                LocalFree(lppszSubStr[i][j]);
            LocalFree(lppszSubStr[i]);
        }
    }

    if(!*lpulFoundCount || !*lprgsbEntryIDs)
    {
        if(rgsbEntryIDs)
            FreeEntryIDs(hPropertyStore, ulEIDCount, rgsbEntryIDs);
    }
    else if(ulFoundIndex && (ulFoundIndex < ulEIDCount) && !pt_bIsWABOpenExSession)
    {
        // We will leak anything we are not using here so clear up before exiting
        // Do this only if this is a WAB session because then that memory was LocalAlloced
        // and can be partially freed up here
        for(i=ulFoundIndex;i<ulEIDCount;i++)
        {
            if(rgsbEntryIDs[i].lpb)
                LocalFree(rgsbEntryIDs[i].lpb);
        }
    }

    if(!pt_bIsWABOpenExSession)
    {
        if(hMPSWabFile)
        IF_WIN32(CloseHandle(hMPSWabFile);) IF_WIN16(CloseFile(hMPSWabFile);)
    }

    if(!pt_bIsWABOpenExSession && bFileLocked)
        UnLockFileAccess(lpMPSWabFileInfo);

    return hr;
}



//$$
//
// Determines if the disk on which WAB resides has free space or not..
// Free space is defined as space being equal too or more than the size
// of the current WAB file. If the available space is less than the size
// of the WAB file, this function will return false ...
//
BOOL WABHasFreeDiskSpace(LPTSTR lpszName, HANDLE hFile)
{
    TCHAR szBuf[MAX_PATH];
    DWORD dwWABSize=0;
    DWORDLONG dwDiskFreeSpace = 0;
    DWORD SectorsPerCluster=0;
    DWORD BytesPerSector=0;
    DWORD NumberOfFreeClusters=0;
    DWORD TotalNumberOfClusters=0;
    BOOL bRet = TRUE;

    szBuf[0]='\0';
    StrCpyN(szBuf, lpszName, ARRAYSIZE(szBuf));
    TrimSpaces(szBuf);
    if(lstrlen(szBuf))
    {
        dwWABSize = GetFileSize(hFile, NULL);

        {
            LPTSTR lpszFirst = szBuf;
            LPTSTR lpszSecond = CharNext(szBuf);
            LPTSTR lpRoot = NULL;
            LPTSTR lpTemp;
            ULONG ulCount = 0;

            if(*lpszFirst == '\\' && *lpszSecond == '\\')
            {
                // This looks like a network share ..
                // There doesnt seem to be any way to determine disk space
                // on a network share .. so we will try to copy the wab
                // file into a tmp file and delete the tmp file. If this operation
                // succeeds we have plenty of disk space. If it fails we dont have any
                // space
                TCHAR szTmp[MAX_PATH];
                StrCpyN(szTmp, szBuf, ARRAYSIZE(szTmp));

                // our temp file name is the wab file name with a - instead of the last char
                lpTemp = szTmp;
                while(*lpTemp)
                    lpTemp = CharNext(lpTemp);
                lpTemp = CharPrev(szTmp, lpTemp);
                if(*lpTemp != '-')
                    *lpTemp = '-';
                else
                    *lpTemp = '_';

                if(!CopyFile(szBuf, szTmp, FALSE))
                {
                    bRet = FALSE;
                }
                else
                    DeleteFile(szTmp);
                /***
                lpTemp = CharNext(lpszSecond);
                while(*lpTemp)
                {
                    if(*lpTemp == '\\')
                    {
                        ulCount++;
                        if (ulCount == 1)
                        {
                            //lpTemp=CharNext(lpTemp);
                            *lpTemp = '\0';
                            break;
                        }
                    }
                    lpTemp = CharNext(lpTemp);
                }
                ***/
            }
            else
            {
                if(*lpszSecond == ':')
                {
                    lpTemp = CharNext(lpszSecond);
                    if(*lpTemp != '\\')
                        *lpTemp = '\0';
                    else
                    {
                        lpTemp = CharNext(lpTemp);
                        *lpTemp = '\0';
                    }
                }
                else
                {
                    *lpszFirst = '\0';
                }
                if(lstrlen(szBuf))
                    lpRoot = szBuf;
                if( GetDiskFreeSpace(lpRoot,
                                    &SectorsPerCluster,	// address of sectors per cluster
                                    &BytesPerSector,	// address of bytes per sector
                                    &NumberOfFreeClusters,	// address of number of free clusters
                                    &TotalNumberOfClusters 	// address of total number of clusters
                                    ) )
                {
                    dwDiskFreeSpace = BytesPerSector * SectorsPerCluster * NumberOfFreeClusters;

                    if(dwDiskFreeSpace < ((DWORDLONG) dwWABSize) )
                        bRet = FALSE;
                }
                else
                {
                    DebugTrace(TEXT("GetDiskFreeSpace failed: %d\n"),GetLastError());
                }
            }
        }

    }

    return bRet;
}