//-------------------------------------------------------------------
//
//  FILE: CLiCLicReg.Cpp
//
//  Summary;
// 		Class implementation for handling the licensing api registration
//
//	Notes;
//		Key = \HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LicenseInfo
//		Value= ErrorControl : REG_DWORD : 0x1
//		Value= Start : REG_DWORD : 0x3
//		Value= Type : REG_DWORD : 0x4
//
//		Subkeys :
//		\SNA
//		\SQL
//		\FilePrint
//
//		Value for All Subkeys=
//		Mode : REG_DWORD :  (0x0 = Per Seat Mode, 0x1 = Concurrent/Per Server Mode)
//		ConcurrentLimit : REG_DWORD : (0x<limit>, ie. 0x100 = 256 concurrent user limit)
//      FamilyDisplayName: RED_SZ : Name for this service (not version specific)
//		DisplayName : REG_SZ : User seen name for this Service entry
//		FlipAllow : REG_DWORD : (0x0 = can change license mode, 0x1 license mode can't
//			be changed.   Server apps are only allowed to switch their license mode
//			once, so after the first switch, this value would be set to non-zero, 
//			then the UI	will not allow for further changes to the licence mode.
//			Changing is currently allowed but a dialog is raised to warn them of the
//			possible violation.
//
//	History
//		11/15/94 MikeMi Created
//
//-------------------------------------------------------------------

#include <windows.h>
#include "CLicReg.hpp"

// Strings for keys and values
//
const WCHAR szLicenseKey[] = L"SYSTEM\\CurrentControlSet\\Services\\LicenseInfo";
const WCHAR szErrControlValue[] = L"ErrorControl";
const WCHAR szStartValue[] = L"Start";
const WCHAR szTypeValue[] = L"Type";

const WCHAR szNameValue[] = L"DisplayName";
const WCHAR szFamilyNameValue[] = L"FamilyDisplayName";
const WCHAR szModeValue[] = L"Mode";
const WCHAR szLimitValue[] = L"ConcurrentLimit";
const WCHAR szFlipValue[] = L"FlipAllow";

// set values under License Key
//
const DWORD dwErrControlValue = SERVICE_ERROR_NORMAL; // 1;
const DWORD dwStartValue = SERVICE_DEMAND_START; // 3;
const DWORD dwTypeValue = SERVICE_ADAPTER; // 4;

//-------------------------------------------------------------------
//
//	Method:	CLicReg::CLicReg
//
//	Summary;
//		Contructor
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

CLicReg::CLicReg( )
{
	_hkey = NULL;
}

//-------------------------------------------------------------------
//
//	Method:	CLicReg::~CLicReg
//
//	Summary;
//		Destructor
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

CLicReg::~CLicReg( )
{
	Close();
}

//-------------------------------------------------------------------
//
//	Method:	CLicReg::CommitNow
//
//	Summary;
//		This will flush the changes made imediately
//
//	Return:
//		ERROR_SUCCESS when this method works.
//		See RegFlushKey for return values
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicReg::CommitNow()
{
	return( RegFlushKey( _hkey ) );
}

//-------------------------------------------------------------------
//
//	Method:	CLicReg::Close
//
//	Summary;
//		This will close the registry. See Open.
//
//	Return: 
//		ERROR_SUCCESS when this method works.
//		See RegCloseKey for return values
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicReg::Close()
{
    LONG lrt = ERROR_SUCCESS;
    if ( _hkey )
    {
        lrt = ::RegCloseKey( _hkey );
        _hkey = NULL;
    }
    return( lrt  );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicense::Open
//
//	Summary;
//		This will open the registry for License Services Enumeration.
//
//	Arguments;
//		fNew [out] - Was the opened reg key new.
//      pszComputer [in] - the computer name to open the registry on
//              this value maybe null (default), this means local machine
//              should be of the form \\name
//
//	Return:  
//		ERROR_SUCCESS when this method works.
//		See RegCreateKeyEx & RegSetValueEx for error returns.
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------
	
LONG 
CLicRegLicense::Open( BOOL& fNew, LPCWSTR pszComputer )
{
	DWORD dwDisposition;
	LONG  lrt;
    HKEY  hkeyRemote = NULL;

    lrt = RegConnectRegistry( (LPTSTR)pszComputer, 
            HKEY_LOCAL_MACHINE, 
            &hkeyRemote );

    if (ERROR_SUCCESS == lrt)
    {
    	fNew = FALSE;
    	lrt = ::RegCreateKeyEx( hkeyRemote, 
    				szLicenseKey,
    				0,
    				NULL,
    				REG_OPTION_NON_VOLATILE,
    				KEY_ALL_ACCESS,
    				NULL,
    				&_hkey,
    				&dwDisposition );

    	if ((ERROR_SUCCESS == lrt) &&
    		(REG_CREATED_NEW_KEY == dwDisposition) )
    	{
    		fNew = 	TRUE;
    		// Set normal values
    		//
    		lrt = ::RegSetValueEx( _hkey,
    				szErrControlValue,
    				0,
    				REG_DWORD,
    				(PBYTE)&dwErrControlValue,
    				sizeof( DWORD ) );
    		if (ERROR_SUCCESS == lrt)
    		{

    			lrt = ::RegSetValueEx( _hkey,
    					szStartValue,
    					0,
    					REG_DWORD,
    					(PBYTE)&dwStartValue,
    					sizeof( DWORD ) );
    			if (ERROR_SUCCESS == lrt)
    			{

    				lrt = ::RegSetValueEx( _hkey,
    						szTypeValue,
    						0,
    						REG_DWORD,
    						(PBYTE)&dwTypeValue,
    						sizeof( DWORD ) );
    			}
    		}
    	}
        ::RegCloseKey( hkeyRemote );    
    }
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicense::EnumService
//
//	Summary;
//		This will enumerate services listed in the registry for Licensing
//
//	Arguments;
//		iService [in] - This should be zero on the first call and incremented
//			on subsequent calls.
//		pszBuffer [out] - string buffer to place service reg name in
//		cchBuffer [in-out] - the length of the pszBuffer, if not large enough,
//			this value will change to what is needed.
//
//	Return:   
//		ERROR_SUCCESS when this method works.
//		ERROR_NO_MORE_ITEMS when end of enumeration was reached
//		See RegEnumKeyEx for error return values
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------
	
LONG 
CLicRegLicense::EnumService( DWORD iService, LPWSTR pszBuffer, DWORD& cchBuffer )
{
	LONG lrt;
	FILETIME ftLastWritten;
	
	lrt = ::RegEnumKeyEx( _hkey, 
			iService,
			pszBuffer,
			&cchBuffer,
			0,
			NULL,
			NULL,
			&ftLastWritten );
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::CLicRegLicenseService
//
//	Summary;
//		Contructor
//
//	Arguments;
//		pszService [in] - Service Reg Key Name 
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

CLicRegLicenseService::CLicRegLicenseService( LPCWSTR pszService )
{
	_pszService = (LPWSTR)pszService;
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::SetServie
//
//	Summary;
//		Set the Service Reg Key name
//
//	Arguments;
//		pszService [in] - Service Reg Key Name 
//
//  History;
//		Nov-15-94 MikeMi Created
//      Apr-26-95   MikeMi  Added Computer name and remoting
//
//-------------------------------------------------------------------

void
CLicRegLicenseService::SetService( LPCWSTR pszService )
{
	Close();
	_pszService = (LPWSTR)pszService;
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::Open
//
//	Summary;
//		Opens/Create registry entry for this service
//
//	Arguments;
//      pszComputer [in] - the computer name to open the registry on
//              this value maybe null (default), this means local machine
//              should be of the form \\name
//
//	Return:
//		ERROR_SUCCESS - Open/Created Correctly
//		See RegCreateKeyEx for other errors.
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------
	
LONG 
CLicRegLicenseService::Open( LPCWSTR pszComputer, BOOL fCreate )
{
	HKEY  hkeyRoot;
	DWORD dwDisposition;
	LONG  lrt;
    HKEY  hkeyRemote = NULL;

    lrt = RegConnectRegistry( (LPTSTR)pszComputer, 
            HKEY_LOCAL_MACHINE, 
            &hkeyRemote );

    if (ERROR_SUCCESS == lrt)
    {
        if (fCreate)
        {
        	lrt = ::RegCreateKeyEx( hkeyRemote, 
        				szLicenseKey,
        				0,
        				NULL,
        				REG_OPTION_NON_VOLATILE,
        				KEY_ALL_ACCESS,
        				NULL,
        				&hkeyRoot,
        				&dwDisposition );
        }
        else
        {
        	lrt = ::RegOpenKeyEx( hkeyRemote, 
				szLicenseKey,
				0,
				KEY_ALL_ACCESS,
				&hkeyRoot );
        }

    	if (ERROR_SUCCESS == lrt)
    	{
    		// open or create our service key
    		//
            if (fCreate)
            {
        		lrt = ::RegCreateKeyEx( hkeyRoot, 
        				_pszService,
        				0,
        				NULL,
        				REG_OPTION_NON_VOLATILE,
        				KEY_ALL_ACCESS,
        				NULL,
        				&_hkey,
        				&dwDisposition );
            }
            else
            {
           		lrt = ::RegOpenKeyEx( hkeyRoot, 
        				_pszService,
        				0,
        				KEY_ALL_ACCESS,
        				&_hkey );
            }
    		::RegCloseKey( hkeyRoot );
    	}
        ::RegCloseKey( hkeyRemote );    
    }
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::CanChangeMode
//
//	Summary;
//		This will check the registry to see if the license mode 
//		can be changed.
//
//	Return:  TRUE if the mode can be changed, otherwise FALSE
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

BOOL 
CLicRegLicenseService::CanChangeMode()
{
	BOOL frt = TRUE;
	LONG lrt;
	DWORD dwSize = sizeof( DWORD );
	DWORD dwRegType = REG_DWORD;
	DWORD fWasChanged;

	lrt = ::RegQueryValueEx( _hkey,
			(LPWSTR)szFlipValue,
			0,
			&dwRegType,
			(PBYTE)&fWasChanged,
			&dwSize );

	if ( (ERROR_SUCCESS == lrt) &&
		 (dwRegType == REG_DWORD) &&
		 (dwSize == sizeof( DWORD )) )
	{
		frt = !fWasChanged;
	}
	else
	{
		SetChangeFlag( FALSE );
	}

	return( frt );
}
//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::SetChangeFlag
//
//	Summary;
//		This will set the change flag in the registry
//
//	Arguments;
//		fHasChanged [in] - Has the license been changed
//
//	Return:
//		ERROR_SUCCESS - The flag was set
//		See RegSetValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::SetChangeFlag( BOOL fHasChanged )
{
	LONG lrt;
    DWORD dwf = (DWORD)fHasChanged;

	lrt = ::RegSetValueEx( _hkey,
			szFlipValue,
			0,
			REG_DWORD,
			(PBYTE)&dwf,
			sizeof( DWORD ) );

	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::SetMode
//
//	Summary;
//		Set this services licensing mode
//
//	Arguments;
//		lm [in] - the mode to set the registry to
//
//	Return:
//		ERROR_SUCCESS - The mode was set
//		See RegSetValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::SetMode( LICENSE_MODE lm )
{
	LONG lrt;
    DWORD dwlm = (DWORD)lm;

	lrt = ::RegSetValueEx( _hkey,
			szModeValue,
			0,
			REG_DWORD,
			(PBYTE)&dwlm,
			sizeof( DWORD ) );
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::SetUserLimit
//
//	Summary;
//		Set this serices user limit in the registry
//
//	Arguments;
//		dwLimit[in] - the limit to set
//
//	Return:
//		ERROR_SUCCESS - The limit was set
//		See RegSetValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::SetUserLimit( DWORD dwLimit )
{
	LONG lrt;

	lrt = ::RegSetValueEx( _hkey,
			szLimitValue,
			0,
			REG_DWORD,
			(PBYTE)&dwLimit,
			sizeof( DWORD ) );

	return( lrt );
}					
//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::GetMode
//
//	Summary;
//		Retrieve the services license mode from the registry
//
//	Arguments;
//		lm [out] - the mode from the registry
//
//	Return:
//		ERROR_SUCCESS - The mode was retrieved
//		See RegQueryValueEx for error returns
//			   
//  Notes:
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::GetMode( LICENSE_MODE& lm )
{
	LONG lrt;
	DWORD dwSize = sizeof( LICENSE_MODE );
	DWORD dwRegType = REG_DWORD;
    DWORD dwlm = LICMODE_UNDEFINED;

	lrt = ::RegQueryValueEx( _hkey,
			(LPWSTR)szModeValue,
			0,
			&dwRegType,
			(PBYTE)&dwlm,
			&dwSize );

    lm = (LICENSE_MODE)dwlm;

	if ( (dwRegType != REG_DWORD) ||
		 (dwSize != sizeof( LICENSE_MODE )) )
	{
		lrt = ERROR_BADDB;
	}
    if (ERROR_SUCCESS != lrt)
    {
        lm = LICMODE_UNDEFINED;
    }
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::GetUserLimit
//
//	Summary;
//		retrieve the user limit fro this service from the registry
//
//	Arguments;
//		dwLimit [out] - The limit retrieved
//
//	Return:
//
//  Notes:
//		ERROR_SUCCESS - The limit was retrieved
//		See RegQueryValueEx for error returns
//
//  History;
//		Nov-15-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::GetUserLimit( DWORD& dwLimit )
{
	LONG lrt;
	DWORD dwSize = sizeof( DWORD );
	DWORD dwRegType = REG_DWORD;

	lrt = ::RegQueryValueEx( _hkey,
			(LPWSTR)szLimitValue,
			0,
			&dwRegType,
			(PBYTE)&dwLimit,
			&dwSize );

	if ( (dwRegType != REG_DWORD) ||
		 (dwSize != sizeof( DWORD )) )
	{
		lrt = ERROR_BADDB;
	}
    if (ERROR_SUCCESS != lrt)
    {
        dwLimit = 0;
    }
	
	return( lrt );
}					

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::GetDisplayName
//
//	Summary;
//		Retrieve the display name for this service from the registry
//
//	Arguments;
//		pszName [in-out] - the buffer to place the retrieved name
//		cchName [in-out] - the length of the pszName buffer in chars
//
//	Return:
//		ERROR_SUCCESS - The mode was retrieved
//		See RegQueryValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-18-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::GetDisplayName( LPWSTR pszName, DWORD& cchName )
{
	LONG lrt;
	DWORD dwSize = cchName * sizeof(WCHAR);
	DWORD dwRegType = REG_SZ;

	lrt = ::RegQueryValueEx( _hkey,
			(LPWSTR)szNameValue,
			0,
			&dwRegType,
			(PBYTE)pszName,
			&dwSize );

	if ((NULL != pszName) &&  // request for data size
	    (dwRegType != REG_SZ))
	{
		lrt = ERROR_BADDB;
	}

	cchName = dwSize / sizeof( WCHAR );
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::SetDisplayName
//
//	Summary;
//		Set the display name for this service in the regstry
//
//	Arguments;
//		pszName [in] - the null terminated display name
//
//	Return:
//		ERROR_SUCCESS - The name eas set
//		See RegSetValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-18-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::SetDisplayName( LPCWSTR pszName )
{
	LONG lrt;

	lrt = ::RegSetValueEx( _hkey,
			szNameValue,
			0,
			REG_SZ,
			(PBYTE)pszName,
			(lstrlen( pszName ) + 1) * sizeof( WCHAR ) );

	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::GetFamilyDisplayName
//
//	Summary;
//		Retrieve the family display name for this service from the registry
//
//	Arguments;
//		pszName [in-out] - the buffer to place the retrieved name
//		cchName [in-out] - the length of the pszName buffer in chars
//
//	Return:
//		ERROR_SUCCESS - The mode was retrieved
//		See RegQueryValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-18-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::GetFamilyDisplayName( LPWSTR pszName, DWORD& cchName )
{
	LONG lrt;
	DWORD dwSize = cchName * sizeof(WCHAR);
	DWORD dwRegType = REG_SZ;

	lrt = ::RegQueryValueEx( _hkey,
			(LPWSTR)szFamilyNameValue,
			0,
			&dwRegType,
			(PBYTE)pszName,
			&dwSize );

	if ((NULL != pszName) &&  // request for data size
	    (dwRegType != REG_SZ))
	{
		lrt = ERROR_BADDB;
	}

	cchName = dwSize / sizeof( WCHAR );
	return( lrt );
}

//-------------------------------------------------------------------
//
//	Method:	CLicRegLicenseService::SetFamilyDisplayName
//
//	Summary;
//		Set the Family display name for this service in the regstry
//
//	Arguments;
//		pszName [in] - the null terminated display name
//
//	Return:
//		ERROR_SUCCESS - The name eas set
//		See RegSetValueEx for error returns
//
//  Notes:
//
//  History;
//		Nov-18-94 MikeMi Created
//
//-------------------------------------------------------------------

LONG 
CLicRegLicenseService::SetFamilyDisplayName( LPCWSTR pszName )
{
	LONG lrt;

	lrt = ::RegSetValueEx( _hkey,
			szFamilyNameValue,
			0,
			REG_SZ,
			(PBYTE)pszName,
			(lstrlen( pszName ) + 1) * sizeof( WCHAR ) );

	return( lrt );
}