idl: Use typedef rather than declare.
[ira/wip.git] / source / 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 "security.idl", "svcctl.idl";
12 [
13 helper("libcli/nbt/nbtname.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 [enum16bit] enum {
77                 NBT_QCLASS_IP = 0x01
78         } nbt_qclass;
79
80         typedef [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                 astring15 name;
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] 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 arround the problem
171  * that we need to use nbt_rdata_data
172  * together with NBT_QTYPE_NETBIOS
173  * for WACK replies
174  */
175 #define NBT_RES_REC_LEVEL(rr_type, rdata) (\
176         (((rr_type) == NBT_QTYPE_NETBIOS) && \
177         talloc_check_name(ndr, "struct ndr_push") && \
178         ((rdata).data.length == 2)) \
179         ? 0 : rr_type)
180
181         typedef [flag(LIBNDR_PRINT_ARRAY_HEX)] struct {
182                 nbt_name   name;
183                 nbt_qtype  rr_type;
184                 nbt_qclass rr_class;
185                 uint32     ttl;
186                 [switch_is(NBT_RES_REC_LEVEL(rr_type, rdata))] nbt_rdata rdata;
187         } nbt_res_rec;
188
189         typedef [flag(NDR_NOALIGN|NDR_BIG_ENDIAN|NDR_PAHEX),public] struct {
190                 uint16            name_trn_id;
191                 nbt_operation     operation;
192                 uint16            qdcount;
193                 uint16            ancount;
194                 uint16            nscount;
195                 uint16            arcount;
196                 nbt_name_question questions[qdcount];
197                 nbt_res_rec       answers[ancount];
198                 nbt_res_rec       nsrecs[nscount];
199                 nbt_res_rec       additional[arcount];
200                 [flag(NDR_REMAINING)] DATA_BLOB padding;
201         } nbt_name_packet;
202
203
204         /*
205           NBT DGRAM packets (UDP/138)
206         */
207
208         typedef [enum8bit] enum {
209                 DGRAM_DIRECT_UNIQUE  = 0x10,
210                 DGRAM_DIRECT_GROUP   = 0x11,
211                 DGRAM_BCAST          = 0x12,
212                 DGRAM_ERROR          = 0x13,
213                 DGRAM_QUERY          = 0x14,
214                 DGRAM_QUERY_POSITIVE = 0x15,
215                 DGRAM_QUERY_NEGATIVE = 0x16
216         } dgram_msg_type;
217
218         typedef [bitmap8bit] bitmap {
219                 DGRAM_FLAG_MORE         = 0x01,
220                 DGRAM_FLAG_FIRST        = 0x02,
221                 DGRAM_FLAG_NODE_TYPE    = 0x0C
222         } dgram_flags;
223
224         typedef [enum8bit] enum {
225                 DGRAM_NODE_B    = 0x00,
226                 DGRAM_NODE_P    = 0x04,
227                 DGRAM_NODE_M    = 0x08,
228                 DGRAM_NODE_NBDD = 0x0C
229         } dgram_node_type;
230
231         /* a dgram_message is the main dgram body in general use */
232
233         /* the most common datagram type is a SMB_TRANSACTION
234            operation, where a SMB packet is used in the data section
235            of a dgram_message to hold a trans request, which in turn
236            holds a small command structure. It's a very strange beast
237            indeed. To make the code cleaner we define a basic SMB
238            packet in IDL here. This is not a general purpose SMB
239            packet, and won't be used in the core SMB client/server
240            code, but it does make working with these types of dgrams
241            easier */
242
243         const string NBT_MAILSLOT_NETLOGON = "\\MAILSLOT\\NET\\NETLOGON";
244         const string NBT_MAILSLOT_NTLOGON  = "\\MAILSLOT\\NET\\NTLOGON";
245         const string NBT_MAILSLOT_GETDC    = "\\MAILSLOT\\NET\\GETDC";
246         const string NBT_MAILSLOT_BROWSE   = "\\MAILSLOT\\BROWSE";
247
248         typedef [enum8bit] enum {
249                 SMB_TRANSACTION = 0x25
250         } smb_command;
251
252         typedef struct {
253                 [range(17,17),value(17)] uint8 wct;
254                 uint16                      total_param_count;
255                 uint16                      total_data_count;
256                 uint16                      max_param_count;
257                 uint16                      max_data_count;
258                 uint8                       max_setup_count;
259                 uint8                       pad;
260                 uint16                      trans_flags;
261                 uint32                      timeout;
262                 uint16                      reserved;
263                 uint16                      param_count;
264                 uint16                      param_offset;
265                 uint16                      data_count;
266                 uint16                      data_offset;
267                 [range(3,3),value(3)] uint8 setup_count;
268                 uint8                       pad2;
269                 uint16                      opcode;
270                 uint16                      priority;
271                 uint16                      class;
272                 [value(strlen(mailslot_name)+1+data.length)] 
273                       uint16                byte_count;
274                 astring                     mailslot_name;
275                 [flag(NDR_REMAINING)]       DATA_BLOB data;
276         } smb_trans_body;
277
278         typedef [nodiscriminant] union {
279                 [case(SMB_TRANSACTION)] smb_trans_body trans;
280         } smb_body;
281
282
283         typedef [flag(NDR_NOALIGN|NDR_LITTLE_ENDIAN|NDR_PAHEX),public] struct {
284                 smb_command                smb_command;
285                 uint8                      err_class;
286                 uint8                      pad;
287                 uint16                     err_code;
288                 uint8                      flags;
289                 uint16                     flags2;
290                 uint16                     pid_high;
291                 uint8                      signature[8];
292                 uint16                     reserved;
293                 uint16                     tid;
294                 uint16                     pid;
295                 uint16                     vuid;
296                 uint16                     mid;
297                 [switch_is(smb_command)]   smb_body body;
298         } dgram_smb_packet;
299
300         const uint32 DGRAM_SMB = 0xff534d42; /* 0xffSMB */
301
302         typedef [nodiscriminant] union {
303                 [case(DGRAM_SMB)] dgram_smb_packet smb;
304         } dgram_message_body;
305
306         typedef struct {
307                 uint16          length;
308                 uint16          offset;
309                 nbt_name        source_name;
310                 nbt_name        dest_name;
311                 uint32          dgram_body_type;
312                 [switch_is(dgram_body_type)] dgram_message_body body;
313         } dgram_message;
314
315         typedef [enum8bit] enum {
316                 DGRAM_ERROR_NAME_NOT_PRESENT = 0x82,
317                 DGRAM_ERROR_INVALID_SOURCE   = 0x83,
318                 DGRAM_ERROR_INVALID_DEST     = 0x84
319         } dgram_err_code;
320
321         typedef [nodiscriminant] union {
322                 [case(DGRAM_DIRECT_UNIQUE)]   dgram_message  msg;
323                 [case(DGRAM_DIRECT_GROUP)]    dgram_message  msg;
324                 [case(DGRAM_BCAST)]           dgram_message  msg;
325                 [case(DGRAM_ERROR)]           dgram_err_code error;
326                 [case(DGRAM_QUERY)]           nbt_name       dest_name;
327                 [case(DGRAM_QUERY_POSITIVE)]  nbt_name       dest_name;
328                 [case(DGRAM_QUERY_NEGATIVE)]  nbt_name       dest_name;
329         } dgram_data;
330
331         typedef [flag(NDR_NOALIGN|NDR_BIG_ENDIAN|NDR_PAHEX),public] struct {
332                 dgram_msg_type msg_type;
333                 dgram_flags    flags;
334                 uint16         dgram_id;
335                 ipv4address    src_addr;
336                 uint16         src_port;
337                 [switch_is(msg_type)] dgram_data data;
338         } nbt_dgram_packet;
339
340
341         /*******************************************/
342         /* \MAILSLOT\NET\NETLOGON mailslot requests */
343         typedef enum {
344                 NETLOGON_QUERY_FOR_PDC           = 0x7, 
345                 NETLOGON_ANNOUNCE_UAS            = 0xa,
346                 NETLOGON_RESPONSE_FROM_PDC       = 0xc,
347                 NETLOGON_QUERY_FOR_PDC2          = 0x12,
348                 NETLOGON_RESPONSE_FROM_PDC2      = 0x17,
349                 NETLOGON_RESPONSE_FROM_PDC_USER  = 0x19
350         } nbt_netlogon_command;
351
352         /* query for pdc request */
353         typedef struct {
354                 astring              computer_name;
355                 astring              mailslot_name;
356                 [flag(NDR_ALIGN2)]   DATA_BLOB _pad;
357                 nstring              unicode_name;
358                 uint32               nt_version;
359                 uint16               lmnt_token;
360                 uint16               lm20_token;
361         } nbt_netlogon_query_for_pdc;
362
363         /* query for pdc request - new style */
364         typedef struct {
365                 uint16               request_count;
366                 nstring              computer_name;
367                 nstring              user_name;
368                 astring              mailslot_name;
369                 uint32               unknown[2];
370                 uint32               nt_version;
371                 uint16               lmnt_token;
372                 uint16               lm20_token;
373         } nbt_netlogon_query_for_pdc2;
374
375         /* response from pdc */
376         typedef struct {
377                 astring pdc_name;
378                 [flag(NDR_ALIGN2)]   DATA_BLOB _pad;
379                 nstring              unicode_pdc_name;
380                 nstring              domain_name;
381                 uint32               nt_version;
382                 uint16               lmnt_token;
383                 uint16               lm20_token;
384         } nbt_netlogon_response_from_pdc;
385
386         typedef [bitmap32bit] bitmap {
387                 NBT_SERVER_PDC           = 0x00000001,
388                 NBT_SERVER_GC            = 0x00000004,
389                 NBT_SERVER_LDAP          = 0x00000008,
390                 NBT_SERVER_DS            = 0x00000010,
391                 NBT_SERVER_KDC           = 0x00000020,
392                 NBT_SERVER_TIMESERV      = 0x00000040,
393                 NBT_SERVER_CLOSEST       = 0x00000080,
394                 NBT_SERVER_WRITABLE      = 0x00000100, 
395                 NBT_SERVER_GOOD_TIMESERV = 0x00000200
396         } nbt_server_type;
397
398         /* response from pdc - type2 */
399         typedef struct {
400                 [flag(NDR_ALIGN4)]   DATA_BLOB _pad;
401                 nbt_server_type      server_type;
402                 GUID                 domain_uuid;
403                 nbt_string           forest;
404                 nbt_string           dns_domain;
405                 nbt_string           pdc_dns_name;
406                 nbt_string           domain;
407                 nbt_string           pdc_name;
408                 nbt_string           user_name;
409                 nbt_string           server_site;
410                 nbt_string           client_site;
411                 uint8                unknown;
412                 uint32               unknown2;
413                 [flag(NDR_BIG_ENDIAN)] 
414                   ipv4address          pdc_ip;
415                 uint32               unknown3[2];
416                 uint32               nt_version;
417                 uint16               lmnt_token;
418                 uint16               lm20_token;
419         } nbt_netlogon_response_from_pdc2;
420
421         typedef enum netr_SamDatabaseID netr_SamDatabaseID;
422
423         /* announce change to UAS or SAM */
424         typedef struct {
425                 netr_SamDatabaseID   db_index;
426                 hyper                serial;
427                 NTTIME               timestamp;
428         } nbt_db_change;
429
430         /* used to announce SAM changes */
431         typedef struct {
432                 uint32           serial_lo;
433                 time_t           timestamp;
434                 uint32           pulse;
435                 uint32           random;
436                 astring          pdc_name;
437                 astring          domain;
438                 [flag(NDR_ALIGN2)] DATA_BLOB _pad;
439                 nstring          unicode_pdc_name;
440                 nstring          unicode_domain;
441                 uint32           db_count;
442                 nbt_db_change    dbchange[db_count];
443                 [value(ndr_size_dom_sid(&sid, ndr->flags))] uint32 sid_size;
444                 [flag(NDR_ALIGN4)] DATA_BLOB _pad2;
445                 dom_sid          sid;
446                 uint32           nt_version;
447                 uint16           lmnt_token;
448                 uint16           lm20_token;
449         } nbt_netlogon_announce_uas;
450
451         typedef [nodiscriminant] union {
452                 [case(NETLOGON_QUERY_FOR_PDC)] nbt_netlogon_query_for_pdc pdc;
453                 [case(NETLOGON_QUERY_FOR_PDC2)] nbt_netlogon_query_for_pdc2 pdc2;
454                 [case(NETLOGON_ANNOUNCE_UAS)] nbt_netlogon_announce_uas uas;
455                 [case(NETLOGON_RESPONSE_FROM_PDC)] nbt_netlogon_response_from_pdc response;
456                 [case(NETLOGON_RESPONSE_FROM_PDC2)] nbt_netlogon_response_from_pdc2 response2;
457                 [case(NETLOGON_RESPONSE_FROM_PDC_USER)] nbt_netlogon_response_from_pdc2 response2;
458         } nbt_netlogon_request;
459
460         typedef [flag(NDR_NOALIGN),public] struct {
461                 nbt_netlogon_command command;
462                 [switch_is(command)] nbt_netlogon_request req;
463         } nbt_netlogon_packet;
464
465         /*******************************************/
466         /* CLDAP netlogon response                 */
467
468         /* note that these structures are very similar to, but not
469            quite identical to, the netlogon structures above */
470
471         typedef struct {
472                 uint16               type;
473                 nstring              pdc_name;
474                 nstring              user_name;
475                 nstring              domain_name;
476                 [value(1)] uint32    nt_version;
477                 uint16               lmnt_token;
478                 uint16               lm20_token;                
479         } nbt_cldap_netlogon_1;
480
481         typedef struct {
482                 uint16               type;
483                 nstring              pdc_name;
484                 nstring              user_name;
485                 nstring              domain_name;
486                 GUID                 domain_uuid;
487                 GUID                 unknown_uuid;
488                 nbt_string           forest;
489                 nbt_string           dns_domain;
490                 nbt_string           pdc_dns_name;
491                 ipv4address          pdc_ip;
492                 nbt_server_type      server_type;
493                 [value(3)] uint32    nt_version;
494                 uint16               lmnt_token;
495                 uint16               lm20_token;                
496         } nbt_cldap_netlogon_3;
497
498         typedef struct {
499                 uint32               type;
500                 nbt_server_type      server_type;
501                 GUID                 domain_uuid;
502                 nbt_string           forest;
503                 nbt_string           dns_domain;
504                 nbt_string           pdc_dns_name;
505                 nbt_string           domain;
506                 nbt_string           pdc_name;
507                 nbt_string           user_name;
508                 nbt_string           server_site;
509                 nbt_string           client_site;
510                 [value(5)] uint32    nt_version;
511                 uint16               lmnt_token;
512                 uint16               lm20_token;
513         } nbt_cldap_netlogon_5;
514
515         typedef struct {
516                 uint32               type;
517                 nbt_server_type      server_type;
518                 GUID                 domain_uuid;
519                 nbt_string           forest;
520                 nbt_string           dns_domain;
521                 nbt_string           pdc_dns_name;
522                 nbt_string           domain;
523                 nbt_string           pdc_name;
524                 nbt_string           user_name;
525                 nbt_string           server_site;
526                 nbt_string           client_site;
527                 uint8                unknown;
528                 uint32               unknown2;
529                 [flag(NDR_BIG_ENDIAN)] 
530                   ipv4address          pdc_ip;
531                 uint32               unknown3[2];
532                 [value(13)] uint32   nt_version;
533                 uint16               lmnt_token;
534                 uint16               lm20_token;
535         } nbt_cldap_netlogon_13;
536
537         typedef [flag(NDR_NOALIGN),public,nodiscriminant] union {
538                 [case(0)]  nbt_cldap_netlogon_1 logon1;
539                 [case(1)]  nbt_cldap_netlogon_1 logon1;
540                 [case(2)]  nbt_cldap_netlogon_3 logon3;
541                 [case(3)]  nbt_cldap_netlogon_3 logon3;
542                 [case(4)]  nbt_cldap_netlogon_5 logon5;
543                 [case(5)]  nbt_cldap_netlogon_5 logon5;
544                 [case(6)]  nbt_cldap_netlogon_5 logon5;
545                 [case(7)]  nbt_cldap_netlogon_5 logon5;
546                 [default]  nbt_cldap_netlogon_13 logon13;
547         } nbt_cldap_netlogon;
548
549         /*******************************************/
550         /* \MAILSLOT\NET\NTLOGON mailslot requests */
551         typedef enum {
552                 NTLOGON_SAM_LOGON         = 0x12,
553                 NTLOGON_SAM_LOGON_REPLY   = 0x13,
554                 NTLOGON_SAM_LOGON_REPLY15 = 0x15
555         } nbt_ntlogon_command;
556
557         typedef struct {
558                 uint16               request_count;
559                 nstring              computer_name;
560                 nstring              user_name;
561                 astring              mailslot_name;
562                 uint32               acct_control;
563                 [value(ndr_size_dom_sid(&sid, ndr->flags))] uint32 sid_size;
564                 [flag(NDR_ALIGN4)]   DATA_BLOB _pad;
565                 dom_sid              sid;
566                 uint32               nt_version;
567                 uint16               lmnt_token;
568                 uint16               lm20_token;
569         } nbt_ntlogon_sam_logon;
570
571         typedef struct {
572                 nstring              server;
573                 nstring              user_name;
574                 nstring              domain;
575                 uint32               nt_version;
576                 uint16               lmnt_token;
577                 uint16               lm20_token;
578         } nbt_ntlogon_sam_logon_reply;
579
580         typedef [nodiscriminant] union {
581                 [case(NTLOGON_SAM_LOGON)]       nbt_ntlogon_sam_logon logon;
582                 [case(NTLOGON_SAM_LOGON_REPLY)] nbt_ntlogon_sam_logon_reply reply;
583                 [case(NTLOGON_SAM_LOGON_REPLY15)] nbt_ntlogon_sam_logon_reply reply;
584         } nbt_ntlogon_request;
585
586         typedef [flag(NDR_NOALIGN),public] struct {
587                 nbt_ntlogon_command command;
588                 [switch_is(command)] nbt_ntlogon_request req;
589         } nbt_ntlogon_packet;
590
591         /********************************************************/
592         /* \MAILSLOT\BROWSE mailslot requests                   */
593         /* for details see http://ubiqx.org/cifs/Browsing.html  */
594         /********************************************************/
595         typedef bitmap svcctl_ServerType svcctl_ServerType;
596
597         typedef [enum8bit] enum { 
598                 HostAnnouncement        = 1,
599                 AnnouncementRequest     = 2,
600                 Election                = 8,
601                 GetBackupListReq        = 9,
602                 GetBackupListResp       = 10,
603                 BecomeBackup            = 11,
604                 DomainAnnouncement      = 12,
605                 MasterAnnouncement      = 13,
606                 ResetBrowserState       = 14,
607                 LocalMasterAnnouncement = 15
608         } nbt_browse_opcode;
609
610         typedef struct {
611                 uint8 UpdateCount;
612                 uint32 Periodicity;
613                 [charset(DOS)] uint8 ServerName[16];
614                 uint8 OSMajor;
615                 uint8 OSMinor;
616                 svcctl_ServerType ServerType;
617                 uint8 BroMajorVer;
618                 uint8 BroMinorVer;
619                 uint16 Signature;
620                 astring Comment;
621         } nbt_browse_host_announcement;
622
623         typedef struct {
624                 uint8 Unused;
625                 astring ResponseName; 
626         } nbt_browse_announcement_request;
627
628         typedef struct {
629                 uint8 Version;
630                 uint32 Criteria;
631                 uint32 UpTime; /* In milliseconds */
632                 uint32 Reserved; /* Must be zero */
633                 astring ServerName; 
634         } nbt_browse_election_request;
635
636         typedef struct {
637                 uint8 ReqCount;
638                 uint32 Token;
639         } nbt_browse_backup_list_request;
640
641         typedef struct {
642                 uint8 BackupCount;
643                 uint32 Token;
644                 nbt_name BackupServerList[BackupCount];/* TODO: this is wrong */
645         } nbt_browse_backup_list_response;
646
647         typedef struct {
648                 astring BrowserName;
649         } nbt_browse_become_backup;
650
651         typedef struct {
652                 uint8 UpdateCount;
653                 uint32 Periodicity;
654                 [charset(DOS)] uint8 ServerName[16];
655                 uint8 OSMajor;
656                 uint8 OSMinor;
657                 svcctl_ServerType ServerType;
658                 uint32 MysteriousField;
659                 astring Comment;
660         } nbt_browse_domain_announcement;
661
662         typedef struct {
663                 astring ServerName;
664         } nbt_browse_master_announcement;
665
666         typedef struct {
667                 uint8 Command;
668         } nbt_browse_reset_state;
669
670         typedef struct {
671                 uint8 UpdateCount;
672                 uint32 Periodicity;
673                 [charset(DOS)] uint8 ServerName[16];
674                 uint8 OSMajor;
675                 uint8 OSMinor;
676                 svcctl_ServerType ServerType;
677                 uint8 BroMajorVer;
678                 uint8 BroMinorVer;
679                 uint16 Signature;
680                 astring Comment;
681         } nbt_browse_local_master_announcement;
682
683         typedef [nodiscriminant] union {
684                 [case(HostAnnouncement)] nbt_browse_host_announcement host_annoucement;
685                 [case(AnnouncementRequest)] nbt_browse_announcement_request announcement_request;
686                 [case(Election)] nbt_browse_election_request election_request;
687                 [case(GetBackupListReq)] nbt_browse_backup_list_request backup_list_request;
688                 [case(GetBackupListResp)] nbt_browse_backup_list_response backup_list_response;
689                 [case(BecomeBackup)] nbt_browse_become_backup become_backup;
690                 [case(DomainAnnouncement)] nbt_browse_domain_announcement domain_announcement;
691                 [case(MasterAnnouncement)] nbt_browse_master_announcement master_announcement;
692                 [case(ResetBrowserState)] nbt_browse_reset_state reset_browser_state;
693                 [case(LocalMasterAnnouncement)] nbt_browse_local_master_announcement local_master_announcement;
694         } nbt_browse_payload;
695
696         typedef [public,flag(NDR_NOALIGN)] struct {
697                 nbt_browse_opcode opcode;
698                 [switch_is(opcode)] nbt_browse_payload payload; 
699         } nbt_browse_packet;
700 }