Tricks of the Windows Gam…ming Gurus (2nd Edition)/Disc2.iso/msdn_vcb/samples/vc98/sdk/dbmsg/mapi/flatfile.ab/abctbl1.c

C/C++ Source or Header | 1996-04-11 | 26.5 KB | 923 lines

/***********************************************************************
 *
 *  ABCTBL1.C
 *
 *  Contents Table
 *
 *  The contents table associated with this provider.  It's file based.
 *  The format of the .SAB file is in ABP.H.
 *
 *  This implementation of IMAPITable is retrieved by calling the
 *  GetContentsTable() method of the sample ABP's single directory (see
 *  abcont.c).
 *
 *  There are a few interesting features in this implementation.  First
 *  it's implemented on a flat file (.SAB).  Second, it actually supports
 *  an implementation of ANR (Ambiguous Name Resolution).  And lastly, it
 *  supports FindRow (limited to prefix searching on display names).
 *
 *  This is the minimum set of restrictions that your provider MUST support.
 *  It MUST have an ANR implementation and support prefix (downward) searching
 *  on whatever your table is sorted on (in this case PR_DISPLAY_NAME).
 *
 *  The browsing of a flat file is done a record at a time.  It's never
 *  completely read into memory.  It only reads records from the file when
 *  it absolutely has to (like in QueryRows).  The advantage to this is
 *  a low memory footprint and the ability to browse rather large files
 *  with decent performance.
 */
/*
 *  ANR is also supported in this implementation.  In the code will often
 *  be 'if' statements making two different code paths between the restricted
 *  and unrestricted version.  The restrictions rely on a couple of
 *  bit arrays.  Each bit corresponds (in order) to the records in the .SAB
 *  file.  One bit array, rgChecked, says whether or not a record in the
 *  .SAB file has actually been compared to the restriction.  It's initially
 *  set to all 0s - which means that none of the records have been checked.
 *  The second bit array, rgMatched, says whether or not the particular
 *  record matches the current restriction.  This array is initialized to all
 *  1s - which says that all the records in the .SAB file match the current
 *  restriction.  The reason for this is for the fraction returned in
 *  QueryPosition--By assuming that all the rows match and only updating
 *  the array when something doesn't match, the fraction returned in
 *  QueryPosition will get larger and has the effect of making the thumb-bar
 *  on a listbox implemented on top of this table to scroll down as you go
 *  down the list.
 *
 *  As a row is about to be read it is checked to see if it's been compared
 *  to the current restriction.  If it has then to determine whether or not
 *  to actually read the record and build the row we just look at the matched
 *  bit array.  If it doesn't match we go on to the next record and check
 *  again.  If it does match we read the record and build the row.
 *
 *  Only if it hasn't been checked do we actually go and read the row and
 *  compare it to the current restriction, setting the rgChecked and
 *  rgMatched bits accordingly.
 *
 *  In this implementation the ANR comparison rules are as follows:
 *  (See FNameMatch for the actual code to do this)
 *
 *    A 'word' is defined as any substring separated by separators.
 *    The separators are defined as ',', ' ', and '-'.
 *    A restriction is said to match a display name iff all the words
 *    in the restriction are all prefixes of words in the display name.
 *
 *    For example, a restriction of "b d" will match:
 *     "Barney Donovan"
 *     "Donovan, Barney"
 *     "Danielle Blumenthal"
 *    But will not match:
 *     "Darby Opal"
 *     "Ben Masters"
 *
 *  Other providers can do whatever matching they want with the ANR
 *  restriction.  For example, soundex or additional field comparisons (like
 *  email addresses).  A good (and fast) implementation will differentiate
 *  your provider from others in a positive way.
 *
 *  FindRow's implementation effectively handles prefix searching on display
 *  names (PR_DISPLAY_NAME).  It does this by binary searching the .SAB file.
 *  The only tricky part is knowing when to stop.  Basically you want to stop
 *  on the first name in the list that matches the restriction.  It's easy to
 *  do linearly, but a little more trick with a binary search.  This
 *  implementation is a reasonable example.
 *
 *
 *  This table has only the following columns:
 */

#include "abp.h"
#include "abctbl.h"
#include "sampabp.rh"

const SizedSPropTagArray(cvalvtMax, tagaivtabcColSet) =
{
    cvalvtMax,
    {
        PR_DISPLAY_NAME_A,
        PR_ENTRYID,
        PR_ADDRTYPE_A,
        PR_EMAIL_ADDRESS_A,
        PR_OBJECT_TYPE,
        PR_DISPLAY_TYPE,
        PR_INSTANCE_KEY
    }
};
const LPSPropTagArray ptagaivtabcColSet = (LPSPropTagArray) &tagaivtabcColSet;

/*
 *
 *  The following routines are implemented in the files abctbl2.c and abctbl3.c:
 *
 *
 *      IVTABC_Release
 *      IVTABC_GetStatus
 *      IVTABC_SetColumns
 *      IVTABC_QueryColumns
 *      IVTABC_GetRowCount
 *      IVTABC_SeekRow
 *      IVTABC_SeekRowApprox
 *      IVTABC_QueryPosition
 *      IVTABC_FindRow
 *      IVTABC_Restrict
 *      IVTABC_CreateBookmark
 *      IVTABC_FreeBookmark
 *      IVTABC_SortTable
 *      IVTABC_QuerySortOrder
 *      IVTABC_QueryRows
 *      IVTABC_Abort
 *      IVTABC_ExpandRow
 *      IVTABC_CollapseRow
 *      IVTABC_WaitForCompletion
 *      IVTABC_GetCollapseState
 *      IVTABC_SetCollapseState
 *
 *
 *  This file (abctbl1.c) has all the utility functions used throughout this
 *  objects methods.  They are the following:
 *
 *      HrNewIVTAbc()
 *      HrValidateEntry()
 *      FChecked()
 *      FMatched()
 *      FNameMatch()
 *      HrOpenFile()
 *      fIVTAbcIdleRoutine()
 *      FreeANRBitmaps()
 *
 *
 *  Copyright 1992-1995 Microsoft Corporation.  All Rights Reserved.
 *
 ***********************************************************************/

/*
 *  vtbl filled in here.
 */

const IVTABC_Vtbl vtblIVTABC =
{

    IVTABC_QueryInterface,
    (IVTABC_AddRef_METHOD *)        ROOT_AddRef,
    IVTABC_Release,
    (IVTABC_GetLastError_METHOD *)  ROOT_GetLastError,
    IVTABC_Advise,
    IVTABC_Unadvise,
    IVTABC_GetStatus,
    IVTABC_SetColumns,
    IVTABC_QueryColumns,
    IVTABC_GetRowCount,
    IVTABC_SeekRow,
    IVTABC_SeekRowApprox,
    IVTABC_QueryPosition,
    IVTABC_FindRow,
    IVTABC_Restrict,
    IVTABC_CreateBookmark,
    IVTABC_FreeBookmark,
    IVTABC_SortTable,
    IVTABC_QuerySortOrder,
    IVTABC_QueryRows,
    IVTABC_Abort,
    IVTABC_ExpandRow,
    IVTABC_CollapseRow,
    IVTABC_WaitForCompletion,
    IVTABC_GetCollapseState,
    IVTABC_SetCollapseState
};


/* Idle function */
FNIDLE fIVTAbcIdleRoutine;

#define     IVTABC_IDLE_INTERVAL        300L
#define     IVTABC_IDLE_PRIORITY        -2
#define     IVTABC_IDLE_FLAGS           FIROINTERVAL

/*************************************************************************
 *
 -  NewIVTAbc
 -
 *  Creates a new IMAPITable on the contents of a .SAB file.
 *
 *
 */
HRESULT
HrNewIVTAbc(LPMAPITABLE *       lppIVTAbc,
            LPABLOGON           lpABLogon,
            LPABCONT            lpABC,
            HINSTANCE           hLibrary,
            LPALLOCATEBUFFER    lpAllocBuff,
            LPALLOCATEMORE      lpAllocMore,
            LPFREEBUFFER        lpFreeBuff,
            LPMALLOC            lpMalloc )
{
    LPIVTABC lpIVTAbc = NULL;
    SCODE scode;
    HRESULT hResult = hrSuccess;
    ULONG ulBK, ulSize, ulSizeHigh;

    /*
     *  Allocate space for the IVTABC structure
     */

    scode = lpAllocBuff(sizeof(IVTABC), (LPVOID *) &lpIVTAbc);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);
        goto err;
    }

    lpIVTAbc->lpVtbl = &vtblIVTABC;
    lpIVTAbc->lcInit = 1;
    lpIVTAbc->hResult = hrSuccess;
    lpIVTAbc->idsLastError = 0;

    lpIVTAbc->hLibrary = hLibrary;
    lpIVTAbc->lpAllocBuff = lpAllocBuff;
    lpIVTAbc->lpAllocMore = lpAllocMore;
    lpIVTAbc->lpFreeBuff = lpFreeBuff;
    lpIVTAbc->lpMalloc = lpMalloc;
    lpIVTAbc->lpABLogon = lpABLogon;

    lpIVTAbc->lpszFileName = NULL;
    hResult = HrLpszGetCurrentFileName(lpABLogon, &(lpIVTAbc->lpszFileName));
    if (HR_FAILED(hResult))
    {
        goto err;
    }

    lpIVTAbc->lpPTAColSet = (LPSPropTagArray) &tagaivtabcColSet;

    /*
     *  Open the .SAB file associated with this logged in session.
     *  Currently it's opened with FILE_SHARED_READ.  This has an
     *  unpleasant side-effect of not being able to modify the .SAB
     *  file while this table is active.
     *
     *  It should be OF_SHARE_DENY_NONE.  I don't have the code to
     *  handle this in this version.
     */
    if ((lpIVTAbc->hFile = CreateFile(
                lpIVTAbc->lpszFileName,
                GENERIC_READ,
                FILE_SHARE_READ|FILE_SHARE_WRITE,
                NULL,
                OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL,
                NULL)) == INVALID_HANDLE_VALUE)
    {
        /*
         *  The file didn't open...
         */

        hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
        SetErrorIDS(lpABC, hResult, IDS_CANT_OPEN_SAB);

        goto err;
    }

    /*
     *  Get the time and date stamp
     *
     */
    (void)GetFileTime(lpIVTAbc->hFile, NULL, NULL, &(lpIVTAbc->filetime));

    /*  Get the size of the file */
    if ((ulSize = GetFileSize(lpIVTAbc->hFile, &ulSizeHigh)) == 0xFFFFFFFF)
    {
        /*
         *  MAYBE I have an error
         */
        if (GetLastError() != NO_ERROR)
        {
            hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
            SetErrorIDS(lpABC, hResult, IDS_SAB_FILE_ATTRIB);
            goto err;
        }

        hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
        SetErrorIDS(lpABC, hResult, IDS_SAB_TOO_LARGE);
        goto err;
    }

    /*
     *  Actual number of valid positions
     */
    lpIVTAbc->ulMaxPos = (ulSize / sizeof(ABCREC));

    /*
     *  Check to see if it's an exact multiple of sizeof(ABCREC)
     */
    if (lpIVTAbc->ulMaxPos * sizeof(ABCREC) != ulSize)
    {
        /*
         *  Nope.
         */

        hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
        SetErrorIDS(lpABC, hResult, IDS_SAB_CORRUPT);
        goto err;
    }

    lpIVTAbc->ulPosition = 0;

    /*  Setup bookmarks  */
    for (ulBK = 0; ulBK < MAX_BOOKMARKS; lpIVTAbc->rglpABCBK[ulBK++] = NULL);

    /*
     *  Restriction stuff
     */

    lpIVTAbc->rgChecked = NULL;
    lpIVTAbc->rgMatched = NULL;
    lpIVTAbc->lpszPartialName = NULL;

    /*
     *  Registered notification stuff
     */

    lpIVTAbc->cAdvise = 0;
    lpIVTAbc->parglpAdvise = NULL;
    lpIVTAbc->ulConnectMic = (ULONG) lpIVTAbc & 0xffffff;
    InitializeCriticalSection(&lpIVTAbc->cs);

    /*
     *  Register the idle function
     */

    lpIVTAbc->ftg = FtgRegisterIdleRoutine(
        fIVTAbcIdleRoutine,
        lpIVTAbc,
        IVTABC_IDLE_PRIORITY,
        IVTABC_IDLE_INTERVAL,
        IVTABC_IDLE_FLAGS);

    InitializeCriticalSection(&lpIVTAbc->cs);

    /*  We must AddRef the lpABLogon object since we will be using it
     */
    lpABLogon->lpVtbl->AddRef(lpABLogon);

    *lppIVTAbc = (LPVOID) lpIVTAbc;

out:


    DebugTraceResult(HrNewIVTAbc, hResult);
    return hResult;

err:
    if (lpIVTAbc)
    {
        if (lpIVTAbc->hFile != INVALID_HANDLE_VALUE)
        {
            /*
             *  Must've opened the file
             */
            CloseHandle(lpIVTAbc->hFile);
        }

        /*  Free the current .SAB file name */
        lpFreeBuff(lpIVTAbc->lpszFileName);

        /*  Free the mem */
        lpFreeBuff( lpIVTAbc );
    }

    goto out;

}

/*************************************************************************
 *
 -  HrValidateEntry
 -
 *
 *  Used in restricted lists
 *  Checks to see if a given entry at a particular location matches
 *  the active restriction.  It always modifies rgChecked, and may
 *  modify rgMatched.
 */
HRESULT
HrValidateEntry(LPIVTABC lpIVTAbc, ULONG ulNewPos)
{
    ABCREC abcrec;
    ULONG cbRead;
    HRESULT hResult;

    /*
     *  Open the file
     */
    hResult = HrOpenFile(lpIVTAbc);
    if (HR_FAILED(hResult))
    {
        DebugTraceResult(HrValidateEntry, hResult);
        return hResult;
    }

    /*
     *  Set the file position to lNewPos
     */

    (void) SetFilePointer(lpIVTAbc->hFile, ulNewPos * sizeof(ABCREC),
                          NULL, FILE_BEGIN);

    /*
     *  Read in the record from the file
     */
    if (!ReadFile(lpIVTAbc->hFile, (LPVOID) &abcrec,
            sizeof(ABCREC), &cbRead, NULL))
    {
        DebugTraceSc(HrValidateEntry, MAPI_E_DISK_ERROR);
        return ResultFromScode(MAPI_E_DISK_ERROR);
    }

    /*  Second check  */
    if (cbRead != sizeof(ABCREC))
    {
        DebugTraceSc(HrValidateEntry, MAPI_E_DISK_ERROR);
        return ResultFromScode(MAPI_E_DISK_ERROR);
    }

    /*
     *  Always set the Checked flag
     */
    lpIVTAbc->rgChecked[ulNewPos / 8] |= (((unsigned char)0x80) >> (ulNewPos % 8));

    /*
     *  See if the rgchDisplayName matches the restriction
     */
    if (!FNameMatch(lpIVTAbc, abcrec.rgchDisplayName))
    {
        /*
         *  Apparently not.  Reset the Matched flag
         */

        lpIVTAbc->ulRstrDenom--;

        lpIVTAbc->rgMatched[ulNewPos / 8] &= ~(((unsigned char)0x80) >> (ulNewPos % 8));
    }

    return hrSuccess;
}

/*************************************************************************
 *
 -  FChecked
 -
 *
 *  Returns whether or not an entry has ever been checked
 *  Just looks at the bit in the rgChecked array that corresponds with
 *  lNewPos
 *
 */
BOOL
FChecked(LPIVTABC lpIVTAbc, ULONG ulNewPos)
{
    ULONG ulT = (ULONG) (lpIVTAbc->rgChecked[ulNewPos / 8] & (((unsigned char)0x80) >> (ulNewPos % 8)));

    return (BOOL) !!ulT;
}

/*************************************************************************
 *
 -  FMatched
 -
 *
 *  Returns whether or not an entry has been matched
 *  Just checks the bit in the rgMatched array corresponding with
 *  lNewPos
 *
 */
BOOL
FMatched(LPIVTABC lpIVTAbc, ULONG ulNewPos)
{
    ULONG ulT = (lpIVTAbc->rgMatched[ulNewPos / 8] & (((unsigned char)0x80) >> (ulNewPos % 8)));

    return (BOOL) !!ulT;

}

/*************************************************************************
 *
 -  FNameMatch
 -
 *  Tries to match the rgchDisplayName with the partial name of the
 *  restriction.
 *  It tries to prefix match each partial name component (i.e. word) with
 *  each rgchDisplayName name component (i.e. word).  Only if all of them
 *  match (from the partial name) does this return TRUE.
 */
BOOL
FCharInString(LPSTR lpsz, CHAR ch);


BOOL
FNameMatch(LPIVTABC lpIVTAbc, LPSTR rgchDisplayName)
{
    LPSTR szANRSep = ", -";
    LPSTR szANR = lpIVTAbc->lpszPartialName;
    LPSTR pchEndSzANR = szANR + lstrlenA(szANR);
    ULONG cchANRName;
    ULONG cchFullNameName;
    LPSTR szFullNameT;
    LPSTR szT;

    /*  If someone tries to match more than an iwMOMax-part name, the function
     *  will return fFalse.  But then if someone is trying to match a name
     *  with iwMOMax parts, chances are they weren't going to get it right
     *  anyway....
     */

#define iwMOMax 50

    WORD rgwMO[iwMOMax];
    int iwMOMac = 0;

    while (TRUE)
    {
        /*  Find the end of the partial name we're pointing at  */

        szT = szANR;
        while (!FCharInString(szANRSep, *szT))
            ++szT;
        cchANRName = szT - szANR;

        /*  Check if it matches any name in the full name  */

        szFullNameT = rgchDisplayName;
        while (TRUE)
        {
            szT = szFullNameT;

            /*  Find the length of the name in the full name  */
            /*  we're checking against.                       */

            while (!FCharInString(szANRSep, *szT))
                ++szT;
            cchFullNameName = szT - szFullNameT;

            if (cchANRName <= cchFullNameName &&
                CompareStringA( lcidUser,
                                NORM_IGNORECASE,
                                szANR,
                                (int) cchANRName,
                                szFullNameT,
                                (int) cchANRName) == 2 )
            {
                int iwMO;

                for (iwMO = 0; iwMO < iwMOMac; iwMO++)
                    if (rgwMO[iwMO] == (WORD) (szFullNameT - rgchDisplayName))
                        break;

                /*  We found the partial name so check the next ANR part */
                if (iwMO == iwMOMac)
                {
                    if (iwMOMac == iwMOMax - 1)
                    {
                        /*  If some user wants to match an iwMOMax part
                         *  name, chances are it wasn't going to match
                         *  anyway...
                         */
                        return FALSE;
                    }
                    rgwMO[iwMOMac++] = szFullNameT - rgchDisplayName;
                    break;
                }
            }

            /*  We didn't find the partial name this time around, so
             *  try to check the next name in the full name.
             */

            szFullNameT += cchFullNameName;

            while (*szFullNameT && FCharInString(szANRSep, *szFullNameT))
                ++szFullNameT;

            if (*szFullNameT == '\0')
                return FALSE;   /*  We never found the partial name. */
        }

        /* We found the partial name, so check the next ANR part */

        szANR += cchANRName;
        while (*szANR && FCharInString(szANRSep, *szANR))
            ++szANR;

        if (*szANR == '\0')
            return TRUE;        /* No more ANR to check, so we found `em all  */
    }

    /*  Not reached (we hope...)  */
    return FALSE;
}

/*
 -  HrOpenFile
 -
 *  Opens the .SAB file associated with the table and
 *  checks whether the .SAB file has changed.
 *  If it has changed, the table bookmarks and ANR bitmaps
 *  are updated and everyone on the advise list is notified.
 */
HRESULT
HrOpenFile(LPIVTABC lpIVTAbc)
{
    HRESULT hResult = hrSuccess;
    FILETIME filetime;
    ULONG ulSize, ulSizeHigh, ulMaxPos;
    LPSTR lpszFileName = NULL;

    /*
     *  If file is not open, open it
     */
    if (lpIVTAbc->hFile == INVALID_HANDLE_VALUE)
    {

        if (!FEqualSABFiles(lpIVTAbc->lpABLogon, lpIVTAbc->lpszFileName))
        {
            /*
             *  Get the new file name
             */
            hResult = HrLpszGetCurrentFileName(lpIVTAbc->lpABLogon, &lpszFileName);
            if (HR_FAILED(hResult))
            {
                goto err;
            }

            /*
             *  Replace the old one with this
             */
            lpIVTAbc->lpFreeBuff(lpIVTAbc->lpszFileName);
            lpIVTAbc->lpszFileName = lpszFileName;

            lpszFileName = NULL;
        }


        /*
         *  File is not open so lets try to open it
         */
        lpIVTAbc->hFile = CreateFile(
            lpIVTAbc->lpszFileName,
            GENERIC_READ,
            FILE_SHARE_READ|FILE_SHARE_WRITE,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (lpIVTAbc->hFile == INVALID_HANDLE_VALUE)
        {
            /*
             *  The file didn't open...
             */
            hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
            SetErrorIDS(lpIVTAbc, hResult, IDS_CANT_OPEN_SAB_FILE);
            goto err;
        }
    }

    /*
     *  Get the time and date stamp
     */
    if (!GetFileTime(lpIVTAbc->hFile, NULL, NULL, &filetime))
    {
        if (GetLastError() != NO_ERROR)
        {
            hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
            SetErrorIDS(lpIVTAbc, hResult, IDS_SAB_FILE_ATTRIB);
        }

        goto err;
    }

    /*  Get the size of the file */
    if ((ulSize = GetFileSize(lpIVTAbc->hFile, &ulSizeHigh)) == 0xFFFFFFFF)
    {
        /*
         *  MAYBE I have an error
         */
        if (GetLastError() != NO_ERROR)
        {
            hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
            SetErrorIDS(lpIVTAbc, hResult, IDS_SAB_FILE_ATTRIB);
            goto err;
        }

        hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
        SetErrorIDS(lpIVTAbc, hResult, IDS_SAB_TOO_LARGE);
        goto err;
    }

    /*
     *  Actual number of valid positions
     */
    ulMaxPos = (ulSize / sizeof(ABCREC));

    /*
     *  Check to see if it's an exact multiple of sizeof(ABCREC)
     */
    if (ulMaxPos * sizeof(ABCREC) != ulSize)
    {
        hResult = ResultFromScode(MAPI_E_UNABLE_TO_COMPLETE);
        SetErrorIDS(lpIVTAbc, hResult, IDS_SAB_CORRUPT);
        goto err;
    }

    /*
     *  if the file has changed set new position, reset bookmarks etc and
     *  notify everybody one the advise list
     */
    if (CompareFileTime(&filetime, &lpIVTAbc->filetime) || ulMaxPos != lpIVTAbc->ulMaxPos)
    {
        ULONG ulBK;
        ABCREC abcrec;
        ULONG cbT;
        LPMAPIADVISESINK *ppadvise;
        ULONG cAdvises;
        NOTIFICATION notif;

        /* save new max position and filetime */
        lpIVTAbc->filetime = filetime;
        lpIVTAbc->ulMaxPos = ulMaxPos;

        /* if current position is past the end of file set it to the end */
        if (lpIVTAbc->ulPosition > lpIVTAbc->ulMaxPos)
            lpIVTAbc->ulPosition = lpIVTAbc->ulMaxPos;

        if (ulMaxPos)
        {
            SetFilePointer(lpIVTAbc->hFile, (ulMaxPos - 1)*sizeof(ABCREC), NULL, FILE_BEGIN);

            /*  Read in the record at that location  */
            if (!ReadFile(lpIVTAbc->hFile, (LPVOID) &abcrec,
                    sizeof(ABCREC), &cbT, NULL))
            {
                hResult = ResultFromScode(MAPI_E_DISK_ERROR);
                SetErrorIDS(lpIVTAbc, hResult, IDS_SAB_NO_READ);

                goto err;
            }

            /* if any of the bookmarks are past the end of file
             * set the file time to current file time, the position to last
             * record and record to last record
             */
            for (ulBK = 0; ulBK < MAX_BOOKMARKS; ulBK++)
                if (lpIVTAbc->rglpABCBK[ulBK] &&
                    lpIVTAbc->rglpABCBK[ulBK]->ulPosition > lpIVTAbc->ulMaxPos)
                {
                    lpIVTAbc->rglpABCBK[ulBK]->ulPosition = ulMaxPos - 1;
                    lpIVTAbc->rglpABCBK[ulBK]->filetime = filetime;
                    lpIVTAbc->rglpABCBK[ulBK]->abcrec = abcrec;
                }

            /*
            *  Reallocate the checked&matched arrays
            */

            cbT = (lpIVTAbc->ulMaxPos) / 8 + 1; /* Number of bytes in both arrays */

            /* Reallocate ANR bitmaps */
            if (lpIVTAbc->rgChecked)
            {
                lpIVTAbc->rgChecked = lpIVTAbc->lpMalloc->lpVtbl->Realloc(
                    lpIVTAbc->lpMalloc,
                    lpIVTAbc->rgChecked,
                    cbT);
            }

            if (lpIVTAbc->rgMatched)
            {
                lpIVTAbc->rgMatched = lpIVTAbc->lpMalloc->lpVtbl->Realloc(
                    lpIVTAbc->lpMalloc,
                    lpIVTAbc->rgMatched,
                    cbT);
            }
        }
        else
        {
            /* if any of the bookmarks are past the end of file
             * set the file time to current file time, the position to the
             * beginning of the file.
             */
            for (ulBK = 0; ulBK < MAX_BOOKMARKS; ulBK++)
                if (lpIVTAbc->rglpABCBK[ulBK] &&
                    lpIVTAbc->rglpABCBK[ulBK]->ulPosition > lpIVTAbc->ulMaxPos)
                {
                    lpIVTAbc->rglpABCBK[ulBK]->ulPosition = 0;
                    lpIVTAbc->rglpABCBK[ulBK]->filetime = filetime;
                }

            /* free the ANR bitmaps */
            FreeANRBitmaps(lpIVTAbc);
        }

        /* initialize the notification */
        ZeroMemory(¬if, sizeof(NOTIFICATION));
        notif.ulEventType = fnevTableModified;
        notif.info.tab.ulTableEvent = TABLE_RELOAD;

        /* notify everyone that the table has changed */
        for (ppadvise = lpIVTAbc->parglpAdvise, cAdvises = 0;
            cAdvises < lpIVTAbc->cAdvise;
            ++ppadvise, ++cAdvises)
        {
            Assert(*ppadvise);
            if (ppadvise)
                (void)(*ppadvise)->lpVtbl->OnNotify(*ppadvise, 1, ¬if);
        }
    }

out:

    DebugTraceResult(NewIVTAbc, hResult);
    return hResult;
err:
    lpIVTAbc->lpFreeBuff(lpszFileName);

    goto out;

}

/*************************************************************************
 *
 -  fIVTAbcIdleRoutine
 -
 *  This function called during idle time closes the .SAB file and notifies
 *  everyone on the advise list if the file name has changed
 *
 */

BOOL STDAPICALLTYPE
fIVTAbcIdleRoutine(LPVOID lpv)
{
    LPIVTABC lpIVTAbc = (LPIVTABC) lpv;

    Assert(lpv);

    /* if file is open close it  */
    if (lpIVTAbc->hFile != INVALID_HANDLE_VALUE)
    {
        CloseHandle(lpIVTAbc->hFile);
        lpIVTAbc->hFile = INVALID_HANDLE_VALUE;
    }

    /* has file name has changed? */
    if (!FEqualSABFiles(lpIVTAbc->lpABLogon, lpIVTAbc->lpszFileName))
    {
        /* file name has changed so call HrOpenFile to reset bookmarks etc */
        if (!HR_FAILED(HrOpenFile(lpIVTAbc)))
        {
            /* close the file */
            CloseHandle(lpIVTAbc->hFile);
            lpIVTAbc->hFile = INVALID_HANDLE_VALUE;
        }
    }
    return TRUE;
}

/*************************************************************************
 *
 -  FreeANRBitmaps
 -
 *  Frees the two ANR bitmaps associated with this table
 *
 *
 */
void
FreeANRBitmaps(LPIVTABC lpIVTAbc)
{
    if (lpIVTAbc->rgChecked)
    {
        lpIVTAbc->lpMalloc->lpVtbl->Free(lpIVTAbc->lpMalloc, lpIVTAbc->rgChecked);
        lpIVTAbc->rgChecked = NULL;
    }

    if (lpIVTAbc->rgMatched)
    {
        lpIVTAbc->lpMalloc->lpVtbl->Free(lpIVTAbc->lpMalloc, lpIVTAbc->rgMatched);
        lpIVTAbc->rgMatched = NULL;
    }
}



/*
 *  FCharInString
 *
 *  Finds a character in a string
 */
BOOL
FCharInString(LPSTR lpsz, CHAR ch)
{

    while (*lpsz && *lpsz != ch)
        lpsz++;

    return (*lpsz == ch);
}