tsproxyrpcinterface

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 30, 2024 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Syntax UUID
	InterfaceSyntaxUUID = &uuid.UUID{TimeLow: 0x44e265dd, TimeMid: 0x7daf, TimeHiAndVersion: 0x42cd, ClockSeqHiAndReserved: 0x85, ClockSeqLow: 0x60, Node: [6]uint8{0x3c, 0xdb, 0x6e, 0x7a, 0x27, 0x29}}
	// Syntax ID
	InterfaceSyntaxV1_3 = &dcerpc.SyntaxID{IfUUID: InterfaceSyntaxUUID, IfVersionMajor: 1, IfVersionMinor: 3}
)
View Source 
var AsyncMessageConsentMessage = 1

AsyncMessageConsentMessage represents the TSG_ASYNC_MESSAGE_CONSENT_MESSAGE RPC constant

View Source 
var AsyncMessageReauth = 3

AsyncMessageReauth represents the TSG_ASYNC_MESSAGE_REAUTH RPC constant

View Source 
var AsyncMessageServiceMessage = 2

AsyncMessageServiceMessage represents the TSG_ASYNC_MESSAGE_SERVICE_MESSAGE RPC constant

View Source 
var CapabilityTypeNap = 1

CapabilityTypeNap represents the TSG_CAPABILITY_TYPE_NAP RPC constant

View Source 
var (
	// import guard
	GoPackage = "tsgu"
)
View Source 
var MaxResourceNames = 50

MaxResourceNames represents the MAX_RESOURCE_NAMES RPC constant

View Source 
var MessagingCapConsentSign = 4

MessagingCapConsentSign represents the TSG_MESSAGING_CAP_CONSENT_SIGN RPC constant

View Source 
var MessagingCapReauth = 16

MessagingCapReauth represents the TSG_MESSAGING_CAP_REAUTH RPC constant

View Source 
var MessagingCapServiceMessage = 8

MessagingCapServiceMessage represents the TSG_MESSAGING_CAP_SERVICE_MSG RPC constant

View Source 
var NapCapabilityIdleTimeout = 2

NapCapabilityIdleTimeout represents the TSG_NAP_CAPABILITY_IDLE_TIMEOUT RPC constant

View Source 
var NapCapabilityQuarantineSOH = 1

NapCapabilityQuarantineSOH represents the TSG_NAP_CAPABILITY_QUAR_SOH RPC constant

View Source 
var PacketTypeAuth = 16468

PacketTypeAuth represents the TSG_PACKET_TYPE_AUTH RPC constant

View Source 
var PacketTypeCapsResponse = 17232

PacketTypeCapsResponse represents the TSG_PACKET_TYPE_CAPS_RESPONSE RPC constant

View Source 
var PacketTypeHeader = 18500

PacketTypeHeader represents the TSG_PACKET_TYPE_HEADER RPC constant

View Source 
var PacketTypeMessagePacket = 18256

PacketTypeMessagePacket represents the TSG_PACKET_TYPE_MESSAGE_PACKET RPC constant

View Source 
var PacketTypeMessageRequestPacket = 18258

PacketTypeMessageRequestPacket represents the TSG_PACKET_TYPE_MSGREQUEST_PACKET RPC constant

View Source 
var PacketTypeQuarantineConfigRequest = 20803

PacketTypeQuarantineConfigRequest represents the TSG_PACKET_TYPE_QUARCONFIGREQUEST RPC constant

View Source 
var PacketTypeQuarantineEncResponse = 17746

PacketTypeQuarantineEncResponse represents the TSG_PACKET_TYPE_QUARENC_RESPONSE RPC constant

View Source 
var PacketTypeQuarantineRequest = 20818

PacketTypeQuarantineRequest represents the TSG_PACKET_TYPE_QUARREQUEST RPC constant

View Source 
var PacketTypeReauth = 21072

PacketTypeReauth represents the TSG_PACKET_TYPE_REAUTH RPC constant

View Source 
var PacketTypeResponse = 20562

PacketTypeResponse represents the TSG_PACKET_TYPE_RESPONSE RPC constant

View Source 
var PacketTypeVersionCaps = 22083

PacketTypeVersionCaps represents the TSG_PACKET_TYPE_VERSIONCAPS RPC constant

View Source 
var TunnelCallAsyncMessageRequest = 1

TunnelCallAsyncMessageRequest represents the TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST RPC constant

View Source 
var TunnelCancelAsyncMessageRequest = 2

TunnelCancelAsyncMessageRequest represents the TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST RPC constant

Functions

func InterfaceServerHandle 

func InterfaceServerHandle(ctx context.Context, o InterfaceServer, opNum int, r ndr.Reader) (dcerpc.Operation, error)

func NewInterfaceServerHandle 

func NewInterfaceServerHandle(o InterfaceServer) dcerpc.ServerHandle

func RegisterInterfaceServer 

func RegisterInterfaceServer(conn dcerpc.Conn, o InterfaceServer, opts ...dcerpc.Option)

Types

type AuthorizeTunnelRequest 

type AuthorizeTunnelRequest struct {
	// tunnelContext: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateTunnel method call. The RDG server SHOULD throw
	// an exception if the RPC validation and verification fails.
	TunnelContext *TunnelNoSerialize `idl:"name:tunnelContext" json:"tunnel_context"`
	// TSGPacket: Pointer to the TSG_PACKET structure. The value of the packetId field MUST
	// be set to TSG_PACKET_TYPE_QUARREQUEST. If this is set to any other value, the error
	// E_PROXY_NOT_SUPPORTED is returned. The packetQuarRequest field of the TSGPacket union
	// field MUST be a pointer to the TSG_PACKET_QUARREQUEST structure.
	Packet *Packet `idl:"name:TSGPacket;pointer:ref" json:"packet"`
}

AuthorizeTunnelRequest structure represents the TsProxyAuthorizeTunnel operation request

func (*AuthorizeTunnelRequest) MarshalNDR 

func (o *AuthorizeTunnelRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*AuthorizeTunnelRequest) UnmarshalNDR 

func (o *AuthorizeTunnelRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type AuthorizeTunnelResponse 

type AuthorizeTunnelResponse struct {
	// TSGPacketResponse: Pointer to the TSG_PACKET structure. The value of the packetId
	// field MUST be TSG_PACKET_TYPE_RESPONSE. The packetResponse field of the TSGPacket
	// union field MUST be a pointer to the TSG_PACKET_RESPONSE structure.
	PacketResponse *Packet `idl:"name:TSGPacketResponse;pointer:ref" json:"packet_response"`
	// Return: The TsProxyAuthorizeTunnel return value.
	Return int32 `idl:"name:Return" json:"return"`
}

AuthorizeTunnelResponse structure represents the TsProxyAuthorizeTunnel operation response

func (*AuthorizeTunnelResponse) MarshalNDR 

func (o *AuthorizeTunnelResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*AuthorizeTunnelResponse) UnmarshalNDR 

func (o *AuthorizeTunnelResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CapabilitiesUnion 

type CapabilitiesUnion struct {
	// Types that are assignable to Value
	//
	// *CapabilitiesUnion_CapNap
	Value is_CapabilitiesUnion `json:"value"`
}

CapabilitiesUnion structure represents TSG_CAPABILITIES_UNION RPC union.

The TSG_CAPABILITIES_UNION union specifies an RPC switch_type union of structures as follows.

func (*CapabilitiesUnion) GetValue 

func (o *CapabilitiesUnion) GetValue() any

func (*CapabilitiesUnion) MarshalUnionNDR 

func (o *CapabilitiesUnion) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw uint32) error

func (*CapabilitiesUnion) NDRSwitchValue 

func (o *CapabilitiesUnion) NDRSwitchValue(sw uint32) uint32

func (*CapabilitiesUnion) UnmarshalUnionNDR 

func (o *CapabilitiesUnion) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw uint32) error

type CapabilitiesUnion_CapNap 

type CapabilitiesUnion_CapNap struct {
	// TSGCapNap:  A TSG_CAPABILITY_NAP structure.
	CapNap *CapabilityNap `idl:"name:TSGCapNap" json:"cap_nap"`
}

CapabilitiesUnion_CapNap structure represents TSG_CAPABILITIES_UNION RPC union arm.

It has following labels: 1

func (*CapabilitiesUnion_CapNap) MarshalNDR 

func (o *CapabilitiesUnion_CapNap) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CapabilitiesUnion_CapNap) UnmarshalNDR 

func (o *CapabilitiesUnion_CapNap) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type CapabilityNap 

type CapabilityNap struct {
	// capabilities:  Indicates the NAP capabilities supported by the RDG client and RDG
	// server. This bit field MUST be 0 or one or more of the following values.
	//
	//	+---------------------------------+
	//	|                                 |
	//	|              VALUE              |
	//	|                                 |
	//	+---------------------------------+
	//	+---------------------------------+
	//	| TSG_NAP_CAPABILITY_QUAR_SOH     |
	//	+---------------------------------+
	//	| TSG_NAP_CAPABILITY_IDLE_TIMEOUT |
	//	+---------------------------------+
	//	| TSG_MESSAGING_CAP_CONSENT_SIGN  |
	//	+---------------------------------+
	//	| TSG_MESSAGING_CAP_SERVICE_MSG   |
	//	+---------------------------------+
	//	| TSG_MESSAGING_CAP_REAUTH        |
	//	+---------------------------------+
	Capabilities uint32 `idl:"name:capabilities" json:"capabilities"`
}

CapabilityNap structure represents TSG_CAPABILITY_NAP RPC structure.

The TSG_CAPABILITY_NAP structure contains information about the NAP capabilities of the RDG client and RDG server.

This structure MUST be embedded in the TSG_PACKET_CAPABILITIES structure.

func (*CapabilityNap) MarshalNDR 

func (o *CapabilityNap) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CapabilityNap) UnmarshalNDR 

func (o *CapabilityNap) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ChannelNoSerialize 

type ChannelNoSerialize dcetypes.ContextHandle

ChannelNoSerialize structure represents PCHANNEL_CONTEXT_HANDLE_NOSERIALIZE RPC structure.

func (*ChannelNoSerialize) ContextHandle 

func (o *ChannelNoSerialize) ContextHandle() *dcetypes.ContextHandle

func (*ChannelNoSerialize) MarshalNDR 

func (o *ChannelNoSerialize) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ChannelNoSerialize) UnmarshalNDR 

func (o *ChannelNoSerialize) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ChannelSerialize 

type ChannelSerialize dcetypes.ContextHandle

ChannelSerialize structure represents PCHANNEL_CONTEXT_HANDLE_SERIALIZE RPC structure.

func (*ChannelSerialize) ContextHandle 

func (o *ChannelSerialize) ContextHandle() *dcetypes.ContextHandle

func (*ChannelSerialize) MarshalNDR 

func (o *ChannelSerialize) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ChannelSerialize) UnmarshalNDR 

func (o *ChannelSerialize) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type CloseChannelRequest 

type CloseChannelRequest struct {
	// context: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateChannel method call.
	Context *ChannelNoSerialize `idl:"name:context" json:"context"`
}

CloseChannelRequest structure represents the TsProxyCloseChannel operation request

func (*CloseChannelRequest) MarshalNDR 

func (o *CloseChannelRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CloseChannelRequest) UnmarshalNDR 

func (o *CloseChannelRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CloseChannelResponse 

type CloseChannelResponse struct {
	// context: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateChannel method call.
	Context *ChannelNoSerialize `idl:"name:context" json:"context"`
	// Return: The TsProxyCloseChannel return value.
	Return int32 `idl:"name:Return" json:"return"`
}

CloseChannelResponse structure represents the TsProxyCloseChannel operation response

func (*CloseChannelResponse) MarshalNDR 

func (o *CloseChannelResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CloseChannelResponse) UnmarshalNDR 

func (o *CloseChannelResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CloseTunnelRequest 

type CloseTunnelRequest struct {
	// context: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateTunnel method call.
	Context *TunnelSerialize `idl:"name:context" json:"context"`
}

CloseTunnelRequest structure represents the TsProxyCloseTunnel operation request

func (*CloseTunnelRequest) MarshalNDR 

func (o *CloseTunnelRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CloseTunnelRequest) UnmarshalNDR 

func (o *CloseTunnelRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CloseTunnelResponse 

type CloseTunnelResponse struct {
	// context: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateTunnel method call.
	Context *TunnelSerialize `idl:"name:context" json:"context"`
	// Return: The TsProxyCloseTunnel return value.
	Return int32 `idl:"name:Return" json:"return"`
}

CloseTunnelResponse structure represents the TsProxyCloseTunnel operation response

func (*CloseTunnelResponse) MarshalNDR 

func (o *CloseTunnelResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CloseTunnelResponse) UnmarshalNDR 

func (o *CloseTunnelResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CreateChannelRequest 

type CreateChannelRequest struct {
	// tunnelContext: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateTunnel method call. The RDG server SHOULD throw
	// an exception if the RPC validation and verification fails.
	TunnelContext *TunnelNoSerialize `idl:"name:tunnelContext" json:"tunnel_context"`
	// tsEndPointInfo: Pointer to the TSENDPOINTINFO structure. The RDG client MUST provide
	// a non-NULL pointer to the RDG server for this structure. The RDG server initializes
	// the ADM element Target server names with an array of resourceName and alternateResourceNames
	// members of TSENDPOINTINFO structure. The RDG server SHOULD try to connect to the
	// target server by each name in the array until it succeeds or until the array is traversed
	// completely. If connection fails for all target server names, HRESULT_CODE(E_PROXY_TS_CONNECTFAILED)
	// (0x000059DD) is returned.<47> The rules for determining a valid server name are specified
	// in section 2.2.1.1.
	EndpointInfo *EndpointInfo `idl:"name:tsEndPointInfo;pointer:ref" json:"endpoint_info"`
}

CreateChannelRequest structure represents the TsProxyCreateChannel operation request

func (*CreateChannelRequest) MarshalNDR 

func (o *CreateChannelRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CreateChannelRequest) UnmarshalNDR 

func (o *CreateChannelRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CreateChannelResponse 

type CreateChannelResponse struct {
	// channelContext: A RPC context handle that represents context-specific information
	// for the channel. The RDG server MUST provide a non-NULL value. The RDG client MUST
	// save and use this context handle on all subsequent method calls on the channel. Specifically,
	// these methods are TsProxySendToServer, TsProxySetupReceivePipe, and TsProxyCloseChannel.
	ChannelContext *ChannelSerialize `idl:"name:channelContext" json:"channel_context"`
	// channelId: An unsigned long identifying the channel. The RDG server MUST provide
	// this value to the RDG client. The RDG client MUST save the returned channel ID for
	// future use in the ADM element Channel id (section 3.5.1). This channel ID is not
	// required on any future method calls.
	ChannelID uint32 `idl:"name:channelId" json:"channel_id"`
	// Return: The TsProxyCreateChannel return value.
	Return int32 `idl:"name:Return" json:"return"`
}

CreateChannelResponse structure represents the TsProxyCreateChannel operation response

func (*CreateChannelResponse) MarshalNDR 

func (o *CreateChannelResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CreateChannelResponse) UnmarshalNDR 

func (o *CreateChannelResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CreateTunnelRequest 

type CreateTunnelRequest struct {
	// TSGPacket: Pointer to the TSG_PACKET structure. If this call is made for a reauthentication,
	// then the packetId field MUST be set to TSG_PACKET_TYPE_REAUTH and the packetReauth
	// field of the TSGPacket union field MUST be a pointer to the TSG_PACKET_REAUTH structure.
	// Otherwise, if this call is made for a new connection and the RDG server is configured
	// for RPC authentication, then the value of the packetId field MUST be set to TSG_PACKET_TYPE_VERSIONCAPS
	// and the packetVersionCaps field of the TSGPacket union field MUST be a pointer to
	// the TSG_PACKET_VERSIONCAPS structure. Otherwise, if this call is made for a new connection
	// and the RDG server is configured for pluggable authentication <37>, then the value
	// of the packetId field MUST be set to TSG_PACKET_TYPE_AUTH and the packetAuth field
	// of the TSGPacket union field MUST be a pointer to the TSG_PACKET_AUTH structure.
	// If TSG_PACKET_AUTH is not populated correctly, the error E_PROXY_COOKIE_BADPACKET
	// is returned.<38>
	Packet *Packet `idl:"name:TSGPacket;pointer:ref" json:"packet"`
}

CreateTunnelRequest structure represents the TsProxyCreateTunnel operation request

func (*CreateTunnelRequest) MarshalNDR 

func (o *CreateTunnelRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CreateTunnelRequest) UnmarshalNDR 

func (o *CreateTunnelRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type CreateTunnelResponse 

type CreateTunnelResponse struct {
	// TSGPacketResponse: Pointer to the TSG_PACKET structure. If TSG_MESSAGING_CAP_CONSENT_SIGN
	// capability is negotiated, the packetId member of the TSGPacketResponse out parameter
	// MUST be TSG_PACKET_TYPE_CAPS_RESPONSE and the packetCapsResponse field of the TSGPacket
	// union field MUST be a pointer to the TSG_PACKET_CAPS_RESPONSE (section 2.2.9.2.1.7).
	// Otherwise, the packetId member of TSGPacketResponse MUST be TSG_PACKET_TYPE_QUARENC_RESPONSE,
	// and the packetQuarEncResponse field of the TSGPacket union field MUST be a pointer
	// to the TSG_PACKET_QUARENC_RESPONSE structure. The ADM element Nonce MUST be initialized
	// to a unique GUID and assigned to the nonce field of the TSG_PACKET_QUARENC_RESPONSE
	// structure either in TSGPacketResponse->TSGPacket.packetQuarEncResponse or TSGPacketResponse->TSGPacket.packetCapsResponse->pktQuarEncResponse.
	PacketResponse *Packet `idl:"name:TSGPacketResponse;pointer:ref" json:"packet_response"`
	// tunnelContext: An RPC context handle that represents context-specific information
	// for the tunnel (2). The RDG server MUST provide a non-NULL value. The RDG client
	// MUST save and use this context handle on all subsequent methods calls on the tunnel
	// (2). The methods are TsProxyAuthorizeTunnel, TsProxyCreateChannel, and TsProxyCloseTunnel.
	TunnelContext *TunnelSerialize `idl:"name:tunnelContext" json:"tunnel_context"`
	// tunnelId: An unsigned long identifier representing the tunnel (2). The RDG server
	// MUST save this value in the ADM element Tunnel id and SHOULD provide this value to
	// the RDG client. The RDG client SHOULD save the tunnel id for future use on the RDG
	// client itself. This tunnel id is not required on any future method calls to the RDG
	// server; the tunnelContext is used instead.
	TunnelID uint32 `idl:"name:tunnelId" json:"tunnel_id"`
	// Return: The TsProxyCreateTunnel return value.
	Return int32 `idl:"name:Return" json:"return"`
}

CreateTunnelResponse structure represents the TsProxyCreateTunnel operation response

func (*CreateTunnelResponse) MarshalNDR 

func (o *CreateTunnelResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CreateTunnelResponse) UnmarshalNDR 

func (o *CreateTunnelResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type EndpointInfo 

type EndpointInfo struct {
	// resourceName:  An array of RESOURCENAME strings, as specified in section 2.2.1.1.
	// The range is from 0 to numResourceNames. This array, in conjunction with alternateResourceNames
	// parameter array, comprises the alias names of the target server to which the RDG
	// server can connect. As specified in the Protocol Overview (section 1.3), the RDG
	// server acts as a proxy to target server. The RDP client and target server MUST use
	// [MS-RDPBCGR] to communicate.
	ResourceName []string `idl:"name:resourceName;size_is:(numResourceNames)" json:"resource_name"`
	// numResourceNames:  The number of RESOURCENAME datatypes in the resourceName array.
	// The value MUST be in the range of 1 to 50, inclusive.
	ResourceNamesLength uint32 `idl:"name:numResourceNames" json:"resource_names_length"`
	// alternateResourceNames:  An array of RESOURCENAME strings to be used as alternative
	// names for the target server. The range is from 0 to numAlternateResourceNames.<10>
	AlternateResourceNames []string `idl:"name:alternateResourceNames;size_is:(numAlternateResourceNames);pointer:unique" json:"alternate_resource_names"`
	// numAlternateResourceNames:  The number of allowed alternateResourceNames. The value
	// MUST be in the range of 0 to 3, inclusive.
	AlternateResourceNamesLength uint16 `idl:"name:numAlternateResourceNames" json:"alternate_resource_names_length"`
	// Port:  Specifies the protocol ID and TCP port number for the target server endpoint
	// to which the RDG server connects. The protocol ID is in the low order 16 bits of
	// this field and port number is in the high order 16 bits. The value of the protocol
	// ID must be set to 3.
	Port uint32 `idl:"name:Port" json:"port"`
}

EndpointInfo structure represents TSENDPOINTINFO RPC structure.

The TSENDPOINTINFO structure contains information about the target server to which the RDG server attempts to connect.

func (*EndpointInfo) MarshalNDR 

func (o *EndpointInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EndpointInfo) UnmarshalNDR 

func (o *EndpointInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type InitialPacketTypeUnion 

type InitialPacketTypeUnion struct {
	// Types that are assignable to Value
	//
	// *InitialPacketTypeUnion_PacketVersionCaps
	// *InitialPacketTypeUnion_PacketAuth
	Value is_InitialPacketTypeUnion `json:"value"`
}

InitialPacketTypeUnion structure represents TSG_INITIAL_PACKET_TYPE_UNION RPC union.

func (*InitialPacketTypeUnion) GetValue 

func (o *InitialPacketTypeUnion) GetValue() any

func (*InitialPacketTypeUnion) MarshalUnionNDR 

func (o *InitialPacketTypeUnion) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw uint32) error

func (*InitialPacketTypeUnion) NDRSwitchValue 

func (o *InitialPacketTypeUnion) NDRSwitchValue(sw uint32) uint32

func (*InitialPacketTypeUnion) UnmarshalUnionNDR 

func (o *InitialPacketTypeUnion) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw uint32) error

type InitialPacketTypeUnion_PacketAuth 

type InitialPacketTypeUnion_PacketAuth struct {
	PacketAuth *PacketAuth `idl:"name:packetAuth" json:"packet_auth"`
}

InitialPacketTypeUnion_PacketAuth structure represents TSG_INITIAL_PACKET_TYPE_UNION RPC union arm.

It has following labels: 16468

func (*InitialPacketTypeUnion_PacketAuth) MarshalNDR 

func (o *InitialPacketTypeUnion_PacketAuth) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*InitialPacketTypeUnion_PacketAuth) UnmarshalNDR 

func (o *InitialPacketTypeUnion_PacketAuth) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type InitialPacketTypeUnion_PacketVersionCaps 

type InitialPacketTypeUnion_PacketVersionCaps struct {
	PacketVersionCaps *PacketVersionCaps `idl:"name:packetVersionCaps" json:"packet_version_caps"`
}

InitialPacketTypeUnion_PacketVersionCaps structure represents TSG_INITIAL_PACKET_TYPE_UNION RPC union arm.

It has following labels: 22083

func (*InitialPacketTypeUnion_PacketVersionCaps) MarshalNDR 

func (o *InitialPacketTypeUnion_PacketVersionCaps) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*InitialPacketTypeUnion_PacketVersionCaps) UnmarshalNDR 

func (o *InitialPacketTypeUnion_PacketVersionCaps) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type InterfaceClient 

type InterfaceClient interface {

	// The TsProxyCreateTunnel method sets up the tunnel (2) in which all further communication
	// between the RDG client and the RDG server occurs. This is also used to exchange versioning
	// and capability information between the RDG client and RDG server. It is used to exchange
	// the RDG server certificate which has already been used to register for an authentication
	// service. After this method call has successfully been completed, a tunnel (2) shutdown
	// can be performed. This is accomplished by using the TsProxyCloseTunnel method call.
	//
	// Prerequisites: The connection state MUST be in Start state.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed in the rest of this table. The client MAY interpret failures
	// in any way it deems appropriate. See section 2.2.6 for details on these errors.
	//
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                          RETURN                          |                         STATE                          |                                                                                  |
	//	|                          VALUE                           |                       TRANSITION                       |                                   DESCRIPTION                                    |
	//	|                                                          |                                                        |                                                                                  |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                               | The connection MUST transition to the connected state. | Returned when a call to the TsProxyCreateTunnel method succeeds.                 |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_INTERNALERROR (0x800759D8)                       | The connection MUST transition to end state.           | Returned when the server encounters an unexpected error. The RDG client MUST end |
	//	|                                                          |                                                        | the protocol when this error is received.                                        |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_COOKIE_BADPACKET (0x800759F7)                    | The connection MUST transition to end state.           | Returned if the packetAuth field of the TSGPacket parameter is NULL.             |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_NOCERTAVAILABLE (0x800759EE)                     | The connection MUST transition to end state.           | Returned when the RDG server cannot find a certificate to register for SCHANNEL  |
	//	|                                                          |                                                        | Authentication Service (AS). The RDG client MUST end the protocol when this      |
	//	|                                                          |                                                        | error is received.                                                               |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_UNSUPPORTED_AUTHENTICATION_METHOD(0x800759F9)    | The connection MUST transition to end state.           | Returned to the RDG client when the RDG server is configured for pluggable       |
	//	|                                                          |                                                        | authentication and the value of the packetId member of the TSGPacket parameter   |
	//	|                                                          |                                                        | is not equal to TSG_PACKET_TYPE_AUTH or TSG_PACKET_TYPE_REAUTH. The RDG server   |
	//	|                                                          |                                                        | MUST disconnect the connection.                                                  |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_COOKIE_AUTHENTICATION_ACCESS_DENIED (0x800759F8) | The connection MUST transition to end state.           | Returned when the given user does not have access to connect via RDG server.     |
	//	|                                                          |                                                        | The RDG server MUST be in pluggable authentication mode for this error to be     |
	//	|                                                          |                                                        | returned.                                                                        |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_CAPABILITYMISMATCH (0x800759E9)                  | The connection MUST transition to end state.           | Returned when the RDG server supports the TSG_MESSAGING_CAP_CONSENT_SIGN         |
	//	|                                                          |                                                        | capability and is configured to allow only a RDG client that supports the        |
	//	|                                                          |                                                        | TSG_MESSAGING_CAP_CONSENT_SIGN capability, but the RDG client doesn't support    |
	//	|                                                          |                                                        | the capability.                                                                  |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	CreateTunnel(context.Context, *CreateTunnelRequest, ...dcerpc.CallOption) (*CreateTunnelResponse, error)

	// The TsProxyAuthorizeTunnel method is used to authorize the tunnel (2) based on rules
	// defined by the RDG server. The RDG server SHOULD perform security authorization for
	// the RDG client. The RDG server SHOULD<39> also use this method to require health
	// checks from the RDG client, which SHOULD result in the RDG client performing health
	// remediation.<40> After this method call has successfully been completed, a tunnel
	// (2) shutdown can be performed. If there are existing channels within the tunnel,
	// the RDG server MUST close all the channels before the tunnel shutdown. The tunnel
	// (2) shutdown is accomplished by using the TsProxyCloseTunnel method call.
	//
	// If this method call completes successfully, the ADM element Number of Connections
	// MUST be incremented by 1.
	//
	// Prerequisites: The connection MUST be in Connected state. If this call is made in
	// any other state, the result is undefined.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See 2.2.6 for details on these errors.
	//
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                        RETURN                        |                             STATE                             |                                                                                  |
	//	|                        VALUE                         |                          TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                                      |                                                               |                                                                                  |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                           | The connection MUST transition to the authorized state.       | Returned when a call to the TsProxyAuthorizeTunnel method succeeds.              |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_NAP_ACCESSDENIED (0x800759DB)                | The connection MUST transition to Tunnel Close Pending state. | Returned when the RDG server denies the RDG client access due to policy. The RDG |
	//	|                                                      |                                                               | client MUST end the protocol when this error is received.                        |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_NOTSUPPORTED) (0x000059E8)      | The connection MUST transition to Tunnel Close Pending state. | Returned if the packetId field of the TSGPacket parameter is not                 |
	//	|                                                      |                                                               | TSG_PACKET_TYPE_QUARREQUEST. The RDG client MUST end the protocol when this      |
	//	|                                                      |                                                               | error is received.                                                               |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_QUARANTINE_ACCESSDENIED (0x800759ED)         | The connection MUST transition to Tunnel Close Pending state. | Returned when the RDG server rejects the connection due to quarantine policy.    |
	//	|                                                      |                                                               | The RDG client MUST end the protocol when this error is received.                |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                     | The connection MUST transition to Tunnel Close Pending state. | Returned when this call is made either in a state other than the Connected state |
	//	|                                                      |                                                               | or the tunnelContext parameter is NULL. The RDG client MUST end the protocol     |
	//	|                                                      |                                                               | when this error is received.                                                     |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_MAXCONNECTIONSREACHED) (0x59E6) | The connection MUST transition to end state.                  | Returned when the ADM element Number of Connections is equal to the maximum      |
	//	|                                                      |                                                               | number of connections when the call is made.<43> The RDG client MUST end the     |
	//	|                                                      |                                                               | protocol when this error is received.                                            |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_INVALID_PARAMETER (0x00000057)                 | The connection MUST not transition its state.                 | Returned when the Negotiated Capabilities ADM element contains                   |
	//	|                                                      |                                                               | TSG_NAP_CAPABILITY_QUAR_SOH and TSGPacket->TSGPacket.packetQuarRequest->dataLen  |
	//	|                                                      |                                                               | is not zero and TSGPacket->TSGPacket.packetQuarRequest->data is not NULL and     |
	//	|                                                      |                                                               | TSGPacket->TSGPacket.packetQuarRequest->data is not prefixed with Nonce.         |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	AuthorizeTunnel(context.Context, *AuthorizeTunnelRequest, ...dcerpc.CallOption) (*AuthorizeTunnelResponse, error)

	// The TsProxyMakeTunnelCall method is designed to be used as a general purpose API.
	// If both the client and the server support the administrative message, the client
	// MAY request the same from the RDG server. If the RDG server has any administrative
	// messages, it SHOULD complete the pending call at this point in time. After a call
	// to TsProxyMakeTunnelCall returns, the RDG client SHOULD queue up another request
	// at this point in time. During the shutdown sequence, the client MUST make this call,
	// if a request is pending on the RDG server, to cancel the administrative message request.
	//
	// Prerequisites: The connection MUST be in Authorized state or Channel Created state
	// or Pipe Created state or Channel Close Pending state or Tunnel Close Pending state.
	// If this call is made in any other state, the error ERROR_ACCESS_DENIED is returned.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See section 2.2.6 for details on these errors. The connection MUST NOT
	// transition its state after completing the TsProxyMakeTunnelCall.
	//
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	|                        RETURN                        |                     STATE                     |                                                                                  |
	//	|                        VALUE                         |                  TRANSITION                   |                                   DESCRIPTION                                    |
	//	|                                                      |                                               |                                                                                  |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                           | The connection MUST NOT transition its state. | Returned when a call to the TsProxyMakeTunnelCall method succeeds.               |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                     | The connection MUST NOT transition its state. | Returned in the following cases. When the call is made in any                    |
	//	|                                                      |                                               | state other than Authorized, Channel Created, Pipe Created, Channel              |
	//	|                                                      |                                               | Close Pending, or Tunnel Close Pending. If procId is neither                     |
	//	|                                                      |                                               | TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST nor TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST.       |
	//	|                                                      |                                               | If procId is TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST and there is already a call to    |
	//	|                                                      |                                               | TsProxyMakeTunnelCall made earlier with procId TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST |
	//	|                                                      |                                               | and it is not yet returned. If procId is TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST     |
	//	|                                                      |                                               | and there is no call to TsProxyMakeTunnelCall made earlier with procId           |
	//	|                                                      |                                               | TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST that is not yet returned. If the tunnelContext |
	//	|                                                      |                                               | parameter is NULL. If the tunnel is not authorized. If the Reauthentication      |
	//	|                                                      |                                               | Connection ADM element is TRUE. The RDG client MUST end the protocol when this   |
	//	|                                                      |                                               | error is received.                                                               |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_FROM_WIN32(RPC_S_CALL_CANCELLED)(0x8007071A) | The connection MUST not transition its state. | Returned when the call is canceled by the RDG client or the call is canceled     |
	//	|                                                      |                                               | because a shutdown sequence is initiated.                                        |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	MakeTunnelCall(context.Context, *MakeTunnelCallRequest, ...dcerpc.CallOption) (*MakeTunnelCallResponse, error)

	// The TsProxyCreateChannel method is used to create a channel between the RDG client
	// and the RDG server.<44> The RDG server SHOULD connect to the target server during
	// this call to start communication between the RDG client and target server. If connection
	// to the target server cannot be done, the RDG server MUST return HRESULT_CODE(E_PROXY_TS_CONNECTFAILED)
	// as noted in the Return Values section.<45> The RDG server MUST return a representation
	// of the channel to the RDG client. After this method call has successfully been completed,
	// a channel shutdown can be performed by using the TsProxyCloseChannel method. Please
	// refer to section 3.1.1 for a state transition diagram.
	//
	// Prerequisites: The tunnel MUST be authorized; otherwise, the error ERROR_ACCESS_DENIED
	// is returned.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See section 2.2.6 for details on these errors.
	//
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                       RETURN                        |                          STATE                           |                                                                                  |
	//	|                        VALUE                        |                        TRANSITION                        |                                   DESCRIPTION                                    |
	//	|                                                     |                                                          |                                                                                  |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                          | The connection MUST transition to Channel Created state. | Returned when a call to the TsProxyCreateChannel method succeeds.                |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                    | The connection MUST NOT transition its state.            | Returned either if tunnelContext parameter is NULL, if this method is called on  |
	//	|                                                     |                                                          | a tunnel which is not authorized, if the tsEndPointInfo parameter is NULL, or if |
	//	|                                                     |                                                          | the numResourceNames member of the tsEndPointInfo parameter is zero.             |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_RAP_ACCESSDENIED (0x800759DA)               | The connection MUST NOT transition its state.            | Returned when an attempt to resolve or access a target server is blocked by RDG  |
	//	|                                                     |                                                          | server policies.                                                                 |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_INTERNALERROR (0x800759D8)                  | The connection MUST NOT transition its state.            | Returned when the server encounters an unexpected error while creating the       |
	//	|                                                     |                                                          | channel.                                                                         |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_TS_CONNECTFAILED) (0x000059DD) | The connection MUST NOT transition its state.            | This error is returned in rpc_fault packet when the RDG server fails to          |
	//	|                                                     |                                                          | connect to any of the target server names, as specified in the members of        |
	//	|                                                     |                                                          | tsEndPointInfo.                                                                  |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	CreateChannel(context.Context, *CreateChannelRequest, ...dcerpc.CallOption) (*CreateChannelResponse, error)

	// The TsProxyCloseChannel method is used to terminate the channel from the RDG client
	// to the RDG server. This SHOULD be called only if the RDG client has not received
	// the RPC response PDU with the PFC_LAST_FRAG bit set in the pfc_flags field. All communication
	// between the RDG client and the target server MUST stop after the RDG server executes
	// this method. The RDG client MUST NOT use this context handle in any subsequent operations
	// after calling this method. This will terminate the channel between the RDG client
	// and the target server. If the RDG server has not already sent the RPC response PDU
	// with the PFC_LAST_FRAG bit set in the pfc_flags field, which happens if the RDG server
	// initiated the disconnect, the RDG client will also receive a return code for TsProxySetupReceivePipe
	// in an RPC response PDU with the PFC_LAST_FRAG bit set in the pfc_flags. For a description
	// of RPC response PDU, pfc_flags, and PFC_LAST_FRAG, refer to [C706] sections 12.6.2
	// and 12.6.14.10.
	//
	// The RDG server completes the TsProxyCloseChannel only after sending all of the data
	// it received before this call was made. The RDG client receives the call complete
	// notification only after it receives all of the data that was sent by the RDG server
	// before completing TsProxyCloseChannel. Please refer to section 3.2.6.2.2 for details
	// on how the data is ensured to reach the destination.
	//
	// Prerequisites: The connection MUST be in Channel Created state or Pipe Created state
	// or Channel Close Pending state.
	//
	// Return Values:
	//
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|              RETURN              |                             STATE                             |                                                                                  |
	//	|              VALUE               |                          TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                  |                                                               |                                                                                  |
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)       | The connection MUST transition to Tunnel Close Pending state. | Returned when the call to the TsProxyCloseChannel method succeeds.               |
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005) | The connection MUST NOT transition its state.                 | Returned when the provided context parameter is NULL or not a valid channel      |
	//	|                                  |                                                               | context handle.                                                                  |
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	CloseChannel(context.Context, *CloseChannelRequest, ...dcerpc.CallOption) (*CloseChannelResponse, error)

	// The TsProxyCloseTunnel method is used to terminate the tunnel (1) between the RDG
	// client and the RDG server. All communication between the RDG client and RDG server
	// MUST stop after the RDG server executes this method. The RDG client MUST NOT use
	// this tunnel context handle in any subsequent operations after this method call. This
	// MUST be the final tear down phase of the RDG client to RDG server tunnel. If the
	// ADM element Reauthentication Connection is FALSE, then the ADM element Number of
	// Connections MUST be decremented by 1 in this call. If there is an existing channel
	// within the tunnel, it SHOULD first be closed using TsProxyCloseChannel. If the RDG
	// client calls the TsProxyCloseTunnel method before calling the TsProxyCloseChannel
	// method, the RDG server MUST close the channel and then close the tunnel.
	//
	// Prerequisites: The connection MUST be in any of the following states: Connected state,
	// Authorized state, Channel Created state, Pipe Created state, Channel Close Pending
	// state, or Tunnel Close Pending state.
	//
	// Return Values: The method MUST return 0 on success. This function SHOULD NOT fail
	// from a RDG protocol perspective. If TsProxyCloseTunnel is called while any of the
	// channels are not closed, then the RDG server MUST close all the channels and then
	// close the tunnel.
	//
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	|              RETURN              |                      STATE                       |                                                                                  |
	//	|              VALUE               |                    TRANSITION                    |                                   DESCRIPTION                                    |
	//	|                                  |                                                  |                                                                                  |
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)       | The connection MUST transition to the end state. | Returned when a call to the TsProxyCloseTunnel method succeeds.                  |
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005) | The connection MUST NOT transition its state.    | Returned when the provided context parameter is NULL or not a valid tunnel       |
	//	|                                  |                                                  | context handle.                                                                  |
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	CloseTunnel(context.Context, *CloseTunnelRequest, ...dcerpc.CallOption) (*CloseTunnelResponse, error)

	// The TsProxySetupReceivePipe method is used for data transfer from the RDG server
	// to the RDG client. The RDG server MUST create an RPC out pipe upon receiving this
	// method call from the RDG client. This call bypasses the NDR and hence, the RPC runtime
	// MUST NOT perform a strict NDR data consistency check for this method. Refer to section
	// 3.6.5 for details on NDR-bypassing. Section 3.6.5.4 and section 3.6.5.5 give details
	// on wire representation of data for responses to TsProxySetupReceivePipe. The out
	// pipe MUST be created by the RDG server in the same manner as NDR creates it for a
	// call.<49> The RDG server MUST use this out pipe and Stub Data field in RPC response
	// PDUs to send all data from the target server to the RDG client on the channel. The
	// RDG client MUST use this out pipe to pull data from the target server on the channel.
	// On connection disconnect, the RDG server MUST send the following on the pipe: A DWORD
	// return code in an RPC response PDU and set the PFC_LAST_FRAG bit in the pfc_flags
	// field of the RPC response PDU. The pipe close is indicated when the PFC_LAST_FRAG
	// bit is set in the pfc_flags field of the RPC response PDU. When the RDG client sees
	// that the PFC_LAST_FRAG bit is set in the pfc_flags field of the RPC response PDU,
	// it MUST interpret the 4 bytes Stub Data as the return code of TsProxySetupReceivePipe.
	// For a description of RPC response PDU, pfc_flags, PFC_LAST_FRAG, and Stub Data, refer
	// to sections 12.6.2 and 12.6.4.10 in [C706]. The RDG client and RDG server MUST negotiate
	// a separate out pipe for each channel. Out pipes MUST NOT be used or shared across
	// channels.<50>
	//
	// As long as the channel is not closed, the RPC and Transport layer guarantee that
	// any data that is sent by the RDG server reaches the RDG client. RPC and Transport
	// layer also ensure that the data is delivered to the RDG client in the order it was
	// sent by the RDG server.
	//
	// After the call reaches the RDG server, the connection MUST transition to Pipe Created
	// state after setting up the out pipe.
	//
	// Prerequisites: The connection MUST be in Channel Created state. If this is called
	// in any other state, then the behavior is undefined.
	//
	// Return Values: The method MUST return ERROR_GRACEFUL_DISCONNECT on success, that
	// is, if the RDG client gracefully disconnects the connection by calling TsProxyCloseChannel.
	// Other failures MUST be one of the codes listed. The client MAY interpret failures
	// in any way it deems appropriate. See section 2.2.6 for details on these errors.
	//
	// The error DWORD value is always sent, when the receive pipe closes down. The receive
	// pipe will always close down when a disconnect takes place.
	//
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                           RETURN                           |                             STATE                             |                                                                                  |
	//	|                           VALUE                            |                          TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                                            |                                                               |                                                                                  |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                           | The connection MUST transition to Tunnel Close Pending state. | Returned either if this method is called before TsProxyCreateChannel or if the   |
	//	|                                                            |                                                               | Channel Context Handle ADM element is NULL. The RDG client MUST end the protocol |
	//	|                                                            |                                                               | when this error is received.                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_INTERNALERROR) (0x000059D8)           | The connection MUST transition to Tunnel Close Pending state. | Returned when an unexpected error occurs in TsProxySetupReceivePipe. The RDG     |
	//	|                                                            |                                                               | client MUST end the protocol when this error is received.                        |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_TS_CONNECTFAILED) (0x000059DD)        | The connection MUST transition to Tunnel Close Pending state. | Returned when the RDG server fails to connect to target server. It is returned   |
	//	|                                                            |                                                               | in an rpc_fault packet.<52> The RDG client MUST end the protocol when this error |
	//	|                                                            |                                                               | is received.                                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_SESSIONTIMEOUT) (0x000059F6)          | The connection MUST transition to Tunnel Close Pending state. | Returned by RDG server if a session timeout occurs and "disconnect on session    |
	//	|                                                            |                                                               | timeout" is configured at the RDG server and the ADM element Negotiated          |
	//	|                                                            |                                                               | Capabilities contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The RDG client MUST end   |
	//	|                                                            |                                                               | the protocol when this error is received.                                        |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_AUTHN_FAILED) (0x000059FA)     | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the client has failed because the    |
	//	|                                                            |                                                               | user credentials are no longer valid and the ADM element Negotiated Capabilities |
	//	|                                                            |                                                               | contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The RDG client MUST end the protocol   |
	//	|                                                            |                                                               | when this error is received.                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_CAP_FAILED) (0x000059FB)       | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the client has failed because the    |
	//	|                                                            |                                                               | user is not authorized to connect through the RDG server anymore and the ADM     |
	//	|                                                            |                                                               | element Negotiated Capabilities contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The    |
	//	|                                                            |                                                               | RDG client MUST end the protocol when this error is received.                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_RAP_FAILED) (0x000059FC)       | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the client has failed because the    |
	//	|                                                            |                                                               | user is not authorized to connect to the given end resource anymore and the ADM  |
	//	|                                                            |                                                               | element Negotiated Capabilities contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The    |
	//	|                                                            |                                                               | RDG client MUST end the protocol when this error is received.                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_CONNECTIONABORTED) (0x000004D4)       | The connection MUST transition to Tunnel Close Pending state. | Returned when the following happens: The RDG server administrator forcefully     |
	//	|                                                            |                                                               | disconnects the connection. Or when the ADM element Negotiated Capabilities      |
	//	|                                                            |                                                               | doesn't contain TSG_NAP_CAPABILITY_IDLE_TIMEOUT and any one of the following     |
	//	|                                                            |                                                               | happens: Session timeout occurs and disconnect on session timeout is configured  |
	//	|                                                            |                                                               | at the RDG server. Reauthentication attempt by the client has failed because     |
	//	|                                                            |                                                               | the user credentials are no longer valid. Reauthentication attempt by the client |
	//	|                                                            |                                                               | has failed because the user is not authorized to connect through the RDG server  |
	//	|                                                            |                                                               | anymore. Reauthentication attempt by the client has failed because the user is   |
	//	|                                                            |                                                               | not authorized to connect to the given end resource anymore. Reauthentication    |
	//	|                                                            |                                                               | attempt by the RDG client has failed because the health of the user's computer   |
	//	|                                                            |                                                               | is no longer compliant with the RDG server configuration. The RDG client MUST    |
	//	|                                                            |                                                               | end the protocol when this error is received.                                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_SDR_NOT_SUPPORTED_BY_TS) (0x000059FD) | The connection MUST transition to Tunnel Close Pending state. | The RDG server is capable of exchanging policies with some target servers.       |
	//	|                                                            |                                                               | The RDG server MAY be configured to allow connections to only target servers     |
	//	|                                                            |                                                               | that are capable of policy exchange. If such a setting is configured and the     |
	//	|                                                            |                                                               | target server is not capable of exchanging policies with the RDG server, this    |
	//	|                                                            |                                                               | error will be returned. The RDG client MUST end the protocol when this error is  |
	//	|                                                            |                                                               | received.                                                                        |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_GRACEFUL_DISCONNECT (0x000004CA)                     | The connection MUST transition to Tunnel Close Pending state. | Returned when the connection is disconnected gracefully by the RDG client        |
	//	|                                                            |                                                               | calling TsProxyCloseChannel.                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_NAP_FAILED) (0x00005A00)       | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the RDG client has failed            |
	//	|                                                            |                                                               | because the user's computer's health is no longer compliant with the RDG         |
	//	|                                                            |                                                               | server configuration and the ADM element Negotiated Capabilities contains        |
	//	|                                                            |                                                               | TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The RDG client MUST end the protocol when this  |
	//	|                                                            |                                                               | error is received.                                                               |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_OPERATION_ABORTED(0x000003E3)                        | The connection MUST transition to Tunnel Close Pending state. | Returned when the call to TsProxySetupReceivePipe is received after the          |
	//	|                                                            |                                                               | Connection Timer has expired.                                                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_BAD_ARGUMENTS(0x000000A0)                            | The connection MUST transition to Tunnel Close Pending state. | Returned when the target server unexpectedly closes the connection between the   |
	//	|                                                            |                                                               | RDG server and the target server.                                                |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	SetupReceivePipe(context.Context, *SetupReceivePipeRequest, ...dcerpc.CallOption) (*SetupReceivePipeResponse, error)

	// The method is used for data transfer from the RDG client to the target server, via
	// the RDG server. The RDG server SHOULD send the buffer data received in this method
	// to the target server. The RPC runtime MUST NOT perform a strict NDR data consistency
	// check for this method. The Remote Desktop Gateway Server Protocol bypasses NDR for
	// this method. The wire data MUST follow the regular RPC specifications as specified
	// in [C706] section 2.1, and [MS-RPCE] minus all NDR headers, trailers, and NDR-specific
	// payload. The RDG server MUST have created the channel to the target server before
	// completing this method call. This method MAY be called multiple times by the RDG
	// client, but only after the previous method call finishes. The RDG server MUST handle
	// multiple sequential invocations of this method call. This method bypasses NDR. For
	// this reason, unlike other RPC methods that return an HRESULT, this method returns
	// a DWORD. This is directly passed to the callee from underlying RPC calls.<48> When
	// this call fails, the RDG server MUST send the final response to TsProxySetupReceivePipe
	// call.
	//
	// Prerequisites: The connection MUST be in Pipe Created state. If this call is made
	// in any other state, ERROR_ONLY_IF_CONNECTED or E_PROXY_TS_CONNECTFAILED is returned.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See section 2.2.6 for details on these errors.
	//
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                      RETURN                      |                             STATE                              |                                                                                  |
	//	|                      VALUE                       |                           TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                                  |                                                                |                                                                                  |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                       | The connection MUST remain in PipeCreated state.               | Returned when a call to the TsProxySendToServer method succeeds.                 |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ONLY_IF_CONNECTED (0x000004E3)             | The connection MUST transition to Channel Close Pending state. | Returned by the RDG server when an attempt is made by the client to send data    |
	//	|                                                  |                                                                | to the target server on connection state other than Pipe Created state. The RDG  |
	//	|                                                  |                                                                | client MUST end the protocol when this error is returned.                        |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                 | The connection MUST transition to Channel Close Pending state. | Returned if the channel context handle passed in the pRpcMessage parameter is    |
	//	|                                                  |                                                                | NULL. The RDG client MUST end the protocol when this error is received.          |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_INTERNALERROR) (0x000059D8) | The connection MUST transition to Channel Close Pending state. | Returned when an unexpected error occurs in TsProxySendToServer. The RDG client  |
	//	|                                                  |                                                                | MUST end the protocol when this error is received.                               |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	SendToServer(context.Context, *SendToServerRequest, ...dcerpc.CallOption) (*SendToServerResponse, error)

	// AlterContext alters the client context.
	AlterContext(context.Context, ...dcerpc.Option) error
}

TsProxyRpcInterface interface.

func NewInterfaceClient 

func NewInterfaceClient(ctx context.Context, cc dcerpc.Conn, opts ...dcerpc.Option) (InterfaceClient, error)

type InterfaceServer 

type InterfaceServer interface {

	// The TsProxyCreateTunnel method sets up the tunnel (2) in which all further communication
	// between the RDG client and the RDG server occurs. This is also used to exchange versioning
	// and capability information between the RDG client and RDG server. It is used to exchange
	// the RDG server certificate which has already been used to register for an authentication
	// service. After this method call has successfully been completed, a tunnel (2) shutdown
	// can be performed. This is accomplished by using the TsProxyCloseTunnel method call.
	//
	// Prerequisites: The connection state MUST be in Start state.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed in the rest of this table. The client MAY interpret failures
	// in any way it deems appropriate. See section 2.2.6 for details on these errors.
	//
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                          RETURN                          |                         STATE                          |                                                                                  |
	//	|                          VALUE                           |                       TRANSITION                       |                                   DESCRIPTION                                    |
	//	|                                                          |                                                        |                                                                                  |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                               | The connection MUST transition to the connected state. | Returned when a call to the TsProxyCreateTunnel method succeeds.                 |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_INTERNALERROR (0x800759D8)                       | The connection MUST transition to end state.           | Returned when the server encounters an unexpected error. The RDG client MUST end |
	//	|                                                          |                                                        | the protocol when this error is received.                                        |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_COOKIE_BADPACKET (0x800759F7)                    | The connection MUST transition to end state.           | Returned if the packetAuth field of the TSGPacket parameter is NULL.             |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_NOCERTAVAILABLE (0x800759EE)                     | The connection MUST transition to end state.           | Returned when the RDG server cannot find a certificate to register for SCHANNEL  |
	//	|                                                          |                                                        | Authentication Service (AS). The RDG client MUST end the protocol when this      |
	//	|                                                          |                                                        | error is received.                                                               |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_UNSUPPORTED_AUTHENTICATION_METHOD(0x800759F9)    | The connection MUST transition to end state.           | Returned to the RDG client when the RDG server is configured for pluggable       |
	//	|                                                          |                                                        | authentication and the value of the packetId member of the TSGPacket parameter   |
	//	|                                                          |                                                        | is not equal to TSG_PACKET_TYPE_AUTH or TSG_PACKET_TYPE_REAUTH. The RDG server   |
	//	|                                                          |                                                        | MUST disconnect the connection.                                                  |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_COOKIE_AUTHENTICATION_ACCESS_DENIED (0x800759F8) | The connection MUST transition to end state.           | Returned when the given user does not have access to connect via RDG server.     |
	//	|                                                          |                                                        | The RDG server MUST be in pluggable authentication mode for this error to be     |
	//	|                                                          |                                                        | returned.                                                                        |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_CAPABILITYMISMATCH (0x800759E9)                  | The connection MUST transition to end state.           | Returned when the RDG server supports the TSG_MESSAGING_CAP_CONSENT_SIGN         |
	//	|                                                          |                                                        | capability and is configured to allow only a RDG client that supports the        |
	//	|                                                          |                                                        | TSG_MESSAGING_CAP_CONSENT_SIGN capability, but the RDG client doesn't support    |
	//	|                                                          |                                                        | the capability.                                                                  |
	//	+----------------------------------------------------------+--------------------------------------------------------+----------------------------------------------------------------------------------+
	CreateTunnel(context.Context, *CreateTunnelRequest) (*CreateTunnelResponse, error)

	// The TsProxyAuthorizeTunnel method is used to authorize the tunnel (2) based on rules
	// defined by the RDG server. The RDG server SHOULD perform security authorization for
	// the RDG client. The RDG server SHOULD<39> also use this method to require health
	// checks from the RDG client, which SHOULD result in the RDG client performing health
	// remediation.<40> After this method call has successfully been completed, a tunnel
	// (2) shutdown can be performed. If there are existing channels within the tunnel,
	// the RDG server MUST close all the channels before the tunnel shutdown. The tunnel
	// (2) shutdown is accomplished by using the TsProxyCloseTunnel method call.
	//
	// If this method call completes successfully, the ADM element Number of Connections
	// MUST be incremented by 1.
	//
	// Prerequisites: The connection MUST be in Connected state. If this call is made in
	// any other state, the result is undefined.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See 2.2.6 for details on these errors.
	//
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                        RETURN                        |                             STATE                             |                                                                                  |
	//	|                        VALUE                         |                          TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                                      |                                                               |                                                                                  |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                           | The connection MUST transition to the authorized state.       | Returned when a call to the TsProxyAuthorizeTunnel method succeeds.              |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_NAP_ACCESSDENIED (0x800759DB)                | The connection MUST transition to Tunnel Close Pending state. | Returned when the RDG server denies the RDG client access due to policy. The RDG |
	//	|                                                      |                                                               | client MUST end the protocol when this error is received.                        |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_NOTSUPPORTED) (0x000059E8)      | The connection MUST transition to Tunnel Close Pending state. | Returned if the packetId field of the TSGPacket parameter is not                 |
	//	|                                                      |                                                               | TSG_PACKET_TYPE_QUARREQUEST. The RDG client MUST end the protocol when this      |
	//	|                                                      |                                                               | error is received.                                                               |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_QUARANTINE_ACCESSDENIED (0x800759ED)         | The connection MUST transition to Tunnel Close Pending state. | Returned when the RDG server rejects the connection due to quarantine policy.    |
	//	|                                                      |                                                               | The RDG client MUST end the protocol when this error is received.                |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                     | The connection MUST transition to Tunnel Close Pending state. | Returned when this call is made either in a state other than the Connected state |
	//	|                                                      |                                                               | or the tunnelContext parameter is NULL. The RDG client MUST end the protocol     |
	//	|                                                      |                                                               | when this error is received.                                                     |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_MAXCONNECTIONSREACHED) (0x59E6) | The connection MUST transition to end state.                  | Returned when the ADM element Number of Connections is equal to the maximum      |
	//	|                                                      |                                                               | number of connections when the call is made.<43> The RDG client MUST end the     |
	//	|                                                      |                                                               | protocol when this error is received.                                            |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_INVALID_PARAMETER (0x00000057)                 | The connection MUST not transition its state.                 | Returned when the Negotiated Capabilities ADM element contains                   |
	//	|                                                      |                                                               | TSG_NAP_CAPABILITY_QUAR_SOH and TSGPacket->TSGPacket.packetQuarRequest->dataLen  |
	//	|                                                      |                                                               | is not zero and TSGPacket->TSGPacket.packetQuarRequest->data is not NULL and     |
	//	|                                                      |                                                               | TSGPacket->TSGPacket.packetQuarRequest->data is not prefixed with Nonce.         |
	//	+------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	AuthorizeTunnel(context.Context, *AuthorizeTunnelRequest) (*AuthorizeTunnelResponse, error)

	// The TsProxyMakeTunnelCall method is designed to be used as a general purpose API.
	// If both the client and the server support the administrative message, the client
	// MAY request the same from the RDG server. If the RDG server has any administrative
	// messages, it SHOULD complete the pending call at this point in time. After a call
	// to TsProxyMakeTunnelCall returns, the RDG client SHOULD queue up another request
	// at this point in time. During the shutdown sequence, the client MUST make this call,
	// if a request is pending on the RDG server, to cancel the administrative message request.
	//
	// Prerequisites: The connection MUST be in Authorized state or Channel Created state
	// or Pipe Created state or Channel Close Pending state or Tunnel Close Pending state.
	// If this call is made in any other state, the error ERROR_ACCESS_DENIED is returned.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See section 2.2.6 for details on these errors. The connection MUST NOT
	// transition its state after completing the TsProxyMakeTunnelCall.
	//
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	|                        RETURN                        |                     STATE                     |                                                                                  |
	//	|                        VALUE                         |                  TRANSITION                   |                                   DESCRIPTION                                    |
	//	|                                                      |                                               |                                                                                  |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                           | The connection MUST NOT transition its state. | Returned when a call to the TsProxyMakeTunnelCall method succeeds.               |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                     | The connection MUST NOT transition its state. | Returned in the following cases. When the call is made in any                    |
	//	|                                                      |                                               | state other than Authorized, Channel Created, Pipe Created, Channel              |
	//	|                                                      |                                               | Close Pending, or Tunnel Close Pending. If procId is neither                     |
	//	|                                                      |                                               | TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST nor TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST.       |
	//	|                                                      |                                               | If procId is TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST and there is already a call to    |
	//	|                                                      |                                               | TsProxyMakeTunnelCall made earlier with procId TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST |
	//	|                                                      |                                               | and it is not yet returned. If procId is TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST     |
	//	|                                                      |                                               | and there is no call to TsProxyMakeTunnelCall made earlier with procId           |
	//	|                                                      |                                               | TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST that is not yet returned. If the tunnelContext |
	//	|                                                      |                                               | parameter is NULL. If the tunnel is not authorized. If the Reauthentication      |
	//	|                                                      |                                               | Connection ADM element is TRUE. The RDG client MUST end the protocol when this   |
	//	|                                                      |                                               | error is received.                                                               |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_FROM_WIN32(RPC_S_CALL_CANCELLED)(0x8007071A) | The connection MUST not transition its state. | Returned when the call is canceled by the RDG client or the call is canceled     |
	//	|                                                      |                                               | because a shutdown sequence is initiated.                                        |
	//	+------------------------------------------------------+-----------------------------------------------+----------------------------------------------------------------------------------+
	MakeTunnelCall(context.Context, *MakeTunnelCallRequest) (*MakeTunnelCallResponse, error)

	// The TsProxyCreateChannel method is used to create a channel between the RDG client
	// and the RDG server.<44> The RDG server SHOULD connect to the target server during
	// this call to start communication between the RDG client and target server. If connection
	// to the target server cannot be done, the RDG server MUST return HRESULT_CODE(E_PROXY_TS_CONNECTFAILED)
	// as noted in the Return Values section.<45> The RDG server MUST return a representation
	// of the channel to the RDG client. After this method call has successfully been completed,
	// a channel shutdown can be performed by using the TsProxyCloseChannel method. Please
	// refer to section 3.1.1 for a state transition diagram.
	//
	// Prerequisites: The tunnel MUST be authorized; otherwise, the error ERROR_ACCESS_DENIED
	// is returned.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See section 2.2.6 for details on these errors.
	//
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                       RETURN                        |                          STATE                           |                                                                                  |
	//	|                        VALUE                        |                        TRANSITION                        |                                   DESCRIPTION                                    |
	//	|                                                     |                                                          |                                                                                  |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                          | The connection MUST transition to Channel Created state. | Returned when a call to the TsProxyCreateChannel method succeeds.                |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                    | The connection MUST NOT transition its state.            | Returned either if tunnelContext parameter is NULL, if this method is called on  |
	//	|                                                     |                                                          | a tunnel which is not authorized, if the tsEndPointInfo parameter is NULL, or if |
	//	|                                                     |                                                          | the numResourceNames member of the tsEndPointInfo parameter is zero.             |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_RAP_ACCESSDENIED (0x800759DA)               | The connection MUST NOT transition its state.            | Returned when an attempt to resolve or access a target server is blocked by RDG  |
	//	|                                                     |                                                          | server policies.                                                                 |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| E_PROXY_INTERNALERROR (0x800759D8)                  | The connection MUST NOT transition its state.            | Returned when the server encounters an unexpected error while creating the       |
	//	|                                                     |                                                          | channel.                                                                         |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_TS_CONNECTFAILED) (0x000059DD) | The connection MUST NOT transition its state.            | This error is returned in rpc_fault packet when the RDG server fails to          |
	//	|                                                     |                                                          | connect to any of the target server names, as specified in the members of        |
	//	|                                                     |                                                          | tsEndPointInfo.                                                                  |
	//	+-----------------------------------------------------+----------------------------------------------------------+----------------------------------------------------------------------------------+
	CreateChannel(context.Context, *CreateChannelRequest) (*CreateChannelResponse, error)

	// The TsProxyCloseChannel method is used to terminate the channel from the RDG client
	// to the RDG server. This SHOULD be called only if the RDG client has not received
	// the RPC response PDU with the PFC_LAST_FRAG bit set in the pfc_flags field. All communication
	// between the RDG client and the target server MUST stop after the RDG server executes
	// this method. The RDG client MUST NOT use this context handle in any subsequent operations
	// after calling this method. This will terminate the channel between the RDG client
	// and the target server. If the RDG server has not already sent the RPC response PDU
	// with the PFC_LAST_FRAG bit set in the pfc_flags field, which happens if the RDG server
	// initiated the disconnect, the RDG client will also receive a return code for TsProxySetupReceivePipe
	// in an RPC response PDU with the PFC_LAST_FRAG bit set in the pfc_flags. For a description
	// of RPC response PDU, pfc_flags, and PFC_LAST_FRAG, refer to [C706] sections 12.6.2
	// and 12.6.14.10.
	//
	// The RDG server completes the TsProxyCloseChannel only after sending all of the data
	// it received before this call was made. The RDG client receives the call complete
	// notification only after it receives all of the data that was sent by the RDG server
	// before completing TsProxyCloseChannel. Please refer to section 3.2.6.2.2 for details
	// on how the data is ensured to reach the destination.
	//
	// Prerequisites: The connection MUST be in Channel Created state or Pipe Created state
	// or Channel Close Pending state.
	//
	// Return Values:
	//
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|              RETURN              |                             STATE                             |                                                                                  |
	//	|              VALUE               |                          TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                  |                                                               |                                                                                  |
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)       | The connection MUST transition to Tunnel Close Pending state. | Returned when the call to the TsProxyCloseChannel method succeeds.               |
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005) | The connection MUST NOT transition its state.                 | Returned when the provided context parameter is NULL or not a valid channel      |
	//	|                                  |                                                               | context handle.                                                                  |
	//	+----------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	CloseChannel(context.Context, *CloseChannelRequest) (*CloseChannelResponse, error)

	// The TsProxyCloseTunnel method is used to terminate the tunnel (1) between the RDG
	// client and the RDG server. All communication between the RDG client and RDG server
	// MUST stop after the RDG server executes this method. The RDG client MUST NOT use
	// this tunnel context handle in any subsequent operations after this method call. This
	// MUST be the final tear down phase of the RDG client to RDG server tunnel. If the
	// ADM element Reauthentication Connection is FALSE, then the ADM element Number of
	// Connections MUST be decremented by 1 in this call. If there is an existing channel
	// within the tunnel, it SHOULD first be closed using TsProxyCloseChannel. If the RDG
	// client calls the TsProxyCloseTunnel method before calling the TsProxyCloseChannel
	// method, the RDG server MUST close the channel and then close the tunnel.
	//
	// Prerequisites: The connection MUST be in any of the following states: Connected state,
	// Authorized state, Channel Created state, Pipe Created state, Channel Close Pending
	// state, or Tunnel Close Pending state.
	//
	// Return Values: The method MUST return 0 on success. This function SHOULD NOT fail
	// from a RDG protocol perspective. If TsProxyCloseTunnel is called while any of the
	// channels are not closed, then the RDG server MUST close all the channels and then
	// close the tunnel.
	//
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	|              RETURN              |                      STATE                       |                                                                                  |
	//	|              VALUE               |                    TRANSITION                    |                                   DESCRIPTION                                    |
	//	|                                  |                                                  |                                                                                  |
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)       | The connection MUST transition to the end state. | Returned when a call to the TsProxyCloseTunnel method succeeds.                  |
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005) | The connection MUST NOT transition its state.    | Returned when the provided context parameter is NULL or not a valid tunnel       |
	//	|                                  |                                                  | context handle.                                                                  |
	//	+----------------------------------+--------------------------------------------------+----------------------------------------------------------------------------------+
	CloseTunnel(context.Context, *CloseTunnelRequest) (*CloseTunnelResponse, error)

	// The TsProxySetupReceivePipe method is used for data transfer from the RDG server
	// to the RDG client. The RDG server MUST create an RPC out pipe upon receiving this
	// method call from the RDG client. This call bypasses the NDR and hence, the RPC runtime
	// MUST NOT perform a strict NDR data consistency check for this method. Refer to section
	// 3.6.5 for details on NDR-bypassing. Section 3.6.5.4 and section 3.6.5.5 give details
	// on wire representation of data for responses to TsProxySetupReceivePipe. The out
	// pipe MUST be created by the RDG server in the same manner as NDR creates it for a
	// call.<49> The RDG server MUST use this out pipe and Stub Data field in RPC response
	// PDUs to send all data from the target server to the RDG client on the channel. The
	// RDG client MUST use this out pipe to pull data from the target server on the channel.
	// On connection disconnect, the RDG server MUST send the following on the pipe: A DWORD
	// return code in an RPC response PDU and set the PFC_LAST_FRAG bit in the pfc_flags
	// field of the RPC response PDU. The pipe close is indicated when the PFC_LAST_FRAG
	// bit is set in the pfc_flags field of the RPC response PDU. When the RDG client sees
	// that the PFC_LAST_FRAG bit is set in the pfc_flags field of the RPC response PDU,
	// it MUST interpret the 4 bytes Stub Data as the return code of TsProxySetupReceivePipe.
	// For a description of RPC response PDU, pfc_flags, PFC_LAST_FRAG, and Stub Data, refer
	// to sections 12.6.2 and 12.6.4.10 in [C706]. The RDG client and RDG server MUST negotiate
	// a separate out pipe for each channel. Out pipes MUST NOT be used or shared across
	// channels.<50>
	//
	// As long as the channel is not closed, the RPC and Transport layer guarantee that
	// any data that is sent by the RDG server reaches the RDG client. RPC and Transport
	// layer also ensure that the data is delivered to the RDG client in the order it was
	// sent by the RDG server.
	//
	// After the call reaches the RDG server, the connection MUST transition to Pipe Created
	// state after setting up the out pipe.
	//
	// Prerequisites: The connection MUST be in Channel Created state. If this is called
	// in any other state, then the behavior is undefined.
	//
	// Return Values: The method MUST return ERROR_GRACEFUL_DISCONNECT on success, that
	// is, if the RDG client gracefully disconnects the connection by calling TsProxyCloseChannel.
	// Other failures MUST be one of the codes listed. The client MAY interpret failures
	// in any way it deems appropriate. See section 2.2.6 for details on these errors.
	//
	// The error DWORD value is always sent, when the receive pipe closes down. The receive
	// pipe will always close down when a disconnect takes place.
	//
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                           RETURN                           |                             STATE                             |                                                                                  |
	//	|                           VALUE                            |                          TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                                            |                                                               |                                                                                  |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                           | The connection MUST transition to Tunnel Close Pending state. | Returned either if this method is called before TsProxyCreateChannel or if the   |
	//	|                                                            |                                                               | Channel Context Handle ADM element is NULL. The RDG client MUST end the protocol |
	//	|                                                            |                                                               | when this error is received.                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_INTERNALERROR) (0x000059D8)           | The connection MUST transition to Tunnel Close Pending state. | Returned when an unexpected error occurs in TsProxySetupReceivePipe. The RDG     |
	//	|                                                            |                                                               | client MUST end the protocol when this error is received.                        |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_TS_CONNECTFAILED) (0x000059DD)        | The connection MUST transition to Tunnel Close Pending state. | Returned when the RDG server fails to connect to target server. It is returned   |
	//	|                                                            |                                                               | in an rpc_fault packet.<52> The RDG client MUST end the protocol when this error |
	//	|                                                            |                                                               | is received.                                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_SESSIONTIMEOUT) (0x000059F6)          | The connection MUST transition to Tunnel Close Pending state. | Returned by RDG server if a session timeout occurs and "disconnect on session    |
	//	|                                                            |                                                               | timeout" is configured at the RDG server and the ADM element Negotiated          |
	//	|                                                            |                                                               | Capabilities contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The RDG client MUST end   |
	//	|                                                            |                                                               | the protocol when this error is received.                                        |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_AUTHN_FAILED) (0x000059FA)     | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the client has failed because the    |
	//	|                                                            |                                                               | user credentials are no longer valid and the ADM element Negotiated Capabilities |
	//	|                                                            |                                                               | contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The RDG client MUST end the protocol   |
	//	|                                                            |                                                               | when this error is received.                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_CAP_FAILED) (0x000059FB)       | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the client has failed because the    |
	//	|                                                            |                                                               | user is not authorized to connect through the RDG server anymore and the ADM     |
	//	|                                                            |                                                               | element Negotiated Capabilities contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The    |
	//	|                                                            |                                                               | RDG client MUST end the protocol when this error is received.                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_RAP_FAILED) (0x000059FC)       | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the client has failed because the    |
	//	|                                                            |                                                               | user is not authorized to connect to the given end resource anymore and the ADM  |
	//	|                                                            |                                                               | element Negotiated Capabilities contains TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The    |
	//	|                                                            |                                                               | RDG client MUST end the protocol when this error is received.                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_CONNECTIONABORTED) (0x000004D4)       | The connection MUST transition to Tunnel Close Pending state. | Returned when the following happens: The RDG server administrator forcefully     |
	//	|                                                            |                                                               | disconnects the connection. Or when the ADM element Negotiated Capabilities      |
	//	|                                                            |                                                               | doesn't contain TSG_NAP_CAPABILITY_IDLE_TIMEOUT and any one of the following     |
	//	|                                                            |                                                               | happens: Session timeout occurs and disconnect on session timeout is configured  |
	//	|                                                            |                                                               | at the RDG server. Reauthentication attempt by the client has failed because     |
	//	|                                                            |                                                               | the user credentials are no longer valid. Reauthentication attempt by the client |
	//	|                                                            |                                                               | has failed because the user is not authorized to connect through the RDG server  |
	//	|                                                            |                                                               | anymore. Reauthentication attempt by the client has failed because the user is   |
	//	|                                                            |                                                               | not authorized to connect to the given end resource anymore. Reauthentication    |
	//	|                                                            |                                                               | attempt by the RDG client has failed because the health of the user's computer   |
	//	|                                                            |                                                               | is no longer compliant with the RDG server configuration. The RDG client MUST    |
	//	|                                                            |                                                               | end the protocol when this error is received.                                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_SDR_NOT_SUPPORTED_BY_TS) (0x000059FD) | The connection MUST transition to Tunnel Close Pending state. | The RDG server is capable of exchanging policies with some target servers.       |
	//	|                                                            |                                                               | The RDG server MAY be configured to allow connections to only target servers     |
	//	|                                                            |                                                               | that are capable of policy exchange. If such a setting is configured and the     |
	//	|                                                            |                                                               | target server is not capable of exchanging policies with the RDG server, this    |
	//	|                                                            |                                                               | error will be returned. The RDG client MUST end the protocol when this error is  |
	//	|                                                            |                                                               | received.                                                                        |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_GRACEFUL_DISCONNECT (0x000004CA)                     | The connection MUST transition to Tunnel Close Pending state. | Returned when the connection is disconnected gracefully by the RDG client        |
	//	|                                                            |                                                               | calling TsProxyCloseChannel.                                                     |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_REAUTH_NAP_FAILED) (0x00005A00)       | The connection MUST transition to Tunnel Close Pending state. | Returned when a reauthentication attempt by the RDG client has failed            |
	//	|                                                            |                                                               | because the user's computer's health is no longer compliant with the RDG         |
	//	|                                                            |                                                               | server configuration and the ADM element Negotiated Capabilities contains        |
	//	|                                                            |                                                               | TSG_NAP_CAPABILITY_IDLE_TIMEOUT. The RDG client MUST end the protocol when this  |
	//	|                                                            |                                                               | error is received.                                                               |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_OPERATION_ABORTED(0x000003E3)                        | The connection MUST transition to Tunnel Close Pending state. | Returned when the call to TsProxySetupReceivePipe is received after the          |
	//	|                                                            |                                                               | Connection Timer has expired.                                                    |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_BAD_ARGUMENTS(0x000000A0)                            | The connection MUST transition to Tunnel Close Pending state. | Returned when the target server unexpectedly closes the connection between the   |
	//	|                                                            |                                                               | RDG server and the target server.                                                |
	//	+------------------------------------------------------------+---------------------------------------------------------------+----------------------------------------------------------------------------------+
	SetupReceivePipe(context.Context, *SetupReceivePipeRequest) (*SetupReceivePipeResponse, error)

	// The method is used for data transfer from the RDG client to the target server, via
	// the RDG server. The RDG server SHOULD send the buffer data received in this method
	// to the target server. The RPC runtime MUST NOT perform a strict NDR data consistency
	// check for this method. The Remote Desktop Gateway Server Protocol bypasses NDR for
	// this method. The wire data MUST follow the regular RPC specifications as specified
	// in [C706] section 2.1, and [MS-RPCE] minus all NDR headers, trailers, and NDR-specific
	// payload. The RDG server MUST have created the channel to the target server before
	// completing this method call. This method MAY be called multiple times by the RDG
	// client, but only after the previous method call finishes. The RDG server MUST handle
	// multiple sequential invocations of this method call. This method bypasses NDR. For
	// this reason, unlike other RPC methods that return an HRESULT, this method returns
	// a DWORD. This is directly passed to the callee from underlying RPC calls.<48> When
	// this call fails, the RDG server MUST send the final response to TsProxySetupReceivePipe
	// call.
	//
	// Prerequisites: The connection MUST be in Pipe Created state. If this call is made
	// in any other state, ERROR_ONLY_IF_CONNECTED or E_PROXY_TS_CONNECTFAILED is returned.
	//
	// Return Values: The method MUST return ERROR_SUCCESS on success. Other failures MUST
	// be one of the codes listed. The client MAY interpret failures in any way it deems
	// appropriate. See section 2.2.6 for details on these errors.
	//
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                      RETURN                      |                             STATE                              |                                                                                  |
	//	|                      VALUE                       |                           TRANSITION                           |                                   DESCRIPTION                                    |
	//	|                                                  |                                                                |                                                                                  |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_SUCCESS (0x00000000)                       | The connection MUST remain in PipeCreated state.               | Returned when a call to the TsProxySendToServer method succeeds.                 |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ONLY_IF_CONNECTED (0x000004E3)             | The connection MUST transition to Channel Close Pending state. | Returned by the RDG server when an attempt is made by the client to send data    |
	//	|                                                  |                                                                | to the target server on connection state other than Pipe Created state. The RDG  |
	//	|                                                  |                                                                | client MUST end the protocol when this error is returned.                        |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| ERROR_ACCESS_DENIED (0x00000005)                 | The connection MUST transition to Channel Close Pending state. | Returned if the channel context handle passed in the pRpcMessage parameter is    |
	//	|                                                  |                                                                | NULL. The RDG client MUST end the protocol when this error is received.          |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| HRESULT_CODE(E_PROXY_INTERNALERROR) (0x000059D8) | The connection MUST transition to Channel Close Pending state. | Returned when an unexpected error occurs in TsProxySendToServer. The RDG client  |
	//	|                                                  |                                                                | MUST end the protocol when this error is received.                               |
	//	+--------------------------------------------------+----------------------------------------------------------------+----------------------------------------------------------------------------------+
	SendToServer(context.Context, *SendToServerRequest) (*SendToServerResponse, error)
}

TsProxyRpcInterface server interface.

type MakeTunnelCallRequest 

type MakeTunnelCallRequest struct {
	// tunnelContext: The RDG client MUST provide the RDG server with the same context handle
	// it received from the TsProxyCreateTunnel method call. The RDG server SHOULD throw
	// an exception if the RPC validation and verification fail.
	TunnelContext *TunnelNoSerialize `idl:"name:tunnelContext" json:"tunnel_context"`
	// procId: This field identifies the work that is performed by the API. This field can
	// have the following values.
	//
	//	+------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                                |                                                                                  |
	//	|                     VALUE                      |                                     MEANING                                      |
	//	|                                                |                                                                                  |
	//	+------------------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------------------+----------------------------------------------------------------------------------+
	//	| TSG_TUNNEL_CALL_ASYNC_MSG_REQUEST 0x00000001   | Used to request an administrative message when the same is available on the      |
	//	|                                                | server.                                                                          |
	//	+------------------------------------------------+----------------------------------------------------------------------------------+
	//	| TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST 0x00000002 | Used to cancel a pending administrative message request.                         |
	//	+------------------------------------------------+----------------------------------------------------------------------------------+
	ProcID uint32 `idl:"name:procId" json:"proc_id"`
	// TSGPacket: Pointer to the TSG_PACKET structure. The value of the packetId field MUST
	// be set to TSG_PACKET_TYPE_MSGREQUEST_PACKET. The packetMsgRequest field of the TSGPacket
	// union field MUST be a pointer to the TSG_PACKET_MSG_REQUEST structure.
	Packet *Packet `idl:"name:TSGPacket;pointer:ref" json:"packet"`
}

MakeTunnelCallRequest structure represents the TsProxyMakeTunnelCall operation request

func (*MakeTunnelCallRequest) MarshalNDR 

func (o *MakeTunnelCallRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*MakeTunnelCallRequest) UnmarshalNDR 

func (o *MakeTunnelCallRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type MakeTunnelCallResponse 

type MakeTunnelCallResponse struct {
	// TSGPacketResponse: Pointer to the TSG_PACKET structure. If procId is TSG_TUNNEL_CANCEL_ASYNC_MSG_REQUEST
	// or if the return value is HRESULT_FROM_WIN32(RPC_S_CALL_CANCELLED), *TSGPacketResponse
	// MUST be set to NULL. Otherwise, the value of the packetId field MUST be TSG_PACKET_TYPE_MESSAGE_PACKET.
	// The packetMsgResponse field of the TSGPacket union field MUST be a pointer to the
	// TSG_PACKET_MSG_RESPONSE structure.
	PacketResponse *Packet `idl:"name:TSGPacketResponse;pointer:ref" json:"packet_response"`
	// Return: The TsProxyMakeTunnelCall return value.
	Return int32 `idl:"name:Return" json:"return"`
}

MakeTunnelCallResponse structure represents the TsProxyMakeTunnelCall operation response

func (*MakeTunnelCallResponse) MarshalNDR 

func (o *MakeTunnelCallResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*MakeTunnelCallResponse) UnmarshalNDR 

func (o *MakeTunnelCallResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type Packet 

type Packet struct {
	// packetId:  This value specifies the type of structure pointer contained in the TSGPacket
	// field. Valid values are specified in sections 2.2.5.2.2, 2.2.5.2.3, 2.2.5.2.4, 2.2.5.2.5,
	// 2.2.5.2.6, 2.2.5.2.7,  2.2.5.2.9, 2.2.5.2.10, 2.2.5.2.11, 2.2.5.2.12, and 2.2.5.2.13.
	PacketID uint32 `idl:"name:packetId" json:"packet_id"`
	// TSGPacket:  A union field containing the actual structure pointer corresponding to
	// the value contained in the packetId field. Valid structures for this field are specified
	// in sections 2.2.9.2.1.1, 2.2.9.2.1.2, 2.2.9.2.1.3, 2.2.9.2.1.4, 2.2.9.2.1.5, 2.2.9.2.1.6,
	// 2.2.9.2.1.7, 2.2.9.2.1.8, 2.2.9.2.1.9, 2.2.9.2.1.10, and 2.2.9.2.1.11.
	Packet *PacketTypeUnion `idl:"name:TSGPacket;switch_is:packetId" json:"packet"`
}

Packet structure represents TSG_PACKET RPC structure.

The TSG_PACKET structure specifies the type of structure to be used by the RDG client and RDG server.

func (*Packet) MarshalNDR 

func (o *Packet) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Packet) UnmarshalNDR 

func (o *Packet) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketAuth 

type PacketAuth struct {
	// TSGVersionCaps:  A TSG_PACKET_VERSIONCAPS structure as specified in section 2.2.9.2.1.2.
	VersionCaps *PacketVersionCaps `idl:"name:TSGVersionCaps" json:"version_caps"`
	// cookieLen:  An unsigned long that specifies the size in bytes for the field cookie.
	CookieLength uint32 `idl:"name:cookieLen" json:"cookie_length"`
	// cookie:  A byte pointer that points to the cookie data. The cookie is used for authentication.
	Cookie []byte `idl:"name:cookie;size_is:(cookieLen)" json:"cookie"`
}

PacketAuth structure represents TSG_PACKET_AUTH RPC structure.

The TSG_PACKET_AUTH structure is sent by the client to the TS Gateway server when Pluggable Authentication is used. This packet includes TSG_PACKET_VERSIONCAPS, which is used for capability negotiation, and cookie, which is used for user authentication. This MUST be the first packet from the client to the server if the server has Pluggable Authentication turned on. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_AUTH.

func (*PacketAuth) MarshalNDR 

func (o *PacketAuth) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketAuth) UnmarshalNDR 

func (o *PacketAuth) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketCapabilities 

type PacketCapabilities struct {
	// capabilityType:  Indicates the type of NAP capability supported by the RDG client
	// or the RDG server. This member MUST be the following value:
	//
	//	+------------+----------------------------------------------------------------------------+
	//	|            |                                                                            |
	//	|   VALUE    |                                  MEANING                                   |
	//	|            |                                                                            |
	//	+------------+----------------------------------------------------------------------------+
	//	+------------+----------------------------------------------------------------------------+
	//	| 0x00000001 | The RDG server supports NAP capability type (TSG_CAPABILITY_TYPE_NAP).<12> |
	//	+------------+----------------------------------------------------------------------------+
	CapabilityType uint32 `idl:"name:capabilityType" json:"capability_type"`
	// TSGPacket:  Specifies the union containing the actual structure corresponding to
	// the value defined in the capabilityType field. Valid structures are specified in
	// sections 2.2.9.2.1.2.1.1 and 2.2.9.2.1.2.1.2.
	Packet *CapabilitiesUnion `idl:"name:TSGPacket;switch_is:capabilityType" json:"packet"`
}

PacketCapabilities structure represents TSG_PACKET_CAPABILITIES RPC structure.

The TSG_PACKET_CAPABILITIES structure contains information about the capabilities of the RDG client and RDG server.

This structure MUST be embedded in the TSG_PACKET_VERSIONCAPS structure.

func (*PacketCapabilities) MarshalNDR 

func (o *PacketCapabilities) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketCapabilities) UnmarshalNDR 

func (o *PacketCapabilities) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketCapsResponse 

type PacketCapsResponse struct {
	// pktQuarEncResponse:  A TSG_PACKET_QUARENC_RESPONSE structure as specified in section
	// 2.2.9.2.1.6.
	PacketQuarantineEncResponse *PacketQuarantineEncResponse `idl:"name:pktQuarEncResponse" json:"packet_quarantine_enc_response"`
	// pktConsentMessage:  A TSG_PACKET_MSG_RESPONSE structure as specified in section 2.2.9.2.1.9.
	PacketConsentMessage *PacketMessageResponse `idl:"name:pktConsentMessage" json:"packet_consent_message"`
}

PacketCapsResponse structure represents TSG_PACKET_CAPS_RESPONSE RPC structure.

The TSG_PACKET_CAPS_RESPONSE structure contains the response of the RDG server, which supports Consent Signing capability, to the RDG client for the TsProxyCreateTunnel method call. This structure contains TSG_PACKET_QUARENC_RESPONSE followed by the consent signing string. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_CAPS_RESPONSE.

func (*PacketCapsResponse) MarshalNDR 

func (o *PacketCapsResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketCapsResponse) UnmarshalNDR 

func (o *PacketCapsResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketHeader 

type PacketHeader struct {
	// ComponentId:  Represents the component sending the packet. This MUST be the following
	// value:
	//
	//	+--------+----------------------+
	//	|        |                      |
	//	| VALUE  |       MEANING        |
	//	|        |                      |
	//	+--------+----------------------+
	//	+--------+----------------------+
	//	| 0x5452 | TS Gateway Transport |
	//	+--------+----------------------+
	ComponentID uint16 `idl:"name:ComponentId" json:"component_id"`
	// PacketId:  Unused.
	//
	// This structure cannot be used by itself as part of any method call. It can be used
	// only in the context of other structures.
	PacketID uint16 `idl:"name:PacketId" json:"packet_id"`
}

PacketHeader structure represents TSG_PACKET_HEADER RPC structure.

The TSG_PACKET_HEADER structure contains information about the ComponentId and PacketId fields of the TSG_PACKET structure. The value of PacketId in TSG_PACKET MUST be set to TSG_PACKET_TYPE_HEADER.

func (*PacketHeader) MarshalNDR 

func (o *PacketHeader) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketHeader) UnmarshalNDR 

func (o *PacketHeader) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketMessageRequest 

type PacketMessageRequest struct {
	// maxMessagesPerBatch:  An unsigned long that specifies how many messages can be sent
	// by the server at one time.
	MaxMessagesPerBatch uint32 `idl:"name:maxMessagesPerBatch" json:"max_messages_per_batch"`
}

PacketMessageRequest structure represents TSG_PACKET_MSG_REQUEST RPC structure.

The TSG_PACKET_MSG_REQUEST structure contains the request from the client to the RDG server to send across an administrative message whenever there is any. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_MSGREQUEST_PACKET.

func (*PacketMessageRequest) MarshalNDR 

func (o *PacketMessageRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketMessageRequest) UnmarshalNDR 

func (o *PacketMessageRequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketMessageResponse 

type PacketMessageResponse struct {
	// msgID:  This field is unused.<20> This field can be ignored.
	MessageID uint32 `idl:"name:msgID" json:"message_id"`
	// msgType:  An unsigned long specifying what type of message is being sent by the server.
	// This MUST be one of the following values.
	//
	//	+----------------------------------------------+--------------------------------------------------+
	//	|                                              |                                                  |
	//	|                    VALUE                     |                     MEANING                      |
	//	|                                              |                                                  |
	//	+----------------------------------------------+--------------------------------------------------+
	//	+----------------------------------------------+--------------------------------------------------+
	//	| TSG_ASYNC_MESSAGE_CONSENT_MESSAGE 0x00000001 | The server is sending a Consent Signing Message. |
	//	+----------------------------------------------+--------------------------------------------------+
	//	| TSG_ASYNC_MESSAGE_SERVICE_MESSAGE 0x00000002 | The server is sending an Administrative Message. |
	//	+----------------------------------------------+--------------------------------------------------+
	//	| TSG_ASYNC_MESSAGE_REAUTH 0x00000003          | The server expects the client to Reauthenticate. |
	//	+----------------------------------------------+--------------------------------------------------+
	MessageType uint32 `idl:"name:msgType" json:"message_type"`
	// isMsgPresent:  A Boolean that indicates whether the messagePacket parameter is present
	// or not. If the value is TRUE, then messagePacket contains valid data and can be processed.
	// If the value is FALSE, messagePacket parameter MUST be ignored.
	IsMessagePresent int32 `idl:"name:isMsgPresent" json:"is_message_present"`
	// messagePacket:  A TSG_PACKET_TYPE_MESSAGE_UNION union, as specified in section 2.2.9.2.1.9.1.
	MessagePacket *PacketTypeMessageUnion `idl:"name:messagePacket;switch_is:msgType" json:"message_packet"`
}

PacketMessageResponse structure represents TSG_PACKET_MSG_RESPONSE RPC structure.

The TSG_PACKET_MSG_RESPONSE structure contains the response of the RDG server to the client when a message needs to be sent to the client. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_MESSAGE_PACKET.

func (*PacketMessageResponse) MarshalNDR 

func (o *PacketMessageResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketMessageResponse) UnmarshalNDR 

func (o *PacketMessageResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketQuarantineConfigRequest 

type PacketQuarantineConfigRequest struct {
	// flags:  Contains information about quarantine configuration.
	Flags uint32 `idl:"name:flags" json:"flags"`
}

PacketQuarantineConfigRequest structure represents TSG_PACKET_QUARCONFIGREQUEST RPC structure.

The TSG_PACKET_QUARCONFIGREQUEST structure contains information about quarantine configuration. RDG server and RDG client MAY support this structure.<13> If the RDG server or RDG client do not support the TSG_PACKET_QUARCONFIGREQUEST structure, then the error code HRESULT_CODE(E_PROXY_NOTSUPPORTED) is returned.

func (*PacketQuarantineConfigRequest) MarshalNDR 

func (o *PacketQuarantineConfigRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketQuarantineConfigRequest) UnmarshalNDR 

func (o *PacketQuarantineConfigRequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketQuarantineEncResponse 

type PacketQuarantineEncResponse struct {
	// flags:  Unused. MUST be 0.
	Flags uint32 `idl:"name:flags" json:"flags"`
	// certChainLen:  An unsigned long specifying the number of characters in certChainData,
	// including the terminating null character. If the quarantineCapabilities field of
	// the TSG_PACKET_VERSIONCAPS structure is set to 1, this MUST be a nonzero value. This
	// field MUST be ignored if certChainData is ignored. The value MUST be in the range
	// of 0 and 24000; both inclusive.
	CertChainLength uint32 `idl:"name:certChainLen" json:"cert_chain_length"`
	// certChainData:  The certificate, along with the chain, that the RDG server used for
	// the SCHANNEL authentication service as part of registering the RPC interfaces and
	// initialization. It MUST be a string representation of the certificate chain if certChainLen
	// is nonzero.<19> This field can be ignored.
	CertChainData string `idl:"name:certChainData;size_is:(certChainLen);string" json:"cert_chain_data"`
	// nonce:  A GUID to uniquely identify this connection to prevent replay attacks by
	// the RDG client. This can be used for auditing purposes. A GUID is a unique ID using
	// opaque sequence of bytes as specified in [MS-DTYP] section 2.3.4.2.
	Nonce *dtyp.GUID `idl:"name:nonce" json:"nonce"`
	// versionCaps:  A pointer to a TSG_PACKET_VERSIONCAPS structure, as specified in section
	// 2.2.9.2.1.2.
	VersionCaps *PacketVersionCaps `idl:"name:versionCaps" json:"version_caps"`
}

PacketQuarantineEncResponse structure represents TSG_PACKET_QUARENC_RESPONSE RPC structure.

The TSG_PACKET_QUARENC_RESPONSE structure contains the response of the RDG server for the TsProxyCreateTunnel method call. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_QUARENC_RESPONSE.

func (*PacketQuarantineEncResponse) MarshalNDR 

func (o *PacketQuarantineEncResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketQuarantineEncResponse) UnmarshalNDR 

func (o *PacketQuarantineEncResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketQuarantineRequest 

type PacketQuarantineRequest struct {
	// flags:  This field can be any value when sending and ignored on receipt.
	Flags uint32 `idl:"name:flags" json:"flags"`
	// machineName:  A string representing the name of the RDG Client Machine name (section
	// 3.5.1).<15> This field can be ignored. The length of the name, including the terminating
	// null character, MUST be equal to the size specified by the nameLength field.
	MachineName string `idl:"name:machineName;size_is:(nameLength);string" json:"machine_name"`
	// nameLength:  An unsigned long specifying the number of characters in machineName,
	// including the terminating null character. The specified value MUST be in the range
	// from 0 to 513 characters.
	NameLength uint32 `idl:"name:nameLength" json:"name_length"`
	// data:  An array of bytes that specifies the statement of health prepended with nonce,
	// which is obtained in TSG_PACKET_QUARENC_RESPONSE (section 2.2.9.2.1.6) from the RDG
	// server in response to TsProxyCreateTunnel.<16> This field can be ignored. The length
	// of this data is specified by the dataLen field.
	Data []byte `idl:"name:data;size_is:(dataLen);pointer:unique" json:"data"`
	// dataLen:  The length, in bytes, of the data field. This value MUST be in the range
	// between 0 and 8000, both inclusive.
	DataLength uint32 `idl:"name:dataLen" json:"data_length"`
}

PacketQuarantineRequest structure represents TSG_PACKET_QUARREQUEST RPC structure.

The TSG_PACKET_QUARREQUEST structure<14> contains information about the RDG client's statement of health (SoH) and the name of the RDG client machine. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_QUARREQUEST.

func (*PacketQuarantineRequest) MarshalNDR 

func (o *PacketQuarantineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketQuarantineRequest) UnmarshalNDR 

func (o *PacketQuarantineRequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketReauth 

type PacketReauth struct {
	// tunnelContext:  An unsigned __int64 that identifies which tunnel is being reauthenticated.
	TunnelContext uint64 `idl:"name:tunnelContext" json:"tunnel_context"`
	// packetId:  An unsigned long that specifies what type of packet is present inside
	// TSGInitialPacket.
	//
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	|                                        |                                                                                  |
	//	|                 VALUE                  |                                     MEANING                                      |
	//	|                                        |                                                                                  |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TSG_PACKET_TYPE_VERSIONCAPS 0x00005643 | This packet is sent when Pluggable Authentication is off.                        |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TSG_PACKET_TYPE_AUTH 0x00004054        | This packet is sent when Pluggable Authentication is on. This packet             |
	//	|                                        | includes TSG_PACKET_VERSIONCAPS as well as the cookie that is required for       |
	//	|                                        | authentication.                                                                  |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	PacketID uint32 `idl:"name:packetId" json:"packet_id"`
	// TSGInitialPacket:  A TSG_INITIAL_PACKET_TYPE_UNION union as specified in section
	// 2.2.9.2.1.11.1.
	InitialPacket *InitialPacketTypeUnion `idl:"name:TSGInitialPacket;switch_is:packetId" json:"initial_packet"`
}

PacketReauth structure represents TSG_PACKET_REAUTH RPC structure.

The TSG_PACKET_REAUTH structure is sent by the client to the TS Gateway server when the client is reauthenticating the connection. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_REAUTH.

func (*PacketReauth) MarshalNDR 

func (o *PacketReauth) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketReauth) UnmarshalNDR 

func (o *PacketReauth) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketReauthMessage 

type PacketReauthMessage struct {
	// tunnelContext:  A unsigned __int64 that is sent by the server to client. When the
	// client initiates the reauthentication sequence, it MUST include this context. This
	// is used by the server to validate successful reauthentication by the client.
	TunnelContext uint64 `idl:"name:tunnelContext" json:"tunnel_context"`
}

PacketReauthMessage structure represents TSG_PACKET_REAUTH_MESSAGE RPC structure.

The TSG_PACKET_REAUTH_MESSAGE structure is sent by the RDG server to the client when the server requires the user credential to be reauthenticated.

func (*PacketReauthMessage) MarshalNDR 

func (o *PacketReauthMessage) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketReauthMessage) UnmarshalNDR 

func (o *PacketReauthMessage) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketResponse 

type PacketResponse struct {
	// flags:  The RDG server MUST set this value to TSG_PACKET_TYPE_QUARREQUEST to indicate
	// that this structure is in response to the TsProxyAuthorizeTunnel method call. The
	// RDG client MAY ignore this field.
	Flags uint32 `idl:"name:flags" json:"flags"`

	// responseData:  Byte data representing the response from the RDG server for the TsProxyAuthorizeTunnel
	// method call. If the Negotiated Capabilities ADM element contains TSG_NAP_CAPABILITY_QUAR_SOH
	// and TSG_NAP_CAPABILITY_IDLE_TIMEOUT and the value of the dataLen member specified
	// in the TSG_PACKET_QUARREQUEST structure (section 2.2.9.2.1.4) is greater than zero,
	// then responseData MUST contain both the statement of health response (SoHR) and the
	// idle timeout value. If Negotiated Capabilities contains only TSG_NAP_CAPABILITY_QUAR_SOH
	// and the value of the dataLen member specified in the TSG_PACKET_QUARREQUEST structure
	// (section 2.2.9.2.1.4) is greater than zero, then responseData MUST contain only the
	// statement of health response. If Negotiated Capabilities contains only TSG_NAP_CAPABILITY_IDLE_TIMEOUT,
	// then responseData MUST contain only the idle timeout value. The length of the data
	// MUST be equal to that specified by responseDataLen. If Negotiated Capabilities does
	// not contain both TSG_NAP_CAPABILITY_QUAR_SOH and TSG_NAP_CAPABILITY_IDLE_TIMEOUT,
	// then responseData is ignored and responseDataLen is set to zero.<17>
	ResponseData []byte `idl:"name:responseData;size_is:(responseDataLen)" json:"response_data"`
	// responseDataLen:  Length, in bytes, of the data specified by the responseData field.
	ResponseDataLength uint32 `idl:"name:responseDataLen" json:"response_data_length"`
	// redirectionFlags:  A TSG_REDIRECTION_FLAGS structure.<18>
	RedirectionFlags *RedirectionFlags `idl:"name:redirectionFlags" json:"redirection_flags"`
	// contains filtered or unexported fields
}

PacketResponse structure represents TSG_PACKET_RESPONSE RPC structure.

The TSG_PACKET_RESPONSE structure contains the response of the RDG server to the RDG client for the TsProxyAuthorizeTunnel method call. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_RESPONSE.

func (*PacketResponse) MarshalNDR 

func (o *PacketResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketResponse) UnmarshalNDR 

func (o *PacketResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketStringMessage 

type PacketStringMessage struct {
	// isDisplayMandatory:  A Boolean that specifies whether the client needs to display
	// this message.
	IsDisplayMandatory int32 `idl:"name:isDisplayMandatory" json:"is_display_mandatory"`
	// isConsentMandatory:  A Boolean that specifies whether the user needs to give its
	// consent before the connection can proceed.
	IsConsentMandatory int32 `idl:"name:isConsentMandatory" json:"is_consent_mandatory"`
	// msgBytes:  An unsigned long specifying the number of characters in msgBuffer, including
	// the terminating null character. The size of the message SHOULD<21> be determined
	// by the serverCert field in the HTTP_TUNNEL_RESPONSE_OPTIONAL structure (section 2.2.10.21).
	// The consent message is embedded in the HTTP_TUNNEL_RESPONSE as part of the HTTP_TUNNEL_RESPONSE_OPTIONAL
	// structure. When the HTTP_TUNNEL_RESPONSE_FIELD_CONSENT_MSG flag is set in the HTTP_TUNNEL_RESPONSE_FIELDS_PRESENT_FLAGS
	// (section 2.2.5.3.8), the HTTP_TUNNEL_RESPONSE_OPTIONAL data structure contains a
	// consent message in the HTTP_UNICODE_STRING format (section 2.2.10.22).
	MessageBytes uint32 `idl:"name:msgBytes" json:"message_bytes"`
	// msgBuffer:  An array of wchar_t specifying the string. The size of the buffer is
	// as indicated by msgBytes.
	MessageBuffer string `idl:"name:msgBuffer;size_is:(msgBytes)" json:"message_buffer"`
}

PacketStringMessage structure represents TSG_PACKET_STRING_MESSAGE RPC structure.

The TSG_PACKET_STRING_MESSAGE structure contains either the Consent Signing Message or the Administrative Message that is being sent from the RDG server to the client.

func (*PacketStringMessage) MarshalNDR 

func (o *PacketStringMessage) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketStringMessage) UnmarshalNDR 

func (o *PacketStringMessage) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeMessageUnion 

type PacketTypeMessageUnion struct {
	// Types that are assignable to Value
	//
	// *PacketTypeMessageUnion_ConsentMessage
	// *PacketTypeMessageUnion_ServiceMessage
	// *PacketTypeMessageUnion_ReauthMessage
	Value is_PacketTypeMessageUnion `json:"value"`
}

PacketTypeMessageUnion structure represents TSG_PACKET_TYPE_MESSAGE_UNION RPC union.

func (*PacketTypeMessageUnion) GetValue 

func (o *PacketTypeMessageUnion) GetValue() any

func (*PacketTypeMessageUnion) MarshalUnionNDR 

func (o *PacketTypeMessageUnion) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw uint32) error

func (*PacketTypeMessageUnion) NDRSwitchValue 

func (o *PacketTypeMessageUnion) NDRSwitchValue(sw uint32) uint32

func (*PacketTypeMessageUnion) UnmarshalUnionNDR 

func (o *PacketTypeMessageUnion) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw uint32) error

type PacketTypeMessageUnion_ConsentMessage 

type PacketTypeMessageUnion_ConsentMessage struct {
	ConsentMessage *PacketStringMessage `idl:"name:consentMessage" json:"consent_message"`
}

PacketTypeMessageUnion_ConsentMessage structure represents TSG_PACKET_TYPE_MESSAGE_UNION RPC union arm.

It has following labels: 1

func (*PacketTypeMessageUnion_ConsentMessage) MarshalNDR 

func (o *PacketTypeMessageUnion_ConsentMessage) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeMessageUnion_ConsentMessage) UnmarshalNDR 

func (o *PacketTypeMessageUnion_ConsentMessage) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeMessageUnion_ReauthMessage 

type PacketTypeMessageUnion_ReauthMessage struct {
	ReauthMessage *PacketReauthMessage `idl:"name:reauthMessage" json:"reauth_message"`
}

PacketTypeMessageUnion_ReauthMessage structure represents TSG_PACKET_TYPE_MESSAGE_UNION RPC union arm.

It has following labels: 3

func (*PacketTypeMessageUnion_ReauthMessage) MarshalNDR 

func (o *PacketTypeMessageUnion_ReauthMessage) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeMessageUnion_ReauthMessage) UnmarshalNDR 

func (o *PacketTypeMessageUnion_ReauthMessage) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeMessageUnion_ServiceMessage 

type PacketTypeMessageUnion_ServiceMessage struct {
	ServiceMessage *PacketStringMessage `idl:"name:serviceMessage" json:"service_message"`
}

PacketTypeMessageUnion_ServiceMessage structure represents TSG_PACKET_TYPE_MESSAGE_UNION RPC union arm.

It has following labels: 2

func (*PacketTypeMessageUnion_ServiceMessage) MarshalNDR 

func (o *PacketTypeMessageUnion_ServiceMessage) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeMessageUnion_ServiceMessage) UnmarshalNDR 

func (o *PacketTypeMessageUnion_ServiceMessage) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion 

type PacketTypeUnion struct {
	// Types that are assignable to Value
	//
	// *PacketTypeUnion_PacketHeader
	// *PacketTypeUnion_PacketVersionCaps
	// *PacketTypeUnion_PacketQuarantineConfigRequest
	// *PacketTypeUnion_PacketQuarantineRequest
	// *PacketTypeUnion_PacketResponse
	// *PacketTypeUnion_PacketQuarantineEncResponse
	// *PacketTypeUnion_PacketCapsResponse
	// *PacketTypeUnion_PacketMessageRequest
	// *PacketTypeUnion_PacketMessageResponse
	// *PacketTypeUnion_PacketAuth
	// *PacketTypeUnion_PacketReauth
	Value is_PacketTypeUnion `json:"value"`
}

PacketTypeUnion structure represents TSG_PACKET_TYPE_UNION RPC union.

The TSG_PACKET_TYPE_UNION union specifies an RPC switch_type union of structures as follows.

func (*PacketTypeUnion) GetValue 

func (o *PacketTypeUnion) GetValue() any

func (*PacketTypeUnion) MarshalUnionNDR 

func (o *PacketTypeUnion) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw uint32) error

func (*PacketTypeUnion) NDRSwitchValue 

func (o *PacketTypeUnion) NDRSwitchValue(sw uint32) uint32

func (*PacketTypeUnion) UnmarshalUnionNDR 

func (o *PacketTypeUnion) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw uint32) error

type PacketTypeUnion_PacketAuth 

type PacketTypeUnion_PacketAuth struct {
	// packetAuth:  A PTSG_PACKET_AUTH as specified in section 2.2.9.2.1.10.
	PacketAuth *PacketAuth `idl:"name:packetAuth" json:"packet_auth"`
}

PacketTypeUnion_PacketAuth structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 16468

func (*PacketTypeUnion_PacketAuth) MarshalNDR 

func (o *PacketTypeUnion_PacketAuth) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketAuth) UnmarshalNDR 

func (o *PacketTypeUnion_PacketAuth) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketCapsResponse 

type PacketTypeUnion_PacketCapsResponse struct {
	// packetCapsResponse:  A PTSG_PACKET_CAPS_RESPONSE as specified in section 2.2.9.2.1.7.
	PacketCapsResponse *PacketCapsResponse `idl:"name:packetCapsResponse" json:"packet_caps_response"`
}

PacketTypeUnion_PacketCapsResponse structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 17232

func (*PacketTypeUnion_PacketCapsResponse) MarshalNDR 

func (o *PacketTypeUnion_PacketCapsResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketCapsResponse) UnmarshalNDR 

func (o *PacketTypeUnion_PacketCapsResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketHeader 

type PacketTypeUnion_PacketHeader struct {
	// packetHeader:  A PTSG_PACKET_HEADER as specified in section 2.2.9.2.1.1.
	PacketHeader *PacketHeader `idl:"name:packetHeader" json:"packet_header"`
}

PacketTypeUnion_PacketHeader structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 18500

func (*PacketTypeUnion_PacketHeader) MarshalNDR 

func (o *PacketTypeUnion_PacketHeader) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketHeader) UnmarshalNDR 

func (o *PacketTypeUnion_PacketHeader) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketMessageRequest 

type PacketTypeUnion_PacketMessageRequest struct {
	// packetMsgRequest:  A PTSG_PACKET_MSG_REQUEST as specified in section 2.2.9.2.1.8.
	PacketMessageRequest *PacketMessageRequest `idl:"name:packetMsgRequest" json:"packet_message_request"`
}

PacketTypeUnion_PacketMessageRequest structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 18258

func (*PacketTypeUnion_PacketMessageRequest) MarshalNDR 

func (o *PacketTypeUnion_PacketMessageRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketMessageRequest) UnmarshalNDR 

func (o *PacketTypeUnion_PacketMessageRequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketMessageResponse 

type PacketTypeUnion_PacketMessageResponse struct {
	// packetMsgResponse:  A PTSG_PACKET_MSG_RESPONSE as specified in section 2.2.9.2.1.9.
	PacketMessageResponse *PacketMessageResponse `idl:"name:packetMsgResponse" json:"packet_message_response"`
}

PacketTypeUnion_PacketMessageResponse structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 18256

func (*PacketTypeUnion_PacketMessageResponse) MarshalNDR 

func (o *PacketTypeUnion_PacketMessageResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketMessageResponse) UnmarshalNDR 

func (o *PacketTypeUnion_PacketMessageResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketQuarantineConfigRequest 

type PacketTypeUnion_PacketQuarantineConfigRequest struct {
	// packetQuarConfigRequest:  A PTSG_PACKET_QUARCONFIGREQUEST as specified in section
	// 2.2.9.2.1.3.
	PacketQuarantineConfigRequest *PacketQuarantineConfigRequest `idl:"name:packetQuarConfigRequest" json:"packet_quarantine_config_request"`
}

PacketTypeUnion_PacketQuarantineConfigRequest structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 20803

func (*PacketTypeUnion_PacketQuarantineConfigRequest) MarshalNDR 

func (o *PacketTypeUnion_PacketQuarantineConfigRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketQuarantineConfigRequest) UnmarshalNDR 

func (o *PacketTypeUnion_PacketQuarantineConfigRequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketQuarantineEncResponse 

type PacketTypeUnion_PacketQuarantineEncResponse struct {
	// packetQuarEncResponse:  A PTSG_PACKET_QUARENC_RESPONSE as specified in section 2.2.9.2.1.6.
	PacketQuarantineEncResponse *PacketQuarantineEncResponse `idl:"name:packetQuarEncResponse" json:"packet_quarantine_enc_response"`
}

PacketTypeUnion_PacketQuarantineEncResponse structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 17746

func (*PacketTypeUnion_PacketQuarantineEncResponse) MarshalNDR 

func (o *PacketTypeUnion_PacketQuarantineEncResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketQuarantineEncResponse) UnmarshalNDR 

func (o *PacketTypeUnion_PacketQuarantineEncResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketQuarantineRequest 

type PacketTypeUnion_PacketQuarantineRequest struct {
	// packetQuarRequest:  A PTSG_PACKET_QUARREQUEST as specified in section 2.2.9.2.1.4.
	PacketQuarantineRequest *PacketQuarantineRequest `idl:"name:packetQuarRequest" json:"packet_quarantine_request"`
}

PacketTypeUnion_PacketQuarantineRequest structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 20818

func (*PacketTypeUnion_PacketQuarantineRequest) MarshalNDR 

func (o *PacketTypeUnion_PacketQuarantineRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketQuarantineRequest) UnmarshalNDR 

func (o *PacketTypeUnion_PacketQuarantineRequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketReauth 

type PacketTypeUnion_PacketReauth struct {
	// packetReauth:  A PTSG_PACKET_REAUTH as specified in section 2.2.9.2.1.11.
	PacketReauth *PacketReauth `idl:"name:packetReauth" json:"packet_reauth"`
}

PacketTypeUnion_PacketReauth structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 21072

func (*PacketTypeUnion_PacketReauth) MarshalNDR 

func (o *PacketTypeUnion_PacketReauth) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketReauth) UnmarshalNDR 

func (o *PacketTypeUnion_PacketReauth) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketResponse 

type PacketTypeUnion_PacketResponse struct {
	// packetResponse:  A PTSG_PACKET_RESPONSE as specified in section 2.2.9.2.1.5.
	PacketResponse *PacketResponse `idl:"name:packetResponse" json:"packet_response"`
}

PacketTypeUnion_PacketResponse structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 20562

func (*PacketTypeUnion_PacketResponse) MarshalNDR 

func (o *PacketTypeUnion_PacketResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketResponse) UnmarshalNDR 

func (o *PacketTypeUnion_PacketResponse) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketTypeUnion_PacketVersionCaps 

type PacketTypeUnion_PacketVersionCaps struct {
	// packetVersionCaps:  A PTSG_PACKET_VERSIONCAPS as specified in section 2.2.9.2.1.2.
	PacketVersionCaps *PacketVersionCaps `idl:"name:packetVersionCaps" json:"packet_version_caps"`
}

PacketTypeUnion_PacketVersionCaps structure represents TSG_PACKET_TYPE_UNION RPC union arm.

It has following labels: 22083

func (*PacketTypeUnion_PacketVersionCaps) MarshalNDR 

func (o *PacketTypeUnion_PacketVersionCaps) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketTypeUnion_PacketVersionCaps) UnmarshalNDR 

func (o *PacketTypeUnion_PacketVersionCaps) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PacketVersionCaps 

type PacketVersionCaps struct {
	// tsgHeader:  Specified in 2.2.9.2.1.1.
	Header *PacketHeader `idl:"name:tsgHeader" json:"header"`
	// TSGCaps:  An array of TSG_PACKET_CAPABILITIES structures. The number of elements
	// in the array is indicated by the numCapabilities field.
	Caps []*PacketCapabilities `idl:"name:TSGCaps;size_is:(numCapabilities)" json:"caps"`
	// numCapabilities:  The number of array elements for the TSGCaps field. This value
	// MUST be in the range of 0 and 32. If the TSGCaps field is ignored, then this field
	// MUST also be ignored.
	CapabilitiesLength uint32 `idl:"name:numCapabilities" json:"capabilities_length"`
	// majorVersion:  Indicates the major version of the RDG client or RDG server, depending
	// on the sender. This MUST be the following value:
	//
	//	+--------+-------------------------------------------------------------------------+
	//	|        |                                                                         |
	//	| VALUE  |                                 MEANING                                 |
	//	|        |                                                                         |
	//	+--------+-------------------------------------------------------------------------+
	//	+--------+-------------------------------------------------------------------------+
	//	| 0x0001 | Current major version of the Terminal Services Gateway Server Protocol. |
	//	+--------+-------------------------------------------------------------------------+
	MajorVersion uint16 `idl:"name:majorVersion" json:"major_version"`
	// minorVersion:  Indicates the minor version of the RDG client or RDG server, depending
	// on the sender. This MUST be the following value.
	//
	//	+--------+-------------------------------------------------------------------------+
	//	|        |                                                                         |
	//	| VALUE  |                                 MEANING                                 |
	//	|        |                                                                         |
	//	+--------+-------------------------------------------------------------------------+
	//	+--------+-------------------------------------------------------------------------+
	//	| 0x0001 | Current minor version of the Terminal Services Gateway Server Protocol. |
	//	+--------+-------------------------------------------------------------------------+
	MinorVersion uint16 `idl:"name:minorVersion" json:"minor_version"`
	// quarantineCapabilities:  Indicates quarantine capabilities of the RDG client and
	// RDG server, depending on the sender. This MAY be the following value:<11>
	//
	//	+--------+---------------------------------------------------------+
	//	|        |                                                         |
	//	| VALUE  |                         MEANING                         |
	//	|        |                                                         |
	//	+--------+---------------------------------------------------------+
	//	+--------+---------------------------------------------------------+
	//	| 0x0001 | Quarantine is supported and required by the RDG server. |
	//	+--------+---------------------------------------------------------+
	QuarantineCapabilities uint16 `idl:"name:quarantineCapabilities" json:"quarantine_capabilities"`
}

PacketVersionCaps structure represents TSG_PACKET_VERSIONCAPS RPC structure.

The TSG_PACKET_VERSIONCAPS structure is used for version and capabilities negotiation. The value of the packetId field in TSG_PACKET MUST be set to TSG_PACKET_TYPE_VERSIONCAPS.

This structure MUST be embedded in the TSG_PACKET_QUARENC_RESPONSE.

func (*PacketVersionCaps) MarshalNDR 

func (o *PacketVersionCaps) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PacketVersionCaps) UnmarshalNDR 

func (o *PacketVersionCaps) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type RedirectionFlags 

type RedirectionFlags struct {
	// enableAllRedirections:  A Boolean value indicating whether the RDG server specifies
	// any control over the device redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | Device redirection is not enabled for all devices. Other fields of this          |
	//	|                  | structure specify which device redirection is enabled or disabled.               |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | Device redirection is enabled for all devices. All other fields of this          |
	//	|                  | structure MUST be ignored.                                                       |
	//	+------------------+----------------------------------------------------------------------------------+
	EnableAllRedirections bool `idl:"name:enableAllRedirections" json:"enable_all_redirections"`
	// disableAllRedirections:  A Boolean value indicating whether the RDG server specifies
	// any control over disabling all device redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | Device redirection is not disabled for all devices. Other fields of this         |
	//	|                  | structure specify which device redirection is enabled or disabled.               |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | Device redirection is disabled for all devices. All other fields of this         |
	//	|                  | structure MUST be ignored.                                                       |
	//	+------------------+----------------------------------------------------------------------------------+
	DisableAllRedirections bool `idl:"name:disableAllRedirections" json:"disable_all_redirections"`
	// driveRedirectionDisabled:  A Boolean value indicating whether the RDG server specifies
	// any control over disabling drive redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | The RDG client is allowed to choose its own redirection settings for enabling or |
	//	|                  | disabling drive redirection.                                                     |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | Drive redirection is disabled.                                                   |
	//	+------------------+----------------------------------------------------------------------------------+
	DriveRedirectionDisabled bool `idl:"name:driveRedirectionDisabled" json:"drive_redirection_disabled"`
	// printerRedirectionDisabled:  A Boolean value indicating whether the RDG server specifies
	// any control over disabling printer redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | The RDG client is allowed to choose its own redirection settings for enabling or |
	//	|                  | disabling printer redirection.                                                   |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | Printer redirection is disabled.                                                 |
	//	+------------------+----------------------------------------------------------------------------------+
	PrinterRedirectionDisabled bool `idl:"name:printerRedirectionDisabled" json:"printer_redirection_disabled"`
	// portRedirectionDisabled:  A Boolean value indicating whether the RDG server specifies
	// any control over disabling port redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | The RDG client is allowed to choose its own redirection settings for enabling    |
	//	|                  | or disabling port redirection. Port redirection applies to both serial (COM) and |
	//	|                  | parallel ports (LPT).                                                            |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | Port redirection is disabled.                                                    |
	//	+------------------+----------------------------------------------------------------------------------+
	PortRedirectionDisabled bool `idl:"name:portRedirectionDisabled" json:"port_redirection_disabled"`

	// clipboardRedirectionDisabled:  A Boolean value indicating whether the RDG server
	// specifies any control over disabling clipboard redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | The RDG client is allowed to choose its own redirection settings for enabling or |
	//	|                  | disabling clipboard redirection.                                                 |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | Clipboard redirection is disabled.                                               |
	//	+------------------+----------------------------------------------------------------------------------+
	ClipboardRedirectionDisabled bool `idl:"name:clipboardRedirectionDisabled" json:"clipboard_redirection_disabled"`
	// pnpRedirectionDisabled:  A Boolean value indicating whether the RDG server specifies
	// any control over disabling Plug and Play redirection on the RDG client.
	//
	//	+------------------+----------------------------------------------------------------------------------+
	//	|                  |                                                                                  |
	//	|      VALUE       |                                     MEANING                                      |
	//	|                  |                                                                                  |
	//	+------------------+----------------------------------------------------------------------------------+
	//	+------------------+----------------------------------------------------------------------------------+
	//	| FALSE 0x00000000 | The RDG client is allowed to choose its own redirection settings for enabling or |
	//	|                  | disabling PnP redirection.                                                       |
	//	+------------------+----------------------------------------------------------------------------------+
	//	| TRUE 0x00000001  | PnP redirection is disabled.                                                     |
	//	+------------------+----------------------------------------------------------------------------------+
	PnPRedirectionDisabled bool `idl:"name:pnpRedirectionDisabled" json:"pnp_redirection_disabled"`
	// contains filtered or unexported fields
}

RedirectionFlags structure represents TSG_REDIRECTION_FLAGS RPC structure.

The TSG_REDIRECTION_FLAGS structure specifies the device redirection settings that MUST be enforced by the RDG client. For details about device redirection, see  [MS-RDSOD] section 2.1.1.2.

This structure MUST be embedded in the TSG_PACKET_RESPONSE structure.

Note Both enableAllRedirections and disableAllRedirections MUST NOT be TRUE.

func (*RedirectionFlags) MarshalNDR 

func (o *RedirectionFlags) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RedirectionFlags) UnmarshalNDR 

func (o *RedirectionFlags) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SendToServerRequest 

type SendToServerRequest struct {
	// pRpcMessage: The protocol data between RDG client and RDG server MUST be decoded
	// as specified in section 2.2.9.3. RPC stub information is specified in [MS-RPCE] sections
	// 1.1 and 1.5.
	Message []byte `idl:"name:pRpcMessage;max_is:(32767)" json:"message"`
}

SendToServerRequest structure represents the TsProxySendToServer operation request

func (*SendToServerRequest) MarshalNDR 

func (o *SendToServerRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SendToServerRequest) UnmarshalNDR 

func (o *SendToServerRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type SendToServerResponse 

type SendToServerResponse struct {
	// Return: The TsProxySendToServer return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

SendToServerResponse structure represents the TsProxySendToServer operation response

func (*SendToServerResponse) MarshalNDR 

func (o *SendToServerResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SendToServerResponse) UnmarshalNDR 

func (o *SendToServerResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type SetupReceivePipeRequest 

type SetupReceivePipeRequest struct {
	// pRpcMessage: The protocol data between RDG client and RDG server MUST be decoded
	// as specified in section 2.2.9.4. RPC stub information is specified in [MS-RPCE] sections
	// 1.1 and 1.5.
	Message []byte `idl:"name:pRpcMessage;max_is:(32767)" json:"message"`
}

SetupReceivePipeRequest structure represents the TsProxySetupReceivePipe operation request

func (*SetupReceivePipeRequest) MarshalNDR 

func (o *SetupReceivePipeRequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SetupReceivePipeRequest) UnmarshalNDR 

func (o *SetupReceivePipeRequest) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type SetupReceivePipeResponse 

type SetupReceivePipeResponse struct {
	// Return: The TsProxySetupReceivePipe return value.
	Return uint32 `idl:"name:Return" json:"return"`
}

SetupReceivePipeResponse structure represents the TsProxySetupReceivePipe operation response

func (*SetupReceivePipeResponse) MarshalNDR 

func (o *SetupReceivePipeResponse) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SetupReceivePipeResponse) UnmarshalNDR 

func (o *SetupReceivePipeResponse) UnmarshalNDR(ctx context.Context, r ndr.Reader) error

type TunnelNoSerialize 

type TunnelNoSerialize dcetypes.ContextHandle

TunnelNoSerialize structure represents PTUNNEL_CONTEXT_HANDLE_NOSERIALIZE RPC structure.

func (*TunnelNoSerialize) ContextHandle 

func (o *TunnelNoSerialize) ContextHandle() *dcetypes.ContextHandle

func (*TunnelNoSerialize) MarshalNDR 

func (o *TunnelNoSerialize) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TunnelNoSerialize) UnmarshalNDR 

func (o *TunnelNoSerialize) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TunnelSerialize 

type TunnelSerialize dcetypes.ContextHandle

TunnelSerialize structure represents PTUNNEL_CONTEXT_HANDLE_SERIALIZE RPC structure.

func (*TunnelSerialize) ContextHandle 

func (o *TunnelSerialize) ContextHandle() *dcetypes.ContextHandle

func (*TunnelSerialize) MarshalNDR 

func (o *TunnelSerialize) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TunnelSerialize) UnmarshalNDR 

func (o *TunnelSerialize) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.