path: root/librpc/idl/dcerpc.idl

#include "idl_types.h"

/*
  the base dcerpc packet definitions - not traditionally coded as IDL,
  but given that pidl can handle it nicely it simplifies things a lot
  to do it this way

  See [C706 - DCE 1.1: Remote Procedure Call] for the OpenGroup
  DCERPC specification:
  http://pubs.opengroup.org/onlinepubs/9629399/toc.htm

  See C706 - Chapter 12: RPC PDU Encodings for packet layouts:
  http://www.opengroup.org/onlinepubs/9629399/chap12.htm

  See also [MS-RPCE] for the Microsoft
  "Remote Procedure Call Protocol Extensions".
  http://msdn.microsoft.com/en-us/library/cc243560.aspx

*/
import "misc.idl";

cpp_quote("extern const uint8_t DCERPC_SEC_VT_MAGIC[8];")

[
  helper("../librpc/ndr/ndr_dcerpc.h")
]
interface dcerpc
{
	typedef struct {
		uint16 context_id;
		uint8 num_transfer_syntaxes;
		ndr_syntax_id abstract_syntax;
		ndr_syntax_id transfer_syntaxes[num_transfer_syntaxes];
	} dcerpc_ctx_list;

	typedef [public] struct {
		uint16 max_xmit_frag;
		uint16 max_recv_frag;
		uint32 assoc_group_id;
		uint8  num_contexts;
		dcerpc_ctx_list ctx_list[num_contexts];
		[flag(NDR_REMAINING)] DATA_BLOB auth_info;
	} dcerpc_bind;

	const uint8 DCERPC_REQUEST_LENGTH = 24;

	typedef struct {
	} dcerpc_empty;

	typedef [nodiscriminant] union {
		[case(LIBNDR_FLAG_OBJECT_PRESENT)] GUID object;
		[default] dcerpc_empty empty;
	} dcerpc_object;

	typedef struct {
		uint32 alloc_hint;
		uint16 context_id;
		uint16 opnum;
		/*
		 * NDR_DCERPC_REQUEST_OBJECT_PRESENT
		 * is defined differently for ndr_dcerpc.c and py_dcerpc.c
		 */
		[switch_is(NDR_DCERPC_REQUEST_OBJECT_PRESENT)] dcerpc_object object;
		[flag(NDR_REMAINING)] DATA_BLOB stub_and_verifier;
	} dcerpc_request;

	typedef [enum16bit] enum {
		DCERPC_BIND_ACK_RESULT_ACCEPTANCE          = 0,
		DCERPC_BIND_ACK_RESULT_USER_REJECTION      = 1,
		DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION  = 2,
		DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK       = 3
	} dcerpc_bind_ack_result;

	const int DCERPC_BIND_PROVIDER_REJECT =
		DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION;

	typedef [enum16bit] enum {
		DCERPC_BIND_ACK_REASON_NOT_SPECIFIED                   = 0,
		DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED   = 1,
		DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED = 2,
		DCERPC_BIND_ACK_REASON_LOCAL_LIMIT_EXCEEDED            = 3
	} dcerpc_bind_ack_reason_values;

	const int DCERPC_BIND_REASON_ASYNTAX =
		DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED;

	typedef [bitmap16bit] bitmap {
		DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING = 0x0001,
		DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN     = 0x0002
	} dcerpc_bind_time_features;

	typedef [nodiscriminant] union {
		[case(DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)]
			dcerpc_bind_time_features negotiate;
		[default] dcerpc_bind_ack_reason_values value;
	} dcerpc_bind_ack_reason;

	typedef struct {
		dcerpc_bind_ack_result result;
		[switch_is(result)] dcerpc_bind_ack_reason reason;
		ndr_syntax_id syntax;
	} dcerpc_ack_ctx;

	typedef struct {
		uint16 max_xmit_frag;
		uint16 max_recv_frag;
		uint32 assoc_group_id;
		[value(strlen_m_term_null(secondary_address))] uint16 secondary_address_size;
		[charset(DOS)] uint8 secondary_address[secondary_address_size];
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
		uint8 num_results;
		dcerpc_ack_ctx ctx_list[num_results];
		[flag(NDR_REMAINING)] DATA_BLOB auth_info;
	} dcerpc_bind_ack;

	typedef [public,enum16bit] enum {
		DCERPC_BIND_NAK_REASON_NOT_SPECIFIED                  = 0,
		DCERPC_BIND_NAK_REASON_TEMPORARY_CONGESTION           = 1,
		DCERPC_BIND_NAK_REASON_LOCAL_LIMIT_EXCEEDED           = 2,
		DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED = 4,
		DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE              = 8,
		DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM               = 9
	} dcerpc_bind_nak_reason;

	const int DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED =
		DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED;
	const int DCERPC_BIND_REASON_INVALID_AUTH_TYPE =
		DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE;

	typedef [public] struct {
		uint8 rpc_vers;         /* RPC version */
		uint8 rpc_vers_minor;   /* Minor version */
	} dcerpc_bind_nak_version;

	typedef [public,nopull] struct {
		dcerpc_bind_nak_reason reject_reason;
		uint8 num_versions;
		dcerpc_bind_nak_version versions[num_versions];
		[flag(NDR_REMAINING)] DATA_BLOB _pad;
	} dcerpc_bind_nak;

	const uint8 DCERPC_RESPONSE_LENGTH = 24;

	typedef struct {
		uint32 alloc_hint;
		uint16 context_id;
		uint8 cancel_count;
		[value(0)] uint8 reserved;
		[flag(NDR_REMAINING)] DATA_BLOB stub_and_verifier;
	} dcerpc_response;

	typedef [v1_enum] enum {
		DCERPC_NCA_S_COMM_FAILURE		= 0x1C010001,
		DCERPC_NCA_S_OP_RNG_ERROR		= 0x1C010002,
		DCERPC_NCA_S_UNKNOWN_IF			= 0x1C010003,
		DCERPC_NCA_S_WRONG_BOOT_TIME		= 0x1C010006,
		DCERPC_NCA_S_YOU_CRASHED		= 0x1C010009,
		DCERPC_NCA_S_PROTO_ERROR		= 0x1C01000B,
		DCERPC_NCA_S_OUT_ARGS_TOO_BIG		= 0x1C010013,
		DCERPC_NCA_S_SERVER_TOO_BUSY		= 0x1C010014,
		DCERPC_NCA_S_FAULT_STRING_TOO_LARGE	= 0x1C010015,
		DCERPC_NCA_S_UNSUPPORTED_TYPE		= 0x1C010017,
		DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO	= 0x1C000001,
		DCERPC_NCA_S_FAULT_ADDR_ERROR		= 0x1C000002,
		DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO	= 0x1C000003,
		DCERPC_NCA_S_FAULT_FP_UNDERFLOW		= 0x1C000004,
		DCERPC_NCA_S_FAULT_FP_OVERRFLOW		= 0x1C000005,
		DCERPC_NCA_S_FAULT_INVALID_TAG		= 0x1C000006,
		DCERPC_NCA_S_FAULT_INVALID_BOUND	= 0x1C000007,
		DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH	= 0x1C000008,
		DCERPC_NCA_S_FAULT_UNSPEC_REJECT	= 0x1C000009,
		DCERPC_NCA_S_FAULT_BAD_ACTID		= 0x1C00000A,
		DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED	= 0x1C00000B,
		DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED	= 0x1C00000C,
		DCERPC_NCA_S_FAULT_CANCEL		= 0x1C00000D,
		DCERPC_NCA_S_FAULT_ILL_INST		= 0x1C00000E,
		DCERPC_NCA_S_FAULT_FP_ERROR		= 0x1C00000F,
		DCERPC_NCA_S_FAULT_INT_OVERFLOW		= 0x1C000010,
		DCERPC_NCA_S_UNUSED_1C000011		= 0x1C000011,
		DCERPC_NCA_S_FAULT_UNSPEC		= 0x1C000012,
		DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE	= 0x1C000013,
		DCERPC_NCA_S_FAULT_PIPE_EMPTY		= 0x1C000014,
		DCERPC_NCA_S_FAULT_PIPE_CLOSED		= 0x1C000015,
		DCERPC_NCA_S_FAULT_PIPE_ORDER		= 0x1C000016,
		DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE	= 0x1C000017,
		DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR	= 0x1C000018,
		DCERPC_NCA_S_FAULT_PIPE_MEMORY		= 0x1C000019,
		DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH	= 0x1C00001A,
		DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY	= 0x1C00001B,
		DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID	= 0x1C00001C,
		DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL	= 0x1C00001D,
		DCERPC_NCA_S_UNUSED_1C00001E		= 0x1C00001E,
		DCERPC_NCA_S_INVALID_CHECKSUM		= 0x1C00001F,
		DCERPC_NCA_S_INVALID_CRC		= 0x1C000020,
		DCERPC_NCA_S_FAULT_USER_DEFINED		= 0x1C000021,
		DCERPC_NCA_S_FAULT_TX_OPEN_FAILED	= 0x1C000022,
		DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR	= 0x1C000023,
		DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND	= 0x1C000024,
		DCERPC_NCA_S_FAULT_NO_CLIENT_STUB	= 0x1C000025,
		DCERPC_FAULT_ACCESS_DENIED		= 0x00000005,
		DCERPC_FAULT_SERVER_UNAVAILABLE		= 0x000006ba,
		DCERPC_FAULT_NO_CALL_ACTIVE		= 0x000006bd,
		DCERPC_FAULT_CANT_PERFORM		= 0x000006d8,
		DCERPC_FAULT_OUT_OF_RESOURCES		= 0x000006d9,
		DCERPC_FAULT_BAD_STUB_DATA		= 0x000006f7,
		DCERPC_FAULT_SEC_PKG_ERROR		= 0x00000721
	} dcerpc_nca_status;

	const int DCERPC_FAULT_OP_RNG_ERROR       = DCERPC_NCA_S_OP_RNG_ERROR;
	const int DCERPC_FAULT_NDR                = DCERPC_FAULT_BAD_STUB_DATA;
	const int DCERPC_FAULT_INVALID_TAG        = DCERPC_NCA_S_FAULT_INVALID_TAG;
	const int DCERPC_FAULT_CONTEXT_MISMATCH   = DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH;
	const int DCERPC_FAULT_OTHER              = 0x00000001;

	/* we return this fault when we haven't yet run the test
	   to see what fault w2k3 returns in this case */
	const int DCERPC_FAULT_TODO         = 0x00000042;

	typedef [bitmap8bit] bitmap {
		DCERPC_FAULT_FLAG_EXTENDED_ERROR_INFORMATION = 0x01
	} dcerpc_fault_flags;

	typedef struct {
		uint32 alloc_hint;
		uint16 context_id;
		uint8 cancel_count;
		dcerpc_fault_flags flags;
		dcerpc_nca_status status;
		[value(0)] uint32 reserved;
		[flag(NDR_REMAINING)] DATA_BLOB error_and_verifier;
	} dcerpc_fault;

	const uint8 DCERPC_FAULT_LENGTH = 32;

	/* the auth types we know about */
	typedef [enum8bit] enum {
		DCERPC_AUTH_TYPE_NONE     = 0,
		/* this seems to be not krb5! */
		DCERPC_AUTH_TYPE_KRB5_1   = 1,
		DCERPC_AUTH_TYPE_SPNEGO   = 9,
		DCERPC_AUTH_TYPE_NTLMSSP  = 10,
		DCERPC_AUTH_TYPE_KRB5     = 16,
		DCERPC_AUTH_TYPE_DPA      = 17,
		DCERPC_AUTH_TYPE_MSN      = 18,
		DCERPC_AUTH_TYPE_DIGEST   = 21,
		DCERPC_AUTH_TYPE_SCHANNEL = 68,
		DCERPC_AUTH_TYPE_MSMQ     = 100,
		DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM = 200
	} dcerpc_AuthType;
	const char *AS_SYSTEM_MAGIC_PATH_TOKEN = "/root/ncalrpc_as_system";

	typedef [enum8bit] enum {
		DCERPC_AUTH_LEVEL_NONE      = 1,
		DCERPC_AUTH_LEVEL_CONNECT   = 2,
		DCERPC_AUTH_LEVEL_CALL      = 3,
		DCERPC_AUTH_LEVEL_PACKET    = 4,
		DCERPC_AUTH_LEVEL_INTEGRITY = 5,
		DCERPC_AUTH_LEVEL_PRIVACY   = 6
	} dcerpc_AuthLevel;

	typedef [public] struct {
		dcerpc_AuthType auth_type;
		dcerpc_AuthLevel auth_level;
		uint8  auth_pad_length;
		uint8  auth_reserved;
		uint32 auth_context_id;
		[flag(NDR_REMAINING)] DATA_BLOB credentials;
	} dcerpc_auth;

	const uint8 DCERPC_AUTH_TRAILER_LENGTH = 8;
	const uint8 DCERPC_AUTH_PAD_ALIGNMENT = 16;

	typedef [public] struct {
		[value(0)]	      uint32    _pad;
		[flag(NDR_REMAINING)] DATA_BLOB auth_info;
	} dcerpc_auth3;

	typedef [public] struct {
		[flag(NDR_REMAINING)] DATA_BLOB auth_info;
	} dcerpc_orphaned;

	typedef [public] struct {
		[flag(NDR_REMAINING)] DATA_BLOB auth_info;
	} dcerpc_co_cancel;

	typedef [public] struct {
		uint32 version;
		uint32 id;
	} dcerpc_cl_cancel;

	typedef [public] struct {
		uint32 version;
		uint32 id;
		boolean32 server_is_accepting;
	} dcerpc_cancel_ack;

	typedef [public] struct {
		uint32 version;
		uint8 _pad1;
		uint16 window_size;
		uint32 max_tdsu;
		uint32 max_frag_size;
		uint16 serial_no;
		uint16 selack_size;
		uint32 selack[selack_size];
	} dcerpc_fack;

	typedef [public] struct {
	} dcerpc_ack;

	typedef [public] struct {
	} dcerpc_ping;

	typedef [public] struct {
	} dcerpc_shutdown;

	typedef [public] struct {
	} dcerpc_working;

	/* RTS data structures */
	typedef [public] struct {
		GUID		Cookie;
	} RTSCookie;

	typedef [v1_enum,public] enum {
		RTS_IPV4	= 0,
		RTS_IPV6	= 1
	} AddressType;

	typedef [nodiscriminant] union {
		[case(RTS_IPV4)] ipv4address	ClientAddressIPV4;
		[case(RTS_IPV6)] ipv6address	ClientAddressIPV6;
	} ClientAddressType;

	typedef [public] struct {
		AddressType					AddressType;
		[switch_is(AddressType)] ClientAddressType	ClientAddress;
		uint8						Padding[12];
	} ClientAddress;

	typedef [v1_enum, public] enum {
		FDClient	= 0,
		FDInProxy	= 1,
		FDServer	= 2,
		FDOutProxy	= 3
	} ForwardDestination;

	typedef [public] struct {
		uint32		BytesReceived;
		uint32		AvailableWindow;
		RTSCookie	ChannelCookie;
	} FlowControlAcknowledgment;

	/* RTS commands */

	/* RTS command: 0x0 */
	typedef [public] struct {
		[range(0x2000,0x40000)] uint32	ReceiveWindowSize;
	} dcerpc_rts_cmd_ReceiveWindowSize;

	/* RTS command: 0x1 */
	typedef [public] struct {
		FlowControlAcknowledgment	Ack;
	} dcerpc_rts_cmd_FlowControlAck;

	/* RTS command: 0x2 */
	typedef [public] struct {
		[range(0x1D4C0,0xDBBA00)] uint32	ConnectionTimeout;
	} dcerpc_rts_cmd_ConnectionTimeout;

	/* RTS command: 0x3 */
	typedef [public] struct {
		RTSCookie	Cookie;
	} dcerpc_rts_cmd_Cookie;

	/* RTS command: 0x4 */
	typedef [public] struct {
		[range(0x20000,0x80000000)] uint32	ChannelLifetime;
	} dcerpc_rts_cmd_ChannelLifetime;

	/* RTS command: 0x5 */
	typedef [public] struct {
		uint32		ClientKeepalive;
	} dcerpc_rts_cmd_ClientKeepalive;

	/* RTS command: 0x6 */
	typedef [public] struct {
		uint32		Version;
	} dcerpc_rts_cmd_Version;

	/* RTS command: 0x7 */
	typedef [public] struct {
	} dcerpc_rts_cmd_Empty;

	/* RTS command: 0x8 */
	typedef [public] struct {
		[range(0x0,0xFFFF)] uint32	ConformanceCount;
		uint8				Padding[ConformanceCount];
	} dcerpc_rts_cmd_Padding;

	/* RTS command: 0x9 */
	typedef [public] struct {
	} dcerpc_rts_cmd_NegativeANCE;

	/* RTS Command: 0xA */
	typedef [public] struct {
	} dcerpc_rts_cmd_ANCE;

	/* RTS command: 0xB */
	typedef [public] struct {
		ClientAddress	ClientAddress;
	} dcerpc_rts_cmd_ClientAddress;

	/* RTS command: 0xC */
	typedef [public] struct {
		RTSCookie	AssociationGroupId;
	} dcerpc_rts_cmd_AssociationGroupId;

	/* RTS command: 0xD */
	typedef [public] struct {
		ForwardDestination	ForwardDestination;
	} dcerpc_rts_cmd_Destination;

	/* RTS command: 0xE */
	typedef [public] struct {
		uint32	PingTrafficSent;
	} dcerpc_rts_cmd_PingTrafficSentNotify;

	typedef [nodiscriminant] union {
		[case(0x0)] dcerpc_rts_cmd_ReceiveWindowSize		ReceiveWindowSize;
		[case(0x1)] dcerpc_rts_cmd_FlowControlAck		FlowControlAck;
		[case(0x2)] dcerpc_rts_cmd_ConnectionTimeout		ConnectionTimeout;
		[case(0x3)] dcerpc_rts_cmd_Cookie			Cookie;
		[case(0x4)] dcerpc_rts_cmd_ChannelLifetime		ChannelLifetime;
		[case(0x5)] dcerpc_rts_cmd_ClientKeepalive		ClientKeepalive;
		[case(0x6)] dcerpc_rts_cmd_Version			Version;
		[case(0x7)] dcerpc_rts_cmd_Empty			Empty;
		[case(0x8)] dcerpc_rts_cmd_Padding			Padding;
		[case(0x9)] dcerpc_rts_cmd_NegativeANCE			NegativeANCE;
		[case(0xA)] dcerpc_rts_cmd_ANCE				ANCE;
		[case(0xB)] dcerpc_rts_cmd_ClientAddress		ClientAddress;
		[case(0xC)] dcerpc_rts_cmd_AssociationGroupId		AssociationGroupId;
		[case(0xD)] dcerpc_rts_cmd_Destination			Destination;
		[case(0xE)] dcerpc_rts_cmd_PingTrafficSentNotify	PingTrafficSentNotify;
	} dcerpc_rts_cmds;

	typedef [public] struct {
		uint32						CommandType;
		[switch_is(CommandType)] dcerpc_rts_cmds	Command;
	} dcerpc_rts_cmd;

	/* The RTS flags */
	typedef [public, bitmap16bit] bitmap {
		RTS_FLAG_NONE			=	0x0000,
		RTS_FLAG_PING			=	0x0001,
		RTS_FLAG_OTHER_CMD		=	0x0002,
		RTS_FLAG_RECYCLE_CHANNEL	=	0x0004,
		RTS_FLAG_IN_CHANNEL		=	0x0008,
		RTS_FLAG_OUT_CHANNEL		=	0x0010,
		RTS_FLAG_EOF			=	0x0020,
		RTS_FLAG_ECHO			=	0x0040
	} dcerpc_rts_flags;

	typedef [public] struct {
		dcerpc_rts_flags	Flags;
		uint16			NumberOfCommands;
		dcerpc_rts_cmd		Commands[NumberOfCommands];
	} dcerpc_rts;

	typedef [public,enum8bit] enum {
		DCERPC_PKT_REQUEST     =  0,	/* Ordinary request. */
		DCERPC_PKT_PING        =  1,	/* Connectionless is server alive ? */
		DCERPC_PKT_RESPONSE    =  2,	/* Ordinary reply. */
		DCERPC_PKT_FAULT       =  3,	/* Fault in processing of call. */
		DCERPC_PKT_WORKING     =  4,	/* Connectionless reply to a ping when server busy. */
		DCERPC_PKT_NOCALL      =  5,	/* Connectionless reply to a ping when server has lost part of clients call. */
		DCERPC_PKT_REJECT      =  6,	/* Refuse a request with a code. */
		DCERPC_PKT_ACK         =  7,	/* Connectionless client to server code. */
		DCERPC_PKT_CL_CANCEL   =  8,	/* Connectionless cancel. */
		DCERPC_PKT_FACK        =  9,	/* Connectionless fragment ack. Both client and server send. */
		DCERPC_PKT_CANCEL_ACK  = 10,	/* Server ACK to client cancel request. */
		DCERPC_PKT_BIND        = 11,	/* Bind to interface. */
		DCERPC_PKT_BIND_ACK    = 12,	/* Server ack of bind. */
		DCERPC_PKT_BIND_NAK    = 13,	/* Server nack of bind. */
		DCERPC_PKT_ALTER       = 14,	/* Alter auth. */
		DCERPC_PKT_ALTER_RESP  = 15,	/* Reply to alter auth. */
		DCERPC_PKT_AUTH3       = 16, 	/* not the real name!  this is undocumented! */
		DCERPC_PKT_SHUTDOWN    = 17,	/* Server to client request to shutdown. */
		DCERPC_PKT_CO_CANCEL   = 18,	/* Connection-oriented cancel request. */
		DCERPC_PKT_ORPHANED    = 19,	/* Client telling server it's aborting a partially sent request or telling server to stop sending replies. */
		DCERPC_PKT_RTS	       = 20	/* RTS packets used in ncacn_http */
	} dcerpc_pkt_type;

	typedef [public,nodiscriminant] union {
		[case(DCERPC_PKT_REQUEST)]    dcerpc_request  request;
		[case(DCERPC_PKT_PING)] 	  dcerpc_ping ping;
		[case(DCERPC_PKT_RESPONSE)]   dcerpc_response response;
		[case(DCERPC_PKT_FAULT)]	  dcerpc_fault fault;
		[case(DCERPC_PKT_WORKING)]	  dcerpc_working working;
		[case(DCERPC_PKT_NOCALL)]     dcerpc_fack nocall;
		[case(DCERPC_PKT_REJECT)]     dcerpc_fault reject;
		[case(DCERPC_PKT_ACK)]        dcerpc_ack ack;
		[case(DCERPC_PKT_CL_CANCEL)]  dcerpc_cl_cancel cl_cancel;
		[case(DCERPC_PKT_FACK)]       dcerpc_fack fack;
		[case(DCERPC_PKT_CANCEL_ACK)] dcerpc_cancel_ack cancel_ack;
		[case(DCERPC_PKT_BIND)]       dcerpc_bind     bind;
		[case(DCERPC_PKT_BIND_ACK)]   dcerpc_bind_ack bind_ack;
		[case(DCERPC_PKT_BIND_NAK)]   dcerpc_bind_nak bind_nak;
		[case(DCERPC_PKT_ALTER)]      dcerpc_bind     alter;
		[case(DCERPC_PKT_ALTER_RESP)] dcerpc_bind_ack alter_resp;
		[case(DCERPC_PKT_SHUTDOWN)]   dcerpc_shutdown shutdown;
		[case(DCERPC_PKT_CO_CANCEL)]  dcerpc_co_cancel co_cancel;
		[case(DCERPC_PKT_ORPHANED)]   dcerpc_orphaned orphaned;
		[case(DCERPC_PKT_AUTH3)]      dcerpc_auth3    auth3;
		[case(DCERPC_PKT_RTS)]	      dcerpc_rts      rts;
	} dcerpc_payload;

	/* pfc_flags values */
	typedef [public,bitmap8bit] bitmap {
		DCERPC_PFC_FLAG_FIRST		= 0x01, /* First fragment */
		DCERPC_PFC_FLAG_LAST		= 0x02, /* Last fragment */
		DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING = 0x04, /* depends on the pdu type */
		DCERPC_PFC_FLAG_CONC_MPX	= 0x10, /* supports concurrent multiplexing of a single connection. */
		DCERPC_PFC_FLAG_DID_NOT_EXECUTE	= 0x20, /* on a fault it means the server hasn't done anything */
		DCERPC_PFC_FLAG_MAYBE		= 0x40, /* `maybe' call semantics requested */
		DCERPC_PFC_FLAG_OBJECT_UUID	= 0x80 /* on valid guid is in the optional object field */
	} dcerpc_pfc_flags;

	/* Cancel was pending at sender */
	const int DCERPC_PFC_FLAG_PENDING_CANCEL =
		DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING;
	const int DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN =
		DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING;

	/* these offsets are needed by the signing code */
	const uint8 DCERPC_PFC_OFFSET      =  3;
	const uint8 DCERPC_DREP_OFFSET     =  4;
	const uint8 DCERPC_FRAG_LEN_OFFSET =  8;
	const uint32 DCERPC_FRAG_MAX_SIZE  = 5840;
	const uint8 DCERPC_AUTH_LEN_OFFSET = 10;
	const uint8 DCERPC_NCACN_PAYLOAD_OFFSET = 16;

	/*
	 * See [MS-RPCE] 3.3.3.5.4 Maximum Server Input Data Size
	 * 4 MByte is the default limit of reassembled request payload
	 */
	const uint32 DCERPC_NCACN_REQUEST_DEFAULT_MAX_SIZE = 0x400000;

	/*
	 * See [MS-RPCE] 3.3.2.5.2 Handling Responses
	 *
	 * Indicates that Windows accepts up to 0x7FFFFFFF ~2 GByte
	 *
	 * talloc has a limit of 256 MByte, so we need to use something smaller.
	 *
	 * For now we try our luck with 240 MByte.
	 */
	const uint32 DCERPC_NCACN_RESPONSE_DEFAULT_MAX_SIZE = 0xf000000; /* 240 MByte */

	/* little-endian flag */
	const uint8 DCERPC_DREP_LE  = 0x10;

	typedef [public,nopush,nopull,noprint] struct {
		uint8 rpc_vers;	        /* RPC version */
		uint8 rpc_vers_minor;   /* Minor version */
		dcerpc_pkt_type ptype;  /* Packet type */
		dcerpc_pfc_flags pfc_flags; /* Fragmentation flags */
		uint8 drep[4];	        /* NDR data representation */
		uint16 frag_length;     /* Total length of fragment */
		uint16 auth_length;     /* authenticator length */
		uint32 call_id;	        /* Call identifier */
		[switch_is(ptype)] dcerpc_payload u;
	} ncacn_packet;

	typedef [public] struct {
		uint8 rpc_vers;		/* RPC version (4) */
		uint8 ptype;
		uint8 pfc_flags;
		uint8 ncadg_flags;
		uint8 drep[3];
		uint8 serial_high;
		GUID object;
		GUID iface;
		GUID activity;
		uint32 server_boot; /* Server boot time */
		uint32 iface_version;
		uint32 seq_num;
		uint16 opnum;
		uint16 ihint;
		uint16 ahint;
		uint16 len;
		uint16 fragnum;
		uint8 auth_proto;
		uint8 serial_low;
		[switch_is(ptype)] dcerpc_payload u;
	} ncadg_packet;

	typedef [bitmap16bit] bitmap {
		DCERPC_SEC_VT_COMMAND_ENUM  = 0x3FFF,
		DCERPC_SEC_VT_COMMAND_END   = 0x4000,
		DCERPC_SEC_VT_MUST_PROCESS  = 0x8000
	} dcerpc_sec_vt_command;

	typedef [enum16bit] enum {
		DCERPC_SEC_VT_COMMAND_BITMASK1  = 0x0001,
		DCERPC_SEC_VT_COMMAND_PCONTEXT  = 0x0002,
		DCERPC_SEC_VT_COMMAND_HEADER2   = 0x0003
	} dcerpc_sec_vt_command_enum;

	typedef [bitmap32bit] bitmap {
		DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING = 0x00000001
	} dcerpc_sec_vt_bitmask1;

	typedef struct {
		ndr_syntax_id abstract_syntax;
		ndr_syntax_id transfer_syntax;
	} dcerpc_sec_vt_pcontext;

	typedef struct {
		dcerpc_pkt_type ptype;  /* Packet type */
		[value(0)] uint8 reserved1;
		[value(0)] uint16 reserved2;
		uint8 drep[4];          /* NDR data representation */
		uint32 call_id;         /* Call identifier */
		uint16 context_id;
		uint16 opnum;
	} dcerpc_sec_vt_header2;

	typedef [switch_type(dcerpc_sec_vt_command_enum),nodiscriminant] union {
	[case(DCERPC_SEC_VT_COMMAND_BITMASK1)] dcerpc_sec_vt_bitmask1 bitmask1;
	[case(DCERPC_SEC_VT_COMMAND_PCONTEXT)] dcerpc_sec_vt_pcontext pcontext;
	[case(DCERPC_SEC_VT_COMMAND_HEADER2)] dcerpc_sec_vt_header2 header2;
	[default,flag(NDR_REMAINING)] DATA_BLOB _unknown;
	} dcerpc_sec_vt_union;

	typedef struct {
		dcerpc_sec_vt_command command;
		[switch_is(command & DCERPC_SEC_VT_COMMAND_ENUM)]
			[subcontext(2),flag(NDR_SUBCONTEXT_NO_UNREAD_BYTES)]
			dcerpc_sec_vt_union u;
	} dcerpc_sec_vt;

	typedef [public,nopush,nopull] struct {
		uint16 count;
	} dcerpc_sec_vt_count;

	/*
	 * We assume that the whole verification trailer fits into
	 * the last 1024 bytes after the stub data.
	 *
	 * There're currently only 3 commands defined and each should
	 * only be used once.
	 */
	const uint16 DCERPC_SEC_VT_MAX_SIZE = 1024;

	typedef [public,flag(NDR_PAHEX)] struct {
		[flag(NDR_ALIGN4)] DATA_BLOB _pad;
		[value(DCERPC_SEC_VT_MAGIC)] uint8 magic[8];
		dcerpc_sec_vt_count count;
		dcerpc_sec_vt commands[count.count];
	} dcerpc_sec_verification_trailer;
}