windows-nt-4.0/private/net/svcdlls/rpl/server/boot.c

/*++

Copyright (c) 1993  Microsoft Corporation

Module Name:

    boot.c

Abstract:

    This module contains RPL boot apis: - internal routines only.

Author:

    Vladimir Z. Vulovic     (vladimv)       10 - November - 1993

Revision History:

    10-Nov-1993     vladimv
        Created

--*/

#include "local.h"
#include "rpldb.h"
#include "db.h"
#include "dblib.h"
#include "config.h"
#include "profile.h"
#include "wksta.h"
#define RPLBOOT_ALLOCATE
#include "boot.h"
#undef RPLBOOT_ALLOCATE
#include "database.h"



DWORD BootGetField(
    IN      PRPL_SESSION    pSession,
    IN      DWORD           FieldIndex,
    OUT     LPVOID *        pData,
    IN OUT  LPINT           pSpaceLeft
    )
{
    BYTE                LocalBuffer[ 300];
    PBYTE               Buffer;
    DWORD               DataSize;
    DWORD               BufferSize;
    JET_ERR             JetError;

    switch( FieldIndex) {
    case BOOT_WindowSize:
    case BOOT_Flags:
    case BOOT_VendorId:
        Buffer = (PBYTE)pData;
        BufferSize = sizeof( DWORD);
        break;
    default:
        Buffer = LocalBuffer;
        BufferSize = sizeof( LocalBuffer);
        break;
    }
    JetError = JetRetrieveColumn( pSession->SesId, pSession->BootTableId,
        BootTable[ FieldIndex].ColumnId, Buffer,
        BufferSize, &DataSize, 0, NULL);
    if ( JetError < 0) {
        RplDump( ++RG_Assert, ("JetError=%d", JetError));
        return( NERR_RplBootInfoCorrupted);
    }
    if ( Buffer != LocalBuffer) {
        if ( BufferSize == DataSize) {
            return( NO_ERROR);
        } else {
            RplDump( ++RG_Assert, ("Bad DataSize=0x%x", DataSize));
            return( NERR_RplBootInfoCorrupted);
        }
    }
    //
    //  We have done with fixed data.  From here on we deal with unicode
    //  strings only.
    //
    if ( DataSize > sizeof( LocalBuffer)) {
        RplDump( ++RG_Assert, ( "Too big DataSize=0x%x", DataSize));
        return( NERR_RplBootInfoCorrupted);
    }
    if ( DataSize == 0) {
        if ( JetError != JET_wrnColumnNull) {
            RplDump( ++RG_Assert, ( "JetError=%d", JetError));
            return( NERR_RplBootInfoCorrupted);
        } else {
            *pData = NULL; // so RPC rpcrt4!_tree_size_ndr() does not bomb here
            return( NO_ERROR);
        }
    }
    if ( DataSize & 1 != 0  ||  wcslen((PWCHAR)LocalBuffer) + 1 != DataSize/2) {
        RplDump( ++RG_Assert, ("LocalBuffer=0x%x, DataSize=0x%x", LocalBuffer, DataSize));
        return( NERR_RplBootInfoCorrupted);
    }
    *pData = MIDL_user_allocate( DataSize);
    if ( *pData == NULL) {
        RplDump( ++RG_Assert, ( "Error=%d", GetLastError()));
        RPL_RETURN( ERROR_NOT_ENOUGH_MEMORY);
    }
    memcpy( *pData, LocalBuffer, DataSize);
    *pSpaceLeft -= DataSize;
    return( NO_ERROR);
}


BOOL BootResumeFirst(
    IN      PRPL_SESSION    pSession,
    IN      LPDWORD         pResumeHandle,
    OUT     PBOOL           pTableEnd
    )
/*++
    Set currency to the first boot record following the boot record
    described by the resume handle.
--*/
{
    BYTE        ResumeValue[ RPL_MAX_VENDOR_NAME_SIZE + RPL_MAX_WKSTA_NAME_SIZE];
    PWCHAR      BootName;
    DWORD       BootNameSize;
    DWORD       ResumeSize;
    JET_ERR     JetError;

    *pTableEnd = FALSE;

    CallB( JetSetCurrentIndex( pSession->SesId, pSession->BootTableId, BOOT_INDEX_VendorIdBootName));
    //
    //  The call to move to the beginning of the table is not redundant.
    //  E.g. JET_errNoCurrentRecord will be returned in case of empty table.
    //
    JetError = JetMove( pSession->SesId, pSession->BootTableId, JET_MoveFirst, 0);
    if ( JetError < 0) {
        if ( JetError == JET_errRecordNotFound
                ||  JetError == JET_errNoCurrentRecord) {
            *pTableEnd = TRUE;
            return( TRUE);
        } else {
            RplDump( ++RG_Assert, ("JetError=%d", JetError));
            return( FALSE);
        }
    }
    if ( !(ARGUMENT_PRESENT( pResumeHandle))  || *pResumeHandle == 0) {
       return( TRUE);   //  not resuming, all done
    }
    ResumeSize = sizeof( ResumeValue);
    if ( !ResumeKeyGet( pSession, *pResumeHandle, ResumeValue, &ResumeSize)) {
        return( FALSE);
    }
    CallB( JetMakeKey( pSession->SesId, pSession->BootTableId, ResumeValue, sizeof( DWORD), JET_bitNewKey));
    BootName = (PWCHAR)( ResumeValue + sizeof(DWORD));
    BootNameSize = (DWORD)( ResumeSize - sizeof(DWORD));
    if ( BootNameSize != (wcslen( BootName) + 1) * sizeof( WCHAR)) {
        RplDump( ++RG_Assert, ("ResumeValue=0x%x, ResumeSize=0x%x", ResumeValue, ResumeSize));
        return( FALSE);
    }
    CallB( JetMakeKey( pSession->SesId, pSession->BootTableId, BootName, BootNameSize, 0));
    CallB( JetSeek( pSession->SesId, pSession->BootTableId, JET_bitSeekGT));
    return( TRUE);
}


VOID BootResumeSave(
    IN      PRPL_SESSION    pSession,
    IN      DWORD           ServerHandle,
    IN      DWORD           VendorId,
    IN      PWCHAR          BootName,
    IN      PDWORD          pResumeHandle
    )
/*++
    This all other other functions that save resume keys is void, because there
    is no documented way of returning error cannot resume to the client.
--*/
{
    BYTE        ResumeBuffer[ 30 * sizeof(WCHAR)];
    DWORD       BootSize;

    memcpy( ResumeBuffer, &VendorId, sizeof( VendorId));
    BootSize = ( wcslen( BootName) + 1) * sizeof(WCHAR);
    memcpy( ResumeBuffer + sizeof(VendorId), BootName, BootSize);
    (VOID)ResumeKeySet( pSession, (DWORD)ServerHandle, ResumeBuffer, BootSize+sizeof(VendorId), pResumeHandle);
}


DWORD BootFilterFind(
    IN      PRPL_SESSION    pSession,
    IN OUT  PRPL_FILTER     pFilter,
    IN OUT  PBOOL           pTableEnd
    )
/*++
    Returns name of the the first/next BOOT structure supporting a given
    VendorId.
    The "first" BOOT does not have to be absolutely first, but first behind
    the BOOT specified by RPL_FILTER.
    In case such BOOT structure cannot be found, returns some kind of error.

Arguments:

    pFilter         -   pointer to RPL_FILTER structure with the following fields
        FindFirst       :   find first (TRUE) or find next (FALSE)
        VendorId        :   vendor id to be suppored (input only)
        BootName        :   buffer large enough to hold the longest
                                BootName string.  When input value of
                                BootNameSize is non-zero, this contains the
                                previous value of BootName string.
                            output value is NOT valid if error or end of table
        BootNameSize    :  at input this contains the size of the previous
                                BootName string.  If this size is zero/non-zero,
                                it means we are looking for the first/next
                                BOOT structure.
                            at output this cotains the size of BootName string
                            output value is NOT valid if error or end of table

    pTableEnd       -   pointer to boolean (input value is FALSE) which will be set
                            to TRUE if we reach end of boot table
-**/
{
    DWORD       CheckVendorId;
    DWORD       DataSize;
    JET_ERR     JetError;

    if ( pFilter->FindFirst == FALSE) {
        JetError = JetMove( pSession->SesId, pSession->BootTableId, JET_MoveNext, 0);
        if ( JetError != JET_errSuccess) {
            if ( JetError == JET_errNoCurrentRecord) {
                RplDump( RG_DebugLevel & RPL_DEBUG_BOOT, ("JetError=%d", JetError));
            } else {
                RplDump( ++RG_Assert, ("JetError=%d", JetError));
            }
            goto cleanup;
        }
    } else {
        pFilter->FindFirst = FALSE;
        CallM( JetSetCurrentIndex( pSession->SesId, pSession->BootTableId, BOOT_INDEX_VendorIdBootName));
        CallM( JetMakeKey( pSession->SesId, pSession->BootTableId, &pFilter->VendorId, sizeof( pFilter->VendorId), JET_bitNewKey));
        if ( pFilter->BootNameSize != 0) {
            //
            //  We are continuing the search from the previous BOOT structure.
            //
            CallM( JetMakeKey( pSession->SesId, pSession->BootTableId, pFilter->BootName, pFilter->BootNameSize, 0));
        }
        //
        //  In case of seek errors assume we have reached end of table.
        //
        JetError = JetSeek( pSession->SesId, pSession->BootTableId, JET_bitSeekGT);
        if ( JetError != JET_errSuccess) {
            RplDump( RG_DebugLevel & RPL_DEBUG_BOOT, ("BootFilterFind: Seek(0x%x) => JetError=%d",
                pFilter->VendorId, JetError));
            goto cleanup;
        }
        //
        //  Verify that element we seeked to has the proper vendor id.
        //
        CallM( JetMakeKey( pSession->SesId, pSession->BootTableId, &pFilter->VendorId, sizeof( pFilter->VendorId), JET_bitNewKey));
        JetError = JetSetIndexRange( pSession->SesId, pSession->BootTableId,
                JET_bitRangeInclusive | JET_bitRangeUpperLimit);
        if ( JetError != JET_errSuccess) {
            RplDump( RG_DebugLevel & RPL_DEBUG_BOOT, ("BootFilterFind: SetIndexRange(0x%x) => JetError=%d",
                pFilter->VendorId, JetError));
            goto cleanup;
        }
    }
#ifdef RPL_DEBUG
    CallM( JetRetrieveColumn( pSession->SesId, pSession->BootTableId,
        BootTable[ BOOT_VendorId].ColumnId, &CheckVendorId,
        sizeof( CheckVendorId), &DataSize, 0, NULL));
    if ( CheckVendorId != pFilter->VendorId) {
        RplDump( ++RG_Assert, ( "CheckVendorId=0x%x"));
    }
#endif // RPL_DEBUG
    CallM( JetRetrieveColumn( pSession->SesId, pSession->BootTableId,
        BootTable[ BOOT_BootName].ColumnId, pFilter->BootName,
        RPL_MAX_BOOT_NAME_SIZE, &pFilter->BootNameSize, 0, NULL));
cleanup:
    if ( JetError < 0) {
        *pTableEnd = TRUE;     // pretend it is end of table
    }
    return( NO_ERROR);
}


DWORD BootSetInfo(
    IN      PRPL_SESSION        pSession,
    IN      DWORD               Level,
    IN      LPVOID              Buffer,
    OUT     LPDWORD             pErrorParameter
    )
{
    LPRPL_BOOT_INFO_2         Info = Buffer;
    switch( Level) {
    case 2:
        if ( Info->WindowSize != -1) {
            *pErrorParameter = BOOT_WindowSize;
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_WindowSize].ColumnId,
                &Info->WindowSize, sizeof( Info->WindowSize), 0, NULL));
        }
        if ( Info->BbcFile != NULL) {
            *pErrorParameter = BOOT_BbcFile;
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_BbcFile].ColumnId,
                Info->BbcFile,
                ( wcslen( Info->BbcFile) + 1) * sizeof(WCHAR),
                0, NULL));
        }
        NOTHING;    //  fall through
    case 1:
        if ( Info->VendorName != NULL) {
            DWORD       VendorId;
            *pErrorParameter = BOOT_VendorName;
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_VendorName].ColumnId,
                Info->VendorName,
                ( wcslen( Info->VendorName) + 1) * sizeof(WCHAR),
                0, NULL));
            VendorId = wcstoul( Info->VendorName, NULL, 16);
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_VendorId].ColumnId,
                &VendorId, sizeof( VendorId), 0, NULL));
        }
        if ( Info->Flags != 0) {
            *pErrorParameter = BOOT_Flags;
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_Flags].ColumnId,
                &Info->Flags, sizeof( Info->Flags), 0, NULL));
        }
        NOTHING;    //  fall through
    case 0:
        if ( Info->BootComment != NULL) {
            *pErrorParameter = BOOT_BootComment;
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_BootComment].ColumnId,
                Info->BootComment,
                ( wcslen( Info->BootComment) + 1) * sizeof(WCHAR),
                0, NULL));
        }
        if ( Info->BootName != NULL) {
            *pErrorParameter = BOOT_BootName;
            CallM( JetSetColumn( pSession->SesId, pSession->BootTableId,
                BootTable[ BOOT_BootName].ColumnId,
                Info->BootName,
                ( wcslen( Info->BootName) + 1) * sizeof(WCHAR),
                0, NULL));
        }
        break;
    }
    return( NO_ERROR);
}


DWORD BootGetInfo(
    IN      PRPL_SESSION        pSession,
    OUT     PDWORD              pVendorId,
    IN      DWORD               Level,
    OUT     LPVOID              Buffer,
    IN OUT  PINT                pSpaceLeft
    )
{
    DWORD                   Error;
    DWORD                   WhoCares;
    LPRPL_BOOT_INFO_2       Info = Buffer;

    switch( Level) {
    case 2:
        Error = BootGetField( pSession, BOOT_WindowSize, (LPVOID *)&Info->WindowSize, pSpaceLeft);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        Error = BootGetField( pSession, BOOT_BbcFile, &Info->BbcFile, pSpaceLeft);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        NOTHING;    //  fall through
    case 1:
        Error = BootGetField( pSession, BOOT_Flags, (LPVOID *)&Info->Flags, pSpaceLeft);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        Error = BootGetField( pSession, BOOT_VendorName, &Info->VendorName, pSpaceLeft);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        NOTHING;    //  fall through
    case 0:
        Error = BootGetField( pSession, BOOT_BootComment, &Info->BootComment, pSpaceLeft);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        Error = BootGetField( pSession, BOOT_BootName, &Info->BootName, pSpaceLeft);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        Error = BootGetField( pSession, BOOT_VendorId, (LPVOID *)pVendorId, &WhoCares);
        if ( Error != NO_ERROR) {
            return( Error);
        }
        break;
    default:
        return( ERROR_INVALID_LEVEL);
        break;
    }
    return( NO_ERROR);
}



VOID BootGetInfoCleanup(
    IN      DWORD                       Level,
    IN OUT  LPVOID                      Buffer
    )
{
    LPRPL_BOOT_INFO_2     Info = Buffer;

    switch( Level) {
    case 2:
        if ( Info->BbcFile != NULL) {
            MIDL_user_free( Info->BbcFile);
        }
        NOTHING;    //  fall through
    case 1:
        if ( Info->VendorName != NULL) {
            MIDL_user_free( Info->VendorName);
        }
        NOTHING;    //  fall through
    case 0:
        if ( Info->BootComment != NULL) {
            MIDL_user_free( Info->BootComment);
        }
        if ( Info->BootName != NULL) {
            MIDL_user_free( Info->BootName);
        }
        break;
    }
}


NET_API_STATUS NET_API_FUNCTION
NetrRplBootAdd(
    IN      RPL_HANDLE                  ServerHandle,
    IN      DWORD                       Level,
    OUT     LPRPL_BOOT_INFO_STRUCT      BootInfoStruct,
    OUT     LPDWORD                     pErrorParameter      OPTIONAL
    )
{
    LPRPL_BOOT_INFO_2       Info;
    LPVOID                  Buffer;
    DWORD                   Error;
    DWORD                   ErrorParameter;
    DWORD                   VendorId;
    PRPL_SESSION            pSession = &RG_ApiSession;

    ErrorParameter = INVALID_ERROR_PARAMETER;
    Buffer = Info = BootInfoStruct->BootInfo2;

    switch( Level) {
    case 2:
        if ( Info->BbcFile == NULL || RPL_STRING_TOO_LONG( Info->BootComment)) {
            ErrorParameter = BOOT_BbcFile;
            break;
        }
        if ( !ValidHexName( Info->VendorName, RPL_VENDOR_NAME_LENGTH, TRUE)) {
            ErrorParameter = BOOT_VendorName;
            break;
        }
        _wcsupr( Info->VendorName);
        VendorId = wcstoul( Info->VendorName, NULL, 16);
        switch( Info->Flags) {
        case BOOT_FLAGS_FINAL_ACKNOWLEDGMENT_TRUE:
        case BOOT_FLAGS_FINAL_ACKNOWLEDGMENT_FALSE:
            break;
        default:
            ErrorParameter = BOOT_Flags;
            break;
        }
        if ( ErrorParameter != INVALID_ERROR_PARAMETER) {
            break;
        }
        if ( RPL_STRING_TOO_LONG( Info->BootComment)) {
            ErrorParameter = BOOT_BootComment;
            break;
        }
        if ( !ValidName( Info->BootName, RPL_MAX_BOOT_NAME_LENGTH, TRUE)) {
            ErrorParameter = BOOT_BootName;
            break;
        }
        _wcsupr( Info->BootName);
        break;
    default:
        return( ERROR_INVALID_LEVEL);
        break;
    }

    if ( ErrorParameter != INVALID_ERROR_PARAMETER) {
        if ( ARGUMENT_PRESENT( pErrorParameter)) {
            *pErrorParameter = ErrorParameter;
        }
        return( ERROR_INVALID_PARAMETER);
    }

    EnterCriticalSection( &RG_ProtectDatabase);
    Call( JetBeginTransaction( pSession->SesId));

    //
    //  Verify that BootName + VendorId is available in the database.
    //
    if ( BootFind( pSession, Info->BootName, VendorId)) {
        Error = NERR_RplBootNameUnavailable;
        goto cleanup;
    }

    CallJ( JetPrepareUpdate( pSession->SesId, pSession->BootTableId, JET_prepInsert));

    Error = BootSetInfo( pSession, Level, Buffer, &ErrorParameter);
    if ( Error == ERROR_SUCCESS) {
        ErrorParameter = 0;
        CallJ( JetUpdate( pSession->SesId, pSession->BootTableId, NULL, 0, NULL));
    }

cleanup:
    if ( Error == NO_ERROR) {
        Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
    } else {
        Call( JetRollback( pSession->SesId, JET_bitRollbackAll));
    }
    LeaveCriticalSection( &RG_ProtectDatabase);

    if ( Error != ERROR_SUCCESS) {
         if ( ARGUMENT_PRESENT( pErrorParameter)) {
             *pErrorParameter = ErrorParameter;
         }
    }
    return( Error);
}



BOOL BootFind(
    IN      PRPL_SESSION        pSession,
    IN      PWCHAR              BootName,
    IN      DWORD               VendorId
    )
{
    JET_ERR         JetError;
    CallB( JetSetCurrentIndex( pSession->SesId, pSession->BootTableId, BOOT_INDEX_VendorIdBootName));
    CallB( JetMakeKey( pSession->SesId, pSession->BootTableId, &VendorId, sizeof(VendorId), JET_bitNewKey));
    CallB( JetMakeKey( pSession->SesId, pSession->BootTableId, BootName, ( wcslen( BootName) + 1) * sizeof(WCHAR), 0));
    JetError = JetSeek( pSession->SesId, pSession->BootTableId, JET_bitSeekEQ);
    if ( JetError < 0) {
#ifdef RPL_DEBUG
        //
        //  JET_errNoCurrentRecord will be returned in case of empty table.
        //
        if ( JetError != JET_errRecordNotFound
                &&  JetError != JET_errNoCurrentRecord) {
            RplDump( ++RG_Assert, ("JetError=%d", JetError));
        }
#endif
        return( FALSE);
    }
    return( TRUE);
}


NET_API_STATUS NET_API_FUNCTION
NetrRplBootDel(
    IN      RPL_HANDLE      ServerHandle,
    IN      LPWSTR          BootName,
    IN      LPWSTR          VendorName
    )
/*++
    If VendorName is NULL we should delete all records with input BootName.
    But for now we insist on valid input for VendorName.
--*/
{
    DWORD                   Error;
    DWORD                   VendorId;
    PRPL_SESSION            pSession = &RG_ApiSession;

    if ( !ValidName( BootName, RPL_MAX_BOOT_NAME_LENGTH, TRUE)) {
        return( ERROR_INVALID_PARAMETER);
    }
    _wcsupr( BootName);
    if ( !ValidHexName( VendorName, RPL_VENDOR_NAME_LENGTH, TRUE)) {
        return( ERROR_INVALID_PARAMETER);
    }
    VendorId = wcstoul( VendorName, NULL, 16);

    EnterCriticalSection( &RG_ProtectDatabase);
    Call( JetBeginTransaction( pSession->SesId));

    if ( RplFindByField( pSession, CONFIG_TABLE_TAG,
            CONFIG_INDEX_BootNameConfigName, BootName)) {
        //
        //  We found a CONFIG record which uses this BOOT.
        //
        Error = NERR_RplBootInUse;
        goto cleanup;
    }
    if ( RplFindByField( pSession, PROFILE_TABLE_TAG,
            PROFILE_INDEX_BootNameProfileName, BootName)) {
        //
        //  We found a PROFILE record which uses this BOOT.
        //
        Error = NERR_RplBootInUse;
        goto cleanup;
    }
    if ( RplFindByField( pSession, WKSTA_TABLE_TAG,
            WKSTA_INDEX_BootNameWkstaName, BootName)) {
        //
        //  We found a WKSTA record which uses this BOOT.
        //
        Error = NERR_RplBootInUse;
        goto cleanup;
    }
    if ( !BootFind( pSession, BootName, VendorId)) {
        Error = NERR_RplBootNotFound;
        goto cleanup;
    }
    CallJ( JetDelete( pSession->SesId, pSession->BootTableId));
    Error = NO_ERROR;

cleanup:
    if ( Error == NO_ERROR) {
        Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
    } else {
        Call( JetRollback( pSession->SesId, JET_bitRollbackAll));
    }
    LeaveCriticalSection( &RG_ProtectDatabase);
    return( Error);
}


NET_API_STATUS NET_API_FUNCTION
NetrRplBootEnum(
    IN      RPL_RPC_HANDLE      ServerHandle,
    IN OUT  LPRPL_BOOT_ENUM     BootEnum,
    IN      DWORD               PrefMaxLength,
    OUT     LPDWORD             TotalEntries,
    IN OUT  LPDWORD             pResumeHandle        OPTIONAL
    )
/*++

Routine Description:

Arguments:

    pServerHandle - ptr to RPL_HANDLE

    InfoStruct - Pointer to a structure that contains the information that
        RPC needs about the returned data.  This structure contains the
        following information:
            Level - The desired information level - indicates how to
                interpret the structure of the returned buffer.
            EntriesRead - Indicates how many elements are returned in the
                 array of structures that are returned.
            BufferPointer - Location for the pointer to the array of
                 structures that are being returned.

    PrefMaxLen - Indicates a maximum size limit that the caller will allow
        for (the return buffer.

    TotalEntries - Pointer to a value that upon return indicates the total
        number of entries in the "active" database.

    pResumeHandle - Inidcates where to restart the enumeration.  This is an
        optional parameter and can be NULL.

Return Value:
    NO_ERROR if success.

--*/
{
    LPBYTE                  Buffer;
    DWORD                   TypicalSize;
    DWORD                   CoreSize;
    DWORD                   Error;
    INT                     SpaceLeft;
    DWORD                   ArrayLength;
    DWORD                   EntriesRead;
    JET_ERR                 JetError;
    BOOL                    InfoError;
    BOOL                    TableEnd;
    DWORD                   VendorId;
    PRPL_SESSION            pSession = &RG_ApiSession;

    switch( BootEnum->Level) {
    case 2:
        TypicalSize = CoreSize = sizeof( RPL_BOOT_INFO_2);
        TypicalSize += 40 * sizeof( WCHAR); //  typical size of BbcFile
        NOTHING;    //  fall through
    case 1:
        if ( BootEnum->Level == 1) {
            TypicalSize = CoreSize = sizeof( RPL_BOOT_INFO_1);
        }
        TypicalSize +=  8 * sizeof( WCHAR); //  typical size of VendorName
        NOTHING;    //  fall through
    case 0:
        if ( BootEnum->Level == 0) {
            TypicalSize = CoreSize = sizeof( RPL_BOOT_INFO_0);
        }
        TypicalSize += 20 * sizeof( WCHAR); //  typical size of BootComment
        TypicalSize +=  8 * sizeof( WCHAR); //  typical size of BootName
        break;
    default:
        return( ERROR_INVALID_LEVEL);
        break;
    }

    if ( PrefMaxLength == -1) {
        //
        //  If the caller has not specified a size, calculate a size
        //  that will hold the entire enumeration.
        //
        SpaceLeft = DEFAULT_BUFFER_SIZE;
    } else {
        SpaceLeft = PrefMaxLength;
    }

    //
    //  Buffer space is shared by the array and by strings pointed at
    //  by the elements in this array.  We need to decide up front how much
    //  space is allocated for array and how much for the strings.
    //
    ArrayLength = SpaceLeft / TypicalSize;
    if ( ArrayLength == 0) {
        ArrayLength = 1;    //  try to return at least one element
    }

    //
    //  Note that MIDL_user_allocate() returns memory which is NOT initialized
    //  to zero.  Since we do NOT use allocate all nodes, this means that all
    //  fields, especially pointers, in array elements must be properly set.
    //
    Buffer = MIDL_user_allocate( ArrayLength * CoreSize);
    if ( Buffer == NULL) {
        return( ERROR_NOT_ENOUGH_MEMORY);
    }
    RplDump( RG_DebugLevel & RPL_DEBUG_BOOT, (
        "BootEnum: Buffer=0x%x, ArrayLength=0x%x", Buffer, ArrayLength));

    BootEnum->BootInfo.Level0->Buffer = (LPRPL_BOOT_INFO_0)Buffer;

    EntriesRead = 0;
    InfoError = FALSE;
    Error = NO_ERROR;

    EnterCriticalSection( &RG_ProtectDatabase);
    Call( JetBeginTransaction( pSession->SesId));

    if ( !BootResumeFirst( pSession, pResumeHandle, &TableEnd)) {
        Error = NERR_RplCannotEnum;
        goto cleanup;
    }
    if ( TableEnd == TRUE) {
        goto cleanup;
    }
    for ( ; ; ) {
        memset( Buffer, 0, CoreSize); // for cleanup to work properly
        Error = BootGetInfo( pSession, &VendorId, BootEnum->Level, Buffer, &SpaceLeft);
        if ( Error != NO_ERROR) {
            InfoError = TRUE;   //  clean things up without holding crit sec
            break;
        }
        EntriesRead++;
        Buffer += CoreSize;
        SpaceLeft -= CoreSize;
        JetError = JetMove( pSession->SesId, pSession->BootTableId, JET_MoveNext, 0);
        if ( JetError != JET_errSuccess) {
            break; // assume end of table
        }
        if ( SpaceLeft <= 0) {
            Error = ERROR_MORE_DATA;
            break;
        }
        if ( EntriesRead >= ArrayLength) {
            //
            //  We have space available but allocated array is not big enough.
            //  This should NOT happen often as our intent (see above) is to
            //  overestimate array length.  When it happens we can still try
            //  to reallocate array to a larger size here.  This is not done
            //  for now (too cumbersome) & we just stop the enumeration.
            //
            Error = ERROR_MORE_DATA;
            break;
        }
    }
cleanup:
    Call( JetCommitTransaction( pSession->SesId, 0));
    LeaveCriticalSection( &RG_ProtectDatabase);
    if ( InfoError == TRUE) {
        BootGetInfoCleanup( BootEnum->Level, Buffer);
    }
    if ( Error == NO_ERROR) {
        *TotalEntries = EntriesRead;
    } else if ( Error == ERROR_MORE_DATA) {
        *TotalEntries = EntriesRead * 2;    //  we cheat here
    } else {
        //
        //  Cleanup in case of "bad" errors.
        //
        while ( EntriesRead > 0) {
            EntriesRead--;
            Buffer -= CoreSize;
            BootGetInfoCleanup( BootEnum->Level, Buffer);
        }
        MIDL_user_free( Buffer);
    }

    RplDump( RG_DebugLevel & RPL_DEBUG_BOOT, ("BootEnum: EntriesRead = 0x%x", EntriesRead));

    BootEnum->BootInfo.Level0->EntriesRead = EntriesRead;
    if ( EntriesRead == 0) {
        BootEnum->BootInfo.Level0->Buffer = NULL;
    }

    if ( ARGUMENT_PRESENT( pResumeHandle)) {
        if ( Error == ERROR_MORE_DATA  &&  EntriesRead > 0) {
            EnterCriticalSection( &RG_ProtectDatabase);
            Call( JetBeginTransaction( pSession->SesId));
            BootResumeSave( pSession, (DWORD)ServerHandle, VendorId,
                ((LPRPL_BOOT_INFO_0)(Buffer-CoreSize))->BootName,
                pResumeHandle);
            Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
            LeaveCriticalSection( &RG_ProtectDatabase);
        } else {
            *pResumeHandle = 0; // resume from beginning
        }
    }
    return( Error);
}