windows-xp/Source/XPSP1/NT/printscan/fax/exchange/ab/abctbl2.c

/***********************************************************************
 *
 *  ABCTBL2.C
 *
 *  Contents Table - Part 2.
 *
 *
 *  The following routines are implemented in this file.
 *
 *
 *      IVTABC_SeekRow
 *      IVTABC_SeekRowApprox
 *      IVTABC_GetRowCount
 *      IVTABC_QueryPosition
 *      IVTABC_FindRow
 *      IVTABC_Restrict
 *      IVTABC_QueryRows
 *
 *
 *
 *  Copyright 1992, 1993, 1994 Microsoft Corporation.  All Rights Reserved.
 *
 * Revision History:
 *
 *      When            Who                                     What
 *      --------        ------------------  ---------------------------------------
 *      1.1.94          MAPI                            Original source from MAPI sample AB Provider
 *      3.7.94          Yoram Yaacovi           Update to MAPI build 154
 *      3.11.94         Yoram Yaacovi           Update to use Fax AB include files
 *      8.1.94          Yoram Yaacovi           Update to MAPI 304
 *      11.7.94         Yoram Yaacovi           Update to MAPI 318 (PR_INSTANCE_KEY)
 *
 ***********************************************************************/

#include "faxab.h"


/*************************************************************************
 *
 -  IVTABC_SeekRow
 -
 *
 *  Tries to seek an appropriate number of rows.
 *
 *
 */
STDMETHODIMP
IVTABC_SeekRow( LPIVTABC lpIVTAbc,
                BOOKMARK bkOrigin,
                LONG lRowCount,
                LONG * lplRowsSought
               )
{
    LONG lNewPos;
    LONG lMoved;
    LONG lDelta;
    LONG lLast;
    HRESULT hResult = hrSuccess;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_SeekRow, hResult);
        return hResult;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_SeekRow, hResult);
        return hResult;
    }

    /*
     *  Check the out parameter for writability (if requested)
     */
    if (lplRowsSought &&
        IsBadWritePtr(lplRowsSought, SIZEOF(LONG)))
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_SeekRow, hResult);
        return hResult;
    }


    EnterCriticalSection(&lpIVTAbc->cs);



    if (bkOrigin == BOOKMARK_BEGINNING)
    {
        lNewPos = 0;

    }
    else if (bkOrigin == BOOKMARK_CURRENT)
    {
        lNewPos = lpIVTAbc->ulPosition;

    }
    else if (bkOrigin == BOOKMARK_END)
    {
        lNewPos = lpIVTAbc->ulMaxPos;

    }
    else
    {
        ULONG ulBK = (ULONG) bkOrigin - 3;
        LPABCBK lpABCBK = NULL;

        /*
         *  See if it's out of range
         */
        if (ulBK < 0 || ulBK >= MAX_BOOKMARKS)
        {
            /*
             *  bad book mark, it's an error, so...
             */
            hResult = ResultFromScode(E_INVALIDARG);

            goto out;
        }

        if (!(lpABCBK = lpIVTAbc->rglpABCBK[ulBK]))
        {
            /*
             *  bookmark has not been allocated
             */
            hResult = ResultFromScode(MAPI_E_INVALID_BOOKMARK);

            goto out;
        }

        /* Not validating existing bookmark  */
        lNewPos = lpABCBK->ulPosition;
    }

    /*
     *  Figure out what endpoint to use and what direction to go to
     *  get there.
     */
    if (lRowCount < 0)
    {
        lLast = 0;
        lDelta = -1;
    }
    else
    {
        lLast = lpIVTAbc->ulMaxPos;
        lDelta = 1;
    }

    /*
     *  While there's rows to seek ...
     */
    lMoved = 0;
    while( (lNewPos != lLast) && (lMoved != lRowCount) )
    {
        lNewPos += lDelta;

        /*
         *  Unrestricted list is easy: just seek.  Also, if the next
         *  'row' is the end of the table, just go there; don't want
         *  to check it against any restriction.
         */
        if ( (!lpIVTAbc->lpszPartialName) || (lNewPos == (LONG) lpIVTAbc->ulMaxPos))
        {
            lMoved += lDelta;
        }

        /*
         *  Otherwise, deal with the restricted list:  only count
         *  the row if it's in the restriction.
         */
        else
        {
            if (!FChecked(lpIVTAbc, (ULONG) lNewPos))
            {
                hResult = HrValidateEntry(lpIVTAbc, (ULONG) lNewPos);

                if (HR_FAILED(hResult))
                {
                    goto out;
                }
            }

            if (FMatched(lpIVTAbc, (ULONG) lNewPos))
            {
                lMoved += lDelta;
            }
        }
    }

    if (lplRowsSought)
        *lplRowsSought = lMoved;

    lpIVTAbc->ulPosition = lNewPos;

out:
    LeaveCriticalSection(&lpIVTAbc->cs);

    DebugTraceResult(IVTABC_SeekRow, hResult);
    return hResult;

}

/*************************************************************************
 *
 -  IVTABC_SeekRowApprox
 -
 *  Tries to set the position of the table according to the approximate
 *  position passed in.
 *
 *
 */
STDMETHODIMP
IVTABC_SeekRowApprox( LPIVTABC lpIVTAbc,
                      ULONG ulNumerator,
                      ULONG ulDenominator
                     )
{
    HRESULT hResult = hrSuccess;
    ULONG iByte;
    BYTE bCount;
    ULONG ulPos = 0;
    ULONG ulCount = 0;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_SeekRowApprox, hResult);
        return hResult;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_SeekRowApprox, hResult);
        return hResult;
    }

    /*
     *  0 denominator is not allowed
     */
    if (!ulDenominator)
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_SeekRowApprox, hResult);
        return hResult;
    }


    EnterCriticalSection(&lpIVTAbc->cs);


    if (ulNumerator >= ulDenominator)
    {
        /*  We're at the end of the list */
        lpIVTAbc->ulPosition = lpIVTAbc->ulMaxPos;

        hResult = hrSuccess;
        goto out;
    }

    /*
     *  Since I'm using muldiv() which takes ints/longs, I should shift right
     *  so that I don't incorrectly call it.
     *  I'm really just checking to see if the sign bit is set...
     */

    if (((long)ulNumerator < 0) || ((long)ulDenominator < 0))
    {
        ulNumerator >>= 1;
        ulDenominator >>= 1;
    }

    if (!lpIVTAbc->lpszPartialName)
    {
        /*
         *  The NON-Restriction method
         */

        lpIVTAbc->ulPosition = MULDIV(lpIVTAbc->ulMaxPos, ulNumerator, ulDenominator);

        hResult = hrSuccess;
        goto out;
    }

    /*
     *  Restriction method
     */

    /*  Figure out % of which corresponds with numerator. */
    ulCount = MULDIV(lpIVTAbc->ulRstrDenom, ulNumerator, ulDenominator);

    /*  Count bits in rgMatched until I match numerator */

    for (iByte = 0; iByte < (lpIVTAbc->ulMaxPos / 8); iByte++)
    {
        CBitsB(lpIVTAbc->rgMatched[iByte], bCount); /* <-- MACRO  */
        ulPos += (ULONG) bCount;

        if (ulPos >= ulCount)
        {
            ulPos -= bCount;    /* Go back a byte */
            break;
        }
    }

    /*  My current position is there. */
    lpIVTAbc->ulPosition = iByte * 8;


out:
    LeaveCriticalSection(&lpIVTAbc->cs);

    DebugTraceResult(IVTABC_SeekRowApprox, hResult);
    return hResult;

}

/*************************************************************************
 *
 -  IVTABC_GetRowCount
 -
 *
 *  If there's a restriction applied, I don't necessarily know how many
 *  rows there are...
 */

STDMETHODIMP
IVTABC_GetRowCount( LPIVTABC lpIVTAbc,
                    ULONG ulFlags,
                    ULONG * lpulCount
                   )
{
    HRESULT hResult;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_GetRowCount, hResult);
        return hResult;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_GetRowCount, hResult);
        return hResult;
    }

    /*
     *  Check the out parameters for writability
     */
    if (IsBadWritePtr(lpulCount, sizeof(ULONG)))
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_GetRowCount, hResult);
        return hResult;
    }

    if (ulFlags & ~TBL_NOWAIT)
    {
        hResult = ResultFromScode(MAPI_E_UNKNOWN_FLAGS);

        DebugTraceResult(IVTABC_GetRowCount, hResult);
        return hResult;
    }


    EnterCriticalSection(&lpIVTAbc->cs);

    /*
     *  If there's no restriction, you can actually calculate this..
     */
    if (!lpIVTAbc->lpszPartialName)
    {

        /*
         *  Number of actual rows
         */
        *lpulCount = lpIVTAbc->ulMaxPos;
        hResult = hrSuccess;
        goto out;
    }

    /*
     *  There's no way that I can tell how many actual entries there
     *  are without counting them.  That takes way too long, so we give
     *  the client our best guess.
     */

    *lpulCount = lpIVTAbc->ulRstrDenom;

    /*
     *  Then we warn the client that this count may not be accurate
     */

    hResult = ResultFromScode(MAPI_W_APPROX_COUNT);

out:
    LeaveCriticalSection(&lpIVTAbc->cs);

    DebugTraceResult(IVTABC_GetRowCount, hResult);
    return hResult;
}

/*************************************************************************
 *
 -  IVTABC_QueryPosition
 -
 *  Figures out the current fractional position
 *
 *
 *
 */
STDMETHODIMP
IVTABC_QueryPosition( LPIVTABC lpIVTAbc,
                      ULONG * lpulRow,
                      ULONG * lpulNumerator,
                      ULONG * lpulDenominator
                     )
{
    HRESULT hResult = hrSuccess;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryPosition, hResult);
        return hResult;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryPosition, hResult);
        return hResult;
    }

    /*
     *  Check the out parameters for writability
     */
    if ( IsBadWritePtr(lpulRow,           SIZEOF(ULONG))
        || IsBadWritePtr(lpulNumerator,   SIZEOF(ULONG))
        || IsBadWritePtr(lpulDenominator, SIZEOF(ULONG))
       )
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryPosition, hResult);
        return hResult;
    }


    EnterCriticalSection(&lpIVTAbc->cs);


    /*  ...I don't have a restriction  */
    if (!lpIVTAbc->lpszPartialName)
    {
        *lpulRow = lpIVTAbc->ulPosition;

        *lpulNumerator = lpIVTAbc->ulPosition;
        *lpulDenominator = lpIVTAbc->ulMaxPos;
    }
    else
    {
        BYTE bCount = 0;
        BYTE bFrag;
        ULONG iByte;

        /*
         *  Zero out fraction
         */
        *lpulNumerator = 0;

        /*
         *  Set denominator that we've been keeping track of.
         */
        *lpulDenominator = (lpIVTAbc->ulRstrDenom ? lpIVTAbc->ulRstrDenom : 1);

        /*
         *  Handle corner case - we're at the beginning of the list...
         */
        if (lpIVTAbc->ulPosition == 0)
        {
            *lpulRow = 0;
            goto out;
        }

        /*
         *  Calculate Numerator
         *  We use the rgMatched bit array and count the bits up to
         *  our current position (lpIVTAbc->ulPosition).
         *
         */
        for (iByte = 0; iByte < (lpIVTAbc->ulPosition / 8); iByte++)
        {
            CBitsB(lpIVTAbc->rgMatched[iByte], bCount); /* <-- MACRO  */
            *lpulNumerator += (ULONG) bCount;
        }
        /*  Count the fragment  */
        bFrag = lpIVTAbc->rgMatched[iByte];
        bFrag = bFrag >> (8 - (lpIVTAbc->ulPosition % 8));

        CBitsB(bFrag, bCount);
        *lpulNumerator += (ULONG) bCount;

        /*
         *  Good guess here...
         */
        *lpulRow = *lpulNumerator;

    }

out:

    LeaveCriticalSection(&lpIVTAbc->cs);

    DebugTraceResult(IVTABC_QueryPosition, hResult);
    return hResult;
}

/*************************************************************************
 *
 -  IVTABC_FindRow
 -
 *
 *  Prefix searches to find a row
 *
 *
 */
STDMETHODIMP
IVTABC_FindRow( LPIVTABC lpIVTAbc,
                LPSRestriction lpRestriction,
                BOOKMARK bkOrigin,
                ULONG ulFlags
               )
{
    HRESULT hResult = hrSuccess;

    ULONG cbRead;
    ABCREC abcrec;
    LONG lpos;
    ULONG fFound = FALSE;
    LPTSTR szPrefix;
    int nCmpResult;

    ULONG ulCurMin;
    ULONG ulCurMac;
    ULONG ulPosT;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_FindRow, hResult);
        return hResult;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_FindRow, hResult);
        return hResult;
    }

    /*
     *  Check flags
     */
    if (ulFlags & ~DIR_BACKWARD)
    {
        hResult = ResultFromScode(MAPI_E_UNKNOWN_FLAGS);

        DebugTraceResult(IVTABC_FindRow, hResult);
        return hResult;
    }

    /*
     *  I don't go backwards, yet.
     */
    if (ulFlags & DIR_BACKWARD)
    {
        hResult = ResultFromScode(MAPI_E_NO_SUPPORT);

        DebugTraceResult(IVTABC_FindRow, hResult);
        return hResult;
    }


    EnterCriticalSection(&lpIVTAbc->cs);

    /*
     *  Open the file
     */
    hResult = HrOpenFile(lpIVTAbc);
    if (HR_FAILED(hResult))
    {
        goto out;
    }

    /*
     *  initialize
     */
    ulCurMin = lpIVTAbc->ulPosition;
    ulCurMac = lpIVTAbc->ulMaxPos;

    /*
     *  I handle two type of restrictions:
     *              prefix searching on Display Names
     *              Finding a row based on it's instance key
     */

    /*
     *  The restriction looks like:
     *
     *  +-----------------
     *  | RES_PROPERTY
     *  +-----------------
     *  | RELOP_GE
     *  +-----------------
     *  | PR_DISPLAY_NAME
     *  +-----------------
     *  | LPSPropVal   -----+
     *  +-----------------  |
     *                      |   +-------------------------
     *                      +-->| PR_DISPLAY_NAME
     *                          +-------------------------
     *                          | 0 <-- for alignment (don't care)
     *                          +-------------------------
     *                          | lpszA <-- prefix for display name
     *                          +-------------------------
     *
     *
     *                              -OR-
     *
     *  Find a row based on it's instance key
     *
     *  +-----------------
     *  | RES_PROPERTY
     *  +-----------------
     *  | RELOP_EQ
     *  +-----------------
     *  | PR_INSTANCE_KEY
     *  +-----------------
     *  | LPSPropVal   -----+
     *  +-----------------  |
     *                      |   +-------------------------
     *                      +-->| PR_INSTANCE_KEY
     *                          +-------------------------
     *                          |     | cbInstanceKey
     *                          + bin +-------------------
     *                          |     | lpbInstanceKey
     *                          +-------------------------
     *
     *
     *  If it doesn't look like one of these, return MAPI_E_TOO_COMPLEX.
     */

    /*
     *  Both restrictions require this one
     */
    if (lpRestriction->rt != RES_PROPERTY)
    {
        hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

        goto out;
    }

    /*
     *  Look for Instance Key first - it's easiest to handle
     */
    if (lpRestriction->res.resProperty.relop == RELOP_EQ)
    {
        LPABCRecInstance lpABCRecInstance;

        if (lpRestriction->res.resProperty.ulPropTag != PR_INSTANCE_KEY)
        {
            /*
             *  Clearly something we don't recognize
             */
            hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

            goto out;
        }

        /*
         *  Crack the bin part of this restriction and
         *  see if we can still find our way back to this
         *  record - quickly...
         */
        lpABCRecInstance = (LPABCRecInstance) lpRestriction->res.resProperty.lpProp->Value.bin.lpb;

        /*
         *  First check to see that we're browsing the same file
         */
        if (lstrcmp(lpABCRecInstance->rgchzFileName, lpIVTAbc->lpszFileName))
        {
            /*
             *  Nope, different names, return not found and leave our position alone...
             */
            hResult = ResultFromScode(MAPI_E_NOT_FOUND);
            goto out;
        }

        /*
         *  Ok, so we think we're browsing the same file.  Has it been modified since the
         *  last time we looked?
         */
        if (memcmp(&(lpABCRecInstance->filetime), &(lpIVTAbc->filetime), SIZEOF(FILETIME)))
        {
            /*
             *  Nope, they're different, so no guarantees here...
             */
            hResult = ResultFromScode(MAPI_E_NOT_FOUND);
            goto out;
        }

        /*
         *  Now, I feel pretty confident about this instance key.  Just set my current position
         *  and go for it.
         */
        lpIVTAbc->ulPosition = lpABCRecInstance->ulRecordPosition;

        /* Done */
        goto out;

    }

    /*
     *  Now we're looking for prefix searching on display name
     */
    if (lpRestriction->res.resProperty.relop != RELOP_GE)
    {
        hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

        goto out;
    }

    if (lpRestriction->res.resProperty.ulPropTag != PR_DISPLAY_NAME_A)
    {
        hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

        goto out;
    }

    szPrefix = lpRestriction->res.resProperty.lpProp->Value.LPSZ;

    if (bkOrigin == BOOKMARK_BEGINNING)
    {
        ulCurMin = 0;

    }
    else if (bkOrigin == BOOKMARK_END)
    {
        ulCurMin = lpIVTAbc->ulMaxPos;

    }
    else if (bkOrigin != BOOKMARK_CURRENT)
    {
        ULONG ulBK = (ULONG) bkOrigin - 3;
        LPABCBK lpABCBK = NULL;

        /*
         *  See if it's out of range
         */
        if (ulBK < 0 || ulBK >= MAX_BOOKMARKS)
        {
            /*
             *  bad book mark, it's an error, so...
             */
            hResult = ResultFromScode(E_INVALIDARG);

            goto out;
        }

        if (!(lpABCBK = lpIVTAbc->rglpABCBK[ulBK]))
        {
            /*
             *  bookmark has not been allocated
             */
            hResult = ResultFromScode(MAPI_E_INVALID_BOOKMARK);

            goto out;
        }

        /*  Not validating existing bookmark  */
        ulCurMin = lpABCBK->ulPosition;
    }

    while (ulCurMin < ulCurMac)
    {
        /*
         *  Look for a row which matches the table restriction (if any).
         */
        ulPosT = (ulCurMin + ulCurMac) / 2;

        lpos = (long)((long)ulPosT * (long)SIZEOF(ABCREC));

        SetFilePointer(lpIVTAbc->hFile, lpos, NULL, FILE_BEGIN);

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

            goto out;
        }

        /*
         *  I want case insensitive comparisons here...
         */
        nCmpResult = lstrcmpi(szPrefix, abcrec.rgchDisplayName);

        if (nCmpResult > 0)
        {
            ulCurMin = ulPosT + 1;
        }
        else
        {
            ulCurMac = ulPosT;
            if ( !lpIVTAbc->lpszPartialName ||
                 FNameMatch(lpIVTAbc, abcrec.rgchDisplayName)
               )
            {
                fFound = TRUE;
            }
        }
    }

    /*
     *  If I didn't find a row, return MAPI_E_NOT_FOUND.
     */
    if (!fFound)
    {
        hResult = ResultFromScode(MAPI_E_NOT_FOUND);

        goto out;
    }

    /*
     *  Otherwise, set the current position to the row found.
     */
    lpIVTAbc->ulPosition = ulCurMac;

out:
    LeaveCriticalSection(&lpIVTAbc->cs);

    DebugTraceResult(IVTABC_FindRow, hResult);
    return hResult;
}

/*************************************************************************
 *
 -  IVTABC_Restrict
 -
 *
 *      Should just support ANR type restrictions...
 */
STDMETHODIMP
IVTABC_Restrict( LPIVTABC lpIVTAbc,
                 LPSRestriction lpRestriction,
                 ULONG ulFlags
                )
{
    LPTSTR szT = NULL;
    LPTSTR lpszTNew = NULL;
    ULONG cbTB = 0;
    BYTE bFilter = 0;
    SCODE scode;
    HRESULT hResult = hrSuccess;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        goto out;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        goto out;
    }

    /*
     *  Check flags
     */
    if (ulFlags & ~(TBL_NOWAIT|TBL_BATCH))
    {
        hResult = ResultFromScode(MAPI_E_UNKNOWN_FLAGS);

        goto out;
    }

    /*
     *  I only handle ANR type restrictions
     */

    /*
     *  Check to see if they're resetting the restrictions
     */
    if (!lpRestriction)
    {
        EnterCriticalSection(&lpIVTAbc->cs);

        if (lpIVTAbc->lpszPartialName)
            (*(lpIVTAbc->lpFreeBuff)) (lpIVTAbc->lpszPartialName);
        lpIVTAbc->lpszPartialName = NULL;

        FreeANRBitmaps(lpIVTAbc);

        LeaveCriticalSection(&lpIVTAbc->cs);

        return hrSuccess;
    }

    /*
     *  The restriction must look like:
     *
     *
     *  +--------------
     *  | RES_PROPERTY
     *  +--------------
     *  | RELOP_EQ
     *  +--------------
     *  | PR_ANR
     *  +--------------
     *  | LPSPropVal ---+
     *  +-------------- |
     *                  |   +-------------------------
     *                  +-->| PR_ANR
     *                      +-------------------------
     *                      | 0 <-- for alignment (don't care)
     *                      +-------------------------
     *                      | lpszA <-- string to ANR on
     *                      +-------------------------
     *
     *
     *
     *  If it doesn't look like this, return MAPI_E_TOO_COMPLEX.
     *
     */

    if (lpRestriction->rt != RES_PROPERTY)
    {
        hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

        goto out;
    }

    if (lpRestriction->res.resProperty.relop != RELOP_EQ)
    {
        hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

        goto out;
    }

    if (lpRestriction->res.resProperty.ulPropTag != PR_ANR)
    {
        hResult = ResultFromScode(MAPI_E_TOO_COMPLEX);

        goto out;
    }

    /*
     *  NULL string is not defined - it's a bad restriction
     */
    if (!lpRestriction->res.resProperty.lpProp->Value.LPSZ)
    {
        hResult = ResultFromScode(E_INVALIDARG);

        goto out;
    }


    szT = lpRestriction->res.resProperty.lpProp->Value.LPSZ;

    /*
     *  Skip over leading spaces
     */

    while (*szT == TEXT(' '))
        szT++;

    /*
     *  Empty string is not defined - it's a bad restriction
     */
    if (*szT == TEXT('\0'))
    {
        hResult = ResultFromScode(E_INVALIDARG);
        goto out;
    }


    /*
     *  Copy the string for the partial name
     */

    scode = lpIVTAbc->lpAllocBuff((lstrlen(szT) + 1)*SIZEOF(TCHAR), (LPVOID *) &lpszTNew);
    if (FAILED(scode))
    {
        /*
         *  Memory error
         */

        hResult = ResultFromScode(scode);
        goto out;
    }
    lstrcpy(lpszTNew, szT);


    EnterCriticalSection(&lpIVTAbc->cs);


    /*
     *  Clear up any old restriction
     */

    if (lpIVTAbc->lpszPartialName)
        lpIVTAbc->lpFreeBuff(lpIVTAbc->lpszPartialName);

    lpIVTAbc->lpszPartialName = lpszTNew;

    FreeANRBitmaps(lpIVTAbc);


    /*
     *  Allocate enough bits for the checked&matched arrays
     */
    cbTB = (lpIVTAbc->ulMaxPos) / 8 + 1;    /* Number of bytes in both arrays */

    lpIVTAbc->rgChecked = lpIVTAbc->lpMalloc->lpVtbl->Alloc(
        lpIVTAbc->lpMalloc,
        cbTB);

    if (lpIVTAbc->rgChecked == NULL)
    {
        lpIVTAbc->lpFreeBuff(lpIVTAbc->lpszPartialName);
        lpIVTAbc->lpszPartialName = NULL;

        hResult = ResultFromScode(scode);

        LeaveCriticalSection(&lpIVTAbc->cs);
        goto out;
    }

    lpIVTAbc->rgMatched = lpIVTAbc->lpMalloc->lpVtbl->Alloc(
        lpIVTAbc->lpMalloc,
        cbTB);

    if (lpIVTAbc->rgMatched == NULL)
    {
        (*(lpIVTAbc->lpFreeBuff)) (lpIVTAbc->lpszPartialName);
        lpIVTAbc->lpszPartialName = NULL;

        lpIVTAbc->lpMalloc->lpVtbl->Free(lpIVTAbc->lpMalloc, lpIVTAbc->rgChecked);
        lpIVTAbc->rgChecked = NULL;

        hResult = ResultFromScode(scode);

        LeaveCriticalSection(&lpIVTAbc->cs);
        goto out;
    }

    /*
     *  Initialize the checked array with 0's
     */

    FillMemory(lpIVTAbc->rgChecked, (UINT) cbTB, 0x00);

    /*
     *  Initialize the matched array with 1's
     *  [we assume that if you haven't checked it, it matches]
     */

    FillMemory(lpIVTAbc->rgMatched, (UINT) cbTB, 0xFF);

    /*
     *  Fill in the end bits so we don't have to worry about them
     *  later
     */
    bFilter = (0xFF >> (lpIVTAbc->ulMaxPos % 8));

    /*  Checked end bits should be 1 */
    lpIVTAbc->rgChecked[cbTB - 1] = bFilter;

    /*  Matched end bits should be 0 */
    lpIVTAbc->rgMatched[cbTB - 1] = ~bFilter;

    /*
     *  Set the currenly known total number of rows
     *  that match the restriction.
     */

    lpIVTAbc->ulRstrDenom = lpIVTAbc->ulMaxPos;

    LeaveCriticalSection(&lpIVTAbc->cs);

out:

    DebugTraceResult(IVTABC_Restrict, hResult);
    return hResult;

}



/*************************************************************************
 *
 -  IVTABC_QueryRows
 -
 *  Attempts to retrieve ulRowCount rows from the .FAB file.  Even in the
 *  restricted case.
 *
 *
 */
STDMETHODIMP
IVTABC_QueryRows( LPIVTABC lpIVTAbc,
                  LONG lRowCount,
                  ULONG ulFlags,
                  LPSRowSet * lppRows
                 )
{
    SCODE scode;
    HRESULT hResult = hrSuccess;
    LPSRowSet lpRowSet = NULL;
    LPSPropValue lpRow = NULL;
    int cbSizeOfRow;
    int cRows, iRow;
    int cCols;
    DWORD cbRead;
    ABCREC abcrec;
    ULONG ulOrigPosition;

    /*
     *  Validate parameters
     */

    /*
     *  Check to see if it's large enough to hold this object
     */
    if (IsBadReadPtr(lpIVTAbc, SIZEOF(IVTABC)))
    {
        /*
         *  Not large enough
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryRows, hResult);
        return hResult;
    }

    /*
     *  Check to see that it's the correct vtbl
     */
    if (lpIVTAbc->lpVtbl != &vtblIVTABC)
    {
        /*
         *  Not my vtbl
         */
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryRows, hResult);
        return hResult;
    }

    /*
     *  Check the out parameter for writability
     */
    if (IsBadWritePtr(lppRows, SIZEOF(LPSRowSet)))
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryRows, hResult);
        return hResult;
    }

    /*
     *  Never valid to ask for 0 rows
     */
    if (!lRowCount)
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryRows, hResult);
        return hResult;
    }

    /*  //$ MM2 Hack!  Won't Read backwards for TR2 */
    if (lRowCount < 0)
    {
        hResult = ResultFromScode(E_INVALIDARG);

        DebugTraceResult(IVTABC_QueryRows, hResult);
        return hResult;
    }

    /*
     *  Check the flags
     */
    if (ulFlags & ~TBL_NOADVANCE)
    {
        hResult = ResultFromScode(MAPI_E_UNKNOWN_FLAGS);

        DebugTraceResult(IVTABC_QueryRows, hResult);
        return hResult;
    }


    EnterCriticalSection(&lpIVTAbc->cs);

    /*
     *  Open the file
     */
    hResult = HrOpenFile(lpIVTAbc);
    if (HR_FAILED(hResult))
    {
        goto out;
    }

    ulOrigPosition = lpIVTAbc->ulPosition;

    /*
     *  Calculate # of rows that will be read.
     */
    cRows = (int)lpIVTAbc->ulMaxPos - (int)lpIVTAbc->ulPosition;
    cRows = (cRows < (int)lRowCount ? cRows : (int)lRowCount);

    /*
     *  Allocate array for SRowSet
     */

    scode = lpIVTAbc->lpAllocBuff(sizeof(ULONG) + cRows * SIZEOF(SRow),
                                        (LPVOID *) &lpRowSet);
    if (FAILED(scode))
    {
        hResult = ResultFromScode(scode);

        goto out;
    }

    /*
     *  Initialize - so we can clean up later if we have to...
     */
    lpRowSet->cRows = cRows;

    for( iRow = 0; iRow < cRows; iRow++ )
    {
        lpRowSet->aRow[iRow].lpProps = NULL;
    }



    /*
     *  Seek to correct position in file
     */
    (void) SetFilePointer( lpIVTAbc->hFile,
                           lpIVTAbc->ulPosition * SIZEOF(ABCREC),
                           NULL,
                           FILE_BEGIN
                          );

    /*
     *  Read each row from the file
     */
    for (iRow = 0; iRow < cRows; iRow++)
    {

        /*  The only properties available are:
         *
         *  PR_DISPLAY_NAME, PR_ENTRYID, PR_ADDRTYPE, PR_EMAIL_ADDRESS,
         *  PR_OBJECT_TYPE, PR_DISPLAY_TYPE
         */

        /*
         *  Handle restricted lists
         */
        if (lpIVTAbc->lpszPartialName)
        {
            ULONG ulPos = lpIVTAbc->ulPosition;

next:
            if (ulPos == lpIVTAbc->ulMaxPos)
            {
                break;
            }

            if (!FChecked(lpIVTAbc, ulPos))
            {
                hResult = HrValidateEntry(lpIVTAbc, ulPos);
                if (HR_FAILED(hResult))
                {
                    goto err;
                }
            }

            if (!FMatched(lpIVTAbc, ulPos))
            {
                ulPos++;
                goto next;
            }

            lpIVTAbc->ulPosition = ulPos;
            (void) SetFilePointer( lpIVTAbc->hFile,
                                   lpIVTAbc->ulPosition * SIZEOF(ABCREC),
                                   NULL,
                                   FILE_BEGIN
                                  );

        }

        lpIVTAbc->ulPosition++;

        /*
         *  Read in the record from the file
         */
        if ( !ReadFile( lpIVTAbc->hFile, (LPVOID) &abcrec,
                        SIZEOF(ABCREC), &cbRead, NULL)
            )
        {
            hResult = ResultFromScode(MAPI_E_DISK_ERROR);
            SetErrorIDS(lpIVTAbc, hResult, IDS_FAB_NO_READ);

            goto err;
        }
        /*  Second check  */
        if ((UINT) cbRead != SIZEOF(ABCREC))
        {
            /*
             *  Should never get here.
             */
            hResult = ResultFromScode(MAPI_E_DISK_ERROR);
            SetErrorIDS(lpIVTAbc, hResult, IDS_FAB_NO_READ);

            goto err;
        }

        /*  Allocate memory to start a row.
         */
        cbSizeOfRow = SIZEOF(ULONG) +
            (int)lpIVTAbc->lpPTAColSet->cValues * SIZEOF(SPropValue);

        scode = lpIVTAbc->lpAllocBuff(cbSizeOfRow, (LPVOID *) &lpRow);
        if (FAILED(scode))
        {
            hResult = ResultFromScode(scode);

            goto err;
        }

        /*
         *  Get all the data
         */
        for (cCols = 0; cCols < (int)lpIVTAbc->lpPTAColSet->cValues; cCols++)
        {
            switch (lpIVTAbc->lpPTAColSet->aulPropTag[cCols])
            {
            case PR_DISPLAY_NAME_A:
            {

                INT cch = lstrlen(abcrec.rgchDisplayName) + 1;

                lpRow[cCols].ulPropTag = PR_DISPLAY_NAME_A;
                scode = lpIVTAbc->lpAllocMore( cch,
                                               lpRow,
                                               (LPVOID *) &(lpRow[cCols].Value.lpszA)
                                              );

                if (FAILED(scode))
                {
                    lpRow[cCols].ulPropTag = PROP_TAG(PT_ERROR,
                        PROP_ID(PR_DISPLAY_NAME_A));
                    lpRow[cCols].Value.err = scode;
                }
                else
                {
#ifdef UNICODE
                    lpRow[cCols].Value.lpszA[0] = 0;
                    WideCharToMultiByte( CP_ACP, 0,
                                         abcrec.rgchDisplayName, -1,
                                         lpRow[cCols].Value.lpszA, cch,
                                         NULL, NULL
                                        );
#else
                    lstrcpy(lpRow[cCols].Value.LPSZ, abcrec.rgchDisplayName);
#endif
                }

            }
            break;

            case PR_EMAIL_ADDRESS_A:
            {

                INT cch = lstrlen(abcrec.rgchEmailAddress) + 1;

                lpRow[cCols].ulPropTag = PR_EMAIL_ADDRESS_A;
                scode = lpIVTAbc->lpAllocMore( cch,
                                               lpRow,
                                               (LPVOID *) &(lpRow[cCols].Value.lpszA)
                                              );

                if (FAILED(scode))
                {
                    lpRow[cCols].ulPropTag = PROP_TAG(PT_ERROR,
                        PROP_ID(PR_EMAIL_ADDRESS_A));
                    lpRow[cCols].Value.err = scode;
                }
                else
                {
#ifdef UNICODE
                    lpRow[cCols].Value.lpszA[0] = 0;
                    WideCharToMultiByte( CP_ACP, 0,
                                         abcrec.rgchEmailAddress, -1,
                                         lpRow[cCols].Value.lpszA, cch,
                                         NULL, NULL
                                        );
#else
                    lstrcpy(lpRow[cCols].Value.LPSZ, abcrec.rgchEmailAddress);
#endif
                }

            }
            break;


            case PR_ADDRTYPE_A:
            {
                /*
                 *  AddrType is always "MSPEER" for the FAB
                 */

                INT cch = lstrlen(lpszEMT) + 1;

                lpRow[cCols].ulPropTag = PR_ADDRTYPE_A;
                scode = lpIVTAbc->lpAllocMore( cch,
                                               lpRow,
                                               (LPVOID *) &(lpRow[cCols].Value.lpszA)
                                              );

                if (FAILED(scode))
                {
                    lpRow[cCols].ulPropTag = PROP_TAG(PT_ERROR,
                        PROP_ID(PR_ADDRTYPE_A));
                    lpRow[cCols].Value.err = scode;
                }
                else
                {
#ifdef UNICODE
                    lpRow[cCols].Value.lpszA[0] = 0;
                    WideCharToMultiByte( CP_ACP, 0,
                                         lpszEMT, -1,
                                         lpRow[cCols].Value.lpszA, cch,
                                         NULL, NULL
                                        );
#else
                    lstrcpy(lpRow[cCols].Value.LPSZ, lpszEMT);
#endif
                }

            }
            break;

            case PR_ENTRYID:
            {
                /*
                 *  Fixed sized entryid.  Basically just the .FAB file record
                 */
                LPUSR_ENTRYID lpUsrEid;

                lpRow[cCols].ulPropTag = PR_ENTRYID;
                scode = lpIVTAbc->lpAllocMore (SIZEOF(USR_ENTRYID), lpRow,
                            (LPVOID *) &(lpRow[cCols].Value.bin.lpb));

                if (FAILED(scode))
                {
                    lpRow[cCols].ulPropTag = PROP_TAG(PT_ERROR,
                        PROP_ID(PR_ENTRYID));
                    lpRow[cCols].Value.err = scode;
                }
                else
                {
                    lpUsrEid = (LPUSR_ENTRYID) lpRow[cCols].Value.bin.lpb;

                    RtlZeroMemory(lpUsrEid, SIZEOF(USR_ENTRYID));

                    /*  Size of entryid */
                    lpRow[cCols].Value.bin.cb = SIZEOF(USR_ENTRYID);

                    lpUsrEid->abFlags[0] = 0;   /*  long-term, recipient */
                    lpUsrEid->abFlags[1] = 0;
                    lpUsrEid->abFlags[2] = 0;
                    lpUsrEid->abFlags[3] = 0;
                    lpUsrEid->muid = muidABMAWF;
                    lpUsrEid->ulVersion = MAWF_VERSION;
                    lpUsrEid->ulType = MAWF_USER;
                    lpUsrEid->abcrec = abcrec;
                }

            }
            break;

            case PR_OBJECT_TYPE:
            {
                /*
                 *  MailUser
                 */

                lpRow[cCols].ulPropTag = PR_OBJECT_TYPE;
                lpRow[cCols].Value.ul = MAPI_MAILUSER;
            }
            break;

            case PR_DISPLAY_TYPE:
            {
                /*
                 *  MailUser
                 */

                lpRow[cCols].ulPropTag = PR_DISPLAY_TYPE;
                lpRow[cCols].Value.ul = DT_MAILUSER;

            }
            break;

            case PR_INSTANCE_KEY:
            {
                LPABCRecInstance lpABCRecInstance;
                UINT cbRecInstance;
                /*
                 *  Instance keys are made up of:
                 *              ulRecordPosition - current position in the file
                 *              filetime                 - current date and time stamp of file
                 *              lpszFileName     - current file that we're browsing
                 */
                lpRow[cCols].ulPropTag = PR_INSTANCE_KEY;

                cbRecInstance = SIZEOF(ABCRecInstance)+(lstrlen(lpIVTAbc->lpszFileName)+1)*SIZEOF(TCHAR);
                scode = lpIVTAbc->lpAllocMore(cbRecInstance,
                                lpRow,
                                (LPVOID) &(lpRow[cCols].Value.bin.lpb));

                if (FAILED(scode))
                {
                    lpRow[cCols].ulPropTag = PROP_TAG(PT_ERROR, PROP_ID(PR_INSTANCE_KEY));
                    lpRow[cCols].Value.err = scode;
                }
                else
                {
                    lpABCRecInstance = (LPABCRecInstance) lpRow[cCols].Value.bin.lpb;

                    ZeroMemory(lpABCRecInstance, cbRecInstance);

                    lpRow[cCols].Value.bin.cb = (ULONG) cbRecInstance;

                    lpABCRecInstance->ulRecordPosition = lpIVTAbc->ulPosition;
                    lpABCRecInstance->filetime = lpIVTAbc->filetime;
                    lstrcpy(lpABCRecInstance->rgchzFileName, lpIVTAbc->lpszFileName);

                }
            }
            break;

            default:
            {
                lpRow[cCols].ulPropTag = PROP_TAG(PT_ERROR,
                    PROP_ID(lpIVTAbc->lpPTAColSet->aulPropTag[cCols]));
                lpRow[cCols].Value.err = MAPI_E_NOT_FOUND;
            }
            break;
            }
        }

        /*  # of columns  */
        lpRowSet->aRow[iRow].cValues = lpIVTAbc->lpPTAColSet->cValues;

        /*  Actual row of data */
        lpRowSet->aRow[iRow].lpProps = lpRow;

        lpRow = NULL;

    }

    /*
     *  it's always iRow.
     */
    lpRowSet->cRows = iRow;

    /*
     *  Handle Seeked position stuff
     */
    if (ulFlags & TBL_NOADVANCE)
    {
        /*
         *  Set it back to it's original position
         */
        lpIVTAbc->ulPosition = ulOrigPosition;
    }


    *lppRows = lpRowSet;

out:
    LeaveCriticalSection(&lpIVTAbc->cs);

    DebugTraceResult(IVTABC_QueryRows, hResult);
    return hResult;

err:
    /*
     *  Clean up memory...
     */

    /*  Free the row  */
    lpIVTAbc->lpFreeBuff(lpRow);

    /*  Clean up the rest of the rows  */
    FreeProws(lpRowSet);

    *lppRows = NULL;

    goto out;

}