windows-server-2003/termsrv/license/tlserver/server/db.cpp

//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1996-1998
//
// File:        db.cpp
//
// Contents:    
//              all routine deal with cross table query
//
// History:     
//  Feb 4, 98      HueiWang    Created
//---------------------------------------------------------------------------
#include "pch.cpp"
#include "globals.h"
#include "db.h"
#include "clilic.h"
#include "keypack.h"
#include "kp.h"
#include "lkpdesc.h"
#include "postjob.h"

#define STRSAFE_NO_DEPRECATE
#include <strsafe.h>

/****************************************************************************
Function:
    LSDBValidateLicense()

Description:
    Routine to validate license agaist database, must call LSDecodeLicense()
    to convert hydra license to LICENSEREQUEST structure.

Arguments:
    IN CSQLStmt* - SQL Statement handle to use
    IN PLICENSEREQUEST - License in the form of LICENSEREQUEST structure
    IN dwKeyPackId - KeyPack table's ID that is license is issued from
    IN dwLicenseId - License tables's License ID 
    OUT LPKEYPACK - KeyPack record this license is issued from, NULL if not
                      interested in this value.
    OUT LPLICENSE - Corresponding license record for this license, NULL if
                      not interest in this value.

Returns:
    ERROR_SUCCESS
    TLS_E_INVALID_LICENSE
    TLS_E_INTERNAL
    ODBC error.
****************************************************************************/
DWORD
TLSDBValidateLicense(
    PTLSDbWorkSpace      pDbWkSpace,
    //IN PBYTE             pbLicense,
    //IN DWORD             cbLicense,
    IN PHWID             phWid,
    IN PLICENSEREQUEST   pLicensedProduct,
    IN DWORD             dwKeyPackId, 
    IN DWORD             dwLicenseId,
    OUT PTLSLICENSEPACK   lpKeyPack,
    OUT LPLICENSEDCLIENT  lpLicense
    )
/*

*/
{
    DWORD dwStatus=ERROR_SUCCESS;
    DWORD dwMatchCount=0;

    if(pDbWkSpace == NULL)
    {
        SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
        TLSASSERT(FALSE);
        return dwStatus;
    }

    TLSLICENSEPACK keypack_search;
    TLSLICENSEPACK keypack_found;

    LICENSEDCLIENT license_search;
    LICENSEDCLIENT license_found;
    int count=0;
    BOOL bValid=TRUE;

    memset(&license_search, 0, sizeof(LICENSEDCLIENT));
    memset(&license_found, 0, sizeof(LICENSEDCLIENT));
    keypack_found.pbDomainSid = NULL;

    license_search.dwLicenseId = dwLicenseId;
    dwStatus = TLSDBLicenseEnumBegin(
                        pDbWkSpace,
                        TRUE,
                        LSLICENSE_SEARCH_LICENSEID,
                        &license_search
                    );

    if(dwStatus != ERROR_SUCCESS)
    {
        if(IS_JB_ERROR(dwStatus) != TRUE)
        {
            SetLastError(dwStatus = TLS_E_INVALID_LICENSE);
        }

        goto cleanup;
    }

    do
    {
        dwStatus=TLSDBLicenseEnumNext(
                                pDbWkSpace, 
                                &license_found
                            );

        if(dwStatus != ERROR_SUCCESS)
            break;

        count++;
    } while(count < 1);

    TLSDBLicenseEnumEnd(pDbWkSpace);

    if(count != 1)
    {
        // can't find the license
        SetLastError(dwStatus = TLS_E_INVALID_LICENSE);
        goto cleanup;
    }

    if(count > 1)
    {
        // more than one entry in database has identical
        // license id
        SetLastError(dwStatus = TLS_E_INTERNAL);
        goto cleanup;
    }

    //
    // Not issue by this license server???
    //
    if(license_found.dwKeyPackId != dwKeyPackId)
    {
        SetLastError(dwStatus = TLS_E_INVALID_LICENSE);
        goto cleanup;
    }

    //
    // new license request might pass different HWID
    //
    dwMatchCount += (int)(license_found.dwSystemBiosChkSum == phWid->dwPlatformID);
    dwMatchCount += (int)(license_found.dwVideoBiosChkSum == phWid->Data1);
    dwMatchCount += (int)(license_found.dwFloppyBiosChkSum == phWid->Data2);
    dwMatchCount += (int)(license_found.dwHardDiskSize == phWid->Data3);
    dwMatchCount += (int)(license_found.dwRamSize == phWid->Data4);

    if(dwMatchCount < LICENSE_MIN_MATCH)
    {
        SetLastError(dwStatus = TLS_E_INVALID_LICENSE);
    }

    //
    // Verify against KeyPack Table
    //
    memset(&keypack_search, 0, sizeof(keypack_search));
    keypack_search.dwKeyPackId = dwKeyPackId;

    dwStatus = TLSDBKeyPackFind(
                            pDbWkSpace,
                            TRUE,
                            LSKEYPACK_EXSEARCH_DWINTERNAL,
                            &keypack_search,
                            &keypack_found
                        );

    if(dwStatus != ERROR_SUCCESS)
    {
        if(IS_JB_ERROR(dwStatus) != TRUE)
        {
            SetLastError(dwStatus = TLS_E_INVALID_LICENSE);
        }

        goto cleanup;
    }

    // match KeyPack's Product ID, Version, Language ID, PlatformID
    // structure change, no more product version.
    if(pLicensedProduct->dwPlatformID != keypack_found.dwPlatformType ||
       _tcsicmp((LPTSTR)pLicensedProduct->pProductInfo->pbCompanyName, keypack_found.szCompanyName) ||
       _tcsicmp((LPTSTR)pLicensedProduct->pProductInfo->pbProductID, keypack_found.szProductId) )
    {
        SetLastError(dwStatus = TLS_E_INVALID_LICENSE);
    }

cleanup:

    //FreeTlsLicensePack(&keypack_found);

    if(dwStatus == ERROR_SUCCESS)
    {
        if(lpKeyPack)
        {
            *lpKeyPack = keypack_found;
        }

        if(lpLicense)
        {
            *lpLicense = license_found;
        }
    }

    return dwStatus;
}

/*************************************************************************
Function:
    LSDBDeleteLicense()

*************************************************************************/
DWORD 
TLSDBDeleteLicense(
    PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPackId, 
    DWORD dwLicenseId
    )
/*
*/
{
    // TODO - license entry base on license id
    // 1) Return license back to key pack
    // 2) 'Physically' delete the license.

    return ERROR_SUCCESS;
}

/*************************************************************************
Function:
    LSDBRevokeLicense()

*************************************************************************/
DWORD 
TLSDBRevokeLicense(
    PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPacKId, 
    IN DWORD dwLicenseId
)
{
    // Set License Status to revoked
    // Return License to KeyPack

    // call LSDBDeleteKeyPack() and if not successful, insert into RevokeLicenseTable
    return ERROR_SUCCESS;
}

/*************************************************************************
Function:
    LSDBReturnLicense()

*************************************************************************/
DWORD 
TLSDBReturnLicense(
    PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPackId, 
    IN DWORD dwLicenseId,
    IN DWORD dwNewLicenseStatus
    )
/*
*/
{
    DWORD dwStatus=ERROR_SUCCESS;
    DWORD dwQuantity = 1;

    TLSDBLockKeyPackTable();
    TLSDBLockLicenseTable();

    //
    // no verification on record got updated.
    //
    LICENSEDCLIENT license;
    license.dwLicenseId = dwLicenseId;
    license.ucLicenseStatus = dwNewLicenseStatus;

    //
    // use undocumented feature to delete license
    //
    DBGPrintf(
            DBG_INFORMATION,
            DBG_FACILITY_RETURN,
            DBGLEVEL_FUNCTION_DETAILSIMPLE,
            _TEXT("Deleting license ID %d issued by keypack %d\n"),
            license.dwLicenseId,
            dwKeyPackId
        );

    if (dwNewLicenseStatus == LSLICENSESTATUS_DELETE)
    {
        // get number of CALs in this license

        LICENSEDCLIENT licenseFound;

        dwStatus = TLSDBLicenseFind(
                        pDbWkSpace,
                        TRUE,
                        LSLICENSE_SEARCH_LICENSEID,
                        &license,
                        &licenseFound
                        );

        if(dwStatus == ERROR_SUCCESS)
        {
            dwQuantity = licenseFound.dwNumLicenses;
        }
    }

    dwStatus = TLSDBLicenseSetValue(
                        pDbWkSpace, 
                        LSLICENSE_EXSEARCH_LICENSESTATUS, 
                        &license,
                        FALSE
                    );

    if(dwStatus == ERROR_SUCCESS && dwNewLicenseStatus == LSLICENSESTATUS_DELETE)
    {
        dwStatus = TLSDBReturnLicenseToKeyPack(
                                    pDbWkSpace, 
                                    dwKeyPackId, 
                                    dwQuantity
                                );
    }

    TLSDBUnlockLicenseTable();
    TLSDBUnlockKeyPackTable();
    return dwStatus;
}


/*************************************************************************
Function:
    LSDBReturnLicenseToKeyPack()
*************************************************************************/
DWORD 
TLSDBReturnLicenseToKeyPack(
    IN PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPackId, 
    IN int dwNumLicense
    )
{
    DWORD dwStatus = ERROR_SUCCESS;
    TLSDBLockKeyPackTable();

    #ifdef DBG
    DWORD dwPrevNumLicense=0;
    #endif

    TLSLICENSEPACK found;
    TLSLICENSEPACK search;

    found.pbDomainSid = NULL;

    do {

        // retrieve number of licenses
        search.dwKeyPackId = dwKeyPackId;
        dwStatus = TLSDBKeyPackFind(
                            pDbWkSpace,
                            TRUE,
                            LSKEYPACK_EXSEARCH_DWINTERNAL,
                            &search,
                            &found
                        );

        if(dwStatus != ERROR_SUCCESS)
        {
            if(IS_JB_ERROR(dwStatus) == FALSE)
            {
                SetLastError(dwStatus = TLS_E_RECORD_NOTFOUND);
            }
            break;
        }

        if(search.dwKeyPackId != found.dwKeyPackId)
        {
            TLSASSERT(FALSE);
        }

        #ifdef DBG
        dwPrevNumLicense = found.dwNumberOfLicenses;
        #endif

        // set the number of licenses issued by 1
        switch( (found.ucAgreementType & ~LSKEYPACK_RESERVED_TYPE) )
        {
            case LSKEYPACKTYPE_RETAIL:
            case LSKEYPACKTYPE_OPEN:
            case LSKEYPACKTYPE_SELECT:
                // number of licenses available
                if (found.dwNumberOfLicenses + dwNumLicense <= found.dwTotalLicenseInKeyPack)
                {
                    found.dwNumberOfLicenses += dwNumLicense;
                    dwNumLicense = 0;
                }
                else
                {
                    DWORD dwRet = found.dwTotalLicenseInKeyPack - found.dwNumberOfLicenses;
                    found.dwNumberOfLicenses = found.dwTotalLicenseInKeyPack;
                    dwNumLicense -= dwRet;
                }
                break;

            case LSKEYPACKTYPE_FREE:
            case LSKEYPACKTYPE_TEMPORARY:
                // number of license issued
                if(found.dwNumberOfLicenses > 0)
                {
                    found.dwNumberOfLicenses -= dwNumLicense;
                    dwNumLicense = 0;
                }
                break;

            default:
                SetLastError(dwStatus = TLS_E_CORRUPT_DATABASE);
                break;
        }
    
        #ifdef DBG
        DBGPrintf(
                DBG_INFORMATION,
                DBG_FACILITY_RETURN,
                DBGLEVEL_FUNCTION_DETAILSIMPLE,
                _TEXT("Returning license to keypack %d - from %d to %d\n"),
                found.dwKeyPackId,
                dwPrevNumLicense,
                found.dwNumberOfLicenses
            );
        #endif

        //
        // use undocumented feature to delete temp. keypack
        if( (found.ucAgreementType & ~LSKEYPACK_RESERVED_TYPE) == LSKEYPACKTYPE_TEMPORARY && 
            found.dwNumberOfLicenses == 0)
        {
            found.ucKeyPackStatus = LSKEYPACKSTATUS_DELETE;
            
            // delete keypack desc table
            LICPACKDESC keyPackDesc;

            memset(&keyPackDesc, 0, sizeof(LICPACKDESC));
            keyPackDesc.dwKeyPackId = found.dwKeyPackId;
            TLSDBKeyPackDescSetValue(
                                pDbWkSpace, 
                                KEYPACKDESC_SET_DELETE_ENTRY, 
                                &keyPackDesc
                            );
        }

        dwStatus=TLSDBKeyPackSetValues(
                            pDbWkSpace, 
                            TRUE, 
                            LSKEYPACK_EXSEARCH_AVAILABLE, 
                            &found
                        );
    } while(FALSE);

    if ((dwStatus == ERROR_SUCCESS) && (dwNumLicense > 0))
    {
        // next, find more keypacks of the same type to return licenses to
        // ignore any error

        TLSDBReturnLicenseToAnyKeyPack(
                        pDbWkSpace,
                        found.szProductId,
                        found.wMajorVersion,
                        found.wMinorVersion,
                        dwKeyPackId,
                        dwNumLicense);


    }

    TLSDBUnlockKeyPackTable();

    return dwStatus;
}


/*************************************************************************
Function:
    TLSDBReturnLicenseToAnyKeyPack()
*************************************************************************/
DWORD 
TLSDBReturnLicenseToAnyKeyPack(
    IN PTLSDbWorkSpace pDbWkSpace,
    IN TCHAR *szProductId,
    IN WORD wMajorVersion,
    IN WORD wMinorVersion,
    IN DWORD dwKeyPackIdSkip,
    IN int dwNumLicense
    )
{
    DWORD dwStatus = ERROR_SUCCESS;

    TLSLICENSEPACK found;
    TLSLICENSEPACK search;

    SAFESTRCPY(search.szProductId,szProductId);

    dwStatus = TLSDBKeyPackEnumBegin(pDbWkSpace,
                                     TRUE,      // bMatchAll
                                     LSKEYPACK_SEARCH_PRODUCTID,
                                     &search
                                     );

    if(dwStatus != ERROR_SUCCESS)
    {
        goto cleanup;
    }

    while ((dwNumLicense > 0)
           && ((dwStatus = TLSDBKeyPackEnumNext(pDbWkSpace, &found))
               == ERROR_SUCCESS))
    {
        if (found.dwKeyPackId == dwKeyPackIdSkip)
            continue;

        if (found.wMajorVersion != wMajorVersion)
            continue;

        if (found.wMinorVersion != wMinorVersion)
            continue;

        if (found.ucAgreementType & LSKEYPACK_REMOTE_TYPE)
            continue;

        if (found.ucKeyPackStatus & LSKEYPACKSTATUS_REMOTE)
            continue;

        UCHAR ucKeyPackStatus = found.ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED;

        if(ucKeyPackStatus == LSKEYPACKSTATUS_UNKNOWN
           || ucKeyPackStatus == LSKEYPACKSTATUS_RETURNED
           || ucKeyPackStatus == LSKEYPACKSTATUS_REVOKED
           || ucKeyPackStatus == LSKEYPACKSTATUS_OTHERS)
            continue;

        if (found.dwNumberOfLicenses == found.dwTotalLicenseInKeyPack)
            continue;

        UCHAR ucAgreementType = found.ucAgreementType & ~LSKEYPACK_RESERVED_TYPE;

        if (ucAgreementType != LSKEYPACKTYPE_RETAIL
            && ucAgreementType != LSKEYPACKTYPE_OPEN
            && ucAgreementType != LSKEYPACKTYPE_SELECT)
            continue;

        if (_tcsicmp(found.szProductId, szProductId) != 0)
            continue;

        // number of licenses available
        if (found.dwNumberOfLicenses + dwNumLicense <= found.dwTotalLicenseInKeyPack)
        {
            found.dwNumberOfLicenses += dwNumLicense;

            dwStatus=TLSDBKeyPackSetValues(
                            pDbWkSpace, 
                            TRUE, 
                            LSKEYPACK_EXSEARCH_AVAILABLE, 
                            &found
                            );

            if (ERROR_SUCCESS == dwStatus)
            {
                dwNumLicense = 0;
            }
        }
        else
        {
            DWORD dwRet = found.dwTotalLicenseInKeyPack - found.dwNumberOfLicenses;
            found.dwNumberOfLicenses = found.dwTotalLicenseInKeyPack;

            dwStatus=TLSDBKeyPackSetValues(
                            pDbWkSpace, 
                            TRUE, 
                            LSKEYPACK_EXSEARCH_AVAILABLE, 
                            &found
                            );

            if (ERROR_SUCCESS == dwStatus)
            {
                dwNumLicense -= dwRet;
            }
        }
    }

    TLSDBKeyPackEnumEnd(pDbWkSpace);

cleanup:
    return dwStatus;
}

/*************************************************************************
Function:
    LSDBRevokeKeyPack()

*************************************************************************/
DWORD 
TLSDBRevokeKeyPack(
    IN PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPackId
    )
{
    // Set Key Pack Status to Revoke
    // Insert this key pack into RevokeKeyPackTable ???
    return ERROR_SUCCESS;
}

/*************************************************************************
Function:
    LSDBReturnKeyPack()

*************************************************************************/
DWORD 
TLSDBReturnKeyPack(
    IN PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPackId
    )
{
    // Same as RevokeKeyPack except status is return
    // Delete Key pack only when all license has been returned.
    return ERROR_SUCCESS;
}

/*************************************************************************
Function:
    LSDBDeleteKeyPack()

*************************************************************************/
DWORD 
TLSDBDeleteKeyPack(
    PTLSDbWorkSpace pDbWkSpace,
    IN DWORD dwKeyPackId
    )
{
    // Delete Only when all license has been returned.
    return ERROR_SUCCESS;
}


//+------------------------------------------------------------------------
//  Function: 
//      AllocateLicenses()
//
//  Description:
//      Allocate license from key Pack
//
//  Arguments:
//      IN lpSqlStmt - sql statement handle
//      IN ucKeyPackType - key pack type to allocate license from
//      IN szCompanyName - Product Company
//      IN szProductId - Product Name
//      IN dwVersion - Product Version
//      IN dwPlatformId - Product PlatformId
//      IN dwLangId - Product Lanugage Id
//      IN OUT lpdwNumLicense - number of license to be allocated and on
//                              return, number of licenses actually allocated
//      IN bufSize - number of interested keypack that has requested license
//      IN OUT lpAllocationVector - number of license allocated from list of 
//                                  key pack that has requested licenses.
//      IN OUT LPKEYPACK - key Pack that license was allocated from
//
//  Returns:
//      TLS_E_INVALID_DATA      Invalid parameter
//      TLS_I_NO_MORE_DATA      No key pack has the requested license
//
//  Notes:
//      To keep code clean/simple, call ReturnLicenses() for returning 
//      licenses
//-------------------------------------------------------------------------
DWORD
VerifyTLSDBAllocateRequest(
    IN PTLSDBAllocateRequest pRequest 
    )
/*
*/
{
    DWORD dwStatus = ERROR_SUCCESS;
    UCHAR ucAgreementType;

    if(pRequest == NULL)
    {
        SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
        goto cleanup;
    }

    ucAgreementType = (pRequest->ucAgreementType & ~LSKEYPACK_RESERVED_TYPE);

    if(ucAgreementType < LSKEYPACKTYPE_FIRST || ucAgreementType > LSKEYPACKTYPE_LAST)
    {
        DBGPrintf(
                DBG_ERROR,
                DBGLEVEL_FUNCTION_DETAILSIMPLE, 
                DBG_ALL_LEVEL,
                _TEXT("AllocateLicenses() invalid keypack type - %d\n"),
                pRequest->ucAgreementType
            );
        SetLastError(dwStatus = TLS_E_INVALID_DATA);
        goto cleanup;
    }

    if(pRequest->szCompanyName == NULL || _tcslen(pRequest->szCompanyName) == 0)
    {
        DBGPrintf(
                DBG_ERROR,
                DBGLEVEL_FUNCTION_DETAILSIMPLE, 
                DBG_ALL_LEVEL,
                _TEXT("AllocateLicenses() invalid company name\n")
            );
        SetLastError(dwStatus = TLS_E_INVALID_DATA);
        goto cleanup;
    }

    if(pRequest->szProductId == NULL || _tcslen(pRequest->szProductId) == 0)
    {
        DBGPrintf(
                DBG_ERROR,
                DBGLEVEL_FUNCTION_DETAILSIMPLE, 
                DBG_ALL_LEVEL,
                _TEXT("AllocateLicenses() invalid product id\n")
            );
        SetLastError(dwStatus = TLS_E_INVALID_DATA);
    }

cleanup:
    return dwStatus;
}
//----------------------------------------------------------------------

DWORD
AllocateLicensesFromDB(
    IN PTLSDbWorkSpace pDbWkSpace,
    IN PTLSDBAllocateRequest pRequest,
    IN BOOL fCheckAgreementType,
    IN OUT PTLSDBLicenseAllocation pAllocated
    )
/*
*/
{
    DWORD status=ERROR_SUCCESS;

    if(pDbWkSpace == NULL || pRequest == NULL || pAllocated == NULL)
    {
        DBGPrintf(
                DBG_ERROR,
                DBGLEVEL_FUNCTION_DETAILSIMPLE, 
                DBG_ALL_LEVEL,
                _TEXT("pDbWkSpace is NULL...\n")
            );

        SetLastError(status = ERROR_INVALID_PARAMETER);
        TLSASSERT(FALSE);
        return status;
    }

    status = VerifyTLSDBAllocateRequest(pRequest);
    if(status != ERROR_SUCCESS)
        return status;

    if(pAllocated->dwBufSize <= 0)
    {
        DBGPrintf(
                DBG_ERROR,
                DBG_FACILITY_ALLOCATELICENSE, 
                DBGLEVEL_FUNCTION_DETAILSIMPLE,
                _TEXT("AllocateLicenses() invalid return buffer size\n")
            );
        SetLastError(status = TLS_E_INVALID_DATA);
        return status;
    }

    #ifdef DBG
    DWORD dwPrevNumLicense;
    #endif

    BOOL bProductInstalled=FALSE;
    DWORD bufIndex=0;
    TLSLICENSEPACK keypack_search;
    TLSLICENSEPACK keypack_found;

    DWORD dwNumLicenses = pRequest->dwNumLicenses;          // number of license wanted/returned
    DWORD dwTotalAllocated=0;

    memset(&keypack_search, 0, sizeof(keypack_search));
    memset(&keypack_found, 0, sizeof(keypack_found));

    keypack_search.ucAgreementType = pRequest->ucAgreementType;
    StringCbCopy(keypack_search.szCompanyName, sizeof(keypack_search.szCompanyName), pRequest->szCompanyName);
    StringCbCopy(keypack_search.szProductId, sizeof(keypack_search.szProductId), pRequest->szProductId);
    keypack_search.wMajorVersion = HIWORD(pRequest->dwVersion);
    keypack_search.wMinorVersion = LOWORD(pRequest->dwVersion);
    keypack_search.dwPlatformType = pRequest->dwPlatformId;

    LicPackTable& licpack_table=pDbWkSpace->m_LicPackTable;
    time_t current_time=time(NULL);

    //
    // Lock Key Pack table
    // Only update requires locking, read might get in-correct value.
    //

    //
    // Only allow one thread to enter - Jet not fast enough in updating entry
    //
    TLSDBLockKeyPackTable();

    status = TLSDBKeyPackEnumBegin(
                            pDbWkSpace, 
                            TRUE,
                            LSKEYPACK_SEARCH_PRODUCTID | (fCheckAgreementType ? LICENSEDPACK_FIND_LICENSEPACK : 0),
                            &keypack_search
                        );

    if(status != ERROR_SUCCESS)
        goto cleanup;


    while(status == ERROR_SUCCESS && dwNumLicenses != 0 && bufIndex < pAllocated->dwBufSize)
    {
        status = TLSDBKeyPackEnumNext(
                                pDbWkSpace,
                                &keypack_found
                            );
        if(status != ERROR_SUCCESS)
            break;


        //
        // Skip remote keypack
        //
        if(keypack_found.ucAgreementType & LSKEYPACK_REMOTE_TYPE)
        {
            continue;
        }

        if(keypack_found.ucKeyPackStatus & LSKEYPACKSTATUS_REMOTE)
        {
            continue;
        }

        if(fCheckAgreementType
           && (keypack_found.ucAgreementType != pRequest->ucAgreementType))
        {
            continue;
        }

        UCHAR ucKeyPackStatus = keypack_found.ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED;

        // Allocating licenses
        //
        // Throw away any key pack that has bad status
        // one of the reason why can't returning license in this routine
        // for returning license, we should not care about key pack 
        // status.
        if(ucKeyPackStatus == LSKEYPACKSTATUS_UNKNOWN ||
           ucKeyPackStatus == LSKEYPACKSTATUS_RETURNED ||
           ucKeyPackStatus == LSKEYPACKSTATUS_REVOKED ||
           ucKeyPackStatus == LSKEYPACKSTATUS_OTHERS)
        {
            continue;
        }

        //
        // we find the product, make sure the version is what we want.
        //
        bProductInstalled=TRUE;

        // Expired keypack
        // TODO - update table here.
        if((DWORD)keypack_found.dwExpirationDate < current_time)
           continue;

        //
        // never allocate from older version
        //
        if( keypack_found.wMajorVersion < HIWORD(pRequest->dwVersion) )
        {
            continue;
        }

        //
        // Same major version but older minor
        //
        if( keypack_found.wMajorVersion == HIWORD(pRequest->dwVersion) && 
            keypack_found.wMinorVersion < LOWORD(pRequest->dwVersion) )
        {
            continue;
        }

        if(pRequest->dwScheme == ALLOCATE_EXACT_VERSION)
        {
            if(keypack_found.wMajorVersion != HIWORD(pRequest->dwVersion) ||
               keypack_found.wMinorVersion < LOWORD(pRequest->dwVersion) )
            {
                continue;
            }
        }

        UCHAR ucAgreementType = (keypack_found.ucAgreementType & ~LSKEYPACK_RESERVED_TYPE);

        //
        // Verify number of licenses left
        //
        if((ucAgreementType == LSKEYPACKTYPE_SELECT ||
            ucAgreementType == LSKEYPACKTYPE_RETAIL || 
			ucAgreementType == LSKEYPACKTYPE_OPEN) &&
            keypack_found.dwNumberOfLicenses == 0)
        {
            continue;
        }

        pAllocated->lpAllocateKeyPack[bufIndex] = keypack_found;

        #ifdef DBG
        dwPrevNumLicense = pAllocated->lpAllocateKeyPack[bufIndex].dwNumberOfLicenses;
        #endif

        if( ucAgreementType != LSKEYPACKTYPE_RETAIL && 
		    ucAgreementType != LSKEYPACKTYPE_OPEN &&
            ucAgreementType != LSKEYPACKTYPE_SELECT )
        {
            // For Free/temporary license, number of available license is
            // how many license has been issued
            pAllocated->lpAllocateKeyPack[bufIndex].dwNumberOfLicenses += dwNumLicenses;
            pAllocated->pdwAllocationVector[bufIndex] = dwNumLicenses;

            dwTotalAllocated += dwNumLicenses;
            pAllocated->lpAllocateKeyPack[bufIndex].dwNextSerialNumber += dwNumLicenses;
            dwNumLicenses=0;
        } 
        else 
        {
            int allocated=min(dwNumLicenses, keypack_found.dwNumberOfLicenses);

            pAllocated->lpAllocateKeyPack[bufIndex].dwNumberOfLicenses -= allocated;
            dwNumLicenses -= allocated;
            pAllocated->pdwAllocationVector[bufIndex] = allocated;

            dwTotalAllocated += allocated;
            pAllocated->lpAllocateKeyPack[bufIndex].dwNextSerialNumber += allocated;
        }

        #if DBG
        DBGPrintf(
                DBG_INFORMATION,
                DBG_FACILITY_ALLOCATELICENSE,
                DBGLEVEL_FUNCTION_DETAILSIMPLE,
                _TEXT("Updating keypack %d number of license from %d to %d\n"),
                pAllocated->lpAllocateKeyPack[bufIndex].dwKeyPackId,
                dwPrevNumLicense,
                pAllocated->lpAllocateKeyPack[bufIndex].dwNumberOfLicenses
            );
        #endif

        //
        // Update number of licenses available for this keypack and license id in keypack
        //
        GetSystemTimeAsFileTime(&(pAllocated->lpAllocateKeyPack[bufIndex].ftLastModifyTime));
        if(licpack_table.UpdateRecord(
                            pAllocated->lpAllocateKeyPack[bufIndex],
                            LICENSEDPACK_ALLOCATE_LICENSE_UPDATE_FIELD
                        ) == FALSE)
        {
            SetLastError(status = SET_JB_ERROR(licpack_table.GetLastJetError()));
            TLSASSERT(FALSE);
            break;
        }

        #ifdef DBG
        TLSLICENSEPACK test;

        if(licpack_table.FetchRecord(test) == FALSE)
        {
            SetLastError(status = SET_JB_ERROR(licpack_table.GetLastJetError()));
            TLSASSERT(FALSE);
        }
    
        if(test.dwKeyPackId != pAllocated->lpAllocateKeyPack[bufIndex].dwKeyPackId ||
           test.dwNumberOfLicenses != pAllocated->lpAllocateKeyPack[bufIndex].dwNumberOfLicenses)
        {
            TLSASSERT(FALSE);
        }

        //FreeTlsLicensePack(&test);
        #endif

        bufIndex++;
        }
    //
    // terminate enumeration.
    //
    TLSDBKeyPackEnumEnd(pDbWkSpace);
    if(status == TLS_I_NO_MORE_DATA)
    {
        if(bufIndex != 0)
        {
            status = ERROR_SUCCESS;
        }
        else if(!bProductInstalled)
        {
            SetLastError(status = TLS_E_PRODUCT_NOTINSTALL);
        }
    }

    if(keypack_found.dwNumberOfLicenses == 0)
    {
        TLSAnnounceLKPToAllRemoteServer(keypack_found.dwKeyPackId,0);
    }

    pAllocated->dwBufSize = bufIndex;
    pAllocated->dwTotalAllocated = dwTotalAllocated;   
    pAllocated->dwBufSize = bufIndex;

cleanup:

    TLSDBUnlockKeyPackTable();
    return status;
}