|
|
/*******************************************************************************
** 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
|
