Finish removal of iconv_convenience in public API's.
[bbaumbach/samba-autobuild/.git] / librpc / idl / nbt.idl
1 #include "idl_types.h"
2
3 /*
4    IDL structures for NBT operations
5
6    NBT is not traditionally encoded using IDL/NDR. This is a bit of an
7    experiment, and I may well switch us back to a more traditional
8    encoding if it doesn't work out
9 */
10
11 import "misc.idl", "security.idl", "svcctl.idl", "samr.idl";
12 [
13         helper("../libcli/netlogon.h", "../libcli/nbt/libnbt.h")
14 ]
15 interface nbt
16 {
17         const int NBT_NAME_SERVICE_PORT  = 137;
18         const int NBT_DGRAM_SERVICE_PORT = 138;
19
20         typedef [bitmap16bit] bitmap {
21                 NBT_RCODE                   = 0x000F,
22                 NBT_FLAG_BROADCAST          = 0x0010,
23                 NBT_FLAG_RECURSION_AVAIL    = 0x0080,
24                 NBT_FLAG_RECURSION_DESIRED  = 0x0100,
25                 NBT_FLAG_TRUNCATION         = 0x0200,
26                 NBT_FLAG_AUTHORITIVE        = 0x0400,
27                 NBT_OPCODE                  = 0x7800,
28                 NBT_FLAG_REPLY              = 0x8000
29         } nbt_operation;
30
31         /* the opcodes are in the operation field, masked with
32            NBT_OPCODE */
33         typedef enum {
34                 NBT_OPCODE_QUERY          =  (0x0<<11),
35                 NBT_OPCODE_REGISTER       =  (0x5<<11),
36                 NBT_OPCODE_RELEASE        =  (0x6<<11),
37                 NBT_OPCODE_WACK           =  (0x7<<11),
38                 NBT_OPCODE_REFRESH        =  (0x8<<11),
39                 NBT_OPCODE_REFRESH2       =  (0x9<<11),
40                 NBT_OPCODE_MULTI_HOME_REG =  (0xf<<11)
41         } nbt_opcode;
42
43         /* rcode values */
44         typedef enum {
45                 NBT_RCODE_OK  = 0x0,
46                 NBT_RCODE_FMT = 0x1,
47                 NBT_RCODE_SVR = 0x2,
48                 NBT_RCODE_NAM = 0x3,
49                 NBT_RCODE_IMP = 0x4,
50                 NBT_RCODE_RFS = 0x5,
51                 NBT_RCODE_ACT = 0x6,
52                 NBT_RCODE_CFT = 0x7
53         } nbt_rcode;
54
55         /* we support any 8bit name type, but by defining the common
56            ones here we get better debug displays */
57         typedef [enum8bit] enum {
58                 NBT_NAME_CLIENT   = 0x00,
59                 NBT_NAME_MS       = 0x01,
60                 NBT_NAME_USER     = 0x03,
61                 NBT_NAME_SERVER   = 0x20,
62                 NBT_NAME_PDC      = 0x1B,
63                 NBT_NAME_LOGON    = 0x1C,
64                 NBT_NAME_MASTER   = 0x1D,
65                 NBT_NAME_BROWSER  = 0x1E
66         } nbt_name_type;
67
68         /* the ndr parser for nbt_name is separately defined in
69            nbtname.c (along with the parsers for nbt_string) */
70         typedef [public,nopull,nopush] struct {
71                 string        name;
72                 string        scope;
73                 nbt_name_type type;
74         } nbt_name;
75
76         typedef [public,enum16bit] enum {
77                 NBT_QCLASS_IP = 0x01
78         } nbt_qclass;
79
80         typedef [public,enum16bit] enum {
81                 NBT_QTYPE_ADDRESS     = 0x0001,
82                 NBT_QTYPE_NAMESERVICE = 0x0002,
83                 NBT_QTYPE_NULL        = 0x000A,
84                 NBT_QTYPE_NETBIOS     = 0x0020,
85                 NBT_QTYPE_STATUS      = 0x0021
86         } nbt_qtype;
87
88         typedef struct {
89                 nbt_name   name;
90                 nbt_qtype  question_type;
91                 nbt_qclass question_class;
92         } nbt_name_question;
93
94         /* these are the possible values of the NBT_NM_OWNER_TYPE
95            field */
96         typedef enum {
97                 NBT_NODE_B = 0x0000,
98                 NBT_NODE_P = 0x2000,
99                 NBT_NODE_M = 0x4000,
100                 NBT_NODE_H = 0x6000
101         } nbt_node_type;
102
103         typedef [bitmap16bit] bitmap {
104                 NBT_NM_PERMANENT        = 0x0200,
105                 NBT_NM_ACTIVE           = 0x0400,
106                 NBT_NM_CONFLICT         = 0x0800,
107                 NBT_NM_DEREGISTER       = 0x1000,
108                 NBT_NM_OWNER_TYPE       = 0x6000,
109                 NBT_NM_GROUP            = 0x8000
110         } nb_flags;
111
112         typedef struct {
113                 nb_flags nb_flags;
114                 ipv4address ipaddr;
115         } nbt_rdata_address;
116
117         typedef struct {
118                 uint16 length;
119                 nbt_rdata_address addresses[length/6];
120         } nbt_rdata_netbios;
121
122         typedef struct {
123                 uint8 unit_id[6];
124                 uint8 jumpers;
125                 uint8 test_result;
126                 uint16 version_number;
127                 uint16 period_of_statistics;
128                 uint16 number_of_crcs;
129                 uint16 number_alignment_errors;
130                 uint16 number_of_collisions;
131                 uint16 number_send_aborts;
132                 uint32 number_good_sends;
133                 uint32 number_good_receives;
134                 uint16 number_retransmits;
135                 uint16 number_no_resource_conditions;
136                 uint16 number_free_command_blocks;
137                 uint16 total_number_command_blocks;
138                 uint16 max_total_number_command_blocks;
139                 uint16 number_pending_sessions;
140                 uint16 max_number_pending_sessions;
141                 uint16 max_total_sessions_possible;
142                 uint16 session_data_packet_size;
143         } nbt_statistics;
144
145         typedef struct {
146                 [charset(DOS)] uint8 name[15];
147                 nbt_name_type type;
148                 nb_flags  nb_flags;
149         } nbt_status_name;
150
151         typedef struct {
152                 [value(num_names * 18 + 47)] uint16 length;
153                 uint8 num_names;
154                 nbt_status_name names[num_names];
155                 nbt_statistics  statistics;
156         } nbt_rdata_status;
157
158         typedef struct {
159                 uint16 length;
160                 uint8  data[length];
161         } nbt_rdata_data;
162
163         typedef [nodiscriminant,public] union {
164                 [case(NBT_QTYPE_NETBIOS)] nbt_rdata_netbios netbios;
165                 [case(NBT_QTYPE_STATUS)]  nbt_rdata_status status;
166                 [default]                 nbt_rdata_data   data;
167         } nbt_rdata;
168
169 /*
170  * this macro works around the problem
171  * that we need to use nbt_rdata_data
172  * together with NBT_QTYPE_NETBIOS
173  * for WACK replies
174  */
175         typedef [flag(LIBNDR_PRINT_ARRAY_HEX),nopush] struct {
176                 nbt_name   name;
177                 nbt_qtype  rr_type;
178                 nbt_qclass rr_class;
179                 uint32     ttl;
180                 [switch_is(rr_type)] nbt_rdata rdata;
181         } nbt_res_rec;
182
183         typedef [flag(NDR_NOALIGN|NDR_BIG_ENDIAN|NDR_PAHEX),public] struct {
184                 uint16            name_trn_id;
185                 nbt_operation     operation;
186                 uint16            qdcount;
187                 uint16            ancount;
188                 uint16            nscount;
189                 uint16            arcount;
190                 nbt_name_question questions[qdcount];
191                 nbt_res_rec       answers[ancount];
192                 nbt_res_rec       nsrecs[nscount];
193                 nbt_res_rec       additional[arcount];
194                 [flag(NDR_REMAINING)] DATA_BLOB padding;
195         } nbt_name_packet;
196
197
198         /*
199           NBT DGRAM packets (UDP/138)
200         */
201
202         typedef [enum8bit] enum {
203                 DGRAM_DIRECT_UNIQUE  = 0x10,
204                 DGRAM_DIRECT_GROUP   = 0x11,
205                 DGRAM_BCAST          = 0x12,
206                 DGRAM_ERROR          = 0x13,
207                 DGRAM_QUERY          = 0x14,
208                 DGRAM_QUERY_POSITIVE = 0x15,
209                 DGRAM_QUERY_NEGATIVE = 0x16
210         } dgram_msg_type;
211
212         typedef [bitmap8bit] bitmap {
213                 DGRAM_FLAG_MORE         = 0x01,
214                 DGRAM_FLAG_FIRST        = 0x02,
215                 DGRAM_FLAG_NODE_TYPE    = 0x0C
216         } dgram_flags;
217
218         typedef [enum8bit] enum {
219                 DGRAM_NODE_B    = 0x00,
220                 DGRAM_NODE_P    = 0x04,
221                 DGRAM_NODE_M    = 0x08,
222                 DGRAM_NODE_NBDD = 0x0C
223         } dgram_node_type;
224
225         /* a dgram_message is the main dgram body in general use */
226
227         /* the most common datagram type is a SMB_TRANSACTION
228            operation, where a SMB packet is used in the data section
229            of a dgram_message to hold a trans request, which in turn
230            holds a small command structure. It's a very strange beast
231            indeed. To make the code cleaner we define a basic SMB
232            packet in IDL here. This is not a general purpose SMB
233            packet, and won't be used in the core SMB client/server
234            code, but it does make working with these types of dgrams
235            easier */
236
237         const string NBT_MAILSLOT_NETLOGON = "\\MAILSLOT\\NET\\NETLOGON";
238         const string NBT_MAILSLOT_NTLOGON  = "\\MAILSLOT\\NET\\NTLOGON";
239         const string NBT_MAILSLOT_GETDC    = "\\MAILSLOT\\NET\\GETDC";
240         const string NBT_MAILSLOT_BROWSE   = "\\MAILSLOT\\BROWSE";
241
242         typedef [enum8bit] enum {
243                 SMB_TRANSACTION = 0x25
244         } smb_command;
245
246         typedef struct {
247                 [range(17,17),value(17)] uint8 wct;
248                 uint16                      total_param_count;
249                 uint16                      total_data_count;
250                 uint16                      max_param_count;
251                 uint16                      max_data_count;
252                 uint8                       max_setup_count;
253                 uint8                       pad;
254                 uint16                      trans_flags;
255                 uint32                      timeout;
256                 uint16                      reserved;
257                 uint16                      param_count;
258                 uint16                      param_offset;
259                 uint16                      data_count;
260                 uint16                      data_offset;
261                 [range(3,3),value(3)] uint8 setup_count;
262                 uint8                       pad2;
263                 uint16                      opcode;
264                 uint16                      priority;
265                 uint16                      _class;
266                 [value(strlen(mailslot_name)+1+data.length)]
267                       uint16                byte_count;
268                 astring                     mailslot_name;
269                 [flag(NDR_REMAINING)]       DATA_BLOB data;
270         } smb_trans_body;
271
272         typedef [nodiscriminant] union {
273                 [case(SMB_TRANSACTION)] smb_trans_body trans;
274         } smb_body;
275
276
277         typedef [flag(NDR_NOALIGN|NDR_LITTLE_ENDIAN|NDR_PAHEX),public] struct {
278                 smb_command                smb_command;
279                 uint8                      err_class;
280                 uint8                      pad;
281                 uint16                     err_code;
282                 uint8                      flags;
283                 uint16                     flags2;
284                 uint16                     pid_high;
285                 uint8                      signature[8];
286                 uint16                     reserved;
287                 uint16                     tid;
288                 uint16                     pid;
289                 uint16                     vuid;
290                 uint16                     mid;
291                 [switch_is(smb_command)]   smb_body body;
292         } dgram_smb_packet;
293
294         const uint32 DGRAM_SMB = 0xff534d42; /* 0xffSMB */
295
296         typedef [nodiscriminant] union {
297                 [case(DGRAM_SMB)] dgram_smb_packet smb;
298         } dgram_message_body;
299
300         typedef struct {
301                 uint16          length;
302                 uint16          offset;
303                 nbt_name        source_name;
304                 nbt_name        dest_name;
305                 uint32          dgram_body_type;
306                 [switch_is(dgram_body_type)] dgram_message_body body;
307         } dgram_message;
308
309         typedef [enum8bit] enum {
310                 DGRAM_ERROR_NAME_NOT_PRESENT = 0x82,
311                 DGRAM_ERROR_INVALID_SOURCE   = 0x83,
312                 DGRAM_ERROR_INVALID_DEST     = 0x84
313         } dgram_err_code;
314
315         typedef [nodiscriminant] union {
316                 [case(DGRAM_DIRECT_UNIQUE)]   dgram_message  msg;
317                 [case(DGRAM_DIRECT_GROUP)]    dgram_message  msg;
318                 [case(DGRAM_BCAST)]           dgram_message  msg;
319                 [case(DGRAM_ERROR)]           dgram_err_code error;
320                 [case(DGRAM_QUERY)]           nbt_name       dest_name;
321                 [case(DGRAM_QUERY_POSITIVE)]  nbt_name       dest_name;
322                 [case(DGRAM_QUERY_NEGATIVE)]  nbt_name       dest_name;
323         } dgram_data;
324
325         typedef [flag(NDR_NOALIGN|NDR_BIG_ENDIAN|NDR_PAHEX),public] struct {
326                 dgram_msg_type msg_type;
327                 dgram_flags    flags;
328                 uint16         dgram_id;
329                 ipv4address    src_addr;
330                 uint16         src_port;
331                 [switch_is(msg_type)] dgram_data data;
332         } nbt_dgram_packet;
333
334
335         /******************************************
336          * \MAILSLOT\NET\NETLOGON mailslot requests
337          * and
338          * \MAILSLOT\NET\NTLOGON mailslot requests
339          */
340
341         typedef [public,gensize] struct {
342                 uint32                  sockaddr_family;
343                 [flag(NDR_BIG_ENDIAN)]  ipv4address pdc_ip;
344                 [flag(NDR_REMAINING)]   DATA_BLOB remaining;
345         } nbt_sockaddr;
346
347         typedef [bitmap32bit,public] bitmap {
348                 NBT_SERVER_PDC                          = 0x00000001,
349                 NBT_SERVER_GC                           = 0x00000004,
350                 NBT_SERVER_LDAP                         = 0x00000008,
351                 NBT_SERVER_DS                           = 0x00000010,
352                 NBT_SERVER_KDC                          = 0x00000020,
353                 NBT_SERVER_TIMESERV                     = 0x00000040,
354                 NBT_SERVER_CLOSEST                      = 0x00000080,
355                 NBT_SERVER_WRITABLE                     = 0x00000100,
356                 NBT_SERVER_GOOD_TIMESERV                = 0x00000200,
357                 NBT_SERVER_NDNC                         = 0x00000400,
358                 NBT_SERVER_SELECT_SECRET_DOMAIN_6       = 0x00000800,
359                 NBT_SERVER_FULL_SECRET_DOMAIN_6         = 0x00001000,
360                 NBT_SERVER_ADS_WEB_SERVICE              = 0x00002000,
361                 NBT_SERVER_HAS_DNS_NAME                 = 0x20000000,
362                 NBT_SERVER_IS_DEFAULT_NC                = 0x40000000,
363                 NBT_SERVER_FOREST_ROOT                  = 0x80000000
364         } nbt_server_type;
365
366         typedef [bitmap32bit,public] bitmap {
367                 NETLOGON_NT_VERSION_1                   = 0x00000001,
368                 NETLOGON_NT_VERSION_5                   = 0x00000002,
369                 NETLOGON_NT_VERSION_5EX                 = 0x00000004,
370                 NETLOGON_NT_VERSION_5EX_WITH_IP         = 0x00000008,
371                 NETLOGON_NT_VERSION_WITH_CLOSEST_SITE   = 0x00000010,
372                 NETLOGON_NT_VERSION_AVIOD_NT4EMUL       = 0x01000000,
373                 NETLOGON_NT_VERSION_PDC                 = 0x10000000,
374                 NETLOGON_NT_VERSION_IP                  = 0x20000000,
375                 NETLOGON_NT_VERSION_LOCAL               = 0x40000000,
376                 NETLOGON_NT_VERSION_GC                  = 0x80000000
377         } netlogon_nt_version_flags;
378
379         typedef [enum16bit,public] enum {
380                 LOGON_PRIMARY_QUERY               = 7,  /* Was also NETLOGON_QUERY_FOR_PDC */
381                 NETLOGON_ANNOUNCE_UAS             = 10,
382                 NETLOGON_RESPONSE_FROM_PDC        = 12,
383                 LOGON_SAM_LOGON_REQUEST           = 18, /* Was also NETLOGON_QUERY_FOR_PDC2, NTLOGON_SAM_LOGON */
384                 LOGON_SAM_LOGON_RESPONSE          = 19, /* Was also NTLOGON_SAM_LOGON_REPLY */
385                 LOGON_SAM_LOGON_PAUSE_RESPONSE    = 20,
386                 LOGON_SAM_LOGON_USER_UNKNOWN      = 21, /* Was also NTLOGON_SAM_LOGON_REPLY15 */
387                 LOGON_SAM_LOGON_RESPONSE_EX       = 23,  /* was NETLOGON_RESPONSE_FROM_PDC2     */
388                 LOGON_SAM_LOGON_PAUSE_RESPONSE_EX = 24,
389                 LOGON_SAM_LOGON_USER_UNKNOWN_EX   = 25 /* was NETLOGON_RESPONSE_FROM_PDC_USER */
390         } netlogon_command;
391
392         typedef bitmap samr_AcctFlags samr_AcctFlags;
393
394         /* query to dc hand marshaled, as it has 'optional'
395          * parts */
396         typedef [nopull,nopush] struct {
397                 uint16               request_count;
398                 nstring              computer_name;
399                 nstring              user_name;
400                 astring              mailslot_name;
401                 samr_AcctFlags       acct_control;
402                 [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
403                 /* The manual alignment is required because this
404                  * structure is marked flag(NDR_NOALIGN) via the
405                  * nbt_netlogon_packet below.
406                  *
407                  * However, both MUST only be present if sid_size > 0
408                  */
409                 [flag(NDR_ALIGN4)]   DATA_BLOB _pad;
410                 [subcontext(0),subcontext_size(sid_size)] dom_sid0 sid;
411                 netlogon_nt_version_flags               nt_version;
412                 uint16               lmnt_token;
413                 uint16               lm20_token;
414         } NETLOGON_SAM_LOGON_REQUEST;
415
416         typedef [flag(NDR_NOALIGN),public] struct {
417                 netlogon_command command;
418                 nstring              pdc_name;
419                 nstring              user_name;
420                 nstring              domain_name;
421                 netlogon_nt_version_flags               nt_version;
422                 uint16               lmnt_token;
423                 uint16               lm20_token;
424         } NETLOGON_SAM_LOGON_RESPONSE_NT40;
425
426         typedef [flag(NDR_NOALIGN),public] struct {
427                 netlogon_command command;
428                 nstring              pdc_name;
429                 nstring              user_name;
430                 nstring              domain_name;
431                 GUID                 domain_uuid;
432                 GUID                 zero_uuid;
433                 nbt_string           forest;
434                 nbt_string           dns_domain;
435                 nbt_string           pdc_dns_name;
436                 ipv4address          pdc_ip;
437                 nbt_server_type      server_type;
438                 netlogon_nt_version_flags    nt_version;
439                 uint16               lmnt_token;
440                 uint16               lm20_token;
441         } NETLOGON_SAM_LOGON_RESPONSE;
442
443         /* response from pdc hand marshaled (we have an additional
444          * function that uses this structure), as it has 'optional'
445          * parts */
446         typedef [flag(NDR_NOALIGN),public] struct {
447                 netlogon_command command;
448                 uint16               sbz; /* From the docs */
449                 nbt_server_type      server_type;
450                 GUID                 domain_uuid;
451                 nbt_string           forest;
452                 nbt_string           dns_domain;
453                 nbt_string           pdc_dns_name;
454                 nbt_string           domain_name;
455                 nbt_string           pdc_name;
456                 nbt_string           user_name;
457                 nbt_string           server_site;
458                 nbt_string           client_site;
459
460                 /* Optional on NETLOGON_NT_VERSION_5EX_WITH_IP */
461                 [value(ndr_size_nbt_sockaddr(&sockaddr, ndr->flags))] uint8 sockaddr_size;
462                 [subcontext(0),subcontext_size(sockaddr_size)] nbt_sockaddr sockaddr;
463
464                 /* Optional on NETLOGON_NT_VERSION_WITH_CLOSEST_SITE */
465                 nbt_string           next_closest_site;
466
467                 netlogon_nt_version_flags               nt_version;
468                 uint16               lmnt_token;
469                 uint16               lm20_token;
470         } NETLOGON_SAM_LOGON_RESPONSE_EX;
471
472         /* query for pdc request */
473         typedef struct {
474                 astring              computer_name;
475                 astring              mailslot_name;
476                 [flag(NDR_ALIGN2)]   DATA_BLOB _pad;
477                 nstring              unicode_name;
478                 netlogon_nt_version_flags               nt_version;
479                 uint16               lmnt_token;
480                 uint16               lm20_token;
481         } nbt_netlogon_query_for_pdc;
482
483         /* response from pdc */
484         typedef [flag(NDR_NOALIGN),public] struct {
485                 netlogon_command command;
486                 astring pdc_name;
487                 [flag(NDR_ALIGN2)]   DATA_BLOB _pad;
488                 nstring              unicode_pdc_name;
489                 nstring              domain_name;
490                 netlogon_nt_version_flags               nt_version;
491                 uint16               lmnt_token;
492                 uint16               lm20_token;
493         } nbt_netlogon_response_from_pdc;
494
495         typedef enum netr_SamDatabaseID netr_SamDatabaseID;
496
497         /* used to announce SAM changes - MS-NRPC 2.2.1.5.1 */
498         typedef struct {
499                 netr_SamDatabaseID   db_index;
500                 hyper                serial;
501                 NTTIME               timestamp;
502         } nbt_db_change_info;
503
504         typedef struct {
505                 uint32           serial_lo;
506                 time_t           timestamp;
507                 uint32           pulse;
508                 uint32           random;
509                 astring          pdc_name;
510                 astring          domain;
511                 [flag(NDR_ALIGN2)] DATA_BLOB _pad;
512                 nstring          unicode_pdc_name;
513                 nstring          unicode_domain;
514                 uint32           db_count;
515                 nbt_db_change_info    dbchange[db_count];
516                 [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
517                 [subcontext(0),subcontext_size(sid_size)] dom_sid0 sid;
518                 uint32           message_format_version;
519                 uint32           message_token;
520         } NETLOGON_DB_CHANGE;
521
522         typedef [nodiscriminant] union {
523                 [case(LOGON_SAM_LOGON_REQUEST)]       NETLOGON_SAM_LOGON_REQUEST logon;
524                 [case(LOGON_PRIMARY_QUERY)] nbt_netlogon_query_for_pdc pdc;
525                 [case(NETLOGON_ANNOUNCE_UAS)] NETLOGON_DB_CHANGE uas;
526         } nbt_netlogon_request;
527
528 #if 0
529                 [case(NETLOGON_RESPONSE_FROM_PDC)] nbt_netlogon_response_from_pdc response;
530                 [case(NETLOGON_RESPONSE_FROM_PDC_USER)] nbt_netlogon_response_from_pdc2 response2;
531
532                 [case(LOGON_SAM_LOGON_PAUSE_RESPONSE)] NETLOGON_SAM_LOGON_RESPONSE reply;
533                 [case(LOGON_SAM_LOGON_RESPONSE)] NETLOGON_SAM_LOGON_RESPONSE reply;
534                 [case(LOGON_SAM_LOGON_USER_UNKNOWN)] NETLOGON_SAM_LOGON_RESPONSE reply;
535                 [case(LOGON_SAM_LOGON_RESPONSE_EX)] NETLOGON_SAM_LOGON_RESPONSE_EX reply_ex;
536                 [case(LOGON_SAM_LOGON_PAUSE_RESPONSE_EX)] NETLOGON_SAM_LOGON_RESPONSE_EX reply_ex;
537                 [case(LOGON_SAM_LOGON_USER_UNKNOWN_EX)] NETLOGON_SAM_LOGON_RESPONSE_EX reply_ex;
538 #endif
539
540         typedef [flag(NDR_NOALIGN),public] struct {
541                 netlogon_command command;
542                 [switch_is(command)] nbt_netlogon_request req;
543         } nbt_netlogon_packet;
544
545         /********************************************************/
546         /* \MAILSLOT\BROWSE mailslot requests                   */
547         /* for details see http://ubiqx.org/cifs/Browsing.html  */
548         /********************************************************/
549         typedef bitmap svcctl_ServerType svcctl_ServerType;
550
551         typedef [enum8bit] enum {
552                 HostAnnouncement        = 1,
553                 AnnouncementRequest     = 2,
554                 Election                = 8,
555                 GetBackupListReq        = 9,
556                 GetBackupListResp       = 10,
557                 BecomeBackup            = 11,
558                 DomainAnnouncement      = 12,
559                 MasterAnnouncement      = 13,
560                 ResetBrowserState       = 14,
561                 LocalMasterAnnouncement = 15
562         } nbt_browse_opcode;
563
564         typedef struct {
565                 uint8 UpdateCount;
566                 uint32 Periodicity;
567                 [charset(DOS)] uint8 ServerName[16];
568                 uint8 OSMajor;
569                 uint8 OSMinor;
570                 svcctl_ServerType ServerType;
571                 uint8 BroMajorVer;
572                 uint8 BroMinorVer;
573                 uint16 Signature;
574                 astring Comment;
575         } nbt_browse_host_announcement;
576
577         typedef struct {
578                 uint8 Unused;
579                 astring ResponseName;
580         } nbt_browse_announcement_request;
581
582         typedef struct {
583                 uint8 Version;
584                 uint32 Criteria;
585                 uint32 UpTime; /* In milliseconds */
586                 uint32 Reserved; /* Must be zero */
587                 astring ServerName;
588         } nbt_browse_election_request;
589
590         typedef struct {
591                 uint8 ReqCount;
592                 uint32 Token;
593         } nbt_browse_backup_list_request;
594
595         typedef struct {
596                 uint8 BackupCount;
597                 uint32 Token;
598                 nbt_name BackupServerList[BackupCount];/* TODO: this is wrong */
599         } nbt_browse_backup_list_response;
600
601         typedef struct {
602                 astring BrowserName;
603         } nbt_browse_become_backup;
604
605         typedef struct {
606                 uint8 UpdateCount;
607                 uint32 Periodicity;
608                 [charset(DOS)] uint8 ServerName[16];
609                 uint8 OSMajor;
610                 uint8 OSMinor;
611                 svcctl_ServerType ServerType;
612                 uint32 MysteriousField;
613                 astring Comment;
614         } nbt_browse_domain_announcement;
615
616         typedef struct {
617                 astring ServerName;
618         } nbt_browse_master_announcement;
619
620         typedef struct {
621                 uint8 Command;
622         } nbt_browse_reset_state;
623
624         typedef struct {
625                 uint8 UpdateCount;
626                 uint32 Periodicity;
627                 [charset(DOS)] uint8 ServerName[16];
628                 uint8 OSMajor;
629                 uint8 OSMinor;
630                 svcctl_ServerType ServerType;
631                 uint8 BroMajorVer;
632                 uint8 BroMinorVer;
633                 uint16 Signature;
634                 astring Comment;
635         } nbt_browse_local_master_announcement;
636
637         typedef [nodiscriminant] union {
638                 [case(HostAnnouncement)] nbt_browse_host_announcement host_annoucement;
639                 [case(AnnouncementRequest)] nbt_browse_announcement_request announcement_request;
640                 [case(Election)] nbt_browse_election_request election_request;
641                 [case(GetBackupListReq)] nbt_browse_backup_list_request backup_list_request;
642                 [case(GetBackupListResp)] nbt_browse_backup_list_response backup_list_response;
643                 [case(BecomeBackup)] nbt_browse_become_backup become_backup;
644                 [case(DomainAnnouncement)] nbt_browse_domain_announcement domain_announcement;
645                 [case(MasterAnnouncement)] nbt_browse_master_announcement master_announcement;
646                 [case(ResetBrowserState)] nbt_browse_reset_state reset_browser_state;
647                 [case(LocalMasterAnnouncement)] nbt_browse_local_master_announcement local_master_announcement;
648         } nbt_browse_payload;
649
650         typedef [public,flag(NDR_NOALIGN)] struct {
651                 nbt_browse_opcode opcode;
652                 [switch_is(opcode)] nbt_browse_payload payload;
653         } nbt_browse_packet;
654 }