1642 lines
66 KiB
C++
1642 lines
66 KiB
C++
/*******************************************************************************
|
|
*
|
|
* winadmin.h
|
|
*
|
|
* main header file for the WINADMIN application
|
|
*
|
|
* copyright notice: Copyright 1997, Citrix Systems Inc.
|
|
* Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
* $Author: donm $ Don Messerli
|
|
*
|
|
* $Log: N:\nt\private\utils\citrix\winutils\tsadmin\VCS\winadmin.h $
|
|
*
|
|
* Rev 1.12 25 Apr 1998 13:43:14 donm
|
|
* MS 2167: try to use proper Wd from registry
|
|
*
|
|
* Rev 1.11 19 Feb 1998 17:42:52 donm
|
|
* removed latest extension DLL support
|
|
*
|
|
* Rev 1.9 19 Jan 1998 16:49:28 donm
|
|
* new ui behavior for domains and servers
|
|
*
|
|
* Rev 1.8 03 Nov 1997 15:28:02 donm
|
|
* added Domains
|
|
*
|
|
* Rev 1.7 22 Oct 1997 21:09:10 donm
|
|
* update
|
|
*
|
|
* Rev 1.6 17 Oct 1997 18:07:28 donm
|
|
* update
|
|
*
|
|
* Rev 1.5 15 Oct 1997 19:52:48 donm
|
|
* update
|
|
*
|
|
* Rev 1.4 13 Oct 1997 23:07:14 donm
|
|
* update
|
|
*
|
|
* Rev 1.3 13 Oct 1997 22:20:02 donm
|
|
* update
|
|
*
|
|
* Rev 1.2 26 Aug 1997 19:16:24 donm
|
|
* bug fixes/changes from WinFrame 1.7
|
|
*
|
|
* Rev 1.1 31 Jul 1997 16:52:52 butchd
|
|
* update
|
|
*
|
|
* Rev 1.0 30 Jul 1997 17:13:12 butchd
|
|
* Initial revision.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#ifndef _WINADMIN_H
|
|
#define _WINADMIN_H
|
|
|
|
#ifndef __AFXWIN_H__
|
|
#error include 'stdafx.h' before including this file for PCH
|
|
#endif
|
|
|
|
#include "resource.h" // main symbols
|
|
#include <afxmt.h>
|
|
#include <winsta.h>
|
|
#include <time.h>
|
|
#include <utildll.h>
|
|
#include "waextend.h"
|
|
|
|
// Classes defined in this file
|
|
class CTreeNode;
|
|
class CWinStation;
|
|
class CModule;
|
|
class CLicense;
|
|
class CServer;
|
|
class CWinAdminApp;
|
|
class CProcess;
|
|
class CHotFix;
|
|
class CDomain;
|
|
class CWd;
|
|
|
|
// Server icon overlay states
|
|
const USHORT STATE_NORMAL = 0x0000;
|
|
const USHORT STATE_NOT = 0x0100;
|
|
const USHORT STATE_QUESTION = 0x0200;
|
|
|
|
const USHORT MSG_TITLE_LENGTH = 64;
|
|
const USHORT MSG_MESSAGE_LENGTH = 256;
|
|
|
|
const USHORT LIST_TOP_OFFSET = 4;
|
|
|
|
const int KBDSHIFT = 0x01;
|
|
const int KBDCTRL = 0x02;
|
|
const int KBDALT = 0x04;
|
|
|
|
|
|
enum VIEW {
|
|
VIEW_BLANK,
|
|
VIEW_ALL_SERVERS,
|
|
VIEW_DOMAIN,
|
|
VIEW_SERVER,
|
|
VIEW_MESSAGE,
|
|
VIEW_WINSTATION,
|
|
VIEW_CHANGING
|
|
};
|
|
|
|
const int PAGE_CHANGING = 0xFFFF;
|
|
|
|
enum AS_PAGE {
|
|
// All Servers Pages
|
|
PAGE_AS_SERVERS,
|
|
PAGE_AS_USERS,
|
|
PAGE_AS_WINSTATIONS,
|
|
PAGE_AS_PROCESSES,
|
|
PAGE_AS_LICENSES
|
|
};
|
|
|
|
enum DOMAIN_PAGE {
|
|
PAGE_DOMAIN_SERVERS,
|
|
PAGE_DOMAIN_USERS,
|
|
PAGE_DOMAIN_WINSTATIONS,
|
|
PAGE_DOMAIN_PROCESSES,
|
|
PAGE_DOMAIN_LICENSES
|
|
};
|
|
|
|
enum SERVER_PAGE {
|
|
// Server Pages
|
|
PAGE_USERS,
|
|
PAGE_WINSTATIONS,
|
|
PAGE_PROCESSES,
|
|
PAGE_LICENSES,
|
|
PAGE_INFO
|
|
};
|
|
|
|
enum WINS_PAGE {
|
|
// WinStation Pages
|
|
PAGE_WS_PROCESSES,
|
|
PAGE_WS_INFO,
|
|
PAGE_WS_MODULES,
|
|
PAGE_WS_CACHE,
|
|
PAGE_WS_NO_INFO
|
|
};
|
|
|
|
// The column enums have to be here so that colsort.cpp can get to them
|
|
// Server User's columns
|
|
enum USERSCOLUMNS {
|
|
USERS_COL_USER,
|
|
USERS_COL_WINSTATION,
|
|
USERS_COL_ID,
|
|
USERS_COL_STATE,
|
|
USERS_COL_IDLETIME,
|
|
USERS_COL_LOGONTIME
|
|
};
|
|
|
|
// Server WinStation's columns
|
|
enum STATIONCOLUMNS {
|
|
WS_COL_WINSTATION,
|
|
WS_COL_USER,
|
|
WS_COL_ID,
|
|
WS_COL_STATE,
|
|
WS_COL_TYPE,
|
|
WS_COL_CLIENTNAME,
|
|
WS_COL_IDLETIME,
|
|
WS_COL_LOGONTIME,
|
|
WS_COL_COMMENT
|
|
};
|
|
|
|
// Server Processes' columns
|
|
enum PROCESSCOLUMNS {
|
|
PROC_COL_USER,
|
|
PROC_COL_WINSTATION,
|
|
PROC_COL_ID,
|
|
PROC_COL_PID,
|
|
PROC_COL_IMAGE
|
|
};
|
|
|
|
// Server Licenses' columns
|
|
enum LICENSECOLUMNS {
|
|
LICENSE_COL_DESCRIPTION,
|
|
LICENSE_COL_REGISTERED,
|
|
LICENSE_COL_USERCOUNT,
|
|
LICENSE_COL_POOLCOUNT,
|
|
LICENSE_COL_NUMBER
|
|
};
|
|
|
|
// Server Hotfix columns
|
|
enum HOTFIXCOLUMNS {
|
|
HOTFIX_COL_NAME,
|
|
HOTFIX_COL_INSTALLEDBY,
|
|
HOTFIX_COL_INSTALLEDON
|
|
};
|
|
|
|
// WinStation Processes columns
|
|
enum WS_PROCESSCOLUMNS {
|
|
WS_PROC_COL_ID,
|
|
WS_PROC_COL_PID,
|
|
WS_PROC_COL_IMAGE
|
|
};
|
|
|
|
// WinStation Modules columns
|
|
enum MODULESCOLUMNS {
|
|
MODULES_COL_FILENAME,
|
|
MODULES_COL_FILEDATETIME,
|
|
MODULES_COL_SIZE,
|
|
MODULES_COL_VERSIONS
|
|
};
|
|
|
|
// All Server Servers columns
|
|
enum SERVERSCOLUMNS {
|
|
SERVERS_COL_SERVER,
|
|
SERVERS_COL_TCPADDRESS,
|
|
SERVERS_COL_IPXADDRESS,
|
|
SERVERS_COL_NUMWINSTATIONS
|
|
};
|
|
|
|
// All Server Users columns
|
|
enum AS_USERS_COLUMNS {
|
|
AS_USERS_COL_SERVER,
|
|
AS_USERS_COL_USER,
|
|
AS_USERS_COL_WINSTATION,
|
|
AS_USERS_COL_ID,
|
|
AS_USERS_COL_STATE,
|
|
AS_USERS_COL_IDLETIME,
|
|
AS_USERS_COL_LOGONTIME
|
|
};
|
|
|
|
// All Server WinStations columns
|
|
enum AS_STATIONCOLUMNS {
|
|
AS_WS_COL_SERVER,
|
|
AS_WS_COL_WINSTATION,
|
|
AS_WS_COL_USER,
|
|
AS_WS_COL_ID,
|
|
AS_WS_COL_STATE,
|
|
AS_WS_COL_TYPE,
|
|
AS_WS_COL_CLIENTNAME,
|
|
AS_WS_COL_IDLETIME,
|
|
AS_WS_COL_LOGONTIME,
|
|
AS_WS_COL_COMMENT
|
|
};
|
|
|
|
// All Server Processes columns
|
|
enum AS_PROCESSCOLUMNS {
|
|
AS_PROC_COL_SERVER,
|
|
AS_PROC_COL_USER,
|
|
AS_PROC_COL_WINSTATION,
|
|
AS_PROC_COL_ID,
|
|
AS_PROC_COL_PID,
|
|
AS_PROC_COL_IMAGE
|
|
};
|
|
|
|
// All Server Licenses columns
|
|
enum AS_LICENSECOLUMNS {
|
|
AS_LICENSE_COL_SERVER,
|
|
AS_LICENSE_COL_DESCRIPTION,
|
|
AS_LICENSE_COL_REGISTERED,
|
|
AS_LICENSE_COL_USERCOUNT,
|
|
AS_LICENSE_COL_POOLCOUNT,
|
|
AS_LICENSE_COL_NUMBER
|
|
};
|
|
|
|
// in colsort.cpp
|
|
void SortByColumn(int View, int Page, CListCtrl *list, int ColumnNumber, BOOL bAscending);
|
|
|
|
// Extension Startup Function
|
|
typedef void (WINAPI *LPFNEXSTARTUPPROC) (HWND);
|
|
// Extension Shutdown Function
|
|
typedef void (WINAPI *LPFNEXSHUTDOWNPROC) (void);
|
|
// Extension Server Enumerate Function
|
|
typedef LPWSTR (WINAPI *LPFNEXENUMERATEPROC) (LPWSTR);
|
|
// Extension WinStation Init Function
|
|
typedef void* (WINAPI *LPFNEXWINSTATIONINITPROC) (HANDLE, ULONG);
|
|
// Extension WinStation Additional Info Function
|
|
typedef void (WINAPI *LPFNEXWINSTATIONINFOPROC) (void*, int);
|
|
// Extension WinStation Cleanup Function
|
|
typedef void (WINAPI *LPFNEXWINSTATIONCLEANUPPROC) (void*);
|
|
// Extension Server Init Function
|
|
typedef void* (WINAPI *LPFNEXSERVERINITPROC) (TCHAR*, HANDLE);
|
|
// Extension Server Cleanup Function
|
|
typedef void (WINAPI *LPFNEXSERVERCLEANUPPROC) (void*);
|
|
// Extension Server Event Function
|
|
typedef BOOL (WINAPI *LPFNEXSERVEREVENTPROC) (void*, ULONG);
|
|
// Extension Get Server Info
|
|
typedef ExtServerInfo* (WINAPI *LPFNEXGETSERVERINFOPROC) (void *);
|
|
// Extension Get Server License Info
|
|
typedef ExtLicenseInfo* (WINAPI *LPFNEXGETSERVERLICENSESPROC) (void*, ULONG*);
|
|
// Extension Get Global Info
|
|
typedef ExtGlobalInfo* (WINAPI *LPFNEXGETGLOBALINFOPROC) (void);
|
|
// Extension Get WinStation Info
|
|
typedef ExtWinStationInfo* (WINAPI *LPFNEXGETWINSTATIONINFOPROC) (void *);
|
|
// Extension Get WinStation Modules
|
|
typedef ExtModuleInfo* (WINAPI *LPFNEXGETWINSTATIONMODULESPROC) (void*, ULONG*);
|
|
// Extension Free Server License Info
|
|
typedef void (WINAPI *LPFNEXFREESERVERLICENSESPROC) (ExtLicenseInfo*);
|
|
// Extension Free WinStation Modules
|
|
typedef void (WINAPI *LPFNEXFREEWINSTATIONMODULESPROC) (ExtModuleInfo*);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CWinAdminApp:
|
|
// See WinAdmin.cpp for the implementation of this class
|
|
//
|
|
class CWinAdminApp : public CWinApp
|
|
{
|
|
public:
|
|
// constructor
|
|
CWinAdminApp();
|
|
// Returns the Current User Name
|
|
TCHAR *GetCurrentUserName() { return m_CurrentUserName; }
|
|
// Returns the Current WinStation Name
|
|
PWINSTATIONNAME GetCurrentWinStationName() { return m_CurrentWinStationName; }
|
|
// Returns the Current Server Name
|
|
TCHAR *GetCurrentServerName() { return m_CurrentServerName; }
|
|
// Returns the Current Logon Id
|
|
ULONG GetCurrentLogonId() { return m_CurrentLogonId; }
|
|
// Returns the Current WinStation Flags
|
|
ULONG GetCurrentWSFlags() { return m_CurrentWSFlags; }
|
|
// Returns TRUE if the current user has Admin privileges?
|
|
BOOL IsUserAdmin() { return m_Admin; }
|
|
// Returns TRUE if we are running under Picasso
|
|
BOOL IsPicasso() { return m_Picasso; }
|
|
// Returns TRUE if we should show system processes
|
|
BOOL ShowSystemProcesses() { return m_ShowSystemProcesses; }
|
|
// Sets the show system processes variable
|
|
void SetShowSystemProcesses(BOOL show) { m_ShowSystemProcesses = show; }
|
|
// Returns TRUE if we should ask user for confirmation of Actions
|
|
BOOL AskConfirmation() { return m_Confirmation; }
|
|
// Sets the confirmation variable
|
|
void SetConfirmation(BOOL conf) { m_Confirmation = conf; }
|
|
// Returms TRUE if we should save the preferences upon exit
|
|
BOOL SavePreferences() { return m_SavePreferences; }
|
|
// Sets the save preferences variable
|
|
void SetSavePreferences(BOOL pref) { m_SavePreferences = pref; }
|
|
// Returns the Process List Refresh Time
|
|
UINT GetProcessListRefreshTime() { return m_ProcessListRefreshTime; }
|
|
// Sets the Process List Refresh Time
|
|
void SetProcessListRefreshTime(UINT pt) { m_ProcessListRefreshTime = pt; }
|
|
// Returns the Status Dialog Refresh Time
|
|
UINT GetStatusRefreshTime() { return m_StatusRefreshTime; }
|
|
// Sets the Status Dialog Refresh Time
|
|
void SetStatusRefreshTime(UINT st) { m_StatusRefreshTime = st; }
|
|
// Returns a pointer to the document
|
|
CDocument *GetDocument() { return m_Document; }
|
|
// Sets the m_Document variable
|
|
void SetDocument(CDocument *doc) { m_Document = doc; }
|
|
// Should we Show All Servers - based on menu item toggle
|
|
BOOL GetShowAllServers() { return m_ShowAllServers; }
|
|
// Set the Show All Servers variable
|
|
void SetShowAllServers(BOOL sa) { m_ShowAllServers = sa; }
|
|
// Returns the value of shadow hotkey key
|
|
int GetShadowHotkeyKey() { return m_ShadowHotkeyKey; }
|
|
// Sets the value of shadow hotkey key
|
|
void SetShadowHotkeyKey(int key) { m_ShadowHotkeyKey = key; }
|
|
// Returns the value of shadow hotkey shift state
|
|
DWORD GetShadowHotkeyShift() { return m_ShadowHotkeyShift; }
|
|
// Sets the value of shadow hotkey shift state
|
|
void SetShadowHotkeyShift(DWORD shift) { m_ShadowHotkeyShift = shift; }
|
|
// Get the tree width
|
|
int GetTreeWidth() { return m_TreeWidth; }
|
|
// Set the tree width
|
|
void SetTreeWidth(int width) { m_TreeWidth = width; }
|
|
// Get the window placement
|
|
WINDOWPLACEMENT *GetPlacement() { return &m_Placement; }
|
|
|
|
// Returns the address of the extension DLL's startup function
|
|
LPFNEXSTARTUPPROC GetExtStartupProc() { return m_lpfnWAExStart; }
|
|
// Returns the address of the extension DLL's shutdown function
|
|
LPFNEXSHUTDOWNPROC GetExtShutdownProc() { return m_lpfnWAExEnd; }
|
|
// Returns the address of the extension DLL's server enumeration function
|
|
LPFNEXENUMERATEPROC GetExtEnumerationProc() { return m_lpfnWAExServerEnumerate; }
|
|
// Returns the address of the extension DLL's WinStation Init function
|
|
LPFNEXWINSTATIONINITPROC GetExtWinStationInitProc() { return m_lpfnWAExWinStationInit; }
|
|
// Returns the address of the extension DLL's WinStation Info function
|
|
LPFNEXWINSTATIONINFOPROC GetExtWinStationInfoProc() { return m_lpfnWAExWinStationInfo; }
|
|
// Returns the address of the extension DLL's WinStation Cleanup function
|
|
LPFNEXWINSTATIONCLEANUPPROC GetExtWinStationCleanupProc() { return m_lpfnWAExWinStationCleanup; }
|
|
// Returns the address of the extension DLL's Server Init function
|
|
LPFNEXSERVERINITPROC GetExtServerInitProc() { return m_lpfnWAExServerInit; }
|
|
// Returns the address of the extension DLL's Server Cleanup function
|
|
LPFNEXSERVERCLEANUPPROC GetExtServerCleanupProc() { return m_lpfnWAExServerCleanup; }
|
|
// Returns the address of the extension DLL's Get Server Info function
|
|
LPFNEXGETSERVERINFOPROC GetExtGetServerInfoProc() { return m_lpfnWAExGetServerInfo; }
|
|
// Returns the address of the extension DLL's Get Server License Info function
|
|
LPFNEXGETSERVERLICENSESPROC GetExtGetServerLicensesProc() { return m_lpfnWAExGetServerLicenses; }
|
|
// Returns the address of the extension DLL's Server Event function
|
|
LPFNEXSERVEREVENTPROC GetExtServerEventProc() { return m_lpfnWAExServerEvent; }
|
|
// Returns the address of the extension DLL's Get Global Info function
|
|
LPFNEXGETGLOBALINFOPROC GetExtGetGlobalInfoProc() { return m_lpfnWAExGetGlobalInfo; }
|
|
// Returns the address of the extension DLL's Get WinStation Info Function
|
|
LPFNEXGETWINSTATIONINFOPROC GetExtGetWinStationInfoProc() { return m_lpfnWAExGetWinStationInfo; }
|
|
// Returns the address of the extension DLL's Get WinStation Module Info function
|
|
LPFNEXGETWINSTATIONMODULESPROC GetExtGetWinStationModulesProc() { return m_lpfnWAExGetWinStationModules; }
|
|
// Returns the address of the extension DLL's Free Server License Info function
|
|
LPFNEXFREESERVERLICENSESPROC GetExtFreeServerLicensesProc() { return m_lpfnWAExFreeServerLicenses; }
|
|
// Returns the address of the extension DLL's Free WinStation Modules function
|
|
LPFNEXFREEWINSTATIONMODULESPROC GetExtFreeWinStationModulesProc() { return m_lpfnWAExFreeWinStationModules; }
|
|
|
|
void BeginOutstandingThread() { ::InterlockedIncrement(&m_OutstandingThreads); }
|
|
void EndOutstandingThread() { ::InterlockedDecrement(&m_OutstandingThreads); }
|
|
|
|
// make this guy public for speed ?
|
|
TCHAR m_szSystemConsole[WINSTATIONNAME_LENGTH+1];
|
|
// make this guy public so the MainFrm can get at it
|
|
WINDOWPLACEMENT m_Placement;
|
|
|
|
private:
|
|
void ReadPreferences();
|
|
void WritePreferences();
|
|
BOOL IsBrowserRunning();
|
|
LONG m_OutstandingThreads; // the number of outstanding threads
|
|
TCHAR m_CurrentUserName[USERNAME_LENGTH+1];
|
|
WINSTATIONNAME m_CurrentWinStationName;
|
|
TCHAR m_CurrentServerName[MAX_COMPUTERNAME_LENGTH + 1];
|
|
ULONG m_CurrentLogonId;
|
|
ULONG m_CurrentWSFlags;
|
|
BOOL m_Admin; // does the user have Admin privileges?
|
|
BOOL m_Picasso; // are we running under Picasso?
|
|
UINT m_ShowSystemProcesses;
|
|
UINT m_ShowAllServers;
|
|
int m_ShadowHotkeyKey;
|
|
DWORD m_ShadowHotkeyShift;
|
|
int m_TreeWidth;
|
|
HINSTANCE m_hExtensionDLL; // handle to the extension DLL if loaded
|
|
|
|
// functions in the extension DLL
|
|
LPFNEXSTARTUPPROC m_lpfnWAExStart;
|
|
LPFNEXSHUTDOWNPROC m_lpfnWAExEnd;
|
|
LPFNEXENUMERATEPROC m_lpfnWAExServerEnumerate;
|
|
LPFNEXWINSTATIONINITPROC m_lpfnWAExWinStationInit;
|
|
LPFNEXWINSTATIONINFOPROC m_lpfnWAExWinStationInfo;
|
|
LPFNEXWINSTATIONCLEANUPPROC m_lpfnWAExWinStationCleanup;
|
|
LPFNEXSERVERINITPROC m_lpfnWAExServerInit;
|
|
LPFNEXSERVERCLEANUPPROC m_lpfnWAExServerCleanup;
|
|
LPFNEXGETSERVERINFOPROC m_lpfnWAExGetServerInfo;
|
|
LPFNEXGETSERVERLICENSESPROC m_lpfnWAExGetServerLicenses;
|
|
LPFNEXSERVEREVENTPROC m_lpfnWAExServerEvent;
|
|
LPFNEXGETGLOBALINFOPROC m_lpfnWAExGetGlobalInfo;
|
|
LPFNEXGETWINSTATIONINFOPROC m_lpfnWAExGetWinStationInfo;
|
|
LPFNEXGETWINSTATIONMODULESPROC m_lpfnWAExGetWinStationModules;
|
|
LPFNEXFREESERVERLICENSESPROC m_lpfnWAExFreeServerLicenses;
|
|
LPFNEXFREEWINSTATIONMODULESPROC m_lpfnWAExFreeWinStationModules;
|
|
|
|
// user preferences
|
|
UINT m_Confirmation; // ask user for confirmation
|
|
UINT m_SavePreferences; // save preferences upon exit
|
|
UINT m_ProcessListRefreshTime;
|
|
UINT m_StatusRefreshTime;
|
|
|
|
CDocument *m_Document;
|
|
|
|
// Overrides
|
|
// ClassWizard generated virtual function overrides
|
|
//{{AFX_VIRTUAL(CWinAdminApp)
|
|
public:
|
|
virtual BOOL InitInstance();
|
|
virtual int ExitInstance();
|
|
//}}AFX_VIRTUAL
|
|
|
|
// Implementation
|
|
|
|
//{{AFX_MSG(CWinAdminApp)
|
|
afx_msg void OnAppAbout();
|
|
// NOTE - the ClassWizard will add and remove member functions here.
|
|
// DO NOT EDIT what you see in these blocks of generated code !
|
|
//}}AFX_MSG
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
|
|
enum NODETYPE {
|
|
NODE_ALL_SERVERS,
|
|
NODE_DOMAIN,
|
|
NODE_SERVER,
|
|
NODE_WINSTATION,
|
|
NODE_PUBLISHED_APPS,
|
|
NODE_APPLICATION,
|
|
NODE_APP_SERVER,
|
|
|
|
NODE_FAV_LIST,
|
|
NODE_THIS_COMP,
|
|
NODE_NONE
|
|
};
|
|
|
|
class CNodeType : public CObject
|
|
{
|
|
public:
|
|
CNodeType( NODETYPE m )
|
|
{
|
|
m_nodetype = m;
|
|
}
|
|
|
|
~CNodeType()
|
|
{
|
|
ODS( L"CNodeType I'm going away\n" );
|
|
}
|
|
|
|
NODETYPE m_nodetype;
|
|
};
|
|
|
|
class CTreeNode : public CObject
|
|
{
|
|
public:
|
|
// constructor
|
|
CTreeNode(NODETYPE NodeType, CObject* pObject) { m_NodeType = NodeType; m_pTreeObject = pObject; }
|
|
// Returns the node type
|
|
NODETYPE GetNodeType() { return m_NodeType; }
|
|
// Returns the object pointed to by this node
|
|
CObject *GetTreeObject() { return m_pTreeObject; }
|
|
// Returns the sort order stored in the object
|
|
ULONG GetSortOrder() { return m_SortOrder; }
|
|
// Sets the sort order stored with the object
|
|
void SetSortOrder(ULONG order) { m_SortOrder = order; }
|
|
|
|
virtual ~CTreeNode( )
|
|
{
|
|
if( m_NodeType == NODE_FAV_LIST || m_NodeType == NODE_THIS_COMP )
|
|
{
|
|
if( m_pTreeObject != NULL )
|
|
{
|
|
delete m_pTreeObject;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private:
|
|
NODETYPE m_NodeType;
|
|
CObject* m_pTreeObject;
|
|
ULONG m_SortOrder;
|
|
};
|
|
|
|
// structure passed to the Server's BackgroundThreadProc
|
|
typedef struct _ServerProcInfo {
|
|
CDocument *pDoc;
|
|
CServer *pServer;
|
|
} ServerProcInfo;
|
|
|
|
// structure for storing User SID
|
|
class CUserSid : public CObject
|
|
{
|
|
public:
|
|
USHORT m_SidCrc;
|
|
TCHAR m_UserName[USERNAME_LENGTH+1];
|
|
};
|
|
|
|
// Information we get from the registry of the server
|
|
typedef struct _ServerRegistryInfo {
|
|
ULONG InstallDate;
|
|
TCHAR ServicePackLevel[128];
|
|
TCHAR MSVersion[128];
|
|
DWORD MSVersionNum;
|
|
TCHAR MSBuild[128];
|
|
TCHAR MSProductName[128];
|
|
TCHAR CTXProductName[128];
|
|
TCHAR CTXVersion[128];
|
|
DWORD CTXVersionNum;
|
|
TCHAR CTXBuild[128];
|
|
} ServerRegistryInfo;
|
|
|
|
|
|
class CHotfix : public CObject
|
|
{
|
|
public:
|
|
TCHAR m_Name[10];
|
|
TCHAR m_InstalledBy[USERNAME_LENGTH + 1];
|
|
ULONG m_InstalledOn;
|
|
ULONG m_Valid;
|
|
CServer *m_pServer;
|
|
};
|
|
|
|
typedef struct _EncLevel {
|
|
WORD StringID;
|
|
DWORD RegistryValue;
|
|
WORD Flags;
|
|
} EncryptionLevel;
|
|
|
|
typedef LONG (WINAPI *LPFNEXTENCRYPTIONLEVELSPROC) (WDNAME *pWdName, EncryptionLevel **);
|
|
|
|
class CWd : public CObject
|
|
{
|
|
public:
|
|
// constructor
|
|
CWd(PWDCONFIG2 pWdConfig, PWDNAME pRegistryName);
|
|
// destructor
|
|
~CWd();
|
|
|
|
BOOL GetEncryptionLevelString(DWORD Value, CString *pString);
|
|
TCHAR *GetName() { return m_WdName; }
|
|
TCHAR *GetRegistryName() { return m_RegistryName; }
|
|
|
|
private:
|
|
HINSTANCE m_hExtensionDLL;
|
|
WDNAME m_WdName;
|
|
WDNAME m_RegistryName;
|
|
LPFNEXTENCRYPTIONLEVELSPROC m_lpfnExtEncryptionLevels;
|
|
EncryptionLevel *m_pEncryptionLevels;
|
|
LONG m_NumEncryptionLevels;
|
|
};
|
|
|
|
// structure passed to a Domain's background thread process
|
|
typedef struct _DomainProcInfo {
|
|
LPVOID pDoc;
|
|
CDomain *pDomain;
|
|
} DomainProcInfo;
|
|
|
|
// Flags for CDomain objects
|
|
const ULONG DF_CURRENT_DOMAIN = 0x00000001;
|
|
|
|
// States of CDomain objects
|
|
enum DOMAIN_STATE {
|
|
DS_NONE, // seed value for m_State and m_PreviousState
|
|
DS_NOT_ENUMERATING, // not enumerating (m_pBackgroundThread == NULL)
|
|
DS_INITIAL_ENUMERATION, // enumerating servers for the first time
|
|
DS_ENUMERATING, // enumerating
|
|
DS_STOPPED_ENUMERATING, // no longer enumerating
|
|
};
|
|
|
|
class CDomain : public CObject
|
|
{
|
|
public:
|
|
// constructor
|
|
CDomain(TCHAR *name);
|
|
// destructor
|
|
~CDomain();
|
|
|
|
TCHAR *GetName() { return m_Name; }
|
|
|
|
// Returns the state of this domain object
|
|
DOMAIN_STATE GetState() { return m_State; }
|
|
// Sets the state of this domain object
|
|
void SetState(DOMAIN_STATE State);
|
|
// Returns the previous state of this domain object
|
|
DOMAIN_STATE GetPreviousState() { return m_PreviousState; }
|
|
// Returns TRUE if m_State is set to a given state
|
|
BOOLEAN IsState(DOMAIN_STATE State) { return (m_State == State); }
|
|
// Returns TRUE if m_PreviousState is set to a given state
|
|
BOOLEAN IsPreviousState(DOMAIN_STATE State) { return (m_PreviousState == State); }
|
|
|
|
// Returns the tree item handle
|
|
HTREEITEM GetTreeItem() { return m_hTreeItem; }
|
|
// Sets the tree item handle
|
|
void SetTreeItem(HTREEITEM handle) { m_hTreeItem = handle; }
|
|
|
|
BOOLEAN IsCurrentDomain() { return (m_Flags & DF_CURRENT_DOMAIN) > 0; }
|
|
void SetCurrentDomain() { m_Flags |= DF_CURRENT_DOMAIN; }
|
|
void ClearCurrentDomain() { m_Flags &= ~DF_CURRENT_DOMAIN; }
|
|
|
|
BOOL StartEnumerating();
|
|
void StopEnumerating();
|
|
void SetEnumEvent() { if(m_pBackgroundThread) m_WakeUpEvent.SetEvent(); }
|
|
|
|
void LockBackgroundThread() { m_ThreadCriticalSection.Lock(); }
|
|
void UnlockBackgroundThread() { m_ThreadCriticalSection.Unlock(); }
|
|
|
|
// returns TRUE as long as the background thread should keep running
|
|
BOOL ShouldBackgroundContinue() { return m_BackgroundContinue; }
|
|
|
|
void ClearBackgroundContinue() { m_BackgroundContinue = FALSE; }
|
|
|
|
// Returns the pointer to the domain's background thread
|
|
CWinThread *GetThreadPointer() { return m_pBackgroundThread; }
|
|
|
|
LPWSTR EnumHydraServers( /*LPWSTR pDomain,*/ DWORD verMajor, DWORD verMinor );
|
|
|
|
void CreateServers(LPWSTR pBuffer, LPVOID pDoc);
|
|
|
|
// Connect to all servers in this Domain
|
|
void ConnectAllServers();
|
|
|
|
// Disconnect from all servers in this Domain
|
|
void DisconnectAllServers();
|
|
|
|
private:
|
|
|
|
// the state of the domain object
|
|
DOMAIN_STATE m_State;
|
|
DOMAIN_STATE m_PreviousState;
|
|
// the name of the domain
|
|
TCHAR m_Name[50];
|
|
HTREEITEM m_hTreeItem;
|
|
|
|
// Background thread to update document when servers
|
|
// appear and disapper
|
|
// Called with AfxBeginThread
|
|
static UINT BackgroundThreadProc(LPVOID);
|
|
CWinThread *m_pBackgroundThread;
|
|
BOOL m_BackgroundContinue;
|
|
// Event to wakeup background thread so that
|
|
// he can exit (WaitForSingleEvent instead of Sleep)
|
|
CEvent m_WakeUpEvent;
|
|
// Critical section to protect accesses to m_pBackgroundThread
|
|
CCriticalSection m_ThreadCriticalSection;
|
|
|
|
ULONG m_Flags;
|
|
|
|
};
|
|
|
|
|
|
// Flags for CServer objects
|
|
const ULONG SF_BACKGROUND_FOUND = 0x00000001;
|
|
const ULONG SF_SERVER_INACTIVE = 0x00000002;
|
|
const ULONG SF_REGISTRY_INFO = 0x00000004;
|
|
const ULONG SF_HANDLE_GOOD = 0x00000008;
|
|
const ULONG SF_SELECTED = 0x00000010;
|
|
const ULONG SF_UNDEFINED_0040 = 0x00000020;
|
|
const ULONG SF_UNDEFINED_0080 = 0x00000040;
|
|
const ULONG SF_LOST_CONNECTION = 0x00000080;
|
|
const ULONG SF_FOUND_LATER = 0x00000100;
|
|
const ULONG SF_WINFRAME = 0x00000200;
|
|
const ULONG SF_CONNECTED = 0x00000400;
|
|
|
|
// How many times we will let a load level query timeout
|
|
// before we set it to N/A
|
|
const USHORT MAX_LL_TIMEOUTS = 10;
|
|
|
|
// States of CServer objects
|
|
enum SERVER_STATE {
|
|
SS_NONE, // seed value for m_State and m_PreviousState
|
|
SS_NOT_CONNECTED, // not connected yet or disconnected
|
|
SS_OPENED, // opened RPC connection
|
|
SS_GETTING_INFO, // getting information about the server
|
|
SS_GOOD, // server information is good
|
|
SS_DISCONNECTING, // in the process of disconnecting
|
|
SS_BAD // could not open the server
|
|
};
|
|
|
|
|
|
class CServer : public CObject
|
|
{
|
|
public:
|
|
|
|
// constructor
|
|
CServer(CDomain *pDomain, TCHAR *name, BOOL bFoundLater, BOOL bConnect); // FoundLater is TRUE if found as new server after initial server enum
|
|
// destructor
|
|
~CServer();
|
|
|
|
// Functions to check,set,and clear m_ServerFlags
|
|
BOOLEAN IsServerSane() { return (m_State != SS_BAD); }
|
|
|
|
BOOLEAN IsManualFind( ) { return m_fManualFind; }
|
|
void SetManualFind( ) { m_fManualFind = TRUE; }
|
|
void ClearManualFind( ) { m_fManualFind = FALSE; }
|
|
|
|
BOOLEAN IsBackgroundFound() { return (m_ServerFlags & SF_BACKGROUND_FOUND) > 0; }
|
|
void SetBackgroundFound() { m_ServerFlags |= SF_BACKGROUND_FOUND; }
|
|
void ClearBackgroundFound() { m_ServerFlags &= ~SF_BACKGROUND_FOUND; }
|
|
|
|
BOOLEAN IsServerInactive() { return (m_ServerFlags & SF_SERVER_INACTIVE) > 0; }
|
|
void SetServerInactive() { m_ServerFlags |= SF_SERVER_INACTIVE; m_BackgroundContinue = FALSE; }
|
|
void ClearServerInactive() { m_ServerFlags &= ~SF_SERVER_INACTIVE; }
|
|
BOOLEAN IsServerActive() { return (m_ServerFlags & SF_SERVER_INACTIVE) == 0; }
|
|
|
|
BOOLEAN IsRegistryInfoValid() { return (m_ServerFlags & SF_REGISTRY_INFO) > 0; }
|
|
void SetRegistryInfoValid() { m_ServerFlags |= SF_REGISTRY_INFO; }
|
|
void ClearRegistryInfoValid() { m_ServerFlags &= ~SF_REGISTRY_INFO; }
|
|
|
|
BOOLEAN IsHandleGood() { return (m_ServerFlags & SF_HANDLE_GOOD) > 0; }
|
|
void SetHandleGood() { m_ServerFlags |= SF_HANDLE_GOOD; }
|
|
void ClearHandleGood() { m_ServerFlags &= ~SF_HANDLE_GOOD; }
|
|
|
|
BOOLEAN IsSelected() { return (m_ServerFlags & SF_SELECTED) > 0; }
|
|
void SetSelected() { m_ServerFlags |= SF_SELECTED; }
|
|
void ClearSelected() { m_ServerFlags &= ~SF_SELECTED; }
|
|
|
|
BOOLEAN HasLostConnection() { return (m_ServerFlags & SF_LOST_CONNECTION) > 0; }
|
|
void SetLostConnection() { m_ServerFlags |= SF_LOST_CONNECTION; }
|
|
void ClearLostConnection() { m_ServerFlags &= ~SF_LOST_CONNECTION; }
|
|
|
|
BOOLEAN WasFoundLater() { return (m_ServerFlags & SF_FOUND_LATER) > 0; }
|
|
void SetFoundLater() { m_ServerFlags |= SF_FOUND_LATER; }
|
|
void ClearFoundLater() { m_ServerFlags &= ~SF_FOUND_LATER; }
|
|
|
|
BOOLEAN IsWinFrame() { return (m_ServerFlags & SF_WINFRAME) > 0; }
|
|
void SetWinFrame() { m_ServerFlags |= SF_WINFRAME; }
|
|
void ClearWinFrame() { m_ServerFlags &= ~SF_WINFRAME; }
|
|
|
|
// Returns the state of this server object
|
|
SERVER_STATE GetState() { return m_State; }
|
|
// Sets the state of this server object
|
|
void SetState(SERVER_STATE State);
|
|
// Returns the previous state of this server object
|
|
SERVER_STATE GetPreviousState() { return m_PreviousState; }
|
|
// Returns TRUE if m_State is set to a given state
|
|
BOOLEAN IsState(SERVER_STATE State) { return (m_State == State); }
|
|
// Returns TRUE if m_PreviousState is set to a given state
|
|
BOOLEAN IsPreviousState(SERVER_STATE State) { return (m_PreviousState == State); }
|
|
// Add a WinStation to WinStationList in sorted order
|
|
void AddWinStation(CWinStation *pWinStation);
|
|
// Returns a pointer to the WinStation linked list
|
|
CObList *GetWinStationList() { return &m_WinStationList; }
|
|
// Locks the WinStation linked list
|
|
void LockWinStationList() { m_WinStationListCriticalSection.Lock(); }
|
|
// Unlocks the WinStation linked list
|
|
void UnlockWinStationList() { m_WinStationListCriticalSection.Unlock(); }
|
|
|
|
void LockThreadAlive() { m_ThreadCriticalSection.Lock(); }
|
|
void UnlockThreadAlive() { m_ThreadCriticalSection.Unlock(); }
|
|
void SetThreadAlive() { LockThreadAlive(); m_bThreadAlive = TRUE; UnlockThreadAlive(); }
|
|
void ClearThreadAlive() { LockThreadAlive(); m_bThreadAlive = FALSE; UnlockThreadAlive(); }
|
|
|
|
// Returns a pointer to the Process linked list
|
|
CObList *GetProcessList() { return &m_ProcessList; }
|
|
// Locks the Process linked list
|
|
void LockProcessList() { m_ProcessListCriticalSection.Lock(); }
|
|
// Unlocks the Process linked list
|
|
void UnlockProcessList() { m_ProcessListCriticalSection.Unlock(); }
|
|
|
|
// Returns a pointer to the License linked list
|
|
CObList *GetLicenseList() { return &m_LicenseList; }
|
|
// Locks the License linked list
|
|
void LockLicenseList() { m_LicenseListCriticalSection.Lock(); }
|
|
// Unlocks the License linked list
|
|
void UnlockLicenseList() { m_LicenseListCriticalSection.Unlock(); }
|
|
|
|
// Returns a pointer to the User Sid linked list
|
|
CObList *GetUserSidList() { return &m_UserSidList; }
|
|
// Returns a pointer to the Hotfix linked list
|
|
CObList *GetHotfixList() { return &m_HotfixList; }
|
|
// Get the server's handle
|
|
HANDLE GetHandle() { return m_Handle; }
|
|
// Set the handle
|
|
void SetHandle(HANDLE hIn) { m_Handle = hIn; }
|
|
// Go get detailed information about the server
|
|
void DoDetail();
|
|
// Get this server's addresses from the browser
|
|
void QueryAddresses();
|
|
// Enumerate this server's processes
|
|
BOOL EnumerateProcesses();
|
|
// Clear out the list of processes
|
|
void ClearProcesses();
|
|
// Get the name of the server
|
|
TCHAR *GetName() { return m_Name; }
|
|
// Returns TRUE if this is the server that the app is being run from
|
|
BOOL IsCurrentServer() { return (lstrcmpi(m_Name, ((CWinAdminApp*)AfxGetApp())->GetCurrentServerName()) == 0); }
|
|
// Clears the WAF_SELECTED bit in all of this server's lists
|
|
void ClearAllSelected();
|
|
// returns TRUE as long as the background thread should keep running
|
|
BOOL ShouldBackgroundContinue() { return m_BackgroundContinue; }
|
|
// turns off the background continue boolean
|
|
void ClearBackgroundContinue() { m_BackgroundContinue = FALSE; }
|
|
// returns a pointer to a CWinStation from m_WinStationList
|
|
CWinStation *FindWinStationById(ULONG Id);
|
|
// returns a pointer to a CProcess from m_ProcessList given a PID
|
|
CProcess *FindProcessByPID(ULONG Pid);
|
|
// returns the number of connected WinStations
|
|
ULONG GetNumWinStations() { return m_NumWinStations; }
|
|
// Sets the number of connected WinStations
|
|
void SetNumWinStations(ULONG num) { m_NumWinStations = num; }
|
|
// Go out and fill in the registry info structure
|
|
BOOL BuildRegistryInfo();
|
|
// Returns the Install Date
|
|
ULONG GetInstallDate() { return m_pRegistryInfo->InstallDate; }
|
|
// Returns the Service Pack Level
|
|
TCHAR *GetServicePackLevel() { return m_pRegistryInfo->ServicePackLevel; }
|
|
// Returns the handle to this server's tree item
|
|
TCHAR *GetMSVersion() { return m_pRegistryInfo->MSVersion; }
|
|
// Returns the MS product version number (binary)
|
|
DWORD GetMSVersionNum() { return m_pRegistryInfo->MSVersionNum; }
|
|
// Returns the MS product build
|
|
TCHAR *GetMSBuild() { return m_pRegistryInfo->MSBuild; }
|
|
// Returns the MS product name
|
|
TCHAR *GetMSProductName() { return m_pRegistryInfo->MSProductName; }
|
|
// Returns the 'Citrix' product name
|
|
TCHAR *GetCTXProductName() { return m_pRegistryInfo->CTXProductName; }
|
|
// Returns the 'Citrix' product version
|
|
TCHAR *GetCTXVersion() { return m_pRegistryInfo->CTXVersion; }
|
|
// Returns the 'Citrix' product version number (binary)
|
|
DWORD GetCTXVersionNum() { return m_pRegistryInfo->CTXVersionNum; }
|
|
// Returns the 'Citrix' product build
|
|
TCHAR *GetCTXBuild() { return m_pRegistryInfo->CTXBuild; }
|
|
|
|
// Sets the pointer to the info from the extension DLL
|
|
void SetExtensionInfo(void *p) { m_pExtensionInfo = p; }
|
|
// Returns the pointer to the info from the extension DLL
|
|
void *GetExtensionInfo() { return m_pExtensionInfo; }
|
|
// Returns a pointer to the info from the extension DLL
|
|
ExtServerInfo *GetExtendedInfo() { return m_pExtServerInfo; }
|
|
|
|
// Manipulate the number selected counts
|
|
UINT GetNumWinStationsSelected() { return m_NumWinStationsSelected; }
|
|
UINT GetNumProcessesSelected() { return m_NumProcessesSelected; }
|
|
void IncrementNumWinStationsSelected() { m_NumWinStationsSelected++; }
|
|
void IncrementNumProcessesSelected() { m_NumProcessesSelected++; }
|
|
void DecrementNumWinStationsSelected() { if(m_NumWinStationsSelected) m_NumWinStationsSelected--; }
|
|
void DecrementNumProcessesSelected() { if(m_NumProcessesSelected) m_NumProcessesSelected--; }
|
|
|
|
void RemoveWinStationProcesses(CWinStation *pWinStation); // remove all the processes for a given WinStation
|
|
void QueryLicenses();
|
|
CDomain *GetDomain() { return m_pDomain; }
|
|
// Returns the pointer to the server's background thread
|
|
CWinThread *GetThreadPointer() { return m_pBackgroundThread; }
|
|
BOOL Connect();
|
|
void Disconnect();
|
|
|
|
// Returns the tree item handle
|
|
HTREEITEM GetTreeItem() { return m_hTreeItem; }
|
|
HTREEITEM GetTreeItemFromFav( ) { return m_hFavTree; }
|
|
HTREEITEM GetTreeItemFromThisComputer( ) { return m_hThisServer; }
|
|
|
|
// Sets the tree item handle
|
|
void SetTreeItem(HTREEITEM handle) { m_hTreeItem = handle; }
|
|
void SetTreeItemForFav( HTREEITEM handle ) { m_hFavTree = handle; }
|
|
void SetTreeItemForThisComputer( HTREEITEM handle ) { m_hThisServer = handle; }
|
|
|
|
|
|
private:
|
|
void AddLicense(CLicense *pNewLicense);
|
|
|
|
// the state of the server object
|
|
SERVER_STATE m_State;
|
|
SERVER_STATE m_PreviousState;
|
|
// the name of the server
|
|
TCHAR m_Name[50];
|
|
// Number of WinStations (store here for sorting)
|
|
ULONG m_NumWinStations;
|
|
// Handle to the tree item for this server in the tree view
|
|
HTREEITEM m_hThisServer;
|
|
HTREEITEM m_hTreeItem;
|
|
HTREEITEM m_hFavTree;
|
|
// Which domain this server is in
|
|
CDomain *m_pDomain;
|
|
|
|
// handle from WinStationOpenServer
|
|
HANDLE m_Handle;
|
|
|
|
CObList m_WinStationList;
|
|
CCriticalSection m_WinStationListCriticalSection;
|
|
|
|
CObList m_ProcessList;
|
|
CCriticalSection m_ProcessListCriticalSection;
|
|
|
|
CObList m_LicenseList;
|
|
CCriticalSection m_LicenseListCriticalSection;
|
|
|
|
CObList m_UserSidList;
|
|
CObList m_HotfixList;
|
|
|
|
// Pointer to registry info structure
|
|
ServerRegistryInfo *m_pRegistryInfo;
|
|
|
|
// Background thread to update document when WinStations
|
|
// appear, disappear, and change state
|
|
// Called with AfxBeginThread
|
|
static UINT BackgroundThreadProc(LPVOID);
|
|
CWinThread *m_pBackgroundThread;
|
|
BOOL m_BackgroundContinue;
|
|
// We need a critical section to wrap accesses to m_bThreadAlive
|
|
CCriticalSection m_ThreadCriticalSection;
|
|
BOOL m_bThreadAlive;
|
|
|
|
// Keep track of how many of each thing are selected
|
|
UINT m_NumWinStationsSelected;
|
|
UINT m_NumProcessesSelected;
|
|
|
|
ULONG m_ServerFlags;
|
|
|
|
BOOLEAN m_fManualFind;
|
|
|
|
// Pointer to information stored by the extension DLL
|
|
void *m_pExtensionInfo;
|
|
// Pointer to extended info from the extension DLL
|
|
ExtServerInfo *m_pExtServerInfo;
|
|
};
|
|
|
|
|
|
class CLicense : public CObject
|
|
{
|
|
public:
|
|
// constructor
|
|
CLicense(CServer *pServer, ExtLicenseInfo *pLicenseInfo);
|
|
// Return the serial number (what we sort on)
|
|
TCHAR *GetSerialNumber() { return m_RegSerialNumber; }
|
|
// Return the license number (what we display)
|
|
TCHAR *GetLicenseNumber() { return m_LicenseNumber; }
|
|
// Return the license class
|
|
LICENSECLASS GetClass() { return m_Class; }
|
|
// Return the description
|
|
TCHAR *GetDescription() { return m_Description; }
|
|
// Return the local count
|
|
ULONG GetLocalCount() { return ((m_PoolCount == 0xFFFFFFFF) ? m_LicenseCount : m_LicenseCount - m_PoolCount); }
|
|
// Return the pooled count
|
|
ULONG GetPoolCount() { return ((m_PoolCount == 0xFFFFFFFF) ? 0 : m_PoolCount); }
|
|
// Return the total count
|
|
ULONG GetTotalCount() { return m_LicenseCount; }
|
|
// Return TRUE if this license is registers
|
|
BOOLEAN IsRegistered() { return((m_Flags & ELF_REGISTERED) > 0); }
|
|
// Return TRUE if pooling is enabled
|
|
BOOLEAN IsPoolingEnabled() { return(m_PoolCount != 0xFFFFFFFF); }
|
|
// Returns a pointer to the server this license is for
|
|
CServer *GetServer() { return m_pServer; }
|
|
|
|
private:
|
|
LICENSECLASS m_Class;
|
|
ULONG m_LicenseCount;
|
|
ULONG m_PoolLicenseCount;
|
|
WCHAR m_RegSerialNumber[26];
|
|
WCHAR m_LicenseNumber[36];
|
|
WCHAR m_Description[65];
|
|
ULONG m_Flags;
|
|
ULONG m_PoolCount;
|
|
CServer *m_pServer;
|
|
};
|
|
|
|
|
|
typedef struct _MessageParms {
|
|
TCHAR MessageTitle[MSG_TITLE_LENGTH + 1];
|
|
TCHAR MessageBody[MSG_MESSAGE_LENGTH + 1];
|
|
CWinStation* pWinStation;
|
|
} MessageParms;
|
|
|
|
|
|
typedef struct _ResetParms {
|
|
CWinStation *pWinStation;
|
|
BOOL bReset; // TRUE if reset, FALSE if logoff
|
|
} ResetParms;
|
|
|
|
|
|
// Flags for CWinStation objects
|
|
const ULONG WF_SELECTED = 0x00000001;
|
|
const ULONG WF_CAN_BE_SHADOWED = 0x00000002;
|
|
const ULONG WF_DIRECT_ASYNC = 0x00000004;
|
|
const ULONG WF_CURRENT = 0x00000008;
|
|
const ULONG WF_HAS_USER = 0x00000010;
|
|
const ULONG WF_ADDITIONAL_DONE = 0x00000020;
|
|
const ULONG WF_QUERIES_SUCCESSFUL = 0x00000040;
|
|
const ULONG WF_CHANGED = 0x00000080; // Changed during last enumeration
|
|
const ULONG WF_NEW = 0x00000100; // New this enumeration
|
|
|
|
|
|
class CWinStation : public CObject
|
|
{
|
|
public:
|
|
// constructor
|
|
CWinStation(CServer *pServer, PLOGONID pLogonId);
|
|
// destructor
|
|
~CWinStation();
|
|
// Updates this WinStation with new data from another CWinStation
|
|
BOOL Update(CWinStation *pWinStation);
|
|
// Returns a pointer to this guy's server
|
|
CServer *GetServer() { return m_pServer; }
|
|
// Returns the logon Id
|
|
ULONG GetLogonId() { return m_LogonId; }
|
|
// Returns the name of the WinStation
|
|
PWINSTATIONNAME GetName() { return m_Name; }
|
|
// Sets the name
|
|
void SetName(PWINSTATIONNAME name) { wcscpy(m_Name, name); }
|
|
// Returns the state
|
|
WINSTATIONSTATECLASS GetState() { return m_State; }
|
|
// Sets the state
|
|
void SetState(WINSTATIONSTATECLASS state) { m_State = state; }
|
|
// Returns TRUE if m_State is set to a given state
|
|
BOOLEAN IsState(WINSTATIONSTATECLASS state) { return (m_State == state); }
|
|
// Returns the sort order
|
|
ULONG GetSortOrder() { return m_SortOrder; }
|
|
// Sets the sort order
|
|
void SetSortOrder(ULONG sort) { m_SortOrder = sort; }
|
|
// Returns the comment
|
|
TCHAR *GetComment() { return m_Comment; }
|
|
// Sets the comment
|
|
void SetComment(TCHAR *comment) { wcscpy(m_Comment, comment); }
|
|
// Returns the user name
|
|
TCHAR *GetUserName() { return m_UserName; }
|
|
// Sets the user name
|
|
void SetUserName(TCHAR *name) { wcscpy(m_UserName, name); }
|
|
// Returns the SdClass
|
|
SDCLASS GetSdClass() { return m_SdClass; }
|
|
// Sets the SdClass
|
|
void SetSdClass(SDCLASS pd) { m_SdClass = pd; }
|
|
// Returns the Logon Time
|
|
LARGE_INTEGER GetLogonTime() { return m_LogonTime; }
|
|
// Sets the Logon Time
|
|
void SetLogonTime(LARGE_INTEGER t) { m_LogonTime = t; }
|
|
// Returns the Last Input Time
|
|
LARGE_INTEGER GetLastInputTime() { return m_LastInputTime; }
|
|
// Sets the Last Input Time
|
|
void SetLastInputTime(LARGE_INTEGER t) { m_LastInputTime = t; }
|
|
// Returns the Current Time
|
|
LARGE_INTEGER GetCurrentTime() { return m_CurrentTime; }
|
|
// Set the Current Time
|
|
void SetCurrentTime(LARGE_INTEGER t) { m_CurrentTime = t; }
|
|
// Returns the IdleTime
|
|
ELAPSEDTIME GetIdleTime() { return m_IdleTime; }
|
|
// Sets the IdleTime variable
|
|
void SetIdleTime(ELAPSEDTIME it) { m_IdleTime = it; }
|
|
// Returns the WdName
|
|
PWDNAME GetWdName() { return m_WdName; }
|
|
// Sets the WdName
|
|
void SetWdName(PWDNAME wdname) { wcscpy(m_WdName, wdname); }
|
|
// Returns the Wd Structure
|
|
CWd *GetWd() { return m_pWd; }
|
|
// Sets the Wd Structure
|
|
void SetWd(CWd *pwd) { m_pWd = pwd; }
|
|
// Returns the PdName
|
|
PPDNAME GetPdName() { return m_PdName; }
|
|
// Returns the Client Name
|
|
TCHAR *GetClientName() { return m_ClientName; }
|
|
// Sets the Client Name
|
|
void SetClientName(TCHAR *name) { wcscpy(m_ClientName, name); }
|
|
//returns the client digital product id
|
|
TCHAR* GetClientDigProductId() { return m_clientDigProductId; }
|
|
//sets the client digital product id
|
|
void SetClientDigProductId( TCHAR* prodid) { wcscpy(m_clientDigProductId, prodid); }
|
|
// Returns the Client Build Number
|
|
ULONG GetClientBuildNumber() { return m_ClientBuildNumber; }
|
|
// Returns the Client Directory
|
|
TCHAR *GetClientDir() { return m_ClientDir; }
|
|
// Returns the Modem Name
|
|
TCHAR *GetModemName() { return m_ModemName; }
|
|
// Returns the Client License
|
|
TCHAR *GetClientLicense() { return m_ClientLicense; }
|
|
// Returns the Client Product Id
|
|
USHORT GetClientProductId() { return m_ClientProductId; }
|
|
// Returns the Client Serial Number
|
|
ULONG GetClientSerialNumber() { return m_ClientSerialNumber; }
|
|
// Returns the Client Address
|
|
TCHAR *GetClientAddress() { return m_ClientAddress; }
|
|
// Returns the number of host buffers
|
|
USHORT GetHostBuffers() { return m_HostBuffers; }
|
|
// Returns the number of client buffers
|
|
USHORT GetClientBuffers() { return m_ClientBuffers; }
|
|
// Returns the buffer length
|
|
USHORT GetBufferLength() { return m_BufferLength; }
|
|
// Gets additional information about the WinStation
|
|
void QueryAdditionalInformation();
|
|
// Shadow this WinStation
|
|
void Shadow();
|
|
// connect to this WinStation
|
|
void Connect(BOOL bUser);
|
|
// show status dialog
|
|
void ShowStatus();
|
|
// Are there outstanding threads?
|
|
BOOL HasOutstandingThreads() { return(m_OutstandingThreads > 0); }
|
|
// Is this WinStation down?
|
|
BOOL IsDown() { return(m_State == State_Down || m_State == State_Init); }
|
|
// Is this WinStation connected?
|
|
BOOL IsConnected() { return(m_State == State_Connected || m_State == State_Active); }
|
|
// Is this WinStation disconnected?
|
|
BOOL IsDisconnected() { return(m_State == State_Disconnected); }
|
|
// Is this WinStation active?
|
|
BOOL IsActive() { return(m_State == State_Active); }
|
|
// Is this WinStation idle?
|
|
BOOL IsIdle() { return(m_State == State_Idle); }
|
|
// Is this WinStation a listener?
|
|
BOOL IsListener() { return(m_State == State_Listen); }
|
|
// Is this the system console
|
|
BOOL IsSystemConsole() { return(0 == lstrcmpi(m_Name, ((CWinAdminApp*)AfxGetApp())->m_szSystemConsole)); }
|
|
// Returns TRUE if this WinStation is on the current server
|
|
BOOL IsOnCurrentServer() { return m_pServer->IsCurrentServer(); }
|
|
// Returns TRUE if the current user is logged in on this WinStation
|
|
BOOL IsCurrentUser() { return(m_pServer->IsCurrentServer() && m_LogonId == ((CWinAdminApp*)AfxGetApp())->GetCurrentLogonId()); }
|
|
//BOOL IsCurrentUser() { return(m_pServer->IsCurrentServer() && (lstrcmpi(m_UserName, ((CWinAdminApp*)AfxGetApp())->GetCurrentUserName()) == 0)); }
|
|
// Returns TRUE if this is the current WinStation
|
|
BOOL IsCurrentWinStation() { return(m_pServer->IsCurrentServer() && m_LogonId == ((CWinAdminApp*)AfxGetApp())->GetCurrentLogonId()); }
|
|
// Returns the handle to this WinStations's tree item
|
|
HTREEITEM GetTreeItem() { return m_hTreeItem; }
|
|
HTREEITEM GetTreeItemFromFav( ) { return m_hFavTree; }
|
|
HTREEITEM GetTreeItemFromThisComputer( ) { return m_hTreeThisComputer; }
|
|
// Sets the tree item handle
|
|
void SetTreeItem(HTREEITEM handle) { m_hTreeItem = handle; }
|
|
void SetTreeItemForFav( HTREEITEM handle ) { m_hFavTree = handle; }
|
|
void SetTreeItemForThisComputer( HTREEITEM handle ) { m_hTreeThisComputer = handle; }
|
|
// Returns the number of colors
|
|
TCHAR *GetColors() { return m_Colors; }
|
|
// Returns the vertical resolution
|
|
USHORT GetVRes() { return m_VRes; }
|
|
// Returns the horizontal resolution
|
|
USHORT GetHRes() { return m_HRes; }
|
|
// Returns the protocol
|
|
USHORT GetProtocolType() { return m_ProtocolType; }
|
|
// Returns the encryption level
|
|
BYTE GetEncryptionLevel() { return m_EncryptionLevel; }
|
|
// Sets the encryption level
|
|
void SetEncryptionLevel(BYTE level) { m_EncryptionLevel = level; }
|
|
|
|
// Fills in the CString with the description of the Encryption level
|
|
BOOL GetEncryptionLevelString(CString *pString) {
|
|
if(m_pWd) {
|
|
return m_pWd->GetEncryptionLevelString(m_EncryptionLevel, pString);
|
|
}
|
|
else return FALSE;
|
|
}
|
|
// Returns the name of the Wd in the registry
|
|
TCHAR *GetWdRegistryName() { return (m_pWd) ? m_pWd->GetRegistryName() : NULL; }
|
|
|
|
// Returns the time of the last update to this WinStation's data
|
|
clock_t GetLastUpdateClock() { return m_LastUpdateClock; }
|
|
void SetLastUpdateClock() { m_LastUpdateClock = clock(); }
|
|
|
|
// Is this an ICA WinStation?
|
|
BOOL IsICA() { return(m_ProtocolType == PROTOCOL_ICA); }
|
|
|
|
// Can this WinStation be shadowed
|
|
BOOL CanBeShadowed() { return((m_WinStationFlags & WF_CAN_BE_SHADOWED) > 0); }
|
|
void SetCanBeShadowed() { m_WinStationFlags |= WF_CAN_BE_SHADOWED; }
|
|
void ClearCanBeShadowed() { m_WinStationFlags &= ~WF_CAN_BE_SHADOWED; }
|
|
|
|
BOOLEAN IsDirectAsync() { return (m_WinStationFlags & WF_DIRECT_ASYNC) > 0; }
|
|
void SetDirectAsync() { m_WinStationFlags |= WF_DIRECT_ASYNC; }
|
|
void ClearDirectAsync() { m_WinStationFlags &= ~WF_DIRECT_ASYNC; }
|
|
|
|
BOOLEAN IsCurrent() { return (m_WinStationFlags & WF_CURRENT) > 0; }
|
|
void SetCurrent() { m_WinStationFlags |= WF_CURRENT; }
|
|
void ClearCurrent() { m_WinStationFlags &= ~WF_CURRENT; }
|
|
|
|
BOOLEAN IsChanged() { return (m_WinStationFlags & WF_CHANGED) > 0; }
|
|
void SetChanged() { m_WinStationFlags |= WF_CHANGED; }
|
|
void ClearChanged() { m_WinStationFlags &= ~WF_CHANGED; }
|
|
|
|
BOOLEAN IsNew() { return (m_WinStationFlags & WF_NEW) > 0; }
|
|
void SetNew() { m_WinStationFlags |= WF_NEW; }
|
|
void ClearNew() { m_WinStationFlags &= ~WF_NEW; }
|
|
|
|
BOOLEAN IsSelected() { return (m_WinStationFlags & WF_SELECTED) > 0; }
|
|
void SetSelected()
|
|
{
|
|
if (!IsSelected())
|
|
{
|
|
m_WinStationFlags |= WF_SELECTED;
|
|
m_pServer->IncrementNumWinStationsSelected();
|
|
}
|
|
}
|
|
|
|
void ClearSelected()
|
|
{
|
|
if (IsSelected())
|
|
{
|
|
m_WinStationFlags &= ~WF_SELECTED;
|
|
m_pServer->DecrementNumWinStationsSelected();
|
|
}
|
|
}
|
|
|
|
BOOLEAN HasUser() { return (m_WinStationFlags & WF_HAS_USER) > 0; }
|
|
void SetHasUser() { m_WinStationFlags |= WF_HAS_USER; }
|
|
void ClearHasUser() { m_WinStationFlags &= ~WF_HAS_USER; }
|
|
|
|
BOOLEAN AdditionalDone() { return (m_WinStationFlags & WF_ADDITIONAL_DONE) > 0; }
|
|
void SetAdditionalDone() { m_WinStationFlags |= WF_ADDITIONAL_DONE; }
|
|
void ClearAdditionalDone() { m_WinStationFlags &= ~WF_ADDITIONAL_DONE; }
|
|
|
|
BOOL QueriesSuccessful() { return (m_WinStationFlags & WF_QUERIES_SUCCESSFUL) > 0; }
|
|
void SetQueriesSuccessful() { m_WinStationFlags |= WF_QUERIES_SUCCESSFUL; }
|
|
void ClearQueriesSuccessful() { m_WinStationFlags &= ~WF_QUERIES_SUCCESSFUL; }
|
|
|
|
// Sets the pointer to the info from the extension DLL
|
|
void SetExtensionInfo(void *p) { m_pExtensionInfo = p; }
|
|
// Returns the pointer to the info from the extension DLL
|
|
void *GetExtensionInfo() { return m_pExtensionInfo; }
|
|
// Sets the pointer to the info from the extension DLL
|
|
void SetExtendedInfo(ExtWinStationInfo *p) { m_pExtWinStationInfo = p; }
|
|
// Returns a pointer to the info from the extension DLL
|
|
ExtWinStationInfo *GetExtendedInfo() { return m_pExtWinStationInfo; }
|
|
// Returns a pointer to the module info from the extension DLL
|
|
ExtModuleInfo *GetExtModuleInfo() { return m_pExtModuleInfo; }
|
|
// Sets the pointer to the module info from the extension DLL
|
|
void SetExtModuleInfo(ExtModuleInfo *m) { m_pExtModuleInfo = m; }
|
|
// Returns the number of modules
|
|
ULONG GetNumModules() { return m_NumModules; }
|
|
|
|
void BeginOutstandingThread() {
|
|
::InterlockedIncrement(&m_OutstandingThreads);
|
|
//((CWinAdminApp*)AfxGetApp())->BeginOutStandingThread());
|
|
}
|
|
|
|
void EndOutstandingThread() {
|
|
::InterlockedDecrement(&m_OutstandingThreads);
|
|
//((CWinAdminApp*)AfxGetApp())->EndOutStandingThread());
|
|
}
|
|
|
|
// static member function to send a message to a WinStation
|
|
// Called with AfxBeginThread
|
|
static UINT SendMessage(LPVOID);
|
|
// static member function to disconnect a WinStation
|
|
// Called with AfxBeginThread
|
|
static UINT Disconnect(LPVOID);
|
|
// static member function to reset a WinStation
|
|
// Called with AfxBeginThread
|
|
static UINT Reset(LPVOID);
|
|
|
|
private:
|
|
CServer* m_pServer;
|
|
CWd* m_pWd;
|
|
ULONG m_LogonId;
|
|
WINSTATIONNAME m_Name;
|
|
WINSTATIONSTATECLASS m_State;
|
|
ULONG m_SortOrder;
|
|
TCHAR m_Comment[WINSTATIONCOMMENT_LENGTH + 1];
|
|
TCHAR m_UserName[USERNAME_LENGTH + 1];
|
|
SDCLASS m_SdClass;
|
|
LARGE_INTEGER m_LogonTime;
|
|
LARGE_INTEGER m_LastInputTime;
|
|
LARGE_INTEGER m_CurrentTime;
|
|
ELAPSEDTIME m_IdleTime;
|
|
WDNAME m_WdName;
|
|
PDNAME m_PdName;
|
|
TCHAR m_ClientName[CLIENTNAME_LENGTH + 1];
|
|
ULONG m_ClientBuildNumber;
|
|
TCHAR m_ClientDir[256];
|
|
TCHAR m_ModemName[256];
|
|
TCHAR m_ClientLicense[30];
|
|
USHORT m_ClientProductId;
|
|
ULONG m_ClientSerialNumber;
|
|
TCHAR m_ClientAddress[30];
|
|
USHORT m_HostBuffers;
|
|
USHORT m_ClientBuffers;
|
|
USHORT m_BufferLength;
|
|
LONG m_OutstandingThreads; // the number of outstanding threads
|
|
|
|
HTREEITEM m_hTreeItem; // tree item for this WinStation in the servers tree view
|
|
HTREEITEM m_hFavTree;
|
|
HTREEITEM m_hTreeThisComputer;
|
|
USHORT m_VRes; // Vertical resolution
|
|
USHORT m_HRes; // Horizontal resolution
|
|
TCHAR m_Colors[4]; // Number of colors (as an ASCII string)
|
|
clock_t m_LastUpdateClock; // Tick count when we last update this WinStation's info
|
|
USHORT m_ProtocolType; // Protocol - PROTOCOL_ICA or PROTOCOL_RDP
|
|
BYTE m_EncryptionLevel; // security level of encryption pd
|
|
|
|
ULONG m_WinStationFlags;
|
|
|
|
// Pointer to information stored by the extension DLL
|
|
void *m_pExtensionInfo;
|
|
ExtWinStationInfo *m_pExtWinStationInfo;
|
|
ExtModuleInfo *m_pExtModuleInfo;
|
|
ULONG m_NumModules;
|
|
TCHAR m_clientDigProductId[CLIENT_PRODUCT_ID_LENGTH];
|
|
};
|
|
|
|
// Process flags
|
|
const ULONG PF_SYSTEM = 0x00000001;
|
|
const ULONG PF_SELECTED = 0x00000002;
|
|
const ULONG PF_TERMINATING = 0x00000004; // Currently trying to terminate it
|
|
const ULONG PF_CHANGED = 0x00000008; // Changed during last enumeration
|
|
const ULONG PF_CURRENT = 0x00000010; // Still active during last enumeration
|
|
const ULONG PF_NEW = 0x00000020; // New this enumeration
|
|
|
|
class CProcess : public CObject
|
|
{
|
|
public:
|
|
// Constructor
|
|
CProcess(ULONG PID,
|
|
ULONG LogonId,
|
|
CServer *pServer,
|
|
PSID pSID,
|
|
CWinStation *pWinStation,
|
|
TCHAR *ImageName);
|
|
|
|
// Updates a process with new information from another process
|
|
BOOL Update(CProcess *pProcess);
|
|
// Returns a pointer to the server that this Process if running on
|
|
CServer *GetServer() { return m_pServer; }
|
|
// Sets the Server
|
|
void SetServer(CServer *pServer) { m_pServer = pServer; }
|
|
// Returns a pointer to the WinStation that owns this process
|
|
CWinStation *GetWinStation() { return m_pWinStation; }
|
|
// Sets the Winstation
|
|
void SetWinStation(CWinStation *pWinStation) { m_pWinStation = pWinStation; }
|
|
// Returns the PID of this process
|
|
ULONG GetPID() { return m_PID; }
|
|
|
|
// Returns the LogonId for this process
|
|
ULONG GetLogonId() { return m_LogonId; }
|
|
// Returns a pointer to the image name
|
|
TCHAR *GetImageName() { return m_ImageName; }
|
|
// Returns a pointer to the user name
|
|
TCHAR *GetUserName() { return m_UserName; }
|
|
// Returns TRUE if this process belongs to the current user
|
|
// BOOL IsCurrentUsers() { return (m_pServer->IsCurrentServer()
|
|
// && wcscmp(m_UserName, ((CWinAdminApp*)AfxGetApp())->GetCurrentUserName())==0); }
|
|
|
|
BOOL IsCurrentUsers() { return(m_pServer->IsCurrentServer() && m_LogonId == ((CWinAdminApp*)AfxGetApp())->GetCurrentLogonId()); }
|
|
|
|
|
|
BOOLEAN IsSystemProcess() { return (m_Flags & PF_SYSTEM) > 0; }
|
|
void SetSystemProcess() { m_Flags |= PF_SYSTEM; }
|
|
void ClearSystemProcess() { m_Flags &= ~PF_SYSTEM; }
|
|
|
|
BOOLEAN IsSelected() { return (m_Flags & PF_SELECTED) > 0; }
|
|
void SetSelected() { m_Flags |= PF_SELECTED; m_pServer->IncrementNumProcessesSelected(); }
|
|
void ClearSelected() { m_Flags &= ~PF_SELECTED; m_pServer->DecrementNumProcessesSelected(); }
|
|
|
|
BOOLEAN IsTerminating() { return (m_Flags & PF_TERMINATING) > 0; }
|
|
void SetTerminating() { m_Flags |= PF_TERMINATING; }
|
|
void ClearTerminating() { m_Flags &= ~PF_TERMINATING; }
|
|
|
|
BOOLEAN IsCurrent() { return (m_Flags & PF_CURRENT) > 0; }
|
|
void SetCurrent() { m_Flags |= PF_CURRENT; }
|
|
void ClearCurrent() { m_Flags &= ~PF_CURRENT; }
|
|
|
|
BOOLEAN IsChanged() { return (m_Flags & PF_CHANGED) > 0; }
|
|
void SetChanged() { m_Flags |= PF_CHANGED; }
|
|
void ClearChanged() { m_Flags &= ~PF_CHANGED; }
|
|
|
|
BOOLEAN IsNew() { return (m_Flags & PF_NEW) > 0; }
|
|
void SetNew() { m_Flags |= PF_NEW; }
|
|
void ClearNew() { m_Flags &= ~PF_NEW; }
|
|
|
|
private:
|
|
// Determine whether or not this is a system process
|
|
BOOL QuerySystemProcess();
|
|
// Determine which user owns a process
|
|
void DetermineProcessUser(PSID pSid);
|
|
|
|
ULONG m_PID;
|
|
ULONG m_LogonId;
|
|
USHORT m_SidCrc;
|
|
TCHAR m_ImageName[20];//[MAX_PROCESSNAME+1];
|
|
TCHAR m_UserName[USERNAME_LENGTH+1];
|
|
CServer *m_pServer;
|
|
CWinStation *m_pWinStation;
|
|
ULONG m_Flags;
|
|
};
|
|
|
|
class CAdminView : public CView
|
|
{
|
|
public:
|
|
virtual void Reset(void *) { }
|
|
virtual LRESULT OnTabbed( WPARAM , LPARAM ){ return 0;}
|
|
};
|
|
|
|
//=------------------------------------------------
|
|
class CMyTabCtrl : public CTabCtrl
|
|
{
|
|
public:
|
|
CMyTabCtrl()
|
|
{
|
|
|
|
}
|
|
protected:
|
|
afx_msg void OnSetFocus( CWnd* );
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
//=------------------------------------------------
|
|
|
|
class CAdminPage : public CFormView
|
|
{
|
|
friend class CServerView;
|
|
friend class CWinStationView;
|
|
friend class CAllServersView;
|
|
friend class CDomainView;
|
|
|
|
public:
|
|
CAdminPage(UINT nIDTemplate);
|
|
CAdminPage();
|
|
DECLARE_DYNCREATE(CAdminPage)
|
|
|
|
virtual void Reset(void *) { }
|
|
virtual void ClearSelections() { }
|
|
};
|
|
|
|
|
|
typedef struct _columndefs {
|
|
UINT stringID;
|
|
int format;
|
|
int width;
|
|
} ColumnDef;
|
|
|
|
// Commonly used column definitions
|
|
#define CD_SERVER { IDS_COL_SERVER, LVCFMT_LEFT, 115 }
|
|
#define CD_USER { IDS_COL_USER, LVCFMT_LEFT, 100 }
|
|
#define CD_USER2 { IDS_COL_USER, LVCFMT_LEFT, 80 }
|
|
#define CD_USER3 { IDS_COL_USER, LVCFMT_LEFT, 90 }
|
|
#define CD_SESSION { IDS_COL_WINSTATION, LVCFMT_LEFT, 80 }
|
|
#define CD_SESSION2 { IDS_COL_WINSTATION, LVCFMT_LEFT, 100 }
|
|
#define CD_ID { IDS_COL_ID, LVCFMT_RIGHT, 30 }
|
|
#define CD_STATE { IDS_COL_STATE, LVCFMT_LEFT, 50 }
|
|
#define CD_TYPE { IDS_COL_TYPE, LVCFMT_LEFT, 80 }
|
|
#define CD_CLIENT_NAME { IDS_COL_CLIENT_NAME, LVCFMT_LEFT, 80 }
|
|
#define CD_IDLETIME { IDS_COL_IDLETIME, LVCFMT_RIGHT, 80 }
|
|
#define CD_LOGONTIME { IDS_COL_LOGONTIME, LVCFMT_LEFT, 90 }
|
|
#define CD_COMMENT { IDS_COL_COMMENT, LVCFMT_LEFT, 200 }
|
|
// Server Columns
|
|
#define CD_TCPADDRESS { IDS_COL_TCPADDRESS, LVCFMT_LEFT, 90 }
|
|
#define CD_IPXADDRESS { IDS_COL_IPXADDRESS, LVCFMT_LEFT, 110 }
|
|
#define CD_NUM_SESSIONS { IDS_COL_NUM_WINSTATIONS, LVCFMT_RIGHT, 70 }
|
|
// License Columns
|
|
#define CD_LICENSE_DESC { IDS_COL_LICENSE_DESC, LVCFMT_LEFT, 200 }
|
|
#define CD_LICENSE_REG { IDS_COL_LICENSE_REGISTERED, LVCFMT_CENTER, 80 }
|
|
#define CD_USERCOUNT { IDS_COL_USERCOUNT, LVCFMT_RIGHT, 80 }
|
|
#define CD_POOLCOUNT { IDS_COL_POOLCOUNT, LVCFMT_RIGHT, 80 }
|
|
#define CD_LICENSE_NUM { IDS_COL_LICENSE_NUMBER, LVCFMT_LEFT, 240 }
|
|
// Process Columns
|
|
#define CD_PROC_ID { IDS_COL_ID, LVCFMT_RIGHT, 30 }
|
|
#define CD_PROC_PID { IDS_COL_PID, LVCFMT_RIGHT, 50 }
|
|
#define CD_PROC_IMAGE { IDS_COL_IMAGE, LVCFMT_LEFT, 100 }
|
|
// Hotfix Columns
|
|
#define CD_HOTFIX { IDS_COL_HOTFIX, LVCFMT_LEFT, 90 }
|
|
#define CD_INSTALLED_BY { IDS_COL_INSTALLED_BY, LVCFMT_LEFT, 90 }
|
|
#define CD_INSTALLED_ON { IDS_COL_INSTALLED_ON, LVCFMT_LEFT, 150 }
|
|
|
|
|
|
// Definitions of PageDef flags
|
|
const UINT PF_PICASSO_ONLY = 0x0001;
|
|
const UINT PF_NO_TAB = 0x0002;
|
|
|
|
typedef struct _pagedef {
|
|
CAdminPage *m_pPage;
|
|
CRuntimeClass *m_pRuntimeClass;
|
|
UINT tabStringID;
|
|
int page;
|
|
UINT flags;
|
|
} PageDef;
|
|
//defines for help
|
|
|
|
//=================================================================================
|
|
|
|
#define ID_HELP_FILE L"tsadmin.hlp"
|
|
|
|
//==================================================================================
|
|
#define HIDC_MESSAGE_TITLE 0x500FB
|
|
#define HIDC_SHADOWSTART_HOTKEY 0x500F1
|
|
#define HIDC_SHADOWSTART_SHIFT 0x500F2
|
|
#define HIDC_SHADOWSTART_CTRL 0x500F3
|
|
#define HIDC_SHADOWSTART_ALT 0x500F4
|
|
#define HIDC_MESSAGE_TITLE 0x500FB
|
|
#define HIDC_MESSAGE_MESSAGE 0x500FC
|
|
#define HIDC_COMMON_USERNAME 0x5012C
|
|
#define HIDC_COMMON_WINSTATIONNAME 0x5012D
|
|
#define HIDC_COMMON_IBYTES 0x5012E
|
|
#define HIDC_COMMON_OBYTES 0x5012F
|
|
#define HIDC_COMMON_IFRAMES 0x50130
|
|
#define HIDC_COMMON_OFRAMES 0x50131
|
|
#define HIDC_COMMON_IBYTESPERFRAME 0x50132
|
|
#define HIDC_COMMON_OBYTESPERFRAME 0x50133
|
|
#define HIDC_COMMON_IFRAMEERRORS 0x50134
|
|
#define HIDC_COMMON_OFRAMEERRORS 0x50135
|
|
#define HIDC_COMMON_IPERCENTFRAMEERRORS 0x50136
|
|
#define HIDC_COMMON_OPERCENTFRAMEERRORS 0x50137
|
|
#define HIDC_COMMON_ITIMEOUTERRORS 0x50138
|
|
#define HIDC_COMMON_OTIMEOUTERRORS 0x50139
|
|
#define HIDC_COMMON_ICOMPRESSIONRATIO 0x5013A
|
|
#define HIDC_COMMON_OCOMPRESSIONRATIO 0x5013B
|
|
#define HIDC_REFRESHNOW 0x50140
|
|
#define HIDC_RESETCOUNTERS 0x50141
|
|
#define HIDC_MOREINFO 0x50142
|
|
#define HIDC_ASYNC_DEVICE 0x5015F
|
|
#define HIDC_ASYNC_BAUD 0x50160
|
|
#define HIDC_ASYNC_DTR 0x50161
|
|
#define HIDC_ASYNC_RTS 0x50162
|
|
#define HIDC_ASYNC_CTS 0x50163
|
|
#define HIDC_ASYNC_DSR 0x50164
|
|
#define HIDC_ASYNC_DCD 0x50165
|
|
#define HIDC_ASYNC_RI 0x50166
|
|
#define HIDC_ASYNC_IFRAMING 0x50167
|
|
#define HIDC_ASYNC_IOVERRUN 0x50168
|
|
#define HIDC_ASYNC_IOVERFLOW 0x50169
|
|
#define HIDC_ASYNC_IPARITY 0x5016A
|
|
#define HIDC_ASYNC_OFRAMING 0x5016B
|
|
#define HIDC_ASYNC_OOVERRUN 0x5016C
|
|
#define HIDC_ASYNC_OOVERFLOW 0x5016D
|
|
#define HIDC_ASYNC_OPARITY 0x5016E
|
|
#define HIDC_NETWORK_LANADAPTER 0x50173
|
|
#define HIDC_PREFERENCES_PROC_MANUAL 0x503EF
|
|
#define HIDC_PREFERENCES_PROC_EVERY 0x503F0
|
|
#define HIDC_PREFERENCES_PROC_SECONDS 0x503F1
|
|
#define HIDC_PREFERENCES_STATUS_MANUAL 0x503F3
|
|
#define HIDC_PREFERENCES_STATUS_EVERY 0x503F4
|
|
#define HIDC_PREFERENCES_STATUS_SECONDS 0x503F5
|
|
#define HIDC_PREFERENCES_CONFIRM 0x503F7
|
|
#define HIDC_PREFERENCES_SAVE 0x503F8
|
|
#define HIDC_PREFERENCES_REMEMBER 0X50443
|
|
|
|
#define HIDD_SERVER_WINSTATIONS 0x20084
|
|
#define HIDD_SERVER_PROCESSES 0x20085
|
|
#define HIDD_SERVER_USERS 0x20086
|
|
#define HIDD_SERVER_LICENSES 0x20087
|
|
#define HIDD_WINSTATION_INFO 0x20099
|
|
#define HIDD_WINSTATION_PROCESSES 0x2009A
|
|
#define HIDD_PREFERENCES 0x2009C
|
|
#define HIDD_SERVER_INFO 0x2009D
|
|
#define HIDD_MESSAGE 0x200FA
|
|
#define HIDD_ASYNC_STATUS 0x2015E
|
|
#define HIDD_NETWORK_STATUS 0x20172
|
|
#define HIDD_CONNECT_PASSWORD 0x201B8
|
|
#define HIDD_ALL_SERVER_PROCESSES 0x201BA
|
|
#define HIDD_ALL_SERVER_USERS 0x201BB
|
|
#define HIDD_ALL_SERVER_SESSIONS 0x201BC
|
|
#define HIDD_BAD_SERVER 0x201BE
|
|
#define HIDD_LISTENER 0x201BF
|
|
#define HIDD_WINSTATION_NOINFO 0x201C0
|
|
#define HIDD_BUSY_SERVER 0x201C1
|
|
#define HIDD_WINSTATION_CACHE 0x201C2
|
|
#define HIDD_BAD_WINSTATION 0x201C3
|
|
|
|
//==========================================================================================
|
|
|
|
|
|
|
|
|
|
//Global variable for help
|
|
|
|
static const DWORD aMenuHelpIDs[] =
|
|
{
|
|
IDC_MESSAGE_TITLE, HIDC_MESSAGE_TITLE,
|
|
IDC_MESSAGE_MESSAGE,HIDC_MESSAGE_MESSAGE,
|
|
IDC_SHADOWSTART_HOTKEY,HIDC_SHADOWSTART_HOTKEY,
|
|
IDC_SHADOWSTART_SHIFT ,HIDC_SHADOWSTART_SHIFT,
|
|
IDC_SHADOWSTART_CTRL ,HIDC_SHADOWSTART_CTRL,
|
|
IDC_SHADOWSTART_ALT ,HIDC_SHADOWSTART_ALT,
|
|
IDC_COMMON_USERNAME ,HIDC_COMMON_USERNAME,
|
|
IDC_COMMON_WINSTATIONNAME ,HIDC_COMMON_WINSTATIONNAME,
|
|
IDC_COMMON_IBYTES,HIDC_COMMON_IBYTES,
|
|
IDC_COMMON_OBYTES ,HIDC_COMMON_OBYTES,
|
|
IDC_COMMON_IFRAMES ,HIDC_COMMON_IFRAMES,
|
|
IDC_COMMON_OFRAMES ,HIDC_COMMON_OFRAMES,
|
|
IDC_COMMON_IBYTESPERFRAME ,HIDC_COMMON_IBYTESPERFRAME,
|
|
IDC_COMMON_OBYTESPERFRAME ,HIDC_COMMON_OBYTESPERFRAME,
|
|
IDC_COMMON_IFRAMEERRORS ,HIDC_COMMON_IFRAMEERRORS,
|
|
IDC_COMMON_OFRAMEERRORS ,HIDC_COMMON_OFRAMEERRORS,
|
|
IDC_COMMON_IPERCENTFRAMEERRORS ,HIDC_COMMON_IPERCENTFRAMEERRORS,
|
|
IDC_COMMON_OPERCENTFRAMEERRORS ,HIDC_COMMON_OPERCENTFRAMEERRORS,
|
|
IDC_COMMON_ITIMEOUTERRORS ,HIDC_COMMON_ITIMEOUTERRORS,
|
|
IDC_COMMON_OTIMEOUTERRORS,HIDC_COMMON_OTIMEOUTERRORS,
|
|
IDC_COMMON_ICOMPRESSIONRATIO ,HIDC_COMMON_ICOMPRESSIONRATIO,
|
|
IDC_COMMON_OCOMPRESSIONRATIO ,HIDC_COMMON_OCOMPRESSIONRATIO,
|
|
IDC_REFRESHNOW ,HIDC_REFRESHNOW,
|
|
IDC_RESETCOUNTERS,HIDC_RESETCOUNTERS,
|
|
IDC_MOREINFO,HIDC_MOREINFO,
|
|
IDC_ASYNC_DEVICE, HIDC_ASYNC_DEVICE ,
|
|
IDC_ASYNC_BAUD ,HIDC_ASYNC_BAUD ,
|
|
IDC_ASYNC_DTR , HIDC_ASYNC_DTR ,
|
|
IDC_ASYNC_RTS , HIDC_ASYNC_RTS ,
|
|
IDC_ASYNC_CTS , HIDC_ASYNC_CTS ,
|
|
IDC_ASYNC_DSR , HIDC_ASYNC_DSR ,
|
|
IDC_ASYNC_DCD , HIDC_ASYNC_DCD ,
|
|
IDC_ASYNC_RI , HIDC_ASYNC_RI ,
|
|
IDC_ASYNC_IFRAMING , HIDC_ASYNC_IFRAMING ,
|
|
IDC_ASYNC_IOVERRUN , HIDC_ASYNC_IOVERRUN ,
|
|
IDC_ASYNC_IOVERFLOW , HIDC_ASYNC_IOVERFLOW,
|
|
IDC_ASYNC_IPARITY , HIDC_ASYNC_IPARITY ,
|
|
IDC_ASYNC_OFRAMING , HIDC_ASYNC_OFRAMING ,
|
|
IDC_ASYNC_OOVERRUN , HIDC_ASYNC_OOVERRUN ,
|
|
IDC_ASYNC_OOVERFLOW , HIDC_ASYNC_OOVERFLOW ,
|
|
IDC_ASYNC_OPARITY , HIDC_ASYNC_OPARITY ,
|
|
IDC_NETWORK_LANADAPTER, HIDC_NETWORK_LANADAPTER,
|
|
IDC_PREFERENCES_PROC_MANUAL ,HIDC_PREFERENCES_PROC_MANUAL ,
|
|
IDC_PREFERENCES_PROC_EVERY , HIDC_PREFERENCES_PROC_EVERY ,
|
|
IDC_PREFERENCES_PROC_SECONDS , HIDC_PREFERENCES_PROC_SECONDS,
|
|
IDC_PREFERENCES_STATUS_MANUAL , HIDC_PREFERENCES_STATUS_MANUAL,
|
|
IDC_PREFERENCES_STATUS_EVERY , HIDC_PREFERENCES_STATUS_EVERY,
|
|
IDC_PREFERENCES_STATUS_SECONDS , HIDC_PREFERENCES_STATUS_SECONDS ,
|
|
IDC_PREFERENCES_STATUS_SECONDS ,HIDC_PREFERENCES_STATUS_SECONDS ,
|
|
IDC_PREFERENCES_CONFIRM ,HIDC_PREFERENCES_CONFIRM ,
|
|
IDD_WINSTATION_NOINFO,HIDD_WINSTATION_NOINFO,
|
|
IDC_PREFERENCES_SAVE , HIDC_PREFERENCES_SAVE,
|
|
IDC_PREFERENCES_PERSISTENT ,HIDC_PREFERENCES_REMEMBER,
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#endif // _WINADMIN_H
|