windows-nt/Source/XPSP1/NT/termsrv/license/tlserver/server/forward.cpp

674 lines
18 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// File: forward.cpp
//
// Contents: Forward license request.
//
// History:
//
//---------------------------------------------------------------------------
#include "pch.cpp"
#include "globals.h"
#include "srvlist.h"
#include "forward.h"
#include "keypack.h"
#include "postjob.h"
//-----------------------------------------------------------------------
CopyRpcTLSRequestToRequest(
TLSLICENSEREQUEST* lpRpcRequest ,
LICENSEREQUEST* lpRequest
)
/*++
--*/
{
lpRequest->cbEncryptedHwid = lpRpcRequest->cbEncryptedHwid;
lpRequest->pbEncryptedHwid = lpRpcRequest->pbEncryptedHwid;
lpRequest->dwLanguageID = lpRpcRequest->dwLanguageID;
lpRequest->dwPlatformID = lpRpcRequest->dwPlatformID;
lpRequest->pProductInfo->dwVersion = lpRpcRequest->ProductInfo.dwVersion;
lpRequest->pProductInfo->cbCompanyName = lpRpcRequest->ProductInfo.cbCompanyName;
lpRequest->pProductInfo->pbCompanyName = lpRpcRequest->ProductInfo.pbCompanyName;
lpRequest->pProductInfo->cbProductID = lpRpcRequest->ProductInfo.cbProductID;
lpRequest->pProductInfo->pbProductID = lpRpcRequest->ProductInfo.pbProductID;
return ERROR_SUCCESS;
}
//-----------------------------------------------------------------------
DWORD
ForwardUpgradeLicenseRequest(
IN LPTSTR pszServerSetupId,
IN OUT DWORD *pdwSupportFlags,
IN TLSLICENSEREQUEST* pRequest,
IN CHALLENGE_CONTEXT ChallengeContext,
IN DWORD cbChallengeResponse,
IN PBYTE pbChallengeResponse,
IN DWORD cbOldLicense,
IN PBYTE pbOldLicense,
OUT PDWORD pcbNewLicense,
OUT PBYTE* ppbNewLicense,
OUT PDWORD pdwErrCode
)
/*++
--*/
{
TLS_HANDLE hHandle = NULL;
DWORD dwStatus;
LICENSEREQUEST LicenseRequest;
BYTE pbEncryptedHwid[1024]; // encrypted HWID can't be more than 1024
TCHAR szCompanyName[LSERVER_MAX_STRING_SIZE+2];
TCHAR szProductId[LSERVER_MAX_STRING_SIZE+2];
Product_Info ProductInfo;
TLServerInfo ServerInfo;
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_RPC,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("ForwardUpgradeLicenseRequest() ...\n")
);
dwStatus = TLSLookupRegisteredServer(
pszServerSetupId,
NULL,
NULL,
&ServerInfo
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
if(TLSCanForwardRequest(
TLS_CURRENT_VERSION,
ServerInfo.GetServerVersion()
) == FALSE)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
goto cleanup;
}
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_RPC,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("ForwardUpgradeLicenseRequest() to %s %s\n"),
pszServerSetupId,
ServerInfo.GetServerName()
);
hHandle = TLSConnectToServerWithServerId(pszServerSetupId);
if(hHandle == NULL)
{
//
// server not available
//
dwStatus = GetLastError();
goto cleanup;
}
//
// RPC AC if pass in the original address
// TlsRequestToRequest(pTlsRequest, &LicenseRequest);
if(pRequest->cbEncryptedHwid >= sizeof(pbEncryptedHwid))
{
TLSASSERT(FALSE);
SetLastError(dwStatus = ERROR_INVALID_DATA);
goto cleanup;
}
if(pRequest->ProductInfo.cbCompanyName >= sizeof(szCompanyName) ||
pRequest->ProductInfo.cbProductID >= sizeof(szProductId) )
{
TLSASSERT(FALSE);
SetLastError(dwStatus = ERROR_INVALID_DATA);
goto cleanup;
}
memset(&LicenseRequest, 0, sizeof(LicenseRequest));
memcpy(
pbEncryptedHwid,
pRequest->pbEncryptedHwid,
pRequest->cbEncryptedHwid
);
LicenseRequest.pbEncryptedHwid = pbEncryptedHwid;
LicenseRequest.cbEncryptedHwid = pRequest->cbEncryptedHwid;
LicenseRequest.dwLanguageID = pRequest->dwLanguageID;
LicenseRequest.dwPlatformID = pRequest->dwPlatformID;
LicenseRequest.pProductInfo = &ProductInfo;
ProductInfo.dwVersion = pRequest->ProductInfo.dwVersion;
ProductInfo.pbCompanyName = (PBYTE)szCompanyName;
ProductInfo.pbProductID = (PBYTE)szProductId;
ProductInfo.cbCompanyName = pRequest->ProductInfo.cbCompanyName;
ProductInfo.cbProductID = pRequest->ProductInfo.cbProductID;
memset(szCompanyName, 0, sizeof(szCompanyName));
memset(szProductId, 0, sizeof(szProductId));
memcpy(
szCompanyName,
pRequest->ProductInfo.pbCompanyName,
pRequest->ProductInfo.cbCompanyName
);
memcpy(
szProductId,
pRequest->ProductInfo.pbProductID,
pRequest->ProductInfo.cbProductID
);
if(IsServiceShuttingdown() == TRUE)
{
dwStatus = TLS_I_SERVICE_STOP;
}
else
{
dwStatus = TLSUpgradeLicenseEx(
hHandle,
pdwSupportFlags,
&LicenseRequest,
ChallengeContext,
cbChallengeResponse,
pbChallengeResponse,
cbOldLicense,
pbOldLicense,
1, // dwQuantity
pcbNewLicense,
ppbNewLicense,
pdwErrCode
);
}
cleanup:
if(hHandle)
{
TLSDisconnectFromServer(hHandle);
}
return dwStatus;
}
//-----------------------------------------------------------------------
DWORD
ForwardNewLicenseRequest(
IN LPTSTR pszServerSetupId,
IN OUT DWORD *pdwSupportFlags,
IN CHALLENGE_CONTEXT ChallengeContext,
IN PTLSLICENSEREQUEST pRequest,
IN LPTSTR pszMachineName,
IN LPTSTR pszUserName,
IN DWORD cbChallengeResponse,
IN PBYTE pbChallengeResponse,
IN BOOL bAcceptTemporaryLicense,
IN BOOL bAcceptFewerLicenses,
IN OUT DWORD *pdwQuantity,
OUT PDWORD pcbLicense,
OUT PBYTE *ppbLicense,
IN OUT PDWORD pdwErrCode
)
/*++
++*/
{
TLS_HANDLE hHandle = NULL;
DWORD dwStatus;
LICENSEREQUEST LicenseRequest;
BYTE pbEncryptedHwid[1024]; // encrypted HWID can't be more than 1024
TCHAR szCompanyName[LSERVER_MAX_STRING_SIZE+2];
TCHAR szProductId[LSERVER_MAX_STRING_SIZE+2];
Product_Info ProductInfo;
TLServerInfo ServerInfo;
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_RPC,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("ForwardNewLicenseRequest() ...\n")
);
dwStatus = TLSLookupRegisteredServer(
pszServerSetupId,
NULL,
NULL,
&ServerInfo
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
if(TLSCanForwardRequest(
TLS_CURRENT_VERSION,
ServerInfo.GetServerVersion()
) == FALSE)
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
goto cleanup;
}
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_RPC,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("ForwardNewLicenseRequest() to %s %s\n"),
pszServerSetupId,
ServerInfo.GetServerName()
);
hHandle = TLSConnectToServerWithServerId(pszServerSetupId);
if(hHandle == NULL)
{
//
// server not available
//
dwStatus = GetLastError();
goto cleanup;
}
//TlsRequestToRequest(pRequest, &LicenseRequest);
if(pRequest->cbEncryptedHwid >= sizeof(pbEncryptedHwid))
{
TLSASSERT(FALSE);
SetLastError(dwStatus = ERROR_INVALID_DATA);
goto cleanup;
}
if(pRequest->ProductInfo.cbCompanyName >= sizeof(szCompanyName) ||
pRequest->ProductInfo.cbProductID >= sizeof(szProductId) )
{
TLSASSERT(FALSE);
SetLastError(dwStatus = ERROR_INVALID_DATA);
goto cleanup;
}
memset(&LicenseRequest, 0, sizeof(LicenseRequest));
memcpy(
pbEncryptedHwid,
pRequest->pbEncryptedHwid,
pRequest->cbEncryptedHwid
);
LicenseRequest.pbEncryptedHwid = pbEncryptedHwid;
LicenseRequest.cbEncryptedHwid = pRequest->cbEncryptedHwid;
LicenseRequest.dwLanguageID = pRequest->dwLanguageID;
LicenseRequest.dwPlatformID = pRequest->dwPlatformID;
LicenseRequest.pProductInfo = &ProductInfo;
ProductInfo.dwVersion = pRequest->ProductInfo.dwVersion;
ProductInfo.pbCompanyName = (PBYTE)szCompanyName;
ProductInfo.pbProductID = (PBYTE)szProductId;
ProductInfo.cbCompanyName = pRequest->ProductInfo.cbCompanyName;
ProductInfo.cbProductID = pRequest->ProductInfo.cbProductID;
memset(szCompanyName, 0, sizeof(szCompanyName));
memset(szProductId, 0, sizeof(szProductId));
memcpy(
szCompanyName,
pRequest->ProductInfo.pbCompanyName,
pRequest->ProductInfo.cbCompanyName
);
memcpy(
szProductId,
pRequest->ProductInfo.pbProductID,
pRequest->ProductInfo.cbProductID
);
if(IsServiceShuttingdown() == TRUE)
{
dwStatus = TLS_I_SERVICE_STOP;
}
else
{
dwStatus = TLSIssueNewLicenseExEx(
hHandle,
pdwSupportFlags,
ChallengeContext,
&LicenseRequest,
pszMachineName,
pszUserName,
cbChallengeResponse,
pbChallengeResponse,
bAcceptTemporaryLicense,
bAcceptFewerLicenses,
pdwQuantity,
pcbLicense,
ppbLicense,
pdwErrCode
);
}
cleanup:
if(hHandle)
{
TLSDisconnectFromServer(hHandle);
}
return dwStatus;
}
//---------------------------------------------------------
DWORD
TLSForwardUpgradeRequest(
IN PTLSForwardUpgradeLicenseRequest pForward,
IN OUT DWORD *pdwSupportFlags,
IN PTLSDBLICENSEREQUEST pRequest,
OUT PDWORD pcbLicense,
OUT PBYTE* ppbLicense
)
/*++
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD dwErrCode = ERROR_SUCCESS;
PTLSDbWorkSpace pDbWkSpace = NULL;
TLServerInfo ServerInfo;
TLSLICENSEPACK search;
TLSLICENSEPACK found;
DWORD dwSupportFlagsTemp;
SAFESTRCPY(search.szProductId,pRequest->pszProductId);
pDbWkSpace = AllocateWorkSpace(g_EnumDbTimeout);
if(pDbWkSpace == NULL)
{
dwStatus=TLS_E_ALLOCATE_HANDLE;
goto cleanup;
}
try {
dwStatus = TLSDBKeyPackEnumBegin(
pDbWkSpace,
TRUE,
LSKEYPACK_SEARCH_PRODUCTID,
&search
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
while( (dwStatus = TLSDBKeyPackEnumNext(pDbWkSpace, &found)) == ERROR_SUCCESS )
{
if(IsServiceShuttingdown() == TRUE)
{
SetLastError(dwStatus = TLS_I_SERVICE_STOP);
break;
}
#if 0
if(!(found.ucAgreementType & LSKEYPACK_REMOTE_TYPE))
{
continue;
}
#endif
if(!(found.ucKeyPackStatus & LSKEYPACKSTATUS_REMOTE))
{
continue;
}
if(found.wMajorVersion < HIWORD(pRequest->dwProductVersion))
{
continue;
}
if(found.wMinorVersion < LOWORD(pRequest->dwProductVersion))
{
continue;
}
if((found.dwPlatformType & ~LSKEYPACK_PLATFORM_REMOTE) != pRequest->dwPlatformID)
{
continue;
}
if(_tcsicmp(found.szCompanyName, pRequest->pszCompanyName) != 0)
{
continue;
}
//
// Save the original Support flags; they can be changed
//
dwSupportFlagsTemp = *pdwSupportFlags;
//
// make call to remote server
//
dwStatus = ForwardUpgradeLicenseRequest(
found.szInstallId,
&dwSupportFlagsTemp,
pForward->m_pRequest,
pForward->m_ChallengeContext,
pForward->m_cbChallengeResponse,
pForward->m_pbChallengeResponse,
pForward->m_cbOldLicense,
pForward->m_pbOldLicense,
pcbLicense,
ppbLicense,
&dwErrCode
);
if (dwStatus == ERROR_SUCCESS &&
dwErrCode == LSERVER_S_SUCCESS)
{
*pdwSupportFlags = dwSupportFlagsTemp;
break;
}
if (dwStatus == TLS_I_SERVICE_STOP)
{
break;
}
// try next server
dwStatus = ERROR_SUCCESS;
}
TLSDBKeyPackEnumEnd(pDbWkSpace);
}
catch( SE_Exception e ) {
dwStatus = e.getSeNumber();
}
catch( ... ) {
dwStatus = TLS_E_INTERNAL;
}
cleanup:
if(pDbWkSpace != NULL)
{
ReleaseWorkSpace(&pDbWkSpace);
}
return dwStatus;
}
//-----------------------------------------------------------------------
DWORD
TLSForwardLicenseRequest(
IN PTLSForwardNewLicenseRequest pForward,
IN OUT DWORD *pdwSupportFlags,
IN PTLSDBLICENSEREQUEST pRequest,
IN BOOL bAcceptFewerLicenses,
IN OUT DWORD *pdwQuantity,
OUT PDWORD pcbLicense,
OUT PBYTE* ppbLicense
)
/*++
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD dwErrCode = ERROR_SUCCESS;
PTLSDbWorkSpace pDbWkSpace = NULL;
TLServerInfo ServerInfo;
TLSLICENSEPACK search;
TLSLICENSEPACK found;
DWORD dwSupportFlagsTemp;
DWORD dwQuantityTemp;
SAFESTRCPY(search.szProductId,pRequest->pszProductId);
pDbWkSpace = AllocateWorkSpace(g_EnumDbTimeout);
if(pDbWkSpace == NULL)
{
dwStatus=TLS_E_ALLOCATE_HANDLE;
goto cleanup;
}
try {
dwStatus = TLSDBKeyPackEnumBegin(
pDbWkSpace,
TRUE,
LSKEYPACK_SEARCH_PRODUCTID,
&search
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
while( (dwStatus = TLSDBKeyPackEnumNext(pDbWkSpace, &found)) == ERROR_SUCCESS )
{
if(IsServiceShuttingdown() == TRUE)
{
SetLastError(dwStatus = TLS_I_SERVICE_STOP);
break;
}
#if 0
if(!(found.ucAgreementType & LSKEYPACK_REMOTE_TYPE))
{
continue;
}
#endif
if(!(found.ucKeyPackStatus & LSKEYPACKSTATUS_REMOTE))
{
continue;
}
if(found.wMajorVersion < HIWORD(pRequest->dwProductVersion))
{
continue;
}
if(found.wMinorVersion < LOWORD(pRequest->dwProductVersion))
{
continue;
}
if((found.dwPlatformType & ~LSKEYPACK_PLATFORM_REMOTE) != pRequest->dwPlatformID)
{
continue;
}
if(_tcsicmp(found.szCompanyName, pRequest->pszCompanyName) != 0)
{
continue;
}
//
// Save the original support flags and quantity;
// they can be changed
//
dwSupportFlagsTemp = *pdwSupportFlags;
dwQuantityTemp = *pdwQuantity;
//
// make call to remote server
//
dwStatus = ForwardNewLicenseRequest(
found.szInstallId,
&dwSupportFlagsTemp,
pForward->m_ChallengeContext,
pForward->m_pRequest,
pForward->m_szMachineName,
pForward->m_szUserName,
pForward->m_cbChallengeResponse,
pForward->m_pbChallengeResponse,
FALSE, // bAcceptTemporaryLicense
bAcceptFewerLicenses,
&dwQuantityTemp,
pcbLicense,
ppbLicense,
&dwErrCode
);
if (dwStatus == ERROR_SUCCESS &&
dwErrCode == LSERVER_S_SUCCESS)
{
*pdwSupportFlags = dwSupportFlagsTemp;
*pdwQuantity = dwQuantityTemp;
break;
}
if (dwStatus == TLS_I_SERVICE_STOP)
{
break;
}
// try next server
dwStatus = ERROR_SUCCESS;
}
TLSDBKeyPackEnumEnd(pDbWkSpace);
}
catch( SE_Exception e ) {
dwStatus = e.getSeNumber();
}
catch( ... ) {
dwStatus = TLS_E_INTERNAL;
}
cleanup:
if(pDbWkSpace != NULL)
{
ReleaseWorkSpace(&pDbWkSpace);
}
return dwStatus;
}