able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/license/tlserver/server/keypack.cpp

1189 lines
28 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1996-1998
//
// File: keypack.cpp
//
// Contents:
// KeyPack Table related function.
//
// History:
// Feb. 4, 98 HueiWang Created.
//---------------------------------------------------------------------------
#include "pch.cpp"
#include "globals.h"
#include "keypack.h"
#include "misc.h"
//++--------------------------------------------------------------------
static BOOL
ValidKeyPackParameter(
IN PTLSLICENSEPACK lpKeyPack,
IN BOOL bAdd
)
/*++
Abstract:
Validate Licese KeyPack value
Parameter:
Returns:
++*/
{
BOOL bValid=FALSE;
UCHAR ucAgreementType = (lpKeyPack->ucAgreementType & ~LSKEYPACK_RESERVED_TYPE);
UCHAR ucKeyPackStatus = (lpKeyPack->ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED);
do {
// verify input parameter
if(ucAgreementType < LSKEYPACKTYPE_FIRST ||
ucAgreementType > LSKEYPACKTYPE_LAST)
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Invalid ucKeyPackType - %d\n"),
lpKeyPack->ucAgreementType
);
break;
}
if((ucKeyPackStatus < LSKEYPACKSTATUS_FIRST ||
ucKeyPackStatus > LSKEYPACKSTATUS_LAST) &&
ucKeyPackStatus != LSKEYPACKSTATUS_DELETE)
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Invalid ucKeyPackStatus - %d\n"),
lpKeyPack->ucKeyPackStatus
);
break;
}
if(lpKeyPack->ucLicenseType < LSKEYPACKLICENSETYPE_FIRST ||
lpKeyPack->ucLicenseType > LSKEYPACKLICENSETYPE_LAST)
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Invalid ucLicenseType - %d\n"),
lpKeyPack->ucLicenseType
);
break;
}
if(!bAdd)
{
bValid = TRUE;
break;
}
//
// Following value is required for adding entry into keypack
//
if(lpKeyPack->ucChannelOfPurchase < LSKEYPACKCHANNELOFPURCHASE_FIRST ||
lpKeyPack->ucChannelOfPurchase > LSKEYPACKCHANNELOFPURCHASE_LAST)
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Invalid ucChannelOfPurchase - %d\n"),
lpKeyPack->ucChannelOfPurchase
);
break;
}
if(!_tcslen(lpKeyPack->szCompanyName))
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Null szCompanyName\n")
);
break;
}
if(!_tcslen(lpKeyPack->szKeyPackId))
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Null szKeyPackId\n")
);
break;
}
if(!_tcslen(lpKeyPack->szProductId))
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Null szProductId\n")
);
break;
}
if(!_tcslen(lpKeyPack->szBeginSerialNumber))
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("Null szBeginSerialNumber\n")
);
break;
}
bValid=TRUE;
} while(FALSE);
return bValid;
}
//++-----------------------------------------------------------
void
TLSDBLockKeyPackTable()
/*++
Abstract:
Lock both LicPack and LicPackStatus table.
Parameter:
None.
++*/
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_LOCK,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("Locking table KeyPackTable\n")
);
LicPackTable::LockTable();
}
//++-----------------------------------------------------------
void
TLSDBUnlockKeyPackTable()
/*++
Abstract:
Unlock both LicPack and LicPackStatus table.
Parameter:
None:
++*/
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_LOCK,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("Unlocking table KeyPackTable\n")
);
LicPackTable::UnlockTable();
}
//++--------------------------------------------------------------
DWORD
TLSDBKeyPackFind(
IN PTLSDbWorkSpace pDbWkSpace,
IN BOOL bMatchAllParm,
IN DWORD dwSearchParm,
IN PTLSLICENSEPACK lpKeyPack,
IN OUT PTLSLICENSEPACK lpFound
)
/*++
Abstract:
Find a license pack based on search parameter.
Parameter:
pDbWkSpace : workspace handle.
bMatchAllParm : TRUE if match all parameter, FALSE otherwise.
dwSearchParm : search parameter.
lpKeyPack : value to search for.
lpFound : record found.
Return:
++*/
{
DWORD dwStatus=ERROR_SUCCESS;
BOOL bSuccess;
if(pDbWkSpace == NULL || lpKeyPack == NULL)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
TLSASSERT(FALSE);
return dwStatus;
}
LicPackTable& licpackTable=pDbWkSpace->m_LicPackTable;
//
// Find the record in LicPack table
//
bSuccess = licpackTable.FindRecord(
bMatchAllParm,
dwSearchParm,
*lpKeyPack,
*lpFound
);
if(bSuccess != TRUE)
{
if(licpackTable.GetLastJetError() == JET_errRecordNotFound)
{
SetLastError(dwStatus = TLS_E_RECORD_NOTFOUND);
}
else
{
LPTSTR pString = NULL;
TLSGetESEError(licpackTable.GetLastJetError(), &pString);
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_DBGENERAL,
TLS_E_JB_BASE,
licpackTable.GetLastJetError(),
(pString != NULL) ? pString : _TEXT("")
);
if(pString != NULL)
{
LocalFree(pString);
}
SetLastError(
dwStatus = (SET_JB_ERROR(licpackTable.GetLastJetError()))
);
TLSASSERT(licpackTable.GetLastJetError() == JET_errRecordNotFound);
}
}
return dwStatus;
}
//++-------------------------------------------------------------------
DWORD
TLSDBKeyPackAddEntry(
IN PTLSDbWorkSpace pDbWkSpace,
IN PTLSLICENSEPACK lpKeyPack
)
/*++
Abstract:
Add an entry into LicPack and LicPackStatus table.
Parameter:
pDbWkSpace :
lpKeyPack ;
Returns:
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
TLSLICENSEPACK found;
BOOL bSuccess;
LicPackTable& licpackTable=pDbWkSpace->m_LicPackTable;
found.pbDomainSid = NULL;
found.cbDomainSid = 0;
//
//
//
TLSDBLockKeyPackTable();
TLSASSERT(pDbWkSpace != NULL && lpKeyPack != NULL);
if(pDbWkSpace == NULL || lpKeyPack == NULL)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
goto cleanup;
}
// lpKeyPack->pbDomainSid == NULL || lpKeyPack->cbDomainSid == 0 ||
if( _tcslen(lpKeyPack->szInstallId) == 0 || _tcslen(lpKeyPack->szTlsServerName) == 0 )
{
TLSASSERT(FALSE);
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
goto cleanup;
}
//
// make sure no duplicate entry via primary index
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LICENSEDPACK_PROCESS_DWINTERNAL,
lpKeyPack,
&found
);
if(dwStatus == ERROR_SUCCESS)
{
dwStatus = TLS_E_DUPLICATE_RECORD;
goto cleanup;
}
dwStatus = ERROR_SUCCESS;
//
// Mark internal field -
//
switch( (lpKeyPack->ucAgreementType & ~LSKEYPACK_RESERVED_TYPE) )
{
case LSKEYPACKTYPE_SELECT:
case LSKEYPACKTYPE_RETAIL:
case LSKEYPACKTYPE_CONCURRENT:
case LSKEYPACKTYPE_OPEN:
// number of license available to client
lpKeyPack->dwNumberOfLicenses = lpKeyPack->dwTotalLicenseInKeyPack;
break;
default:
// number of licenses issued.
lpKeyPack->dwNumberOfLicenses = 0;
break;
}
//
// Begin serial number in this keypack
//
lpKeyPack->dwNextSerialNumber = 1;
GetSystemTimeAsFileTime(&(lpKeyPack->ftLastModifyTime));
//
// Mark beta keypack.
//
if(TLSIsBetaNTServer() == TRUE)
{
lpKeyPack->ucKeyPackStatus |= LSKEYPACKSTATUS_BETA;
}
//
// insert the record
//
bSuccess = licpackTable.InsertRecord(
*lpKeyPack
);
if(bSuccess == FALSE)
{
if(licpackTable.GetLastJetError() == JET_errKeyDuplicate)
{
SetLastError(dwStatus=TLS_E_DUPLICATE_RECORD);
}
else
{
LPTSTR pString = NULL;
TLSGetESEError(licpackTable.GetLastJetError(), &pString);
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_DBGENERAL,
TLS_E_JB_BASE,
licpackTable.GetLastJetError(),
(pString != NULL) ? pString : _TEXT("")
);
if(pString != NULL)
{
LocalFree(pString);
}
SetLastError(dwStatus = SET_JB_ERROR(licpackTable.GetLastJetError()));
TLSASSERT(FALSE);
}
}
cleanup:
TLSDBUnlockKeyPackTable();
SetLastError(dwStatus);
return dwStatus;
}
//-----------------------------------------------------
DWORD
TLSDBKeyPackDeleteEntry(
IN PTLSDbWorkSpace pDbWkSpace,
IN BOOL bDeleteAllRecord,
IN PTLSLICENSEPACK lpKeyPack
)
/*++
Abstract:
Delete an entry from both LicPack and LicPackStatus table.
Parameter:
pDbWkSpace : workspace handle.
bDeleteAllRecord : Delete all record with same ID.
lpKeyPack : record to be delete.
Returns:
Note:
If not deleting same record, current record must be point
to the record that going to be deleted.
++*/
{
DWORD dwStatus=ERROR_SUCCESS;
BOOL bSuccess;
LicPackTable& licpackTable = pDbWkSpace->m_LicPackTable;
GetSystemTimeAsFileTime(&(lpKeyPack->ftLastModifyTime));
//
// BACKUP - Need to update this record to deleted state instead of delete it.
//
if(bDeleteAllRecord == TRUE)
{
//
// Delete record from LicPack Table.
//
bSuccess = licpackTable.DeleteAllRecord(
TRUE,
LICENSEDPACK_PROCESS_DWINTERNAL,
*lpKeyPack
);
}
else
{
bSuccess = licpackTable.DeleteRecord();
}
if(bSuccess == FALSE)
{
SetLastError(dwStatus = SET_JB_ERROR(licpackTable.GetLastJetError()));
if(licpackTable.GetLastJetError() != JET_errRecordNotFound)
{
LPTSTR pString = NULL;
TLSGetESEError(licpackTable.GetLastJetError(), &pString);
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_DBGENERAL,
TLS_E_JB_BASE,
licpackTable.GetLastJetError(),
(pString != NULL) ? pString : _TEXT("")
);
if(pString != NULL)
{
LocalFree(pString);
}
TLSASSERT(FALSE);
}
}
return dwStatus;
}
//-----------------------------------------------------
DWORD
TLSDBKeyPackUpdateEntry(
IN PTLSDbWorkSpace pDbWkSpace,
IN BOOL bPointerOnRecord,
IN DWORD dwUpdateParm,
IN PTLSLICENSEPACK lpKeyPack
)
/*
*/
{
DWORD dwStatus = ERROR_SUCCESS;
BOOL bSuccess;
TLSLICENSEPACK found;
LicPackTable& licpackTable=pDbWkSpace->m_LicPackTable;
if(bPointerOnRecord == FALSE)
{
found.pbDomainSid = NULL;
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LICENSEDPACK_PROCESS_DWINTERNAL,
lpKeyPack,
&found
);
lpKeyPack->dwKeyPackId = found.dwKeyPackId;
if(dwStatus != ERROR_SUCCESS)
{
TLSASSERT(FALSE);
goto cleanup;
}
}
#if DBG
{
//
// try to cache some bug...
//
TLSLICENSEPACK found1;
found.pbDomainSid = NULL;
bSuccess = licpackTable.FetchRecord( found1, 0xFFFFFFFF );
//
// Make sure we update right record
if( found1.dwKeyPackId != lpKeyPack->dwKeyPackId )
{
TLSASSERT(FALSE);
}
//
// check input parameter
if( ValidKeyPackParameter( lpKeyPack, FALSE ) == FALSE )
{
TLSASSERT(FALSE);
}
}
#endif
//
// Update the timestamp for this record.
//
GetSystemTimeAsFileTime(&(lpKeyPack->ftLastModifyTime));
bSuccess = licpackTable.UpdateRecord(
*lpKeyPack,
(dwUpdateParm & ~LICENSEDPACK_PROCESS_DWINTERNAL) | LICENSEDPACK_PROCESS_MODIFYTIME
);
if(bSuccess == FALSE)
{
LPTSTR pString = NULL;
TLSGetESEError(licpackTable.GetLastJetError(), &pString);
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_DBGENERAL,
TLS_E_JB_BASE,
licpackTable.GetLastJetError(),
(pString != NULL) ? pString : _TEXT("")
);
if(pString != NULL)
{
LocalFree(pString);
}
SetLastError(dwStatus = SET_JB_ERROR(licpackTable.GetLastJetError()));
TLSASSERT(FALSE);
}
cleanup:
return dwStatus;
}
//-----------------------------------------------------
DWORD
TLSDBKeyPackUpdateNumOfAvailableLicense(
IN PTLSDbWorkSpace pDbWkSpace,
IN BOOL bAdd,
IN PTLSLICENSEPACK lpKeyPack
)
/*++
Abstract:
Update number of license available .
Parameter:
pDbWkSpace : workspace handle.
bAdd : TRUE if add license
lpKeyPack :
Returns:
++*/
{
DWORD dwStatus=ERROR_SUCCESS;
if(pDbWkSpace == NULL || lpKeyPack == NULL)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
TLSASSERT(pDbWkSpace != NULL);
return dwStatus;
}
TLSLICENSEPACK found;
DWORD dwNumberLicenseToAddRemove;
BOOL bRemoveMoreThanAvailable=FALSE;
found.pbDomainSid = NULL;
TLSDBLockKeyPackTable();
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LICENSEDPACK_PROCESS_DWINTERNAL,
lpKeyPack,
&found
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
dwNumberLicenseToAddRemove = lpKeyPack->dwTotalLicenseInKeyPack;
*lpKeyPack = found;
if(dwNumberLicenseToAddRemove == 0)
{
// query only, a hook so that test program can get actual
// numbers - Jet not re-reading MDB file problem
goto cleanup;
}
//
// Only allow add/remove license on retail
//
if( (found.ucAgreementType & ~LSKEYPACK_RESERVED_TYPE) != LSKEYPACKTYPE_RETAIL &&
(found.ucAgreementType & ~LSKEYPACK_RESERVED_TYPE) != LSKEYPACKTYPE_CONCURRENT)
{
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_KEYPACK,
DBGLEVEL_FUNCTION_DETAILSIMPLE,
_TEXT("LSDBKeyPackUpdate : Invalid parameter...\n")
);
SetLastError(dwStatus = TLS_E_INVALID_DATA);
goto cleanup;
}
if(bAdd)
{
// increase both total and number available
found.dwNumberOfLicenses += dwNumberLicenseToAddRemove;
found.dwTotalLicenseInKeyPack += dwNumberLicenseToAddRemove;
}
else
{
//
// if number of licenses to remove is greater that what's available,
// remove all available license and set the return code to invalid data.
//
if(found.dwNumberOfLicenses < dwNumberLicenseToAddRemove)
{
bRemoveMoreThanAvailable = TRUE;
}
dwNumberLicenseToAddRemove = min(dwNumberLicenseToAddRemove, found.dwNumberOfLicenses);
found.dwNumberOfLicenses -= dwNumberLicenseToAddRemove;
found.dwTotalLicenseInKeyPack -= dwNumberLicenseToAddRemove;
}
dwStatus = TLSDBKeyPackSetValues(
pDbWkSpace,
TRUE,
LSKEYPACK_SEARCH_TOTALLICENSES | LSKEYPACK_EXSEARCH_AVAILABLE,
&found
);
*lpKeyPack = found;
cleanup:
TLSDBUnlockKeyPackTable();
if(dwStatus == ERROR_SUCCESS && bRemoveMoreThanAvailable)
SetLastError(dwStatus = TLS_W_REMOVE_TOOMANY);
return dwStatus;
}
//+-----------------------------------------------------------------
DWORD
TLSDBKeyPackAdd(
IN PTLSDbWorkSpace pDbWkSpace,
IN OUT PTLSLICENSEPACK lpKeyPack // return internal tracking ID
)
/*++
Abstract:
Install a product keypack into keypack table, routine only set
keypack status to pending, must call corresponding set status
routine to activate key pack.
Parameters:
pDbWkSpace : Workspace handle.
lpKeyPack : value to be inserted.
Returns:
++*/
{
DWORD lNextKeyPackId;
DWORD dwStatus;
if(!ValidKeyPackParameter(lpKeyPack, TRUE))
{
SetLastError(TLS_E_INVALID_DATA);
return TLS_E_INVALID_DATA;
}
TLSLICENSEPACK found;
TLSDBLockKeyPackTable();
found.pbDomainSid = NULL;
//
// No duplicate entry for product installed
//
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LICENSEDPACK_FIND_PRODUCT,
lpKeyPack,
&found
);
if(dwStatus == ERROR_SUCCESS)
{
// Product already installed
switch( (found.ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED) )
{
case LSKEYPACKSTATUS_TEMPORARY:
// case 1 : keypack is installed by temporary license
if(found.ucAgreementType == lpKeyPack->ucAgreementType)
{
dwStatus = TLS_E_DUPLICATE_RECORD;
}
break;
case LSKEYPACKSTATUS_ACTIVE:
case LSKEYPACKSTATUS_PENDING:
// case 2 : duplicate entry
dwStatus = TLS_E_DUPLICATE_RECORD;
break;
case LSKEYPACKSTATUS_RETURNED:
case LSKEYPACKSTATUS_REVOKED:
case LSKEYPACKSTATUS_OTHERS:
// de-activated license key pack.
// keep it.
break;
default:
dwStatus = TLS_E_CORRUPT_DATABASE;
#if DBG
TLSASSERT(FALSE);
#endif
}
if(dwStatus != ERROR_SUCCESS)
goto cleanup;
}
else if(dwStatus == TLS_E_RECORD_NOTFOUND)
{
//
// Always use new keypack ID
// temporary license will be deleted after all license
// has been returned.
//
lpKeyPack->dwKeyPackId = TLSDBGetNextKeyPackId();
dwStatus = TLSDBKeyPackAddEntry(
pDbWkSpace,
lpKeyPack
);
}
cleanup:
TLSDBUnlockKeyPackTable();
return dwStatus;
}
//+-------------------------------------------------------------------
DWORD
TLSDBKeyPackEnumBegin(
IN PTLSDbWorkSpace pDbWkSpace,
IN BOOL bMatchAll,
IN DWORD dwSearchParm,
IN PTLSLICENSEPACK lpSearch
)
/*
Abstract:
Begin enumeration of licensepack table.
Parameter:
pDbWkSpace : workspace handle.
bMatchAll : match all search value.
dwSearchParm : value to search.
lpSearch : search value
Return:
*/
{
DWORD dwStatus = ERROR_SUCCESS;
BOOL bSuccess = TRUE;
if(pDbWkSpace == NULL)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
TLSASSERT(FALSE);
return dwStatus;
}
LicPackTable& licpackTable=pDbWkSpace->m_LicPackTable;
bSuccess = licpackTable.EnumerateBegin(
bMatchAll,
dwSearchParm,
lpSearch
);
if(bSuccess == FALSE)
{
LPTSTR pString = NULL;
TLSGetESEError(licpackTable.GetLastJetError(), &pString);
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_DBGENERAL,
TLS_E_JB_BASE,
licpackTable.GetLastJetError(),
(pString != NULL) ? pString : _TEXT("")
);
if(pString != NULL)
{
LocalFree(pString);
}
SetLastError(dwStatus = SET_JB_ERROR(licpackTable.GetLastJetError()));
TLSASSERT(FALSE);
}
return dwStatus;
}
//+-------------------------------------------------------------------
DWORD
TLSDBKeyPackEnumNext(
IN PTLSDbWorkSpace pDbWkSpace,
IN OUT PTLSLICENSEPACK lpKeyPack
)
/*++
Abstract:
Fetch next row of record that match search condition.
Parameters:
pDbWkSpace : workspace handle.
lpKeyPack : return founded keypack.
Return:
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
if(pDbWkSpace == NULL || lpKeyPack == NULL)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
TLSASSERT(FALSE);
return dwStatus;
}
//FreeTlsLicensePack(lpKeyPack);
LicPackTable& licpackTable=pDbWkSpace->m_LicPackTable;
switch(licpackTable.EnumerateNext(*lpKeyPack))
{
case RECORD_ENUM_ERROR:
{
LPTSTR pString = NULL;
TLSGetESEError(licpackTable.GetLastJetError(), &pString);
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_DBGENERAL,
TLS_E_JB_BASE,
licpackTable.GetLastJetError(),
(pString != NULL) ? pString : _TEXT("")
);
if(pString != NULL)
{
LocalFree(pString);
}
}
dwStatus = SET_JB_ERROR(licpackTable.GetLastJetError());
TLSASSERT(FALSE);
break;
case RECORD_ENUM_MORE_DATA:
dwStatus = ERROR_SUCCESS;
break;
case RECORD_ENUM_END:
dwStatus = TLS_I_NO_MORE_DATA;
}
return dwStatus;
}
//+-------------------------------------------------------------------
void
TLSDBKeyPackEnumEnd(
IN PTLSDbWorkSpace pDbWkSpace
)
/*++
Abstract:
End enumeration of licensepack.
Parameter:
pDbWkSpace : workspace handle.
++*/
{
TLSASSERT(pDbWkSpace != NULL);
pDbWkSpace->m_LicPackTable.EnumerateEnd();
return;
}
//+-------------------------------------------------------------------
DWORD
TLSDBKeyPackSetValues(
IN PTLSDbWorkSpace pDbWkSpace,
IN BOOL bPointerOnRecord,
IN DWORD dwSetParm,
IN PTLSLICENSEPACK lpKeyPack
)
/*++
Abstract:
Set column value of a license pack record.
Parameter;
pDbWkSpace : workspace handle.
bInternal : call is from internal routine, no error checking.
dwSetParm : Columns to be set.
lpKeyPack : value to be set.
Returns.
++*/
{
DWORD dwStatus=ERROR_SUCCESS;
if(pDbWkSpace == NULL || lpKeyPack == NULL)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
TLSASSERT(FALSE);
goto cleanup;
}
if(bPointerOnRecord == FALSE)
{
TLSLICENSEPACK found;
// Find this keypack's internal keypack id
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LICENSEDPACK_FIND_PRODUCT,
lpKeyPack,
&found
);
//FreeTlsLicensePack(&found);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
lpKeyPack->dwKeyPackId = found.dwKeyPackId;
}
if(lpKeyPack->ucKeyPackStatus == LSKEYPACKSTATUS_DELETE)
{
dwStatus = TLSDBKeyPackDeleteEntry(
pDbWkSpace,
TRUE, // delete all records with same ID
lpKeyPack
);
}
else
{
dwStatus = TLSDBKeyPackUpdateEntry(
pDbWkSpace,
TRUE,
dwSetParm,
lpKeyPack
);
}
cleanup:
return dwStatus;
}
//+-------------------------------------------------------------------
DWORD
TLSDBKeyPackSetStatus(
IN PTLSDbWorkSpace pDbWkSpace,
IN DWORD dwSetStatus,
IN PTLSLICENSEPACK lpKeyPack
)
/*++
Abstract:
Stub routine for RPC to set status of a keypack
++*/
{
return TLSDBKeyPackSetValues(
pDbWkSpace,
FALSE,
dwSetStatus,
lpKeyPack
);
}
//+-------------------------------------------------------------------
DWORD
TLSDBKeyPackGetAvailableLicenses(
IN PTLSDbWorkSpace pDbWkSpace,
IN DWORD dwSearchParm,
IN PTLSLICENSEPACK lplsKeyPack,
IN OUT LPDWORD lpdwAvail
)
/*++
Abstract:
retrieve number of available licenses for the key pack.
Parameter:
pDbWkSpace : workspace handle.
dwSearchParm : search parameters.
lpLsKeyPack : search value.
lpdwAvail : return number of available licenses.
Return:
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
TLSLICENSEPACK found;
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
dwSearchParm,
lplsKeyPack,
&found
);
if(dwStatus == ERROR_SUCCESS)
{
switch(found.ucAgreementType)
{
case LSKEYPACKTYPE_SELECT:
case LSKEYPACKTYPE_RETAIL:
case LSKEYPACKTYPE_CONCURRENT:
case LSKEYPACKTYPE_OPEN:
*lpdwAvail = found.dwNumberOfLicenses;
break;
default:
*lpdwAvail = LONG_MAX;
}
}
//FreeTlsLicensePack(&found);
return dwStatus;
}
Reference in a new issue Copy permalink