mirror of https://github.com/dahall/Vanara.git
3803 lines
203 KiB
C#
3803 lines
203 KiB
C#
using System;
|
||
using System.Runtime.InteropServices;
|
||
using System.Text;
|
||
using Vanara.Extensions;
|
||
using Vanara.InteropServices;
|
||
|
||
namespace Vanara.PInvoke
|
||
{
|
||
/// <summary>Items from the WTSApi32.dll</summary>
|
||
public static partial class WTSApi32
|
||
{
|
||
/// <summary>A session value the indicates all WTS sessions.</summary>
|
||
public const uint WTS_ANY_SESSION = unchecked((uint)-2);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public const string WTS_CURRENT_SERVER_NAME = null;
|
||
|
||
/// <summary>Indicates the RD Session Host server on which your application is running.</summary>
|
||
public static SafeHWTSSERVER WTS_CURRENT_SERVER => SafeHWTSSERVER.Current;
|
||
|
||
/// <summary>Indicates the RD Session Host server on which your application is running.</summary>
|
||
public static SafeHWTSSERVER WTS_CURRENT_SERVER_HANDLE => SafeHWTSSERVER.Current;
|
||
|
||
/// <summary>Specifies the current session (SessionId)</summary>
|
||
public const uint WTS_CURRENT_SESSION = unchecked((uint)-1);
|
||
|
||
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;
|
||
|
||
/// <summary>The virtual modifier that represents the key to press to stop remote control of the session.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSStartRemoteControlSessionA")]
|
||
[Flags]
|
||
public enum REMOTECONTROL_HOTKEY
|
||
{
|
||
/// <summary>The SHIFT key.</summary>
|
||
REMOTECONTROL_KBDSHIFT_HOTKEY = 0x1,
|
||
|
||
/// <summary>The CTRL key.</summary>
|
||
REMOTECONTROL_KBDCTRL_HOTKEY = 0x2,
|
||
|
||
/// <summary>The ALT key.</summary>
|
||
REMOTECONTROL_KBDALT_HOTKEY = 0x4,
|
||
}
|
||
|
||
/// <summary>A <see cref="WTS_INFO_CLASS.WTSClientProtocolType"/> return value indicating the session protocol type.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelOpenEx")]
|
||
public enum SessionProtocolType : ushort
|
||
{
|
||
/// <summary>The console session.</summary>
|
||
Console = 0,
|
||
|
||
/// <summary>This value is retained for legacy purposes.</summary>
|
||
Legacy = 1,
|
||
|
||
/// <summary>The RDP protocol.</summary>
|
||
RDP = 2
|
||
}
|
||
|
||
/// <summary>Options for <c>WTSVirtualChannelOpenEx</c>.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSVirtualChannelOpenEx")]
|
||
[Flags]
|
||
public enum WTS_CHANNEL_OPTION
|
||
{
|
||
/// <summary>Open the channel as a DVC.</summary>
|
||
WTS_CHANNEL_OPTION_DYNAMIC = 0x00000001,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTS_CHANNEL_OPTION_DYNAMIC_PRI_LOW = 0x00000000,
|
||
|
||
/// <summary>
|
||
/// Medium priority. Use this priority level to send short control messages that must have priority over the data in the low
|
||
/// priority channels.
|
||
/// </summary>
|
||
WTS_CHANNEL_OPTION_DYNAMIC_PRI_MED = 0x00000002,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTS_CHANNEL_OPTION_DYNAMIC_PRI_HIGH = 0x00000004,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTS_CHANNEL_OPTION_DYNAMIC_PRI_REAL = 0x00000006,
|
||
|
||
/// <summary>
|
||
/// Disables compression for this DVC. You must specify this value in combination with the <c>WTS_CHANNEL_OPTION_DYNAMIC</c> value.
|
||
/// </summary>
|
||
WTS_CHANNEL_OPTION_DYNAMIC_NO_COMPRESS = 0x00000008
|
||
}
|
||
|
||
/// <summary>
|
||
/// Contains values that indicate the type of user configuration information to set or retrieve in a call to the WTSQueryUserConfig
|
||
/// and WTSSetUserConfig functions.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigInitialProgram,
|
||
|
||
/// <summary>A null-terminated string that contains the path of the working directory for the initial program.</summary>
|
||
WTSUserConfigWorkingDirectory,
|
||
|
||
/// <summary>A value that indicates whether the client can specify the initial program.</summary>
|
||
WTSUserConfigfInheritInitialProgram,
|
||
|
||
/// <summary>A value that indicates whether the user account is permitted to log on to an RD Session Host server.</summary>
|
||
WTSUserConfigfAllowLogonTerminalServer,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigTimeoutSettingsConnections,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigTimeoutSettingsDisconnections,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigTimeoutSettingsIdle,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigfDeviceClientDrives,
|
||
|
||
/// <summary>
|
||
/// RDP 5.0 and later clients: A value that indicates whether the RD Session Host server automatically reestablishes client
|
||
/// printer mappings at logon.
|
||
/// </summary>
|
||
WTSUserConfigfDeviceClientPrinters,
|
||
|
||
/// <summary>RDP 5.0 and later clients: A value that indicates whether the client printer is the default printer.</summary>
|
||
WTSUserConfigfDeviceClientDefaultPrinter,
|
||
|
||
/// <summary>
|
||
/// A value that indicates what happens when the connection or idle timers expire or when a connection is lost due to a
|
||
/// connection error.
|
||
/// </summary>
|
||
WTSUserConfigBrokenTimeoutSettings,
|
||
|
||
/// <summary>A value that indicates how a disconnected session for this user can be reconnected.</summary>
|
||
WTSUserConfigReconnectSettings,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigModemCallbackSettings,
|
||
|
||
/// <summary>
|
||
/// This constant currently is not used by Remote Desktop Services.A null-terminated string that contains the phone number to
|
||
/// use for callback connections.
|
||
/// </summary>
|
||
WTSUserConfigModemCallbackPhoneNumber,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigShadowingSettings,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigTerminalServerProfilePath,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigTerminalServerHomeDir,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigTerminalServerHomeDirDrive,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSUserConfigfTerminalServerRemoteHomeDir,
|
||
|
||
/// <summary>
|
||
/// A WTSUSERCONFIG structure that contains configuration data for the session. Windows Server 2008 and Windows Vista: This
|
||
/// value is not supported.
|
||
/// </summary>
|
||
WTSUserConfigUser,
|
||
}
|
||
|
||
/// <summary>
|
||
/// Specifies the source of configuration information returned by the WTSQueryUserConfig function. This enumeration type is used in
|
||
/// the WTSUSERCONFIG structure.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>The configuration information came from the Security Accounts Manager (SAM) database.</summary>
|
||
WTSUserConfigSourceSAM,
|
||
}
|
||
|
||
/// <summary>Specifies the connection state of a Remote Desktop Services session.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>
|
||
/// A user is logged on to the WinStation. This state occurs when a user is signed in and actively connected to the device.
|
||
/// </summary>
|
||
WTSActive,
|
||
|
||
/// <summary>The WinStation is connected to the client.</summary>
|
||
WTSConnected,
|
||
|
||
/// <summary>The WinStation is in the process of connecting to the client.</summary>
|
||
WTSConnectQuery,
|
||
|
||
/// <summary>The WinStation is shadowing another WinStation.</summary>
|
||
WTSShadow,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSDisconnected,
|
||
|
||
/// <summary>The WinStation is waiting for a client to connect.</summary>
|
||
WTSIdle,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSListen,
|
||
|
||
/// <summary>The WinStation is being reset.</summary>
|
||
WTSReset,
|
||
|
||
/// <summary>The WinStation is down due to an error.</summary>
|
||
WTSDown,
|
||
|
||
/// <summary>The WinStation is initializing.</summary>
|
||
WTSInit,
|
||
}
|
||
|
||
/// <summary>Bitmask that specifies the set of events to wait for.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSWaitSystemEvent")]
|
||
[Flags]
|
||
public enum WTS_EVENT : uint
|
||
{
|
||
/// <summary>The wait terminated because of a <c>WTSWaitSystemEvent</c> call with <c>WTS_EVENT_FLUSH</c>.</summary>
|
||
WTS_EVENT_NONE = 0x00000000,
|
||
|
||
/// <summary>A new WinStation was created.</summary>
|
||
WTS_EVENT_CREATE = 0x00000001,
|
||
|
||
/// <summary>An existing WinStation was deleted.</summary>
|
||
WTS_EVENT_DELETE = 0x00000002,
|
||
|
||
/// <summary>An existing WinStation was renamed.</summary>
|
||
WTS_EVENT_RENAME = 0x00000004,
|
||
|
||
/// <summary>A client connected to a WinStation.</summary>
|
||
WTS_EVENT_CONNECT = 0x00000008,
|
||
|
||
/// <summary>A client disconnected from a WinStation.</summary>
|
||
WTS_EVENT_DISCONNECT = 0x00000010,
|
||
|
||
/// <summary>A user logged on to the system from either the Remote Desktop Services console or from a client WinStation.</summary>
|
||
WTS_EVENT_LOGON = 0x00000020,
|
||
|
||
/// <summary>A user logged off from either the Remote Desktop Services console or from a client WinStation.</summary>
|
||
WTS_EVENT_LOGOFF = 0x00000040,
|
||
|
||
/// <summary>
|
||
/// A WinStation connection state changed. For a list of connection states, see the WTS_CONNECTSTATE_CLASS enumeration type.
|
||
/// </summary>
|
||
WTS_EVENT_STATECHANGE = 0x00000080,
|
||
|
||
/// <summary>
|
||
/// The Remote Desktop Services' license state changed. This occurs when a license is added or deleted using License Manager.
|
||
/// </summary>
|
||
WTS_EVENT_LICENSE = 0x00000100,
|
||
|
||
/// <summary>Wait for any event type.</summary>
|
||
WTS_EVENT_ALL = 0x7fffffff,
|
||
|
||
/// <summary>Cause all pending <c>WTSWaitSystemEvent</c> calls on the specified RD Session Host server handle to return.</summary>
|
||
WTS_EVENT_FLUSH = 0x80000000,
|
||
}
|
||
|
||
/// <summary>
|
||
/// Contains values that indicate the type of session information to retrieve in a call to the WTSQuerySessionInformation function.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>
|
||
/// A null-terminated string that contains the name of the initial program that Remote Desktop Services runs when the user logs on.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSInitialProgram,
|
||
|
||
/// <summary>
|
||
/// 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
|
||
/// </summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSApplicationName,
|
||
|
||
/// <summary>A null-terminated string that contains the default directory used when launching the initial program.</summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSWorkingDirectory,
|
||
|
||
/// <summary>This value is not used.</summary>
|
||
WTSOEMId,
|
||
|
||
/// <summary>A ULONG value that contains the session identifier.</summary>
|
||
[CorrespondingType(typeof(uint))]
|
||
WTSSessionId,
|
||
|
||
/// <summary>A null-terminated string that contains the name of the user associated with the session.</summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSUserName,
|
||
|
||
/// <summary>A null-terminated string that contains the name of the Remote Desktop Services session.</summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSWinStationName,
|
||
|
||
/// <summary>A null-terminated string that contains the name of the domain to which the logged-on user belongs.</summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSDomainName,
|
||
|
||
/// <summary>The session's current connection state. For more information, see WTS_CONNECTSTATE_CLASS.</summary>
|
||
[CorrespondingType(typeof(WTS_CONNECTSTATE_CLASS))]
|
||
WTSConnectState,
|
||
|
||
/// <summary>A ULONG value that contains the build number of the client.</summary>
|
||
[CorrespondingType(typeof(uint))]
|
||
WTSClientBuildNumber,
|
||
|
||
/// <summary>A null-terminated string that contains the name of the client.</summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSClientName,
|
||
|
||
/// <summary>A null-terminated string that contains the directory in which the client is installed.</summary>
|
||
[CorrespondingType(typeof(string))]
|
||
WTSClientDirectory,
|
||
|
||
/// <summary>A USHORT client-specific product identifier.</summary>
|
||
[CorrespondingType(typeof(ushort))]
|
||
WTSClientProductId,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(uint))]
|
||
WTSClientHardwareId,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(WTS_CLIENT_ADDRESS))]
|
||
WTSClientAddress,
|
||
|
||
/// <summary>Information about the display resolution of the client. For more information, see WTS_CLIENT_DISPLAY.</summary>
|
||
[CorrespondingType(typeof(WTS_CLIENT_DISPLAY))]
|
||
WTSClientDisplay,
|
||
|
||
/// <summary>
|
||
/// A USHORT value that specifies information about the protocol type for the session. This is one of the following values.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(SessionProtocolType))]
|
||
WTSClientProtocolType,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSIdleTime,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSLogonTime,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSIncomingBytes,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSOutgoingBytes,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSIncomingFrames,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSOutgoingFrames,
|
||
|
||
/// <summary>Information about a Remote Desktop Connection (RDC) client. For more information, see WTSCLIENT.</summary>
|
||
[CorrespondingType(typeof(WTSCLIENT))]
|
||
WTSClientInfo,
|
||
|
||
/// <summary>Information about a client session on a RD Session Host server. For more information, see WTSINFO.</summary>
|
||
[CorrespondingType(typeof(WTSINFO))]
|
||
WTSSessionInfo,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(WTSINFOEX))]
|
||
WTSSessionInfoEx,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(WTSCONFIGINFO))]
|
||
WTSConfigInfo,
|
||
|
||
/// <summary>This value is not supported.</summary>
|
||
WTSValidationInfo,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[CorrespondingType(typeof(WTS_SESSION_ADDRESS))]
|
||
WTSSessionAddressV4,
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
WTSIsRemoteSession,
|
||
}
|
||
|
||
/// <summary>The purpose of the call.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSCreateListenerA")]
|
||
public enum WTS_LISTENER
|
||
{
|
||
/// <summary>Create a new listener.</summary>
|
||
WTS_LISTENER_CREATE = 0x00000001,
|
||
|
||
/// <summary>Update the settings of an existing listener.</summary>
|
||
WTS_LISTENER_UPDATE = 0x00000010,
|
||
}
|
||
|
||
/// <summary>The state of the session.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NS:wtsapi32._WTSINFOEX_LEVEL1_A")]
|
||
[Flags]
|
||
public enum WTS_SESSIONSTATE : uint
|
||
{
|
||
/// <summary>The session state is not known.</summary>
|
||
WTS_SESSIONSTATE_UNKNOWN = 0xFFFFFFFF,
|
||
|
||
/// <summary>The session state is locked.</summary>
|
||
WTS_SESSIONSTATE_LOCK = 0x00000000,
|
||
|
||
/// <summary>The session state is unlocked.</summary>
|
||
WTS_SESSIONSTATE_UNLOCK = 0x00000001,
|
||
}
|
||
|
||
/// <summary>Specifies the type of structure that a Remote Desktop Services function has returned in a buffer.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>The buffer contains one or more WTS_PROCESS_INFO structures.</summary>
|
||
WTSTypeProcessInfoLevel0,
|
||
|
||
/// <summary>The buffer contains one or more WTS_PROCESS_INFO_EX structures.</summary>
|
||
WTSTypeProcessInfoLevel1,
|
||
|
||
/// <summary>The buffer contains one or more WTS_SESSION_INFO_1 structures.</summary>
|
||
WTSTypeSessionInfoLevel1,
|
||
}
|
||
|
||
/// <summary>Contains values that indicate the type of virtual channel information to retrieve.</summary>
|
||
/// <remarks>
|
||
/// 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.
|
||
/// </remarks>
|
||
// 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
|
||
{
|
||
/// <summary>This value is not currently supported.</summary>
|
||
WTSVirtualClientData,
|
||
|
||
/// <summary>Indicates a request for the file handle of a virtual channel that can be used for asynchronous I/O.</summary>
|
||
WTSVirtualFileHandle,
|
||
}
|
||
|
||
/// <summary>Indicates the type of shutdown.</summary>
|
||
[PInvokeData("wtsapi32.h", MSDNShortId = "NF:wtsapi32.WTSShutdownSystem")]
|
||
public enum WTS_WSD
|
||
{
|
||
/// <summary>
|
||
/// Forces all client sessions to log off (except the session calling <c>WTSShutdownSystem</c>) 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.
|
||
/// </summary>
|
||
WTS_WSD_LOGOFF = 0x00000001,
|
||
|
||
/// <summary>
|
||
/// Shuts down the system on the RD Session Host server. This is equivalent to calling the ExitWindowsEx function with
|
||
/// <c>EWX_SHUTDOWN</c>. The calling process must have the <c>SE_SHUTDOWN_NAME</c> privilege enabled.
|
||
/// </summary>
|
||
WTS_WSD_SHUTDOWN = 0x00000002,
|
||
|
||
/// <summary>
|
||
/// Shuts down and then restarts the system on the RD Session Host server. This is equivalent to calling <c>ExitWindowsEx</c>
|
||
/// with <c>EWX_REBOOT</c>. The calling process must have the <c>SE_SHUTDOWN_NAME</c> privilege enabled.
|
||
/// </summary>
|
||
WTS_WSD_REBOOT = 0x00000004,
|
||
|
||
/// <summary>
|
||
/// 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 <c>EWX_SHUTDOWN</c> and <c>EWX_POWEROFF</c>. The calling process
|
||
/// must have the <c>SE_SHUTDOWN_NAME</c> privilege enabled.
|
||
/// </summary>
|
||
WTS_WSD_POWEROFF = 0x00000008,
|
||
|
||
/// <summary>This value is not supported currently.</summary>
|
||
WTS_WSD_FASTREBOOT = 0x00000010,
|
||
}
|
||
|
||
/// <summary>Closes an open handle to a Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
/// <param name="hServer">
|
||
/// <para>A handle to an RD Session Host server opened by a call to the WTSOpenServer or WTSOpenServerEx function.</para>
|
||
/// <para>Do not pass <c>WTS_CURRENT_SERVER_HANDLE</c> for this parameter.</para>
|
||
/// </param>
|
||
/// <returns>None</returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Call the <c>WTSCloseServer</c> 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.
|
||
/// </para>
|
||
/// <para>After the handle has been closed, it cannot be used with any other WTS APIs.</para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Connects a Remote Desktop Services session to an existing session on the local computer.</summary>
|
||
/// <param name="LogonId">
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>This can be <c>LOGONID_CURRENT</c> to use the current session.</para>
|
||
/// </param>
|
||
/// <param name="TargetLogonId">
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>This can be <c>LOGONID_CURRENT</c> to use the current session.</para>
|
||
/// </param>
|
||
/// <param name="pPassword">
|
||
/// 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 <c>NULL</c>.
|
||
/// </param>
|
||
/// <param name="bWait">
|
||
/// Indicates whether the operation is synchronous. Specify <c>TRUE</c> to wait for the operation to complete, or <c>FALSE</c> to
|
||
/// return immediately.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>Either the LogonId or TargetLogonId parameter can be <c>LOGONID_CURRENT</c>, but not both.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Creates a new Remote Desktop Services listener or configures an existing listener.</summary>
|
||
/// <param name="hServer">A handle to an RD Session Host server. Always set this parameter to <c>WTS_CURRENT_SERVER_HANDLE</c>.</param>
|
||
/// <param name="pReserved">This parameter is reserved. Always set this parameter to <c>NULL</c>.</param>
|
||
/// <param name="Reserved">This parameter is reserved. Always set this parameter to zero.</param>
|
||
/// <param name="pListenerName">A pointer to a null-terminated string that contains the name of the listener to create or configure.</param>
|
||
/// <param name="pBuffer">A pointer to a WTSLISTENERCONFIG structure that contains configuration information for the listener.</param>
|
||
/// <param name="flag">
|
||
/// <para>The purpose of the call. This parameter can be one of the following values.</para>
|
||
/// <para>WTS_LISTENER_CREATE (1 (0x1))</para>
|
||
/// <para>Create a new listener.</para>
|
||
/// <para>WTS_LISTENER_UPDATE (16 (0x10))</para>
|
||
/// <para>Update the settings of an existing listener.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This function creates or configures a listener that uses Remote Desktop Protocol (RDP). Always set the <c>version</c> member of
|
||
/// the WTSLISTENERCONFIG structure that is pointed to by the pBuffer parameter to one.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// This function does not validate the settings for the new listener. Be sure that the settings are valid before calling this function.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer or WTSOpenServerEx function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// A Remote Desktop Services session identifier. To indicate the current session, specify <c>WTS_CURRENT_SESSION</c>. To retrieve
|
||
/// the identifiers of all sessions on a specified RD Session Host server, use the WTSEnumerateSessions function.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="bWait">
|
||
/// Indicates whether the operation is synchronous. Specify <c>TRUE</c> to wait for the operation to complete, or <c>FALSE</c> to
|
||
/// return immediately.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Enables or disables Child Sessions.</summary>
|
||
/// <param name="bEnable">
|
||
/// Indicates whether to enable or disable child sessions. Pass <c>TRUE</c> if child sessions are to be enabled or <c>FALSE</c> otherwise.
|
||
/// </param>
|
||
/// <returns>Returns nonzero if the function succeeds or zero otherwise.</returns>
|
||
/// <remarks>For more information about child sessions, see Child Sessions.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Enumerates all the Remote Desktop Services listeners on a Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
/// <param name="hServer">A handle to an RD Session Host server. Always set this parameter to <c>WTS_CURRENT_SERVER_HANDLE</c>.</param>
|
||
/// <param name="pReserved">This parameter is reserved. Always set this parameter to <c>NULL</c>.</param>
|
||
/// <param name="Reserved">This parameter is reserved. Always set this parameter to zero.</param>
|
||
/// <param name="pListeners">A pointer to an array of <c>WTSLISTENERNAME</c> variables that receive the names of the listeners.</param>
|
||
/// <param name="pCount">
|
||
/// A pointer to a <c>DWORD</c> 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 <c>NULL</c>. The function will return the number of
|
||
/// <c>WTSLISTENERNAME</c> variables necessary to allocate for the array pointed to by the pListeners parameter.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This function returns all listeners currently running on the server, including listeners that do not support Remote Desktop
|
||
/// Protocol (RDP).
|
||
/// </para>
|
||
/// <para>
|
||
/// If the number of listeners is unknown, you can call this function with pListeners set to <c>NULL</c>. The function will then
|
||
/// return, in the pCount parameter, the number of <c>WTSLISTENERNAME</c> 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.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Retrieves information about the active processes on a specified Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
/// <param name="hServer">
|
||
/// Handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="Reserved">Reserved; must be zero.</param>
|
||
/// <param name="Version">Specifies the version of the enumeration request. Must be 1.</param>
|
||
/// <param name="ppProcessInfo">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="pCount">
|
||
/// Pointer to a variable that receives the number of <c>WTS_PROCESS_INFO</c> structures returned in the ppProcessInfo buffer.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// The caller must be a member of the Administrators group to enumerate processes that are running under a different user's context.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the server on which your application is running.
|
||
/// </param>
|
||
/// <param name="pLevel">
|
||
/// <para>
|
||
/// A pointer to a <c>DWORD</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// If you do not specify a valid value for this parameter, on output, <c>WTSEnumerateProcessesEx</c> sets this parameter to one and
|
||
/// returns an error. Otherwise, on output, <c>WTSEnumerateProcessesEx</c> does not change the value of this parameter.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="SessionId">
|
||
/// The session for which to enumerate processes. To enumerate processes for all sessions on the server, specify <c>WTS_ANY_SESSION</c>.
|
||
/// </param>
|
||
/// <param name="ppProcessInfo">
|
||
/// 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 <c>NULL</c>.
|
||
/// </param>
|
||
/// <param name="pCount">
|
||
/// A pointer to a variable that receives the number of structures returned in the buffer referenced by the ppProcessInfo parameter.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// The caller must be a member of the Administrators group to enumerate processes that are running under another user session.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the server on which your application is running.
|
||
/// </param>
|
||
/// <param name="SessionId">
|
||
/// The session for which to enumerate processes. To enumerate processes for all sessions on the server, specify <c>WTS_ANY_SESSION</c>.
|
||
/// </param>
|
||
/// <param name="ppProcessInfo">An array of WTS_PROCESS_INFO_EX structures.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// The caller must be a member of the Administrators group to enumerate processes that are running under another user session.
|
||
/// </remarks>
|
||
// 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<WTS_PROCESS_INFO_EX>((int)cnt);
|
||
}
|
||
finally
|
||
{
|
||
WTSFreeMemoryEx(WTS_TYPE_CLASS.WTSTypeProcessInfoLevel1, ptr, cnt);
|
||
}
|
||
return true;
|
||
}
|
||
ppProcessInfo = null;
|
||
return false;
|
||
}
|
||
|
||
/// <summary>Returns a list of all Remote Desktop Session Host (RD Session Host) servers within the specified domain.</summary>
|
||
/// <param name="pDomainName">
|
||
/// Pointer to the name of the domain to be queried. If the value of this parameter is <c>NULL</c>, the specified domain is the
|
||
/// current domain.
|
||
/// </param>
|
||
/// <param name="Reserved">Reserved. The value of this parameter must be 0.</param>
|
||
/// <param name="Version">Version of the enumeration request. The value of the parameter must be 1.</param>
|
||
/// <param name="ppServerInfo">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="pCount">
|
||
/// Pointer to a variable that receives the number of WTS_SERVER_INFO structures returned in the ppServerInfo buffer.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>This function will not work if NetBT is disabled.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Returns a list of all Remote Desktop Session Host (RD Session Host) servers within the specified domain.</summary>
|
||
/// <param name="pDomainName">
|
||
/// Pointer to the name of the domain to be queried. If the value of this parameter is <c>NULL</c>, the specified domain is the
|
||
/// current domain.
|
||
/// </param>
|
||
/// <param name="ppServerInfo">An array of WTS_SERVER_INFO structures, which contains the returned results of the enumeration.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>This function will not work if NetBT is disabled.</remarks>
|
||
// 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<WTS_SERVER_INFO>((int)cnt);
|
||
return true;
|
||
}
|
||
ppServerInfo = null;
|
||
return false;
|
||
}
|
||
|
||
/// <summary>Retrieves a list of sessions on a Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
/// <param name="hServer">
|
||
/// <para>A handle to the RD Session Host server.</para>
|
||
/// <para>
|
||
/// <c>Note</c> You can use the WTSOpenServer or WTSOpenServerEx functions to retrieve a handle to a specific server, or
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to use the RD Session Host server that hosts your application.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="Reserved">This parameter is reserved. It must be zero.</param>
|
||
/// <param name="Version">The version of the enumeration request. This parameter must be 1.</param>
|
||
/// <param name="ppSessionInfo">
|
||
/// <para>
|
||
/// A pointer to an array of WTS_SESSION_INFO structures that represent the retrieved sessions. To free the returned buffer, call
|
||
/// the WTSFreeMemory function.
|
||
/// </para>
|
||
/// <para>Session permissions:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// To enumerate a session, you must enable the query information permission. For more information, see Remote Desktop Services Permissions.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>To change permissions on a session, use the Remote Desktop Services Configuration administrative tool.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// 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.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="pCount">A pointer to the number of <c>WTS_SESSION_INFO</c> structures returned in the ppSessionInfo parameter.</param>
|
||
/// <returns>
|
||
/// <para>Returns zero if this function fails. If this function succeeds, a nonzero value is returned.</para>
|
||
/// <para>To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>For more information, and an extended example on how to use this function, see the following kb article.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// 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 <c>WTS_CURRENT_SERVER_HANDLE</c>.
|
||
/// </param>
|
||
/// <param name="pLevel">
|
||
/// This parameter is reserved. Always set this parameter to one. On output, <c>WTSEnumerateSessionsEx</c> does not change the value
|
||
/// of this parameter.
|
||
/// </param>
|
||
/// <param name="Filter">This parameter is reserved. Always set this parameter to zero.</param>
|
||
/// <param name="ppSessionInfo">
|
||
/// A pointer to a <c>PWTS_SESSION_INFO_1</c> 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 <c>NULL</c>.
|
||
/// </param>
|
||
/// <param name="pCount">
|
||
/// A pointer to a <c>DWORD</c> variable that receives the number of WTS_SESSION_INFO_1 structures returned in the ppSessionInfo buffer.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// 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 <c>WTSTypeSessionInfoLevel1</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// 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 <c>WTS_CURRENT_SERVER_HANDLE</c>.
|
||
/// </param>
|
||
/// <param name="ppSessionInfo">
|
||
/// 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.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// 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 <c>WTSTypeSessionInfoLevel1</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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<WTS_SESSION_INFO_1>((int)cnt);
|
||
}
|
||
finally
|
||
{
|
||
WTSFreeMemoryEx(WTS_TYPE_CLASS.WTSTypeSessionInfoLevel1, ptr, cnt);
|
||
}
|
||
return true;
|
||
}
|
||
ppSessionInfo = null;
|
||
return false;
|
||
}
|
||
|
||
/// <summary>Frees memory allocated by a Remote Desktop Services function.</summary>
|
||
/// <param name="pMemory">Pointer to the memory to free.</param>
|
||
/// <returns>None</returns>
|
||
/// <remarks>
|
||
/// Several Remote Desktop Services functions allocate buffers to return information. Use the <c>WTSFreeMemory</c> function to free
|
||
/// these buffers.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// Frees memory that contains WTS_PROCESS_INFO_EX or WTS_SESSION_INFO_1 structures allocated by a Remote Desktop Services function.
|
||
/// </summary>
|
||
/// <param name="WTSTypeClass">
|
||
/// A value of the WTS_TYPE_CLASS enumeration type that specifies the type of structures contained in the buffer referenced by the
|
||
/// pMemory parameter.
|
||
/// </param>
|
||
/// <param name="pMemory">A pointer to the buffer to free.</param>
|
||
/// <param name="NumberOfEntries">The number of elements in the buffer referenced by the pMemory parameter.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// 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 <c>WTSFreeMemoryEx</c> function. To free other buffers,
|
||
/// you can call either the WTSFreeMemory function or the <c>WTSFreeMemoryEx</c> function.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Retrieves the child session identifier, if present.</summary>
|
||
/// <param name="pSessionId">
|
||
/// The address of a <c>ULONG</c> variable that receives the child session identifier. This will be ( <c>ULONG</c>)–1 if there is no
|
||
/// child session for the current session.
|
||
/// </param>
|
||
/// <returns>Returns nonzero if the function succeeds or zero otherwise.</returns>
|
||
/// <remarks>For more information about child sessions, see Child Sessions.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Retrieves the security descriptor of a Remote Desktop Services listener.</summary>
|
||
/// <param name="hServer">A handle to an RD Session Host server. Always set this parameter to <c>WTS_CURRENT_SERVER_HANDLE</c>.</param>
|
||
/// <param name="pReserved">This parameter is reserved. Always set this parameter to <c>NULL</c>.</param>
|
||
/// <param name="Reserved">This parameter is reserved. Always set this parameter to zero.</param>
|
||
/// <param name="pListenerName">A pointer to a null-terminated string that contains the name of the listener.</param>
|
||
/// <param name="SecurityInformation">
|
||
/// <para>
|
||
/// A SECURITY_INFORMATION value that specifies the security information to retrieve. Always enable the
|
||
/// <c>DACL_SECURITY_INFORMATION</c> and <c>SACL_SECURITY_INFORMATION</c> flags.
|
||
/// </para>
|
||
/// <para>For more information about possible values, see SECURITY_INFORMATION.</para>
|
||
/// </param>
|
||
/// <param name="pSecurityDescriptor">
|
||
/// <para>
|
||
/// A pointer to a SECURITY_DESCRIPTOR structure that receives the security information associated with the listener referenced by
|
||
/// the pListenerName parameter. The <c>SECURITY_DESCRIPTOR</c> structure is returned in self-relative format. For more information
|
||
/// about possible values, see <c>SECURITY_DESCRIPTOR</c>.
|
||
/// </para>
|
||
/// <para>The discretionary access control list (DACL) of the security descriptor can contain one or more of the following values.</para>
|
||
/// <para>WTS_SECURITY_ALL_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>STANDARD_RIGHTS_REQUIRED</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_CONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_DISCONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_LOGON</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_MESSAGE</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_QUERY_INFORMATION</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_REMOTE_CONTROL</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_RESET</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_SET_INFORMATION</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_VIRTUAL_CHANNELS</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_CONNECT (256 (0x100))</para>
|
||
/// <para>The right to connect.</para>
|
||
/// <para>WTS_SECURITY_CURRENT_GUEST_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_LOGOFF</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_VIRTUAL_CHANNELS</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_CURRENT_USER_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_DISCONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_LOGOFF</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_RESET</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_SET_INFORMATION</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_VIRTUAL_CHANNELS</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_DISCONNECT (512 (0x200))</para>
|
||
/// <para>The right to disconnect.</para>
|
||
/// <para>WTS_SECURITY_GUEST_ACCESS</para>
|
||
/// <para>Defined as <c>WTS_SECURITY_LOGON</c>.</para>
|
||
/// <para>WTS_SECURITY_LOGOFF (64 (0x40))</para>
|
||
/// <para>The right to log off.</para>
|
||
/// <para>WTS_SECURITY_LOGON (32 (0x20))</para>
|
||
/// <para>The right to log on.</para>
|
||
/// <para>WTS_SECURITY_MESSAGE (128 (0x80))</para>
|
||
/// <para>The right to send a message to the user.</para>
|
||
/// <para>WTS_SECURITY_QUERY_INFORMATION (1 (0x1))</para>
|
||
/// <para>The right to query for information.</para>
|
||
/// <para>WTS_SECURITY_REMOTE_CONTROL (16 (0x10))</para>
|
||
/// <para>The right to use remote control.</para>
|
||
/// <para>WTS_SECURITY_RESET (4 (0x4))</para>
|
||
/// <para>The right to reset information.</para>
|
||
/// <para>WTS_SECURITY_SET_INFORMATION (2 (0x2))</para>
|
||
/// <para>The right to set information.</para>
|
||
/// <para>WTS_SECURITY_USER_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_CONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_CURRENT_GUEST_ACCESS</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_QUERY_INFORMATION</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_VIRTUAL_CHANNELS (8 (0x8))</para>
|
||
/// <para>The right to use virtual channels.</para>
|
||
/// </param>
|
||
/// <param name="nLength">The size, in bytes, of the SECURITY_DESCRIPTOR structure referenced by the pSecurityDescriptor parameter.</param>
|
||
/// <param name="lpnLengthNeeded">
|
||
/// 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.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// 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.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Determines whether child sessions are enabled.</summary>
|
||
/// <param name="pbEnabled">
|
||
/// The address of a <c>BOOL</c> variable that receives a nonzero value if child sessions are enabled or zero otherwise.
|
||
/// </param>
|
||
/// <returns>Returns nonzero if the function succeeds or zero otherwise.</returns>
|
||
/// <remarks>For more information about child sessions, see Child Sessions.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Logs off a specified Remote Desktop Services session.</summary>
|
||
/// <param name="hServer">
|
||
/// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer or WTSOpenServerEx function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// A Remote Desktop Services session identifier. To indicate the current session, specify <c>WTS_CURRENT_SESSION</c>. You can use
|
||
/// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="bWait">
|
||
/// <para>Indicates whether the operation is synchronous.</para>
|
||
/// <para>If bWait is <c>TRUE</c>, the function returns when the session is logged off.</para>
|
||
/// <para>
|
||
/// If bWait is <c>FALSE</c>, the function returns immediately. To verify that the session has been logged off, specify the session
|
||
/// identifier in a call to the WTSQuerySessionInformation function. <c>WTSQuerySessionInformation</c> returns zero if the session
|
||
/// is logged off.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Opens a handle to the specified Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
/// <param name="pServerName">Pointer to a null-terminated string specifying the NetBIOS name of the RD Session Host server.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to the specified server.</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>When you have finished using the handle returned by <c>WTSOpenServer</c>, release it by calling the WTSCloseServer function.</para>
|
||
/// <para>
|
||
/// 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 <c>WTS_CURRENT_SERVER_HANDLE</c> instead.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// Opens a handle to the specified Remote Desktop Session Host (RD Session Host) server or Remote Desktop Virtualization Host (RD
|
||
/// Virtualization Host) server.
|
||
/// </summary>
|
||
/// <param name="pServerName">A pointer to a null-terminated string that contains the NetBIOS name of the server.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to the specified server.</para>
|
||
/// <para>
|
||
/// If the function fails, it returns an invalid handle. You can test the validity of the handle by using it in another function call.
|
||
/// </para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// To work with sessions running on virtual machines on the RD Virtualization Host server on which the calling application is
|
||
/// running, specify <c>WTS_CURRENT_SERVER_NAME</c> for the pServerName parameter.
|
||
/// </para>
|
||
/// <para>When you have finished using the handle returned by this function, release it by calling the WTSCloseServer function.</para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Retrieves configuration information for a Remote Desktop Services listener.</summary>
|
||
/// <param name="hServer">A handle to an RD Session Host server. Always set this parameter to <c>WTS_CURRENT_SERVER_HANDLE</c>.</param>
|
||
/// <param name="pReserved">This parameter is reserved. Always set this parameter to <c>NULL</c>.</param>
|
||
/// <param name="Reserved">This parameter is reserved. Always set this parameter to zero.</param>
|
||
/// <param name="pListenerName">A pointer to a null-terminated string that contains the name of the listener to query.</param>
|
||
/// <param name="pBuffer">A pointer to a WTSLISTENERCONFIG structure that receives the retrieved listener configuration information.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// This function does not retrieve the security descriptor for the listener. To retrieve the security descriptor, call the
|
||
/// WTSGetListenerSecurity function.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// A Remote Desktop Services session identifier. To indicate the session in which the calling application is running (or the
|
||
/// current session) specify <c>WTS_CURRENT_SESSION</c>. Only specify <c>WTS_CURRENT_SESSION</c> when obtaining session information
|
||
/// on the local server. If <c>WTS_CURRENT_SESSION</c> is specified when querying session information on a remote server, the
|
||
/// returned session information will be inconsistent. Do not use the returned data.
|
||
/// </para>
|
||
/// <para>
|
||
/// You can use the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="WTSInfoClass">
|
||
/// A value of the WTS_INFO_CLASS enumeration that indicates the type of session information to retrieve in a call to the
|
||
/// <c>WTSQuerySessionInformation</c> function.
|
||
/// </param>
|
||
/// <param name="ppBuffer">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="pBytesReturned">A pointer to a variable that receives the size, in bytes, of the data returned in ppBuffer.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// To retrieve the session ID for the current session when Remote Desktop Services is running, call
|
||
/// <c>WTSQuerySessionInformation</c> and specify <c>WTS_CURRENT_SESSION</c> for the SessionId parameter and <c>WTSSessionId</c> for
|
||
/// the WTSInfoClass parameter. The session ID will be returned in the ppBuffer parameter. If Remote Desktop Services is not
|
||
/// running, calls to <c>WTSQuerySessionInformation</c> fail. In this situation, you can retrieve the current session ID by calling
|
||
/// the ProcessIdToSessionId function.
|
||
/// </para>
|
||
/// <para>
|
||
/// To determine whether your application is running on the physical console, you must specify <c>WTS_CURRENT_SESSION</c> for the
|
||
/// SessionId parameter, and <c>WTSClientProtocolType</c> as the WTSInfoClass parameter. If ppBuffer is "0", the session is attached
|
||
/// to the physical console.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// Retrieves configuration information for the specified user on the specified domain controller or Remote Desktop Session Host (RD
|
||
/// Session Host) server.
|
||
/// </summary>
|
||
/// <param name="pServerName">
|
||
/// Pointer to a null-terminated string containing the name of a domain controller or an RD Session Host server. Specify
|
||
/// <c>WTS_CURRENT_SERVER_NAME</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="pUserName">
|
||
/// <para>
|
||
/// 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 <c>NULL</c>.
|
||
/// </para>
|
||
/// <para><c>Windows Server 2008 and Windows Vista:</c> Setting this parameter to <c>NULL</c> returns an error.</para>
|
||
/// </param>
|
||
/// <param name="WTSConfigClass">
|
||
/// 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 <c>WTS_CONFIG_CLASS</c> describes the format of the data returned in ppBuffer for each of the
|
||
/// information types.
|
||
/// </param>
|
||
/// <param name="ppBuffer">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="pBytesReturned">Pointer to a variable that receives the size, in bytes, of the data returned in ppBuffer.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// The <c>WTSQueryUserConfig</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// Any domain controller can set or query user configuration information. Use the DsGetDcName function to retrieve the name of a
|
||
/// domain controller.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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 <c>SE_TCB_NAME</c> privilege.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>Caution</c><c>WTSQueryUserToken</c> 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.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="phToken">
|
||
/// 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.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// If the function succeeds, the return value is a nonzero value, and the phToken parameter points to the primary token of the user.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the function fails, the return value is zero. To get extended error information, call GetLastError. Among other errors,
|
||
/// <c>GetLastError</c> can return one of the following errors.
|
||
/// </para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// For information about primary tokens, see Access Tokens. For more information about account privileges, see Remote Desktop
|
||
/// Services Permissions and Authorization Constants.
|
||
/// </para>
|
||
/// <para>See LocalSystem account for information about the privileges associated with that account.</para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Registers the specified window to receive session change notifications.</summary>
|
||
/// <param name="hWnd">Handle of the window to receive session change notifications.</param>
|
||
/// <param name="dwFlags">
|
||
/// <para>Specifies which session notifications are to be received. This parameter can be one of the following values.</para>
|
||
/// <para>0 - NOTIFY_FOR_THIS_SESSION</para>
|
||
/// <para>
|
||
/// Only session notifications involving the session attached to by the window identified by the hWnd parameter value are to be received.
|
||
/// </para>
|
||
/// <para>1 - NOTIFY_FOR_ALL_SESSIONS</para>
|
||
/// <para>All session notifications are to be received.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// If the function succeeds, the return value is <c>TRUE</c>. Otherwise, it is <c>FALSE</c>. To get extended error information,
|
||
/// call GetLastError.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// If this function is called before the dependent services of Remote Desktop Services have started, an
|
||
/// <c>RPC_S_INVALID_BINDING</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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 <c>WTSUnRegisterSessionNotification</c>.
|
||
/// </para>
|
||
/// <para>If the window handle passed in this function is already registered, the value of the dwFlags parameter is ignored.</para>
|
||
/// <para>To receive session change notifications from a service, use the HandlerEx function.</para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Registers the specified window to receive session change notifications.</summary>
|
||
/// <param name="hServer">Handle of the server returned from WTSOpenServer or <c>WTS_CURRENT_SERVER</c>.</param>
|
||
/// <param name="hWnd">Handle of the window to receive session change notifications.</param>
|
||
/// <param name="dwFlags">
|
||
/// <para>
|
||
/// Specifies which session notifications are to be received. This parameter can only be <c>NOTIFY_FOR_THIS_SESSION</c> if hServer
|
||
/// is a remote server.
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>NOTIFY_FOR_THIS_SESSION (0)
|
||
/// <para>
|
||
/// Only session notifications involving the session attached to by the window identified by the hWnd parameter value are to be received.
|
||
/// </para>
|
||
/// </item>
|
||
/// <item>NOTIFY_FOR_ALL_SESSIONS (1)
|
||
/// <para>All session notifications are to be received.</para>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <returns>
|
||
/// If the function succeeds, the return value is <c>TRUE</c>. Otherwise, it is <c>FALSE</c>. To get extended error information,
|
||
/// call GetLastError.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// If this function is called before the dependent services of Remote Desktop Services have started, an
|
||
/// <c>RPC_S_INVALID_BINDING</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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 <c>WTSUnRegisterSessionNotificationEx</c>.
|
||
/// </para>
|
||
/// <para>If the window handle passed in this function is already registered, the value of the dwFlags parameter is ignored.</para>
|
||
/// <para>To receive session change notifications from a service, use the HandlerEx function.</para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Displays a message box on the client desktop of a specified Remote Desktop Services session.</summary>
|
||
/// <param name="hServer">
|
||
/// A handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// A Remote Desktop Services session identifier. To indicate the current session, specify <c>WTS_CURRENT_SESSION</c>. You can use
|
||
/// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="pTitle">A pointer to a null-terminated string for the title bar of the message box.</param>
|
||
/// <param name="TitleLength">The length, in bytes, of the title bar string.</param>
|
||
/// <param name="pMessage">A pointer to a null-terminated string that contains the message to display.</param>
|
||
/// <param name="MessageLength">The length, in bytes, of the message string.</param>
|
||
/// <param name="Style">
|
||
/// The contents and behavior of the message box. This value is typically <c>MB_OK</c>. For a complete list of values, see the uType
|
||
/// parameter of the MessageBox function.
|
||
/// </param>
|
||
/// <param name="Timeout">
|
||
/// The time, in seconds, that the <c>WTSSendMessage</c> function waits for the user's response. If the user does not respond within
|
||
/// the time-out interval, the pResponse parameter returns <c>IDTIMEOUT</c>. If the Timeout parameter is zero, <c>WTSSendMessage</c>
|
||
/// waits indefinitely for the user to respond.
|
||
/// </param>
|
||
/// <param name="pResponse">
|
||
/// <para>A pointer to a variable that receives the user's response, which can be one of the following values.</para>
|
||
/// <para>IDABORT (3)</para>
|
||
/// <para><c>Abort</c></para>
|
||
/// <para>IDCANCEL (2)</para>
|
||
/// <para><c>Cancel</c></para>
|
||
/// <para>IDCONTINUE (11)</para>
|
||
/// <para><c>Continue</c></para>
|
||
/// <para>IDIGNORE (5)</para>
|
||
/// <para><c>Ignore</c></para>
|
||
/// <para>IDNO (7)</para>
|
||
/// <para><c>No</c></para>
|
||
/// <para>IDOK (1)</para>
|
||
/// <para><c>OK</c></para>
|
||
/// <para>IDRETRY (4)</para>
|
||
/// <para><c>Retry</c></para>
|
||
/// <para>IDTRYAGAIN (10)</para>
|
||
/// <para><c>Try Again</c></para>
|
||
/// <para>IDYES (6)</para>
|
||
/// <para><c>Yes</c></para>
|
||
/// <para>IDASYNC (32001 (0x7D01))</para>
|
||
/// <para>The bWait parameter was <c>FALSE</c>, so the function returned without waiting for a response.</para>
|
||
/// <para>IDTIMEOUT (32000 (0x7D00))</para>
|
||
/// <para>The bWait parameter was <c>TRUE</c> and the time-out interval elapsed.</para>
|
||
/// </param>
|
||
/// <param name="bWait">
|
||
/// <para>
|
||
/// If <c>TRUE</c>, <c>WTSSendMessage</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// If <c>FALSE</c>, the function returns immediately and the pResponse parameter returns <c>IDASYNC</c>. 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks/>
|
||
// 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);
|
||
|
||
/// <summary>Configures the security descriptor of a Remote Desktop Services listener.</summary>
|
||
/// <param name="hServer">A handle to an RD Session Host server. Always set this parameter to <c>WTS_CURRENT_SERVER_HANDLE</c>.</param>
|
||
/// <param name="pReserved">This parameter is reserved. Always set this parameter to <c>NULL</c>.</param>
|
||
/// <param name="Reserved">This parameter is reserved. Always set this parameter to zero.</param>
|
||
/// <param name="pListenerName">A pointer to a null-terminated string that contains the name of the listener.</param>
|
||
/// <param name="SecurityInformation">
|
||
/// <para>
|
||
/// A SECURITY_INFORMATION value that specifies the security information to set. Always enable the <c>DACL_SECURITY_INFORMATION</c>
|
||
/// and <c>SACL_SECURITY_INFORMATION</c> flags.
|
||
/// </para>
|
||
/// <para>For more information about possible values, see SECURITY_INFORMATION.</para>
|
||
/// </param>
|
||
/// <param name="pSecurityDescriptor">
|
||
/// <para>
|
||
/// A pointer to a SECURITY_DESCRIPTOR structure that contains the security information associated with the listener. For more
|
||
/// information about possible values, see <c>SECURITY_DESCRIPTOR</c>. For information about <c>STANDARD_RIGHTS_REQUIRED</c>, see
|
||
/// Standard Access Rights.
|
||
/// </para>
|
||
/// <para>The discretionary access control list (DACL) of the security descriptor can contain one or more of the following values.</para>
|
||
/// <para>WTS_SECURITY_ALL_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>STANDARD_RIGHTS_REQUIRED</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_CONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_DISCONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_LOGON</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_MESSAGE</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_QUERY_INFORMATION</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_REMOTE_CONTROL</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_RESET</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_SET_INFORMATION</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_VIRTUAL_CHANNELS</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_CONNECT (256 (0x100))</para>
|
||
/// <para>The right to connect.</para>
|
||
/// <para>WTS_SECURITY_CURRENT_GUEST_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_LOGOFF</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_VIRTUAL_CHANNELS</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_CURRENT_USER_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_DISCONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_LOGOFF</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_RESET</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_SET_INFORMATION</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_VIRTUAL_CHANNELS</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_DISCONNECT (512 (0x200))</para>
|
||
/// <para>The right to disconnect.</para>
|
||
/// <para>WTS_SECURITY_GUEST_ACCESS</para>
|
||
/// <para>Defined as <c>WTS_SECURITY_LOGON</c>.</para>
|
||
/// <para>WTS_SECURITY_LOGOFF (64 (0x40))</para>
|
||
/// <para>The right to log off.</para>
|
||
/// <para>WTS_SECURITY_LOGON (32 (0x20))</para>
|
||
/// <para>The right to log on.</para>
|
||
/// <para>WTS_SECURITY_MESSAGE (128 (0x80))</para>
|
||
/// <para>The right to send a message to the user.</para>
|
||
/// <para>WTS_SECURITY_QUERY_INFORMATION (1 (0x1))</para>
|
||
/// <para>The right to query for information.</para>
|
||
/// <para>WTS_SECURITY_REMOTE_CONTROL (16 (0x10))</para>
|
||
/// <para>The right to use remote control.</para>
|
||
/// <para>WTS_SECURITY_RESET (4 (0x4))</para>
|
||
/// <para>The right to reset information.</para>
|
||
/// <para>WTS_SECURITY_SET_INFORMATION (2 (0x2))</para>
|
||
/// <para>The right to set information.</para>
|
||
/// <para>WTS_SECURITY_USER_ACCESS</para>
|
||
/// <para>Combines these values:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_CONNECT</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_CURRENT_GUEST_ACCESS</c></term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>WTS_SECURITY_QUERY_INFORMATION</c></term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>WTS_SECURITY_VIRTUAL_CHANNELS (8 (0x8))</para>
|
||
/// <para>The right to use virtual channels.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call the GetLastError function.</para>
|
||
/// </returns>
|
||
/// <remarks/>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// Modifies configuration information for the specified user on the specified domain controller or Remote Desktop Session Host (RD
|
||
/// Session Host) server.
|
||
/// </summary>
|
||
/// <param name="pServerName">
|
||
/// Pointer to a null-terminated string containing the name of a domain controller or RD Session Host server. Specify
|
||
/// <c>WTS_CURRENT_SERVER_NAME</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="pUserName">Pointer to a null-terminated string containing the name of the user whose configuration is being set.</param>
|
||
/// <param name="WTSConfigClass">
|
||
/// 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 <c>WTS_CONFIG_CLASS</c> describes the format of the data specified in ppBuffer for each
|
||
/// of the information types.
|
||
/// </param>
|
||
/// <param name="pBuffer">Pointer to the data used to modify the specified user's configuration.</param>
|
||
/// <param name="DataLength">Size, in <c>TCHARs</c>, of the pBuffer buffer.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// The WTSQueryUserConfig and <c>WTSSetUserConfig</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// Any domain controller can set or query user configuration information. Use the DsGetDcName function to retrieve the name of a
|
||
/// domain controller.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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 <c>DWORD</c>. Then cast the value to an <c>LPWSTR</c> in the call to <c>WTSSetUserConfig</c>, as in the
|
||
/// following example:
|
||
/// </para>
|
||
/// <para>
|
||
/// <code>WTSSetUserConfig( strServer.GetBuffer(0), m_strName.GetBuffer(0), WTSUserConfigfAllowLogonTerminalServer, (LPWSTR) &dwEnable, sizeof(DWORD));</code>
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// <para>Shuts down (and optionally restarts) the specified Remote Desktop Session Host (RD Session Host) server.</para>
|
||
/// <para>
|
||
/// To shut down or restart the system, the calling process must have the <c>SE_SHUTDOWN_NAME</c> privilege enabled. For more
|
||
/// information about security privileges, see Privileges and Authorization Constants.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hServer">
|
||
/// Handle to an RD Session Host server. Specify a handle opened by the WTSOpenServer function, or specify
|
||
/// <c>WTS_CURRENT_SERVER_HANDLE</c> to indicate the RD Session Host server on which your application is running.
|
||
/// </param>
|
||
/// <param name="ShutdownFlag">
|
||
/// <para>Indicates the type of shutdown. This parameter can be one of the following values.</para>
|
||
/// <para>WTS_WSD_LOGOFF</para>
|
||
/// <para>
|
||
/// Forces all client sessions to log off (except the session calling <c>WTSShutdownSystem</c>) 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.
|
||
/// </para>
|
||
/// <para>Use this value only on the Remote Desktop Services console.</para>
|
||
/// <para>WTS_WSD_POWEROFF</para>
|
||
/// <para>
|
||
/// 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 <c>EWX_SHUTDOWN</c> and <c>EWX_POWEROFF</c>. The calling process must
|
||
/// have the <c>SE_SHUTDOWN_NAME</c> privilege enabled.
|
||
/// </para>
|
||
/// <para>WTS_WSD_REBOOT</para>
|
||
/// <para>
|
||
/// Shuts down and then restarts the system on the RD Session Host server. This is equivalent to calling <c>ExitWindowsEx</c> with
|
||
/// <c>EWX_REBOOT</c>. The calling process must have the <c>SE_SHUTDOWN_NAME</c> privilege enabled.
|
||
/// </para>
|
||
/// <para>WTS_WSD_SHUTDOWN</para>
|
||
/// <para>
|
||
/// Shuts down the system on the RD Session Host server. This is equivalent to calling the ExitWindowsEx function with
|
||
/// <c>EWX_SHUTDOWN</c>. The calling process must have the <c>SE_SHUTDOWN_NAME</c> privilege enabled.
|
||
/// </para>
|
||
/// <para>WTS_WSD_FASTREBOOT</para>
|
||
/// <para>This value is not supported currently.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is nonzero.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>A system shutdown terminates all users and active programs. The following steps occur during shutdown.</para>
|
||
/// <list type="number">
|
||
/// <item>
|
||
/// <term>An exit command is issued to all active user applications.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>If the application does not exit within a specific interval, the application is terminated.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>After all the applications for a user terminate, the user is logged off.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>After all users are logged off, an exit command is issued to all system services.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>If the system service does not terminate within a specific interval, the service is terminated.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>The file system cache is written to disk.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>The disks are marked read-only.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// The RD Session Host server displays the message "It is now safe to turn off your computer", or the system is restarted if
|
||
/// <c>WTS_WSD_REBOOT</c> is specified. (The message is displayed on the console because all client sessions have been terminated.)
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// <c>Note</c> 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>Windows Server 2008 and Windows Vista:</c> A call to <c>WTSShutdownSystem</c> does not work when Remote Connection Manager
|
||
/// (RCM) is disabled. This is the case when the Remote Desktop Services service is stopped.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// Starts the remote control of another Remote Desktop Services session. You must call this function from a remote session.
|
||
/// </summary>
|
||
/// <param name="pTargetServerName">A pointer to the name of the server where the session that you want remote control of exists.</param>
|
||
/// <param name="TargetLogonId">The logon ID of the session that you want remote control of.</param>
|
||
/// <param name="HotkeyVk">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="HotkeyModifiers">
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// For example, if the <c>WTSStartRemoteControlSession</c> function is called with HotkeyVk set to <c>VK_MULTIPLY</c> and
|
||
/// HotkeyModifiers set to <c>REMOTECONTROL_KBDCTRL_HOTKEY</c>, 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.
|
||
/// </para>
|
||
/// <para>REMOTECONTROL_KBDSHIFT_HOTKEY</para>
|
||
/// <para>The SHIFT key</para>
|
||
/// <para>REMOTECONTROL_KBDCTRL_HOTKEY</para>
|
||
/// <para>The CTRL key</para>
|
||
/// <para>REMOTECONTROL_KBDALT_HOTKEY</para>
|
||
/// <para>The ALT key</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks/>
|
||
// 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);
|
||
|
||
/// <summary>Stops a remote control session.</summary>
|
||
/// <param name="LogonId">The logon ID of the session that you want to stop the remote control of.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Terminates the specified process on the specified Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
/// <param name="hServer">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="ProcessId">Specifies the process identifier of the process to terminate.</param>
|
||
/// <param name="ExitCode">Specifies the exit code for the terminated process.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Unregisters the specified window so that it receives no further session change notifications.</summary>
|
||
/// <param name="hWnd">Handle of the window to be unregistered from receiving session notifications.</param>
|
||
/// <returns>
|
||
/// If the function succeeds, the return value is <c>TRUE</c>. Otherwise, it is <c>FALSE</c>. To get extended error information,
|
||
/// call GetLastError.
|
||
/// </returns>
|
||
/// <remarks>This function must be called once for every call to the WTSRegisterSessionNotification function.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Unregisters the specified window so that it receives no further session change notifications.</summary>
|
||
/// <param name="hServer">Handle of the server returned from WTSOpenServer or <c>WTS_CURRENT_SERVER</c>.</param>
|
||
/// <param name="hWnd">Handle of the window to be unregistered from receiving session notifications.</param>
|
||
/// <returns>
|
||
/// If the function succeeds, the return value is <c>TRUE</c>. Otherwise, it is <c>FALSE</c>. To get extended error information,
|
||
/// call GetLastError.
|
||
/// </returns>
|
||
/// <remarks>This function must be called once for every call to the WTSRegisterSessionNotificationEx function.</remarks>
|
||
// 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);
|
||
|
||
/// <summary>Closes an open virtual channel handle.</summary>
|
||
/// <param name="hChannelHandle">Handle to a virtual channel opened by the WTSVirtualChannelOpen function.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// <para>Opens a handle to the server end of a specified virtual channel.</para>
|
||
/// <para>This function is obsolete. Instead, use the WTSVirtualChannelOpenEx function.</para>
|
||
/// </summary>
|
||
/// <param name="hServer">This parameter must be WTS_CURRENT_SERVER_HANDLE.</param>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// A Remote Desktop Services session identifier. To indicate the current session, specify <c>WTS_CURRENT_SESSION</c>. You can use
|
||
/// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="pVirtualName">
|
||
/// A pointer to a <c>null</c>-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 <c>null</c>.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a handle to the specified virtual channel.</para>
|
||
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>When you have finished using the handle, release it by calling the WTSVirtualChannelClose function.</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// <para>Creates a virtual channel in a manner similar to WTSVirtualChannelOpen.</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="SessionId">
|
||
/// <para>
|
||
/// A Remote Desktop Services session identifier. To indicate the current session, specify <c>WTS_CURRENT_SESSION</c>. You can use
|
||
/// the WTSEnumerateSessions function to retrieve the identifiers of all sessions on a specified RD Session Host server.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="pVirtualName">
|
||
/// <para>
|
||
/// 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 <c>CHANNEL_NAME_LEN</c> characters, not including the terminating null.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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 <c>MAX_PATH</c> characters.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="flags">
|
||
/// <para>To open the channel as an SVC, specify zero for this parameter. To open the channel as a DVC, specify <c>WTS_CHANNEL_OPTION_DYNAMIC</c>.</para>
|
||
/// <para>
|
||
/// When opening a DVC, you can specify a priority setting for the data that is being transferred by specifying one of the
|
||
/// <c>WTS_CHANNEL_OPTION_DYNAMIC_PRI_XXX</c> values in combination with the <c>WTS_CHANNEL_OPTION_DYNAMIC</c> value.
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <strong>WTS_CHANNEL_OPTION_DYNAMIC_NO_COMPRESS</strong><br/> Disables compression for this DVC. You must specify this value in
|
||
/// combination with the <c>WTS_CHANNEL_OPTION_DYNAMIC</c> value.
|
||
/// </item>
|
||
/// <item>
|
||
/// <strong>WTS_CHANNEL_OPTION_DYNAMIC_PRI_LOW</strong> (default) <br/> 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.
|
||
/// </item>
|
||
/// <item>
|
||
/// <strong>WTS_CHANNEL_OPTION_DYNAMIC_PRI_MED</strong><br/> Medium priority. Use this priority level to send short control messages
|
||
/// that must have priority over the data in the low priority channels.
|
||
/// </item>
|
||
/// <item>
|
||
/// <strong>WTS_CHANNEL_OPTION_DYNAMIC_PRI_HIGH</strong><br/> 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.
|
||
/// </item>
|
||
/// <item>
|
||
/// <strong>WTS_CHANNEL_OPTION_DYNAMIC_PRI_REAL</strong><br/> 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.
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <returns><c>NULL</c> on error with GetLastError set.</returns>
|
||
// 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);
|
||
|
||
/// <summary>Deletes all queued input data sent from the client to the server on a specified virtual channel.</summary>
|
||
/// <param name="hChannelHandle">Handle to a virtual channel opened by the WTSVirtualChannelOpen function.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Deletes all queued output data sent from the server to the client on a specified virtual channel.</summary>
|
||
/// <param name="hChannelHandle">Handle to a virtual channel opened by the WTSVirtualChannelOpen function.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Returns information about a specified virtual channel.</summary>
|
||
/// <param name="hChannelHandle">Handle to a virtual channel opened by the WTSVirtualChannelOpen function.</param>
|
||
/// <param name="WTSVirtualClass">Specifies the type of information to get for the channel.</param>
|
||
/// <param name="ppBuffer">Pointer to a buffer that receives the requested information.</param>
|
||
/// <param name="pBytesReturned">Pointer to a variable that receives the number of bytes returned in the ppBuffer parameter.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// 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 <c>WTSVirtualChannelQuery</c>.
|
||
/// </para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// 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
|
||
/// <c>WTSVirtualChannelQuery</c> function, specifying the WTSVirtualFileHandle virtual class type. <c>WTSVirtualChannelQuery</c>
|
||
/// returns a file handle that you can use to perform asynchronous (overlapped) read and write operations. Finally, the code frees
|
||
/// the memory allocated by <c>WTSVirtualChannelQuery</c> with a call to the WTSFreeMemory function, and closes the virtual channel
|
||
/// with a call to the WTSVirtualChannelClose function.
|
||
/// </para>
|
||
/// <para>
|
||
/// Note that you should not explicitly close the file handle obtained by calling <c>WTSVirtualChannelQuery</c>. This is because
|
||
/// WTSVirtualChannelClose closes the file handle.
|
||
/// </para>
|
||
/// <para>
|
||
/// <code> 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; }</code>
|
||
/// </para>
|
||
/// <para>For more information about overlapped mode, see Synchronization and Overlapped Input and Output.</para>
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>
|
||
/// <para>Reads data from the server end of a virtual channel.</para>
|
||
/// <para><c>WTSVirtualChannelRead</c> reads the data written by a VirtualChannelWrite call at the client end of the virtual channel.</para>
|
||
/// </summary>
|
||
/// <param name="hChannelHandle">Handle to a virtual channel opened by the WTSVirtualChannelOpen function.</param>
|
||
/// <param name="TimeOut">
|
||
/// Specifies the time-out, in milliseconds. If TimeOut is zero, <c>WTSVirtualChannelRead</c> 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.
|
||
/// </param>
|
||
/// <param name="Buffer">
|
||
/// <para>
|
||
/// 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 <c>WTSVirtualChannelRead</c> call is <c>CHANNEL_CHUNK_LENGTH</c> bytes. If the client's
|
||
/// VirtualChannelWrite call writes a larger block of data, the server must make multiple <c>WTSVirtualChannelRead</c> calls.
|
||
/// </para>
|
||
/// <para>
|
||
/// In certain cases, Remote Desktop Services places a <c>CHANNEL_PDU_HEADER</c> structure at the beginning of each chunk of data
|
||
/// read by the <c>WTSVirtualChannelRead</c> function. This will occur if the client DLL sets the
|
||
/// <c>CHANNEL_OPTION_SHOW_PROTOCOL</c> 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.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="BufferSize">
|
||
/// Specifies the size, in bytes, of Buffer. If the chunk of data in Buffer will be preceded by a <c>CHANNEL_PDU_HEADER</c>
|
||
/// structure, the value of this parameter should be at least <c>CHANNEL_PDU_LENGTH</c>. Otherwise, the value of this parameter
|
||
/// should be at least <c>CHANNEL_CHUNK_LENGTH</c>.
|
||
/// </param>
|
||
/// <param name="pBytesRead">Pointer to a variable that receives the number of bytes read.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <c>Note</c><c>WTSVirtualChannelRead</c> is not thread safe. To access a virtual channel from multiple threads, or to do
|
||
/// asynchronous IO through a virtual channel, use WTSVirtualChannelQuery with <c>WTSVirtualFileHandle</c>.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Writes data to the server end of a virtual channel.</summary>
|
||
/// <param name="hChannelHandle">Handle to a virtual channel opened by the WTSVirtualChannelOpen function.</param>
|
||
/// <param name="Buffer">Pointer to a buffer containing the data to write to the virtual channel.</param>
|
||
/// <param name="Length">Specifies the size, in bytes, of the data to write.</param>
|
||
/// <param name="pBytesWritten">Pointer to a variable that receives the number of bytes written.</param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <c>Note</c><c>WTSVirtualChannelWrite</c> is not thread safe. To access a virtual channel from multiple threads, or to do
|
||
/// asynchronous IO through a virtual channel, use WTSVirtualChannelQuery with <c>WTSVirtualFileHandle</c>.
|
||
/// </remarks>
|
||
// 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);
|
||
|
||
/// <summary>Waits for a Remote Desktop Services event before returning to the caller.</summary>
|
||
/// <param name="hServer">
|
||
/// 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.
|
||
/// </param>
|
||
/// <param name="EventMask">
|
||
/// <para>
|
||
/// Bitmask that specifies the set of events to wait for. This mask can be WTS_EVENT_FLUSH to cause all pending
|
||
/// <c>WTSWaitSystemEvent</c> calls on the specified RD Session Host server handle to return. Or, the mask can be a combination of
|
||
/// the following values.
|
||
/// </para>
|
||
/// <para>WTS_EVENT_ALL</para>
|
||
/// <para>Wait for any event type.</para>
|
||
/// <para>WTS_EVENT_CONNECT</para>
|
||
/// <para>A client connected to a WinStation.</para>
|
||
/// <para>WTS_EVENT_CREATE</para>
|
||
/// <para>A new WinStation was created.</para>
|
||
/// <para>WTS_EVENT_DELETE</para>
|
||
/// <para>An existing WinStation was deleted.</para>
|
||
/// <para>WTS_EVENT_DISCONNECT</para>
|
||
/// <para>A client disconnected from a WinStation.</para>
|
||
/// <para>WTS_EVENT_LICENSE</para>
|
||
/// <para>The Remote Desktop Services' license state changed. This occurs when a license is added or deleted using License Manager.</para>
|
||
/// <para>WTS_EVENT_LOGOFF</para>
|
||
/// <para>A user logged off from either the Remote Desktop Services console or from a client WinStation.</para>
|
||
/// <para>WTS_EVENT_LOGON</para>
|
||
/// <para>A user logged on to the system from either the Remote Desktop Services console or from a client WinStation.</para>
|
||
/// <para>WTS_EVENT_RENAME</para>
|
||
/// <para>An existing WinStation was renamed.</para>
|
||
/// <para>WTS_EVENT_STATECHANGE</para>
|
||
/// <para>A WinStation connection state changed. For a list of connection states, see the WTS_CONNECTSTATE_CLASS enumeration type.</para>
|
||
/// </param>
|
||
/// <param name="pEventFlags">
|
||
/// 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 <c>WTS_EVENT_NONE</c> if the wait terminated because of a
|
||
/// <c>WTSWaitSystemEvent</c> call with <c>WTS_EVENT_FLUSH</c>.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>If the function succeeds, the return value is a nonzero value.</para>
|
||
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
||
/// </returns>
|
||
// 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);
|
||
|
||
/// <summary>Provides a handle to a virtual channel.</summary>
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct HVIRTUALCHANNEL : IHandle
|
||
{
|
||
private readonly IntPtr handle;
|
||
|
||
/// <summary>Initializes a new instance of the <see cref="HVIRTUALCHANNEL"/> struct.</summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
public HVIRTUALCHANNEL(IntPtr preexistingHandle) => handle = preexistingHandle;
|
||
|
||
/// <summary>Returns an invalid handle by instantiating a <see cref="HVIRTUALCHANNEL"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
||
public static HVIRTUALCHANNEL NULL => new HVIRTUALCHANNEL(IntPtr.Zero);
|
||
|
||
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
||
public bool IsNull => handle == IntPtr.Zero;
|
||
|
||
/// <summary>Performs an explicit conversion from <see cref="HVIRTUALCHANNEL"/> to <see cref="IntPtr"/>.</summary>
|
||
/// <param name="h">The handle.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static explicit operator IntPtr(HVIRTUALCHANNEL h) => h.handle;
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HVIRTUALCHANNEL"/>.</summary>
|
||
/// <param name="h">The pointer to a handle.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static implicit operator HVIRTUALCHANNEL(IntPtr h) => new HVIRTUALCHANNEL(h);
|
||
|
||
/// <summary>Implements the operator !=.</summary>
|
||
/// <param name="h1">The first handle.</param>
|
||
/// <param name="h2">The second handle.</param>
|
||
/// <returns>The result of the operator.</returns>
|
||
public static bool operator !=(HVIRTUALCHANNEL h1, HVIRTUALCHANNEL h2) => !(h1 == h2);
|
||
|
||
/// <summary>Implements the operator ==.</summary>
|
||
/// <param name="h1">The first handle.</param>
|
||
/// <param name="h2">The second handle.</param>
|
||
/// <returns>The result of the operator.</returns>
|
||
public static bool operator ==(HVIRTUALCHANNEL h1, HVIRTUALCHANNEL h2) => h1.Equals(h2);
|
||
|
||
/// <inheritdoc/>
|
||
public override bool Equals(object obj) => obj is HVIRTUALCHANNEL h && handle == h.handle;
|
||
|
||
/// <inheritdoc/>
|
||
public override int GetHashCode() => handle.GetHashCode();
|
||
|
||
/// <inheritdoc/>
|
||
public IntPtr DangerousGetHandle() => handle;
|
||
}
|
||
|
||
/// <summary>Provides a handle to a WTS server.</summary>
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
public struct HWTSSERVER : IHandle
|
||
{
|
||
private readonly IntPtr handle;
|
||
|
||
/// <summary>Initializes a new instance of the <see cref="HWTSSERVER"/> struct.</summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
public HWTSSERVER(IntPtr preexistingHandle) => handle = preexistingHandle;
|
||
|
||
/// <summary>Returns an invalid handle by instantiating a <see cref="HWTSSERVER"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
||
public static readonly HWTSSERVER NULL = new HWTSSERVER(IntPtr.Zero);
|
||
|
||
/// <summary>A constant representing the handle of the current WTS server.</summary>
|
||
public static readonly HWTSSERVER WTS_CURRENT_SERVER_HANDLE = NULL;
|
||
|
||
/// <summary>A constant representing the handle of the current WTS server.</summary>
|
||
public static readonly HWTSSERVER WTS_CURRENT_SERVER = NULL;
|
||
|
||
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
||
public bool IsNull => handle == IntPtr.Zero;
|
||
|
||
/// <summary>Performs an explicit conversion from <see cref="HWTSSERVER"/> to <see cref="IntPtr"/>.</summary>
|
||
/// <param name="h">The handle.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static explicit operator IntPtr(HWTSSERVER h) => h.handle;
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HWTSSERVER"/>.</summary>
|
||
/// <param name="h">The pointer to a handle.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static implicit operator HWTSSERVER(IntPtr h) => new HWTSSERVER(h);
|
||
|
||
/// <summary>Implements the operator !=.</summary>
|
||
/// <param name="h1">The first handle.</param>
|
||
/// <param name="h2">The second handle.</param>
|
||
/// <returns>The result of the operator.</returns>
|
||
public static bool operator !=(HWTSSERVER h1, HWTSSERVER h2) => !(h1 == h2);
|
||
|
||
/// <summary>Implements the operator ==.</summary>
|
||
/// <param name="h1">The first handle.</param>
|
||
/// <param name="h2">The second handle.</param>
|
||
/// <returns>The result of the operator.</returns>
|
||
public static bool operator ==(HWTSSERVER h1, HWTSSERVER h2) => h1.Equals(h2);
|
||
|
||
/// <inheritdoc/>
|
||
public override bool Equals(object obj) => obj is HWTSSERVER h && handle == h.handle;
|
||
|
||
/// <inheritdoc/>
|
||
public override int GetHashCode() => handle.GetHashCode();
|
||
|
||
/// <inheritdoc/>
|
||
public IntPtr DangerousGetHandle() => handle;
|
||
}
|
||
|
||
/// <summary>Contains the client network address of a Remote Desktop Services session.</summary>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>The client network address is also not available in the following cases:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>The connection is established through a Remote Desktop Gateway.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>The connection is originated by the <c>Microsoft Remote Desktop</c> app that is available in the Store.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </remarks>
|
||
// 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
|
||
{
|
||
/// <summary>Address family. This member can be <c>AF_INET</c>, <c>AF_INET6</c>, <c>AF_IPX</c>, <c>AF_NETBIOS</c>, or <c>AF_UNSPEC</c>.</summary>
|
||
public uint AddressFamily;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Client network address. The format of the field of <c>Address</c> depends on the address type as specified by the
|
||
/// <c>AddressFamily</c> member.
|
||
/// </para>
|
||
/// <para>
|
||
/// For an address family <c>AF_INET</c>: <c>Address</c> contains the IPV4 address of the client as a null-terminated string.
|
||
/// </para>
|
||
/// <para>
|
||
/// For an family <c>AF_INET6</c>: <c>Address</c> 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")
|
||
/// </para>
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
|
||
public byte[] Address;
|
||
}
|
||
|
||
/// <summary>Contains information about the display of a Remote Desktop Connection (RDC) client.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>Horizontal dimension, in pixels, of the client's display.</summary>
|
||
public uint HorizontalResolution;
|
||
|
||
/// <summary>Vertical dimension, in pixels, of the client's display.</summary>
|
||
public uint VerticalResolution;
|
||
|
||
/// <summary>
|
||
/// <para>Color depth of the client's display. This member can be one of the following values.</para>
|
||
/// <para>1</para>
|
||
/// <para>4 bits per pixel.</para>
|
||
/// <para>2</para>
|
||
/// <para>8 bits per pixel.</para>
|
||
/// <para>4</para>
|
||
/// <para>16 bits per pixel.</para>
|
||
/// <para>8</para>
|
||
/// <para>A 3-byte RGB values for a maximum of 2^24 colors.</para>
|
||
/// <para>16</para>
|
||
/// <para>15 bits per pixel.</para>
|
||
/// <para>24</para>
|
||
/// <para>24 bits per pixel.</para>
|
||
/// <para>32</para>
|
||
/// <para>32 bits per pixel.</para>
|
||
/// </summary>
|
||
public uint ColorDepth;
|
||
}
|
||
|
||
/// <summary>Contains information about a process running on a Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>Remote Desktop Services session identifier for the session associated with the process.</summary>
|
||
public uint SessionId;
|
||
|
||
/// <summary>Process identifier that uniquely identifies the process on the RD Session Host server.</summary>
|
||
public uint ProcessId;
|
||
|
||
/// <summary>Pointer to a null-terminated string containing the name of the executable file associated with the process.</summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pProcessName;
|
||
|
||
/// <summary>
|
||
/// Pointer to the user Security Identifiers in the process's primary access token. For more information about SIDs and access
|
||
/// tokens, see Access Control.
|
||
/// </summary>
|
||
public PSID pUserSid;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>The Remote Desktop Services session identifier for the session associated with the process.</summary>
|
||
public uint SessionId;
|
||
|
||
/// <summary>The process identifier that uniquely identifies the process on the RD Session Host server.</summary>
|
||
public uint ProcessId;
|
||
|
||
/// <summary>A pointer to a null-terminated string that contains the name of the executable file associated with the process.</summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pProcessName;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public PSID pUserSid;
|
||
|
||
/// <summary>The number of threads in the process.</summary>
|
||
public uint NumberOfThreads;
|
||
|
||
/// <summary>The number of handles in the process.</summary>
|
||
public uint HandleCount;
|
||
|
||
/// <summary>The page file usage of the process, in bytes.</summary>
|
||
public uint PagefileUsage;
|
||
|
||
/// <summary>The peak page file usage of the process, in bytes.</summary>
|
||
public uint PeakPagefileUsage;
|
||
|
||
/// <summary>The working set size of the process, in bytes.</summary>
|
||
public uint WorkingSetSize;
|
||
|
||
/// <summary>The peak working set size of the process, in bytes.</summary>
|
||
public uint PeakWorkingSetSize;
|
||
|
||
/// <summary>The amount of time, in milliseconds, the process has been running in user mode.</summary>
|
||
public long UserTime;
|
||
|
||
/// <summary>The amount of time, in milliseconds, the process has been running in kernel mode.</summary>
|
||
public long KernelTime;
|
||
}
|
||
|
||
/// <summary>Contains information about a specific Remote Desktop Services server.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>Name of the server.</summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pServerName;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>A null-terminated string that contains the address family. Always set this member to "AF_INET".</summary>
|
||
public uint AddressFamily;
|
||
|
||
/// <summary>
|
||
/// The virtual IP address assigned to the session. The format of this address is identical to that used in the
|
||
/// WTS_CLIENT_ADDRESS structure.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
|
||
public byte[] Address;
|
||
}
|
||
|
||
/// <summary>Contains information about a client session on a Remote Desktop Session Host (RD Session Host) server.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>Session identifier of the session.</summary>
|
||
public uint SessionId;
|
||
|
||
/// <summary>
|
||
/// 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".
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pWinStationName;
|
||
|
||
/// <summary>A value from the WTS_CONNECTSTATE_CLASS enumeration type that indicates the session's current connection state.</summary>
|
||
public WTS_CONNECTSTATE_CLASS State;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// 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 <c>WTSEnumerateSessionsEx</c> 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 <c>SessionId</c> member.
|
||
/// </para>
|
||
/// <para>
|
||
/// 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 <c>pHostName</c> member contains the name of the
|
||
/// virtual machine. The <c>pFarmName</c> member is applicable to sessions that are hosted on virtual machines that are joined to a
|
||
/// RD Session Host farm.
|
||
/// </para>
|
||
/// </remarks>
|
||
// 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
|
||
{
|
||
/// <summary>
|
||
/// An identifier that uniquely identifies the session within the list of sessions returned by the WTSEnumerateSessionsEx
|
||
/// function. For more information, see Remarks.
|
||
/// </summary>
|
||
public uint ExecEnvId;
|
||
|
||
/// <summary>
|
||
/// A value of the WTS_CONNECTSTATE_CLASS enumeration type that specifies the connection state of a Remote Desktop Services session.
|
||
/// </summary>
|
||
public WTS_CONNECTSTATE_CLASS State;
|
||
|
||
/// <summary>A session identifier assigned by the RD Session Host server, RD Virtualization Host server, or virtual machine.</summary>
|
||
public uint SessionId;
|
||
|
||
/// <summary>
|
||
/// A pointer to a null-terminated string that contains the name of this session. For example, "services", "console", or "RDP-Tcp#0".
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pSessionName;
|
||
|
||
/// <summary>
|
||
/// 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 <c>NULL</c>. If the
|
||
/// session is running on a virtual machine, the string contains the name of the virtual machine.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pHostName;
|
||
|
||
/// <summary>
|
||
/// 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 <c>NULL</c>.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pUserName;
|
||
|
||
/// <summary>
|
||
/// 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 <c>NULL</c>.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pDomainName;
|
||
|
||
/// <summary>
|
||
/// 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 <c>NULL</c>.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.LPTStr)]
|
||
public string pFarmName;
|
||
}
|
||
|
||
/// <summary>Contains information about a Remote Desktop Connection (RDC) client.</summary>
|
||
/// <remarks>
|
||
/// For the <c>ClientAddressFamily</c> member, <c>AF_INET</c> (IPv4) will return in string format, for example "127.0.0.1".
|
||
/// <c>AF_INET6</c> (IPv6) will return in binary form.
|
||
/// </remarks>
|
||
// 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
|
||
{
|
||
/// <summary>The NetBIOS name of the client computer.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CLIENTNAME_LENGTH + 1)]
|
||
public string ClientName;
|
||
|
||
/// <summary>The domain name of the client computer.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)]
|
||
public string Domain;
|
||
|
||
/// <summary>The client user name.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)]
|
||
public string UserName;
|
||
|
||
/// <summary>The folder for the initial program.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string WorkDirectory;
|
||
|
||
/// <summary>The program to start on connection.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string InitialProgram;
|
||
|
||
/// <summary>The security level of encryption.</summary>
|
||
public byte EncryptionLevel;
|
||
|
||
/// <summary>
|
||
/// The address family. This member can be <c>AF_INET</c>, <c>AF_INET6</c>, <c>AF_IPX</c>, <c>AF_NETBIOS</c>, or <c>AF_UNSPEC</c>.
|
||
/// </summary>
|
||
public uint ClientAddressFamily;
|
||
|
||
/// <summary>The client network address.</summary>
|
||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = CLIENTADDRESS_LENGTH + 1)]
|
||
public ushort[] ClientAddress;
|
||
|
||
/// <summary>Horizontal dimension, in pixels, of the client's display.</summary>
|
||
public ushort HRes;
|
||
|
||
/// <summary>Vertical dimension, in pixels, of the client's display.</summary>
|
||
public ushort VRes;
|
||
|
||
/// <summary>
|
||
/// Color depth of the client's display. For possible values, see the <c>ColorDepth</c> member of the WTS_CLIENT_DISPLAY structure.
|
||
/// </summary>
|
||
public ushort ColorDepth;
|
||
|
||
/// <summary>The location of the client ActiveX control DLL.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string ClientDirectory;
|
||
|
||
/// <summary>The client build number.</summary>
|
||
public uint ClientBuildNumber;
|
||
|
||
/// <summary>Reserved.</summary>
|
||
public uint ClientHardwareId;
|
||
|
||
/// <summary>Reserved.</summary>
|
||
public ushort ClientProductId;
|
||
|
||
/// <summary>The number of output buffers on the server per session.</summary>
|
||
public ushort OutBufCountHost;
|
||
|
||
/// <summary>The number of output buffers on the client.</summary>
|
||
public ushort OutBufCountClient;
|
||
|
||
/// <summary>The length of the output buffers, in bytes.</summary>
|
||
public ushort OutBufLength;
|
||
|
||
/// <summary>The device ID of the network adapter.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string DeviceId;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Contains information about a Remote Desktop Services session. This structure is returned by the WTSQuerySessionInformation
|
||
/// function when you specify "WTSConfigInfo" for the WTSInfoClass parameter.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>This member is reserved.</summary>
|
||
public uint version;
|
||
|
||
/// <summary>This member is reserved.</summary>
|
||
[MarshalAs(UnmanagedType.Bool)]
|
||
public bool fConnectClientDrivesAtLogon;
|
||
|
||
/// <summary>This member is reserved.</summary>
|
||
[MarshalAs(UnmanagedType.Bool)]
|
||
public bool fConnectPrinterAtLogon;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether the client can use printer redirection.</para>
|
||
/// <para>0</para>
|
||
/// <para>Enable client printer redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>Disable client printer redirection.</para>
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.Bool)]
|
||
public bool fDisablePrinterRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether the printer connected to the client is the default printer for the user.</para>
|
||
/// <para>0</para>
|
||
/// <para>The printer connected to the client is not the default printer for the user.</para>
|
||
/// <para>1</para>
|
||
/// <para>The printer connected to the client is the default printer for the user.</para>
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.Bool)]
|
||
public bool fDisableDefaultMainClientPrinter;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Remote control is disabled.</para>
|
||
/// <para>1</para>
|
||
/// <para>The user of remote control has full control of the user's session, with the user's permission.</para>
|
||
/// <para>2</para>
|
||
/// <para>The user of remote control has full control of the user's session; the user's permission is not required.</para>
|
||
/// <para>3</para>
|
||
/// <para>
|
||
/// The user of remote control can view the session remotely, with the user's permission; the remote user cannot actively
|
||
/// control the session.
|
||
/// </para>
|
||
/// <para>4</para>
|
||
/// <para>
|
||
/// The user of remote control can view the session remotely but not actively control the session; the user's permission is not required.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint ShadowSettings;
|
||
|
||
/// <summary>A null-terminated string that contains the user name used in automatic logon scenarios.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)]
|
||
public string LogonUserName;
|
||
|
||
/// <summary>A null-terminated string that contains the domain name used in automatic logon scenarios.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)]
|
||
public string LogonDomain;
|
||
|
||
/// <summary>A null-terminated string that contains the path of the working directory of the initial program.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string WorkDirectory;
|
||
|
||
/// <summary>
|
||
/// A null-terminated string that contains the name of the program to start immediately after the user logs on to the server.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string InitialProgram;
|
||
|
||
/// <summary>This member is reserved.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string ApplicationName;
|
||
}
|
||
|
||
/// <summary>Contains information about a Remote Desktop Services session.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>A value of the WTS_CONNECTSTATE_CLASS enumeration type that indicates the session's current connection state.</summary>
|
||
public WTS_CONNECTSTATE_CLASS State;
|
||
|
||
/// <summary>The session identifier.</summary>
|
||
public uint SessionId;
|
||
|
||
/// <summary>Uncompressed Remote Desktop Protocol (RDP) data from the client to the server.</summary>
|
||
public uint IncomingBytes;
|
||
|
||
/// <summary>Uncompressed RDP data from the server to the client.</summary>
|
||
public uint OutgoingBytes;
|
||
|
||
/// <summary>The number of frames of RDP data sent from the client to the server since the client connected.</summary>
|
||
public uint IncomingFrames;
|
||
|
||
/// <summary>The number of frames of RDP data sent from the server to the client since the client connected.</summary>
|
||
public uint OutgoingFrames;
|
||
|
||
/// <summary>Compressed RDP data from the client to the server.</summary>
|
||
public uint IncomingCompressedBytes;
|
||
|
||
/// <summary/>
|
||
public uint OutgoingCompressedBytes;
|
||
|
||
/// <summary>A null-terminated string that contains the name of the WinStation for the session.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = WINSTATIONNAME_LENGTH)]
|
||
public string WinStationName;
|
||
|
||
/// <summary>A null-terminated string that contains the name of the domain that the user belongs to.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH)]
|
||
public string Domain;
|
||
|
||
/// <summary>A null-terminated string that contains the name of the user who owns the session.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 2)]
|
||
public string UserName;
|
||
|
||
/// <summary>The most recent client connection time.</summary>
|
||
public long ConnectTimeUTC;
|
||
|
||
/// <summary>The most recent client connection time.</summary>
|
||
public DateTime ConnectTime => DateTime.FromFileTimeUtc(ConnectTimeUTC);
|
||
|
||
/// <summary>The last client disconnection time.</summary>
|
||
public long DisconnectTimeUTC;
|
||
|
||
/// <summary>The last client disconnection time.</summary>
|
||
public DateTime DisconnectTime => DateTime.FromFileTimeUtc(DisconnectTimeUTC);
|
||
|
||
/// <summary>The time of the last user input in the session.</summary>
|
||
public long LastInputTimeUTC;
|
||
|
||
/// <summary>The time of the last user input in the session.</summary>
|
||
public DateTime LastInputTime => DateTime.FromFileTimeUtc(LogonTimeUTC);
|
||
|
||
/// <summary>The time that the user logged on to the session.</summary>
|
||
public long LogonTimeUTC;
|
||
|
||
/// <summary>The time that the user logged on to the session.</summary>
|
||
public DateTime LogonTime => DateTime.FromFileTimeUtc(LogonTimeUTC);
|
||
|
||
/// <summary>The time that the <c>WTSINFO</c> data structure was called.</summary>
|
||
public long CurrentTimeUTC;
|
||
|
||
/// <summary>The time that the <c>WTSINFO</c> data structure was called.</summary>
|
||
public DateTime CurrentTime => DateTime.FromFileTimeUtc(CurrentTimeUTC);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
// 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
|
||
{
|
||
/// <summary>Specifies the level of information contained in the Data member. This can be the following value.
|
||
/// <para><strong>1</strong></para>
|
||
/// <para>The Data member is a WTSINFOEX_LEVEL1 structure.</para>
|
||
/// </summary>
|
||
public uint Level;
|
||
|
||
/// <summary>A WTSINFOEX_LEVEL union. The type of structure contained here is specified by the <c>Level</c> member.</summary>
|
||
public WTSINFOEX_LEVEL Data;
|
||
}
|
||
|
||
/// <summary>Contains a WTSINFOEX_LEVEL1 structure that contains extended information about a Remote Desktop Services session.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>A WTSINFOEX_LEVEL1 structure that contains extended session information.</summary>
|
||
public WTSINFOEX_LEVEL1 WTSInfoExLevel1;
|
||
}
|
||
|
||
/// <summary>Contains extended information about a Remote Desktop Services session.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>The session identifier.</summary>
|
||
public uint SessionId;
|
||
|
||
/// <summary>
|
||
/// A value of the WTS_CONNECTSTATE_CLASS enumeration type that specifies the connection state of a Remote Desktop Services session.
|
||
/// </summary>
|
||
public WTS_CONNECTSTATE_CLASS SessionState;
|
||
|
||
/// <summary>
|
||
/// <para>The state of the session. This can be one or more of the following values.</para>
|
||
/// <para>WTS_SESSIONSTATE_UNKNOWN (4294967295 (0xFFFFFFFF))</para>
|
||
/// <para>The session state is not known.</para>
|
||
/// <para>WTS_SESSIONSTATE_LOCK (0 (0x0))</para>
|
||
/// <para>The session is locked.</para>
|
||
/// <para>WTS_SESSIONSTATE_UNLOCK (1 (0x1))</para>
|
||
/// <para>The session is unlocked.</para>
|
||
/// <para>
|
||
/// <c>Windows Server 2008 R2 and Windows 7:</c> Due to a code defect, the usage of the <c>WTS_SESSIONSTATE_LOCK</c> and
|
||
/// <c>WTS_SESSIONSTATE_UNLOCK</c> flags is reversed. That is, <c>WTS_SESSIONSTATE_LOCK</c> indicates that the session is
|
||
/// unlocked, and <c>WTS_SESSIONSTATE_UNLOCK</c> indicates the session is locked.
|
||
/// </para>
|
||
/// </summary>
|
||
public WTS_SESSIONSTATE SessionFlags;
|
||
|
||
/// <summary>A null-terminated string that contains the name of the window station for the session.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = WINSTATIONNAME_LENGTH + 1)]
|
||
public string WinStationName;
|
||
|
||
/// <summary>A null-terminated string that contains the name of the user who owns the session.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)]
|
||
public string UserName;
|
||
|
||
/// <summary>A null-terminated string that contains the name of the domain that the user belongs to.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)]
|
||
public string DomainName;
|
||
|
||
/// <summary>
|
||
/// 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).
|
||
/// </summary>
|
||
public long LogonTimeUTC;
|
||
|
||
/// <summary>
|
||
/// 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).
|
||
/// </summary>
|
||
public DateTime LogonTime => DateTime.FromFileTimeUtc(LogonTimeUTC);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public long ConnectTimeUTC;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public DateTime ConnectTime => DateTime.FromFileTimeUtc(ConnectTimeUTC);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public long DisconnectTimeUTC;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public DateTime DisconnectTime => DateTime.FromFileTimeUtc(DisconnectTimeUTC);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public long LastInputTimeUTC;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public DateTime LastInputTime => DateTime.FromFileTimeUtc(LastInputTimeUTC);
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public long CurrentTimeUTC;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public DateTime CurrentTime => DateTime.FromFileTimeUtc(CurrentTimeUTC);
|
||
|
||
/// <summary>
|
||
/// The number of bytes of uncompressed Remote Desktop Protocol (RDP) data sent from the client to the server since the client connected.
|
||
/// </summary>
|
||
public uint IncomingBytes;
|
||
|
||
/// <summary>The number of bytes of uncompressed RDP data sent from the server to the client since the client connected.</summary>
|
||
public uint OutgoingBytes;
|
||
|
||
/// <summary>The number of frames of RDP data sent from the client to the server since the client connected.</summary>
|
||
public uint IncomingFrames;
|
||
|
||
/// <summary>The number of frames of RDP data sent from the server to the client since the client connected.</summary>
|
||
public uint OutgoingFrames;
|
||
|
||
/// <summary>The number of bytes of compressed RDP data sent from the client to the server since the client connected.</summary>
|
||
public uint IncomingCompressedBytes;
|
||
|
||
/// <summary>The number of bytes of compressed RDP data sent from the server to the client since the client connected.</summary>
|
||
public uint OutgoingCompressedBytes;
|
||
}
|
||
|
||
/// <summary>Contains information about a Remote Desktop Services listener. This structure is used by the WTSCreateListener function.</summary>
|
||
// 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
|
||
{
|
||
/// <summary>This member is reserved.</summary>
|
||
public uint version;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether the listener is enabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The listener is disabled.</para>
|
||
/// <para>1</para>
|
||
/// <para>The listener is enabled.</para>
|
||
/// </summary>
|
||
public uint fEnableListener;
|
||
|
||
/// <summary>The maximum number of active connections that the listener accepts.</summary>
|
||
public uint MaxConnectionCount;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether the listener always prompts the user for a password. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>Prompt the user for a password only when specified by the server.</para>
|
||
/// <para>1</para>
|
||
/// <para>Always prompt the user for a password.</para>
|
||
/// </summary>
|
||
public uint fPromptForPassword;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies whether the listener should use the color depth specified by the user. This member can be one of the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Use the color depth specified by the server.</para>
|
||
/// <para>1</para>
|
||
/// <para>Use the color depth specified by the user.</para>
|
||
/// </summary>
|
||
public uint fInheritColorDepth;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// The color depth setting for the listener. This setting only applies when the <c>fInheritColorDepth</c> member is zero. This
|
||
/// can be one of the following values.
|
||
/// </para>
|
||
/// <para>1</para>
|
||
/// <para>8 bit</para>
|
||
/// <para>2</para>
|
||
/// <para>15 bit</para>
|
||
/// <para>3</para>
|
||
/// <para>16 bit</para>
|
||
/// <para>4</para>
|
||
/// <para>24 bit</para>
|
||
/// <para>5</para>
|
||
/// <para>32 bit</para>
|
||
/// </summary>
|
||
public uint ColorDepth;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies whether the listener should use the <c>BrokenTimeoutSettings</c> value specified by the user. This member can be
|
||
/// one of the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Use the <c>BrokenTimeoutSettings</c> value specified by server.</para>
|
||
/// <para>1</para>
|
||
/// <para>Use the <c>BrokenTimeoutSettings</c> value specified by the user.</para>
|
||
/// </summary>
|
||
public uint fInheritBrokenTimeoutSettings;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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 <c>fInheritBrokenTimeoutSettings</c> member is zero. This member can be one of the
|
||
/// following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>1</para>
|
||
/// <para>When a connection or idle timer expires, or when a connection is lost due to a connection error, the session is terminated.</para>
|
||
/// </summary>
|
||
public uint BrokenTimeoutSettings;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether printer redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable printer redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>Printer redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisablePrinterRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether drive redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable drive redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>Drive redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisableDriveRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether COM port redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable COM port redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>COM port redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisableComPortRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether LPT port redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable LPT port redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>LPT port redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisableLPTPortRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether clipboard redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable clipboard redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>Clipboard redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisableClipboardRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether audio redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable audio redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>Audio redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisableAudioRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether Plug and Play redirection is disabled. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The user can enable Plug and Play redirection.</para>
|
||
/// <para>1</para>
|
||
/// <para>Plug and Play redirection is disabled.</para>
|
||
/// </summary>
|
||
public uint fDisablePNPRedirection;
|
||
|
||
/// <summary>
|
||
/// <para>Specifies whether the client printer is the default printer. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>The client printer is not the default printer.</para>
|
||
/// <para>1</para>
|
||
/// <para>The client printer is the default printer.</para>
|
||
/// </summary>
|
||
public uint fDisableDefaultMainClientPrinter;
|
||
|
||
/// <summary>The network adapter that the listener uses.</summary>
|
||
public uint LanAdapter;
|
||
|
||
/// <summary>The port number of the listener.</summary>
|
||
public uint PortNumber;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies whether the listener should use the <c>ShadowSettings</c> value specified by the user. This member can be one of
|
||
/// the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Use the setting specified by the server.</para>
|
||
/// <para>1</para>
|
||
/// <para>Use the setting specified by the user.</para>
|
||
/// </summary>
|
||
public uint fInheritShadowSettings;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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 <c>fInheritShadowSettings</c> member is zero. This member can be one of the
|
||
/// following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Remote control is disabled.</para>
|
||
/// <para>1</para>
|
||
/// <para>The user of remote control has full control of the user's session, with the user's permission.</para>
|
||
/// <para>2</para>
|
||
/// <para>The user of remote control has full control of the user's session; the user's permission is not required.</para>
|
||
/// <para>3</para>
|
||
/// <para>
|
||
/// The user of remote control can view the session remotely, with the user's permission; the remote user cannot actively
|
||
/// control the session.
|
||
/// </para>
|
||
/// <para>4</para>
|
||
/// <para>
|
||
/// The user of remote control can view the session remotely but not actively control the session; the user's permission is not required.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint ShadowSettings;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public uint TimeoutSettingsConnection;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public uint TimeoutSettingsDisconnection;
|
||
|
||
/// <summary>The maximum idle time, in milliseconds. A value of zero indicates that the idle timer is disabled.</summary>
|
||
public uint TimeoutSettingsIdle;
|
||
|
||
/// <summary>
|
||
/// <para>The security layer of the listener. This member can be one of the following values.</para>
|
||
/// <para>0</para>
|
||
/// <para>Remote Desktop Protocol (RDP) is used by the server and the client for authentication before a connection is established.</para>
|
||
/// <para>1</para>
|
||
/// <para>The server and the client negotiate the method for authentication before a connection is established.</para>
|
||
/// <para>2</para>
|
||
/// <para>
|
||
/// Transport Layer Security (TLS) protocol is used by the server and the client for authentication before a connection is established.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint SecurityLayer;
|
||
|
||
/// <summary>
|
||
/// <para>Encryption level of the listener. This member can be one of the following values.</para>
|
||
/// <para>1</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>2</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>3</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>4</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint MinEncryptionLevel;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies whether network-level user authentication is required before the connection is established. This member can be one
|
||
/// of the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Network-level user authentication is not required.</para>
|
||
/// <para>1</para>
|
||
/// <para>Network-level user authentication is required.</para>
|
||
/// </summary>
|
||
public uint UserAuthentication;
|
||
|
||
/// <summary>A null-terminated string that contains a description of the listener.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = WTS_COMMENT_LENGTH + 1)]
|
||
public string Comment;
|
||
|
||
/// <summary>A null-terminated string that contains the user name used in automatic logon scenarios.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = USERNAME_LENGTH + 1)]
|
||
public string LogonUserName;
|
||
|
||
/// <summary>A null-terminated string that contains the domain name used in automatic logon scenarios.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = DOMAIN_LENGTH + 1)]
|
||
public string LogonDomain;
|
||
|
||
/// <summary>A null-terminated string that contains the path of the working directory of the initial program.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string WorkDirectory;
|
||
|
||
/// <summary>
|
||
/// A null-terminated string that contains the name of the program to start immediately after the user logs on to the server.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string InitialProgram;
|
||
}
|
||
|
||
/// <summary>A fixed length string used by <see cref="WTSEnumerateListeners"/></summary>
|
||
[PInvokeData("wtsapi32.h")]
|
||
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
||
public struct WTSLISTENERNAME
|
||
{
|
||
private const int WTS_LISTENER_NAME_LENGTH = 32;
|
||
|
||
/// <summary>Name of the server.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = WTS_LISTENER_NAME_LENGTH + 1)]
|
||
public string Name;
|
||
|
||
/// <summary>Converts to string.</summary>
|
||
/// <returns>A <see cref="System.String"/> that represents this instance.</returns>
|
||
public override string ToString() => Name ?? "";
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="WTSLISTENERNAME"/> to <see cref="System.String"/>.</summary>
|
||
/// <param name="n">The n.</param>
|
||
/// <returns>The resulting <see cref="System.String"/> instance from the conversion.</returns>
|
||
public static implicit operator string(WTSLISTENERNAME n) => n.Name;
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="System.String"/> to <see cref="WTSLISTENERNAME"/>.</summary>
|
||
/// <param name="n">The n.</param>
|
||
/// <returns>The resulting <see cref="WTSLISTENERNAME"/> instance from the conversion.</returns>
|
||
public static implicit operator WTSLISTENERNAME(string n) => new WTSLISTENERNAME { Name = n };
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
/// <remarks/>
|
||
// 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
|
||
{
|
||
/// <summary>
|
||
/// A value of the WTS_CONFIG_SOURCE enumeration type that specifies the source of configuration information returned by the
|
||
/// WTSQueryUserConfig function.
|
||
/// </summary>
|
||
public WTS_CONFIG_SOURCE Source;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// A value that indicates whether the client can specify the initial program. This member can be one of the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>
|
||
/// The client cannot specify the initial program. Instead, the program specified by the <c>InitialProgram</c> member starts
|
||
/// automatically when the user logs on to the server. The server logs the user off when the user exits that program.
|
||
/// </para>
|
||
/// <para>1</para>
|
||
/// <para>The client can specify the initial program.</para>
|
||
/// </summary>
|
||
public uint InheritInitialProgram;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>The user cannot log on.</para>
|
||
/// <para>1</para>
|
||
/// <para>The user can log on.</para>
|
||
/// </summary>
|
||
public uint AllowLogonTerminalServer;
|
||
|
||
/// <summary>
|
||
/// 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
|
||
/// <c>BrokenTimeoutSettings</c> member. Every time the user logs on, the timer is reset. A value of zero indicates that the
|
||
/// connection timer is disabled.
|
||
/// </summary>
|
||
public uint TimeoutSettingsConnections;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
public uint TimeoutSettingsDisconnections;
|
||
|
||
/// <summary>
|
||
/// 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 <c>BrokenTimeoutSettings</c> member. A value of zero indicates
|
||
/// that the idle timer is disabled.
|
||
/// </summary>
|
||
public uint TimeoutSettingsIdle;
|
||
|
||
/// <summary>This member is reserved.</summary>
|
||
public uint DeviceClientDrives;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>The server does not automatically connect to previously mapped client printers.</para>
|
||
/// <para>1</para>
|
||
/// <para>The server automatically connects to previously mapped client printers.</para>
|
||
/// </summary>
|
||
public uint DeviceClientPrinters;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// A value that indicates whether the client printer is the default printer. This member can be one of the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>The client printer is not the default printer.</para>
|
||
/// <para>1</para>
|
||
/// <para>The client printer is the default printer.</para>
|
||
/// </summary>
|
||
public uint ClientDefaultPrinter;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>The session is disconnected, but it remains on the server.</para>
|
||
/// <para>1</para>
|
||
/// <para>The session is terminated.</para>
|
||
/// </summary>
|
||
public uint BrokenTimeoutSettings;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// A value that indicates how a disconnected session for this user can be reconnected. This member can be one of the following values.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>The user can log on to any client computer to reconnect to a disconnected session.</para>
|
||
/// <para>1</para>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint ReconnectSettings;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// 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.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>Remote control is disabled.</para>
|
||
/// <para>1</para>
|
||
/// <para>The user of remote control has full control of the user's session, with the user's permission.</para>
|
||
/// <para>2</para>
|
||
/// <para>The user of remote control has full control of the user's session; the user's permission is not required.</para>
|
||
/// <para>3</para>
|
||
/// <para>
|
||
/// The user of remote control can view the session remotely, with the user's permission; the remote user cannot actively
|
||
/// control the session.
|
||
/// </para>
|
||
/// <para>4</para>
|
||
/// <para>
|
||
/// The user of remote control can view the session remotely but not actively control the session; the user's permission is not required.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint ShadowingSettings;
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// A value that indicates whether the <c>TerminalServerHomeDir</c> 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.
|
||
/// </para>
|
||
/// <para>0</para>
|
||
/// <para>The <c>TerminalServerHomeDir</c> member contains a path to a local directory.</para>
|
||
/// <para>1</para>
|
||
/// <para>
|
||
/// The <c>TerminalServerHomeDir</c> member contains a path to a network share, and the <c>TerminalServerHomeDirDrive</c> member
|
||
/// contains a drive letter to which this path is mapped.
|
||
/// </para>
|
||
/// </summary>
|
||
public uint TerminalServerRemoteHomeDir;
|
||
|
||
/// <summary>
|
||
/// A null-terminated string that contains the name of the program to start immediately after the user logs on to the server.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string InitialProgram;
|
||
|
||
/// <summary>A null-terminated string that contains the path of the working directory for the initial program.</summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string WorkDirectory;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string TerminalServerProfilePath;
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH + 1)]
|
||
public string TerminalServerHomeDir;
|
||
|
||
/// <summary>
|
||
/// A null-terminated string that contains the drive name (a drive letter followed by a colon) to which the path specified in
|
||
/// the <c>TerminalServerHomeDir</c> member is mapped. This member is only valid when the <c>TerminalServerRemoteHomeDir</c>
|
||
/// member is set to one.
|
||
/// </summary>
|
||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = WTS_DRIVE_LENGTH + 1)]
|
||
public string TerminalServerHomeDirDrive;
|
||
}
|
||
|
||
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HVIRTUALCHANNEL"/> that is disposed using <see cref="WTSVirtualChannelClose"/>.</summary>
|
||
public class SafeHVIRTUALCHANNEL : SafeHANDLE
|
||
{
|
||
/// <summary>Initializes a new instance of the <see cref="SafeHVIRTUALCHANNEL"/> class and assigns an existing handle.</summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
/// <param name="ownsHandle">
|
||
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
||
/// </param>
|
||
public SafeHVIRTUALCHANNEL(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
||
|
||
/// <summary>Initializes a new instance of the <see cref="SafeHVIRTUALCHANNEL"/> class.</summary>
|
||
private SafeHVIRTUALCHANNEL() : base() { }
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="SafeHVIRTUALCHANNEL"/> to <see cref="HVIRTUALCHANNEL"/>.</summary>
|
||
/// <param name="h">The safe handle instance.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static implicit operator HVIRTUALCHANNEL(SafeHVIRTUALCHANNEL h) => h.handle;
|
||
|
||
/// <inheritdoc/>
|
||
protected override bool InternalReleaseHandle() => WTSVirtualChannelClose(handle);
|
||
}
|
||
|
||
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HWTSSERVER"/> that is disposed using <see cref="WTSCloseServer"/>.</summary>
|
||
public class SafeHWTSSERVER : SafeHANDLE
|
||
{
|
||
/// <summary>Initializes a new instance of the <see cref="SafeHWTSSERVER"/> class and assigns an existing handle.</summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
/// <param name="ownsHandle">
|
||
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
||
/// </param>
|
||
public SafeHWTSSERVER(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
||
|
||
/// <summary>Initializes a new instance of the <see cref="SafeHWTSSERVER"/> class.</summary>
|
||
private SafeHWTSSERVER() : base() { }
|
||
|
||
/// <summary>Performs an implicit conversion from <see cref="SafeHWTSSERVER"/> to <see cref="HWTSSERVER"/>.</summary>
|
||
/// <param name="h">The safe handle instance.</param>
|
||
/// <returns>The result of the conversion.</returns>
|
||
public static implicit operator HWTSSERVER(SafeHWTSSERVER h) => h.handle;
|
||
|
||
/// <summary>Gets the handle of the current server (WTS_CURRENT_SERVER).</summary>
|
||
public static SafeHWTSSERVER Current => new(IntPtr.Zero, false);
|
||
|
||
/// <inheritdoc/>
|
||
protected override bool InternalReleaseHandle() { WTSCloseServer(handle); return true; }
|
||
}
|
||
|
||
/// <summary>Provides a <see cref="SafeHandle"/> for WTS memory that is disposed using <see cref="WTSFreeMemory"/>.</summary>
|
||
public class SafeWTSMemoryHandle : SafeHANDLE
|
||
{
|
||
/// <summary>Initializes a new instance of the <see cref="SafeWTSMemoryHandle"/> class and assigns an existing handle.</summary>
|
||
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
||
/// <param name="ownsHandle">
|
||
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
||
/// </param>
|
||
public SafeWTSMemoryHandle(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
||
|
||
/// <summary>Initializes a new instance of the <see cref="SafeWTSMemoryHandle"/> class.</summary>
|
||
private SafeWTSMemoryHandle() : base() { }
|
||
|
||
/// <summary>
|
||
/// Extracts an array of structures of <typeparamref name="T"/> containing <paramref name="count"/> items. <note
|
||
/// type="note">This call can cause memory exceptions if the pointer does not have sufficient allocated memory to retrieve all
|
||
/// the structures.</note>
|
||
/// </summary>
|
||
/// <typeparam name="T">The type of the structures to retrieve.</typeparam>
|
||
/// <param name="count">The number of structures to retrieve.</param>
|
||
/// <returns>An array of structures of <typeparamref name="T"/>.</returns>
|
||
public T[] ToArray<T>(int count) => handle.ToArray<T>(count);
|
||
|
||
/// <summary>Returns a <see cref="System.String"/> that represents this instance.</summary>
|
||
/// <param name="allocatedBytes">The size, in bytes, of the data returned in ppBuffer.</param>
|
||
/// <returns>A <see cref="System.String"/> that represents this instance.</returns>
|
||
public string ToString(uint allocatedBytes) => StringHelper.GetString(handle, CharSet.Auto, allocatedBytes);
|
||
|
||
/// <summary>Marshals data from this memory to a newly allocated managed object of the type specified by a generic type parameter.</summary>
|
||
/// <typeparam name="T">The type of the object to which the data is to be copied. This must be a structure.</typeparam>
|
||
/// <param name="allocatedBytes">If known, the total number of bytes allocated to the native memory.</param>
|
||
/// <returns>A managed object that contains the data that this memory points to.</returns>
|
||
public T ToStructure<T>(uint allocatedBytes) => handle.Convert<T>(allocatedBytes == 0 ? uint.MaxValue : allocatedBytes);
|
||
|
||
#if ALLOWSPAN
|
||
/// <summary>Creates a new span over this allocated memory.</summary>
|
||
/// <returns>The span representation of the structure.</returns>
|
||
public virtual ReadOnlySpan<T> AsReadOnlySpan<T>(int length) => handle.AsReadOnlySpan<T>(length);
|
||
|
||
/// <summary>Creates a new span over this allocated memory.</summary>
|
||
/// <returns>The span representation of the structure.</returns>
|
||
public virtual Span<T> AsSpan<T>(int length) => handle.AsSpan<T>(length);
|
||
#endif
|
||
|
||
/// <inheritdoc/>
|
||
protected override bool InternalReleaseHandle() { WTSFreeMemory(handle); return true; }
|
||
}
|
||
}
|
||
} |