able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/admtools/winutils/tsadmin/winadmin.h

1642 lines
66 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*******************************************************************************
*
* 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
Reference in a new issue Copy permalink