windows-nt/Source/XPSP1/NT/termsrv/license/tlserver/server/policy.h

610 lines
15 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// File: policy.h
//
// Contents:
//
// History:
//
//---------------------------------------------------------------------------
#ifndef __POLICY_MODULE_MGR__
#define __POLICY_MODULE_MGR__
#include "tlsstl.h" // STL.
#include <stdio.h>
#include <tchar.h>
#include "tlsdef.h"
#include "tlspol.h"
#include "locks.h"
#define RETURNLICENSEPROCNAME "PMReturnLicense"
#define LICENSEUPGRADEPROCNAME "PMLicenseUpgrade"
#define LICENSEREQUESTPROCNAME "PMLicenseRequest"
#define TEMINATEPROCNAME "PMTerminate"
#define INITIALIZEPROCNAME "PMInitialize"
#define SUPPORTEDPRODUCTPROCNAME "PMInitializeProduct"
#define ULOADPRODUCTPROCNAME "PMUnloadProduct"
#define REGISTERLKPPROCNAME "PMRegisterLicensePack"
#define POLICY_DENY_ALL_REQUEST 0x00000000
#define POLICY_USE_DEFAULT 0x00000001
typedef POLICYSTATUS (WINAPI *TLSPMReturnLicense)(
PMHANDLE hClient,
ULARGE_INTEGER* pLicenseSerialNumber,
PPMLICENSETOBERETURN pLicenseToBeReturn,
PDWORD pdwLicenseStatus,
PDWORD pdwRetCode
);
typedef POLICYSTATUS (WINAPI *TLSPMLicenseUpgrade)(
PMHANDLE hClient,
DWORD dwProgressCode,
PVOID pbProgressData,
PVOID* ppbReturnData,
PDWORD pdwRetCode
);
typedef POLICYSTATUS (WINAPI *TLSPMLicenseRequest)(
PMHANDLE client,
DWORD dwProgressCode,
PVOID pbProgressData,
PVOID* pbNewProgressData,
PDWORD pdwRetCode
);
typedef void (WINAPI *TLSPMTerminate)();
typedef POLICYSTATUS (WINAPI* TLSPMInitialize)(
DWORD dwLicenseServerVersion,
LPCTSTR pszCompanyName,
LPCTSTR pszProductCode,
PDWORD pdwNumProduct,
PPMSUPPORTEDPRODUCT* ppProduct,
PDWORD pdwRetCode
);
typedef POLICYSTATUS (WINAPI* TLSPMInitializeProduct)(
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductId,
LPCTSTR pszTLSProductId,
PDWORD pdwRetCode
);
typedef POLICYSTATUS (WINAPI* TLSPMUnloadProduct)(
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductId,
LPCTSTR pszTLSProductCode,
PDWORD pdwRetCode
);
typedef POLICYSTATUS (WINAPI* TLSPMRegisterLicensePack)(
PMHANDLE hClient,
DWORD dwProgressCode,
PVOID pbProgressData,
PVOID pbProgressRetData,
PDWORD pdwRetCode
);
class CTLSPolicyMgr;
////////////////////////////////////////////////////////////////////////////
class CTLSPolicy {
friend class CTLSPolicyMgr;
private:
typedef enum {
MODULE_UNKNOWN, // object has been initialized.
MODULE_LOADED, // module has been loaded.
MODULE_PMINITALIZED, // module has been initialized.
MODULE_PMTERMINATED, // module has been terminated.
MODULE_ERROR, // module initialization error or
// cause an exeption
MODULE_UNLOADED // module has been unloaded.
} MODULE_STATE;
long m_RefCount;
DWORD m_dwFlags;
BOOL m_bAlreadyLogError;
POLICYSTATUS m_dwLastCallStatus; // Policy Module last call status
DWORD m_dwPolicyErrCode; // Policy specific error code.
MODULE_STATE m_dwModuleState;
//
// Policy module must be multi-thread safe.
//
TLSPMReturnLicense m_pfnReturnLicense;
TLSPMLicenseUpgrade m_pfnLicenseUpgrade;
TLSPMLicenseRequest m_pfnLicenseRequest;
TLSPMUnloadProduct m_pfnUnloadProduct;
TLSPMInitializeProduct m_pfnInitProduct;
TLSPMRegisterLicensePack m_pfnRegisterLkp;
HMODULE m_hPolicyModule;
TCHAR m_szCompanyName[LSERVER_MAX_STRING_SIZE+1];
TCHAR m_szProductId[LSERVER_MAX_STRING_SIZE+1];
TCHAR m_szCHProductId[LSERVER_MAX_STRING_SIZE+1];
//--------------------------------------------------------------
void
SetDllFlags(DWORD dllFlags)
{
m_dwFlags = dllFlags;
}
//--------------------------------------------------------------
long
Acquire()
{
return InterlockedIncrement(&m_RefCount);
}
//--------------------------------------------------------------
long
Release()
{
return InterlockedDecrement(&m_RefCount);
}
//--------------------------------------------------------------
DWORD
InitializePolicyModule();
//--------------------------------------------------------------
void
SetModuleState(
MODULE_STATE state
)
/*++
++*/
{
m_dwModuleState = state;
return;
}
//-------------------------------------------------------------
MODULE_STATE
GetModuleState()
{
return m_dwModuleState;
}
//-------------------------------------------------------------
void
CreatePolicy(
HMODULE hModule,
LPCTSTR pszCompanyName,
LPCTSTR pszProductId,
TLSPMReturnLicense pfnReturnLicense,
TLSPMLicenseUpgrade pfnLicenseUpgrade,
TLSPMLicenseRequest pfnLicenseRequest,
TLSPMUnloadProduct pfnUnloadProduct,
TLSPMInitializeProduct pfnInitProduct,
TLSPMRegisterLicensePack pfnRegisterLkp
)
/*++
++*/
{
m_hPolicyModule = hModule;
m_pfnReturnLicense = pfnReturnLicense;
m_pfnLicenseUpgrade = pfnLicenseUpgrade;
m_pfnLicenseRequest = pfnLicenseRequest;
m_pfnUnloadProduct = pfnUnloadProduct;
m_pfnInitProduct = pfnInitProduct;
m_pfnRegisterLkp = pfnRegisterLkp;
SetModuleState(MODULE_PMINITALIZED);
lstrcpyn(
m_szCompanyName,
pszCompanyName,
sizeof(m_szCompanyName) / sizeof(m_szCompanyName[0])
);
lstrcpyn(
m_szProductId,
pszProductId,
sizeof(m_szProductId) / sizeof(m_szProductId[0])
);
}
void
LogPolicyRequestStatus(
DWORD dwMsgId
);
public:
CTLSPolicy() :
m_pfnReturnLicense(NULL),
m_pfnLicenseUpgrade(NULL),
m_pfnLicenseRequest(NULL),
m_pfnUnloadProduct(NULL),
m_pfnInitProduct(NULL),
m_pfnRegisterLkp(NULL),
m_hPolicyModule(NULL),
m_RefCount(0),
m_bAlreadyLogError(FALSE),
m_dwModuleState(MODULE_UNKNOWN),
m_dwFlags(0),
m_dwLastCallStatus(POLICY_SUCCESS),
m_dwPolicyErrCode(ERROR_SUCCESS)
/*++
Constructor
++*/
{
#ifdef DBG
memset(m_szCompanyName, 0, sizeof(m_szCompanyName));
memset(m_szProductId, 0, sizeof(m_szProductId));
memset(m_szCHProductId, 0, sizeof(m_szCHProductId));
#endif
}
//--------------------------------------------------------------
~CTLSPolicy()
/*++
Destructor
++*/
{
Unload();
}
//--------------------------------------------------------------
DWORD
GetProductFlags()
{
return m_dwFlags;
}
//--------------------------------------------------------------
long
GetRefCount()
{
return InterlockedExchange(&m_RefCount, m_RefCount);
}
//--------------------------------------------------------------
void
Unload();
//--------------------------------------------------------------
DWORD
Initialize(
HINSTANCE hInstance,
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductId,
LPCTSTR pszProductId,
LPCTSTR pszDllName,
DWORD dwDllFlag = POLICY_DENY_ALL_REQUEST
);
//--------------------------------------------------------------
LPCTSTR
GetCompanyName()
{
return m_szCompanyName;
}
//--------------------------------------------------------------
LPCTSTR
GetProductId()
{
return m_szProductId;
}
//--------------------------------------------------------------
LPCTSTR
GetCHProductId()
{
return m_szCHProductId;
}
//--------------------------------------------------------------
DWORD
GetPolicyRetCode() { return m_dwPolicyErrCode; }
//--------------------------------------------------------------
DWORD
GetPolicyLastCallStatus() { return m_dwLastCallStatus; }
//--------------------------------------------------------------
BOOL
IsValid();
//--------------------------------------------------------------
DWORD
PMReturnLicense(
PMHANDLE hClient,
ULARGE_INTEGER* pLicenseSerialNumber,
PPMLICENSETOBERETURN pLicenseTobeReturn,
PDWORD pdwLicenseStatus
);
//--------------------------------------------------------------
DWORD
PMLicenseUpgrade(
PMHANDLE hClient,
DWORD dwProgressCode,
PVOID pbProgressData,
PVOID* ppbReturnData
);
//--------------------------------------------------------------
DWORD
PMLicenseRequest(
PMHANDLE client,
DWORD dwProgressCode,
const PVOID pbProgressData,
PVOID* pbNewProgressData
);
//--------------------------------------------------------------
DWORD
PMRegisterLicensePack(
PMHANDLE hClient,
DWORD dwProgressCode,
const PVOID pbProgessData,
PVOID pbProgressRetData
);
//--------------------------------------------------------------
DWORD
PMUnload();
//--------------------------------------------------------------
DWORD
PMInitProduct();
};
/////////////////////////////////////////////////////////////////////
typedef struct __PolicyModule {
TCHAR m_szCompanyName[LSERVER_MAX_STRING_SIZE+1];
TCHAR m_szProductId[LSERVER_MAX_STRING_SIZE+1];
friend bool operator<(const __PolicyModule&, const __PolicyModule&);
__PolicyModule()
{
memset(m_szCompanyName, 0, sizeof(m_szCompanyName));
memset(m_szProductId, 0, sizeof(m_szProductId));
}
} PolicyModule;
inline bool
operator<(
const PolicyModule& a,
const PolicyModule& b
)
/*++
++*/
{
int iComp;
iComp = _tcsicmp(a.m_szCompanyName, b.m_szCompanyName);
if(iComp == 0)
{
iComp = _tcsicmp(a.m_szProductId, b.m_szProductId);
}
return iComp < 0;
}
//////////////////////////////////////////////////////////
//
// CTLSPolicyMgr must be a global object so destructor is
// invoked at the end.
//
class CTLSPolicyMgr {
private:
typedef map<PolicyModule, HMODULE, less<PolicyModule> > PMLoadedModuleMapType;
typedef map<PolicyModule, CTLSPolicy*, less<PolicyModule> > PMProductPolicyMapType;
typedef map<PolicyModule, PolicyModule, less<PolicyModule> > PMProductTransationMapType;
//
// Policy module per product
//
CRWLock m_ProductPolicyModuleRWLock;
PMProductPolicyMapType m_ProductPolicyModule;
//
// List of loaded policy module
//
CRWLock m_LoadedPolicyRWLock;
PMLoadedModuleMapType m_LoadedPolicy;
//
// List of Product transation
//
CRWLock m_ProductTranslationRWLock;
PMProductTransationMapType m_ProductTranslation;
HMODULE
LoadPolicyModule(
LPCTSTR pszCompanyName,
LPCTSTR pszProductCode,
LPCTSTR pszDllName
);
//
// Find policy module handle for a particular product
//
PMProductPolicyMapType::iterator
FindProductPolicyModule(
LPCTSTR pszCompanyName,
LPCTSTR pszProductId
);
//
// Find policy module handle for a particular product
//
PMProductTransationMapType::iterator
FindProductTransation(
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductCode
);
void
InsertProductTransation(
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductCode,
LPCTSTR pszTLSProductCode
);
DWORD
GetSupportedProduct(
HMODULE hModule,
LPCTSTR pszDllName,
LPCTSTR pszCompanyName,
LPCTSTR pszProductId,
PDWORD pdwNumProducts,
PPMSUPPORTEDPRODUCT* pSupportedProduct
);
DWORD
InsertProductPolicyModule(
HMODULE hModule,
BOOL bReplace,
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductId,
LPCTSTR pszTLSProductId,
LPCTSTR pszDllName,
DWORD dwFlag
);
DWORD
UnloadPolicyModule(
HINSTANCE hModule
);
public:
CTLSPolicyMgr();
~CTLSPolicyMgr();
//
// Insert a policy module handle into Handle arrays.
//
DWORD
AddPolicyModule(
BOOL bReplace,
LPCTSTR pszCompanyName,
LPCTSTR pszProductId,
LPCTSTR pszDllName,
DWORD dwFlag
);
DWORD
UnloadPolicyModule(
LPCTSTR pszCompanyName,
LPCTSTR pszProductCode
);
//
// Find a policy module for specific product
//
CTLSPolicy*
AcquireProductPolicyModule(
LPCTSTR pszCompanyName,
LPCTSTR pszProductId
);
//
// Find a translation for CH.
//
BOOL
TranslateCHCodeToTlsCode(
LPCTSTR pszCompanyName,
LPCTSTR pszCHProductCode,
LPTSTR pszTlsProductCode,
PDWORD pdwBufferSize
);
//
// Release a product policy module
//
void
ReleaseProductPolicyModule( CTLSPolicy* p );
//
// Initialize All Product Policy Module
//
DWORD
InitProductPolicyModule();
};
#ifdef __cplusplus
extern "C" {
#endif
DWORD
ServiceInitPolicyModule(void);
DWORD
ServiceLoadAllPolicyModule(
IN HKEY hRoot,
IN LPCTSTR pszSubkey
);
CTLSPolicy*
AcquirePolicyModule(
IN LPCTSTR pszCompanyName,
IN LPCTSTR pszProductId,
IN BOOL bUseProductPolicy
);
BOOL
TranslateCHCodeToTlsCode(
IN LPCTSTR pszCompanyName,
IN LPCTSTR pszCHProductId,
IN LPTSTR pszTLSProductId,
IN OUT PDWORD pdwBufferSize
);
void
ReleasePolicyModule(
CTLSPolicy* ptr
);
#ifdef __cplusplus
}
#endif
#endif