You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1025 lines
30 KiB
1025 lines
30 KiB
//+--------------------------------------------------------------------------
|
|
//
|
|
// 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;
|
|
}
|
|
|
|
|
|
|