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 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_ALIGN4)]    DATA_BLOB _pad;
  29                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
  30         } dcerpc_bind;
  31
  32         const uint8 DCERPC_REQUEST_LENGTH = 24;
  33
  34         typedef struct {
  35         } dcerpc_empty;
  36
  37         typedef [nodiscriminant] union {
  38                 [default] dcerpc_empty empty;
  39                 [case(LIBNDR_FLAG_OBJECT_PRESENT)] GUID object;
  40         } dcerpc_object;
  41
  42         typedef struct {
  43                 uint32 alloc_hint;
  44                 uint16 context_id;
  45                 uint16 opnum;
  46                 [switch_is(ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT)] dcerpc_object object;
  47                 [flag(NDR_ALIGN8)]    DATA_BLOB _pad;
  48                 [flag(NDR_REMAINING)] DATA_BLOB stub_and_verifier;
  49         } dcerpc_request;
  50
  51         const int DCERPC_BIND_REASON_ASYNTAX                 = 1;
  52         const int DCERPC_BIND_PROVIDER_REJECT                = 2;
  53         const int DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED = 4;
  54         const int DCERPC_BIND_REASON_INVALID_AUTH_TYPE       = 8;
  55
  56         typedef struct {
  57                 uint16 result;
  58                 uint16 reason;
  59                 ndr_syntax_id syntax;
  60         } dcerpc_ack_ctx;
  61
  62         typedef struct {
  63                 uint16 max_xmit_frag;
  64                 uint16 max_recv_frag;
  65                 uint32 assoc_group_id;
  66                 [value(strlen(secondary_address)+1)] uint16 secondary_address_size;
  67                 [charset(DOS)] uint8 secondary_address[secondary_address_size];
  68                 [flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
  69                 uint8 num_results;
  70                 dcerpc_ack_ctx ctx_list[num_results];
  71                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
  72         } dcerpc_bind_ack;
  73
  74         typedef struct {
  75                 uint32 num_versions;
  76                 uint32 versions[num_versions];
  77         } dcerpc_bind_nak_versions;
  78
  79         typedef [nodiscriminant] union {
  80                 [case(DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED)] dcerpc_bind_nak_versions v;
  81                 [default] ;
  82         } dcerpc_bind_nak_versions_ctr;
  83
  84         typedef struct {
  85                 uint16 reject_reason;
  86                 [switch_is(reject_reason)] dcerpc_bind_nak_versions_ctr versions;
  87         } dcerpc_bind_nak;
  88
  89         const uint8 DCERPC_RESPONSE_LENGTH = 24;
  90
  91         typedef struct {
  92                 uint32 alloc_hint;
  93                 uint16 context_id;
  94                 uint8 cancel_count;
  95                 [flag(NDR_ALIGN8)]    DATA_BLOB _pad;
  96                 [flag(NDR_REMAINING)] DATA_BLOB stub_and_verifier;
  97         } dcerpc_response;
  98
  99
 100         const int DCERPC_FAULT_OP_RNG_ERROR       = 0x1c010002;
 101         const int DCERPC_FAULT_UNK_IF             = 0x1c010003;
 102         const int DCERPC_FAULT_NDR                = 0x000006f7;
 103         const int DCERPC_FAULT_INVALID_TAG        = 0x1c000006;
 104         const int DCERPC_FAULT_CONTEXT_MISMATCH   = 0x1c00001a;
 105         const int DCERPC_FAULT_OTHER              = 0x00000001;
 106         const int DCERPC_FAULT_ACCESS_DENIED      = 0x00000005;
 107         const int DCERPC_FAULT_CANT_PERFORM       = 0x000006d8;
 108
 109         /* we return this fault when we haven't yet run the test
 110            to see what fault w2k3 returns in this case */
 111         const int DCERPC_FAULT_TODO         = 0x00000042;
 112
 113         typedef struct {
 114                 uint32 alloc_hint;
 115                 uint16 context_id;
 116                 uint8 cancel_count;
 117                 uint32 status;
 118                 [flag(NDR_REMAINING)] DATA_BLOB _pad;
 119         } dcerpc_fault;
 120
 121         /* the auth types we know about */
 122         typedef [enum8bit] enum {
 123                 DCERPC_AUTH_TYPE_NONE     = 0,
 124                 /* this seems to be not krb5! */
 125                 DCERPC_AUTH_TYPE_KRB5_1   = 1,
 126                 DCERPC_AUTH_TYPE_SPNEGO   = 9,
 127                 DCERPC_AUTH_TYPE_NTLMSSP  = 10,
 128                 DCERPC_AUTH_TYPE_KRB5     = 16,
 129                 DCERPC_AUTH_TYPE_DPA      = 17,
 130                 DCERPC_AUTH_TYPE_MSN      = 18,
 131                 DCERPC_AUTH_TYPE_DIGEST   = 21,
 132                 DCERPC_AUTH_TYPE_SCHANNEL = 68,
 133                 DCERPC_AUTH_TYPE_MSMQ     = 100
 134         } dcerpc_AuthType;
 135
 136         typedef [enum8bit] enum {
 137                 DCERPC_AUTH_LEVEL_NONE      = 1,
 138                 DCERPC_AUTH_LEVEL_CONNECT   = 2,
 139                 DCERPC_AUTH_LEVEL_CALL      = 3,
 140                 DCERPC_AUTH_LEVEL_PACKET    = 4,
 141                 DCERPC_AUTH_LEVEL_INTEGRITY = 5,
 142                 DCERPC_AUTH_LEVEL_PRIVACY   = 6
 143         } dcerpc_AuthLevel;
 144
 145         const uint8 DCERPC_AUTH_LEVEL_DEFAULT   = DCERPC_AUTH_LEVEL_CONNECT;
 146
 147         typedef [public] struct {
 148                 dcerpc_AuthType auth_type;
 149                 dcerpc_AuthLevel auth_level;
 150                 uint8  auth_pad_length;
 151                 uint8  auth_reserved;
 152                 uint32 auth_context_id;
 153                 [flag(NDR_REMAINING)] DATA_BLOB credentials;
 154         } dcerpc_auth;
 155
 156         const uint8 DCERPC_AUTH_TRAILER_LENGTH = 8;
 157
 158         typedef [public] struct {
 159                 uint32 _pad;
 160                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
 161         } dcerpc_auth3;
 162
 163         typedef [public] struct {
 164                 uint32 _pad;
 165                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
 166         } dcerpc_orphaned;
 167
 168         typedef [public] struct {
 169                 uint32 _pad;
 170                 [flag(NDR_REMAINING)] DATA_BLOB auth_info;
 171         } dcerpc_co_cancel;
 172
 173         typedef [public] struct {
 174                 uint32 version;
 175                 uint32 id;
 176         } dcerpc_cl_cancel;
 177
 178         typedef [public] struct {
 179                 uint32 version;
 180                 uint32 id;
 181                 boolean32 server_is_accepting;
 182         } dcerpc_cancel_ack;
 183
 184         typedef [public] struct {
 185                 uint32 version;
 186                 uint8 _pad1;
 187                 uint16 window_size;
 188                 uint32 max_tdsu;
 189                 uint32 max_frag_size;
 190                 uint16 serial_no;
 191                 uint16 selack_size;
 192                 uint32 selack[selack_size];
 193         } dcerpc_fack;
 194
 195         typedef [public] struct {
 196         } dcerpc_ack;
 197
 198         typedef [public] struct {
 199         } dcerpc_ping;
 200
 201         typedef [public] struct {
 202         } dcerpc_shutdown;
 203
 204         typedef [public] struct {
 205         } dcerpc_working;
 206
 207         typedef [enum8bit] enum {
 208                 DCERPC_PKT_REQUEST     =  0,    /* Ordinary request. */
 209                 DCERPC_PKT_PING        =  1,    /* Connectionless is server alive ? */
 210                 DCERPC_PKT_RESPONSE    =  2,    /* Ordinary reply. */
 211                 DCERPC_PKT_FAULT       =  3,    /* Fault in processing of call. */
 212                 DCERPC_PKT_WORKING     =  4,    /* Connectionless reply to a ping when server busy. */
 213                 DCERPC_PKT_NOCALL      =  5,    /* Connectionless reply to a ping when server has lost part of clients call. */
 214                 DCERPC_PKT_REJECT      =  6,    /* Refuse a request with a code. */
 215                 DCERPC_PKT_ACK         =  7,    /* Connectionless client to server code. */
 216                 DCERPC_PKT_CL_CANCEL   =  8,    /* Connectionless cancel. */
 217                 DCERPC_PKT_FACK        =  9,    /* Connectionless fragment ack. Both client and server send. */
 218                 DCERPC_PKT_CANCEL_ACK  = 10,    /* Server ACK to client cancel request. */
 219                 DCERPC_PKT_BIND        = 11,    /* Bind to interface. */
 220                 DCERPC_PKT_BIND_ACK    = 12,    /* Server ack of bind. */
 221                 DCERPC_PKT_BIND_NAK    = 13,    /* Server nack of bind. */
 222                 DCERPC_PKT_ALTER       = 14,    /* Alter auth. */
 223                 DCERPC_PKT_ALTER_RESP  = 15,    /* Reply to alter auth. */
 224                 DCERPC_PKT_AUTH3       = 16,    /* not the real name!  this is undocumented! */
 225                 DCERPC_PKT_SHUTDOWN    = 17,    /* Server to client request to shutdown. */
 226                 DCERPC_PKT_CO_CANCEL   = 18,    /* Connection-oriented cancel request. */
 227                 DCERPC_PKT_ORPHANED    = 19     /* Client telling server it's aborting a partially sent request or telling server to stop sending replies. */
 228         } dcerpc_pkt_type;
 229
 230         typedef [nodiscriminant] union {
 231                 [case(DCERPC_PKT_REQUEST)]    dcerpc_request  request;
 232                 [case(DCERPC_PKT_PING)]           dcerpc_ping ping;
 233                 [case(DCERPC_PKT_RESPONSE)]   dcerpc_response response;
 234                 [case(DCERPC_PKT_FAULT)]          dcerpc_fault fault;
 235                 [case(DCERPC_PKT_WORKING)]        dcerpc_working working;
 236                 [case(DCERPC_PKT_NOCALL)]     dcerpc_fack nocall;
 237                 [case(DCERPC_PKT_REJECT)]     dcerpc_fault reject;
 238                 [case(DCERPC_PKT_ACK)]        dcerpc_ack ack;
 239                 [case(DCERPC_PKT_CL_CANCEL)]  dcerpc_cl_cancel cl_cancel;
 240                 [case(DCERPC_PKT_FACK)]       dcerpc_fack fack;
 241                 [case(DCERPC_PKT_CANCEL_ACK)] dcerpc_cancel_ack cancel_ack;
 242                 [case(DCERPC_PKT_BIND)]       dcerpc_bind     bind;
 243                 [case(DCERPC_PKT_BIND_ACK)]   dcerpc_bind_ack bind_ack;
 244                 [case(DCERPC_PKT_BIND_NAK)]   dcerpc_bind_nak bind_nak;
 245                 [case(DCERPC_PKT_ALTER)]      dcerpc_bind     alter;
 246                 [case(DCERPC_PKT_ALTER_RESP)] dcerpc_bind_ack alter_resp;
 247                 [case(DCERPC_PKT_SHUTDOWN)]   dcerpc_shutdown shutdown;
 248                 [case(DCERPC_PKT_CO_CANCEL)]  dcerpc_co_cancel co_cancel;
 249                 [case(DCERPC_PKT_ORPHANED)]   dcerpc_orphaned orphaned;
 250                 [case(DCERPC_PKT_AUTH3)]      dcerpc_auth3    auth3;
 251         } dcerpc_payload;
 252
 253         /* pfc_flags values */
 254         const uint8 DCERPC_PFC_FLAG_FIRST               = 0x01; /* First fragment */
 255         const uint8 DCERPC_PFC_FLAG_LAST                = 0x02; /* Last fragment */
 256         const uint8 DCERPC_PFC_FLAG_PENDING_CANCEL      = 0x04; /* Cancel was pending at sender */
 257         const uint8 DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN = DCERPC_PFC_FLAG_PENDING_CANCEL; /* depends on the pdu type */
 258         const uint8 DCERPC_PFC_FLAG_CONC_MPX            = 0x10; /* supports concurrent multiplexing of a single connection. */
 259         const uint8 DCERPC_PFC_FLAG_DID_NOT_EXECUTE     = 0x20; /* on a fault it means the server hasn't done anything */
 260         const uint8 DCERPC_PFC_FLAG_MAYBE               = 0x40; /* `maybe' call semantics requested */
 261         const uint8 DCERPC_PFC_FLAG_OBJECT_UUID         = 0x80; /* on valid guid is in the optional object field */
 262
 263         /* these offsets are needed by the signing code */
 264         const uint8 DCERPC_PFC_OFFSET      =  3;
 265         const uint8 DCERPC_DREP_OFFSET     =  4;
 266         const uint8 DCERPC_FRAG_LEN_OFFSET =  8;
 267         const uint8 DCERPC_AUTH_LEN_OFFSET = 10;
 268
 269         /* little-endian flag */
 270         const uint8 DCERPC_DREP_LE  = 0x10;
 271
 272         typedef [public] struct {
 273                 uint8 rpc_vers;         /* RPC version */
 274                 uint8 rpc_vers_minor;   /* Minor version */
 275                 dcerpc_pkt_type ptype;  /* Packet type */
 276                 uint8 pfc_flags;        /* Fragmentation flags */
 277                 uint8 drep[4];          /* NDR data representation */
 278                 uint16 frag_length;     /* Total length of fragment */
 279                 uint16 auth_length;     /* authenticator length */
 280                 uint32 call_id;         /* Call identifier */
 281                 [switch_is(ptype)] dcerpc_payload u;
 282         } ncacn_packet;
 283
 284         typedef [public] struct {
 285                 uint8 rpc_vers;         /* RPC version (4) */
 286                 uint8 ptype;
 287                 uint8 pfc_flags;
 288                 uint8 ncadg_flags;
 289                 uint8 drep[3];
 290                 uint8 serial_high;
 291                 GUID object;
 292                 GUID iface;
 293                 GUID activity;
 294                 uint32 server_boot; /* Server boot time */
 295                 uint32 iface_version;
 296                 uint32 seq_num;
 297                 uint16 opnum;
 298                 uint16 ihint;
 299                 uint16 ahint;
 300                 uint16 len;
 301                 uint16 fragnum;
 302                 uint8 auth_proto;
 303                 uint8 serial_low;
 304                 [switch_is(ptype)] dcerpc_payload u;
 305         } ncadg_packet;
 306 }