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

1240 lines
32 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-1996
//
// File: rpc.c
//
// Contents: Various RPC function to accept client request
//
// History: 12-09-98 HueiWang Created
// 05-26-98 HueiWang Move all code to TLSRpcXXX
// API here is only for compatible with
// NT40 Hydra
//---------------------------------------------------------------------------
#include "pch.cpp"
#include "globals.h"
#include "server.h"
#include "init.h"
//+------------------------------------------------------------------------
error_status_t
LSGetRevokeKeyPackList(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [out][in] */ PDWORD pcbNumberOfKeyPack,
/* [size_is][out][in] */ PDWORD pRevokeKeyPackList
)
/*
Note : For backward compatible with NT40 Hydra only
*/
{
*pcbNumberOfKeyPack=0;
return ERROR_SUCCESS;
}
//+------------------------------------------------------------------------
error_status_t
LSGetRevokeLicenseList(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [out][in] */ PDWORD pcbNumberOfLicenses,
/* [size_is][out][in] */ PDWORD pRevokeLicenseList
)
/*
Note : For backward compatible with NT40 Hydra only
*/
{
*pcbNumberOfLicenses=0;
return ERROR_SUCCESS;
}
//+------------------------------------------------------------------------
error_status_t
LSValidateLicense(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD cbLicense,
/* [size_is][in] */ BYTE __RPC_FAR *pbLicense
)
/*
Note : For backward compatible with NT40 Hydra only
*/
{
return TLSMapReturnCode(TLS_E_NOTSUPPORTED);
}
//+------------------------------------------------------------------------
error_status_t
LSConnect(
/* [in] */ handle_t hRpcBinding,
/* [out] */ PCONTEXT_HANDLE __RPC_FAR *pphContext
)
{
return TLSRpcConnect( hRpcBinding, pphContext );
}
//-----------------------------------------------------------------------
error_status_t
LSSendServerCertificate(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD cbCert,
/* [size_is][in] */ PBYTE pbCert
)
{
DWORD status = ERROR_SUCCESS;
TLSRpcSendServerCertificate(
phContext,
cbCert,
pbCert,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSDisconnect(
/* [out][in] */ PPCONTEXT_HANDLE pphContext
)
{
return TLSRpcDisconnect(pphContext);
}
//+------------------------------------------------------------------------
error_status_t
LSGetServerName(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [size_is][string][out][in] */ LPTSTR szMachineName,
/* [out][in] */ PDWORD pcbSize
)
/*
Description :
Return Server's Machine Name.
Arguments:
phContext - client context handle.
szMachineName - Pointer to a buffer that receives a null-terminated
string containing the computer name. The buffer size
should be large enough to contain
MAX_COMPUTERNAME_LENGTH + 1 characters.
cbSize - Pointer to a DWORD variable. On input, the variable
specifies the size, in bytes or characters, of the buffer.
On output, the variable returns the number of bytes or characters
copied to the destination buffer, not including the terminating
null character.
Returns:
LSERVER_S_SUCCESS
*/
{
DWORD dwErrCode=ERROR_SUCCESS;
TLSRpcGetServerName(
phContext,
szMachineName,
pcbSize,
&dwErrCode
);
return dwErrCode;
}
//+------------------------------------------------------------------------
error_status_t
LSGetServerScope(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [size_is][string][out][in] */ LPTSTR szScopeName,
/* [out][in] */ PDWORD pcbSize
)
/*
Description:
Return License Server's scope
Arguments:
IN phContext - Client context
IN OUT szScopeName - return server's scope, must be at least
MAX_COMPUTERNAME_LENGTH in length
Return Value:
LSERVER_S_SUCCESS or error code from WideCharToMultiByte()
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcGetServerScope(
phContext,
szScopeName,
pcbSize,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSGetInfo(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD cbHSCert,
/* [size_is][ref][in] */ PBYTE pHSCert,
/* [ref][out] */ PDWORD pcbLSCert,
/* [size_is][size_is][out] */ BYTE __RPC_FAR *__RPC_FAR *pLSCert,
/* [ref][out] */ PDWORD pcbLSSecretKey,
/* [size_is][size_is][out] */ BYTE __RPC_FAR *__RPC_FAR *pLSSecretKey
)
/*
Description:
Routine to exchange Hydra server's certificate and License server's
certificate/private key for signing client machine's hardware ID.
Arguments:
IN phContext - client context handle
IN cbHSCert - size of Hydra Server's certificate
IN pHSCert - Hydra Server's certificate
IN OUT pcbLSCert - return size of License Server's certificate
OUT pLSCert - return License Server's certificate
OUT pcbLSSecretKey - return size of License Server's private key.
OUT pLSSecretKey - retrun License Server's private key
Return Value:
LSERVER_S_SUCCESS success
LSERVER_E_INVALID_DATA Invalid hydra server certificate
LSERVER_E_OUTOFMEMORY Can't allocate required memory
TLS_E_INTERNAL Internal error occurred in License Server
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcGetInfo(
phContext,
cbHSCert,
pHSCert,
pcbLSCert,
pLSCert,
pcbLSSecretKey,
pLSSecretKey,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSGetLastError(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD cbBufferSize,
/* [string][out][in] */ LPTSTR szBuffer
)
/*
Description:
Return error description text for client's last LSXXX call
Arguments:
IN phContext - Client context
IN cbBufferSize - max. size of szBuffer
IN OUT szBuffer - Pointer to a buffer to receive the
null-terminated character string containing
error description
Note:
Return ANSI error string.
Returns:
LSERVER_S_SUCCESS
TLS_E_INTERNAL No error or can't find corresponding error
description.
Error code from WideCharToMultiByte().
*/
{
DWORD status;
TLSRpcGetLastError(
phContext,
&cbBufferSize,
szBuffer,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSIssuePlatformChallenge(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwClientInfo,
/* [ref][out] */ PCHALLENGE_CONTEXT pChallengeContext,
/* [out] */ PDWORD pcbChallengeData,
/* [size_is][size_is][out] */ BYTE __RPC_FAR *__RPC_FAR *pChallengeData
)
/*
Description:
Issue a platform challenge to hydra client.
Arguments:
IN phContext - client context handle
IN dwClientInfo - client info.
OUT pChallengeContext - pointer to client challenge context.
OUT pcbChallengeData - size of challenge data.
OUT pChallengeData - random client challenge data.
Returns:
LSERVER_S_SUCCESS
LSERVER_E_OUTOFMEMORY
LSERVER_E_INVALID_DATA Invalid client info.
LSERVER_E_SERVER_BUSY
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcIssuePlatformChallenge(
phContext,
dwClientInfo,
pChallengeContext,
pcbChallengeData,
pChallengeData,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSAllocateConcurrentLicense(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [string][in] */ LPTSTR szHydraServer,
/* [in] */ LICENSE_REQUEST_TYPE __RPC_FAR *pRequest,
/* [ref][out][in] */ LONG __RPC_FAR *dwQuantity
)
/*
Description:
Allocate concurrent licenses base on product.
Arguments:
IN phContext - client context handle
IN szHydraServer - name of hydra server requesting concurrent licenses
IN pRequest - product to request for concurrent license.
IN OUT dwQuantity - See note
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_INVALID_DATA Invalid parameter.
LSERVER_E_NO_PRODUCT request product not installed
LSERVER_E_NO_LICNESE no available license for request product
LSERVER_E_LICENSE_REVOKED Request license has been revoked
LSERVER_E_LICENSE_EXPIRED Request license has expired
LSERVER_E_CORRUPT_DATABASE Corrupt database
LSERVER_E_INTERNAL_ERROR Internal error in license server
Note:
dwQuantity
Input Output
------------------------- -----------------------------------------
0 Total number of concurrent license
issued to hydra server.
> 0, number of license Actual number of license allocated
requested
< 0, number of license Actual number of license returned, always
to return positive value.
*/
{
DWORD status=ERROR_SUCCESS;
TLSLICENSEREQUEST RpcRequest;
RequestToTlsRequest(pRequest, &RpcRequest);
TLSRpcAllocateConcurrentLicense(
phContext,
szHydraServer,
&RpcRequest,
dwQuantity,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSIssueNewLicense(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ CHALLENGE_CONTEXT ChallengeContext,
/* [in] */ LICENSE_REQUEST_TYPE __RPC_FAR *pRequest_org,
/* [string][in] */ LPTSTR szMachineName,
/* [string][in] */ LPTSTR szUserName,
/* [in] */ DWORD cbChallengeResponse,
/* [size_is][in] */ PBYTE cbChallenge,
/* [in] */ BOOL bAcceptTemporaryLicense,
/* [out] */ PDWORD pcbLicense,
/* [size_is][size_is][out] */ BYTE __RPC_FAR *__RPC_FAR *ppLicense
)
/*
Description:
Routine to issue new license to hydra client based on product requested,
it returns existing license if client already has a license and the
license is not expired/returned/revoked, if request product has not been
installed, it will issue a temporary license, if license found is temporary
or expired, it will tried to upgrade/re-issue a new license with latest
version of requested product, if the existing license is temporary and
no license can be issued, it returns LSERVER_E_LICENSE_EXPIRED
Arguments:
IN phContext - client context handle.
IN ChallengeContext - client challenge context handle, return from
call LSIssuePlatformChallenge()
IN cbChallengeResponse - size of the client's response to license server's
platform challenge.
IN pbChallenge - client's response to license server's platform challenge
OUT pcbLicense - size of return license.
OUT ppLicense - return license, could be old license
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_OUTOFMEMORY
LSERVER_E_SERVER_BUSY Server is busy to process request.
LSERVER_E_INVALID_DATA Invalid platform challenge response.
LSERVER_E_NO_LICENSE No license available.
LSERVER_E_NO_PRODUCT Request product is not installed on server.
LSERVER_E_LICENSE_REJECTED License request is rejected by cert. server
LSERVER_E_LICENSE_REVOKED Old license found and has been revoked
LSERVER_E_LICENSE_EXPIRED Request product's license has expired
LSERVER_E_CORRUPT_DATABASE Corrupted database.
LSERVER_E_INTERNAL_ERROR Internal error in license server
LSERVER_I_PROXIMATE_LICENSE Closest match license returned.
LSERVER_I_TEMPORARY_LICENSE Temporary license has been issued
LSERVER_I_LICENSE_UPGRADED Old license has been upgraded.
*/
{
DWORD status=ERROR_SUCCESS;
TLSLICENSEREQUEST RpcRequest;
RequestToTlsRequest(pRequest_org, &RpcRequest);
TLSRpcRequestNewLicense(
phContext,
ChallengeContext,
&RpcRequest,
szMachineName,
szUserName,
cbChallengeResponse,
cbChallenge,
bAcceptTemporaryLicense,
pcbLicense,
ppLicense,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSUpgradeLicense(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD cbOldLicense,
/* [size_is][in] */ PBYTE pbOldLicense,
/* [in] */ DWORD dwClientInfo,
/* [out] */ PDWORD pcbNewLicense,
/* [size_is][size_is][out] */ PBYTE __RPC_FAR *ppbNewLicense
)
/*
Description:
Update an old license.
Arguments:
IN phContext - client context handle.
IN cbOldLicense - size of license to be upgraded.
IN pOldLicense - license to be upgrade.
OUT pcbNewLicense - size of upgraded license
OUT pNewLicense - upgraded license.
Return Value:
LSERVER_S_SUCCESS
TLS_E_INTERNAL
LSERVER_E_INTERNAL_ERROR
LSERVER_E_INVALID_DATA old license is invalid.
LSERVER_E_NO_LICENSE no available license
LSERVER_E_NO_PRODUCT request product not install in current server.
LSERVER_E_CORRUPT_DATABASE Corrupted database.
LSERVER_E_LICENSE_REJECTED License request rejected by cert. server.
LSERVER_E_SERVER_BUSY
Note:
Only support upgrading temporary license to permanent license.
*/
{
DWORD status = ERROR_SUCCESS;
PBYTE pbEncodedCert=NULL;
DWORD cbEncodedCert=0;
BOOL bTemporaryLicense;
LPCLIENTCONTEXT lpContext = (LPCLIENTCONTEXT)phContext;
DWORD dwNumLicensedProduct=0;
PLICENSEDPRODUCT pLicensedProduct=NULL;
DBGPrintf(
DBG_INFORMATION,
DBG_FACILITY_RPC,
DBGLEVEL_FUNCTION_TRACE,
_TEXT("%s : LSUpgradeLicense\n"),
lpContext->m_Client
);
InterlockedIncrement( &lpContext->m_RefCount );
do {
if(!(lpContext->m_ClientFlags & CLIENT_ACCESS_REQUEST))
{
status = TLS_E_ACCESS_DENIED;
break;
}
if(CanIssuePermLicense() == FALSE)
{
// no upgrade if certificate not available
status = TLS_E_NO_CERTIFICATE;
break;
}
//
// convert license back to product request structure.
//
status=LSVerifyDecodeClientLicense(
pbOldLicense,
cbOldLicense,
g_pbSecretKey,
g_cbSecretKey,
&dwNumLicensedProduct,
pLicensedProduct
);
if(status != LICENSE_STATUS_OK)
{
break;
}
pLicensedProduct = (PLICENSEDPRODUCT)AllocateMemory(
dwNumLicensedProduct * sizeof(LICENSEDPRODUCT)
);
if(pLicensedProduct == NULL)
{
status = GetLastError();
break;
}
status=LSVerifyDecodeClientLicense(
pbOldLicense,
cbOldLicense,
g_pbSecretKey,
g_cbSecretKey,
&dwNumLicensedProduct,
pLicensedProduct
);
if(status != LICENSE_STATUS_OK)
{
break;
}
RPC_STATUS rpcStatus;
TLSLICENSEREQUEST request;
RequestToTlsRequest(&pLicensedProduct->LicensedProduct, &request);
if( (_tcsnicmp(
_TEXT(HYDRA_PRODUCTID_SKU),
(LPTSTR)pLicensedProduct->LicensedProduct.pProductInfo->pbProductID,
_tcslen(_TEXT(HYDRA_PRODUCTID_SKU)) ) == 0) ||
(_tcsnicmp(
TERMSERV_PRODUCTID_SKU,
(LPTSTR)pLicensedProduct->LicensedProduct.pProductInfo->pbProductID,
_tcslen(TERMSERV_PRODUCTID_SKU) ) == 0) )
{
//
// Terminal Server client specific code
//
request.ProductInfo.pbProductID = (PBYTE) TERMSERV_PRODUCTID_SKU;
request.ProductInfo.cbProductID = (DWORD) (_tcslen(TERMSERV_PRODUCTID_SKU) + 1) * sizeof(TCHAR);
request.dwPlatformID = dwClientInfo;
}
rpcStatus = TLSRpcUpgradeLicense(
phContext,
&request,
TLSERVER_CHALLENGE_CONTEXT,
0,
NULL,
cbOldLicense,
pbOldLicense,
pcbNewLicense,
ppbNewLicense,
&status
);
} while(FALSE);
if( (status == LSERVER_E_NO_PRODUCT || status == LSERVER_E_NO_LICENSE)
&& (pLicensedProduct != NULL) && (pLicensedProduct->pLicensedVersion != NULL)
&& !(pLicensedProduct->pLicensedVersion->dwFlags & LICENSED_VERSION_TEMPORARY) )
{
//
// backward compatible - always returns success in the case of perm. license
//
*ppbNewLicense = (PBYTE)midl_user_allocate(cbOldLicense);
if(*ppbNewLicense != NULL)
{
memcpy(*ppbNewLicense, pbOldLicense, cbOldLicense);
*pcbNewLicense = cbOldLicense;
status = ERROR_SUCCESS;
}
else
{
status = TLS_E_ALLOCATE_MEMORY;
}
}
//if(pbSaveData != NULL)
//{
// pLicensedProduct->pbOrgProductID = pbSaveData;
// pLicensedProduct->cbOrgProductID = cbSaveData;
//}
for(DWORD index =0; index < dwNumLicensedProduct; index++)
{
LSFreeLicensedProduct(pLicensedProduct+index);
}
FreeMemory(pLicensedProduct);
lpContext->m_LastError=status;
InterlockedDecrement( &lpContext->m_RefCount );
// midl_user_free(pOldLicense);
#if DBG
lpContext->m_LastCall = RPC_CALL_UPGRADELICENSE;
#endif
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSKeyPackEnumBegin(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwSearchParm,
/* [in] */ BOOL bMatchAll,
/* [ref][in] */ LPLSKeyPackSearchParm lpSearchParm
)
/*
Description:
Function to begin enumerate through all key pack installed on server
based on search criterial.
Arguments:
IN phContext - client context handle.
IN dwSearchParm - search criterial.
IN bMatchAll - match all search criterial.
IN lpSearchParm - search parameter.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_SERVER_BUSY Server is too busy to process request
LSERVER_E_OUTOFMEMORY
TLS_E_INTERNAL
LSERVER_E_INTERNAL_ERROR
LSERVER_E_INVALID_DATA Invalid data in search parameter
LSERVER_E_INVALID_SEQUENCE Invalid calling sequence, likely, previous
enumeration has not ended.
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcKeyPackEnumBegin(
phContext,
dwSearchParm,
bMatchAll,
lpSearchParm,
&status
);
return status;
}
//+------------------------------------------------------------------------
DWORD
LSKeyPackEnumNext(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [ref][out] */ LPLSKeyPack lpKeyPack
)
/*
Description:
Return next key pack that match search criterial
Arguments:
IN phContext - client context handle
OUT lpKeyPack - key pack that match search criterial
Return Value:
LSERVER_S_SUCCESS
LSERVER_I_NO_MORE_DATA No more keypack match search criterial
TLS_E_INTERNAL General error in license server
LSERVER_E_INTERNAL_ERROR Internal error in license server
LSERVER_E_SERVER_BUSY License server is too busy to process request
LSERVER_E_OUTOFMEMORY Can't process request due to insufficient memory
LSERVER_E_INVALID_SEQUENCE Invalid calling sequence, must call
LSKeyPackEnumBegin().
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcKeyPackEnumNext(
phContext,
lpKeyPack,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSKeyPackEnumEnd(
/* [in] */ PCONTEXT_HANDLE phContext
)
/*
Description:
Routine to end an enumeration on key pack.
Arguments:
IN phContext - client context handle.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_INTERNAL_ERROR Internal error occurred in license server
TLS_E_INTERNAL General error occurred in license server
LSERVER_E_INVALID_HANDLE Has not call LSKeyPackEnumBegin()
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcKeyPackEnumEnd(phContext, &status);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSKeyPackAdd(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [ref][out][in] */ LPLSKeyPack lpKeypack
)
/*
Description:
Add a license key pack.
Arguments:
IN phContext - client context handle.
IN OUT lpKeyPack - key pack to be added.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_INTERNAL_ERROR
TLS_E_INTERNAL
LSERVER_E_SERVER_BUSY
LSERVER_E_DUPLICATE Product already installed.
LSERVER_E_INVALID_DATA
LSERVER_E_CORRUPT_DATABASE
Note:
Application must call LSKeyPackSetStatus() to activate keypack
*/
{
#if !defined(ENFORCE_LICENSING) || defined(PRIVATE_DBG)
DWORD status=ERROR_SUCCESS;
TLSRpcKeyPackAdd(phContext, lpKeypack, &status);
return status;
#else
return TLSMapReturnCode(TLS_E_NOTSUPPORTED);
#endif
}
//+------------------------------------------------------------------------
error_status_t
LSKeyPackSetStatus(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwSetParam,
/* [ref][in] */ LPLSKeyPack lpKeyPack
)
/*
Description:
Routine to activate/deactivated a key pack.
Arguments:
IN phContext - client context handle
IN dwSetParam - type of key pack status to be set.
IN lpKeyPack - new key pack status.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_INTERNAL_ERROR
TLS_E_INTERNAL
LSERVER_E_INVALID_DATA
LSERVER_E_SERVER_BUSY
LSERVER_E_DATANOTFOUND Key pack is not in server
LSERVER_E_CORRUPT_DATABASE
*/
{
#if !defined(ENFORCE_LICENSING) || defined(PRIVATE_DBG)
DWORD status=ERROR_SUCCESS;
TLSRpcKeyPackSetStatus(
phContext,
dwSetParam,
lpKeyPack,
&status
);
return status;
#else
return TLSMapReturnCode(TLS_E_NOTSUPPORTED);
#endif
}
//+------------------------------------------------------------------------
error_status_t
LSLicenseEnumBegin(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwSearchParm,
/* [in] */ BOOL bMatchAll,
/* [ref][in] */ LPLSLicenseSearchParm lpSearchParm
)
/*
Description:
Begin enumeration of license issued based on search criterial
Arguments:
IN phContext - client context handle
IN dwSearchParm - license search criterial.
IN bMatchAll - match all search criterial
IN lpSearchParm - license(s) to be enumerated.
Return Value:
Same as LSKeyPackEnumBegin().
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcLicenseEnumBegin(
phContext,
dwSearchParm,
bMatchAll,
lpSearchParm,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSLicenseEnumNext(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [ref][out] */ LPLSLicense lpLicense
)
/*
Description:
Arguments:
IN phContext - client context handle
OUT lpLicense - license match search criterial.
Return Value:
Same as LSKeyPackEnumNext().
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcLicenseEnumNext(phContext, lpLicense, &status);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSLicenseEnumEnd(
/* [in] */ PCONTEXT_HANDLE phContext
)
/*
Description:
End enumeration of issued licenses.
Arguments:
IN phContext - client context handle.
Return Value:
Same as LSKeyPackEnumEnd().
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcLicenseEnumEnd(phContext, &status);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSLicenseSetStatus(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwSetParam,
/* [in] */ LPLSLicense lpLicense
)
/*
Description:
Routine to set status of a issued license.
Arguments:
IN phContext - client context handle.
IN dwSetParam -
IN lpLicense -
Return Value:
Same as LSKeyPackSetStatus().
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcLicenseSetStatus(
phContext,
dwSetParam,
lpLicense,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSLicenseGetCert(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [ref][in] */ LPLSLicense lpLicense,
/* [out] */ LPDWORD cbCert,
/* [size_is][size_is][out] */ PBYTE __RPC_FAR *pbCert
)
/*
Description:
Retrieve actual certificate issued to client.
Arguments:
IN phContext - client context handle
IN lpLicense -
OUT cbCert - size of certificate.
OUT pbCert - actual certificate.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_INTERNAL_ERROR
TLS_E_INTERNAL
LSERVER_E_INVALID_DATA
LSERVER_E_DATANOTFOUND
LSERVER_E_CORRUPT_DATABASE
*/
{
return LSERVER_S_SUCCESS;
}
//+------------------------------------------------------------------------
error_status_t
LSGetAvailableLicenses(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwSearchParm,
/* [ref][in] */ LPLSKeyPack lplsKeyPack,
/* [ref][out] */ LPDWORD lpdwAvail
)
/*
Description:
Retrieve number of available license for a product.
Arguments:
IN phContext - client context.
IN dwSearchParm -
IN lplsKeyPack -
OUT lpdwAvail -
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_INTERNAL_ERROR
TLS_E_INTERNAL
LSERVER_E_DATANOTFOUND
LSERVER_E_INVALID_DATA
LSERVER_E_CORRUPT_DATABASE
*/
{
DWORD status=ERROR_SUCCESS;
TLSRpcGetAvailableLicenses(
phContext,
dwSearchParm,
lplsKeyPack,
lpdwAvail,
&status
);
return status;
}
//+------------------------------------------------------------------------
error_status_t
LSGetServerCertificate(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ BOOL bSignCert,
/* [size_is][size_is][out] */ LPBYTE __RPC_FAR *ppCertBlob,
/* [ref][out] */ LPDWORD lpdwCertBlobLen
)
/*
Description:
Get License Server's signature or exchange certificate
Arguments:
IN phContext - client context.
IN bSignCert - TRUE if signature certificate, FALSE if exchange certificate
OUT ppCertBlob - pointer to pointer to receive certificate.
OUT lpdwCertBlobLen - size of certificate returned.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_ACCESS_DENIED Client doesn't have required privilege
LSERVER_E_NO_CERTIFICATE License Server hasn't register yet.
*/
{
#if ENFORCE_LICENSING
DWORD status=ERROR_SUCCESS;
TLSRpcGetServerCertificate(
phContext,
bSignCert,
ppCertBlob,
lpdwCertBlobLen,
&status
);
return status;
#else
return TLSMapReturnCode(TLS_E_NOTSUPPORTED);
#endif
}
//+------------------------------------------------------------------------
error_status_t
LSRegisterLicenseKeyPack(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [size_is][in] */ LPBYTE pbCHCertBlob,
/* [in] */ DWORD cbCHCertBlobSize,
/* [size_is][in] */ LPBYTE pbRootCertBlob,
/* [in] */ DWORD cbRootCertBlob,
/* [size_is][in] */ LPBYTE lpKeyPackBlob,
/* [in] */ DWORD dwKeyPackBlobLen
)
/*
Description:
Register (Add) a license key pack into License Server.
Arguments:
IN phContext - client context.
IN pbCHCertBlob - CH's certificate.
IN cbCHCertBlobSize - CH certificate size.
IN pbRootCertBlob - Root's certificate.
IN cbRootCertBlob - Size of Root's certificate.
IN lpKeyPackBlob - pointer to encrypted license KeyPack blob.
IN dwKeyPackBlobLen - size of keypack blob.
Return Value:
LSERVER_S_SUCCESS
LSERVER_E_ACCESS_DENIED Client doesn't have required privilege
LSERVER_E_NO_CERTIFICATE License Server hasn't register yet.
LSERVER_E_INVALID_DATA Can't verify any of the certificate or
can't decode license keypack blob.
LSERVER_E_SERVER_BUSY Server is busy.
LSERVER_E_DUPLICATE KeyPack already register
LSERVER_E_ERROR_GENERAL General ODBC error.
*/
{
#if ENFORCE_LICENSING
DWORD status=ERROR_SUCCESS;
TLSRpcRegisterLicenseKeyPack(
phContext,
pbCHCertBlob,
cbCHCertBlobSize,
pbRootCertBlob,
cbRootCertBlob,
lpKeyPackBlob,
dwKeyPackBlobLen,
&status
);
return status;
#else
return TLSMapReturnCode(TLS_E_NOTSUPPORTED);
#endif
}
//+------------------------------------------------------------------------
error_status_t
LSInstallCertificate(
/* [in] */ PCONTEXT_HANDLE phContext,
/* [in] */ DWORD dwCertType,
/* [in] */ DWORD dwCertLevel,
/* [in] */ DWORD cbSignatureCert,
/* [size_is][in] */ PBYTE pbSignatureCert,
/* [in] */ DWORD cbExchangeCert,
/* [size_is][in] */ PBYTE pbExchangeCert
)
/*
Description:
Install CH, CA, or License Server's certificate issued by CA into
License Server.
Arguments:
RETURN:
ACCESS_DENIED No privilege
LSERVER_E_INVALID_DATA Can't verify certificate
LSERVER_E_DUPLICATE Certificate already installed
LSERVER_I_CERTIFICATE_OVERWRITE Overwrite certificate.
*/
{
#if ENFORCE_LICENSING
DWORD status=ERROR_SUCCESS;
TLSRpcInstallCertificate(
phContext,
dwCertType,
dwCertLevel,
cbSignatureCert,
pbSignatureCert,
cbExchangeCert,
pbExchangeCert,
&status
);
return status;
#else
return TLSMapReturnCode(TLS_E_NOTSUPPORTED);
#endif
}
Reference in a new issue Copy permalink