//+-------------------------------------------------------------------------- // // 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 }