using System; using System.Runtime.InteropServices; using System.Text; using Vanara.Extensions; using Vanara.InteropServices; using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME; namespace Vanara.PInvoke { /// Items from the WTSApi32.dll public static partial class WTSApi32 { /// A session value the indicates all WTS sessions. public const uint WTS_ANY_SESSION = unchecked((uint)-2); private const int CLIENTADDRESS_LENGTH = 30; private const int CLIENTNAME_LENGTH = 20; private const int DOMAIN_LENGTH = 17; private const string Lib_WTSApi32 = "wtsapi32.dll"; private const int MAX_PATH = 260; private const int USERNAME_LENGTH = 20; private const int WINSTATIONNAME_LENGTH = 32; private const int WTS_COMMENT_LENGTH = 60; private const int WTS_DRIVE_LENGTH = 3; /// The virtual modifier that represents the key to press to stop remote control of the session. [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSStartRemoteControlSessionA")] [Flags] public enum REMOTECONTROL_HOTKEY { /// The SHIFT key. REMOTECONTROL_KBDSHIFT_HOTKEY = 0x1, /// The CTRL key. REMOTECONTROL_KBDCTRL_HOTKEY = 0x2, /// The ALT key. REMOTECONTROL_KBDALT_HOTKEY = 0x4, } /// Options for WTSVirtualChannelOpenEx. [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelOpenEx")] [Flags] public enum WTS_CHANNEL_OPTION { /// Open the channel as a DVC. WTS_CHANNEL_OPTION_DYNAMIC = 0x00000001, /// /// Low priority. The data will be sent on both sides with low priority. Use this priority level for block transfers of all /// sizes, where the transfer speed is not important. In almost all (95%) cases, the channel should be opened with this flag. /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_LOW = 0x00000000, /// /// Medium priority. Use this priority level to send short control messages that must have priority over the data in the low /// priority channels. /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_MED = 0x00000002, /// /// High priority. Use this priority level for data that is critical and directly affects the user experience. The transfer size /// may vary. Display data falls into this category. /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_HIGH = 0x00000004, /// /// Real-time priority. Use this priority level only in cases where the data transfer is absolutely critical. The data transfer /// size should be limited to a few hundred bytes per message. /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_REAL = 0x00000006, /// /// Disables compression for this DVC. You must specify this value in combination with the WTS_CHANNEL_OPTION_DYNAMIC value. /// WTS_CHANNEL_OPTION_DYNAMIC_NO_COMPRESS = 0x00000008 } /// /// Contains values that indicate the type of user configuration information to set or retrieve in a call to the WTSQueryUserConfig /// and WTSSetUserConfig functions. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ne-wtsapi32-wts_config_class typedef enum _WTS_CONFIG_CLASS { // WTSUserConfigInitialProgram, WTSUserConfigWorkingDirectory, WTSUserConfigfInheritInitialProgram, // WTSUserConfigfAllowLogonTerminalServer, WTSUserConfigTimeoutSettingsConnections, WTSUserConfigTimeoutSettingsDisconnections, // WTSUserConfigTimeoutSettingsIdle, WTSUserConfigfDeviceClientDrives, WTSUserConfigfDeviceClientPrinters, // WTSUserConfigfDeviceClientDefaultPrinter, WTSUserConfigBrokenTimeoutSettings, WTSUserConfigReconnectSettings, // WTSUserConfigModemCallbackSettings, WTSUserConfigModemCallbackPhoneNumber, WTSUserConfigShadowingSettings, // WTSUserConfigTerminalServerProfilePath, WTSUserConfigTerminalServerHomeDir, WTSUserConfigTerminalServerHomeDirDrive, // WTSUserConfigfTerminalServerRemoteHomeDir, WTSUserConfigUser } WTS_CONFIG_CLASS; [PInvokeData("wtsapi32.h", MSDNShortId = "NE:wtsapi32._WTS_CONFIG_CLASS")] public enum WTS_CONFIG_CLASS { /// /// A null-terminated string that contains the path of the initial program that Remote Desktop Services runs when the user logs /// on.If the WTSUserConfigfInheritInitialProgram value is 1, the initial program can be any program specified by the client. /// WTSUserConfigInitialProgram, /// A null-terminated string that contains the path of the working directory for the initial program. WTSUserConfigWorkingDirectory, /// A value that indicates whether the client can specify the initial program. WTSUserConfigfInheritInitialProgram, /// A value that indicates whether the user account is permitted to log on to an RD Session Host server. WTSUserConfigfAllowLogonTerminalServer, /// /// A DWORD value that specifies the maximum connection duration, in milliseconds. One minute before the connection time-out /// interval expires, the user is notified of the pending disconnection. The user's session is disconnected or terminated /// depending on the WTSUserConfigBrokenTimeoutSettings value. Every time the user logs on, the timer is reset. A value of zero /// indicates that the connection timer is disabled. /// WTSUserConfigTimeoutSettingsConnections, /// /// A DWORD value that specifies the maximum duration, in milliseconds, that an RD Session Host server retains a disconnected /// session before the logon is terminated. A value of zero indicates that the disconnection timer is disabled. /// WTSUserConfigTimeoutSettingsDisconnections, /// /// A DWORD value that specifies the maximum idle time, in milliseconds. If there is no keyboard or mouse activity for the /// specified interval, the user's session is disconnected or terminated depending on the WTSUserConfigBrokenTimeoutSettings /// value. A value of zero indicates that the idle timer is disabled. /// WTSUserConfigTimeoutSettingsIdle, /// /// This constant currently is not used by Remote Desktop Services.A value that indicates whether the RD Session Host server /// automatically reestablishes client drive mappings at logon. /// WTSUserConfigfDeviceClientDrives, /// /// RDP 5.0 and later clients: A value that indicates whether the RD Session Host server automatically reestablishes client /// printer mappings at logon. /// WTSUserConfigfDeviceClientPrinters, /// RDP 5.0 and later clients: A value that indicates whether the client printer is the default printer. WTSUserConfigfDeviceClientDefaultPrinter, /// /// A value that indicates what happens when the connection or idle timers expire or when a connection is lost due to a /// connection error. /// WTSUserConfigBrokenTimeoutSettings, /// A value that indicates how a disconnected session for this user can be reconnected. WTSUserConfigReconnectSettings, /// /// This constant currently is not used by Remote Desktop Services.A value that indicates the configuration for dial-up /// connections in which the RD Session Host server stops responding and then calls back the client to establish the connection. /// WTSUserConfigModemCallbackSettings, /// /// This constant currently is not used by Remote Desktop Services.A null-terminated string that contains the phone number to /// use for callback connections. /// WTSUserConfigModemCallbackPhoneNumber, /// /// RDP 5.0 and later clients: A value that indicates whether the user session can be shadowed. Shadowing allows a user to /// remotely monitor the on-screen operations of another user. /// WTSUserConfigShadowingSettings, /// /// A null-terminated string that contains the path of the user's profile for RD Session Host server logon. The directory the /// path identifies must be created manually, and must exist prior to the logon. WTSSetUserConfig will not create the directory /// if it does not already exist. /// WTSUserConfigTerminalServerProfilePath, /// /// A null-terminated string that contains the path of the user's root directory for RD Session Host server logon. This string /// can specify a local path or a UNC path (\ComputerName\Share\Path). For more information, see WTSUserConfigfTerminalServerRemoteHomeDir. /// WTSUserConfigTerminalServerHomeDir, /// /// A null-terminated string that contains a drive name (a drive letter followed by a colon) to which the UNC path specified in /// the WTSUserConfigTerminalServerHomeDir string is mapped. For more information, see WTSUserConfigfTerminalServerRemoteHomeDir. /// WTSUserConfigTerminalServerHomeDirDrive, /// /// A value that indicates whether the user's root directory for RD Session Host server logon is a local path or a mapped drive /// letter. Note that this value cannot be used with WTSSetUserConfig. /// WTSUserConfigfTerminalServerRemoteHomeDir, /// /// A WTSUSERCONFIG structure that contains configuration data for the session. Windows Server 2008 and Windows Vista: This /// value is not supported. /// WTSUserConfigUser, } /// /// Specifies the source of configuration information returned by the WTSQueryUserConfig function. This enumeration type is used in /// the WTSUSERCONFIG structure. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ne-wtsapi32-wts_config_source typedef enum _WTS_CONFIG_SOURCE { // WTSUserConfigSourceSAM } WTS_CONFIG_SOURCE; [PInvokeData("wtsapi32.h", MSDNShortId = "NE:wtsapi32._WTS_CONFIG_SOURCE")] public enum WTS_CONFIG_SOURCE { /// The configuration information came from the Security Accounts Manager (SAM) database. WTSUserConfigSourceSAM, } /// Specifies the connection state of a Remote Desktop Services session. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ne-wtsapi32-wts_connectstate_class typedef enum // _WTS_CONNECTSTATE_CLASS { WTSActive, WTSConnected, WTSConnectQuery, WTSShadow, WTSDisconnected, WTSIdle, WTSListen, WTSReset, // WTSDown, WTSInit } WTS_CONNECTSTATE_CLASS; [PInvokeData("wtsapi32.h", MSDNShortId = "NE:wtsapi32._WTS_CONNECTSTATE_CLASS")] public enum WTS_CONNECTSTATE_CLASS { /// /// A user is logged on to the WinStation. This state occurs when a user is signed in and actively connected to the device. /// WTSActive, /// The WinStation is connected to the client. WTSConnected, /// The WinStation is in the process of connecting to the client. WTSConnectQuery, /// The WinStation is shadowing another WinStation. WTSShadow, /// /// The WinStation is active but the client is disconnected. This state occurs when a user is signed in but not actively /// connected to the device, such as when the user has chosen to exit to the lock screen. /// WTSDisconnected, /// The WinStation is waiting for a client to connect. WTSIdle, /// /// The WinStation is listening for a connection. A listener session waits for requests for new client connections. No user is /// logged on a listener session. A listener session cannot be reset, shadowed, or changed to a regular client session. /// WTSListen, /// The WinStation is being reset. WTSReset, /// The WinStation is down due to an error. WTSDown, /// The WinStation is initializing. WTSInit, } /// Bitmask that specifies the set of events to wait for. [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSWaitSystemEvent")] [Flags] public enum WTS_EVENT : uint { /// The wait terminated because of a WTSWaitSystemEvent call with WTS_EVENT_FLUSH. WTS_EVENT_NONE = 0x00000000, /// A new WinStation was created. WTS_EVENT_CREATE = 0x00000001, /// An existing WinStation was deleted. WTS_EVENT_DELETE = 0x00000002, /// An existing WinStation was renamed. WTS_EVENT_RENAME = 0x00000004, /// A client connected to a WinStation. WTS_EVENT_CONNECT = 0x00000008, /// A client disconnected from a WinStation. WTS_EVENT_DISCONNECT = 0x00000010, /// A user logged on to the system from either the Remote Desktop Services console or from a client WinStation. WTS_EVENT_LOGON = 0x00000020, /// A user logged off from either the Remote Desktop Services console or from a client WinStation. WTS_EVENT_LOGOFF = 0x00000040, /// /// A WinStation connection state changed. For a list of connection states, see the WTS_CONNECTSTATE_CLASS enumeration type. /// WTS_EVENT_STATECHANGE = 0x00000080, /// /// The Remote Desktop Services' license state changed. This occurs when a license is added or deleted using License Manager. /// WTS_EVENT_LICENSE = 0x00000100, /// Wait for any event type. WTS_EVENT_ALL = 0x7fffffff, /// Cause all pending WTSWaitSystemEvent calls on the specified RD Session Host server handle to return. WTS_EVENT_FLUSH = 0x80000000, } /// /// Contains values that indicate the type of session information to retrieve in a call to the WTSQuerySessionInformation function. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ne-wtsapi32-wts_info_class typedef enum _WTS_INFO_CLASS { // WTSInitialProgram, WTSApplicationName, WTSWorkingDirectory, WTSOEMId, WTSSessionId, WTSUserName, WTSWinStationName, // WTSDomainName, WTSConnectState, WTSClientBuildNumber, WTSClientName, WTSClientDirectory, WTSClientProductId, WTSClientHardwareId, // WTSClientAddress, WTSClientDisplay, WTSClientProtocolType, WTSIdleTime, WTSLogonTime, WTSIncomingBytes, WTSOutgoingBytes, // WTSIncomingFrames, WTSOutgoingFrames, WTSClientInfo, WTSSessionInfo, WTSSessionInfoEx, WTSConfigInfo, WTSValidationInfo, // WTSSessionAddressV4, WTSIsRemoteSession } WTS_INFO_CLASS; [PInvokeData("wtsapi32.h", MSDNShortId = "NE:wtsapi32._WTS_INFO_CLASS")] public enum WTS_INFO_CLASS { /// /// A null-terminated string that contains the name of the initial program that Remote Desktop Services runs when the user logs on. /// [CorrespondingType(typeof(string))] WTSInitialProgram, /// /// A null-terminated string that contains the published name of the application that the session is running.Windows Server 2008 /// R2, Windows 7, Windows Server 2008 and Windows Vista: This value is not supported /// [CorrespondingType(typeof(string))] WTSApplicationName, /// A null-terminated string that contains the default directory used when launching the initial program. [CorrespondingType(typeof(string))] WTSWorkingDirectory, /// This value is not used. WTSOEMId, /// A ULONG value that contains the session identifier. [CorrespondingType(typeof(uint))] WTSSessionId, /// A null-terminated string that contains the name of the user associated with the session. [CorrespondingType(typeof(string))] WTSUserName, /// A null-terminated string that contains the name of the Remote Desktop Services session. [CorrespondingType(typeof(string))] WTSWinStationName, /// A null-terminated string that contains the name of the domain to which the logged-on user belongs. [CorrespondingType(typeof(string))] WTSDomainName, /// The session's current connection state. For more information, see WTS_CONNECTSTATE_CLASS. [CorrespondingType(typeof(WTS_CONNECTSTATE_CLASS))] WTSConnectState, /// A ULONG value that contains the build number of the client. [CorrespondingType(typeof(uint))] WTSClientBuildNumber, /// A null-terminated string that contains the name of the client. [CorrespondingType(typeof(string))] WTSClientName, /// A null-terminated string that contains the directory in which the client is installed. [CorrespondingType(typeof(string))] WTSClientDirectory, /// A USHORT client-specific product identifier. [CorrespondingType(typeof(ushort))] WTSClientProductId, /// /// A ULONG value that contains a client-specific hardware identifier. This option is reserved for future use. /// WTSQuerySessionInformation will always return a value of 0. /// [CorrespondingType(typeof(uint))] WTSClientHardwareId, /// /// The network type and network address of the client. For more information, see WTS_CLIENT_ADDRESS. The IP address is offset /// by two bytes from the start of the Address member of the WTS_CLIENT_ADDRESS structure. /// [CorrespondingType(typeof(WTS_CLIENT_ADDRESS))] WTSClientAddress, /// Information about the display resolution of the client. For more information, see WTS_CLIENT_DISPLAY. [CorrespondingType(typeof(WTS_CLIENT_DISPLAY))] WTSClientDisplay, /// /// A USHORT value that specifies information about the protocol type for the session. This is one of the following values. /// [CorrespondingType(typeof(ushort))] WTSClientProtocolType, /// /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns /// ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows Vista: This value is not used. /// WTSIdleTime, /// /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns /// ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows Vista: This value is not used. /// WTSLogonTime, /// /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns /// ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows Vista: This value is not used. /// WTSIncomingBytes, /// /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns /// ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows Vista: This value is not used. /// WTSOutgoingBytes, /// /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns /// ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows Vista: This value is not used. /// WTSIncomingFrames, /// /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns /// ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows Vista: This value is not used. /// WTSOutgoingFrames, /// Information about a Remote Desktop Connection (RDC) client. For more information, see WTSCLIENT. [CorrespondingType(typeof(WTSCLIENT))] WTSClientInfo, /// Information about a client session on a RD Session Host server. For more information, see WTSINFO. [CorrespondingType(typeof(WTSINFO))] WTSSessionInfo, /// /// Extended information about a session on a RD Session Host server. For more information, see WTSINFOEX. Windows Server 2008 /// and Windows Vista: This value is not supported. /// [CorrespondingType(typeof(WTSINFOEX))] WTSSessionInfoEx, /// /// A WTSCONFIGINFO structure that contains information about the configuration of a RD Session Host server. Windows Server 2008 /// and Windows Vista: This value is not supported. /// [CorrespondingType(typeof(WTSCONFIGINFO))] WTSConfigInfo, /// This value is not supported. WTSValidationInfo, /// /// A WTS_SESSION_ADDRESS structure that contains the IPv4 address assigned to the session. If the session does not have a /// virtual IP address, the WTSQuerySessionInformation function returns ERROR_NOT_SUPPORTED.Windows Server 2008 and Windows /// Vista: This value is not supported. /// [CorrespondingType(typeof(WTS_SESSION_ADDRESS))] WTSSessionAddressV4, /// /// Determines whether the current session is a remote session. The WTSQuerySessionInformation function returns a value of TRUE /// to indicate that the current session is a remote session, and FALSE to indicate that the current session is a local session. /// This value can only be used for the local machine, so the hServer parameter of the WTSQuerySessionInformation function must /// contain WTS_CURRENT_SERVER_HANDLE. Windows Server 2008 and Windows Vista: This value is not supported. /// WTSIsRemoteSession, } /// The purpose of the call. [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSCreateListenerA")] public enum WTS_LISTENER { /// Create a new listener. WTS_LISTENER_CREATE = 0x00000001, /// Update the settings of an existing listener. WTS_LISTENER_UPDATE = 0x00000010, } /// The state of the session. [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSINFOEX_LEVEL1_A")] [Flags] public enum WTS_SESSIONSTATE : uint { /// The session state is not known. WTS_SESSIONSTATE_UNKNOWN = 0xFFFFFFFF, /// The session state is locked. WTS_SESSIONSTATE_LOCK = 0x00000000, /// The session state is unlocked. WTS_SESSIONSTATE_UNLOCK = 0x00000001, } /// Specifies the type of structure that a Remote Desktop Services function has returned in a buffer. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ne-wtsapi32-wts_type_class typedef enum _WTS_TYPE_CLASS { // WTSTypeProcessInfoLevel0, WTSTypeProcessInfoLevel1, WTSTypeSessionInfoLevel1 } WTS_TYPE_CLASS; [PInvokeData("wtsapi32.h", MSDNShortId = "NE:wtsapi32._WTS_TYPE_CLASS")] public enum WTS_TYPE_CLASS { /// The buffer contains one or more WTS_PROCESS_INFO structures. WTSTypeProcessInfoLevel0, /// The buffer contains one or more WTS_PROCESS_INFO_EX structures. WTSTypeProcessInfoLevel1, /// The buffer contains one or more WTS_SESSION_INFO_1 structures. WTSTypeSessionInfoLevel1, } /// Contains values that indicate the type of virtual channel information to retrieve. /// /// For an example that shows the use of the WTSVirtualFileHandle value, see WTSVirtualChannelQuery. This example shows how to gain /// access to a virtual channel file handle that can be used for asynchronous I/O. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ne-wtsapi32-wts_virtual_class typedef enum _WTS_VIRTUAL_CLASS { // WTSVirtualClientData, WTSVirtualFileHandle } WTS_VIRTUAL_CLASS; [PInvokeData("wtsapi32.h", MSDNShortId = "NE:wtsapi32._WTS_VIRTUAL_CLASS")] public enum WTS_VIRTUAL_CLASS { /// This value is not currently supported. WTSVirtualClientData, /// Indicates a request for the file handle of a virtual channel that can be used for asynchronous I/O. WTSVirtualFileHandle, } /// Indicates the type of shutdown. [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSShutdownSystem")] public enum WTS_WSD { /// /// Forces all client sessions to log off (except the session calling WTSShutdownSystem) and disables any subsequent /// remote logons. This can be used as a step before shutting down. Logons will be re-enabled when the Remote Desktop Services /// service is restarted. /// WTS_WSD_LOGOFF = 0x00000001, /// /// Shuts down the system on the RD Session Host server. This is equivalent to calling the ExitWindowsEx function with /// EWX_SHUTDOWN. The calling process must have the SE_SHUTDOWN_NAME privilege enabled. /// WTS_WSD_SHUTDOWN = 0x00000002, /// /// Shuts down and then restarts the system on the RD Session Host server. This is equivalent to calling ExitWindowsEx /// with EWX_REBOOT. The calling process must have the SE_SHUTDOWN_NAME privilege enabled. /// WTS_WSD_REBOOT = 0x00000004, /// /// Shuts down the system on the RD Session Host server and, on computers that support software control of AC power, turns off /// the power. This is equivalent to calling ExitWindowsEx with EWX_SHUTDOWN and EWX_POWEROFF. The calling process /// must have the SE_SHUTDOWN_NAME privilege enabled. /// WTS_WSD_POWEROFF = 0x00000008, /// This value is not supported currently. WTS_WSD_FASTREBOOT = 0x00000010, } /// Closes an open handle to a Remote Desktop Session Host (RD Session Host) server. /// /// A handle to an RD Session Host server opened by a call to the WTSOpenServer or WTSOpenServerEx function. /// Do not pass WTS_CURRENT_SERVER_HANDLE for this parameter. /// /// None /// /// /// Call the WTSCloseServer function as part of your program's clean-up routine to close all the server handles opened by /// calls to the WTSOpenServer or WTSOpenServerEx function. /// /// After the handle has been closed, it cannot be used with any other WTS APIs. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtscloseserver void WTSCloseServer( HANDLE hServer ); [DllImport(Lib_WTSApi32, SetLastError = false, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSCloseServer")] public static extern void WTSCloseServer(HWTSSERVER hServer); /// Connects a Remote Desktop Services session to an existing session on the local computer. /// /// /// The logon ID of the session to connect to. The user of that session must have permissions to connect to an existing session. The /// output of this session will be routed to the session identified by the TargetLogonId parameter. /// /// This can be LOGONID_CURRENT to use the current session. /// /// /// /// The logon ID of the session to receive the output of the session represented by the LogonId parameter. The output of the session /// identified by the LogonId parameter will be routed to this session. /// /// This can be LOGONID_CURRENT to use the current session. /// /// /// A pointer to the password for the user account that is specified in the LogonId parameter. The value of pPassword can be an /// empty string if the caller is logged on using the same domain name and user name as the logon ID. The value of pPassword cannot /// be NULL. /// /// /// Indicates whether the operation is synchronous. Specify TRUE to wait for the operation to complete, or FALSE to /// return immediately. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// Either the LogonId or TargetLogonId parameter can be LOGONID_CURRENT, but not both. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsconnectsessiona BOOL WTSConnectSessionA( ULONG // LogonId, ULONG TargetLogonId, PSTR pPassword, BOOL bWait ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSConnectSessionA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSConnectSession(uint LogonId, uint TargetLogonId, [MarshalAs(UnmanagedType.LPTStr)] string pPassword, [MarshalAs(UnmanagedType.Bool)] bool bWait); /// Creates a new Remote Desktop Services listener or configures an existing listener. /// A handle to an RD Session Host server. Always set this parameter to WTS_CURRENT_SERVER_HANDLE. /// This parameter is reserved. Always set this parameter to NULL. /// This parameter is reserved. Always set this parameter to zero. /// A pointer to a null-terminated string that contains the name of the listener to create or configure. /// A pointer to a WTSLISTENERCONFIG structure that contains configuration information for the listener. /// /// The purpose of the call. This parameter can be one of the following values. /// WTS_LISTENER_CREATE (1 (0x1)) /// Create a new listener. /// WTS_LISTENER_UPDATE (16 (0x10)) /// Update the settings of an existing listener. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// /// This function creates or configures a listener that uses Remote Desktop Protocol (RDP). Always set the version member of /// the WTSLISTENERCONFIG structure that is pointed to by the pBuffer parameter to one. /// /// /// This function does not create or configure the security descriptor of the listener. When you call this function to create a new /// listener, the function assigns the default security descriptor to the new listener. To modify the security descriptor, call the /// WTSSetListenerSecurity function. For more information about security descriptors, see SECURITY_DESCRIPTOR. /// /// /// This function does not validate the settings for the new listener. Be sure that the settings are valid before calling this function. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtscreatelistenera BOOL WTSCreateListenerA( HANDLE // hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, PWTSLISTENERCONFIGA pBuffer, DWORD flag ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSCreateListenerA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSCreateListener(HWTSSERVER hServer, [In, Optional] IntPtr pReserved, [In, Optional] uint Reserved, [MarshalAs(UnmanagedType.LPTStr)] string pListenerName, in WTSLISTENERCONFIG pBuffer, WTS_LISTENER flag); /// /// Disconnects the logged-on user from the specified Remote Desktop Services session without closing the session. If the user /// subsequently logs on to the same Remote Desktop Session Host (RD Session Host) server, the user is reconnected to the same session. /// /// /// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer or WTSOpenServerEx function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the RD Session Host server on which your application is running. /// /// /// /// A Remote Desktop Services session identifier. To indicate the current session, specify WTS_CURRENT_SESSION. To retrieve /// the identifiers of all sessions on a specified RD Session Host server, use the WTSEnumerateSessions function. /// /// /// To be able to disconnect another user's session, you need to have the Disconnect permission. For more information, see Remote /// Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// To disconnect sessions running on a virtual machine hosted on a RD Virtualization Host server, you must be a member of the /// Administrators group on the RD Virtualization Host server. /// /// /// /// Indicates whether the operation is synchronous. Specify TRUE to wait for the operation to complete, or FALSE to /// return immediately. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsdisconnectsession BOOL WTSDisconnectSession( HANDLE // hServer, DWORD SessionId, BOOL bWait ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSDisconnectSession")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSDisconnectSession(HWTSSERVER hServer, uint SessionId, [MarshalAs(UnmanagedType.Bool)] bool bWait); /// Enables or disables Child Sessions. /// /// Indicates whether to enable or disable child sessions. Pass TRUE if child sessions are to be enabled or FALSE otherwise. /// /// Returns nonzero if the function succeeds or zero otherwise. /// For more information about child sessions, see Child Sessions. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenablechildsessions BOOL WTSEnableChildSessions( BOOL // bEnable ); [DllImport(Lib_WTSApi32, SetLastError = false, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnableChildSessions")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnableChildSessions([MarshalAs(UnmanagedType.Bool)] bool bEnable); /// Enumerates all the Remote Desktop Services listeners on a Remote Desktop Session Host (RD Session Host) server. /// A handle to an RD Session Host server. Always set this parameter to WTS_CURRENT_SERVER_HANDLE. /// This parameter is reserved. Always set this parameter to NULL. /// This parameter is reserved. Always set this parameter to zero. /// A pointer to an array of WTSLISTENERNAME variables that receive the names of the listeners. /// /// A pointer to a DWORD variable that contains the number of listener names in the array referenced by the pListeners /// parameter. If the number of listener names is unknown, pass pListeners as NULL. The function will return the number of /// WTSLISTENERNAME variables necessary to allocate for the array pointed to by the pListeners parameter. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// /// This function returns all listeners currently running on the server, including listeners that do not support Remote Desktop /// Protocol (RDP). /// /// /// If the number of listeners is unknown, you can call this function with pListeners set to NULL. The function will then /// return, in the pCount parameter, the number of WTSLISTENERNAME variables necessary to receive all the listeners. Allocate /// the array for pListeners based on this number, and then call the function again, setting pListeners to the newly allocated array /// and pCount to the number returned by the first call. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumeratelistenersa BOOL WTSEnumerateListenersA( // HANDLE hServer, PVOID pReserved, DWORD Reserved, PWTSLISTENERNAMEA pListeners, DWORD *pCount ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateListenersA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnumerateListeners(HWTSSERVER hServer, [In, Optional] IntPtr pReserved, [In, Optional] uint Reserved, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] WTSLISTENERNAME[] pListeners, ref uint pCount); /// Retrieves information about the active processes on a specified Remote Desktop Session Host (RD Session Host) server. /// /// Handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the RD Session Host server on which your application is running. /// /// Reserved; must be zero. /// Specifies the version of the enumeration request. Must be 1. /// /// Pointer to a variable that receives a pointer to an array of WTS_PROCESS_INFO structures. Each structure in the array contains /// information about an active process on the specified RD Session Host server. To free the returned buffer, call the WTSFreeMemory function. /// /// /// Pointer to a variable that receives the number of WTS_PROCESS_INFO structures returned in the ppProcessInfo buffer. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// The caller must be a member of the Administrators group to enumerate processes that are running under a different user's context. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumerateprocessesa BOOL WTSEnumerateProcessesA( // HANDLE hServer, DWORD Reserved, DWORD Version, PWTS_PROCESS_INFOA *ppProcessInfo, DWORD *pCount ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateProcessesA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnumerateProcesses(HWTSSERVER hServer, [In, Optional] uint Reserved, uint Version, out SafeWTSMemoryHandle ppProcessInfo, out uint pCount); /// /// Retrieves information about the active processes on the specified Remote Desktop Session Host (RD Session Host) server or Remote /// Desktop Virtualization Host (RD Virtualization Host) server. /// /// /// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the server on which your application is running. /// /// /// /// A pointer to a DWORD variable that, on input, specifies the type of information to return. To return an array of /// WTS_PROCESS_INFO structures, specify zero. To return an array of WTS_PROCESS_INFO_EX structures, specify one. /// /// /// If you do not specify a valid value for this parameter, on output, WTSEnumerateProcessesEx sets this parameter to one and /// returns an error. Otherwise, on output, WTSEnumerateProcessesEx does not change the value of this parameter. /// /// /// /// The session for which to enumerate processes. To enumerate processes for all sessions on the server, specify WTS_ANY_SESSION. /// /// /// A pointer to a variable that receives a pointer to an array of WTS_PROCESS_INFO or WTS_PROCESS_INFO_EX structures. The type of /// structure is determined by the value passed to the pLevel parameter. Each structure in the array contains information about an /// active process. When you have finished using the array, free it by calling the WTSFreeMemoryEx function. You should also set the /// pointer to NULL. /// /// /// A pointer to a variable that receives the number of structures returned in the buffer referenced by the ppProcessInfo parameter. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// The caller must be a member of the Administrators group to enumerate processes that are running under another user session. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumerateprocessesexa BOOL WTSEnumerateProcessesExA( // HANDLE hServer, DWORD *pLevel, DWORD SessionId, LPSTR *ppProcessInfo, DWORD *pCount ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateProcessesExA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnumerateProcessesEx(HWTSSERVER hServer, ref uint pLevel, uint SessionId, out IntPtr ppProcessInfo, out uint pCount); /// /// Retrieves information about the active processes on the specified Remote Desktop Session Host (RD Session Host) server or Remote /// Desktop Virtualization Host (RD Virtualization Host) server. /// /// /// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the server on which your application is running. /// /// /// The session for which to enumerate processes. To enumerate processes for all sessions on the server, specify WTS_ANY_SESSION. /// /// An array of WTS_PROCESS_INFO_EX structures. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// The caller must be a member of the Administrators group to enumerate processes that are running under another user session. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumerateprocessesexa BOOL WTSEnumerateProcessesExA( // HANDLE hServer, DWORD *pLevel, DWORD SessionId, LPSTR *ppProcessInfo, DWORD *pCount ); [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateProcessesExA")] public static bool WTSEnumerateProcessesEx(HWTSSERVER hServer, uint SessionId, out WTS_PROCESS_INFO_EX[] ppProcessInfo) { uint lvl = 1; if (WTSEnumerateProcessesEx(hServer, ref lvl, SessionId, out var ptr, out var cnt) && lvl == 1) { try { ppProcessInfo = ptr.ToArray((int)cnt); } finally { WTSFreeMemoryEx(WTS_TYPE_CLASS.WTSTypeProcessInfoLevel1, ptr, cnt); } return true; } ppProcessInfo = null; return false; } /// Returns a list of all Remote Desktop Session Host (RD Session Host) servers within the specified domain. /// /// Pointer to the name of the domain to be queried. If the value of this parameter is NULL, the specified domain is the /// current domain. /// /// Reserved. The value of this parameter must be 0. /// Version of the enumeration request. The value of the parameter must be 1. /// /// Points to an array of WTS_SERVER_INFO structures, which contains the returned results of the enumeration. After use, the memory /// used by this buffer should be freed by calling WTSFreeMemory. /// /// /// Pointer to a variable that receives the number of WTS_SERVER_INFO structures returned in the ppServerInfo buffer. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// This function will not work if NetBT is disabled. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumerateserversa BOOL WTSEnumerateServersA( LPSTR // pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOA *ppServerInfo, DWORD *pCount ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateServersA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnumerateServers([Optional, MarshalAs(UnmanagedType.LPTStr)] string pDomainName, [Optional] uint Reserved, uint Version, out SafeWTSMemoryHandle ppServerInfo, out uint pCount); /// Returns a list of all Remote Desktop Session Host (RD Session Host) servers within the specified domain. /// /// Pointer to the name of the domain to be queried. If the value of this parameter is NULL, the specified domain is the /// current domain. /// /// An array of WTS_SERVER_INFO structures, which contains the returned results of the enumeration. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// This function will not work if NetBT is disabled. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumerateserversa BOOL WTSEnumerateServersA( LPSTR // pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOA *ppServerInfo, DWORD *pCount ); [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateServersA")] public static bool WTSEnumerateServers([Optional] string pDomainName, out WTS_SERVER_INFO[] ppServerInfo) { if (WTSEnumerateServers(pDomainName, 0, 1, out var ptr, out var cnt)) { using (ptr) ppServerInfo = ptr.ToArray((int)cnt); return true; } ppServerInfo = null; return false; } /// Retrieves a list of sessions on a Remote Desktop Session Host (RD Session Host) server. /// /// A handle to the RD Session Host server. /// /// Note You can use the WTSOpenServer or WTSOpenServerEx functions to retrieve a handle to a specific server, or /// WTS_CURRENT_SERVER_HANDLE to use the RD Session Host server that hosts your application. /// /// /// This parameter is reserved. It must be zero. /// The version of the enumeration request. This parameter must be 1. /// /// /// A pointer to an array of WTS_SESSION_INFO structures that represent the retrieved sessions. To free the returned buffer, call /// the WTSFreeMemory function. /// /// Session permissions: /// /// /// /// To enumerate a session, you must enable the query information permission. For more information, see Remote Desktop Services Permissions. /// /// /// /// To change permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// /// To enumerate sessions running on a virtual machine hosted on a RD Virtualization Host server, you must be a member of the /// Administrators group on the RD Virtualization Host server. /// /// /// /// /// A pointer to the number of WTS_SESSION_INFO structures returned in the ppSessionInfo parameter. /// /// Returns zero if this function fails. If this function succeeds, a nonzero value is returned. /// To get extended error information, call GetLastError. /// /// For more information, and an extended example on how to use this function, see the following kb article. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumeratesessionsa BOOL WTSEnumerateSessionsA( HANDLE // hServer, DWORD Reserved, DWORD Version, PWTS_SESSION_INFOA *ppSessionInfo, DWORD *pCount ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateSessionsA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnumerateSessions(HWTSSERVER hServer, [Optional] uint Reserved, uint Version, out SafeWTSMemoryHandle ppSessionInfo, out uint pCount); /// /// Retrieves a list of sessions on a specified Remote Desktop Session Host (RD Session Host) server or Remote Desktop /// Virtualization Host (RD Virtualization Host) server. /// /// /// A handle to the target server. Specify a handle returned by the WTSOpenServer or WTSOpenServerEx function. To enumerate sessions /// on the RD Session Host server on which the application is running, specify WTS_CURRENT_SERVER_HANDLE. /// /// /// This parameter is reserved. Always set this parameter to one. On output, WTSEnumerateSessionsEx does not change the value /// of this parameter. /// /// This parameter is reserved. Always set this parameter to zero. /// /// A pointer to a PWTS_SESSION_INFO_1 variable that receives a pointer to an array of WTS_SESSION_INFO_1 structures. Each /// structure in the array contains information about a session on the specified RD Session Host server. If you obtained a handle to /// an RD Virtualization Host server by calling the WTSOpenServerEx function, the array contains information about sessions on /// virtual machines on the server. When you have finished using the array, free it by calling the WTSFreeMemoryEx function. You /// should also set the pointer to NULL. /// /// /// A pointer to a DWORD variable that receives the number of WTS_SESSION_INFO_1 structures returned in the ppSessionInfo buffer. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// /// To obtain information about sessions running on virtual machines on an RD Virtualization Host server, you must obtain the handle /// by calling the WTSOpenServerEx function. To free the returned buffer, call the WTSFreeMemoryEx function and set the WTSClassType /// parameter to WTSTypeSessionInfoLevel1. /// /// /// To enumerate a session, you need to have the Query Information permission for that session. For more information, see Remote /// Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// To enumerate sessions running on a virtual machine hosted on an RD Virtualization Host server, you must be a member of the /// Administrators group on the RD Virtualization Host server. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumeratesessionsexa BOOL WTSEnumerateSessionsExA( // HANDLE hServer, DWORD *pLevel, DWORD Filter, PWTS_SESSION_INFO_1A *ppSessionInfo, DWORD *pCount ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateSessionsExA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSEnumerateSessionsEx(HWTSSERVER hServer, in uint pLevel, [Optional] uint Filter, out IntPtr ppSessionInfo, out uint pCount); /// /// Retrieves a list of sessions on a specified Remote Desktop Session Host (RD Session Host) server or Remote Desktop /// Virtualization Host (RD Virtualization Host) server. /// /// /// A handle to the target server. Specify a handle returned by the WTSOpenServer or WTSOpenServerEx function. To enumerate sessions /// on the RD Session Host server on which the application is running, specify WTS_CURRENT_SERVER_HANDLE. /// /// /// Receives an array of WTS_SESSION_INFO_1 structures. Each /// structure in the array contains information about a session on the specified RD Session Host server. If you obtained a handle to /// an RD Virtualization Host server by calling the WTSOpenServerEx function, the array contains information about sessions on /// virtual machines on the server. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// /// To obtain information about sessions running on virtual machines on an RD Virtualization Host server, you must obtain the handle /// by calling the WTSOpenServerEx function. To free the returned buffer, call the WTSFreeMemoryEx function and set the WTSClassType /// parameter to WTSTypeSessionInfoLevel1. /// /// /// To enumerate a session, you need to have the Query Information permission for that session. For more information, see Remote /// Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// To enumerate sessions running on a virtual machine hosted on an RD Virtualization Host server, you must be a member of the /// Administrators group on the RD Virtualization Host server. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsenumeratesessionsexa BOOL WTSEnumerateSessionsExA( // HANDLE hServer, DWORD *pLevel, DWORD Filter, PWTS_SESSION_INFO_1A *ppSessionInfo, DWORD *pCount ); [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSEnumerateSessionsExA")] [return: MarshalAs(UnmanagedType.Bool)] public static bool WTSEnumerateSessionsEx(HWTSSERVER hServer, out WTS_SESSION_INFO_1[] ppSessionInfo) { if (WTSEnumerateSessionsEx(hServer, 1, 0, out var ptr, out var cnt)) { try { ppSessionInfo = ptr.ToArray((int)cnt); } finally { WTSFreeMemoryEx(WTS_TYPE_CLASS.WTSTypeSessionInfoLevel1, ptr, cnt); } return true; } ppSessionInfo = null; return false; } /// Frees memory allocated by a Remote Desktop Services function. /// Pointer to the memory to free. /// None /// /// Several Remote Desktop Services functions allocate buffers to return information. Use the WTSFreeMemory function to free /// these buffers. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsfreememory void WTSFreeMemory( PVOID pMemory ); [DllImport(Lib_WTSApi32, SetLastError = false, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSFreeMemory")] public static extern void WTSFreeMemory(IntPtr pMemory); /// /// Frees memory that contains WTS_PROCESS_INFO_EX or WTS_SESSION_INFO_1 structures allocated by a Remote Desktop Services function. /// /// /// A value of the WTS_TYPE_CLASS enumeration type that specifies the type of structures contained in the buffer referenced by the /// pMemory parameter. /// /// A pointer to the buffer to free. /// The number of elements in the buffer referenced by the pMemory parameter. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// Several Remote Desktop Services functions allocate buffers to return information. To free buffers that contain /// WTS_PROCESS_INFO_EX or WTS_SESSION_INFO_1 structures, you must call the WTSFreeMemoryEx function. To free other buffers, /// you can call either the WTSFreeMemory function or the WTSFreeMemoryEx function. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsfreememoryexa BOOL WTSFreeMemoryExA( WTS_TYPE_CLASS // WTSTypeClass, PVOID pMemory, ULONG NumberOfEntries ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSFreeMemoryExA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSFreeMemoryEx(WTS_TYPE_CLASS WTSTypeClass, IntPtr pMemory, uint NumberOfEntries); /// Retrieves the child session identifier, if present. /// /// The address of a ULONG variable that receives the child session identifier. This will be ( ULONG)–1 if there is no /// child session for the current session. /// /// Returns nonzero if the function succeeds or zero otherwise. /// For more information about child sessions, see Child Sessions. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsgetchildsessionid BOOL WTSGetChildSessionId( PULONG // pSessionId ); [DllImport(Lib_WTSApi32, SetLastError = false, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSGetChildSessionId")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSGetChildSessionId(out uint pSessionId); /// Retrieves the security descriptor of a Remote Desktop Services listener. /// A handle to an RD Session Host server. Always set this parameter to WTS_CURRENT_SERVER_HANDLE. /// This parameter is reserved. Always set this parameter to NULL. /// This parameter is reserved. Always set this parameter to zero. /// A pointer to a null-terminated string that contains the name of the listener. /// /// /// A SECURITY_INFORMATION value that specifies the security information to retrieve. Always enable the /// DACL_SECURITY_INFORMATION and SACL_SECURITY_INFORMATION flags. /// /// For more information about possible values, see SECURITY_INFORMATION. /// /// /// /// A pointer to a SECURITY_DESCRIPTOR structure that receives the security information associated with the listener referenced by /// the pListenerName parameter. The SECURITY_DESCRIPTOR structure is returned in self-relative format. For more information /// about possible values, see SECURITY_DESCRIPTOR. /// /// The discretionary access control list (DACL) of the security descriptor can contain one or more of the following values. /// WTS_SECURITY_ALL_ACCESS /// Combines these values: /// /// /// STANDARD_RIGHTS_REQUIRED /// /// /// WTS_SECURITY_CONNECT /// /// /// WTS_SECURITY_DISCONNECT /// /// /// WTS_SECURITY_LOGON /// /// /// WTS_SECURITY_MESSAGE /// /// /// WTS_SECURITY_QUERY_INFORMATION /// /// /// WTS_SECURITY_REMOTE_CONTROL /// /// /// WTS_SECURITY_RESET /// /// /// WTS_SECURITY_SET_INFORMATION /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS /// /// /// WTS_SECURITY_CONNECT (256 (0x100)) /// The right to connect. /// WTS_SECURITY_CURRENT_GUEST_ACCESS /// Combines these values: /// /// /// WTS_SECURITY_LOGOFF /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS /// /// /// WTS_SECURITY_CURRENT_USER_ACCESS /// Combines these values: /// /// /// WTS_SECURITY_DISCONNECT /// /// /// WTS_SECURITY_LOGOFF /// /// /// WTS_SECURITY_RESET /// /// /// WTS_SECURITY_SET_INFORMATION /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS /// /// /// WTS_SECURITY_DISCONNECT (512 (0x200)) /// The right to disconnect. /// WTS_SECURITY_GUEST_ACCESS /// Defined as WTS_SECURITY_LOGON. /// WTS_SECURITY_LOGOFF (64 (0x40)) /// The right to log off. /// WTS_SECURITY_LOGON (32 (0x20)) /// The right to log on. /// WTS_SECURITY_MESSAGE (128 (0x80)) /// The right to send a message to the user. /// WTS_SECURITY_QUERY_INFORMATION (1 (0x1)) /// The right to query for information. /// WTS_SECURITY_REMOTE_CONTROL (16 (0x10)) /// The right to use remote control. /// WTS_SECURITY_RESET (4 (0x4)) /// The right to reset information. /// WTS_SECURITY_SET_INFORMATION (2 (0x2)) /// The right to set information. /// WTS_SECURITY_USER_ACCESS /// Combines these values: /// /// /// WTS_SECURITY_CONNECT /// /// /// WTS_SECURITY_CURRENT_GUEST_ACCESS /// /// /// WTS_SECURITY_QUERY_INFORMATION /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS (8 (0x8)) /// The right to use virtual channels. /// /// The size, in bytes, of the SECURITY_DESCRIPTOR structure referenced by the pSecurityDescriptor parameter. /// /// A pointer to a variable that receives the number of bytes required to store the complete security descriptor. If this number is /// less than or equal to the value of the nLength parameter, the security descriptor is copied to the SECURITY_DESCRIPTOR structure /// referenced by the pSecurityDescriptor parameter; otherwise, no action is taken. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// If the number of bytes needed for the buffer that receives the SECURITY_DESCRIPTOR structure is unknown, you can call this /// method with nLength set to zero. The method will then return, in the lpnLengthNeeded parameter, the number of bytes required for /// the buffer. Allocate the buffer based on this number, and then call the method again, setting pSecurityDescriptor to the newly /// allocated buffer and nLength to the number returned by the first call. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsgetlistenersecuritya BOOL WTSGetListenerSecurityA( // HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, SECURITY_INFORMATION SecurityInformation, // PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSGetListenerSecurityA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSGetListenerSecurity(HWTSSERVER hServer, [In, Optional] IntPtr pReserved, [Optional] uint Reserved, [MarshalAs(UnmanagedType.LPTStr)] string pListenerName, SECURITY_INFORMATION SecurityInformation, [Out, Optional] PSECURITY_DESCRIPTOR pSecurityDescriptor, [Optional] uint nLength, out uint lpnLengthNeeded); /// Determines whether child sessions are enabled. /// /// The address of a BOOL variable that receives a nonzero value if child sessions are enabled or zero otherwise. /// /// Returns nonzero if the function succeeds or zero otherwise. /// For more information about child sessions, see Child Sessions. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsischildsessionsenabled BOOL WTSIsChildSessionsEnabled( // PBOOL pbEnabled ); [DllImport(Lib_WTSApi32, SetLastError = false, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSIsChildSessionsEnabled")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSIsChildSessionsEnabled([MarshalAs(UnmanagedType.Bool)] out bool pbEnabled); /// Logs off a specified Remote Desktop Services session. /// /// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer or WTSOpenServerEx function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the RD Session Host server on which your application is running. /// /// /// /// A Remote Desktop Services session identifier. To indicate the current session, specify WTS_CURRENT_SESSION. You can use /// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server. /// /// /// To be able to log off another user's session, you need to have the Reset permission. For more information, see Remote Desktop /// Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// To log off sessions running on a virtual machine hosted on a RD Virtualization Host server, you must be a member of the /// Administrators group on the RD Virtualization Host server. /// /// /// /// Indicates whether the operation is synchronous. /// If bWait is TRUE, the function returns when the session is logged off. /// /// If bWait is FALSE, the function returns immediately. To verify that the session has been logged off, specify the session /// identifier in a call to the WTSQuerySessionInformation function. WTSQuerySessionInformation returns zero if the session /// is logged off. /// /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtslogoffsession BOOL WTSLogoffSession( HANDLE hServer, // DWORD SessionId, BOOL bWait ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSLogoffSession")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSLogoffSession(HWTSSERVER hServer, uint SessionId, [MarshalAs(UnmanagedType.Bool)] bool bWait); /// Opens a handle to the specified Remote Desktop Session Host (RD Session Host) server. /// Pointer to a null-terminated string specifying the NetBIOS name of the RD Session Host server. /// /// If the function succeeds, the return value is a handle to the specified server. /// /// If the function fails, it returns a handle that is not valid. You can test the validity of the handle by using it in another /// function call. /// /// /// /// When you have finished using the handle returned by WTSOpenServer, release it by calling the WTSCloseServer function. /// /// You do not need to open a handle for operations performed on the RD Session Host server on which your application is running. /// Use the constant WTS_CURRENT_SERVER_HANDLE instead. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsopenservera HANDLE WTSOpenServerA( LPSTR pServerName ); [DllImport(Lib_WTSApi32, SetLastError = false, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSOpenServerA")] public static extern SafeHWTSSERVER WTSOpenServer([MarshalAs(UnmanagedType.LPTStr)] string pServerName); /// /// Opens a handle to the specified Remote Desktop Session Host (RD Session Host) server or Remote Desktop Virtualization Host (RD /// Virtualization Host) server. /// /// A pointer to a null-terminated string that contains the NetBIOS name of the server. /// /// If the function succeeds, the return value is a handle to the specified server. /// /// If the function fails, it returns an invalid handle. You can test the validity of the handle by using it in another function call. /// /// /// /// /// If the server specified by the pServerName parameter is an RD Session Host server, the behavior of this function is identical to /// that of the WTSOpenServer function. /// /// /// To work with sessions running on virtual machines on the RD Virtualization Host server on which the calling application is /// running, specify WTS_CURRENT_SERVER_NAME for the pServerName parameter. /// /// When you have finished using the handle returned by this function, release it by calling the WTSCloseServer function. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsopenserverexa HANDLE WTSOpenServerExA( LPSTR // pServerName ); [DllImport(Lib_WTSApi32, SetLastError = false, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSOpenServerExA")] public static extern SafeHWTSSERVER WTSOpenServerEx([MarshalAs(UnmanagedType.LPTStr)] string pServerName); /// Retrieves configuration information for a Remote Desktop Services listener. /// A handle to an RD Session Host server. Always set this parameter to WTS_CURRENT_SERVER_HANDLE. /// This parameter is reserved. Always set this parameter to NULL. /// This parameter is reserved. Always set this parameter to zero. /// A pointer to a null-terminated string that contains the name of the listener to query. /// A pointer to a WTSLISTENERCONFIG structure that receives the retrieved listener configuration information. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// /// This function does not retrieve the security descriptor for the listener. To retrieve the security descriptor, call the /// WTSGetListenerSecurity function. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsquerylistenerconfiga BOOL WTSQueryListenerConfigA( // HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, PWTSLISTENERCONFIGA pBuffer ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSQueryListenerConfigA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSQueryListenerConfig(HWTSSERVER hServer, [In, Optional] IntPtr pReserved, [In, Optional] uint Reserved, [MarshalAs(UnmanagedType.LPTStr)] string pListenerName, out WTSLISTENERCONFIG pBuffer); /// /// Retrieves session information for the specified session on the specified Remote Desktop Session Host (RD Session Host) server. /// It can be used to query session information on local and remote RD Session Host servers. /// /// /// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the RD Session Host server on which your application is running. /// /// /// /// A Remote Desktop Services session identifier. To indicate the session in which the calling application is running (or the /// current session) specify WTS_CURRENT_SESSION. Only specify WTS_CURRENT_SESSION when obtaining session information /// on the local server. If WTS_CURRENT_SESSION is specified when querying session information on a remote server, the /// returned session information will be inconsistent. Do not use the returned data. /// /// /// You can use the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server. /// /// /// To query information for another user's session, you must have Query Information permission. For more information, see Remote /// Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// /// A value of the WTS_INFO_CLASS enumeration that indicates the type of session information to retrieve in a call to the /// WTSQuerySessionInformation function. /// /// /// A pointer to a variable that receives a pointer to the requested information. The format and contents of the data depend on the /// information class specified in the WTSInfoClass parameter. To free the returned buffer, call the WTSFreeMemory function. /// /// A pointer to a variable that receives the size, in bytes, of the data returned in ppBuffer. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// /// To retrieve the session ID for the current session when Remote Desktop Services is running, call /// WTSQuerySessionInformation and specify WTS_CURRENT_SESSION for the SessionId parameter and WTSSessionId for /// the WTSInfoClass parameter. The session ID will be returned in the ppBuffer parameter. If Remote Desktop Services is not /// running, calls to WTSQuerySessionInformation fail. In this situation, you can retrieve the current session ID by calling /// the ProcessIdToSessionId function. /// /// /// To determine whether your application is running on the physical console, you must specify WTS_CURRENT_SESSION for the /// SessionId parameter, and WTSClientProtocolType as the WTSInfoClass parameter. If ppBuffer is "0", the session is attached /// to the physical console. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsquerysessioninformationa BOOL // WTSQuerySessionInformationA( HANDLE hServer, DWORD SessionId, WTS_INFO_CLASS WTSInfoClass, LPSTR *ppBuffer, DWORD *pBytesReturned ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSQuerySessionInformationA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSQuerySessionInformation(HWTSSERVER hServer, uint SessionId, WTS_INFO_CLASS WTSInfoClass, out SafeWTSMemoryHandle ppBuffer, out uint pBytesReturned); /// /// Retrieves configuration information for the specified user on the specified domain controller or Remote Desktop Session Host (RD /// Session Host) server. /// /// /// Pointer to a null-terminated string containing the name of a domain controller or an RD Session Host server. Specify /// WTS_CURRENT_SERVER_NAME to indicate the RD Session Host server on which your application is running. /// /// /// /// Pointer to a null-terminated string containing the user name to query. To retrieve the default user settings for the RD Session /// Host server, set this parameter to NULL. /// /// Windows Server 2008 and Windows Vista: Setting this parameter to NULL returns an error. /// /// /// Specifies the type of information to retrieve. This parameter can be one of the values from the WTS_CONFIG_CLASS enumeration /// type. The documentation for WTS_CONFIG_CLASS describes the format of the data returned in ppBuffer for each of the /// information types. /// /// /// Pointer to a variable that receives a pointer to the requested information. The format and contents of the data depend on the /// information class specified in the WTSConfigClass parameter. To free the returned buffer, call the WTSFreeMemory function. /// /// Pointer to a variable that receives the size, in bytes, of the data returned in ppBuffer. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// /// The WTSQueryUserConfig and WTSSetUserConfig functions are passed a server name instead of a handle because user account /// information often resides on a domain controller. To set user configuration information, use the primary domain controller. You /// can call the NetGetDCName function to get the name of the primary domain controller. To query user configuration information, /// you can use the NetGetAnyDCName function to get the name of a primary or backup domain controller. /// /// /// Any domain controller can set or query user configuration information. Use the DsGetDcName function to retrieve the name of a /// domain controller. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsqueryuserconfiga BOOL WTSQueryUserConfigA( LPSTR // pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR *ppBuffer, DWORD *pBytesReturned ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSQueryUserConfigA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSQueryUserConfig([MarshalAs(UnmanagedType.LPTStr)] string pServerName, [Optional, MarshalAs(UnmanagedType.LPTStr)] string pUserName, WTS_CONFIG_CLASS WTSConfigClass, out SafeWTSMemoryHandle ppBuffer, out uint pBytesReturned); /// /// /// Obtains the primary access token of the logged-on user specified by the session ID. To call this function successfully, the /// calling application must be running within the context of the LocalSystem account and have the SE_TCB_NAME privilege. /// /// /// CautionWTSQueryUserToken is intended for highly trusted services. Service providers must use caution that they do /// not leak user tokens when calling this function. Service providers must close token handles after they have finished using them. /// /// /// /// /// A Remote Desktop Services session identifier. Any program running in the context of a service will have a session identifier of /// zero (0). You can use the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session /// Host server. /// /// /// To be able to query information for another user's session, you need to have the Query Information permission. For more /// information, see Remote Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services /// Configuration administrative tool. /// /// /// /// If the function succeeds, receives a pointer to the token handle for the logged-on user. Note that you must call the CloseHandle /// function to close this handle. /// /// /// /// If the function succeeds, the return value is a nonzero value, and the phToken parameter points to the primary token of the user. /// /// /// If the function fails, the return value is zero. To get extended error information, call GetLastError. Among other errors, /// GetLastError can return one of the following errors. /// /// /// /// /// For information about primary tokens, see Access Tokens. For more information about account privileges, see Remote Desktop /// Services Permissions and Authorization Constants. /// /// See LocalSystem account for information about the privileges associated with that account. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsqueryusertoken BOOL WTSQueryUserToken( ULONG // SessionId, PHANDLE phToken ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSQueryUserToken")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSQueryUserToken(uint SessionId, out HTOKEN phToken); /// Registers the specified window to receive session change notifications. /// Handle of the window to receive session change notifications. /// /// Specifies which session notifications are to be received. This parameter can be one of the following values. /// 0 - NOTIFY_FOR_THIS_SESSION /// /// Only session notifications involving the session attached to by the window identified by the hWnd parameter value are to be received. /// /// 1 - NOTIFY_FOR_ALL_SESSIONS /// All session notifications are to be received. /// /// /// If the function succeeds, the return value is TRUE. Otherwise, it is FALSE. To get extended error information, /// call GetLastError. /// /// /// /// If this function is called before the dependent services of Remote Desktop Services have started, an /// RPC_S_INVALID_BINDING error code may be returned. When the Global\TermSrvReadyEvent global event is set, all dependent /// services have started and this function can be successfully called. /// /// /// Session change notifications are sent in the form of a WM_WTSSESSION_CHANGE message. These notifications are sent only to the /// windows that have registered for them using this function. /// /// /// When a window no longer requires these notifications, it must call WTSUnRegisterSessionNotification before being destroyed. For /// every call to this function, there must be a corresponding call to WTSUnRegisterSessionNotification. /// /// If the window handle passed in this function is already registered, the value of the dwFlags parameter is ignored. /// To receive session change notifications from a service, use the HandlerEx function. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsregistersessionnotification BOOL // WTSRegisterSessionNotification( HWND hWnd, DWORD dwFlags ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSRegisterSessionNotification")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSRegisterSessionNotification(HWND hWnd, uint dwFlags); /// Registers the specified window to receive session change notifications. /// Handle of the server returned from WTSOpenServer or WTS_CURRENT_SERVER. /// Handle of the window to receive session change notifications. /// /// /// Specifies which session notifications are to be received. This parameter can only be NOTIFY_FOR_THIS_SESSION if hServer /// is a remote server. /// /// /// NOTIFY_FOR_THIS_SESSION (0) /// /// Only session notifications involving the session attached to by the window identified by the hWnd parameter value are to be received. /// /// /// NOTIFY_FOR_ALL_SESSIONS (1) /// All session notifications are to be received. /// /// /// /// /// If the function succeeds, the return value is TRUE. Otherwise, it is FALSE. To get extended error information, /// call GetLastError. /// /// /// /// If this function is called before the dependent services of Remote Desktop Services have started, an /// RPC_S_INVALID_BINDING error code may be returned. When the "Global\TermSrvReadyEvent" global event is set, all dependent /// services have started and this function can be successfully called. /// /// /// Session change notifications are sent in the form of a WM_WTSSESSION_CHANGE message. These notifications are sent only to the /// windows that have registered for them using this function. /// /// /// When a window no longer requires these notifications, it must call WTSUnRegisterSessionNotificationEx before being destroyed. /// For every call to this function, there must be a corresponding call to WTSUnRegisterSessionNotificationEx. /// /// If the window handle passed in this function is already registered, the value of the dwFlags parameter is ignored. /// To receive session change notifications from a service, use the HandlerEx function. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsregistersessionnotificationex BOOL // WTSRegisterSessionNotificationEx( HANDLE hServer, HWND hWnd, DWORD dwFlags ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSRegisterSessionNotificationEx")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSRegisterSessionNotificationEx(HWTSSERVER hServer, HWND hWnd, uint dwFlags); /// Displays a message box on the client desktop of a specified Remote Desktop Services session. /// /// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the RD Session Host server on which your application is running. /// /// /// /// A Remote Desktop Services session identifier. To indicate the current session, specify WTS_CURRENT_SESSION. You can use /// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server. /// /// /// To send a message to another user's session, you need to have the Message permission. For more information, see Remote Desktop /// Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration administrative tool. /// /// /// A pointer to a null-terminated string for the title bar of the message box. /// The length, in bytes, of the title bar string. /// A pointer to a null-terminated string that contains the message to display. /// The length, in bytes, of the message string. /// /// The contents and behavior of the message box. This value is typically MB_OK. For a complete list of values, see the uType /// parameter of the MessageBox function. /// /// /// The time, in seconds, that the WTSSendMessage function waits for the user's response. If the user does not respond within /// the time-out interval, the pResponse parameter returns IDTIMEOUT. If the Timeout parameter is zero, WTSSendMessage /// waits indefinitely for the user to respond. /// /// /// A pointer to a variable that receives the user's response, which can be one of the following values. /// IDABORT (3) /// Abort /// IDCANCEL (2) /// Cancel /// IDCONTINUE (11) /// Continue /// IDIGNORE (5) /// Ignore /// IDNO (7) /// No /// IDOK (1) /// OK /// IDRETRY (4) /// Retry /// IDTRYAGAIN (10) /// Try Again /// IDYES (6) /// Yes /// IDASYNC (32001 (0x7D01)) /// The bWait parameter was FALSE, so the function returned without waiting for a response. /// IDTIMEOUT (32000 (0x7D00)) /// The bWait parameter was TRUE and the time-out interval elapsed. /// /// /// /// If TRUE, WTSSendMessage does not return until the user responds or the time-out interval elapses. If the Timeout /// parameter is zero, the function does not return until the user responds. /// /// /// If FALSE, the function returns immediately and the pResponse parameter returns IDASYNC. Use this method for simple /// information messages (such as print job–notification messages) that do not need to return the user's response to the calling program. /// /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtssendmessagea BOOL WTSSendMessageA( HANDLE hServer, // DWORD SessionId, LPSTR pTitle, DWORD TitleLength, LPSTR pMessage, DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD // *pResponse, BOOL bWait ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSSendMessageA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSSendMessage(HWTSSERVER hServer, uint SessionId, [MarshalAs(UnmanagedType.LPTStr)] string pTitle, int TitleLength, [MarshalAs(UnmanagedType.LPTStr)] string pMessage, int MessageLength, uint Style, uint Timeout, out uint pResponse, [MarshalAs(UnmanagedType.Bool)] bool bWait); /// Configures the security descriptor of a Remote Desktop Services listener. /// A handle to an RD Session Host server. Always set this parameter to WTS_CURRENT_SERVER_HANDLE. /// This parameter is reserved. Always set this parameter to NULL. /// This parameter is reserved. Always set this parameter to zero. /// A pointer to a null-terminated string that contains the name of the listener. /// /// /// A SECURITY_INFORMATION value that specifies the security information to set. Always enable the DACL_SECURITY_INFORMATION /// and SACL_SECURITY_INFORMATION flags. /// /// For more information about possible values, see SECURITY_INFORMATION. /// /// /// /// A pointer to a SECURITY_DESCRIPTOR structure that contains the security information associated with the listener. For more /// information about possible values, see SECURITY_DESCRIPTOR. For information about STANDARD_RIGHTS_REQUIRED, see /// Standard Access Rights. /// /// The discretionary access control list (DACL) of the security descriptor can contain one or more of the following values. /// WTS_SECURITY_ALL_ACCESS /// Combines these values: /// /// /// STANDARD_RIGHTS_REQUIRED /// /// /// WTS_SECURITY_CONNECT /// /// /// WTS_SECURITY_DISCONNECT /// /// /// WTS_SECURITY_LOGON /// /// /// WTS_SECURITY_MESSAGE /// /// /// WTS_SECURITY_QUERY_INFORMATION /// /// /// WTS_SECURITY_REMOTE_CONTROL /// /// /// WTS_SECURITY_RESET /// /// /// WTS_SECURITY_SET_INFORMATION /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS /// /// /// WTS_SECURITY_CONNECT (256 (0x100)) /// The right to connect. /// WTS_SECURITY_CURRENT_GUEST_ACCESS /// Combines these values: /// /// /// WTS_SECURITY_LOGOFF /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS /// /// /// WTS_SECURITY_CURRENT_USER_ACCESS /// Combines these values: /// /// /// WTS_SECURITY_DISCONNECT /// /// /// WTS_SECURITY_LOGOFF /// /// /// WTS_SECURITY_RESET /// /// /// WTS_SECURITY_SET_INFORMATION /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS /// /// /// WTS_SECURITY_DISCONNECT (512 (0x200)) /// The right to disconnect. /// WTS_SECURITY_GUEST_ACCESS /// Defined as WTS_SECURITY_LOGON. /// WTS_SECURITY_LOGOFF (64 (0x40)) /// The right to log off. /// WTS_SECURITY_LOGON (32 (0x20)) /// The right to log on. /// WTS_SECURITY_MESSAGE (128 (0x80)) /// The right to send a message to the user. /// WTS_SECURITY_QUERY_INFORMATION (1 (0x1)) /// The right to query for information. /// WTS_SECURITY_REMOTE_CONTROL (16 (0x10)) /// The right to use remote control. /// WTS_SECURITY_RESET (4 (0x4)) /// The right to reset information. /// WTS_SECURITY_SET_INFORMATION (2 (0x2)) /// The right to set information. /// WTS_SECURITY_USER_ACCESS /// Combines these values: /// /// /// WTS_SECURITY_CONNECT /// /// /// WTS_SECURITY_CURRENT_GUEST_ACCESS /// /// /// WTS_SECURITY_QUERY_INFORMATION /// /// /// WTS_SECURITY_VIRTUAL_CHANNELS (8 (0x8)) /// The right to use virtual channels. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call the GetLastError function. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtssetlistenersecuritya BOOL WTSSetListenerSecurityA( // HANDLE hServer, PVOID pReserved, DWORD Reserved, LPSTR pListenerName, SECURITY_INFORMATION SecurityInformation, // PSECURITY_DESCRIPTOR pSecurityDescriptor ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSSetListenerSecurityA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSSetListenerSecurity(HWTSSERVER hServer, [In, Optional] IntPtr pReserved, [In, Optional] uint Reserved, [MarshalAs(UnmanagedType.LPTStr)] string pListenerName, SECURITY_INFORMATION SecurityInformation, [In] PSECURITY_DESCRIPTOR pSecurityDescriptor); /// /// Modifies configuration information for the specified user on the specified domain controller or Remote Desktop Session Host (RD /// Session Host) server. /// /// /// Pointer to a null-terminated string containing the name of a domain controller or RD Session Host server. Specify /// WTS_CURRENT_SERVER_NAME to indicate the RD Session Host server on which your application is running. /// /// Pointer to a null-terminated string containing the name of the user whose configuration is being set. /// /// Specifies the type of information to set for the user. This parameter can be one of the values from the WTS_CONFIG_CLASS /// enumeration type. The documentation for WTS_CONFIG_CLASS describes the format of the data specified in ppBuffer for each /// of the information types. /// /// Pointer to the data used to modify the specified user's configuration. /// Size, in TCHARs, of the pBuffer buffer. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// /// The WTSQueryUserConfig and WTSSetUserConfig functions are passed a server name instead of a handle because user account /// information often resides on a domain controller. To set user configuration information, use the primary domain controller. You /// can call the NetGetDCName function to get the name of the primary domain controller. To query user configuration information, /// you can use the NetGetAnyDCName function to get the name of a primary or backup domain controller. /// /// /// Any domain controller can set or query user configuration information. Use the DsGetDcName function to retrieve the name of a /// domain controller. /// /// /// If the value of the WTSConfigClass parameter corresponds to an integer value in the WTS_CONFIG_CLASS enumeration, define the /// value to be set as a DWORD. Then cast the value to an LPWSTR in the call to WTSSetUserConfig, as in the /// following example: /// /// /// WTSSetUserConfig( strServer.GetBuffer(0), m_strName.GetBuffer(0), WTSUserConfigfAllowLogonTerminalServer, (LPWSTR) &dwEnable, sizeof(DWORD)); /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtssetuserconfiga BOOL WTSSetUserConfigA( LPSTR // pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer, DWORD DataLength ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSSetUserConfigA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSSetUserConfig([MarshalAs(UnmanagedType.LPTStr)] string pServerName, [MarshalAs(UnmanagedType.LPTStr)] string pUserName, WTS_CONFIG_CLASS WTSConfigClass, [MarshalAs(UnmanagedType.LPTStr)] string pBuffer, int DataLength); /// /// Shuts down (and optionally restarts) the specified Remote Desktop Session Host (RD Session Host) server. /// /// To shut down or restart the system, the calling process must have the SE_SHUTDOWN_NAME privilege enabled. For more /// information about security privileges, see Privileges and Authorization Constants. /// /// /// /// Handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify /// WTS_CURRENT_SERVER_HANDLE to indicate the RD Session Host server on which your application is running. /// /// /// Indicates the type of shutdown. This parameter can be one of the following values. /// WTS_WSD_LOGOFF /// /// Forces all client sessions to log off (except the session calling WTSShutdownSystem) and disables any subsequent remote /// logons. This can be used as a step before shutting down. Logons will be re-enabled when the Remote Desktop Services service is restarted. /// /// Use this value only on the Remote Desktop Services console. /// WTS_WSD_POWEROFF /// /// Shuts down the system on the RD Session Host server and, on computers that support software control of AC power, turns off the /// power. This is equivalent to calling ExitWindowsEx with EWX_SHUTDOWN and EWX_POWEROFF. The calling process must /// have the SE_SHUTDOWN_NAME privilege enabled. /// /// WTS_WSD_REBOOT /// /// Shuts down and then restarts the system on the RD Session Host server. This is equivalent to calling ExitWindowsEx with /// EWX_REBOOT. The calling process must have the SE_SHUTDOWN_NAME privilege enabled. /// /// WTS_WSD_SHUTDOWN /// /// Shuts down the system on the RD Session Host server. This is equivalent to calling the ExitWindowsEx function with /// EWX_SHUTDOWN. The calling process must have the SE_SHUTDOWN_NAME privilege enabled. /// /// WTS_WSD_FASTREBOOT /// This value is not supported currently. /// /// /// If the function succeeds, the return value is nonzero. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// A system shutdown terminates all users and active programs. The following steps occur during shutdown. /// /// /// An exit command is issued to all active user applications. /// /// /// If the application does not exit within a specific interval, the application is terminated. /// /// /// After all the applications for a user terminate, the user is logged off. /// /// /// After all users are logged off, an exit command is issued to all system services. /// /// /// If the system service does not terminate within a specific interval, the service is terminated. /// /// /// The file system cache is written to disk. /// /// /// The disks are marked read-only. /// /// /// /// The RD Session Host server displays the message "It is now safe to turn off your computer", or the system is restarted if /// WTS_WSD_REBOOT is specified. (The message is displayed on the console because all client sessions have been terminated.) /// /// /// /// /// Note Because there can be many users and processes in a large multiple-user configuration, large system configurations /// may take some time to shut down in an orderly fashion. It is important to allow the system to shut down completely. /// /// /// Windows Server 2008 and Windows Vista: A call to WTSShutdownSystem does not work when Remote Connection Manager /// (RCM) is disabled. This is the case when the Remote Desktop Services service is stopped. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsshutdownsystem BOOL WTSShutdownSystem( HANDLE hServer, // DWORD ShutdownFlag ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSShutdownSystem")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSShutdownSystem(HWTSSERVER hServer, WTS_WSD ShutdownFlag); /// /// Starts the remote control of another Remote Desktop Services session. You must call this function from a remote session. /// /// A pointer to the name of the server where the session that you want remote control of exists. /// The logon ID of the session that you want remote control of. /// /// The virtual-key code that represents the key to press to stop remote control of the session. The key that is defined in this /// parameter is used with the HotkeyModifiers parameter. /// /// /// /// The virtual modifier that represents the key to press to stop remote control of the session. The virtual modifier is used with /// the HotkeyVk parameter. /// /// /// For example, if the WTSStartRemoteControlSession function is called with HotkeyVk set to VK_MULTIPLY and /// HotkeyModifiers set to REMOTECONTROL_KBDCTRL_HOTKEY, the user who has remote control of the target session can press CTRL /// + * to stop remote control of the session and return to their own session. /// /// REMOTECONTROL_KBDSHIFT_HOTKEY /// The SHIFT key /// REMOTECONTROL_KBDCTRL_HOTKEY /// The CTRL key /// REMOTECONTROL_KBDALT_HOTKEY /// The ALT key /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsstartremotecontrolsessiona BOOL // WTSStartRemoteControlSessionA( LPSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers ); [DllImport(Lib_WTSApi32, SetLastError = true, CharSet = CharSet.Auto)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSStartRemoteControlSessionA")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSStartRemoteControlSession([MarshalAs(UnmanagedType.LPTStr)] string pTargetServerName, uint TargetLogonId, byte HotkeyVk, REMOTECONTROL_HOTKEY HotkeyModifiers); /// Stops a remote control session. /// The logon ID of the session that you want to stop the remote control of. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsstopremotecontrolsession BOOL // WTSStopRemoteControlSession( ULONG LogonId ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSStopRemoteControlSession")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSStopRemoteControlSession(uint LogonId); /// Terminates the specified process on the specified Remote Desktop Session Host (RD Session Host) server. /// /// Handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify WTS_CURRENT_SERVER_HANDLE /// to indicate the RD Session Host server on which your application is running. /// /// Specifies the process identifier of the process to terminate. /// Specifies the exit code for the terminated process. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsterminateprocess BOOL WTSTerminateProcess( HANDLE // hServer, DWORD ProcessId, DWORD ExitCode ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSTerminateProcess")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSTerminateProcess(HWTSSERVER hServer, uint ProcessId, uint ExitCode); /// Unregisters the specified window so that it receives no further session change notifications. /// Handle of the window to be unregistered from receiving session notifications. /// /// If the function succeeds, the return value is TRUE. Otherwise, it is FALSE. To get extended error information, /// call GetLastError. /// /// This function must be called once for every call to the WTSRegisterSessionNotification function. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsunregistersessionnotification BOOL // WTSUnRegisterSessionNotification( HWND hWnd ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSUnRegisterSessionNotification")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSUnRegisterSessionNotification(HWND hWnd); /// Unregisters the specified window so that it receives no further session change notifications. /// Handle of the server returned from WTSOpenServer or WTS_CURRENT_SERVER. /// Handle of the window to be unregistered from receiving session notifications. /// /// If the function succeeds, the return value is TRUE. Otherwise, it is FALSE. To get extended error information, /// call GetLastError. /// /// This function must be called once for every call to the WTSRegisterSessionNotificationEx function. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsunregistersessionnotificationex BOOL // WTSUnRegisterSessionNotificationEx( HANDLE hServer, HWND hWnd ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSUnRegisterSessionNotificationEx")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSUnRegisterSessionNotificationEx(HWTSSERVER hServer, HWND hWnd); /// Closes an open virtual channel handle. /// Handle to a virtual channel opened by the WTSVirtualChannelOpen function. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelclose BOOL WTSVirtualChannelClose( // HANDLE hChannelHandle ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelClose")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSVirtualChannelClose(HVIRTUALCHANNEL hChannelHandle); /// /// Opens a handle to the server end of a specified virtual channel. /// This function is obsolete. Instead, use the WTSVirtualChannelOpenEx function. /// /// This parameter must be WTS_CURRENT_SERVER_HANDLE. /// /// /// A Remote Desktop Services session identifier. To indicate the current session, specify WTS_CURRENT_SESSION. You can use /// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server. /// /// /// To open a virtual channel on another user's session, you need to have permission from the Virtual Channel. For more information, /// see Remote Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services Configuration /// administrative tool. /// /// /// /// A pointer to a null-terminated string containing the virtual channel name. Note that this is an ANSI string even when /// UNICODE is defined. The virtual channel name consists of one to CHANNEL_NAME_LEN characters, not including the terminating null. /// /// /// If the function succeeds, the return value is a handle to the specified virtual channel. /// If the function fails, the return value is NULL. To get extended error information, call GetLastError. /// /// /// When you have finished using the handle, release it by calling the WTSVirtualChannelClose function. /// /// For an example that shows how to gain access to a virtual channel file handle that can be used for asynchronous I/O, see WTSVirtualChannelQuery. /// /// /// If you try to use this function to open the same virtual channel multiple times, it can cause a 10-second delay and disrupt the /// established channel. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelopen HANDLE WTSVirtualChannelOpen( // HANDLE hServer, DWORD SessionId, LPSTR pVirtualName ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelOpen")] public static extern SafeHVIRTUALCHANNEL WTSVirtualChannelOpen(HWTSSERVER hServer, uint SessionId, [MarshalAs(UnmanagedType.LPStr)] string pVirtualName); /// /// Creates a virtual channel in a manner similar to WTSVirtualChannelOpen. /// /// This API supports both static virtual channel (SVC) and dynamic virtual channel (DVC) creation. If the flags parameter is zero, /// it behaves the same as WTSVirtualChannelOpen. A DVC can be opened by specifying the appropriate flag. After a DVC is created, /// you can use the same functions for Read, Write, Query, or Close that are used for the SVC. /// /// /// /// /// A Remote Desktop Services session identifier. To indicate the current session, specify WTS_CURRENT_SESSION. You can use /// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server. /// /// /// To be able to open a virtual channel on another user's session, you must have the Virtual Channels permission. For more /// information, see Remote Desktop Services Permissions. To modify permissions on a session, use the Remote Desktop Services /// Configuration administrative tool. /// /// /// /// /// In the case of an SVC, points to a null-terminated string that contains the virtual channel name. The length of an SVC name is /// limited to CHANNEL_NAME_LEN characters, not including the terminating null. /// /// /// In the case of a DVC, points to a null-terminated string that contains the endpoint name of the listener. The length of a DVC /// name is limited to MAX_PATH characters. /// /// /// /// To open the channel as an SVC, specify zero for this parameter. To open the channel as a DVC, specify WTS_CHANNEL_OPTION_DYNAMIC. /// /// When opening a DVC, you can specify a priority setting for the data that is being transferred by specifying one of the /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_XXX values in combination with the WTS_CHANNEL_OPTION_DYNAMIC value. /// /// /// /// WTS_CHANNEL_OPTION_DYNAMIC_NO_COMPRESS
Disables compression for this DVC. You must specify this value in /// combination with the WTS_CHANNEL_OPTION_DYNAMIC value. /// /// /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_LOW (default)
Low priority. The data will be sent on both sides with low /// priority. Use this priority level for block transfers of all sizes, where the transfer speed is not important. In almost all /// (95%) cases, the channel should be opened with this flag. /// /// /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_MED
Medium priority. Use this priority level to send short control messages /// that must have priority over the data in the low priority channels. /// /// /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_HIGH
High priority. Use this priority level for data that is critical and /// directly affects the user experience. The transfer size may vary. Display data falls into this category. /// /// /// WTS_CHANNEL_OPTION_DYNAMIC_PRI_REAL
Real-time priority. Use this priority level only in cases where the /// data transfer is absolutely critical. The data transfer size should be limited to a few hundred bytes per message. /// /// /// /// NULL on error with GetLastError set. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelopenex HANDLE WTSVirtualChannelOpenEx( // DWORD SessionId, LPSTR pVirtualName, DWORD flags ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelOpenEx")] public static extern SafeHVIRTUALCHANNEL WTSVirtualChannelOpenEx(uint SessionId, [MarshalAs(UnmanagedType.LPStr)] string pVirtualName, WTS_CHANNEL_OPTION flags); /// Deletes all queued input data sent from the client to the server on a specified virtual channel. /// Handle to a virtual channel opened by the WTSVirtualChannelOpen function. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelpurgeinput BOOL // WTSVirtualChannelPurgeInput( HANDLE hChannelHandle ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelPurgeInput")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSVirtualChannelPurgeInput(HVIRTUALCHANNEL hChannelHandle); /// Deletes all queued output data sent from the server to the client on a specified virtual channel. /// Handle to a virtual channel opened by the WTSVirtualChannelOpen function. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelpurgeoutput BOOL // WTSVirtualChannelPurgeOutput( HANDLE hChannelHandle ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelPurgeOutput")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSVirtualChannelPurgeOutput(HVIRTUALCHANNEL hChannelHandle); /// Returns information about a specified virtual channel. /// Handle to a virtual channel opened by the WTSVirtualChannelOpen function. /// Specifies the type of information to get for the channel. /// Pointer to a buffer that receives the requested information. /// Pointer to a variable that receives the number of bytes returned in the ppBuffer parameter. /// /// /// If the function succeeds, the return value is a nonzero value. Call the WTSFreeMemory function with the value returned in the /// ppBuffer parameter to free the temporary memory allocated by WTSVirtualChannelQuery. /// /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// /// The following example shows how to gain access to a virtual channel file handle that can be used for asynchronous I/O. First the /// code opens a virtual channel by using a call to the WTSVirtualChannelOpen function. Then the code calls the /// WTSVirtualChannelQuery function, specifying the WTSVirtualFileHandle virtual class type. WTSVirtualChannelQuery /// returns a file handle that you can use to perform asynchronous (overlapped) read and write operations. Finally, the code frees /// the memory allocated by WTSVirtualChannelQuery with a call to the WTSFreeMemory function, and closes the virtual channel /// with a call to the WTSVirtualChannelClose function. /// /// /// Note that you should not explicitly close the file handle obtained by calling WTSVirtualChannelQuery. This is because /// WTSVirtualChannelClose closes the file handle. /// /// /// PVOID vcFileHandlePtr = NULL; DWORD len; DWORD result = ERROR_SUCCESS; HANDLE vcHandle = NULL; HANDLE vcFileHandle = NULL; // // Open a virtual channel. // vcHandle = WTSVirtualChannelOpen( WTS_CURRENT_SERVER_HANDLE, // Current TS Server WTS_CURRENT_SESSION, // Current TS Session (LPSTR) "TSTCHNL" // Channel name ); if (vcHandle == NULL) { result = GetLastError(); } // // Gain access to the underlying file handle for // asynchronous I/O. // if (result == ERROR_SUCCESS) { if (!WTSVirtualChannelQuery( vcHandle, WTSVirtualFileHandle, &vcFileHandlePtr, &len )) { result = GetLastError(); } } // // Copy the data and // free the buffer allocated by WTSVirtualChannelQuery. // if (result == ERROR_SUCCESS) { memcpy(&vcFileHandle, vcFileHandlePtr, sizeof(vcFileHandle)); WTSFreeMemory(vcFileHandlePtr); // // Use vcFileHandle for overlapped reads and writes here. // //. //. //. } // // Call WTSVirtualChannelClose to close the virtual channel. // Note: do not close the file handle. // if (vcHandle != NULL) { WTSVirtualChannelClose(vcHandle); vcFileHandle = NULL; } /// /// For more information about overlapped mode, see Synchronization and Overlapped Input and Output. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelquery BOOL WTSVirtualChannelQuery( // HANDLE hChannelHandle, WTS_VIRTUAL_CLASS , PVOID *ppBuffer, DWORD *pBytesReturned ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelQuery")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSVirtualChannelQuery(HVIRTUALCHANNEL hChannelHandle, WTS_VIRTUAL_CLASS WTSVirtualClass, out SafeWTSMemoryHandle ppBuffer, out uint pBytesReturned); /// /// Reads data from the server end of a virtual channel. /// WTSVirtualChannelRead reads the data written by a VirtualChannelWrite call at the client end of the virtual channel. /// /// Handle to a virtual channel opened by the WTSVirtualChannelOpen function. /// /// Specifies the time-out, in milliseconds. If TimeOut is zero, WTSVirtualChannelRead returns immediately if there is no /// data to read. If TimeOut is INFINITE (defined in Winbase.h), the function waits indefinitely until there is data to read. /// /// /// /// Pointer to a buffer that receives a chunk of data read from the server end of the virtual channel. The maximum amount of data /// that the server can receive in a single WTSVirtualChannelRead call is CHANNEL_CHUNK_LENGTH bytes. If the client's /// VirtualChannelWrite call writes a larger block of data, the server must make multiple WTSVirtualChannelRead calls. /// /// /// In certain cases, Remote Desktop Services places a CHANNEL_PDU_HEADER structure at the beginning of each chunk of data /// read by the WTSVirtualChannelRead function. This will occur if the client DLL sets the /// CHANNEL_OPTION_SHOW_PROTOCOL option when it calls the VirtualChannelInit function to initialize the virtual channel. This /// will also occur if the channel is a dynamic virtual channel written to by using the IWTSVirtualChannel::Write method. Otherwise, /// the buffer receives only the data written in the VirtualChannelWrite call. /// /// /// /// Specifies the size, in bytes, of Buffer. If the chunk of data in Buffer will be preceded by a CHANNEL_PDU_HEADER /// structure, the value of this parameter should be at least CHANNEL_PDU_LENGTH. Otherwise, the value of this parameter /// should be at least CHANNEL_CHUNK_LENGTH. /// /// Pointer to a variable that receives the number of bytes read. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// NoteWTSVirtualChannelRead is not thread safe. To access a virtual channel from multiple threads, or to do /// asynchronous IO through a virtual channel, use WTSVirtualChannelQuery with WTSVirtualFileHandle. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelread BOOL WTSVirtualChannelRead( HANDLE // hChannelHandle, ULONG TimeOut, PCHAR Buffer, ULONG BufferSize, PULONG pBytesRead ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelRead")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSVirtualChannelRead(HVIRTUALCHANNEL hChannelHandle, uint TimeOut, [Out, MarshalAs(UnmanagedType.LPStr)] StringBuilder Buffer, uint BufferSize, out uint pBytesRead); /// Writes data to the server end of a virtual channel. /// Handle to a virtual channel opened by the WTSVirtualChannelOpen function. /// Pointer to a buffer containing the data to write to the virtual channel. /// Specifies the size, in bytes, of the data to write. /// Pointer to a variable that receives the number of bytes written. /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// /// /// NoteWTSVirtualChannelWrite is not thread safe. To access a virtual channel from multiple threads, or to do /// asynchronous IO through a virtual channel, use WTSVirtualChannelQuery with WTSVirtualFileHandle. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsvirtualchannelwrite BOOL WTSVirtualChannelWrite( // HANDLE hChannelHandle, PCHAR Buffer, ULONG Length, PULONG pBytesWritten ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelWrite")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSVirtualChannelWrite(HVIRTUALCHANNEL hChannelHandle, [MarshalAs(UnmanagedType.LPStr)] string Buffer, uint Length, out uint pBytesWritten); /// Waits for a Remote Desktop Services event before returning to the caller. /// /// Handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify WTS_CURRENT_SERVER_HANDLE /// to indicate the RD Session Host server on which your application is running. /// /// /// /// Bitmask that specifies the set of events to wait for. This mask can be WTS_EVENT_FLUSH to cause all pending /// WTSWaitSystemEvent calls on the specified RD Session Host server handle to return. Or, the mask can be a combination of /// the following values. /// /// WTS_EVENT_ALL /// Wait for any event type. /// WTS_EVENT_CONNECT /// A client connected to a WinStation. /// WTS_EVENT_CREATE /// A new WinStation was created. /// WTS_EVENT_DELETE /// An existing WinStation was deleted. /// WTS_EVENT_DISCONNECT /// A client disconnected from a WinStation. /// WTS_EVENT_LICENSE /// The Remote Desktop Services' license state changed. This occurs when a license is added or deleted using License Manager. /// WTS_EVENT_LOGOFF /// A user logged off from either the Remote Desktop Services console or from a client WinStation. /// WTS_EVENT_LOGON /// A user logged on to the system from either the Remote Desktop Services console or from a client WinStation. /// WTS_EVENT_RENAME /// An existing WinStation was renamed. /// WTS_EVENT_STATECHANGE /// A WinStation connection state changed. For a list of connection states, see the WTS_CONNECTSTATE_CLASS enumeration type. /// /// /// Pointer to a variable that receives a bitmask of the event or events that occurred. The returned mask can be a combination of /// the values from the previous list, or it can be WTS_EVENT_NONE if the wait terminated because of a /// WTSWaitSystemEvent call with WTS_EVENT_FLUSH. /// /// /// If the function succeeds, the return value is a nonzero value. /// If the function fails, the return value is zero. To get extended error information, call GetLastError. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtswaitsystemevent BOOL WTSWaitSystemEvent( HANDLE // hServer, DWORD EventMask, DWORD *pEventFlags ); [DllImport(Lib_WTSApi32, SetLastError = true, ExactSpelling = true)] [PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSWaitSystemEvent")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool WTSWaitSystemEvent(HVIRTUALCHANNEL hServer, WTS_EVENT EventMask, out WTS_EVENT pEventFlags); /// Provides a handle to a virtual channel. [StructLayout(LayoutKind.Sequential)] public struct HVIRTUALCHANNEL : IHandle { private readonly IntPtr handle; /// Initializes a new instance of the struct. /// An object that represents the pre-existing handle to use. public HVIRTUALCHANNEL(IntPtr preexistingHandle) => handle = preexistingHandle; /// Returns an invalid handle by instantiating a object with . public static HVIRTUALCHANNEL NULL => new HVIRTUALCHANNEL(IntPtr.Zero); /// Gets a value indicating whether this instance is a null handle. public bool IsNull => handle == IntPtr.Zero; /// Performs an explicit conversion from to . /// The handle. /// The result of the conversion. public static explicit operator IntPtr(HVIRTUALCHANNEL h) => h.handle; /// Performs an implicit conversion from to . /// The pointer to a handle. /// The result of the conversion. public static implicit operator HVIRTUALCHANNEL(IntPtr h) => new HVIRTUALCHANNEL(h); /// Implements the operator !=. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(HVIRTUALCHANNEL h1, HVIRTUALCHANNEL h2) => !(h1 == h2); /// Implements the operator ==. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(HVIRTUALCHANNEL h1, HVIRTUALCHANNEL h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is HVIRTUALCHANNEL h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } /// Provides a handle to a WTS server. [StructLayout(LayoutKind.Sequential)] public struct HWTSSERVER : IHandle { private readonly IntPtr handle; /// Initializes a new instance of the struct. /// An object that represents the pre-existing handle to use. public HWTSSERVER(IntPtr preexistingHandle) => handle = preexistingHandle; /// Returns an invalid handle by instantiating a object with . public static readonly HWTSSERVER NULL = new HWTSSERVER(IntPtr.Zero); /// A constant representing the handle of the current WTS server. public static readonly HWTSSERVER WTS_CURRENT_SERVER_HANDLE = NULL; /// A constant representing the handle of the current WTS server. public static readonly HWTSSERVER WTS_CURRENT_SERVER = NULL; /// Gets a value indicating whether this instance is a null handle. public bool IsNull => handle == IntPtr.Zero; /// Performs an explicit conversion from to . /// The handle. /// The result of the conversion. public static explicit operator IntPtr(HWTSSERVER h) => h.handle; /// Performs an implicit conversion from to . /// The pointer to a handle. /// The result of the conversion. public static implicit operator HWTSSERVER(IntPtr h) => new HWTSSERVER(h); /// Implements the operator !=. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(HWTSSERVER h1, HWTSSERVER h2) => !(h1 == h2); /// Implements the operator ==. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(HWTSSERVER h1, HWTSSERVER h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is HWTSSERVER h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } /// Contains the client network address of a Remote Desktop Services session. /// /// /// The client network address is reported by the RDP client itself when it connects to the server. This could be different than the /// address that actually connected to the server. For example, suppose there is a NAT between the client and the server. The client /// can report its own IP address, but the IP address that actually connects to the server is the NAT address. For VPN connections, /// the IP address might not be discoverable by the client. If it cannot be discovered, the client can report the only IP address it /// has, which may be the ISP assigned address. Because the address may not be the actual network address, it should not be used as /// a form of client authentication. /// /// The client network address is also not available in the following cases: /// /// /// The connection is established through a Remote Desktop Gateway. /// /// /// The connection is originated by the Microsoft Remote Desktop app that is available in the Store. /// /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_client_address typedef struct _WTS_CLIENT_ADDRESS { // DWORD AddressFamily; BYTE Address[20]; } WTS_CLIENT_ADDRESS, *PWTS_CLIENT_ADDRESS; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_CLIENT_ADDRESS")] [StructLayout(LayoutKind.Sequential)] public struct WTS_CLIENT_ADDRESS { /// Address family. This member can be AF_INET, AF_INET6, AF_IPX, AF_NETBIOS, or AF_UNSPEC. public uint AddressFamily; /// /// /// Client network address. The format of the field of Address depends on the address type as specified by the /// AddressFamily member. /// /// /// For an address family AF_INET: Address contains the IPV4 address of the client as a null-terminated string. /// /// /// For an family AF_INET6: Address contains the IPV6 address of the client as raw byte values. (For example, the /// address "FFFF::1" would be represented as the following series of byte values: "0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 /// 0x00 0x00 0x00 0x00 0x00 0x00 0x01") /// /// [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] public byte[] Address; } /// Contains information about the display of a Remote Desktop Connection (RDC) client. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_client_display typedef struct _WTS_CLIENT_DISPLAY { // DWORD HorizontalResolution; DWORD VerticalResolution; DWORD ColorDepth; } WTS_CLIENT_DISPLAY, *PWTS_CLIENT_DISPLAY; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_CLIENT_DISPLAY")] [StructLayout(LayoutKind.Sequential)] public struct WTS_CLIENT_DISPLAY { /// Horizontal dimension, in pixels, of the client's display. public uint HorizontalResolution; /// Vertical dimension, in pixels, of the client's display. public uint VerticalResolution; /// /// Color depth of the client's display. This member can be one of the following values. /// 1 /// 4 bits per pixel. /// 2 /// 8 bits per pixel. /// 4 /// 16 bits per pixel. /// 8 /// A 3-byte RGB values for a maximum of 2^24 colors. /// 16 /// 15 bits per pixel. /// 24 /// 24 bits per pixel. /// 32 /// 32 bits per pixel. /// public uint ColorDepth; } /// Contains information about a process running on a Remote Desktop Session Host (RD Session Host) server. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_process_infoa typedef struct _WTS_PROCESS_INFOA { // DWORD SessionId; DWORD ProcessId; LPSTR pProcessName; PSID pUserSid; } WTS_PROCESS_INFOA, *PWTS_PROCESS_INFOA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_PROCESS_INFOA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTS_PROCESS_INFO { /// Remote Desktop Services session identifier for the session associated with the process. public uint SessionId; /// Process identifier that uniquely identifies the process on the RD Session Host server. public uint ProcessId; /// Pointer to a null-terminated string containing the name of the executable file associated with the process. [MarshalAs(UnmanagedType.LPTStr)] public string pProcessName; /// /// Pointer to the user Security Identifiers in the process's primary access token. For more information about SIDs and access /// tokens, see Access Control. /// public PSID pUserSid; } /// /// Contains extended information about a process running on a Remote Desktop Session Host (RD Session Host) server. This structure /// is returned by the WTSEnumerateProcessesEx function when you set the pLevel parameter to one. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_process_info_exa typedef struct _WTS_PROCESS_INFO_EXA // { DWORD SessionId; DWORD ProcessId; LPSTR pProcessName; PSID pUserSid; DWORD NumberOfThreads; DWORD HandleCount; DWORD // PagefileUsage; DWORD PeakPagefileUsage; DWORD WorkingSetSize; DWORD PeakWorkingSetSize; LARGE_INTEGER UserTime; LARGE_INTEGER // KernelTime; } WTS_PROCESS_INFO_EXA, *PWTS_PROCESS_INFO_EXA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_PROCESS_INFO_EXA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTS_PROCESS_INFO_EX { /// The Remote Desktop Services session identifier for the session associated with the process. public uint SessionId; /// The process identifier that uniquely identifies the process on the RD Session Host server. public uint ProcessId; /// A pointer to a null-terminated string that contains the name of the executable file associated with the process. [MarshalAs(UnmanagedType.LPTStr)] public string pProcessName; /// /// A pointer to the user security identifiers (SIDs) in the primary access token of the process. For more information about /// SIDs and access tokens, see Access Control and Security Identifiers. /// public PSID pUserSid; /// The number of threads in the process. public uint NumberOfThreads; /// The number of handles in the process. public uint HandleCount; /// The page file usage of the process, in bytes. public uint PagefileUsage; /// The peak page file usage of the process, in bytes. public uint PeakPagefileUsage; /// The working set size of the process, in bytes. public uint WorkingSetSize; /// The peak working set size of the process, in bytes. public uint PeakWorkingSetSize; /// The amount of time, in milliseconds, the process has been running in user mode. public long UserTime; /// The amount of time, in milliseconds, the process has been running in kernel mode. public long KernelTime; } /// Contains information about a specific Remote Desktop Services server. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_server_infoa typedef struct _WTS_SERVER_INFOA { LPSTR // pServerName; } WTS_SERVER_INFOA, *PWTS_SERVER_INFOA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_SERVER_INFOA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTS_SERVER_INFO { /// Name of the server. [MarshalAs(UnmanagedType.LPTStr)] public string pServerName; } /// /// Contains the virtual IP address assigned to a session. This structure is returned by the WTSQuerySessionInformation function /// when you specify "WTSSessionAddressV4" for the WTSInfoClass parameter. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_session_address typedef struct _WTS_SESSION_ADDRESS { // DWORD AddressFamily; BYTE Address[20]; } WTS_SESSION_ADDRESS, *PWTS_SESSION_ADDRESS; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_SESSION_ADDRESS")] [StructLayout(LayoutKind.Sequential)] public struct WTS_SESSION_ADDRESS { /// A null-terminated string that contains the address family. Always set this member to "AF_INET". public uint AddressFamily; /// /// The virtual IP address assigned to the session. The format of this address is identical to that used in the /// WTS_CLIENT_ADDRESS structure. /// [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] public byte[] Address; } /// Contains information about a client session on a Remote Desktop Session Host (RD Session Host) server. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_session_infoa typedef struct _WTS_SESSION_INFOA { // DWORD SessionId; LPSTR pWinStationName; WTS_CONNECTSTATE_CLASS State; } WTS_SESSION_INFOA, *PWTS_SESSION_INFOA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_SESSION_INFOA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTS_SESSION_INFO { /// Session identifier of the session. public uint SessionId; /// /// Pointer to a null-terminated string that contains the WinStation name of this session. The WinStation name is a name that /// Windows associates with the session, for example, "services", "console", or "RDP-Tcp#0". /// [MarshalAs(UnmanagedType.LPTStr)] public string pWinStationName; /// A value from the WTS_CONNECTSTATE_CLASS enumeration type that indicates the session's current connection state. public WTS_CONNECTSTATE_CLASS State; } /// /// Contains extended information about a client session on a Remote Desktop Session Host (RD Session Host) server or Remote Desktop /// Virtualization Host (RD Virtualization Host) server. /// /// /// /// The WTSEnumerateSessionsEx function returns this structure if you call the function and specify a handle to an RD Virtualization /// Host server that you obtained by calling the WTSOpenServerEx function. In this case, the WTSEnumerateSessionsEx function /// aggregates all the sessions running on the host itself as well as sessions running on individual virtual machines. The ExecEnvId /// parameter uniquely identifies each session in the aggregated list. This identifier may be different from the actual session /// identifier defined in the server or virtual machine that hosts the session, which is specified by the SessionId member. /// /// /// The session represented by this structure could be a session running directly on the server or a session running within a /// virtual machine. If the session is running within a virtual machine, the pHostName member contains the name of the /// virtual machine. The pFarmName member is applicable to sessions that are hosted on virtual machines that are joined to a /// RD Session Host farm. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wts_session_info_1a typedef struct _WTS_SESSION_INFO_1A { // DWORD ExecEnvId; WTS_CONNECTSTATE_CLASS State; DWORD SessionId; LPSTR pSessionName; LPSTR pHostName; LPSTR pUserName; LPSTR // pDomainName; LPSTR pFarmName; } WTS_SESSION_INFO_1A, *PWTS_SESSION_INFO_1A; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTS_SESSION_INFO_1A")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTS_SESSION_INFO_1 { /// /// An identifier that uniquely identifies the session within the list of sessions returned by the WTSEnumerateSessionsEx /// function. For more information, see Remarks. /// public uint ExecEnvId; /// /// A value of the WTS_CONNECTSTATE_CLASS enumeration type that specifies the connection state of a Remote Desktop Services session. /// public WTS_CONNECTSTATE_CLASS State; /// A session identifier assigned by the RD Session Host server, RD Virtualization Host server, or virtual machine. public uint SessionId; /// /// A pointer to a null-terminated string that contains the name of this session. For example, "services", "console", or "RDP-Tcp#0". /// [MarshalAs(UnmanagedType.LPTStr)] public string pSessionName; /// /// A pointer to a null-terminated string that contains the name of the computer that the session is running on. If the session /// is running directly on an RD Session Host server or RD Virtualization Host server, the string contains NULL. If the /// session is running on a virtual machine, the string contains the name of the virtual machine. /// [MarshalAs(UnmanagedType.LPTStr)] public string pHostName; /// /// A pointer to a null-terminated string that contains the name of the user who is logged on to the session. If no user is /// logged on to the session, the string contains NULL. /// [MarshalAs(UnmanagedType.LPTStr)] public string pUserName; /// /// A pointer to a null-terminated string that contains the domain name of the user who is logged on to the session. If no user /// is logged on to the session, the string contains NULL. /// [MarshalAs(UnmanagedType.LPTStr)] public string pDomainName; /// /// A pointer to a null-terminated string that contains the name of the farm that the virtual machine is joined to. If the /// session is not running on a virtual machine that is joined to a farm, the string contains NULL. /// [MarshalAs(UnmanagedType.LPTStr)] public string pFarmName; } /// Contains information about a Remote Desktop Connection (RDC) client. /// /// For the ClientAddressFamily member, AF_INET (IPv4) will return in string format, for example "127.0.0.1". /// AF_INET6 (IPv6) will return in binary form. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsclienta typedef struct _WTSCLIENTA { CHAR // ClientName[CLIENTNAME_LENGTH + 1]; CHAR Domain[DOMAIN_LENGTH + 1]; CHAR UserName[USERNAME_LENGTH + 1]; CHAR // WorkDirectory[MAX_PATH + 1]; CHAR InitialProgram[MAX_PATH + 1]; BYTE EncryptionLevel; ULONG ClientAddressFamily; USHORT // ClientAddress[CLIENTADDRESS_LENGTH + 1]; USHORT HRes; USHORT VRes; USHORT ColorDepth; CHAR ClientDirectory[MAX_PATH + 1]; ULONG // ClientBuildNumber; ULONG ClientHardwareId; USHORT ClientProductId; USHORT OutBufCountHost; USHORT OutBufCountClient; USHORT // OutBufLength; CHAR DeviceId[MAX_PATH + 1]; } WTSCLIENTA, *PWTSCLIENTA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSCLIENTA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSCLIENT { /// The NetBIOS name of the client computer. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CLIENTNAME_LENGTH + 1)] public string ClientName; /// The domain name of the client computer. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)] public string Domain; /// The client user name. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)] public string UserName; /// The folder for the initial program. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string WorkDirectory; /// The program to start on connection. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string InitialProgram; /// The security level of encryption. public byte EncryptionLevel; /// /// The address family. This member can be AF_INET, AF_INET6, AF_IPX, AF_NETBIOS, or AF_UNSPEC. /// public uint ClientAddressFamily; /// The client network address. [MarshalAs(UnmanagedType.ByValArray, SizeConst = CLIENTADDRESS_LENGTH + 1)] public ushort[] ClientAddress; /// Horizontal dimension, in pixels, of the client's display. public ushort HRes; /// Vertical dimension, in pixels, of the client's display. public ushort VRes; /// /// Color depth of the client's display. For possible values, see the ColorDepth member of the WTS_CLIENT_DISPLAY structure. /// public ushort ColorDepth; /// The location of the client ActiveX control DLL. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string ClientDirectory; /// The client build number. public uint ClientBuildNumber; /// Reserved. public uint ClientHardwareId; /// Reserved. public ushort ClientProductId; /// The number of output buffers on the server per session. public ushort OutBufCountHost; /// The number of output buffers on the client. public ushort OutBufCountClient; /// The length of the output buffers, in bytes. public ushort OutBufLength; /// The device ID of the network adapter. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string DeviceId; } /// /// Contains information about a Remote Desktop Services session. This structure is returned by the WTSQuerySessionInformation /// function when you specify "WTSConfigInfo" for the WTSInfoClass parameter. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsconfiginfoa typedef struct _WTSCONFIGINFOA { ULONG // version; ULONG fConnectClientDrivesAtLogon; ULONG fConnectPrinterAtLogon; ULONG fDisablePrinterRedirection; ULONG // fDisableDefaultMainClientPrinter; ULONG ShadowSettings; CHAR LogonUserName[USERNAME_LENGTH + 1]; CHAR LogonDomain[DOMAIN_LENGTH + // 1]; CHAR WorkDirectory[MAX_PATH + 1]; CHAR InitialProgram[MAX_PATH + 1]; CHAR ApplicationName[MAX_PATH + 1]; } WTSCONFIGINFOA, *PWTSCONFIGINFOA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSCONFIGINFOA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSCONFIGINFO { /// This member is reserved. public uint version; /// This member is reserved. public uint fConnectClientDrivesAtLogon; /// This member is reserved. public uint fConnectPrinterAtLogon; /// /// Specifies whether the client can use printer redirection. /// 0 /// Enable client printer redirection. /// 1 /// Disable client printer redirection. /// public uint fDisablePrinterRedirection; /// /// Specifies whether the printer connected to the client is the default printer for the user. /// 0 /// The printer connected to the client is not the default printer for the user. /// 1 /// The printer connected to the client is the default printer for the user. /// public uint fDisableDefaultMainClientPrinter; /// /// /// The remote control setting. Remote control allows a user to remotely monitor the on-screen operations of another user. This /// member can be one of the following values. /// /// 0 /// Remote control is disabled. /// 1 /// The user of remote control has full control of the user's session, with the user's permission. /// 2 /// The user of remote control has full control of the user's session; the user's permission is not required. /// 3 /// /// The user of remote control can view the session remotely, with the user's permission; the remote user cannot actively /// control the session. /// /// 4 /// /// The user of remote control can view the session remotely but not actively control the session; the user's permission is not required. /// /// public uint ShadowSettings; /// A null-terminated string that contains the user name used in automatic logon scenarios. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)] public string LogonUserName; /// A null-terminated string that contains the domain name used in automatic logon scenarios. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)] public string LogonDomain; /// A null-terminated string that contains the path of the working directory of the initial program. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string WorkDirectory; /// /// A null-terminated string that contains the name of the program to start immediately after the user logs on to the server. /// [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string InitialProgram; /// This member is reserved. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string ApplicationName; } /// Contains information about a Remote Desktop Services session. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsinfoa typedef struct _WTSINFOA { // WTS_CONNECTSTATE_CLASS State; DWORD SessionId; DWORD IncomingBytes; DWORD OutgoingBytes; DWORD IncomingFrames; DWORD // OutgoingFrames; DWORD IncomingCompressedBytes; DWORD OutgoingCompressedBy; CHAR WinStationName[WINSTATIONNAME_LENGTH]; CHAR // Domain[DOMAIN_LENGTH]; CHAR UserName[USERNAME_LENGTH + 1]; LARGE_INTEGER ConnectTime; LARGE_INTEGER DisconnectTime; LARGE_INTEGER // LastInputTime; LARGE_INTEGER LogonTime; LARGE_INTEGER CurrentTime; } WTSINFOA, *PWTSINFOA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSINFOA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSINFO { /// A value of the WTS_CONNECTSTATE_CLASS enumeration type that indicates the session's current connection state. public WTS_CONNECTSTATE_CLASS State; /// The session identifier. public uint SessionId; /// Uncompressed Remote Desktop Protocol (RDP) data from the client to the server. public uint IncomingBytes; /// Uncompressed RDP data from the server to the client. public uint OutgoingBytes; /// The number of frames of RDP data sent from the client to the server since the client connected. public uint IncomingFrames; /// The number of frames of RDP data sent from the server to the client since the client connected. public uint OutgoingFrames; /// Compressed RDP data from the client to the server. public uint IncomingCompressedBytes; /// public uint OutgoingCompressedBy; /// A null-terminated string that contains the name of the WinStation for the session. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = WINSTATIONNAME_LENGTH)] public string WinStationName; /// A null-terminated string that contains the name of the domain that the user belongs to. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH)] public string Domain; /// A null-terminated string that contains the name of the user who owns the session. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)] public string UserName; /// The most recent client connection time. public FILETIME ConnectTime; /// The last client disconnection time. public FILETIME DisconnectTime; /// The time of the last user input in the session. public FILETIME LastInputTime; /// The time that the user logged on to the session. public FILETIME LogonTime; /// The time that the WTSINFO data structure was called. public FILETIME CurrentTime; } /// /// Contains a WTSINFOEX_LEVEL union that contains extended information about a Remote Desktop Services session. This structure is /// returned by the WTSQuerySessionInformation function when you specify "WTSSessionInfoEx" for the WTSInfoClass parameter. /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsinfoexa typedef struct _WTSINFOEXA { DWORD Level; // WTSINFOEX_LEVEL_A Data; } WTSINFOEXA, *PWTSINFOEXA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSINFOEXA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSINFOEX { /// Specifies the level of information contained in the Data member. This can be the following value. /// 1 /// The Data member is a WTSINFOEX_LEVEL1 structure. /// public uint Level; /// A WTSINFOEX_LEVEL union. The type of structure contained here is specified by the Level member. public WTSINFOEX_LEVEL Data; } /// Contains a WTSINFOEX_LEVEL1 structure that contains extended information about a Remote Desktop Services session. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsinfoex_level_a typedef union _WTSINFOEX_LEVEL_A { // WTSINFOEX_LEVEL1_A WTSInfoExLevel1; } WTSINFOEX_LEVEL_A, *PWTSINFOEX_LEVEL_A; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSINFOEX_LEVEL_A")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSINFOEX_LEVEL { /// A WTSINFOEX_LEVEL1 structure that contains extended session information. public WTSINFOEX_LEVEL1 WTSInfoExLevel1; } /// Contains extended information about a Remote Desktop Services session. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsinfoex_level1_a typedef struct _WTSINFOEX_LEVEL1_A { // ULONG SessionId; WTS_CONNECTSTATE_CLASS SessionState; LONG SessionFlags; CHAR WinStationName[WINSTATIONNAME_LENGTH + 1]; CHAR // UserName[USERNAME_LENGTH + 1]; CHAR DomainName[DOMAIN_LENGTH + 1]; LARGE_INTEGER LogonTime; LARGE_INTEGER ConnectTime; // LARGE_INTEGER DisconnectTime; LARGE_INTEGER LastInputTime; LARGE_INTEGER CurrentTime; DWORD IncomingBytes; DWORD OutgoingBytes; // DWORD IncomingFrames; DWORD OutgoingFrames; DWORD IncomingCompressedBytes; DWORD OutgoingCompressedBytes; } WTSINFOEX_LEVEL1_A, *PWTSINFOEX_LEVEL1_A; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSINFOEX_LEVEL1_A")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSINFOEX_LEVEL1 { /// The session identifier. public uint SessionId; /// /// A value of the WTS_CONNECTSTATE_CLASS enumeration type that specifies the connection state of a Remote Desktop Services session. /// public WTS_CONNECTSTATE_CLASS SessionState; /// /// The state of the session. This can be one or more of the following values. /// WTS_SESSIONSTATE_UNKNOWN (4294967295 (0xFFFFFFFF)) /// The session state is not known. /// WTS_SESSIONSTATE_LOCK (0 (0x0)) /// The session is locked. /// WTS_SESSIONSTATE_UNLOCK (1 (0x1)) /// The session is unlocked. /// /// Windows Server 2008 R2 and Windows 7: Due to a code defect, the usage of the WTS_SESSIONSTATE_LOCK and /// WTS_SESSIONSTATE_UNLOCK flags is reversed. That is, WTS_SESSIONSTATE_LOCK indicates that the session is /// unlocked, and WTS_SESSIONSTATE_UNLOCK indicates the session is locked. /// /// public WTS_SESSIONSTATE SessionFlags; /// A null-terminated string that contains the name of the window station for the session. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = WINSTATIONNAME_LENGTH + 1)] public string WinStationName; /// A null-terminated string that contains the name of the user who owns the session. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)] public string UserName; /// A null-terminated string that contains the name of the domain that the user belongs to. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)] public string DomainName; /// /// The time that the user logged on to the session. This value is stored as a large integer that represents the number of /// 100-nanosecond intervals since January 1, 1601 Coordinated Universal Time (Greenwich Mean Time). /// public FILETIME LogonTime; /// /// The time of the most recent client connection to the session. This value is stored as a large integer that represents the /// number of 100-nanosecond intervals since January 1, 1601 Coordinated Universal Time. /// public FILETIME ConnectTime; /// /// The time of the most recent client disconnection to the session. This value is stored as a large integer that represents the /// number of 100-nanosecond intervals since January 1, 1601 Coordinated Universal Time. /// public FILETIME DisconnectTime; /// /// The time of the last user input in the session. This value is stored as a large integer that represents the number of /// 100-nanosecond intervals since January 1, 1601 Coordinated Universal Time. /// public FILETIME LastInputTime; /// /// The time that this structure was filled. This value is stored as a large integer that represents the number of /// 100-nanosecond intervals since January 1, 1601 Coordinated Universal Time. /// public FILETIME CurrentTime; /// /// The number of bytes of uncompressed Remote Desktop Protocol (RDP) data sent from the client to the server since the client connected. /// public uint IncomingBytes; /// The number of bytes of uncompressed RDP data sent from the server to the client since the client connected. public uint OutgoingBytes; /// The number of frames of RDP data sent from the client to the server since the client connected. public uint IncomingFrames; /// The number of frames of RDP data sent from the server to the client since the client connected. public uint OutgoingFrames; /// The number of bytes of compressed RDP data sent from the client to the server since the client connected. public uint IncomingCompressedBytes; /// The number of bytes of compressed RDP data sent from the server to the client since the client connected. public uint OutgoingCompressedBytes; } /// Contains information about a Remote Desktop Services listener. This structure is used by the WTSCreateListener function. // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtslistenerconfiga typedef struct _WTSLISTENERCONFIGA { // ULONG version; ULONG fEnableListener; ULONG MaxConnectionCount; ULONG fPromptForPassword; ULONG fInheritColorDepth; ULONG // ColorDepth; ULONG fInheritBrokenTimeoutSettings; ULONG BrokenTimeoutSettings; ULONG fDisablePrinterRedirection; ULONG // fDisableDriveRedirection; ULONG fDisableComPortRedirection; ULONG fDisableLPTPortRedirection; ULONG fDisableClipboardRedirection; // ULONG fDisableAudioRedirection; ULONG fDisablePNPRedirection; ULONG fDisableDefaultMainClientPrinter; ULONG LanAdapter; ULONG // PortNumber; ULONG fInheritShadowSettings; ULONG ShadowSettings; ULONG TimeoutSettingsConnection; ULONG // TimeoutSettingsDisconnection; ULONG TimeoutSettingsIdle; ULONG SecurityLayer; ULONG MinEncryptionLevel; ULONG UserAuthentication; // CHAR Comment[WTS_COMMENT_LENGTH + 1]; CHAR LogonUserName[USERNAME_LENGTH + 1]; CHAR LogonDomain[DOMAIN_LENGTH + 1]; CHAR // WorkDirectory[MAX_PATH + 1]; CHAR InitialProgram[MAX_PATH + 1]; } WTSLISTENERCONFIGA, *PWTSLISTENERCONFIGA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSLISTENERCONFIGA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSLISTENERCONFIG { /// This member is reserved. public uint version; /// /// Specifies whether the listener is enabled. This member can be one of the following values. /// 0 /// The listener is disabled. /// 1 /// The listener is enabled. /// public uint fEnableListener; /// The maximum number of active connections that the listener accepts. public uint MaxConnectionCount; /// /// Specifies whether the listener always prompts the user for a password. This member can be one of the following values. /// 0 /// Prompt the user for a password only when specified by the server. /// 1 /// Always prompt the user for a password. /// public uint fPromptForPassword; /// /// /// Specifies whether the listener should use the color depth specified by the user. This member can be one of the following values. /// /// 0 /// Use the color depth specified by the server. /// 1 /// Use the color depth specified by the user. /// public uint fInheritColorDepth; /// /// /// The color depth setting for the listener. This setting only applies when the fInheritColorDepth member is zero. This /// can be one of the following values. /// /// 1 /// 8 bit /// 2 /// 15 bit /// 3 /// 16 bit /// 4 /// 24 bit /// 5 /// 32 bit /// public uint ColorDepth; /// /// /// Specifies whether the listener should use the BrokenTimeoutSettings value specified by the user. This member can be /// one of the following values. /// /// 0 /// Use the BrokenTimeoutSettings value specified by server. /// 1 /// Use the BrokenTimeoutSettings value specified by the user. /// public uint fInheritBrokenTimeoutSettings; /// /// /// The action the listener takes when a connection or idle timer expires, or when a connection is lost due to a connection /// error. This setting only applies when the fInheritBrokenTimeoutSettings member is zero. This member can be one of the /// following values. /// /// 0 /// /// When a connection or idle timer expires, or when a connection is lost due to a connection error, the user is disconnected /// but the session remains on the server. /// /// 1 /// When a connection or idle timer expires, or when a connection is lost due to a connection error, the session is terminated. /// public uint BrokenTimeoutSettings; /// /// Specifies whether printer redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable printer redirection. /// 1 /// Printer redirection is disabled. /// public uint fDisablePrinterRedirection; /// /// Specifies whether drive redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable drive redirection. /// 1 /// Drive redirection is disabled. /// public uint fDisableDriveRedirection; /// /// Specifies whether COM port redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable COM port redirection. /// 1 /// COM port redirection is disabled. /// public uint fDisableComPortRedirection; /// /// Specifies whether LPT port redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable LPT port redirection. /// 1 /// LPT port redirection is disabled. /// public uint fDisableLPTPortRedirection; /// /// Specifies whether clipboard redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable clipboard redirection. /// 1 /// Clipboard redirection is disabled. /// public uint fDisableClipboardRedirection; /// /// Specifies whether audio redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable audio redirection. /// 1 /// Audio redirection is disabled. /// public uint fDisableAudioRedirection; /// /// Specifies whether Plug and Play redirection is disabled. This member can be one of the following values. /// 0 /// The user can enable Plug and Play redirection. /// 1 /// Plug and Play redirection is disabled. /// public uint fDisablePNPRedirection; /// /// Specifies whether the client printer is the default printer. This member can be one of the following values. /// 0 /// The client printer is not the default printer. /// 1 /// The client printer is the default printer. /// public uint fDisableDefaultMainClientPrinter; /// The network adapter that the listener uses. public uint LanAdapter; /// The port number of the listener. public uint PortNumber; /// /// /// Specifies whether the listener should use the ShadowSettings value specified by the user. This member can be one of /// the following values. /// /// 0 /// Use the setting specified by the server. /// 1 /// Use the setting specified by the user. /// public uint fInheritShadowSettings; /// /// /// The remote control setting for the listener. Remote control allows a user to remotely monitor the on-screen operations of /// another user. This setting only applies when the fInheritShadowSettings member is zero. This member can be one of the /// following values. /// /// 0 /// Remote control is disabled. /// 1 /// The user of remote control has full control of the user's session, with the user's permission. /// 2 /// The user of remote control has full control of the user's session; the user's permission is not required. /// 3 /// /// The user of remote control can view the session remotely, with the user's permission; the remote user cannot actively /// control the session. /// /// 4 /// /// The user of remote control can view the session remotely but not actively control the session; the user's permission is not required. /// /// public uint ShadowSettings; /// /// The maximum connection duration, in milliseconds. Every time the user logs on, the timer is reset. A value of zero indicates /// that the connection timer is disabled. /// public uint TimeoutSettingsConnection; /// /// The maximum duration, in milliseconds, that a server retains a disconnected session before the logon is terminated. A value /// of zero indicates that the disconnection timer is disabled. /// public uint TimeoutSettingsDisconnection; /// The maximum idle time, in milliseconds. A value of zero indicates that the idle timer is disabled. public uint TimeoutSettingsIdle; /// /// The security layer of the listener. This member can be one of the following values. /// 0 /// Remote Desktop Protocol (RDP) is used by the server and the client for authentication before a connection is established. /// 1 /// The server and the client negotiate the method for authentication before a connection is established. /// 2 /// /// Transport Layer Security (TLS) protocol is used by the server and the client for authentication before a connection is established. /// /// public uint SecurityLayer; /// /// Encryption level of the listener. This member can be one of the following values. /// 1 /// /// Data sent from the client to the server is encrypted by using 56-bit encryption. Data sent from the server to the client is /// not encrypted. /// /// 2 /// /// All data sent from the client to the server and from the server to the client is encrypted by using the maximum key strength /// supported by the client. /// /// 3 /// /// All data sent from the client to the server and from the server to the client is encrypted by using 128-bit encryption. /// Clients that do not support this level of encryption cannot connect. /// /// 4 /// /// All data sent from the client to the server and from the server to the client is encrypted and decrypted by using the /// Federal Information Processing Standards (FIPS) encryption algorithms and Microsoft cryptographic modules. /// /// public uint MinEncryptionLevel; /// /// /// Specifies whether network-level user authentication is required before the connection is established. This member can be one /// of the following values. /// /// 0 /// Network-level user authentication is not required. /// 1 /// Network-level user authentication is required. /// public uint UserAuthentication; /// A null-terminated string that contains a description of the listener. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = WTS_COMMENT_LENGTH + 1)] public string Comment; /// A null-terminated string that contains the user name used in automatic logon scenarios. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)] public string LogonUserName; /// A null-terminated string that contains the domain name used in automatic logon scenarios. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)] public string LogonDomain; /// A null-terminated string that contains the path of the working directory of the initial program. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string WorkDirectory; /// /// A null-terminated string that contains the name of the program to start immediately after the user logs on to the server. /// [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string InitialProgram; } /// A fixed length string used by [PInvokeData("wtsapi32.h")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSLISTENERNAME { private const int WTS_LISTENER_NAME_LENGTH = 32; /// Name of the server. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = WTS_LISTENER_NAME_LENGTH + 1)] public string Name; /// Converts to string. /// A that represents this instance. public override string ToString() => Name ?? ""; /// Performs an implicit conversion from to . /// The n. /// The resulting instance from the conversion. public static implicit operator string(WTSLISTENERNAME n) => n.Name; /// Performs an implicit conversion from to . /// The n. /// The resulting instance from the conversion. public static implicit operator WTSLISTENERNAME(string n) => new WTSLISTENERNAME { Name = n }; } /// /// Contains configuration information for a user on a domain controller or Remote Desktop Session Host (RD Session Host) server. /// This structure is used by the WTSQueryUserConfig and WTSSetUserConfig functions. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/wtsapi32/ns-wtsapi32-wtsuserconfiga typedef struct _WTSUSERCONFIGA { DWORD // Source; DWORD InheritInitialProgram; DWORD AllowLogonTerminalServer; DWORD TimeoutSettingsConnections; DWORD // TimeoutSettingsDisconnections; DWORD TimeoutSettingsIdle; DWORD DeviceClientDrives; DWORD DeviceClientPrinters; DWORD // ClientDefaultPrinter; DWORD BrokenTimeoutSettings; DWORD ReconnectSettings; DWORD ShadowingSettings; DWORD // TerminalServerRemoteHomeDir; CHAR InitialProgram[MAX_PATH + 1]; CHAR WorkDirectory[MAX_PATH + 1]; CHAR // TerminalServerProfilePath[MAX_PATH + 1]; CHAR TerminalServerHomeDir[MAX_PATH + 1]; CHAR // TerminalServerHomeDirDrive[WTS_DRIVE_LENGTH + 1]; } WTSUSERCONFIGA, *PWTSUSERCONFIGA; [PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSUSERCONFIGA")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] public struct WTSUSERCONFIG { /// /// A value of the WTS_CONFIG_SOURCE enumeration type that specifies the source of configuration information returned by the /// WTSQueryUserConfig function. /// public WTS_CONFIG_SOURCE Source; /// /// /// A value that indicates whether the client can specify the initial program. This member can be one of the following values. /// /// 0 /// /// The client cannot specify the initial program. Instead, the program specified by the InitialProgram member starts /// automatically when the user logs on to the server. The server logs the user off when the user exits that program. /// /// 1 /// The client can specify the initial program. /// public uint InheritInitialProgram; /// /// /// A value that indicates whether the user account is permitted to log on to an RD Session Host server. This member can be one /// of the following values. /// /// 0 /// The user cannot log on. /// 1 /// The user can log on. /// public uint AllowLogonTerminalServer; /// /// The maximum connection duration, in milliseconds. One minute before the connection expires, the server notifies the user /// about the pending disconnection. When the connection times out, the server takes the action specified by the /// BrokenTimeoutSettings member. Every time the user logs on, the timer is reset. A value of zero indicates that the /// connection timer is disabled. /// public uint TimeoutSettingsConnections; /// /// The maximum duration, in milliseconds, that the server retains a disconnected session before the logon is terminated. A /// value of zero indicates that the disconnection timer is disabled. /// public uint TimeoutSettingsDisconnections; /// /// The amount of time, in milliseconds, that a connection can remain idle. If there is no keyboard or mouse activity for this /// period of time, the server takes the action specified by the BrokenTimeoutSettings member. A value of zero indicates /// that the idle timer is disabled. /// public uint TimeoutSettingsIdle; /// This member is reserved. public uint DeviceClientDrives; /// /// /// A value that indicates whether the server automatically connects to previously mapped client printers when the user logs on /// to the server. This member can be one of the following values. /// /// 0 /// The server does not automatically connect to previously mapped client printers. /// 1 /// The server automatically connects to previously mapped client printers. /// public uint DeviceClientPrinters; /// /// /// A value that indicates whether the client printer is the default printer. This member can be one of the following values. /// /// 0 /// The client printer is not the default printer. /// 1 /// The client printer is the default printer. /// public uint ClientDefaultPrinter; /// /// /// The action the server takes when the connection or idle timers expire, or when a connection is lost due to a connection /// error. This member can be one of the following values. /// /// 0 /// The session is disconnected, but it remains on the server. /// 1 /// The session is terminated. /// public uint BrokenTimeoutSettings; /// /// /// A value that indicates how a disconnected session for this user can be reconnected. This member can be one of the following values. /// /// 0 /// The user can log on to any client computer to reconnect to a disconnected session. /// 1 /// /// The user must log on to the client computer originally used to establish the disconnected session. If the user logs on to a /// different client computer, the user gets a new session. /// /// public uint ReconnectSettings; /// /// /// The remote control setting. Remote control allows a user to remotely monitor the on-screen operations of another user. This /// member can be one of the following values. /// /// 0 /// Remote control is disabled. /// 1 /// The user of remote control has full control of the user's session, with the user's permission. /// 2 /// The user of remote control has full control of the user's session; the user's permission is not required. /// 3 /// /// The user of remote control can view the session remotely, with the user's permission; the remote user cannot actively /// control the session. /// /// 4 /// /// The user of remote control can view the session remotely but not actively control the session; the user's permission is not required. /// /// public uint ShadowingSettings; /// /// /// A value that indicates whether the TerminalServerHomeDir member contains a path to a local directory or a network /// share. You cannot set this member by using the WTSSetUserConfig function. This member can be one of the following values. /// /// 0 /// The TerminalServerHomeDir member contains a path to a local directory. /// 1 /// /// The TerminalServerHomeDir member contains a path to a network share, and the TerminalServerHomeDirDrive member /// contains a drive letter to which this path is mapped. /// /// public uint TerminalServerRemoteHomeDir; /// /// A null-terminated string that contains the name of the program to start immediately after the user logs on to the server. /// [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string InitialProgram; /// A null-terminated string that contains the path of the working directory for the initial program. [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string WorkDirectory; /// /// A null-terminated string that contains the profile path that is assigned to the user when the user connects to the server. /// The directory specified by the path must be created manually, and must exist prior to the logon. /// [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string TerminalServerProfilePath; /// /// A null-terminated string that contains the path to the home folder of the user's Remote Desktop Services sessions. The /// folder can be a local folder or a network share. /// [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)] public string TerminalServerHomeDir; /// /// A null-terminated string that contains the drive name (a drive letter followed by a colon) to which the path specified in /// the TerminalServerHomeDir member is mapped. This member is only valid when the TerminalServerRemoteHomeDir /// member is set to one. /// [MarshalAs(UnmanagedType.ByValTStr, SizeConst = WTS_DRIVE_LENGTH + 1)] public string TerminalServerHomeDirDrive; } /// Provides a for that is disposed using . public class SafeHVIRTUALCHANNEL : SafeHANDLE { /// Initializes a new instance of the class and assigns an existing handle. /// An object that represents the pre-existing handle to use. /// /// to reliably release the handle during the finalization phase; otherwise, (not recommended). /// public SafeHVIRTUALCHANNEL(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { } /// Initializes a new instance of the class. private SafeHVIRTUALCHANNEL() : base() { } /// Performs an implicit conversion from to . /// The safe handle instance. /// The result of the conversion. public static implicit operator HVIRTUALCHANNEL(SafeHVIRTUALCHANNEL h) => h.handle; /// protected override bool InternalReleaseHandle() => WTSVirtualChannelClose(handle); } /// Provides a for that is disposed using . public class SafeHWTSSERVER : SafeHANDLE { /// Initializes a new instance of the class and assigns an existing handle. /// An object that represents the pre-existing handle to use. /// /// to reliably release the handle during the finalization phase; otherwise, (not recommended). /// public SafeHWTSSERVER(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { } /// Initializes a new instance of the class. private SafeHWTSSERVER() : base() { } /// Performs an implicit conversion from to . /// The safe handle instance. /// The result of the conversion. public static implicit operator HWTSSERVER(SafeHWTSSERVER h) => h.handle; /// protected override bool InternalReleaseHandle() { WTSCloseServer(handle); return true; } } /// Provides a for WTS memory that is disposed using . public class SafeWTSMemoryHandle : SafeHANDLE { /// Initializes a new instance of the class and assigns an existing handle. /// An object that represents the pre-existing handle to use. /// /// to reliably release the handle during the finalization phase; otherwise, (not recommended). /// public SafeWTSMemoryHandle(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { } /// Initializes a new instance of the class. private SafeWTSMemoryHandle() : base() { } /// /// Extracts an array of structures of containing items. This call can cause memory exceptions if the pointer does not have sufficient allocated memory to retrieve all /// the structures. /// /// The type of the structures to retrieve. /// The number of structures to retrieve. /// An array of structures of . public T[] ToArray(int count) => handle.ToArray(count); /// Returns a that represents this instance. /// The size, in bytes, of the data returned in ppBuffer. /// A that represents this instance. public string ToString(uint allocatedBytes) => StringHelper.GetString(handle, CharSet.Auto, allocatedBytes); /// Marshals data from this memory to a newly allocated managed object of the type specified by a generic type parameter. /// The type of the object to which the data is to be copied. This must be a structure. /// If known, the total number of bytes allocated to the native memory. /// A managed object that contains the data that this memory points to. public T ToStructure(uint allocatedBytes) => handle.Convert(allocatedBytes == 0 ? uint.MaxValue : allocatedBytes); #if ALLOWSPAN /// Creates a new span over this allocated memory. /// The span representation of the structure. public virtual ReadOnlySpan AsReadOnlySpan(int length) => handle.AsReadOnlySpan(length); /// Creates a new span over this allocated memory. /// The span representation of the structure. public virtual Span AsSpan(int length) => handle.AsSpan(length); #endif /// protected override bool InternalReleaseHandle() { WTSFreeMemory(handle); return true; } } } }