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

888 lines
25 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: findlost.cpp
//
// Contents:
// Find lost license
//
// History:
// Feb 4, 98 HueiWang Created
//---------------------------------------------------------------------------
#include "pch.cpp"
#include "globals.h"
#include "findlost.h"
#include "misc.h"
#include "db.h"
#include "clilic.h"
#include "keypack.h"
#include "kp.h"
#include "lkpdesc.h"
//++-------------------------------------------------------------------
DWORD
DBFindLicenseExact(
IN PTLSDbWorkSpace pDbWkSpace,
IN PLICENSEDPRODUCT pLicProduct,
OUT LICENSEDCLIENT *pFoundLicense
)
/*++
Abstract:
Find license based on exact match of client HWID
Parameter:
pDbWkSpace : workspace handle.
pLicProduct : product to request license.
pFoundLicense: found license
Returns:
TLS_E_RECORD_NOTFOUND: HWID not found
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
BOOL bFound=FALSE;
DWORD dwMatchHwidCount;
LICENSEDCLIENT search_license;
TLSLICENSEPACK search_keypack;
TLSLICENSEPACK found_keypack;
memset(&search_license, 0, sizeof(search_license));
memset(pFoundLicense, 0, sizeof(LICENSEDCLIENT));
search_license.dwSystemBiosChkSum = pLicProduct->Hwid.dwPlatformID;
search_license.dwVideoBiosChkSum = pLicProduct->Hwid.Data1;
search_license.dwFloppyBiosChkSum = pLicProduct->Hwid.Data2;
search_license.dwHardDiskSize = pLicProduct->Hwid.Data3;
search_license.dwRamSize = pLicProduct->Hwid.Data4;
//
// lock both tables -
// Other threads might be in the process of allocating a temp. license
// while this thread is searching
//
TLSDBLockKeyPackTable();
TLSDBLockLicenseTable();
dwStatus = TLSDBLicenseEnumBegin(
pDbWkSpace,
TRUE,
LICENSE_COLUMN_SEARCH_HWID,
&search_license
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
while(bFound == FALSE)
{
dwStatus = TLSDBLicenseEnumNext(
pDbWkSpace,
pFoundLicense
);
if(dwStatus != ERROR_SUCCESS)
{
break;
}
//
// Verify against client HWID
//
dwMatchHwidCount = 0;
dwMatchHwidCount += (pFoundLicense->dwSystemBiosChkSum == pLicProduct->Hwid.dwPlatformID);
dwMatchHwidCount += (pFoundLicense->dwVideoBiosChkSum == pLicProduct->Hwid.Data1);
dwMatchHwidCount += (pFoundLicense->dwFloppyBiosChkSum == pLicProduct->Hwid.Data2);
dwMatchHwidCount += (pFoundLicense->dwHardDiskSize == pLicProduct->Hwid.Data3);
dwMatchHwidCount += (pFoundLicense->dwRamSize == pLicProduct->Hwid.Data4);
if(dwMatchHwidCount != 5)
{
break;
}
//
// See if this match our license pack
//
search_keypack.dwKeyPackId = pFoundLicense->dwKeyPackId;
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LSKEYPACK_EXSEARCH_DWINTERNAL,
&search_keypack,
&found_keypack
);
if(dwStatus != ERROR_SUCCESS)
{
continue;
}
//
// No actual license is issued for concurrent KeyPack.
//
if(found_keypack.ucAgreementType != LSKEYPACKTYPE_RETAIL &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_SELECT &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_OPEN &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_TEMPORARY &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_FREE )
{
continue;
}
UCHAR ucKeyPackStatus = found_keypack.ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED;
//
// No license for pending activation key pack, use temporary license scheme.
//
if(ucKeyPackStatus != LSKEYPACKSTATUS_ACTIVE &&
ucKeyPackStatus != LSKEYPACKSTATUS_TEMPORARY)
{
continue;
}
if(found_keypack.wMajorVersion != pLicProduct->pLicensedVersion->wMajorVersion ||
found_keypack.wMinorVersion != pLicProduct->pLicensedVersion->wMinorVersion)
{
continue;
}
if(found_keypack.dwPlatformType != pLicProduct->LicensedProduct.dwPlatformID)
{
continue;
}
if(_tcsnicmp(found_keypack.szProductId,
(LPTSTR)(pLicProduct->pbOrgProductID),
((pLicProduct->cbOrgProductID)/sizeof(TCHAR)) - 1)
!= 0)
{
continue;
}
//
// Found our lost license.
//
bFound = TRUE;
}
TLSDBLicenseEnumEnd(pDbWkSpace);
cleanup:
if(dwStatus == TLS_I_NO_MORE_DATA)
{
SetLastError(dwStatus = TLS_E_RECORD_NOTFOUND);
}
TLSDBUnlockLicenseTable();
TLSDBUnlockKeyPackTable();
return dwStatus;
}
//++-------------------------------------------------------------------
DWORD
DBFindLostLicenseExact(
IN PTLSDbWorkSpace pDbWkSpace,
IN PTLSDBAllocateRequest pRequest, // ucKeyPackType not use
// IN BOOL bMatchHwid,
IN PHWID pHwid,
IN OUT PTLSLICENSEPACK lpKeyPack,
IN OUT PLICENSEDCLIENT lpLicense
)
/*++
Abstract:
Find lost license base on exact/closest match of client HWID
Parameter:
pDbWkSpace : workspace handle.
pRequest : product to request license.
bMatchHwid : TRUE if match HWID, FALSE otherwise.
lpKeyPack : keyPack that license was issued from.
lpLicense : Founded license record.
Returns:
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
BOOL bFound=FALSE;
DWORD dwMatchHwidCount;
LICENSEDCLIENT search_license;
LICENSEDCLIENT found_license;
TLSLICENSEPACK search_keypack;
TLSLICENSEPACK found_keypack;
//
// Ignore ucKeyPackType
//
pRequest->ucAgreementType = LSKEYPACKTYPE_FIRST;
dwStatus = VerifyTLSDBAllocateRequest(pRequest);
if(dwStatus != ERROR_SUCCESS)
{
return dwStatus;
}
memset(&search_license, 0, sizeof(search_license));
memset(&found_license, 0, sizeof(found_license));
search_license.dwSystemBiosChkSum = pHwid->dwPlatformID;
search_license.dwVideoBiosChkSum = pHwid->Data1;
search_license.dwFloppyBiosChkSum = pHwid->Data2;
search_license.dwHardDiskSize = pHwid->Data3;
search_license.dwRamSize = pHwid->Data4;
//
// lock both table -
// Other thread might be in the process of allocating a temp. license while this
// thread try to delete the temp. key pack.
//
TLSDBLockKeyPackTable();
TLSDBLockLicenseTable();
dwStatus = TLSDBLicenseEnumBegin(
pDbWkSpace,
TRUE,
LICENSE_COLUMN_SEARCH_HWID,
&search_license
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
while(bFound == FALSE)
{
dwStatus = TLSDBLicenseEnumNext(
pDbWkSpace,
&found_license
);
if(dwStatus != ERROR_SUCCESS)
{
break;
}
//
// Verify against client HWID
//
dwMatchHwidCount = 0;
dwMatchHwidCount += (found_license.dwSystemBiosChkSum == pHwid->dwPlatformID);
dwMatchHwidCount += (found_license.dwVideoBiosChkSum == pHwid->Data1);
dwMatchHwidCount += (found_license.dwFloppyBiosChkSum == pHwid->Data2);
dwMatchHwidCount += (found_license.dwHardDiskSize == pHwid->Data3);
dwMatchHwidCount += (found_license.dwRamSize == pHwid->Data4);
if(dwMatchHwidCount != 5)
{
break;
}
//
// consider only valid license
//
if( found_license.ucLicenseStatus != LSLICENSE_STATUS_ACTIVE &&
found_license.ucLicenseStatus != LSLICENSE_STATUS_PENDING &&
found_license.ucLicenseStatus != LSLICENSE_STATUS_TEMPORARY)
{
continue;
}
//
// See if this match our license pack
//
search_keypack.dwKeyPackId = found_license.dwKeyPackId;
dwStatus = TLSDBKeyPackFind(
pDbWkSpace,
TRUE,
LSKEYPACK_EXSEARCH_DWINTERNAL,
&search_keypack,
&found_keypack
);
if(dwStatus != ERROR_SUCCESS)
{
continue;
}
//
// No actual license is issued for concurrent KeyPack.
//
if(found_keypack.ucAgreementType != LSKEYPACKTYPE_RETAIL &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_SELECT &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_OPEN &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_TEMPORARY &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_FREE )
{
continue;
}
UCHAR ucKeyPackStatus = found_keypack.ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED;
//
// No license for pending activation key pack, use temporary license scheme.
//
if(ucKeyPackStatus != LSKEYPACKSTATUS_ACTIVE &&
ucKeyPackStatus != LSKEYPACKSTATUS_TEMPORARY)
{
continue;
}
if(found_keypack.wMajorVersion != HIWORD(pRequest->dwVersion) ||
found_keypack.wMinorVersion != LOWORD(pRequest->dwVersion) )
{
continue;
}
if(found_keypack.dwPlatformType != pRequest->dwPlatformId)
{
continue;
}
if(_tcscmp(found_keypack.szCompanyName, pRequest->szCompanyName) != 0)
{
continue;
}
if(_tcscmp(found_keypack.szProductId, pRequest->szProductId) != 0)
{
continue;
}
//
// Found our lost license.
//
bFound = TRUE;
*lpLicense = found_license;
*lpKeyPack = found_keypack;
}
TLSDBLicenseEnumEnd(pDbWkSpace);
cleanup:
if(dwStatus == TLS_I_NO_MORE_DATA)
{
SetLastError(dwStatus = TLS_E_RECORD_NOTFOUND);
}
TLSDBUnlockLicenseTable();
TLSDBUnlockKeyPackTable();
return dwStatus;
}
//++-------------------------------------------------------------------
DWORD
DBFindLostLicenseMatch(
IN PTLSDbWorkSpace pDbWkSpace,
IN PTLSDBAllocateRequest pRequest, // ucKeyPackType not use
IN BOOL bMatchHwid,
IN PHWID pHwid,
IN OUT PTLSLICENSEPACK lpKeyPack,
IN OUT PLICENSEDCLIENT lpLicense
)
/*++
Abstract:
Find lost license base on exact/closest match of client HWID
Parameter:
pDbWkSpace : workspace handle.
pRequest : product to request license.
bMatchHwid : TRUE if match HWID, FALSE otherwise.
lpKeyPack : keyPack that license was issued from.
lpLicense : Founded license record.
Returns:
++*/
{
DWORD status=ERROR_SUCCESS;
BOOL bFound=FALSE;
TLSLICENSEPACK search_keypack;
TLSLICENSEPACK found_keypack;
DWORD dwMatchHwidCount;
found_keypack.pbDomainSid = NULL;
//
// Ignore ucKeyPackType
//
pRequest->ucAgreementType = LSKEYPACKTYPE_FIRST;
status = VerifyTLSDBAllocateRequest(pRequest);
if(status != ERROR_SUCCESS)
return status;
LICENSEDCLIENT search_license;
LICENSEDCLIENT found_license;
//---------------------------------------------------------------------------
// Set up search parameter
//
memset(&search_keypack, 0, sizeof(search_keypack));
_tcscpy(search_keypack.szCompanyName, pRequest->szCompanyName);
_tcscpy(search_keypack.szProductId, pRequest->szProductId);
search_keypack.wMajorVersion = HIWORD(pRequest->dwVersion);
search_keypack.wMinorVersion = LOWORD(pRequest->dwVersion);
search_keypack.dwPlatformType = pRequest->dwPlatformId;
//
// lock both table -
// Other thread might be in the process of allocating a temp. license while this
// thread try to delete the temp. key pack.
//
TLSDBLockKeyPackTable();
TLSDBLockLicenseTable();
//
// KeyPack table index is based on keypack type
//
status=TLSDBKeyPackEnumBegin(
pDbWkSpace,
TRUE,
LSKEYPACK_SEARCH_PRODUCTID,
&search_keypack
);
if(status != ERROR_SUCCESS)
goto cleanup;
while( !bFound )
{
status = TLSDBKeyPackEnumNext(
pDbWkSpace,
&found_keypack
);
if(status != ERROR_SUCCESS)
break;
//
// No actual license is issued for concurrent KeyPack.
//
if(found_keypack.ucAgreementType != LSKEYPACKTYPE_RETAIL &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_SELECT &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_OPEN &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_TEMPORARY &&
found_keypack.ucAgreementType != LSKEYPACKTYPE_FREE )
{
continue;
}
UCHAR ucKeyPackStatus = found_keypack.ucKeyPackStatus & ~LSKEYPACKSTATUS_RESERVED;
//
// No license for pending activation key pack, use temporary license scheme.
//
if(ucKeyPackStatus != LSKEYPACKSTATUS_ACTIVE &&
ucKeyPackStatus != LSKEYPACKSTATUS_TEMPORARY)
{
continue;
}
if(found_keypack.wMajorVersion != search_keypack.wMajorVersion ||
found_keypack.wMinorVersion != search_keypack.wMinorVersion )
{
continue;
}
if(found_keypack.dwPlatformType != search_keypack.dwPlatformType)
{
continue;
}
if(_tcscmp(found_keypack.szCompanyName, search_keypack.szCompanyName) != 0)
{
continue;
}
if(_tcscmp(found_keypack.szProductId, search_keypack.szProductId) != 0)
{
continue;
}
// we found a candidate keypack, look into license table
memset(&search_license, 0, sizeof(search_license));
memset(&found_license, 0, sizeof(found_license));
search_license.dwKeyPackId = found_keypack.dwKeyPackId;
status = TLSDBLicenseEnumBegin(
pDbWkSpace,
TRUE,
LICENSE_PROCESS_KEYPACKID,
&search_license
);
if(status != ERROR_SUCCESS)
break;
while( bFound == FALSE )
{
status = TLSDBLicenseEnumNext(
pDbWkSpace,
&found_license
);
if(status != ERROR_SUCCESS)
break;
//
// consider only valid license
//
if( found_license.ucLicenseStatus != LSLICENSE_STATUS_ACTIVE &&
found_license.ucLicenseStatus != LSLICENSE_STATUS_PENDING &&
found_license.ucLicenseStatus != LSLICENSE_STATUS_TEMPORARY)
{
continue;
}
//
// Verify against client HWID
//
dwMatchHwidCount = 0;
dwMatchHwidCount += (found_license.dwSystemBiosChkSum == pHwid->dwPlatformID);
dwMatchHwidCount += (found_license.dwVideoBiosChkSum == pHwid->Data1);
dwMatchHwidCount += (found_license.dwFloppyBiosChkSum == pHwid->Data2);
dwMatchHwidCount += (found_license.dwHardDiskSize == pHwid->Data3);
dwMatchHwidCount += (found_license.dwRamSize == pHwid->Data4);
if(dwMatchHwidCount == 5 || (bMatchHwid == FALSE && dwMatchHwidCount >= LICENSE_MIN_MATCH))
{
bFound = TRUE;
*lpLicense = found_license;
*lpKeyPack = found_keypack;
}
}
TLSDBLicenseEnumEnd(pDbWkSpace);
}
TLSDBKeyPackEnumEnd(pDbWkSpace);
cleanup:
//FreeTlsLicensePack(&found_keypack);
if(status == TLS_I_NO_MORE_DATA)
{
SetLastError(status = TLS_E_RECORD_NOTFOUND);
}
TLSDBUnlockLicenseTable();
TLSDBUnlockKeyPackTable();
return status;
}
//++--------------------------------------------------------------------
DWORD
TLSFindLicense(
IN PLICENSEDPRODUCT pLicProduct,
OUT PLICENSEDCLIENT pLicClient
)
{
PTLSDbWorkSpace pDbWkSpace = NULL;
DWORD status = ERROR_SUCCESS;
pDbWkSpace = AllocateWorkSpace(g_EnumDbTimeout);
if(pDbWkSpace == NULL)
{
status=TLS_E_ALLOCATE_HANDLE;
goto cleanup;
}
status = DBFindLicenseExact(pDbWkSpace,pLicProduct,pLicClient);
ReleaseWorkSpace(&pDbWkSpace);
cleanup:
return status;
}
//++--------------------------------------------------------------------
DWORD
TLSFindDbLicensedProduct(
IN PTLSDBLICENSEDPRODUCT pDbLicProduct,
OUT PLICENSEDCLIENT pLicClient
)
{
PTLSDbWorkSpace pDbWkSpace = NULL;
DWORD status = ERROR_SUCCESS;
LICENSEDPRODUCT LicProduct;
LICENSED_VERSION_INFO LicVerInfo;
pDbWkSpace = AllocateWorkSpace(g_EnumDbTimeout);
if(pDbWkSpace == NULL)
{
status=TLS_E_ALLOCATE_HANDLE;
goto cleanup;
}
memcpy(&(LicProduct.Hwid), &(pDbLicProduct->ClientHwid), sizeof(HWID));
LicVerInfo.wMajorVersion = HIWORD(pDbLicProduct->dwProductVersion);
LicVerInfo.wMinorVersion = LOWORD(pDbLicProduct->dwProductVersion);
LicProduct.pLicensedVersion = &LicVerInfo;
LicProduct.LicensedProduct.dwPlatformID = pDbLicProduct->dwPlatformID;
LicProduct.pbOrgProductID = (PBYTE)(pDbLicProduct->szLicensedProductId);
LicProduct.cbOrgProductID = _tcslen(pDbLicProduct->szLicensedProductId) * sizeof(TCHAR);
status = DBFindLicenseExact(pDbWkSpace,&LicProduct,pLicClient);
ReleaseWorkSpace(&pDbWkSpace);
cleanup:
return status;
}
//++--------------------------------------------------------------------
DWORD
TLSDBFindLostLicense(
IN PTLSDbWorkSpace pDbWkSpace,
IN PTLSDBLICENSEREQUEST pLicenseRequest,
IN PHWID pHwid,
IN OUT PTLSDBLICENSEDPRODUCT pLicensedProduct,
OUT PUCHAR pucMarked
)
/*++
Abstract:
Wrapper to DBFindLostLicense().
See DBFindLostLicense.
++*/
{
DWORD dwStatus=ERROR_SUCCESS;
TLSLICENSEPACK keypack;
LICENSEDCLIENT License;
ULARGE_INTEGER ulSerialNumber;
FILETIME notBefore;
FILETIME notAfter;
PMGENERATELICENSE PolModGenLicense;
PPMCERTEXTENSION pPolModCertExtension=NULL;
PMLICENSEREQUEST PolRequest;
TLSDBAllocateRequest AllocateRequest;
DWORD dwRetCode=ERROR_SUCCESS;
keypack.pbDomainSid = NULL;
AllocateRequest.szCompanyName = (LPTSTR)pLicenseRequest->pszCompanyName;
AllocateRequest.szProductId = (LPTSTR)pLicenseRequest->pszProductId;
AllocateRequest.dwVersion = pLicenseRequest->dwProductVersion;
AllocateRequest.dwPlatformId = pLicenseRequest->dwPlatformID;
AllocateRequest.dwLangId = pLicenseRequest->dwLanguageID;
AllocateRequest.dwNumLicenses = 1;
dwStatus = DBFindLostLicenseExact(
pDbWkSpace,
&AllocateRequest,
//TRUE,
pHwid,
&keypack,
&License
);
#if 0
//
// TermSrv does not support matching, comment out for now
//
if(dwStatus == TLS_E_RECORD_NOTFOUND)
{
//
// find by matching, very expensive operation
//
dwStatus = DBFindLostLicenseMatch(
pDbWkSpace,
&AllocateRequest,
FALSE,
pHwid,
&keypack,
&License
);
if(dwStatus == ERROR_SUCCESS)
{
dwRetCode = TLS_W_LICENSE_PROXIMATE;
}
}
#endif
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
UnixTimeToFileTime(License.ftIssueDate, &notBefore);
UnixTimeToFileTime(License.ftExpireDate, &notAfter);
ulSerialNumber.LowPart = License.dwLicenseId;
ulSerialNumber.HighPart = keypack.dwKeyPackId;
PolRequest.dwProductVersion = MAKELONG(keypack.wMinorVersion, keypack.wMajorVersion);
PolRequest.pszProductId = (LPTSTR)keypack.szProductId;
PolRequest.pszCompanyName = (LPTSTR)keypack.szCompanyName;
PolRequest.dwLanguageId = pLicenseRequest->dwLanguageID;
PolRequest.dwPlatformId = keypack.dwPlatformType;
PolRequest.pszMachineName = License.szMachineName;
PolRequest.pszUserName = License.szUserName;
//
// Inform Policy Module of license generation.
//
PolModGenLicense.pLicenseRequest = &PolRequest;
PolModGenLicense.dwKeyPackType = keypack.ucAgreementType;
PolModGenLicense.dwKeyPackId = keypack.dwKeyPackId;
PolModGenLicense.dwKeyPackLicenseId = License.dwKeyPackLicenseId;
PolModGenLicense.ClientLicenseSerialNumber = ulSerialNumber;
PolModGenLicense.ftNotBefore = notBefore;
PolModGenLicense.ftNotAfter = notAfter;
dwStatus = pLicenseRequest->pPolicy->PMLicenseRequest(
pLicenseRequest->hClient,
REQUEST_GENLICENSE,
(PVOID)&PolModGenLicense,
(PVOID *)&pPolModCertExtension
);
if(dwStatus != ERROR_SUCCESS)
{
//
// Error in policy module
//
goto cleanup;
}
//
// Check error return from policy module
//
if(pPolModCertExtension != NULL)
{
if(pPolModCertExtension->pbData != NULL && pPolModCertExtension->cbData == 0 ||
pPolModCertExtension->pbData == NULL && pPolModCertExtension->cbData != 0 )
{
// assuming no extension data
pPolModCertExtension->cbData = 0;
pPolModCertExtension->pbData = NULL;
}
if(CompareFileTime(&(pPolModCertExtension->ftNotBefore), &(pPolModCertExtension->ftNotAfter)) > 0)
{
//
// invalid data return from policy module
//
TLSLogEvent(
EVENTLOG_ERROR_TYPE,
TLS_E_GENERATECLIENTELICENSE,
dwStatus = TLS_E_POLICYMODULEERROR,
pLicenseRequest->pPolicy->GetCompanyName(),
pLicenseRequest->pPolicy->GetProductId()
);
goto cleanup;
}
//
// Ignore not before and not after
//
}
if(keypack.ucAgreementType == LSKEYPACKTYPE_TEMPORARY)
{
//
// we found a temporary license
//
dwRetCode = TLS_I_FOUND_TEMPORARY_LICENSE;
}
//
// License expired
//
if(License.ftExpireDate < time(NULL))
{
dwRetCode = TLS_E_LICENSE_EXPIRED;
}
//
// Return licensed product
//
pLicensedProduct->pSubjectPublicKeyInfo = NULL;
pLicensedProduct->dwQuantity = License.dwNumLicenses;
pLicensedProduct->ulSerialNumber = ulSerialNumber;
pLicensedProduct->dwKeyPackId = keypack.dwKeyPackId;
pLicensedProduct->dwLicenseId = License.dwLicenseId;
pLicensedProduct->dwKeyPackLicenseId = License.dwKeyPackLicenseId;
pLicensedProduct->ClientHwid.dwPlatformID = License.dwSystemBiosChkSum;
pLicensedProduct->ClientHwid.Data1 = License.dwVideoBiosChkSum;
pLicensedProduct->ClientHwid.Data2 = License.dwFloppyBiosChkSum;
pLicensedProduct->ClientHwid.Data3 = License.dwHardDiskSize;
pLicensedProduct->ClientHwid.Data4 = License.dwRamSize;
pLicensedProduct->bTemp = (keypack.ucAgreementType == LSKEYPACKTYPE_TEMPORARY);
pLicensedProduct->NotBefore = notBefore;
pLicensedProduct->NotAfter = notAfter;
pLicensedProduct->dwProductVersion = MAKELONG(keypack.wMinorVersion, keypack.wMajorVersion);
_tcscpy(pLicensedProduct->szCompanyName, keypack.szCompanyName);
_tcscpy(pLicensedProduct->szLicensedProductId, keypack.szProductId);
_tcscpy(pLicensedProduct->szRequestProductId, pLicenseRequest->pClientLicenseRequest->pszProductId);
_tcscpy(pLicensedProduct->szUserName, License.szUserName);
_tcscpy(pLicensedProduct->szMachineName, License.szMachineName);
pLicensedProduct->dwLanguageID = pLicenseRequest->dwLanguageID;
pLicensedProduct->dwPlatformID = pLicenseRequest->dwPlatformID;
pLicensedProduct->pbPolicyData = (pPolModCertExtension) ? pPolModCertExtension->pbData : NULL;
pLicensedProduct->cbPolicyData = (pPolModCertExtension) ? pPolModCertExtension->cbData : 0;
if (NULL != pucMarked)
{
// this field is being reused for marking (e.g. user is authenticated)
*pucMarked = License.ucEntryStatus;
}
cleanup:
return (dwStatus == ERROR_SUCCESS) ? dwRetCode : dwStatus;
}
Reference in a new issue Copy permalink