source: trunk/server/librpc/idl/dcerpc.idl@ 808

Last change on this file since 808 was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 16.7 KB
Line 
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*/
11import "misc.idl";
12
13interface 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}
Note: See TracBrowser for help on using the repository browser.