librpc/idl/dcerpc.idl

   1 #include "idl_types.h"
   2
   3 /*
   4   the base dcerpc packet definitions - not traditionally coded as IDL,
   5   but given that pidl can handle it nicely it simplifies things a lot
   6   to do it this way
   7
   8   see http://www.opengroup.org/onlinepubs/9629399/chap12.htm for packet
   9   layouts
  10 */
  11 import "misc.idl";
  12
  13 interface dcerpc
  14 {
  15         typedef struct {
  16                 uint16 context_id;
  17                 uint8 num_transfer_syntaxes;
  18                 ndr_syntax_id abstract_syntax;
  19                 ndr_syntax_id transfer_syntaxes[num_transfer_syntaxes];
  20         } dcerpc_ctx_list;
  21
  22         typedef [public] struct {
  23                 uint16 max_xmit_frag;
  24                 uint16 max_recv_frag;
  25                 uint32 assoc_group_id;
  26                 uint8  num_contexts;
  27                 dcerpc_ctx_list ctx_list[num_contexts];
  28                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
  29         } dcerpc_bind;
  30
  31         const uint8 DCERPC_REQUEST_LENGTH = 24;
  32
  33         typedef struct {
  34         } dcerpc_empty;
  35
  36         typedef [nodiscriminant] union {
  37                 [default] dcerpc_empty empty;
  38                 [case(LIBNDR_FLAG_OBJECT_PRESENT)] GUID object;
  39         } dcerpc_object;
  40
  41         typedef struct {
  42                 uint32 alloc_hint;
  43                 uint16 context_id;
  44                 uint16 opnum;
  45                 [switch_is(ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT)] dcerpc_object object;
  46                 [flag(NDR_ALIGN8)]    DATA_BLOB _pad;
  47                 [flag(NDR_REMAINING)] DATA_BLOB stub_and_verifier;
  48         } dcerpc_request;
  49
  50         const int DCERPC_BIND_REASON_ASYNTAX                 = 1;
  51         const int DCERPC_BIND_PROVIDER_REJECT                = 2;
  52         const int DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED = 4;
  53         const int DCERPC_BIND_REASON_INVALID_AUTH_TYPE       = 8;
  54
  55         typedef struct {
  56                 uint16 result;
  57                 uint16 reason;
  58                 ndr_syntax_id syntax;
  59         } dcerpc_ack_ctx;
  60
  61         typedef struct {
  62                 uint16 max_xmit_frag;
  63                 uint16 max_recv_frag;
  64                 uint32 assoc_group_id;
  65                 [value(strlen(secondary_address)+1)] uint16 secondary_address_size;
  66                 [charset(DOS)] uint8 secondary_address[secondary_address_size];
  67                 [flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
  68                 uint8 num_results;
  69                 dcerpc_ack_ctx ctx_list[num_results];
  70                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
  71         } dcerpc_bind_ack;
  72
  73         typedef struct {
  74                 uint32 num_versions;
  75                 uint32 versions[num_versions];
  76         } dcerpc_bind_nak_versions;
  77
  78         typedef [nodiscriminant] union {
  79                 [case(DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED)] dcerpc_bind_nak_versions v;
  80                 [default] ;
  81         } dcerpc_bind_nak_versions_ctr;
  82
  83         typedef struct {
  84                 uint16 reject_reason;
  85                 [switch_is(reject_reason)] dcerpc_bind_nak_versions_ctr versions;
  86         } dcerpc_bind_nak;
  87
  88         const uint8 DCERPC_RESPONSE_LENGTH = 24;
  89
  90         typedef struct {
  91                 uint32 alloc_hint;
  92                 uint16 context_id;
  93                 uint8 cancel_count;
  94                 [flag(NDR_ALIGN8)]    DATA_BLOB _pad;
  95                 [flag(NDR_REMAINING)] DATA_BLOB stub_and_verifier;
  96         } dcerpc_response;
  97
  98         typedef [v1_enum] enum {
  99                 DCERPC_NCA_S_COMM_FAILURE               = 0x1C010001,
 100                 DCERPC_NCA_S_OP_RNG_ERROR               = 0x1C010002,
 101                 DCERPC_NCA_S_UNKNOWN_IF                 = 0x1C010003,
 102                 DCERPC_NCA_S_WRONG_BOOT_TIME            = 0x1C010006,
 103                 DCERPC_NCA_S_YOU_CRASHED                = 0x1C010009,
 104                 DCERPC_NCA_S_PROTO_ERROR                = 0x1C01000B,
 105                 DCERPC_NCA_S_OUT_ARGS_TOO_BIG           = 0x1C010013,
 106                 DCERPC_NCA_S_SERVER_TOO_BUSY            = 0x1C010014,
 107                 DCERPC_NCA_S_FAULT_STRING_TOO_LARGE     = 0x1C010015,
 108                 DCERPC_NCA_S_UNSUPPORTED_TYPE           = 0x1C010017,
 109                 DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO      = 0x1C000001,
 110                 DCERPC_NCA_S_FAULT_ADDR_ERROR           = 0x1C000002,
 111                 DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO       = 0x1C000003,
 112                 DCERPC_NCA_S_FAULT_FP_UNDERFLOW         = 0x1C000004,
 113                 DCERPC_NCA_S_FAULT_FP_OVERRFLOW         = 0x1C000005,
 114                 DCERPC_NCA_S_FAULT_INVALID_TAG          = 0x1C000006,
 115                 DCERPC_NCA_S_FAULT_INVALID_BOUND        = 0x1C000007,
 116                 DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH = 0x1C000008,
 117                 DCERPC_NCA_S_FAULT_UNSPEC_REJECT        = 0x1C000009,
 118                 DCERPC_NCA_S_FAULT_BAD_ACTID            = 0x1C00000A,
 119                 DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED   = 0x1C00000B,
 120                 DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED  = 0x1C00000C,
 121                 DCERPC_NCA_S_FAULT_CANCEL               = 0x1C00000D,
 122                 DCERPC_NCA_S_FAULT_ILL_INST             = 0x1C00000E,
 123                 DCERPC_NCA_S_FAULT_FP_ERROR             = 0x1C00000F,
 124                 DCERPC_NCA_S_FAULT_INT_OVERFLOW         = 0x1C000010,
 125                 DCERPC_NCA_S_UNUSED_1C000011            = 0x1C000011,
 126                 DCERPC_NCA_S_FAULT_UNSPEC               = 0x1C000012,
 127                 DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE  = 0x1C000013,
 128                 DCERPC_NCA_S_FAULT_PIPE_EMPTY           = 0x1C000014,
 129                 DCERPC_NCA_S_FAULT_PIPE_CLOSED          = 0x1C000015,
 130                 DCERPC_NCA_S_FAULT_PIPE_ORDER           = 0x1C000016,
 131                 DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE      = 0x1C000017,
 132                 DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR      = 0x1C000018,
 133                 DCERPC_NCA_S_FAULT_PIPE_MEMORY          = 0x1C000019,
 134                 DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH     = 0x1C00001A,
 135                 DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY     = 0x1C00001B,
 136                 DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID    = 0x1C00001C,
 137                 DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL    = 0x1C00001D,
 138                 DCERPC_NCA_S_UNUSED_1C00001E            = 0x1C00001E,
 139                 DCERPC_NCA_S_INVALID_CHECKSUM           = 0x1C00001F,
 140                 DCERPC_NCA_S_INVALID_CRC                = 0x1C000020,
 141                 DCERPC_NCA_S_FAULT_USER_DEFINED         = 0x1C000021,
 142                 DCERPC_NCA_S_FAULT_TX_OPEN_FAILED       = 0x1C000022,
 143                 DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR   = 0x1C000023,
 144                 DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND     = 0x1C000024,
 145                 DCERPC_NCA_S_FAULT_NO_CLIENT_STUB       = 0x1C000025
 146         } dcerpc_nca_status;
 147
 148         const int DCERPC_FAULT_OP_RNG_ERROR       = 0x1c010002;
 149         const int DCERPC_FAULT_UNK_IF             = 0x1c010003;
 150         const int DCERPC_FAULT_NDR                = 0x000006f7;
 151         const int DCERPC_FAULT_INVALID_TAG        = 0x1c000006;
 152         const int DCERPC_FAULT_CONTEXT_MISMATCH   = 0x1c00001a;
 153         const int DCERPC_FAULT_OTHER              = 0x00000001;
 154         const int DCERPC_FAULT_ACCESS_DENIED      = 0x00000005;
 155         const int DCERPC_FAULT_CANT_PERFORM       = 0x000006d8;
 156         const int DCERPC_FAULT_SEC_PKG_ERROR      = 0x00000721;
 157
 158         /* we return this fault when we haven't yet run the test
 159            to see what fault w2k3 returns in this case */
 160         const int DCERPC_FAULT_TODO         = 0x00000042;
 161
 162         typedef struct {
 163                 uint32 alloc_hint;
 164                 uint16 context_id;
 165                 uint8 cancel_count;
 166                 dcerpc_nca_status status;
 167                 [flag(NDR_REMAINING)] DATA_BLOB _pad;
 168         } dcerpc_fault;
 169
 170         /* the auth types we know about */
 171         typedef [enum8bit] enum {
 172                 DCERPC_AUTH_TYPE_NONE     = 0,
 173                 /* this seems to be not krb5! */
 174                 DCERPC_AUTH_TYPE_KRB5_1   = 1,
 175                 DCERPC_AUTH_TYPE_SPNEGO   = 9,
 176                 DCERPC_AUTH_TYPE_NTLMSSP  = 10,
 177                 DCERPC_AUTH_TYPE_KRB5     = 16,
 178                 DCERPC_AUTH_TYPE_DPA      = 17,
 179                 DCERPC_AUTH_TYPE_MSN      = 18,
 180                 DCERPC_AUTH_TYPE_DIGEST   = 21,
 181                 DCERPC_AUTH_TYPE_SCHANNEL = 68,
 182                 DCERPC_AUTH_TYPE_MSMQ     = 100,
 183                 DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM = 200
 184         } dcerpc_AuthType;
 185
 186         typedef [enum8bit] enum {
 187                 DCERPC_AUTH_LEVEL_NONE      = 1,
 188                 DCERPC_AUTH_LEVEL_CONNECT   = 2,
 189                 DCERPC_AUTH_LEVEL_CALL      = 3,
 190                 DCERPC_AUTH_LEVEL_PACKET    = 4,
 191                 DCERPC_AUTH_LEVEL_INTEGRITY = 5,
 192                 DCERPC_AUTH_LEVEL_PRIVACY   = 6
 193         } dcerpc_AuthLevel;
 194
 195         const uint8 DCERPC_AUTH_LEVEL_DEFAULT   = DCERPC_AUTH_LEVEL_CONNECT;
 196
 197         typedef [public] struct {
 198                 dcerpc_AuthType auth_type;
 199                 dcerpc_AuthLevel auth_level;
 200                 uint8  auth_pad_length;
 201                 uint8  auth_reserved;
 202                 uint32 auth_context_id;
 203                 [flag(NDR_REMAINING)] DATA_BLOB credentials;
 204         } dcerpc_auth;
 205
 206         const uint8 DCERPC_AUTH_TRAILER_LENGTH = 8;
 207
 208         typedef [public] struct {
 209                 [value(0)]            uint32    _pad;
 210                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
 211         } dcerpc_auth3;
 212
 213         typedef [public] struct {
 214                 [value(0)]            uint32    _pad;
 215                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
 216         } dcerpc_orphaned;
 217
 218         typedef [public] struct {
 219                 [value(0)]            uint32    _pad;
 220                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
 221         } dcerpc_co_cancel;
 222
 223         typedef [public] struct {
 224                 uint32 version;
 225                 uint32 id;
 226         } dcerpc_cl_cancel;
 227
 228         typedef [public] struct {
 229                 uint32 version;
 230                 uint32 id;
 231                 boolean32 server_is_accepting;
 232         } dcerpc_cancel_ack;
 233
 234         typedef [public] struct {
 235                 uint32 version;
 236                 uint8 _pad1;
 237                 uint16 window_size;
 238                 uint32 max_tdsu;
 239                 uint32 max_frag_size;
 240                 uint16 serial_no;
 241                 uint16 selack_size;
 242                 uint32 selack[selack_size];
 243         } dcerpc_fack;
 244
 245         typedef [public] struct {
 246         } dcerpc_ack;
 247
 248         typedef [public] struct {
 249         } dcerpc_ping;
 250
 251         typedef [public] struct {
 252         } dcerpc_shutdown;
 253
 254         typedef [public] struct {
 255         } dcerpc_working;
 256
 257         /* RTS data structures */
 258         typedef [public] struct {
 259                 GUID            Cookie;
 260         } RTSCookie;
 261
 262         typedef [v1_enum,public] enum {
 263                 RTS_IPV4        = 0,
 264                 RTS_IPV6        = 1
 265         } AddressType;
 266
 267         typedef [nodiscriminant] union {
 268                 [case(RTS_IPV4)] ipv4address    ClientAddressIPV4;
 269                 [case(RTS_IPV6)] ipv6address    ClientAddressIPV6;
 270         } ClientAddressType;
 271
 272         typedef [public] struct {
 273                 AddressType                                     AddressType;
 274                 [switch_is(AddressType)] ClientAddressType      ClientAddress;
 275                 uint8                                           Padding[12];
 276         } ClientAddress;
 277
 278         typedef [v1_enum, public] enum {
 279                 FDClient        = 0,
 280                 FDInProxy       = 1,
 281                 FDServer        = 2,
 282                 FDOutProxy      = 3
 283         } ForwardDestination;
 284
 285         typedef [public] struct {
 286                 uint32          BytesReceived;
 287                 uint32          AvailableWindow;
 288                 RTSCookie       ChannelCookie;
 289         } FlowControlAcknowledgment;
 290
 291         /* RTS commands */
 292
 293         /* RTS command: 0x0 */
 294         typedef [public] struct {
 295                 [range(0x2000,0x40000)] uint32  ReceiveWindowSize;
 296         } dcerpc_rts_cmd_ReceiveWindowSize;
 297
 298         /* RTS command: 0x1 */
 299         typedef [public] struct {
 300                 FlowControlAcknowledgment       Ack;
 301         } dcerpc_rts_cmd_FlowControlAck;
 302
 303         /* RTS command: 0x2 */
 304         typedef [public] struct {
 305                 [range(0x1D4C0,0xDBBA00)] uint32        ConnectionTimeout;
 306         } dcerpc_rts_cmd_ConnectionTimeout;
 307
 308         /* RTS command: 0x3 */
 309         typedef [public] struct {
 310                 RTSCookie       Cookie;
 311         } dcerpc_rts_cmd_Cookie;
 312
 313         /* RTS command: 0x4 */
 314         typedef [public] struct {
 315                 [range(0x20000,0x80000000)] uint32      ChannelLifetime;
 316         } dcerpc_rts_cmd_ChannelLifetime;
 317
 318         /* RTS command: 0x5 */
 319         typedef [public] struct {
 320                 uint32          ClientKeepalive;
 321         } dcerpc_rts_cmd_ClientKeepalive;
 322
 323         /* RTS command: 0x6 */
 324         typedef [public] struct {
 325                 uint32          Version;
 326         } dcerpc_rts_cmd_Version;
 327
 328         /* RTS command: 0x7 */
 329         typedef [public] struct {
 330         } dcerpc_rts_cmd_Empty;
 331
 332         /* RTS command: 0x8 */
 333         typedef [public] struct {
 334                 [range(0x0,0xFFFF)] uint32      ConformanceCount;
 335                 uint8                           Padding[ConformanceCount];
 336         } dcerpc_rts_cmd_Padding;
 337
 338         /* RTS command: 0x9 */
 339         typedef [public] struct {
 340         } dcerpc_rts_cmd_NegativeANCE;
 341
 342         /* RTS Command: 0xA */
 343         typedef [public] struct {
 344         } dcerpc_rts_cmd_ANCE;
 345
 346         /* RTS command: 0xB */
 347         typedef [public] struct {
 348                 ClientAddress   ClientAddress;
 349         } dcerpc_rts_cmd_ClientAddress;
 350
 351         /* RTS command: 0xC */
 352         typedef [public] struct {
 353                 RTSCookie       AssociationGroupId;
 354         } dcerpc_rts_cmd_AssociationGroupId;
 355
 356         /* RTS command: 0xD */
 357         typedef [public] struct {
 358                 ForwardDestination      ForwardDestination;
 359         } dcerpc_rts_cmd_Destination;
 360
 361         /* RTS command: 0xE */
 362         typedef [public] struct {
 363                 uint32  PingTrafficSent;
 364         } dcerpc_rts_cmd_PingTrafficSentNotify;
 365
 366         typedef [nodiscriminant] union {
 367                 [case(0x0)] dcerpc_rts_cmd_ReceiveWindowSize            ReceiveWindowSize;
 368                 [case(0x1)] dcerpc_rts_cmd_FlowControlAck               FlowControlAck;
 369                 [case(0x2)] dcerpc_rts_cmd_ConnectionTimeout            ConnectionTimeout;
 370                 [case(0x3)] dcerpc_rts_cmd_Cookie                       Cookie;
 371                 [case(0x4)] dcerpc_rts_cmd_ChannelLifetime              ChannelLifetime;
 372                 [case(0x5)] dcerpc_rts_cmd_ClientKeepalive              ClientKeepalive;
 373                 [case(0x6)] dcerpc_rts_cmd_Version                      Version;
 374                 [case(0x7)] dcerpc_rts_cmd_Empty                        Empty;
 375                 [case(0x8)] dcerpc_rts_cmd_Padding                      Padding;
 376                 [case(0x9)] dcerpc_rts_cmd_NegativeANCE                 NegativeANCE;
 377                 [case(0xA)] dcerpc_rts_cmd_ANCE                         ANCE;
 378                 [case(0xB)] dcerpc_rts_cmd_ClientAddress                ClientAddress;
 379                 [case(0xC)] dcerpc_rts_cmd_AssociationGroupId           AssociationGroupId;
 380                 [case(0xD)] dcerpc_rts_cmd_Destination                  Destination;
 381                 [case(0xE)] dcerpc_rts_cmd_PingTrafficSentNotify        PingTrafficSentNotify;
 382         } dcerpc_rts_cmds;
 383
 384         typedef [public] struct {
 385                 uint32                                          CommandType;
 386                 [switch_is(CommandType)] dcerpc_rts_cmds        Command;
 387         } dcerpc_rts_cmd;
 388
 389         /* The RTS flags */
 390         typedef [public, bitmap16bit] bitmap {
 391                 RTS_FLAG_NONE                   =       0x0000,
 392                 RTS_FLAG_PING                   =       0x0001,
 393                 RTS_FLAG_OTHER_CMD              =       0x0002,
 394                 RTS_FLAG_RECYCLE_CHANNEL        =       0x0004,
 395                 RTS_FLAG_IN_CHANNEL             =       0x0008,
 396                 RTS_FLAG_OUT_CHANNEL            =       0x0010,
 397                 RTS_FLAG_EOF                    =       0x0020,
 398                 RTS_FLAG_ECHO                   =       0x0040
 399         } dcerpc_rts_flags;
 400
 401         typedef [public] struct {
 402                 dcerpc_rts_flags        Flags;
 403                 uint16                  NumberOfCommands;
 404                 dcerpc_rts_cmd          Commands[NumberOfCommands];
 405         } dcerpc_rts;
 406
 407         typedef [enum8bit] enum {
 408                 DCERPC_PKT_REQUEST     =  0,    /* Ordinary request. */
 409                 DCERPC_PKT_PING        =  1,    /* Connectionless is server alive ? */
 410                 DCERPC_PKT_RESPONSE    =  2,    /* Ordinary reply. */
 411                 DCERPC_PKT_FAULT       =  3,    /* Fault in processing of call. */
 412                 DCERPC_PKT_WORKING     =  4,    /* Connectionless reply to a ping when server busy. */
 413                 DCERPC_PKT_NOCALL      =  5,    /* Connectionless reply to a ping when server has lost part of clients call. */
 414                 DCERPC_PKT_REJECT      =  6,    /* Refuse a request with a code. */
 415                 DCERPC_PKT_ACK         =  7,    /* Connectionless client to server code. */
 416                 DCERPC_PKT_CL_CANCEL   =  8,    /* Connectionless cancel. */
 417                 DCERPC_PKT_FACK        =  9,    /* Connectionless fragment ack. Both client and server send. */
 418                 DCERPC_PKT_CANCEL_ACK  = 10,    /* Server ACK to client cancel request. */
 419                 DCERPC_PKT_BIND        = 11,    /* Bind to interface. */
 420                 DCERPC_PKT_BIND_ACK    = 12,    /* Server ack of bind. */
 421                 DCERPC_PKT_BIND_NAK    = 13,    /* Server nack of bind. */
 422                 DCERPC_PKT_ALTER       = 14,    /* Alter auth. */
 423                 DCERPC_PKT_ALTER_RESP  = 15,    /* Reply to alter auth. */
 424                 DCERPC_PKT_AUTH3       = 16,    /* not the real name!  this is undocumented! */
 425                 DCERPC_PKT_SHUTDOWN    = 17,    /* Server to client request to shutdown. */
 426                 DCERPC_PKT_CO_CANCEL   = 18,    /* Connection-oriented cancel request. */
 427                 DCERPC_PKT_ORPHANED    = 19,    /* Client telling server it's aborting a partially sent request or telling server to stop sending replies. */
 428                 DCERPC_PKT_RTS         = 20     /* RTS packets used in ncacn_http */
 429         } dcerpc_pkt_type;
 430
 431         typedef [nodiscriminant] union {
 432                 [case(DCERPC_PKT_REQUEST)]    dcerpc_request  request;
 433                 [case(DCERPC_PKT_PING)]           dcerpc_ping ping;
 434                 [case(DCERPC_PKT_RESPONSE)]   dcerpc_response response;
 435                 [case(DCERPC_PKT_FAULT)]          dcerpc_fault fault;
 436                 [case(DCERPC_PKT_WORKING)]        dcerpc_working working;
 437                 [case(DCERPC_PKT_NOCALL)]     dcerpc_fack nocall;
 438                 [case(DCERPC_PKT_REJECT)]     dcerpc_fault reject;
 439                 [case(DCERPC_PKT_ACK)]        dcerpc_ack ack;
 440                 [case(DCERPC_PKT_CL_CANCEL)]  dcerpc_cl_cancel cl_cancel;
 441                 [case(DCERPC_PKT_FACK)]       dcerpc_fack fack;
 442                 [case(DCERPC_PKT_CANCEL_ACK)] dcerpc_cancel_ack cancel_ack;
 443                 [case(DCERPC_PKT_BIND)]       dcerpc_bind     bind;
 444                 [case(DCERPC_PKT_BIND_ACK)]   dcerpc_bind_ack bind_ack;
 445                 [case(DCERPC_PKT_BIND_NAK)]   dcerpc_bind_nak bind_nak;
 446                 [case(DCERPC_PKT_ALTER)]      dcerpc_bind     alter;
 447                 [case(DCERPC_PKT_ALTER_RESP)] dcerpc_bind_ack alter_resp;
 448                 [case(DCERPC_PKT_SHUTDOWN)]   dcerpc_shutdown shutdown;
 449                 [case(DCERPC_PKT_CO_CANCEL)]  dcerpc_co_cancel co_cancel;
 450                 [case(DCERPC_PKT_ORPHANED)]   dcerpc_orphaned orphaned;
 451                 [case(DCERPC_PKT_AUTH3)]      dcerpc_auth3    auth3;
 452                 [case(DCERPC_PKT_RTS)]        dcerpc_rts      rts;
 453         } dcerpc_payload;
 454
 455         /* pfc_flags values */
 456         const uint8 DCERPC_PFC_FLAG_FIRST               = 0x01; /* First fragment */
 457         const uint8 DCERPC_PFC_FLAG_LAST                = 0x02; /* Last fragment */
 458         const uint8 DCERPC_PFC_FLAG_PENDING_CANCEL      = 0x04; /* Cancel was pending at sender */
 459         const uint8 DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN = DCERPC_PFC_FLAG_PENDING_CANCEL; /* depends on the pdu type */
 460         const uint8 DCERPC_PFC_FLAG_CONC_MPX            = 0x10; /* supports concurrent multiplexing of a single connection. */
 461         const uint8 DCERPC_PFC_FLAG_DID_NOT_EXECUTE     = 0x20; /* on a fault it means the server hasn't done anything */
 462         const uint8 DCERPC_PFC_FLAG_MAYBE               = 0x40; /* `maybe' call semantics requested */
 463         const uint8 DCERPC_PFC_FLAG_OBJECT_UUID         = 0x80; /* on valid guid is in the optional object field */
 464
 465         /* these offsets are needed by the signing code */
 466         const uint8 DCERPC_PFC_OFFSET      =  3;
 467         const uint8 DCERPC_DREP_OFFSET     =  4;
 468         const uint8 DCERPC_FRAG_LEN_OFFSET =  8;
 469         const uint8 DCERPC_AUTH_LEN_OFFSET = 10;
 470
 471         /* little-endian flag */
 472         const uint8 DCERPC_DREP_LE  = 0x10;
 473
 474         typedef [public] struct {
 475                 uint8 rpc_vers;         /* RPC version */
 476                 uint8 rpc_vers_minor;   /* Minor version */
 477                 dcerpc_pkt_type ptype;  /* Packet type */
 478                 uint8 pfc_flags;        /* Fragmentation flags */
 479                 uint8 drep[4];          /* NDR data representation */
 480                 uint16 frag_length;     /* Total length of fragment */
 481                 uint16 auth_length;     /* authenticator length */
 482                 uint32 call_id;         /* Call identifier */
 483                 [switch_is(ptype)] dcerpc_payload u;
 484         } ncacn_packet;
 485
 486         typedef [public] struct {
 487                 uint8 rpc_vers;         /* RPC version (4) */
 488                 uint8 ptype;
 489                 uint8 pfc_flags;
 490                 uint8 ncadg_flags;
 491                 uint8 drep[3];
 492                 uint8 serial_high;
 493                 GUID object;
 494                 GUID iface;
 495                 GUID activity;
 496                 uint32 server_boot; /* Server boot time */
 497                 uint32 iface_version;
 498                 uint32 seq_num;
 499                 uint16 opnum;
 500                 uint16 ihint;
 501                 uint16 ahint;
 502                 uint16 len;
 503                 uint16 fragnum;
 504                 uint8 auth_proto;
 505                 uint8 serial_low;
 506                 [switch_is(ptype)] dcerpc_payload u;
 507         } ncadg_packet;
 508 }