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

1994 lines
50 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//Copyright (c) 1998 - 1999 Microsoft Corporation
/*++
Module Name:
MainFrm.cpp
Abstract:
This Module contains the implementation of CMainFrame class
(The Frame Window of the application)
Author:
Arathi Kundapur (v-akunda) 11-Feb-1998
Revision History:
--*/
#include "stdafx.h"
#include <lm.h>
#include "LicMgr.h"
#include "defines.h"
#include "LSServer.h"
#include "MainFrm.h"
#include "RtList.h"
#include "lSmgrdoc.h"
#include "LtView.h"
#include "cntdlg.h"
#include "addkp.h"
#include "treenode.h"
#include "ntsecapi.h"
//#include "lrwizapi.h"
#include "TlsHunt.h"
#include "htmlhelp.h"
#define DELETE_AND_ADDTO_ERROR DeleteServer(pLicServerList,TempPos,pLicServer);\
if(!ErrorServers.IsEmpty()) \
ErrorServers = ErrorServers + _T(","); \
ErrorServers = ErrorServers + Name;
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMainFrame
IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
ON_MESSAGE(WM_ENUMERATESERVER, OnEnumerateServer)
ON_MESSAGE(WM_SEL_CHANGE, OnSelChange)
ON_MESSAGE(WM_ADD_ALL_SERVERS, OnAddAllServers)
ON_MESSAGE(WM_ADD_SERVER, OnAddServer)
ON_MESSAGE(WM_ADD_KEYPACK, OnAddKeyPack)
ON_COMMAND(ID_LARGE_ICONS, OnLargeIcons)
ON_COMMAND(ID_SMALL_ICONS, OnSmallIcons)
ON_COMMAND(ID_LIST, OnList)
ON_COMMAND(ID_DETAILS, OnDetails)
ON_COMMAND(ID_EXIT, OnExit)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
ON_COMMAND(ID_HELP_FINDER, OnHelp)
ON_COMMAND(ID_HELP_USING, CFrameWnd::OnHelpUsing)
ON_COMMAND(ID_CONNECT_SERVER, OnConnectServer)
ON_COMMAND(ID_REGISTRATION, OnRegistration)
ON_COMMAND(ID_KEY_HELP , OnHelp )
ON_UPDATE_COMMAND_UI( ID_REGISTRATION, OnUpdateAddNewKeyPack)
ON_UPDATE_COMMAND_UI( ID_ACTION_DOWNLOADLICENSES, OnUpdateDownloadlicenses )
ON_UPDATE_COMMAND_UI( ID_ACTION_ADVANCED_REPEATLASTDOWNLOAD , OnUpdateRepeatLastDownload )
ON_UPDATE_COMMAND_UI( ID_ACTION_ADVANCED_REREGISTERSERVER , OnUpdateReregisterserver )
ON_UPDATE_COMMAND_UI( ID_ACTION_ADVANCED_UNREGISTERSERVER , OnUpdateUnregisterserver )
ON_UPDATE_COMMAND_UI( ID_VIEW_PROPERTIES , OnUpdateProperties )
ON_COMMAND( ID_REFRESH, OnRefreshServer )
ON_COMMAND( ID_VIEW_REFRESHALL , OnRefresh )
ON_UPDATE_COMMAND_UI( ID_REFRESH , OnUpdateRefresh )
ON_COMMAND( ID_ACTION_DOWNLOADLICENSES , OnDownLoadLicenses )
ON_COMMAND( ID_ACTION_ADVANCED_REPEATLASTDOWNLOAD , OnRepeatLastDownLoad )
ON_COMMAND( ID_ACTION_ADVANCED_REREGISTERSERVER , OnReRegisterServer )
ON_COMMAND( ID_ACTION_ADVANCED_UNREGISTERSERVER , OnUnRegisterServer )
ON_COMMAND( ID_VIEW_PROPERTIES , OnProperties )
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // status line indicator
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction
CMainFrame::CMainFrame()
{
m_pRightView= NULL;
m_pLeftView = NULL;
m_pServer = NULL;
}
CMainFrame::~CMainFrame()
{
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndToolBar.Create(this) ||
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
#if 0
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
#endif
// Remove this if you don't want tool tips or a resizeable toolbar
m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
// Delete these three lines if you don't want the toolbar to be dockable
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar);
return 0;
}
void CMainFrame::OnHelp()
{
TCHAR * pHtml = L"ts_lice_topnode.htm";
HtmlHelp(AfxGetMainWnd()->m_hWnd, L"tslic.chm", HH_DISPLAY_TOPIC,(DWORD_PTR)pHtml);
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
cs.style &= ~FWS_ADDTOTITLE;
return CFrameWnd::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
CFrameWnd::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
CFrameWnd::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers
BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
m_SplitterWnd.CreateStatic(this,1,2); //1 row, 2 columns
m_SplitterWnd.CreateView(0,0,(CRuntimeClass *)pContext->m_pNewViewClass,CSize(150,150),pContext);
m_SplitterWnd.CreateView(0,1,RUNTIME_CLASS(CRightList),CSize(0,0),pContext);
m_pRightView = (CView *)m_SplitterWnd.GetPane(0, 1);
m_pLeftView = (CLicMgrLeftView *)m_SplitterWnd.GetPane(0, 0);
return TRUE;
}
LRESULT CMainFrame::OnSelChange(WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = 0;
m_pRightView->SendMessage(WM_SEL_CHANGE,wParam,lParam);
return lResult;
}
void CMainFrame::OnLargeIcons()
{
PressButton(ID_LARGE_ICONS,TRUE);
PressButton(ID_SMALL_ICONS,FALSE);
PressButton(ID_LIST,FALSE);
PressButton(ID_DETAILS,FALSE);
m_pRightView->SendMessage(WM_COMMAND,ID_LARGE_ICONS,0);
}
void CMainFrame::OnSmallIcons()
{
PressButton(ID_LARGE_ICONS,FALSE);
PressButton(ID_SMALL_ICONS,TRUE);
PressButton(ID_LIST,FALSE);
PressButton(ID_DETAILS,FALSE);
m_pRightView->SendMessage(WM_COMMAND,ID_SMALL_ICONS,0);
}
void CMainFrame::OnList()
{
PressButton(ID_LARGE_ICONS,FALSE);
PressButton(ID_SMALL_ICONS,FALSE);
PressButton(ID_LIST,TRUE);
PressButton(ID_DETAILS,FALSE);
m_pRightView->SendMessage(WM_COMMAND,ID_LIST,0);
}
void CMainFrame::OnDetails()
{
PressButton(ID_LARGE_ICONS,FALSE);
PressButton(ID_SMALL_ICONS,FALSE);
PressButton(ID_LIST,FALSE);
PressButton(ID_DETAILS,TRUE);
m_pRightView->SendMessage(WM_COMMAND,ID_DETAILS,0);
}
void CMainFrame::OnExit()
{
SendMessage(WM_CLOSE,0,0);
}
LRESULT CMainFrame::OnAddAllServers(WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = 0;
m_pLeftView->SendMessage(WM_ADD_ALL_SERVERS,wParam,lParam);
return lResult;
}
LRESULT CMainFrame::OnAddServer(WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = 0;
m_pLeftView->SendMessage(WM_ADD_SERVER,wParam,lParam);
m_pRightView->SendMessage(WM_ADD_SERVER,wParam,lParam);
return lResult;
}
LRESULT CMainFrame::OnAddKeyPack(WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = 0;
m_pLeftView->SendMessage(WM_ADD_KEYPACK,wParam,lParam);
m_pRightView->SendMessage(WM_ADD_KEYPACK,wParam,lParam);
return lResult;
}
void CMainFrame::OnAppAbout()
{
CString AppName;
AppName.LoadString(IDS_APP_NAME);
::ShellAbout((HWND)m_hWnd,(LPCTSTR)AppName,
NULL,NULL);
}
void CMainFrame::OnRegistration()
{
CWnd* cWnd = AfxGetMainWnd();
HWND hWnd=cWnd->GetSafeHwnd();
DWORD status;
CString TempString;
CString Server;
CLicServer* pServer = NULL;
WCHAR szServer[MAX_COMPUTERNAME_LENGTH + 1];
BOOL bRefresh;
try
{
if(ERROR_SUCCESS != GetActiveServer(&pServer))
{
DBGMSG( L"LICMGR : OnRegistration no active servers\n",0 );
return;
}
if(SERVER_TS5_ENFORCED == pServer->GetServerType())
{
DBGMSG( L"LICMGR : OnRegistration on enforced server\n",0 );
if( !pServer->IsUserAdmin( ) )
{
AfxMessageBox( IDS_E_ACCESSDENIED );
// ::MessageBox( GetSafeHwnd( ) , L"Unable to perform operation: Access denied" , L"Terminal Services Licensing" , MB_OK|MB_ICONINFORMATION );
return;
}
if(pServer->UseIpAddress())
{
Server = pServer->GetIpAddress();
}
else
{
Server = pServer->GetName();
}
lstrcpy(szServer, (LPCTSTR)Server);
DWORD dwStatus = pServer->GetServerRegistrationStatus( );
DBGMSG( L"LICMGR:CMainFrame::OnRegistration calling StartWizard\n", 0 );
StartWizard( hWnd , WIZACTION_REGISTERLS , szServer , &bRefresh );
//DBGMSG( L"LICMGR:CMainFrame::OnRegistration - StartWizard returned 0x%x\n" , status );
if( IsLicenseServerRegistered( hWnd , szServer , &status ) == ERROR_SUCCESS )
{
pServer->SetServerRegistrationStatus( status );
}
if( dwStatus != status )
{
RefreshServer(pServer);
}
UpdateWindow();
}
else
{
DBGMSG( L"LICMGR : OnRegistration on non-enforced server\n",0 );
// AddKeyPackDialog(NULL);
}
}
catch (...)
{
// validation failed - user already alerted, fall through
// Note: DELETE_EXCEPTION_(e) not required
}
}
//////////////////////////////////////////////////////////////////////////////
BOOL
CMainFrame::ConnectServer(
LPCTSTR pszServer
)
/*++
++*/
{
CConnectDialog ConnectDialog;
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc)
return FALSE;
HRESULT hResult = ERROR_SUCCESS;
SERVER_TYPE ServerType;
CString Scope;
if(pszServer == NULL)
{
if(ConnectDialog.DoModal() != IDOK)
{
return FALSE;
}
//
// Empty string - local machine
//
if(ConnectDialog.m_Server.IsEmpty())
{
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
DWORD dwBufSize = MAX_COMPUTERNAME_LENGTH + 1;
memset(szComputerName, 0, sizeof(szComputerName));
GetComputerName(szComputerName, &dwBufSize);
ConnectDialog.m_Server = szComputerName;
}
}
else
{
//
// Minimize code change
//
ConnectDialog.m_Server = pszServer;
}
SetCursor(LoadCursor(NULL,IDC_WAIT));
if(TRUE == pDoc->IsServerInList(ConnectDialog.m_Server))
{
//AfxMessageBox(IDS_DUPLICATE_SERVER);
return FALSE;
}
//HUEIHUEI - Check if server is registered
//
// Do a NT4 RPC connect to make sure the license server
// can accept our calls.
//
CString IpAddress(ConnectDialog.m_Server);
hResult = pDoc->ConnectToServer(
ConnectDialog.m_Server,
Scope,
ServerType
);
if(ERROR_SUCCESS != hResult)
{
CDialog ErrorDialog(IDD_CONNECT_ERROR,this);
ErrorDialog.DoModal();
}
else
{
CAllServers * pAllServers = pDoc->GetAllServers();
CLicServer *pServer1 = NULL;
if(IpAddress != ConnectDialog.m_Server)
{
if(TRUE == pDoc->IsServerInList(ConnectDialog.m_Server))
{
return TRUE;
}
pServer1 = new CLicServer(
ConnectDialog.
m_Server,
ServerType,
Scope,
IpAddress
);
}
else
{
pServer1= new CLicServer(
ConnectDialog.
m_Server,
ServerType,
Scope
);
}
if(pServer1)
{
DWORD dwStatus;
// check for admin
pServer1->SetAdmin( IsUserAdmin( pServer1->GetName() ) );
if( pServer1->IsUserAdmin( ) )
{
if( IsLicenseServerRegistered( GetSafeHwnd() , ( LPCTSTR )pServer1->GetName() , &dwStatus ) == ERROR_SUCCESS )
{
pServer1->SetServerRegistrationStatus( dwStatus );
}
}
CLicMgrDoc * pDoc = (CLicMgrDoc *)(GetActiveView()->GetDocument());
pDoc->EnumerateKeyPacks( pServer1 , LSKEYPACK_SEARCH_LANGID , TRUE );
WIZCONNECTION WizConType;
if( GetConnectionType( GetSafeHwnd() , pServer1->GetName() , &WizConType ) == ERROR_SUCCESS )
{
DBGMSG( L"ConnectServer - GetConnectionType obtained %d" , WizConType );
pServer1->SetConType( WizConType );
}
pAllServers->AddLicServer(pServer1);
SendMessage(WM_ADD_SERVER,0,(LPARAM)pServer1);
// after the send message is called all servers will have their keypacks cached.
pServer1->SetDownLoadLics( IsDownLoadedPacks( pServer1 ) );
}
else
{
return FALSE;
}
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
void
CMainFrame::OnConnectServer()
{
ConnectServer();
}
HRESULT CMainFrame::AddKeyPackDialog(CLicServer * pServer)
{
HRESULT hResult = ERROR_SUCCESS;
CString TempString;
CString Server;
//if pServer is null,Then the message is from Listview.
//Get the current server from the treeview.
SetCursor(LoadCursor(NULL,IDC_WAIT));
if(NULL == pServer)
{
if(ERROR_SUCCESS != GetActiveServer(&pServer))
{
hResult = E_FAIL;
return hResult;
}
}
//Server = pServer->GetName();
CLicMgrDoc * pDoc = (CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc)
{
hResult = E_FAIL;
return hResult;
}
KeyPackList * pKeypackList = pServer->GetKeyPackList();
if(NULL == pKeypackList)
{
hResult = E_FAIL;
return hResult;
}
//If Server is not enumerated enumerate now.
if(!pServer->IsExpanded())
{
HRESULT hResult = pDoc->EnumerateKeyPacks(pServer,LSKEYPACK_SEARCH_LANGID, TRUE);
if(hResult != S_OK)
{
hResult = E_FAIL;
return hResult;
}
POSITION pos1 = pKeypackList->GetHeadPosition();
while(pos1)
{
CKeyPack *pKeyPack = (CKeyPack *)pKeypackList->GetNext(pos1);
hResult = pDoc->EnumerateLicenses(pKeyPack,LSLICENSE_SEARCH_KEYPACKID, TRUE);
if(hResult != S_OK)
{
hResult = E_FAIL;
return hResult;
}
}
}
CAddKeyPack KeyPack(pKeypackList,IsUserAdmin(Server));
KeyPack.DoModal();
return hResult;
}
void CMainFrame::OnUpdateAddNewKeyPack(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
HRESULT hrStatus;
// we have to force another check here
bEnable = IsServerRegistered( &hrStatus );
if( FAILED( hrStatus ) )
{
pCmdUI->Enable(bEnable);
}
else
{
pCmdUI->Enable( !bEnable );
}
}
HRESULT
CMainFrame::AddLicensestoList(
CKeyPack * pKeyPack,
CListCtrl * pListCtrl,
BOOL bRefresh
)
/*++
--*/
{
CLicServer *pServer = NULL;
CString Error;
HRESULT hr;
ASSERT(pKeyPack);
ASSERT(pListCtrl);
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pKeyPack || NULL == pListCtrl || NULL == pDoc)
{
return E_FAIL;
}
if(TRUE == bRefresh)
{
if((hr = pKeyPack->RefreshIssuedLicenses()) != S_OK)
{
EnumFailed(hr,pKeyPack->GetServer());
return E_FAIL;
}
}
IssuedLicenseList * pIssuedLicenseList = pKeyPack->GetIssuedLicenseList();
ASSERT(pIssuedLicenseList);
if(NULL == pIssuedLicenseList)
{
return E_FAIL;
}
LSKeyPack sKeyPack = pKeyPack->GetKeyPackStruct();
int nIndex = 0;
int nSubitemIndex = 1;
CString TempString;
POSITION pos;
LV_ITEM lvI;
lvI.mask = LVIF_TEXT |LVIF_IMAGE |LVIF_STATE | LVIF_PARAM;
lvI.state = 0;
lvI.stateMask =0;
lvI.iSubItem = 0;
lvI.iImage = 2;
pos = pIssuedLicenseList->GetHeadPosition();
while(pos)
{
lvI.iItem = nIndex;
nSubitemIndex = 1;
CLicense * pLicense = pIssuedLicenseList->GetNext(pos);
ASSERT(pLicense);
if(NULL == pLicense)
{
continue;
}
LSLicenseEx sLicense = pLicense->GetLicenseStruct();
lvI.lParam = (LPARAM)pLicense;
TempString = sLicense.szMachineName;
lvI.pszText = TempString.GetBuffer(TempString.GetLength());
lvI.cchTextMax =lstrlen(lvI.pszText + 1);
nIndex = pListCtrl->InsertItem(&lvI);
//Set the Issue date.
pDoc->TimeToString(&sLicense.ftIssueDate, TempString);
if(TempString.IsEmpty())
{
TempString.LoadString(IDS_UNKNOWN);
}
pListCtrl->SetItemText(nIndex,nSubitemIndex,(LPCTSTR)TempString);
nSubitemIndex++;
//Set the expiry date.
if(0x7FFFFFFF != sLicense.ftExpireDate)
{
TempString.LoadString(IDS_DASH);
pDoc->TimeToString(&sLicense.ftExpireDate, TempString);
if(TempString.IsEmpty())
{
TempString.LoadString(IDS_UNKNOWN);
}
}
else
{
TempString.LoadString(IDS_DASH);
}
pListCtrl->SetItemText(nIndex,nSubitemIndex,(LPCTSTR)TempString);
nSubitemIndex++;
// adding status text to license's status column
switch( sLicense.ucLicenseStatus )
{
case LSLICENSE_STATUS_UNKNOWN:
TempString.LoadString( IDS_LICENSESTATUS_UNKNOWN );
break;
case LSLICENSE_STATUS_TEMPORARY:
TempString.LoadString( IDS_LICENSESTATUS_TEMPORARY );
break;
case LSLICENSE_STATUS_ACTIVE:
//case LSLICENSE_STATUS_PENDING_ACTIVE:
case LSLICENSE_STATUS_CONCURRENT:
TempString.LoadString( IDS_LICENSESTATUS_ACTIVE );
break;
case LSLICENSE_STATUS_UPGRADED:
TempString.LoadString( IDS_LICENSESTATUS_UPGRADED );
break;
//case LSLICENSE_STATUS_REVOKE:
//case LSLICENSE_STATUS_REVOKE_PENDING:
// TempString.LoadString( IDS_LICENSESTATUS_REVOKE );
}
if( TempString.IsEmpty() )
{
TempString.LoadString(IDS_UNKNOWN);
}
pListCtrl->SetItemText(nIndex,nSubitemIndex,(LPCTSTR)TempString);
nIndex ++;
}
return S_OK;
}
void CMainFrame :: PressButton(UINT uId, BOOL bPress)
{
CToolBarCtrl& ToolBarCtrl = m_wndToolBar.GetToolBarCtrl();
ToolBarCtrl.PressButton(uId,bPress);
}
/////////////////////////////////////////////////////////////////////
LRESULT
CMainFrame::OnEnumerateServer(WPARAM wParam, LPARAM lParam)
{
CTlsHunt huntDlg;
huntDlg.DoModal();
if( wParam == 0 &&
huntDlg.IsUserCancel() == FALSE &&
huntDlg.GetNumServerFound() == 0 )
{
AfxMessageBox(IDS_NOSERVERINDOMAIN);
}
return 0;
}
/////////////////////////////////////////////////////////////////////
void
CMainFrame :: ConnectAndDisplay()
{
CLicMgrApp *pApp = (CLicMgrApp*)AfxGetApp();
ASSERT(pApp);
CLicMgrDoc *pDoc = (CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pApp || NULL == pDoc)
return;
HRESULT hResult = ERROR_SUCCESS;
CString LicServer;
CString Server = pApp->m_Server;
if(!Server.IsEmpty())
{
//Server Specified in the command line. Connect to it.
hResult = pDoc->ConnectWithCurrentParams();
}
else
{
ActivateFrame();
//
// Save a copy of what we have.
//
LicServer = pApp->m_Server;
pApp->m_Server = _TEXT("");
hResult = pDoc->ConnectWithCurrentParams();
pApp->m_Server = LicServer;
hResult = ERROR_SUCCESS;
}
switch(hResult)
{
case E_FAIL:
AfxMessageBox(IDS_CONNECT_SERVER_FAILED);
break;
case E_OUTOFMEMORY:
AfxMessageBox(IDS_NO_MEMORY);
SendMessage(WM_CLOSE,0,0);
break;
case E_DUPLICATE:
AfxMessageBox(IDS_DUPLICATE_SERVER);
break;
}
return;
}
HRESULT CMainFrame :: GetLicServer(CString * pLicServer)
{
HRESULT hResult = ERROR_SUCCESS;
if(NULL == pLicServer)
return hResult;
HKEY hKey = NULL;
DWORD lSize = MAX_PATH;
ULONG lDataType = REG_SZ;
TCHAR szString[MAX_PATH] = {0};
long lResult;
lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,TERMSERVICE_PARAMETER_KEY,0,KEY_READ,&hKey);
if(ERROR_SUCCESS != lResult)
{
hResult = E_FAIL;
goto cleanup;
}
lResult = RegQueryValueEx(hKey,USE_LICSENSE_SERVER,0,&lDataType,(unsigned char *)szString,&lSize);
if(ERROR_SUCCESS != lResult)
{
hResult = E_FAIL;
goto cleanup;
}
if(szString[0] != 1)
{
hResult = E_FAIL;
goto cleanup;
}
lDataType = REG_SZ;
lSize = MAX_PATH;
lResult = RegQueryValueEx(hKey,LICSENSE_SERVER,0,&lDataType,(unsigned char *)szString,&lSize);
if(ERROR_SUCCESS != lResult)
{
hResult = E_FAIL;
goto cleanup;
}
else
*pLicServer = szString;
cleanup:
if(hKey)
RegCloseKey(hKey);
return hResult;
}
void CMainFrame::OnRefresh()
{
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc)
{
AfxMessageBox(IDS_INTERNAL_ERROR);
return;
}
HRESULT hResult = ERROR_SUCCESS;
CString ErrorServers;
CString Error;
CWaitCursor Wait;
CAllServers *pAllServers = pDoc->GetAllServers();
ASSERT(pAllServers);
if(NULL == pAllServers)
{
AfxMessageBox(IDS_INTERNAL_ERROR);
return;
}
LicServerList * pLicServerList = pAllServers->GetLicServerList();
ASSERT(pLicServerList);
if(NULL == pLicServerList)
{
AfxMessageBox(IDS_INTERNAL_ERROR);
return;
}
POSITION pos = pLicServerList->GetHeadPosition();
OnEnumerateServer(
(pos == NULL) ? 0 : 1, // show error dialog if nothing in the list
0
);
Wait.Restore();
while(pos)
{
// Connect to each server and check if the information in the cache is current. If not update the information.
// If the connection to the server cannot be establised,add them to the list to display to the user.
POSITION TempPos = pos;
CLicServer * pLicServer = pLicServerList->GetNext(pos);
ASSERT(pLicServer);
if(NULL == pLicServer)
{
continue;
}
CString Name = pLicServer->GetName();
//Call Refresh Server
hResult = RefreshServer(pLicServer);
}
if(!ErrorServers.IsEmpty())
{
Error.LoadString(IDS_REFRESH_SERVERS_ERROR);
Error = Error + ErrorServers;
AfxMessageBox(Error);
}
return;
}
void CMainFrame::DeleteServer(LicServerList * pLicServerList, POSITION TempPos, CLicServer * pLicServer)
{
if(NULL == pLicServerList || NULL == pLicServer)
return;
m_pLeftView->SendMessage(WM_DELETE_SERVER,0,(LPARAM)pLicServer);
m_pRightView->SendMessage(WM_DELETE_SERVER,0,(LPARAM)pLicServer);
pLicServerList->RemoveAt(TempPos);
delete pLicServer;
pLicServer = NULL;
}
void CMainFrame::SetTreeViewSel(LPARAM lParam, NODETYPE NodeType)
{
if(NULL == lParam || NULL == m_pLeftView)
return;
((CLicMgrLeftView *)m_pLeftView)->SetSelection(lParam, NodeType);
SetActiveView(m_pLeftView);
return;
}
HRESULT CMainFrame::AddLicenses(CKeyPack * pKeyPack,UINT nLicenses)
{
HRESULT hResult = ERROR_SUCCESS;
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc || NULL == pKeyPack)
{
hResult = E_FAIL;
return hResult;
}
LPLSKeyPack psKeyPack;
psKeyPack = &pKeyPack->GetKeyPackStruct();
hResult = pDoc->AddLicenses(pKeyPack->GetServer(),psKeyPack,nLicenses);
if(ERROR_SUCCESS != hResult)
{
return hResult;
}
m_pRightView->SendMessage(WM_UPDATE_SERVER,0,(LPARAM)pKeyPack->GetServer());
return hResult;
}
HRESULT CMainFrame::RemoveLicenses(CKeyPack * pKeyPack,UINT nLicenses)
{
HRESULT hResult = ERROR_SUCCESS;
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc || NULL == pKeyPack)
{
hResult = E_FAIL;
return hResult;
}
LPLSKeyPack psKeyPack;
psKeyPack = &pKeyPack->GetKeyPackStruct();
hResult = pDoc->RemoveLicenses(pKeyPack->GetServer(),psKeyPack,nLicenses);
if(ERROR_SUCCESS != hResult && LSERVER_I_REMOVE_TOOMANY != hResult)
{
return hResult;
}
m_pRightView->SendMessage(WM_UPDATE_SERVER,0,(LPARAM)pKeyPack->GetServer());
return hResult;
}
void InitLsaString(PLSA_UNICODE_STRING LsaString, LPWSTR String )
{
DWORD StringLength;
if (String == NULL)
{
LsaString->Buffer = NULL;
LsaString->Length = 0;
LsaString->MaximumLength = 0;
return;
}
StringLength = lstrlen(String);
LsaString->Buffer = String;
LsaString->Length = (USHORT) StringLength * sizeof(WCHAR);
LsaString->MaximumLength=(USHORT)(StringLength+1) * sizeof(WCHAR);
}
NTSTATUS
OpenPolicy(
LPWSTR ServerName,
DWORD DesiredAccess,
PLSA_HANDLE PolicyHandle
)
/*++
--*/
{
LSA_OBJECT_ATTRIBUTES ObjectAttributes;
LSA_UNICODE_STRING ServerString;
PLSA_UNICODE_STRING Server = NULL;
// Always initialize the object attributes to all zeroes.
ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
if (ServerName != NULL)
{
// Make a LSA_UNICODE_STRING out of the LPWSTR passed in
InitLsaString(&ServerString, ServerName);
Server = &ServerString;
}
// Attempt to open the policy.
return LsaOpenPolicy(Server, &ObjectAttributes, DesiredAccess, PolicyHandle );
}
BOOL CMainFrame::IsUserAdmin(CString& Server)
{
BOOL IsUserAdmin = FALSE;
LSA_HANDLE PolicyHandle = NULL;
NTSTATUS Status;
Status = OpenPolicy(Server.GetBuffer(Server.GetLength()),POLICY_SERVER_ADMIN,&PolicyHandle);
DBGMSG( L"LICMGR@CMainFrame::IsUserAdmin OpenPolicy returned 0x%x\n" , Status );
if(Status == 0)
IsUserAdmin = TRUE;
if(PolicyHandle)
LsaClose(PolicyHandle);
return IsUserAdmin;
}
void CMainFrame::EnumFailed(HRESULT reason, CLicServer * pLicServer)
{
DBGMSG( L"CMainFrame_EnumFailed\n" , 0 );
ASSERT(pLicServer);
if(NULL == pLicServer)
return;
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc)
return;
CString Error;
CString Server;
POSITION pos;
BOOL bFoundServer = FALSE;
LicServerList * pLicServerList = NULL;
POSITION temppos = NULL;
switch(reason)
{
case CONNECTION_FAILED:
DBGMSG( L"\tCONNECTION_FAILED\n" , 0 );
Server = pLicServer->GetName();
Error.Format(IDS_CONNECT_ERROR,Server);
AfxMessageBox(Error);
pLicServerList = (pDoc->GetAllServers())->GetLicServerList();
if(NULL == pLicServerList)
break;
//Find the position of the server in the List;
pos = pLicServerList->GetHeadPosition();
while(pos)
{
temppos = pos;
CLicServer *pServer = (CLicServer *)pLicServerList->GetNext(pos);
ASSERT(pServer);
if(NULL == pServer)
continue;
if((0 == Server.CompareNoCase(pServer->GetName())) || (0 == Server.CompareNoCase(pServer->GetIpAddress())))
{
bFoundServer = TRUE;
break;
}
}
if(bFoundServer)
DeleteServer(pLicServerList,temppos,pLicServer);
break;
case LSERVER_E_SERVER_BUSY:
DBGMSG( L"\tLSERVER_E_SERVER_BUSY\n" , 0 );
AfxMessageBox(IDS_SERVER_BUSY);
break;
case LSERVER_E_OUTOFMEMORY:
DBGMSG( L"\tLSERVER_E_OUTOFMEMORY\n" , 0 );
AfxMessageBox(IDS_SERVER_OUTOFMEMORY);
break;
case LSERVER_E_INTERNAL_ERROR:
DBGMSG( L"\tLSERVER_E_INTERNAL_ERROR\n" , 0 );
AfxMessageBox(IDS_SERVER_INTERNAL_ERROR);
pLicServerList = (pDoc->GetAllServers())->GetLicServerList();
if(NULL == pLicServerList)
break;
//Find the position of the server in the List;
pos = pLicServerList->GetHeadPosition();
while(pos)
{
temppos = pos;
CLicServer *pServer = (CLicServer *)pLicServerList->GetNext(pos);
ASSERT(pServer);
if(NULL == pServer)
continue;
if((0 == Server.CompareNoCase(pServer->GetName())) || (0 == Server.CompareNoCase(pServer->GetIpAddress())))
{
bFoundServer = TRUE;
break;
}
}
if(bFoundServer)
DeleteServer(pLicServerList,temppos,pLicServer);
break;
case E_OUTOFMEMORY:
DBGMSG( L"\tE_OUTOFMEMORY\n" , 0 );
AfxMessageBox(IDS_NO_MEMORY);
break;
default:
break;
}
}
void CMainFrame::SelectView(VIEW view)
{
if(view == TREEVIEW)
{
SetActiveView(m_pLeftView);
}
else
{
SetActiveView(m_pRightView);
}
}
HRESULT CMainFrame::RefreshServer(CLicServer * pLicServer)
{
DWORD dwStatus;
HRESULT hResult = E_FAIL;
CWaitCursor Wait;
if(NULL == pLicServer)
{
return E_INVALIDARG;
}
DBGMSG( L"LICMGR : CMainFrame::RefreshServer %s\n" , pLicServer->GetName( ) );
CLicMgrDoc * pDoc =(CLicMgrDoc *)(GetActiveView()->GetDocument());
ASSERT(pDoc);
if(NULL == pDoc)
{
return ERROR_INTERNAL_ERROR;
}
CString Server;
if(pLicServer->UseIpAddress())
{
Server = pLicServer->GetIpAddress();
}
else
{
Server = pLicServer->GetName();
}
WIZCONNECTION WizConType;
DBGMSG( L"LICMGR:CMainFrame::RefreshServer setting ConnectionType\n" , 0 );
if( GetConnectionType( GetSafeHwnd() , Server , &WizConType ) == ERROR_SUCCESS )
{
pLicServer->SetConType( WizConType );
}
// check for admin
DBGMSG( L"LICMGR:CMainFrame::RefreshServer setting admin priv\n" , 0 );
pLicServer->SetAdmin( IsUserAdmin( Server ) );
if( !pLicServer->IsUserAdmin( ) )
{
return E_ACCESSDENIED;
}
DBGMSG( L"LICMGR:CMainFrame::RefreshServer updating server status\n" , 0 );
if( IsLicenseServerRegistered( GetSafeHwnd( ) , Server , &dwStatus ) == ERROR_SUCCESS )
{
pLicServer->SetServerRegistrationStatus( dwStatus );
}
else
{
pLicServer->SetServerRegistrationStatus( ( DWORD )-1 );
}
//Could connect to the server. check if Info in cache is proper.
//If server is not expanded leave it like that.
/*
if(!pLicServer->IsExpanded())
{
DBGMSG( L"LICMGR:Cmainframe licserver not expanded\n" , 0 );
return S_OK;
}
*/
KeyPackList * pkeypackList = pLicServer->GetKeyPackList();
if(NULL == pkeypackList)
{
DBGMSG( L"LICMGR:RefreshServer no keypacklist\n",0 );
return E_FAIL;
}
POSITION pos1 = pkeypackList->GetHeadPosition();
CKeyPack *pKeyPack = NULL;
DBGMSG( L"LICMGR:CMainFrame::RefreshServer removing keypacks\n" , 0 );
while(pos1)
{
pKeyPack = (CKeyPack *)pkeypackList->GetNext(pos1);
ASSERT(pKeyPack);
if(pKeyPack)
{
delete pKeyPack;
pKeyPack = NULL;
}
}
pkeypackList->RemoveAll();
pLicServer->Expand(FALSE);
DBGMSG( L"LICMGR:CMainFrame::RefreshServer enumerating keypacks\n" , 0 );
hResult = pDoc->EnumerateKeyPacks(
pLicServer,
LSKEYPACK_SEARCH_LANGID,
TRUE
);
if(hResult != S_OK)
{
EnumFailed( hResult , pLicServer );
return hResult;
}
/*
pos1 = pkeypackList->GetHeadPosition();
BOOL bFlag = FALSE;
while(pos1)
{
CKeyPack *pKeyPack = (CKeyPack *)pkeypackList->GetNext(pos1);
hResult = pDoc->EnumerateLicenses(
pKeyPack,
LSLICENSE_SEARCH_KEYPACKID,
TRUE
);
if(hResult != S_OK)
{
return hResult;
}
}
*/
DBGMSG( L"LICMGR:CMainFrame::RefreshServer checking for keypacks\n" , 0 );
pLicServer->SetDownLoadLics( IsDownLoadedPacks( pLicServer ) );
m_pLeftView->SendMessage(WM_UPDATE_SERVER,0,(LPARAM)pLicServer);
m_pRightView->SendMessage(WM_UPDATE_SERVER,0,(LPARAM)pLicServer);
return hResult;
}
//--------------------------------------------------------------------
void CMainFrame::OnUpdateDownloadlicenses( CCmdUI * pCmdUI )
{
DBGMSG( L"LICMGR@CMainFrame::OnUpdateDownloadlicenses\n" , 0 );
CLicServer *pServer = NULL;
HRESULT hr;
GetActiveServer( &pServer );
pCmdUI->Enable( FALSE );
if( pServer != NULL )
{
if( pServer->GetServerType( ) == SERVER_TS5_ENFORCED )
{
pCmdUI->Enable( IsServerRegistered( &hr ) );
}
else
{
pCmdUI->Enable( TRUE );
}
}
else
{
pCmdUI->Enable( FALSE );
}
}
//--------------------------------------------------------------------
void CMainFrame::OnUpdateRepeatLastDownload( CCmdUI * pCmdUI )
{
DBGMSG( L"LICMGR@CMainFrame::OnUpdateRepeatLastDownload\n" , 0 );
HRESULT hr;
CLicServer * pLicServer = NULL;
if( SUCCEEDED( GetActiveServer( &pLicServer ) ) )
{
if( pLicServer->GetConType( ) != CONNECTION_WWW )
{
if( IsServerRegistered( &hr ) )
{
pCmdUI->Enable( IsLicensesDownLoaded() );
return;
}
}
}
pCmdUI->Enable( FALSE );
}
//--------------------------------------------------------------------
void CMainFrame::OnUpdateReregisterserver( CCmdUI * pCmdUI )
{
DBGMSG( L"LICMGR@CMainFrame::OnUpdateReregisterserver\n" , 0 );
HRESULT hr;
CLicServer * pLicServer = NULL;
if( SUCCEEDED( GetActiveServer( &pLicServer ) ) )
{
if( pLicServer->GetConType( ) != CONNECTION_WWW )
{
pCmdUI->Enable( IsServerRegistered( &hr ) );
return;
}
}
pCmdUI->Enable( FALSE );
}
//--------------------------------------------------------------------
void CMainFrame::OnUpdateUnregisterserver( CCmdUI * pCmdUI )
{
DBGMSG( L"LICMGR@CMainFrame::OnUpdateUnregisterserver\n" , 0 );
HRESULT hr;
CLicServer * pLicServer = NULL;
if( SUCCEEDED( GetActiveServer( &pLicServer ) ) )
{
if( pLicServer->GetConType( ) != CONNECTION_WWW )
{
pCmdUI->Enable( IsServerRegistered( &hr ) );
return;
}
}
pCmdUI->Enable( FALSE );
}
//--------------------------------------------------------------------
void CMainFrame::OnUpdateRefresh( CCmdUI *pCmdUI )
{
CLicServer * pLicServer = NULL;
if( FAILED( GetActiveServer( &pLicServer ) ) )
{
pCmdUI->Enable( FALSE );
}
else
{
pCmdUI->Enable( TRUE );
}
}
//--------------------------------------------------------------------
void CMainFrame::OnUpdateProperties( CCmdUI *pCmdUI )
{
CLicServer * pLicServer = NULL;
GetActiveServer( &pLicServer );
pCmdUI->Enable( FALSE );
if( pLicServer != NULL && pLicServer->GetServerType( ) == SERVER_TS5_ENFORCED )
{
pCmdUI->Enable( TRUE );
}
}
//--------------------------------------------------------------------
void CMainFrame::OnRefreshServer( )
{
CLicServer * pLicServer = NULL;
if( FAILED( GetActiveServer( &pLicServer ) ) )
{
// nothing to refresh
return;
}
RefreshServer( pLicServer );
}
//--------------------------------------------------------------------
BOOL CMainFrame::IsServerRegistered( HRESULT *phrStatus )
{
BOOL bEnable = FALSE;
ASSERT( phrStatus != NULL );
DWORD dwServerStatus = ERROR_SUCCESS;
CLicServer * pLicServer = NULL;
*phrStatus = GetActiveServer( &pLicServer );
if( pLicServer != NULL )
{
if( pLicServer->GetServerType() == SERVER_TS5_ENFORCED )
{
dwServerStatus = pLicServer->GetServerRegistrationStatus( );
}
else
{
*phrStatus = E_FAIL; // fail all non enforced server
}
}
if( dwServerStatus == LSERVERSTATUS_REGISTER_INTERNET ||
dwServerStatus == LSERVERSTATUS_REGISTER_OTHER )
{
bEnable = TRUE;
}
else
{
bEnable = FALSE;
}
DBGMSG( L"LICMGR@CMainFrame::IsServerRegistered -- status returned 0x%x\n" , dwServerStatus );
return bEnable;
}
//--------------------------------------------------------------------
// used by views
//--------------------------------------------------------------------
void CMainFrame::UI_initmenu( CMenu *pMenu , NODETYPE nt )
{
HRESULT hr;
CLicServer *pServer;
GetActiveServer( &pServer );
if( pMenu == NULL )
{
return;
}
UINT uMF = MF_GRAYED | MF_DISABLED;
if( pServer != NULL )
{
if( pServer->GetConType() != CONNECTION_WWW )
{
DBGMSG( L"LICMGR:UI_initmenu server contype is not www\n" , 0 );
uMF = MF_ENABLED;
}
}
BOOL bEnable = IsServerRegistered( &hr );
if( nt == NODE_SERVER )
{
if( bEnable )
{
if( FAILED( hr ) )
{
pMenu->EnableMenuItem( ID_SVR_ACTIVATESERVER , MF_ENABLED );
}
else
{
pMenu->EnableMenuItem( ID_SVR_ACTIVATESERVER , MF_GRAYED | MF_DISABLED );
}
pMenu->EnableMenuItem( ID_LPK_ADVANCED_REACTIVATESERVER , uMF );
pMenu->EnableMenuItem( ID_LPK_ADVANCED_DEACTIVATESERVER , uMF );
pMenu->EnableMenuItem( ID_LPK_PROPERTIES , MF_ENABLED );
if( IsLicensesDownLoaded() )
{
pMenu->EnableMenuItem( ID_LPK_DOWNLOADLICENSES , MF_ENABLED );
pMenu->EnableMenuItem( ID_LPK_ADVANCED_REPEATLASTDOWNLOAD , uMF );
}
else
{
pMenu->EnableMenuItem( ID_LPK_DOWNLOADLICENSES , MF_ENABLED );
pMenu->EnableMenuItem( ID_LPK_ADVANCED_REPEATLASTDOWNLOAD , MF_GRAYED | MF_DISABLED );
}
}
else
{
if( SUCCEEDED( hr ) )
{
pMenu->EnableMenuItem( ID_SVR_ACTIVATESERVER , MF_ENABLED );
}
else
{
pMenu->EnableMenuItem( ID_SVR_ACTIVATESERVER , MF_DISABLED | MF_GRAYED );
}
if( pServer != NULL )
{
if( pServer->GetServerType( ) == SERVER_TS5_ENFORCED )
{
pMenu->EnableMenuItem( ID_LPK_DOWNLOADLICENSES , MF_GRAYED | MF_DISABLED );
pMenu->EnableMenuItem( ID_LPK_PROPERTIES , MF_ENABLED );
}
else
{
pMenu->EnableMenuItem( ID_LPK_DOWNLOADLICENSES , MF_ENABLED );
pMenu->EnableMenuItem( ID_LPK_PROPERTIES , MF_GRAYED | MF_DISABLED );
}
}
pMenu->EnableMenuItem( ID_LPK_ADVANCED_REPEATLASTDOWNLOAD , MF_GRAYED | MF_DISABLED );
pMenu->EnableMenuItem( ID_LPK_ADVANCED_REACTIVATESERVER , MF_GRAYED | MF_DISABLED );
pMenu->EnableMenuItem( ID_LPK_ADVANCED_DEACTIVATESERVER , MF_GRAYED | MF_DISABLED );
}
}
else if( nt == NODE_KEYPACK )
{
if( bEnable )
{
if( IsLicensesDownLoaded() )
{
pMenu->EnableMenuItem( ID_LICPAK_DOWNLOADLICENSES , MF_ENABLED );
pMenu->EnableMenuItem( ID_LICPAK_REPEATDOWNLOAD , uMF );
}
else
{
pMenu->EnableMenuItem( ID_LICPAK_DOWNLOADLICENSES , MF_ENABLED );
pMenu->EnableMenuItem( ID_LICPAK_REPEATDOWNLOAD , MF_GRAYED | MF_DISABLED );
}
}
else
{
if( pServer != NULL && pServer->GetServerType() == SERVER_TS5_ENFORCED )
{
pMenu->EnableMenuItem( ID_LICPAK_DOWNLOADLICENSES , MF_GRAYED | MF_DISABLED );
}
else
{
pMenu->EnableMenuItem( ID_LICPAK_DOWNLOADLICENSES , MF_ENABLED );
}
pMenu->EnableMenuItem( ID_LICPAK_REPEATDOWNLOAD , MF_GRAYED | MF_DISABLED );
}
}
else if( nt == NODE_ALL_SERVERS )
{
pMenu->EnableMenuItem( ID_ALLSVR_REFRESHALL , MF_ENABLED );
}
/*
else if( nt == NODE_NONE )
{
// this can only mean licenses
if( !IsLicensesDownLoaded( ) )
{
pMenu->EnableMenuItem( ID_LIC_DOWNLOADLICENSES , MF_GRAYED | MF_DISABLED );
}
}
*/
}
//------------------------------------------------------------------------------------
void CMainFrame::OnDownLoadLicenses( )
{
BOOL bF;
CLicServer *pLicServer = NULL;
GetActiveServer( &pLicServer );
if( pLicServer != NULL )
{
if( pLicServer->GetServerType() == SERVER_TS5_ENFORCED )
{
DWORD dw = WizardActionOnServer( WIZACTION_DOWNLOADLKP , &bF , NOVIEW );
DBGMSG( L"LICMGR : OnDownLoadLicenses returned 0x%x\n " , dw );
}
else
{
AddKeyPackDialog(NULL);
}
}
}
//------------------------------------------------------------------------------------
void CMainFrame::OnRepeatLastDownLoad( )
{
BOOL bF;
DWORD dw = WizardActionOnServer( WIZACTION_DOWNLOADLASTLKP , &bF , NOVIEW );
DBGMSG( L"LICMGR : OnRepeatLastDownLoad returned 0x%x\n " , dw );
}
//------------------------------------------------------------------------------------
void CMainFrame::OnReRegisterServer( )
{
BOOL bF;
DWORD dw = WizardActionOnServer( WIZACTION_REREGISTERLS , &bF , NOVIEW );
DBGMSG( L"LICMGR : OnReRegisterServer returned 0x%x\n " , dw );
}
//------------------------------------------------------------------------------------
void CMainFrame::OnUnRegisterServer( )
{
BOOL bF;
DWORD dw = WizardActionOnServer( WIZACTION_UNREGISTERLS , &bF , NOVIEW );
DBGMSG( L"LICMGR : OnUnRegisterServer returned 0x%x\n " , dw );
}
//------------------------------------------------------------------------------------
void CMainFrame::OnProperties( )
{
BOOL bF;
DWORD dw = WizardActionOnServer( WIZACTION_SHOWPROPERTIES , &bF , NOVIEW );
DBGMSG( L"LICMGR : CMainFrame -- OnProperties returned 0x%x\n", dw );
}
//------------------------------------------------------------------------------------
BOOL CMainFrame::IsLicensesDownLoaded( )
{
CLicServer * pLicServer = NULL;
if( SUCCEEDED( GetActiveServer( &pLicServer ) ) )
{
if( pLicServer != NULL )
{
if( pLicServer->GetConType( ) != CONNECTION_PHONE )
{
DBGMSG( L"Licmgr CMainFrame::IsLicensesDownLoaded GetConnectionType internet - www base\n" , 0 );
return pLicServer->IsLicsDownloaded( );
}
else
{
return FALSE;
}
}
}
return FALSE;
}
//------------------------------------------------------------------------------------
DWORD CMainFrame::WizardActionOnServer( WIZACTION wa , PBOOL pbRefresh , VIEW vt )
{
CLicMgrLeftView * pLeftView = (CLicMgrLeftView *)m_pLeftView;
CTreeCtrl& TreeCtrl = pLeftView->GetTreeCtrl();
CRightList * pRightView = (CRightList *)m_pRightView;
CLicServer *pServer = NULL;
if( vt == TREEVIEW )
{
CTreeNode *pNode = (CTreeNode *)TreeCtrl.GetItemData( pLeftView->GetRightClickedItem() );
if( pNode->GetNodeType() == NODE_SERVER )
{
pServer = static_cast< CLicServer * >( pNode->GetTreeObject() );
}
else if( pNode->GetNodeType( ) == NODE_KEYPACK )
{
CKeyPack *pKeyPack = static_cast< CKeyPack *>( pNode->GetTreeObject() );
if( pKeyPack != NULL )
{
pServer = pKeyPack->GetServer( );
}
}
}
else if( vt == LISTVIEW )
{
CListCtrl& listctrl = pRightView->GetListCtrl();
CLicMgrDoc * pDoc = ( CLicMgrDoc * )( GetActiveView()->GetDocument( ) );
ASSERT(pDoc);
if(NULL == pDoc)
{
return ERROR_INVALID_PARAMETER;
}
int nSelected = listctrl.GetNextItem(-1, LVNI_SELECTED);
if( -1 != nSelected)
{
DWORD_PTR dCurrSel = listctrl.GetItemData( nSelected );
if( NODE_ALL_SERVERS == pDoc->GetNodeType() )
{
pServer = reinterpret_cast< CLicServer * >( dCurrSel );
}
else if( pDoc->GetNodeType() == NODE_SERVER )
{
CKeyPack *pKeyPack = reinterpret_cast< CKeyPack *>( dCurrSel );
if( pKeyPack != NULL )
{
pServer = pKeyPack->GetServer( );
}
}
else if( pDoc->GetNodeType( ) == NODE_KEYPACK )
{
CLicense * pLicense = reinterpret_cast< CLicense * >( dCurrSel );
pServer = ( pLicense->GetKeyPack() )->GetServer( );
}
}
}
else if( vt == NOVIEW )
{
CLicServer * pLicServer = NULL;
if( SUCCEEDED( GetActiveServer( &pLicServer ) ) )
{
pServer = pLicServer;
}
}
if( pServer != NULL )
{
DWORD dw = ERROR_SUCCESS;
// check for admin
if( !pServer->IsUserAdmin( ) )
{
AfxMessageBox( IDS_E_ACCESSDENIED );
//::MessageBox( GetSafeHwnd( ) , L"Unable to perform operation: Access denied" , L"Terminal Services Licensing" , MB_OK|MB_ICONINFORMATION );
return ERROR_ACCESS_DENIED;
}
if( wa != WIZACTION_REGISTERLS )
{
if( pServer->GetServerType() == SERVER_TS5_ENFORCED )
{
DBGMSG( L"LICMGR:CMainFrame::WizardActionOnServer calling StartWizard\n", 0 );
dw = StartWizard( GetSafeHwnd( ) , wa , (LPCTSTR)pServer->GetName( ) , pbRefresh );
DBGMSG( L"StartWizard ( central call ) returned 0x%x\n", dw );
DBGMSG( L"StartWizard ( central call ) refresh = %s\n", *pbRefresh ? L"true" : L"false" );
if( *pbRefresh )
{
RefreshServer( pServer );
}
}
else
{
if( wa == WIZACTION_DOWNLOADLKP )
{
AddKeyPackDialog(NULL);
}
}
}
switch( wa )
{
case WIZACTION_REGISTERLS:
// this handles non-enforced as well.
OnRegistration( );
break;
case WIZACTION_UNREGISTERLS :
if( dw == ERROR_SUCCESS )
{
pServer->SetDownLoadLics( FALSE );
}
// FALL THROUGH
case WIZACTION_REREGISTERLS :
{
DWORD dwStatus;
if( IsLicenseServerRegistered( GetSafeHwnd( ) , (LPCTSTR)pServer->GetName( ) , &dwStatus ) == ERROR_SUCCESS )
{
pServer->SetServerRegistrationStatus( dwStatus );
}
}
break;
}
return dw;
}
return ERROR_INVALID_PARAMETER;
}
//------------------------------------------------------------------------------------
BOOL CMainFrame::IsDownLoadedPacks( CLicServer *pServer )
{
UINT counter = 0;
if( pServer != NULL )
{
KeyPackList *pKeyPackList = pServer->GetKeyPackList( );
if( pKeyPackList != NULL )
{
POSITION pos = pKeyPackList->GetHeadPosition();
while(pos)
{
CKeyPack *pKeyPack = (CKeyPack *)pKeyPackList->GetNext(pos);
if( pKeyPack != NULL )
{
if( pKeyPack->GetKeyPackStruct().ucKeyPackType != LSKEYPACKTYPE_TEMPORARY &&
pKeyPack->GetKeyPackStruct().ucKeyPackType != LSKEYPACKTYPE_FREE )
{
counter++;
DBGMSG( L"LICMGR:CMainFrame found %d keypack(s)\n" , counter );
}
}
}
if( counter >= 1 )
{
DBGMSG( L"LICMGR : CMainFrame IsDownLoadedPacks returns true\n" ,0 );
return TRUE;
}
}
}
DBGMSG( L"LICMGR : CMainFrame IsDownLoadedPacks returns false \n" ,0 );
return FALSE;
}
Reference in a new issue Copy permalink