← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_nbt.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/ndr_nbt.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "../librpc/gen_ndr/ndr_nbt.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_misc.h"
 
7
#include "librpc/gen_ndr/ndr_security.h"
 
8
#include "librpc/gen_ndr/ndr_svcctl.h"
 
9
#include "librpc/gen_ndr/ndr_samr.h"
 
10
static enum ndr_err_code ndr_push_nbt_operation(struct ndr_push *ndr, int ndr_flags, uint16_t r)
 
11
{
 
12
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
13
        return NDR_ERR_SUCCESS;
 
14
}
 
15
 
 
16
static enum ndr_err_code ndr_pull_nbt_operation(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
 
17
{
 
18
        uint16_t v;
 
19
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
20
        *r = v;
 
21
        return NDR_ERR_SUCCESS;
 
22
}
 
23
 
 
24
_PUBLIC_ void ndr_print_nbt_operation(struct ndr_print *ndr, const char *name, uint16_t r)
 
25
{
 
26
        ndr_print_uint16(ndr, name, r);
 
27
        ndr->depth++;
 
28
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_RCODE", NBT_RCODE, r);
 
29
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_FLAG_BROADCAST", NBT_FLAG_BROADCAST, r);
 
30
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_FLAG_RECURSION_AVAIL", NBT_FLAG_RECURSION_AVAIL, r);
 
31
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_FLAG_RECURSION_DESIRED", NBT_FLAG_RECURSION_DESIRED, r);
 
32
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_FLAG_TRUNCATION", NBT_FLAG_TRUNCATION, r);
 
33
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_FLAG_AUTHORITIVE", NBT_FLAG_AUTHORITIVE, r);
 
34
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_OPCODE", NBT_OPCODE, r);
 
35
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_FLAG_REPLY", NBT_FLAG_REPLY, r);
 
36
        ndr->depth--;
 
37
}
 
38
 
 
39
static enum ndr_err_code ndr_push_nbt_name_type(struct ndr_push *ndr, int ndr_flags, enum nbt_name_type r)
 
40
{
 
41
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
42
        return NDR_ERR_SUCCESS;
 
43
}
 
44
 
 
45
static enum ndr_err_code ndr_pull_nbt_name_type(struct ndr_pull *ndr, int ndr_flags, enum nbt_name_type *r)
 
46
{
 
47
        uint8_t v;
 
48
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
49
        *r = v;
 
50
        return NDR_ERR_SUCCESS;
 
51
}
 
52
 
 
53
_PUBLIC_ void ndr_print_nbt_name_type(struct ndr_print *ndr, const char *name, enum nbt_name_type r)
 
54
{
 
55
        const char *val = NULL;
 
56
 
 
57
        switch (r) {
 
58
                case NBT_NAME_CLIENT: val = "NBT_NAME_CLIENT"; break;
 
59
                case NBT_NAME_MS: val = "NBT_NAME_MS"; break;
 
60
                case NBT_NAME_USER: val = "NBT_NAME_USER"; break;
 
61
                case NBT_NAME_SERVER: val = "NBT_NAME_SERVER"; break;
 
62
                case NBT_NAME_PDC: val = "NBT_NAME_PDC"; break;
 
63
                case NBT_NAME_LOGON: val = "NBT_NAME_LOGON"; break;
 
64
                case NBT_NAME_MASTER: val = "NBT_NAME_MASTER"; break;
 
65
                case NBT_NAME_BROWSER: val = "NBT_NAME_BROWSER"; break;
 
66
        }
 
67
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
68
}
 
69
 
 
70
_PUBLIC_ void ndr_print_nbt_name(struct ndr_print *ndr, const char *name, const struct nbt_name *r)
 
71
{
 
72
        ndr_print_struct(ndr, name, "nbt_name");
 
73
        ndr->depth++;
 
74
        ndr_print_string(ndr, "name", r->name);
 
75
        ndr_print_string(ndr, "scope", r->scope);
 
76
        ndr_print_nbt_name_type(ndr, "type", r->type);
 
77
        ndr->depth--;
 
78
}
 
79
 
 
80
_PUBLIC_ enum ndr_err_code ndr_push_nbt_qclass(struct ndr_push *ndr, int ndr_flags, enum nbt_qclass r)
 
81
{
 
82
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
83
        return NDR_ERR_SUCCESS;
 
84
}
 
85
 
 
86
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_qclass(struct ndr_pull *ndr, int ndr_flags, enum nbt_qclass *r)
 
87
{
 
88
        uint16_t v;
 
89
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
90
        *r = v;
 
91
        return NDR_ERR_SUCCESS;
 
92
}
 
93
 
 
94
_PUBLIC_ void ndr_print_nbt_qclass(struct ndr_print *ndr, const char *name, enum nbt_qclass r)
 
95
{
 
96
        const char *val = NULL;
 
97
 
 
98
        switch (r) {
 
99
                case NBT_QCLASS_IP: val = "NBT_QCLASS_IP"; break;
 
100
        }
 
101
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
102
}
 
103
 
 
104
_PUBLIC_ enum ndr_err_code ndr_push_nbt_qtype(struct ndr_push *ndr, int ndr_flags, enum nbt_qtype r)
 
105
{
 
106
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
107
        return NDR_ERR_SUCCESS;
 
108
}
 
109
 
 
110
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_qtype(struct ndr_pull *ndr, int ndr_flags, enum nbt_qtype *r)
 
111
{
 
112
        uint16_t v;
 
113
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
114
        *r = v;
 
115
        return NDR_ERR_SUCCESS;
 
116
}
 
117
 
 
118
_PUBLIC_ void ndr_print_nbt_qtype(struct ndr_print *ndr, const char *name, enum nbt_qtype r)
 
119
{
 
120
        const char *val = NULL;
 
121
 
 
122
        switch (r) {
 
123
                case NBT_QTYPE_ADDRESS: val = "NBT_QTYPE_ADDRESS"; break;
 
124
                case NBT_QTYPE_NAMESERVICE: val = "NBT_QTYPE_NAMESERVICE"; break;
 
125
                case NBT_QTYPE_NULL: val = "NBT_QTYPE_NULL"; break;
 
126
                case NBT_QTYPE_NETBIOS: val = "NBT_QTYPE_NETBIOS"; break;
 
127
                case NBT_QTYPE_STATUS: val = "NBT_QTYPE_STATUS"; break;
 
128
        }
 
129
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
130
}
 
131
 
 
132
static enum ndr_err_code ndr_push_nbt_name_question(struct ndr_push *ndr, int ndr_flags, const struct nbt_name_question *r)
 
133
{
 
134
        if (ndr_flags & NDR_SCALARS) {
 
135
                NDR_CHECK(ndr_push_align(ndr, 4));
 
136
                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->name));
 
137
                NDR_CHECK(ndr_push_nbt_qtype(ndr, NDR_SCALARS, r->question_type));
 
138
                NDR_CHECK(ndr_push_nbt_qclass(ndr, NDR_SCALARS, r->question_class));
 
139
        }
 
140
        if (ndr_flags & NDR_BUFFERS) {
 
141
        }
 
142
        return NDR_ERR_SUCCESS;
 
143
}
 
144
 
 
145
static enum ndr_err_code ndr_pull_nbt_name_question(struct ndr_pull *ndr, int ndr_flags, struct nbt_name_question *r)
 
146
{
 
147
        if (ndr_flags & NDR_SCALARS) {
 
148
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
149
                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->name));
 
150
                NDR_CHECK(ndr_pull_nbt_qtype(ndr, NDR_SCALARS, &r->question_type));
 
151
                NDR_CHECK(ndr_pull_nbt_qclass(ndr, NDR_SCALARS, &r->question_class));
 
152
        }
 
153
        if (ndr_flags & NDR_BUFFERS) {
 
154
        }
 
155
        return NDR_ERR_SUCCESS;
 
156
}
 
157
 
 
158
_PUBLIC_ void ndr_print_nbt_name_question(struct ndr_print *ndr, const char *name, const struct nbt_name_question *r)
 
159
{
 
160
        ndr_print_struct(ndr, name, "nbt_name_question");
 
161
        ndr->depth++;
 
162
        ndr_print_nbt_name(ndr, "name", &r->name);
 
163
        ndr_print_nbt_qtype(ndr, "question_type", r->question_type);
 
164
        ndr_print_nbt_qclass(ndr, "question_class", r->question_class);
 
165
        ndr->depth--;
 
166
}
 
167
 
 
168
static enum ndr_err_code ndr_push_nb_flags(struct ndr_push *ndr, int ndr_flags, uint16_t r)
 
169
{
 
170
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
171
        return NDR_ERR_SUCCESS;
 
172
}
 
173
 
 
174
static enum ndr_err_code ndr_pull_nb_flags(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
 
175
{
 
176
        uint16_t v;
 
177
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
178
        *r = v;
 
179
        return NDR_ERR_SUCCESS;
 
180
}
 
181
 
 
182
_PUBLIC_ void ndr_print_nb_flags(struct ndr_print *ndr, const char *name, uint16_t r)
 
183
{
 
184
        ndr_print_uint16(ndr, name, r);
 
185
        ndr->depth++;
 
186
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_NM_PERMANENT", NBT_NM_PERMANENT, r);
 
187
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_NM_ACTIVE", NBT_NM_ACTIVE, r);
 
188
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_NM_CONFLICT", NBT_NM_CONFLICT, r);
 
189
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_NM_DEREGISTER", NBT_NM_DEREGISTER, r);
 
190
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_NM_OWNER_TYPE", NBT_NM_OWNER_TYPE, r);
 
191
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "NBT_NM_GROUP", NBT_NM_GROUP, r);
 
192
        ndr->depth--;
 
193
}
 
194
 
 
195
static enum ndr_err_code ndr_push_nbt_rdata_address(struct ndr_push *ndr, int ndr_flags, const struct nbt_rdata_address *r)
 
196
{
 
197
        if (ndr_flags & NDR_SCALARS) {
 
198
                NDR_CHECK(ndr_push_align(ndr, 4));
 
199
                NDR_CHECK(ndr_push_nb_flags(ndr, NDR_SCALARS, r->nb_flags));
 
200
                NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipaddr));
 
201
        }
 
202
        if (ndr_flags & NDR_BUFFERS) {
 
203
        }
 
204
        return NDR_ERR_SUCCESS;
 
205
}
 
206
 
 
207
static enum ndr_err_code ndr_pull_nbt_rdata_address(struct ndr_pull *ndr, int ndr_flags, struct nbt_rdata_address *r)
 
208
{
 
209
        if (ndr_flags & NDR_SCALARS) {
 
210
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
211
                NDR_CHECK(ndr_pull_nb_flags(ndr, NDR_SCALARS, &r->nb_flags));
 
212
                NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipaddr));
 
213
        }
 
214
        if (ndr_flags & NDR_BUFFERS) {
 
215
        }
 
216
        return NDR_ERR_SUCCESS;
 
217
}
 
218
 
 
219
_PUBLIC_ void ndr_print_nbt_rdata_address(struct ndr_print *ndr, const char *name, const struct nbt_rdata_address *r)
 
220
{
 
221
        ndr_print_struct(ndr, name, "nbt_rdata_address");
 
222
        ndr->depth++;
 
223
        ndr_print_nb_flags(ndr, "nb_flags", r->nb_flags);
 
224
        ndr_print_ipv4address(ndr, "ipaddr", r->ipaddr);
 
225
        ndr->depth--;
 
226
}
 
227
 
 
228
static enum ndr_err_code ndr_push_nbt_rdata_netbios(struct ndr_push *ndr, int ndr_flags, const struct nbt_rdata_netbios *r)
 
229
{
 
230
        uint32_t cntr_addresses_0;
 
231
        if (ndr_flags & NDR_SCALARS) {
 
232
                NDR_CHECK(ndr_push_align(ndr, 4));
 
233
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
 
234
                for (cntr_addresses_0 = 0; cntr_addresses_0 < r->length / 6; cntr_addresses_0++) {
 
235
                        NDR_CHECK(ndr_push_nbt_rdata_address(ndr, NDR_SCALARS, &r->addresses[cntr_addresses_0]));
 
236
                }
 
237
        }
 
238
        if (ndr_flags & NDR_BUFFERS) {
 
239
        }
 
240
        return NDR_ERR_SUCCESS;
 
241
}
 
242
 
 
243
static enum ndr_err_code ndr_pull_nbt_rdata_netbios(struct ndr_pull *ndr, int ndr_flags, struct nbt_rdata_netbios *r)
 
244
{
 
245
        uint32_t cntr_addresses_0;
 
246
        TALLOC_CTX *_mem_save_addresses_0;
 
247
        if (ndr_flags & NDR_SCALARS) {
 
248
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
249
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 
250
                NDR_PULL_ALLOC_N(ndr, r->addresses, r->length / 6);
 
251
                _mem_save_addresses_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
252
                NDR_PULL_SET_MEM_CTX(ndr, r->addresses, 0);
 
253
                for (cntr_addresses_0 = 0; cntr_addresses_0 < r->length / 6; cntr_addresses_0++) {
 
254
                        NDR_CHECK(ndr_pull_nbt_rdata_address(ndr, NDR_SCALARS, &r->addresses[cntr_addresses_0]));
 
255
                }
 
256
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addresses_0, 0);
 
257
        }
 
258
        if (ndr_flags & NDR_BUFFERS) {
 
259
        }
 
260
        return NDR_ERR_SUCCESS;
 
261
}
 
262
 
 
263
_PUBLIC_ void ndr_print_nbt_rdata_netbios(struct ndr_print *ndr, const char *name, const struct nbt_rdata_netbios *r)
 
264
{
 
265
        uint32_t cntr_addresses_0;
 
266
        ndr_print_struct(ndr, name, "nbt_rdata_netbios");
 
267
        ndr->depth++;
 
268
        ndr_print_uint16(ndr, "length", r->length);
 
269
        ndr->print(ndr, "%s: ARRAY(%d)", "addresses", (int)r->length / 6);
 
270
        ndr->depth++;
 
271
        for (cntr_addresses_0=0;cntr_addresses_0<r->length / 6;cntr_addresses_0++) {
 
272
                char *idx_0=NULL;
 
273
                if (asprintf(&idx_0, "[%d]", cntr_addresses_0) != -1) {
 
274
                        ndr_print_nbt_rdata_address(ndr, "addresses", &r->addresses[cntr_addresses_0]);
 
275
                        free(idx_0);
 
276
                }
 
277
        }
 
278
        ndr->depth--;
 
279
        ndr->depth--;
 
280
}
 
281
 
 
282
static enum ndr_err_code ndr_push_nbt_statistics(struct ndr_push *ndr, int ndr_flags, const struct nbt_statistics *r)
 
283
{
 
284
        if (ndr_flags & NDR_SCALARS) {
 
285
                NDR_CHECK(ndr_push_align(ndr, 4));
 
286
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->unit_id, 6));
 
287
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->jumpers));
 
288
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->test_result));
 
289
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version_number));
 
290
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->period_of_statistics));
 
291
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_of_crcs));
 
292
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_alignment_errors));
 
293
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_of_collisions));
 
294
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_send_aborts));
 
295
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_good_sends));
 
296
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_good_receives));
 
297
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_retransmits));
 
298
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_no_resource_conditions));
 
299
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_free_command_blocks));
 
300
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->total_number_command_blocks));
 
301
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_total_number_command_blocks));
 
302
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->number_pending_sessions));
 
303
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_number_pending_sessions));
 
304
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_total_sessions_possible));
 
305
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->session_data_packet_size));
 
306
        }
 
307
        if (ndr_flags & NDR_BUFFERS) {
 
308
        }
 
309
        return NDR_ERR_SUCCESS;
 
310
}
 
311
 
 
312
static enum ndr_err_code ndr_pull_nbt_statistics(struct ndr_pull *ndr, int ndr_flags, struct nbt_statistics *r)
 
313
{
 
314
        if (ndr_flags & NDR_SCALARS) {
 
315
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
316
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->unit_id, 6));
 
317
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->jumpers));
 
318
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->test_result));
 
319
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version_number));
 
320
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->period_of_statistics));
 
321
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_of_crcs));
 
322
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_alignment_errors));
 
323
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_of_collisions));
 
324
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_send_aborts));
 
325
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_good_sends));
 
326
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_good_receives));
 
327
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_retransmits));
 
328
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_no_resource_conditions));
 
329
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_free_command_blocks));
 
330
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->total_number_command_blocks));
 
331
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_total_number_command_blocks));
 
332
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->number_pending_sessions));
 
333
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_number_pending_sessions));
 
334
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_total_sessions_possible));
 
335
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->session_data_packet_size));
 
336
        }
 
337
        if (ndr_flags & NDR_BUFFERS) {
 
338
        }
 
339
        return NDR_ERR_SUCCESS;
 
340
}
 
341
 
 
342
_PUBLIC_ void ndr_print_nbt_statistics(struct ndr_print *ndr, const char *name, const struct nbt_statistics *r)
 
343
{
 
344
        ndr_print_struct(ndr, name, "nbt_statistics");
 
345
        ndr->depth++;
 
346
        ndr_print_array_uint8(ndr, "unit_id", r->unit_id, 6);
 
347
        ndr_print_uint8(ndr, "jumpers", r->jumpers);
 
348
        ndr_print_uint8(ndr, "test_result", r->test_result);
 
349
        ndr_print_uint16(ndr, "version_number", r->version_number);
 
350
        ndr_print_uint16(ndr, "period_of_statistics", r->period_of_statistics);
 
351
        ndr_print_uint16(ndr, "number_of_crcs", r->number_of_crcs);
 
352
        ndr_print_uint16(ndr, "number_alignment_errors", r->number_alignment_errors);
 
353
        ndr_print_uint16(ndr, "number_of_collisions", r->number_of_collisions);
 
354
        ndr_print_uint16(ndr, "number_send_aborts", r->number_send_aborts);
 
355
        ndr_print_uint32(ndr, "number_good_sends", r->number_good_sends);
 
356
        ndr_print_uint32(ndr, "number_good_receives", r->number_good_receives);
 
357
        ndr_print_uint16(ndr, "number_retransmits", r->number_retransmits);
 
358
        ndr_print_uint16(ndr, "number_no_resource_conditions", r->number_no_resource_conditions);
 
359
        ndr_print_uint16(ndr, "number_free_command_blocks", r->number_free_command_blocks);
 
360
        ndr_print_uint16(ndr, "total_number_command_blocks", r->total_number_command_blocks);
 
361
        ndr_print_uint16(ndr, "max_total_number_command_blocks", r->max_total_number_command_blocks);
 
362
        ndr_print_uint16(ndr, "number_pending_sessions", r->number_pending_sessions);
 
363
        ndr_print_uint16(ndr, "max_number_pending_sessions", r->max_number_pending_sessions);
 
364
        ndr_print_uint16(ndr, "max_total_sessions_possible", r->max_total_sessions_possible);
 
365
        ndr_print_uint16(ndr, "session_data_packet_size", r->session_data_packet_size);
 
366
        ndr->depth--;
 
367
}
 
368
 
 
369
static enum ndr_err_code ndr_push_nbt_status_name(struct ndr_push *ndr, int ndr_flags, const struct nbt_status_name *r)
 
370
{
 
371
        if (ndr_flags & NDR_SCALARS) {
 
372
                NDR_CHECK(ndr_push_align(ndr, 2));
 
373
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 15, sizeof(uint8_t), CH_DOS));
 
374
                NDR_CHECK(ndr_push_nbt_name_type(ndr, NDR_SCALARS, r->type));
 
375
                NDR_CHECK(ndr_push_nb_flags(ndr, NDR_SCALARS, r->nb_flags));
 
376
        }
 
377
        if (ndr_flags & NDR_BUFFERS) {
 
378
        }
 
379
        return NDR_ERR_SUCCESS;
 
380
}
 
381
 
 
382
static enum ndr_err_code ndr_pull_nbt_status_name(struct ndr_pull *ndr, int ndr_flags, struct nbt_status_name *r)
 
383
{
 
384
        if (ndr_flags & NDR_SCALARS) {
 
385
                NDR_CHECK(ndr_pull_align(ndr, 2));
 
386
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, 15, sizeof(uint8_t), CH_DOS));
 
387
                NDR_CHECK(ndr_pull_nbt_name_type(ndr, NDR_SCALARS, &r->type));
 
388
                NDR_CHECK(ndr_pull_nb_flags(ndr, NDR_SCALARS, &r->nb_flags));
 
389
        }
 
390
        if (ndr_flags & NDR_BUFFERS) {
 
391
        }
 
392
        return NDR_ERR_SUCCESS;
 
393
}
 
394
 
 
395
_PUBLIC_ void ndr_print_nbt_status_name(struct ndr_print *ndr, const char *name, const struct nbt_status_name *r)
 
396
{
 
397
        ndr_print_struct(ndr, name, "nbt_status_name");
 
398
        ndr->depth++;
 
399
        ndr_print_string(ndr, "name", r->name);
 
400
        ndr_print_nbt_name_type(ndr, "type", r->type);
 
401
        ndr_print_nb_flags(ndr, "nb_flags", r->nb_flags);
 
402
        ndr->depth--;
 
403
}
 
404
 
 
405
static enum ndr_err_code ndr_push_nbt_rdata_status(struct ndr_push *ndr, int ndr_flags, const struct nbt_rdata_status *r)
 
406
{
 
407
        uint32_t cntr_names_0;
 
408
        if (ndr_flags & NDR_SCALARS) {
 
409
                NDR_CHECK(ndr_push_align(ndr, 4));
 
410
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_names * 18 + 47));
 
411
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_names));
 
412
                for (cntr_names_0 = 0; cntr_names_0 < r->num_names; cntr_names_0++) {
 
413
                        NDR_CHECK(ndr_push_nbt_status_name(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
 
414
                }
 
415
                NDR_CHECK(ndr_push_nbt_statistics(ndr, NDR_SCALARS, &r->statistics));
 
416
        }
 
417
        if (ndr_flags & NDR_BUFFERS) {
 
418
        }
 
419
        return NDR_ERR_SUCCESS;
 
420
}
 
421
 
 
422
static enum ndr_err_code ndr_pull_nbt_rdata_status(struct ndr_pull *ndr, int ndr_flags, struct nbt_rdata_status *r)
 
423
{
 
424
        uint32_t cntr_names_0;
 
425
        TALLOC_CTX *_mem_save_names_0;
 
426
        if (ndr_flags & NDR_SCALARS) {
 
427
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
428
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 
429
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_names));
 
430
                NDR_PULL_ALLOC_N(ndr, r->names, r->num_names);
 
431
                _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
432
                NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 
433
                for (cntr_names_0 = 0; cntr_names_0 < r->num_names; cntr_names_0++) {
 
434
                        NDR_CHECK(ndr_pull_nbt_status_name(ndr, NDR_SCALARS, &r->names[cntr_names_0]));
 
435
                }
 
436
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 
437
                NDR_CHECK(ndr_pull_nbt_statistics(ndr, NDR_SCALARS, &r->statistics));
 
438
        }
 
439
        if (ndr_flags & NDR_BUFFERS) {
 
440
        }
 
441
        return NDR_ERR_SUCCESS;
 
442
}
 
443
 
 
444
_PUBLIC_ void ndr_print_nbt_rdata_status(struct ndr_print *ndr, const char *name, const struct nbt_rdata_status *r)
 
445
{
 
446
        uint32_t cntr_names_0;
 
447
        ndr_print_struct(ndr, name, "nbt_rdata_status");
 
448
        ndr->depth++;
 
449
        ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->num_names * 18 + 47:r->length);
 
450
        ndr_print_uint8(ndr, "num_names", r->num_names);
 
451
        ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->num_names);
 
452
        ndr->depth++;
 
453
        for (cntr_names_0=0;cntr_names_0<r->num_names;cntr_names_0++) {
 
454
                char *idx_0=NULL;
 
455
                if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
 
456
                        ndr_print_nbt_status_name(ndr, "names", &r->names[cntr_names_0]);
 
457
                        free(idx_0);
 
458
                }
 
459
        }
 
460
        ndr->depth--;
 
461
        ndr_print_nbt_statistics(ndr, "statistics", &r->statistics);
 
462
        ndr->depth--;
 
463
}
 
464
 
 
465
static enum ndr_err_code ndr_push_nbt_rdata_data(struct ndr_push *ndr, int ndr_flags, const struct nbt_rdata_data *r)
 
466
{
 
467
        if (ndr_flags & NDR_SCALARS) {
 
468
                NDR_CHECK(ndr_push_align(ndr, 2));
 
469
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
 
470
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
 
471
        }
 
472
        if (ndr_flags & NDR_BUFFERS) {
 
473
        }
 
474
        return NDR_ERR_SUCCESS;
 
475
}
 
476
 
 
477
static enum ndr_err_code ndr_pull_nbt_rdata_data(struct ndr_pull *ndr, int ndr_flags, struct nbt_rdata_data *r)
 
478
{
 
479
        if (ndr_flags & NDR_SCALARS) {
 
480
                NDR_CHECK(ndr_pull_align(ndr, 2));
 
481
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 
482
                NDR_PULL_ALLOC_N(ndr, r->data, r->length);
 
483
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
 
484
        }
 
485
        if (ndr_flags & NDR_BUFFERS) {
 
486
        }
 
487
        return NDR_ERR_SUCCESS;
 
488
}
 
489
 
 
490
_PUBLIC_ void ndr_print_nbt_rdata_data(struct ndr_print *ndr, const char *name, const struct nbt_rdata_data *r)
 
491
{
 
492
        ndr_print_struct(ndr, name, "nbt_rdata_data");
 
493
        ndr->depth++;
 
494
        ndr_print_uint16(ndr, "length", r->length);
 
495
        ndr_print_array_uint8(ndr, "data", r->data, r->length);
 
496
        ndr->depth--;
 
497
}
 
498
 
 
499
_PUBLIC_ enum ndr_err_code ndr_push_nbt_rdata(struct ndr_push *ndr, int ndr_flags, const union nbt_rdata *r)
 
500
{
 
501
        if (ndr_flags & NDR_SCALARS) {
 
502
                int level = ndr_push_get_switch_value(ndr, r);
 
503
                switch (level) {
 
504
                        case NBT_QTYPE_NETBIOS: {
 
505
                                NDR_CHECK(ndr_push_nbt_rdata_netbios(ndr, NDR_SCALARS, &r->netbios));
 
506
                        break; }
 
507
 
 
508
                        case NBT_QTYPE_STATUS: {
 
509
                                NDR_CHECK(ndr_push_nbt_rdata_status(ndr, NDR_SCALARS, &r->status));
 
510
                        break; }
 
511
 
 
512
                        default: {
 
513
                                NDR_CHECK(ndr_push_nbt_rdata_data(ndr, NDR_SCALARS, &r->data));
 
514
                        break; }
 
515
 
 
516
                }
 
517
        }
 
518
        if (ndr_flags & NDR_BUFFERS) {
 
519
                int level = ndr_push_get_switch_value(ndr, r);
 
520
                switch (level) {
 
521
                        case NBT_QTYPE_NETBIOS:
 
522
                        break;
 
523
 
 
524
                        case NBT_QTYPE_STATUS:
 
525
                        break;
 
526
 
 
527
                        default:
 
528
                        break;
 
529
 
 
530
                }
 
531
        }
 
532
        return NDR_ERR_SUCCESS;
 
533
}
 
534
 
 
535
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_rdata(struct ndr_pull *ndr, int ndr_flags, union nbt_rdata *r)
 
536
{
 
537
        int level;
 
538
        level = ndr_pull_get_switch_value(ndr, r);
 
539
        if (ndr_flags & NDR_SCALARS) {
 
540
                switch (level) {
 
541
                        case NBT_QTYPE_NETBIOS: {
 
542
                                NDR_CHECK(ndr_pull_nbt_rdata_netbios(ndr, NDR_SCALARS, &r->netbios));
 
543
                        break; }
 
544
 
 
545
                        case NBT_QTYPE_STATUS: {
 
546
                                NDR_CHECK(ndr_pull_nbt_rdata_status(ndr, NDR_SCALARS, &r->status));
 
547
                        break; }
 
548
 
 
549
                        default: {
 
550
                                NDR_CHECK(ndr_pull_nbt_rdata_data(ndr, NDR_SCALARS, &r->data));
 
551
                        break; }
 
552
 
 
553
                }
 
554
        }
 
555
        if (ndr_flags & NDR_BUFFERS) {
 
556
                switch (level) {
 
557
                        case NBT_QTYPE_NETBIOS:
 
558
                        break;
 
559
 
 
560
                        case NBT_QTYPE_STATUS:
 
561
                        break;
 
562
 
 
563
                        default:
 
564
                        break;
 
565
 
 
566
                }
 
567
        }
 
568
        return NDR_ERR_SUCCESS;
 
569
}
 
570
 
 
571
_PUBLIC_ void ndr_print_nbt_rdata(struct ndr_print *ndr, const char *name, const union nbt_rdata *r)
 
572
{
 
573
        int level;
 
574
        level = ndr_print_get_switch_value(ndr, r);
 
575
        ndr_print_union(ndr, name, level, "nbt_rdata");
 
576
        switch (level) {
 
577
                case NBT_QTYPE_NETBIOS:
 
578
                        ndr_print_nbt_rdata_netbios(ndr, "netbios", &r->netbios);
 
579
                break;
 
580
 
 
581
                case NBT_QTYPE_STATUS:
 
582
                        ndr_print_nbt_rdata_status(ndr, "status", &r->status);
 
583
                break;
 
584
 
 
585
                default:
 
586
                        ndr_print_nbt_rdata_data(ndr, "data", &r->data);
 
587
                break;
 
588
 
 
589
        }
 
590
}
 
591
 
 
592
static enum ndr_err_code ndr_pull_nbt_res_rec(struct ndr_pull *ndr, int ndr_flags, struct nbt_res_rec *r)
 
593
{
 
594
        {
 
595
                uint32_t _flags_save_STRUCT = ndr->flags;
 
596
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
597
                if (ndr_flags & NDR_SCALARS) {
 
598
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
599
                        NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->name));
 
600
                        NDR_CHECK(ndr_pull_nbt_qtype(ndr, NDR_SCALARS, &r->rr_type));
 
601
                        NDR_CHECK(ndr_pull_nbt_qclass(ndr, NDR_SCALARS, &r->rr_class));
 
602
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
 
603
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata, r->rr_type));
 
604
                        NDR_CHECK(ndr_pull_nbt_rdata(ndr, NDR_SCALARS, &r->rdata));
 
605
                }
 
606
                if (ndr_flags & NDR_BUFFERS) {
 
607
                }
 
608
                ndr->flags = _flags_save_STRUCT;
 
609
        }
 
610
        return NDR_ERR_SUCCESS;
 
611
}
 
612
 
 
613
_PUBLIC_ void ndr_print_nbt_res_rec(struct ndr_print *ndr, const char *name, const struct nbt_res_rec *r)
 
614
{
 
615
        ndr_print_struct(ndr, name, "nbt_res_rec");
 
616
        {
 
617
                uint32_t _flags_save_STRUCT = ndr->flags;
 
618
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
619
                ndr->depth++;
 
620
                ndr_print_nbt_name(ndr, "name", &r->name);
 
621
                ndr_print_nbt_qtype(ndr, "rr_type", r->rr_type);
 
622
                ndr_print_nbt_qclass(ndr, "rr_class", r->rr_class);
 
623
                ndr_print_uint32(ndr, "ttl", r->ttl);
 
624
                ndr_print_set_switch_value(ndr, &r->rdata, r->rr_type);
 
625
                ndr_print_nbt_rdata(ndr, "rdata", &r->rdata);
 
626
                ndr->depth--;
 
627
                ndr->flags = _flags_save_STRUCT;
 
628
        }
 
629
}
 
630
 
 
631
_PUBLIC_ enum ndr_err_code ndr_push_nbt_name_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_name_packet *r)
 
632
{
 
633
        uint32_t cntr_questions_0;
 
634
        uint32_t cntr_answers_0;
 
635
        uint32_t cntr_nsrecs_0;
 
636
        uint32_t cntr_additional_0;
 
637
        {
 
638
                uint32_t _flags_save_STRUCT = ndr->flags;
 
639
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
640
                if (ndr_flags & NDR_SCALARS) {
 
641
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
642
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->name_trn_id));
 
643
                        NDR_CHECK(ndr_push_nbt_operation(ndr, NDR_SCALARS, r->operation));
 
644
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->qdcount));
 
645
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ancount));
 
646
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->nscount));
 
647
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->arcount));
 
648
                        for (cntr_questions_0 = 0; cntr_questions_0 < r->qdcount; cntr_questions_0++) {
 
649
                                NDR_CHECK(ndr_push_nbt_name_question(ndr, NDR_SCALARS, &r->questions[cntr_questions_0]));
 
650
                        }
 
651
                        for (cntr_answers_0 = 0; cntr_answers_0 < r->ancount; cntr_answers_0++) {
 
652
                                NDR_CHECK(ndr_push_nbt_res_rec(ndr, NDR_SCALARS, &r->answers[cntr_answers_0]));
 
653
                        }
 
654
                        for (cntr_nsrecs_0 = 0; cntr_nsrecs_0 < r->nscount; cntr_nsrecs_0++) {
 
655
                                NDR_CHECK(ndr_push_nbt_res_rec(ndr, NDR_SCALARS, &r->nsrecs[cntr_nsrecs_0]));
 
656
                        }
 
657
                        for (cntr_additional_0 = 0; cntr_additional_0 < r->arcount; cntr_additional_0++) {
 
658
                                NDR_CHECK(ndr_push_nbt_res_rec(ndr, NDR_SCALARS, &r->additional[cntr_additional_0]));
 
659
                        }
 
660
                        {
 
661
                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
662
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
663
                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->padding));
 
664
                                ndr->flags = _flags_save_DATA_BLOB;
 
665
                        }
 
666
                }
 
667
                if (ndr_flags & NDR_BUFFERS) {
 
668
                }
 
669
                ndr->flags = _flags_save_STRUCT;
 
670
        }
 
671
        return NDR_ERR_SUCCESS;
 
672
}
 
673
 
 
674
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_name_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_name_packet *r)
 
675
{
 
676
        uint32_t cntr_questions_0;
 
677
        TALLOC_CTX *_mem_save_questions_0;
 
678
        uint32_t cntr_answers_0;
 
679
        TALLOC_CTX *_mem_save_answers_0;
 
680
        uint32_t cntr_nsrecs_0;
 
681
        TALLOC_CTX *_mem_save_nsrecs_0;
 
682
        uint32_t cntr_additional_0;
 
683
        TALLOC_CTX *_mem_save_additional_0;
 
684
        {
 
685
                uint32_t _flags_save_STRUCT = ndr->flags;
 
686
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
687
                if (ndr_flags & NDR_SCALARS) {
 
688
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
689
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_trn_id));
 
690
                        NDR_CHECK(ndr_pull_nbt_operation(ndr, NDR_SCALARS, &r->operation));
 
691
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->qdcount));
 
692
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ancount));
 
693
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->nscount));
 
694
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->arcount));
 
695
                        NDR_PULL_ALLOC_N(ndr, r->questions, r->qdcount);
 
696
                        _mem_save_questions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
697
                        NDR_PULL_SET_MEM_CTX(ndr, r->questions, 0);
 
698
                        for (cntr_questions_0 = 0; cntr_questions_0 < r->qdcount; cntr_questions_0++) {
 
699
                                NDR_CHECK(ndr_pull_nbt_name_question(ndr, NDR_SCALARS, &r->questions[cntr_questions_0]));
 
700
                        }
 
701
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_questions_0, 0);
 
702
                        NDR_PULL_ALLOC_N(ndr, r->answers, r->ancount);
 
703
                        _mem_save_answers_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
704
                        NDR_PULL_SET_MEM_CTX(ndr, r->answers, 0);
 
705
                        for (cntr_answers_0 = 0; cntr_answers_0 < r->ancount; cntr_answers_0++) {
 
706
                                NDR_CHECK(ndr_pull_nbt_res_rec(ndr, NDR_SCALARS, &r->answers[cntr_answers_0]));
 
707
                        }
 
708
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_answers_0, 0);
 
709
                        NDR_PULL_ALLOC_N(ndr, r->nsrecs, r->nscount);
 
710
                        _mem_save_nsrecs_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
711
                        NDR_PULL_SET_MEM_CTX(ndr, r->nsrecs, 0);
 
712
                        for (cntr_nsrecs_0 = 0; cntr_nsrecs_0 < r->nscount; cntr_nsrecs_0++) {
 
713
                                NDR_CHECK(ndr_pull_nbt_res_rec(ndr, NDR_SCALARS, &r->nsrecs[cntr_nsrecs_0]));
 
714
                        }
 
715
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nsrecs_0, 0);
 
716
                        NDR_PULL_ALLOC_N(ndr, r->additional, r->arcount);
 
717
                        _mem_save_additional_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
718
                        NDR_PULL_SET_MEM_CTX(ndr, r->additional, 0);
 
719
                        for (cntr_additional_0 = 0; cntr_additional_0 < r->arcount; cntr_additional_0++) {
 
720
                                NDR_CHECK(ndr_pull_nbt_res_rec(ndr, NDR_SCALARS, &r->additional[cntr_additional_0]));
 
721
                        }
 
722
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_additional_0, 0);
 
723
                        {
 
724
                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
725
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
726
                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->padding));
 
727
                                ndr->flags = _flags_save_DATA_BLOB;
 
728
                        }
 
729
                }
 
730
                if (ndr_flags & NDR_BUFFERS) {
 
731
                }
 
732
                ndr->flags = _flags_save_STRUCT;
 
733
        }
 
734
        return NDR_ERR_SUCCESS;
 
735
}
 
736
 
 
737
_PUBLIC_ void ndr_print_nbt_name_packet(struct ndr_print *ndr, const char *name, const struct nbt_name_packet *r)
 
738
{
 
739
        uint32_t cntr_questions_0;
 
740
        uint32_t cntr_answers_0;
 
741
        uint32_t cntr_nsrecs_0;
 
742
        uint32_t cntr_additional_0;
 
743
        ndr_print_struct(ndr, name, "nbt_name_packet");
 
744
        {
 
745
                uint32_t _flags_save_STRUCT = ndr->flags;
 
746
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
747
                ndr->depth++;
 
748
                ndr_print_uint16(ndr, "name_trn_id", r->name_trn_id);
 
749
                ndr_print_nbt_operation(ndr, "operation", r->operation);
 
750
                ndr_print_uint16(ndr, "qdcount", r->qdcount);
 
751
                ndr_print_uint16(ndr, "ancount", r->ancount);
 
752
                ndr_print_uint16(ndr, "nscount", r->nscount);
 
753
                ndr_print_uint16(ndr, "arcount", r->arcount);
 
754
                ndr->print(ndr, "%s: ARRAY(%d)", "questions", (int)r->qdcount);
 
755
                ndr->depth++;
 
756
                for (cntr_questions_0=0;cntr_questions_0<r->qdcount;cntr_questions_0++) {
 
757
                        char *idx_0=NULL;
 
758
                        if (asprintf(&idx_0, "[%d]", cntr_questions_0) != -1) {
 
759
                                ndr_print_nbt_name_question(ndr, "questions", &r->questions[cntr_questions_0]);
 
760
                                free(idx_0);
 
761
                        }
 
762
                }
 
763
                ndr->depth--;
 
764
                ndr->print(ndr, "%s: ARRAY(%d)", "answers", (int)r->ancount);
 
765
                ndr->depth++;
 
766
                for (cntr_answers_0=0;cntr_answers_0<r->ancount;cntr_answers_0++) {
 
767
                        char *idx_0=NULL;
 
768
                        if (asprintf(&idx_0, "[%d]", cntr_answers_0) != -1) {
 
769
                                ndr_print_nbt_res_rec(ndr, "answers", &r->answers[cntr_answers_0]);
 
770
                                free(idx_0);
 
771
                        }
 
772
                }
 
773
                ndr->depth--;
 
774
                ndr->print(ndr, "%s: ARRAY(%d)", "nsrecs", (int)r->nscount);
 
775
                ndr->depth++;
 
776
                for (cntr_nsrecs_0=0;cntr_nsrecs_0<r->nscount;cntr_nsrecs_0++) {
 
777
                        char *idx_0=NULL;
 
778
                        if (asprintf(&idx_0, "[%d]", cntr_nsrecs_0) != -1) {
 
779
                                ndr_print_nbt_res_rec(ndr, "nsrecs", &r->nsrecs[cntr_nsrecs_0]);
 
780
                                free(idx_0);
 
781
                        }
 
782
                }
 
783
                ndr->depth--;
 
784
                ndr->print(ndr, "%s: ARRAY(%d)", "additional", (int)r->arcount);
 
785
                ndr->depth++;
 
786
                for (cntr_additional_0=0;cntr_additional_0<r->arcount;cntr_additional_0++) {
 
787
                        char *idx_0=NULL;
 
788
                        if (asprintf(&idx_0, "[%d]", cntr_additional_0) != -1) {
 
789
                                ndr_print_nbt_res_rec(ndr, "additional", &r->additional[cntr_additional_0]);
 
790
                                free(idx_0);
 
791
                        }
 
792
                }
 
793
                ndr->depth--;
 
794
                ndr_print_DATA_BLOB(ndr, "padding", r->padding);
 
795
                ndr->depth--;
 
796
                ndr->flags = _flags_save_STRUCT;
 
797
        }
 
798
}
 
799
 
 
800
static enum ndr_err_code ndr_push_dgram_msg_type(struct ndr_push *ndr, int ndr_flags, enum dgram_msg_type r)
 
801
{
 
802
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
803
        return NDR_ERR_SUCCESS;
 
804
}
 
805
 
 
806
static enum ndr_err_code ndr_pull_dgram_msg_type(struct ndr_pull *ndr, int ndr_flags, enum dgram_msg_type *r)
 
807
{
 
808
        uint8_t v;
 
809
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
810
        *r = v;
 
811
        return NDR_ERR_SUCCESS;
 
812
}
 
813
 
 
814
_PUBLIC_ void ndr_print_dgram_msg_type(struct ndr_print *ndr, const char *name, enum dgram_msg_type r)
 
815
{
 
816
        const char *val = NULL;
 
817
 
 
818
        switch (r) {
 
819
                case DGRAM_DIRECT_UNIQUE: val = "DGRAM_DIRECT_UNIQUE"; break;
 
820
                case DGRAM_DIRECT_GROUP: val = "DGRAM_DIRECT_GROUP"; break;
 
821
                case DGRAM_BCAST: val = "DGRAM_BCAST"; break;
 
822
                case DGRAM_ERROR: val = "DGRAM_ERROR"; break;
 
823
                case DGRAM_QUERY: val = "DGRAM_QUERY"; break;
 
824
                case DGRAM_QUERY_POSITIVE: val = "DGRAM_QUERY_POSITIVE"; break;
 
825
                case DGRAM_QUERY_NEGATIVE: val = "DGRAM_QUERY_NEGATIVE"; break;
 
826
        }
 
827
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
828
}
 
829
 
 
830
static enum ndr_err_code ndr_push_dgram_flags(struct ndr_push *ndr, int ndr_flags, uint8_t r)
 
831
{
 
832
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
833
        return NDR_ERR_SUCCESS;
 
834
}
 
835
 
 
836
static enum ndr_err_code ndr_pull_dgram_flags(struct ndr_pull *ndr, int ndr_flags, uint8_t *r)
 
837
{
 
838
        uint8_t v;
 
839
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
840
        *r = v;
 
841
        return NDR_ERR_SUCCESS;
 
842
}
 
843
 
 
844
_PUBLIC_ void ndr_print_dgram_flags(struct ndr_print *ndr, const char *name, uint8_t r)
 
845
{
 
846
        ndr_print_uint8(ndr, name, r);
 
847
        ndr->depth++;
 
848
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DGRAM_FLAG_MORE", DGRAM_FLAG_MORE, r);
 
849
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DGRAM_FLAG_FIRST", DGRAM_FLAG_FIRST, r);
 
850
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DGRAM_FLAG_NODE_TYPE", DGRAM_FLAG_NODE_TYPE, r);
 
851
        ndr->depth--;
 
852
}
 
853
 
 
854
static enum ndr_err_code ndr_push_smb_command(struct ndr_push *ndr, int ndr_flags, enum smb_command r)
 
855
{
 
856
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
857
        return NDR_ERR_SUCCESS;
 
858
}
 
859
 
 
860
static enum ndr_err_code ndr_pull_smb_command(struct ndr_pull *ndr, int ndr_flags, enum smb_command *r)
 
861
{
 
862
        uint8_t v;
 
863
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
864
        *r = v;
 
865
        return NDR_ERR_SUCCESS;
 
866
}
 
867
 
 
868
_PUBLIC_ void ndr_print_smb_command(struct ndr_print *ndr, const char *name, enum smb_command r)
 
869
{
 
870
        const char *val = NULL;
 
871
 
 
872
        switch (r) {
 
873
                case SMB_TRANSACTION: val = "SMB_TRANSACTION"; break;
 
874
        }
 
875
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
876
}
 
877
 
 
878
static enum ndr_err_code ndr_push_smb_trans_body(struct ndr_push *ndr, int ndr_flags, const struct smb_trans_body *r)
 
879
{
 
880
        if (ndr_flags & NDR_SCALARS) {
 
881
                NDR_CHECK(ndr_push_align(ndr, 4));
 
882
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 17));
 
883
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->total_param_count));
 
884
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->total_data_count));
 
885
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_param_count));
 
886
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_data_count));
 
887
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->max_setup_count));
 
888
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pad));
 
889
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->trans_flags));
 
890
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timeout));
 
891
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
 
892
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->param_count));
 
893
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->param_offset));
 
894
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->data_count));
 
895
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->data_offset));
 
896
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 3));
 
897
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pad2));
 
898
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opcode));
 
899
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->priority));
 
900
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->_class));
 
901
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->mailslot_name) + 1 + r->data.length));
 
902
                {
 
903
                        uint32_t _flags_save_string = ndr->flags;
 
904
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
905
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mailslot_name));
 
906
                        ndr->flags = _flags_save_string;
 
907
                }
 
908
                {
 
909
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
910
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
911
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 
912
                        ndr->flags = _flags_save_DATA_BLOB;
 
913
                }
 
914
        }
 
915
        if (ndr_flags & NDR_BUFFERS) {
 
916
        }
 
917
        return NDR_ERR_SUCCESS;
 
918
}
 
919
 
 
920
static enum ndr_err_code ndr_pull_smb_trans_body(struct ndr_pull *ndr, int ndr_flags, struct smb_trans_body *r)
 
921
{
 
922
        if (ndr_flags & NDR_SCALARS) {
 
923
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
924
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->wct));
 
925
                if (r->wct < 17 || r->wct > 17) {
 
926
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
927
                }
 
928
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->total_param_count));
 
929
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->total_data_count));
 
930
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_param_count));
 
931
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_data_count));
 
932
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->max_setup_count));
 
933
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pad));
 
934
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->trans_flags));
 
935
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timeout));
 
936
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
 
937
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->param_count));
 
938
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->param_offset));
 
939
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data_count));
 
940
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data_offset));
 
941
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->setup_count));
 
942
                if (r->setup_count < 3 || r->setup_count > 3) {
 
943
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
944
                }
 
945
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pad2));
 
946
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opcode));
 
947
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->priority));
 
948
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->_class));
 
949
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->byte_count));
 
950
                {
 
951
                        uint32_t _flags_save_string = ndr->flags;
 
952
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
953
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mailslot_name));
 
954
                        ndr->flags = _flags_save_string;
 
955
                }
 
956
                {
 
957
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
958
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
959
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 
960
                        ndr->flags = _flags_save_DATA_BLOB;
 
961
                }
 
962
        }
 
963
        if (ndr_flags & NDR_BUFFERS) {
 
964
        }
 
965
        return NDR_ERR_SUCCESS;
 
966
}
 
967
 
 
968
_PUBLIC_ void ndr_print_smb_trans_body(struct ndr_print *ndr, const char *name, const struct smb_trans_body *r)
 
969
{
 
970
        ndr_print_struct(ndr, name, "smb_trans_body");
 
971
        ndr->depth++;
 
972
        ndr_print_uint8(ndr, "wct", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?17:r->wct);
 
973
        ndr_print_uint16(ndr, "total_param_count", r->total_param_count);
 
974
        ndr_print_uint16(ndr, "total_data_count", r->total_data_count);
 
975
        ndr_print_uint16(ndr, "max_param_count", r->max_param_count);
 
976
        ndr_print_uint16(ndr, "max_data_count", r->max_data_count);
 
977
        ndr_print_uint8(ndr, "max_setup_count", r->max_setup_count);
 
978
        ndr_print_uint8(ndr, "pad", r->pad);
 
979
        ndr_print_uint16(ndr, "trans_flags", r->trans_flags);
 
980
        ndr_print_uint32(ndr, "timeout", r->timeout);
 
981
        ndr_print_uint16(ndr, "reserved", r->reserved);
 
982
        ndr_print_uint16(ndr, "param_count", r->param_count);
 
983
        ndr_print_uint16(ndr, "param_offset", r->param_offset);
 
984
        ndr_print_uint16(ndr, "data_count", r->data_count);
 
985
        ndr_print_uint16(ndr, "data_offset", r->data_offset);
 
986
        ndr_print_uint8(ndr, "setup_count", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?3:r->setup_count);
 
987
        ndr_print_uint8(ndr, "pad2", r->pad2);
 
988
        ndr_print_uint16(ndr, "opcode", r->opcode);
 
989
        ndr_print_uint16(ndr, "priority", r->priority);
 
990
        ndr_print_uint16(ndr, "_class", r->_class);
 
991
        ndr_print_uint16(ndr, "byte_count", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->mailslot_name) + 1 + r->data.length:r->byte_count);
 
992
        ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
 
993
        ndr_print_DATA_BLOB(ndr, "data", r->data);
 
994
        ndr->depth--;
 
995
}
 
996
 
 
997
static enum ndr_err_code ndr_push_smb_body(struct ndr_push *ndr, int ndr_flags, const union smb_body *r)
 
998
{
 
999
        if (ndr_flags & NDR_SCALARS) {
 
1000
                int level = ndr_push_get_switch_value(ndr, r);
 
1001
                switch (level) {
 
1002
                        case SMB_TRANSACTION: {
 
1003
                                NDR_CHECK(ndr_push_smb_trans_body(ndr, NDR_SCALARS, &r->trans));
 
1004
                        break; }
 
1005
 
 
1006
                        default:
 
1007
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1008
                }
 
1009
        }
 
1010
        if (ndr_flags & NDR_BUFFERS) {
 
1011
                int level = ndr_push_get_switch_value(ndr, r);
 
1012
                switch (level) {
 
1013
                        case SMB_TRANSACTION:
 
1014
                        break;
 
1015
 
 
1016
                        default:
 
1017
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1018
                }
 
1019
        }
 
1020
        return NDR_ERR_SUCCESS;
 
1021
}
 
1022
 
 
1023
static enum ndr_err_code ndr_pull_smb_body(struct ndr_pull *ndr, int ndr_flags, union smb_body *r)
 
1024
{
 
1025
        int level;
 
1026
        level = ndr_pull_get_switch_value(ndr, r);
 
1027
        if (ndr_flags & NDR_SCALARS) {
 
1028
                switch (level) {
 
1029
                        case SMB_TRANSACTION: {
 
1030
                                NDR_CHECK(ndr_pull_smb_trans_body(ndr, NDR_SCALARS, &r->trans));
 
1031
                        break; }
 
1032
 
 
1033
                        default:
 
1034
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1035
                }
 
1036
        }
 
1037
        if (ndr_flags & NDR_BUFFERS) {
 
1038
                switch (level) {
 
1039
                        case SMB_TRANSACTION:
 
1040
                        break;
 
1041
 
 
1042
                        default:
 
1043
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1044
                }
 
1045
        }
 
1046
        return NDR_ERR_SUCCESS;
 
1047
}
 
1048
 
 
1049
_PUBLIC_ void ndr_print_smb_body(struct ndr_print *ndr, const char *name, const union smb_body *r)
 
1050
{
 
1051
        int level;
 
1052
        level = ndr_print_get_switch_value(ndr, r);
 
1053
        ndr_print_union(ndr, name, level, "smb_body");
 
1054
        switch (level) {
 
1055
                case SMB_TRANSACTION:
 
1056
                        ndr_print_smb_trans_body(ndr, "trans", &r->trans);
 
1057
                break;
 
1058
 
 
1059
                default:
 
1060
                        ndr_print_bad_level(ndr, name, level);
 
1061
        }
 
1062
}
 
1063
 
 
1064
_PUBLIC_ enum ndr_err_code ndr_push_dgram_smb_packet(struct ndr_push *ndr, int ndr_flags, const struct dgram_smb_packet *r)
 
1065
{
 
1066
        {
 
1067
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1068
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
1069
                if (ndr_flags & NDR_SCALARS) {
 
1070
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
1071
                        NDR_CHECK(ndr_push_smb_command(ndr, NDR_SCALARS, r->smb_command));
 
1072
                        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->err_class));
 
1073
                        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pad));
 
1074
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->err_code));
 
1075
                        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->flags));
 
1076
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->flags2));
 
1077
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->pid_high));
 
1078
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->signature, 8));
 
1079
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
 
1080
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->tid));
 
1081
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->pid));
 
1082
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vuid));
 
1083
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->mid));
 
1084
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->body, r->smb_command));
 
1085
                        NDR_CHECK(ndr_push_smb_body(ndr, NDR_SCALARS, &r->body));
 
1086
                }
 
1087
                if (ndr_flags & NDR_BUFFERS) {
 
1088
                }
 
1089
                ndr->flags = _flags_save_STRUCT;
 
1090
        }
 
1091
        return NDR_ERR_SUCCESS;
 
1092
}
 
1093
 
 
1094
_PUBLIC_ enum ndr_err_code ndr_pull_dgram_smb_packet(struct ndr_pull *ndr, int ndr_flags, struct dgram_smb_packet *r)
 
1095
{
 
1096
        {
 
1097
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1098
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
1099
                if (ndr_flags & NDR_SCALARS) {
 
1100
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
1101
                        NDR_CHECK(ndr_pull_smb_command(ndr, NDR_SCALARS, &r->smb_command));
 
1102
                        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->err_class));
 
1103
                        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pad));
 
1104
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->err_code));
 
1105
                        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->flags));
 
1106
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags2));
 
1107
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->pid_high));
 
1108
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->signature, 8));
 
1109
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
 
1110
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->tid));
 
1111
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->pid));
 
1112
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vuid));
 
1113
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->mid));
 
1114
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->body, r->smb_command));
 
1115
                        NDR_CHECK(ndr_pull_smb_body(ndr, NDR_SCALARS, &r->body));
 
1116
                }
 
1117
                if (ndr_flags & NDR_BUFFERS) {
 
1118
                }
 
1119
                ndr->flags = _flags_save_STRUCT;
 
1120
        }
 
1121
        return NDR_ERR_SUCCESS;
 
1122
}
 
1123
 
 
1124
_PUBLIC_ void ndr_print_dgram_smb_packet(struct ndr_print *ndr, const char *name, const struct dgram_smb_packet *r)
 
1125
{
 
1126
        ndr_print_struct(ndr, name, "dgram_smb_packet");
 
1127
        {
 
1128
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1129
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
1130
                ndr->depth++;
 
1131
                ndr_print_smb_command(ndr, "smb_command", r->smb_command);
 
1132
                ndr_print_uint8(ndr, "err_class", r->err_class);
 
1133
                ndr_print_uint8(ndr, "pad", r->pad);
 
1134
                ndr_print_uint16(ndr, "err_code", r->err_code);
 
1135
                ndr_print_uint8(ndr, "flags", r->flags);
 
1136
                ndr_print_uint16(ndr, "flags2", r->flags2);
 
1137
                ndr_print_uint16(ndr, "pid_high", r->pid_high);
 
1138
                ndr_print_array_uint8(ndr, "signature", r->signature, 8);
 
1139
                ndr_print_uint16(ndr, "reserved", r->reserved);
 
1140
                ndr_print_uint16(ndr, "tid", r->tid);
 
1141
                ndr_print_uint16(ndr, "pid", r->pid);
 
1142
                ndr_print_uint16(ndr, "vuid", r->vuid);
 
1143
                ndr_print_uint16(ndr, "mid", r->mid);
 
1144
                ndr_print_set_switch_value(ndr, &r->body, r->smb_command);
 
1145
                ndr_print_smb_body(ndr, "body", &r->body);
 
1146
                ndr->depth--;
 
1147
                ndr->flags = _flags_save_STRUCT;
 
1148
        }
 
1149
}
 
1150
 
 
1151
static enum ndr_err_code ndr_push_dgram_message_body(struct ndr_push *ndr, int ndr_flags, const union dgram_message_body *r)
 
1152
{
 
1153
        if (ndr_flags & NDR_SCALARS) {
 
1154
                int level = ndr_push_get_switch_value(ndr, r);
 
1155
                switch (level) {
 
1156
                        case DGRAM_SMB: {
 
1157
                                NDR_CHECK(ndr_push_dgram_smb_packet(ndr, NDR_SCALARS, &r->smb));
 
1158
                        break; }
 
1159
 
 
1160
                        default:
 
1161
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1162
                }
 
1163
        }
 
1164
        if (ndr_flags & NDR_BUFFERS) {
 
1165
                int level = ndr_push_get_switch_value(ndr, r);
 
1166
                switch (level) {
 
1167
                        case DGRAM_SMB:
 
1168
                        break;
 
1169
 
 
1170
                        default:
 
1171
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1172
                }
 
1173
        }
 
1174
        return NDR_ERR_SUCCESS;
 
1175
}
 
1176
 
 
1177
static enum ndr_err_code ndr_pull_dgram_message_body(struct ndr_pull *ndr, int ndr_flags, union dgram_message_body *r)
 
1178
{
 
1179
        int level;
 
1180
        level = ndr_pull_get_switch_value(ndr, r);
 
1181
        if (ndr_flags & NDR_SCALARS) {
 
1182
                switch (level) {
 
1183
                        case DGRAM_SMB: {
 
1184
                                NDR_CHECK(ndr_pull_dgram_smb_packet(ndr, NDR_SCALARS, &r->smb));
 
1185
                        break; }
 
1186
 
 
1187
                        default:
 
1188
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1189
                }
 
1190
        }
 
1191
        if (ndr_flags & NDR_BUFFERS) {
 
1192
                switch (level) {
 
1193
                        case DGRAM_SMB:
 
1194
                        break;
 
1195
 
 
1196
                        default:
 
1197
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1198
                }
 
1199
        }
 
1200
        return NDR_ERR_SUCCESS;
 
1201
}
 
1202
 
 
1203
_PUBLIC_ void ndr_print_dgram_message_body(struct ndr_print *ndr, const char *name, const union dgram_message_body *r)
 
1204
{
 
1205
        int level;
 
1206
        level = ndr_print_get_switch_value(ndr, r);
 
1207
        ndr_print_union(ndr, name, level, "dgram_message_body");
 
1208
        switch (level) {
 
1209
                case DGRAM_SMB:
 
1210
                        ndr_print_dgram_smb_packet(ndr, "smb", &r->smb);
 
1211
                break;
 
1212
 
 
1213
                default:
 
1214
                        ndr_print_bad_level(ndr, name, level);
 
1215
        }
 
1216
}
 
1217
 
 
1218
static enum ndr_err_code ndr_push_dgram_message(struct ndr_push *ndr, int ndr_flags, const struct dgram_message *r)
 
1219
{
 
1220
        if (ndr_flags & NDR_SCALARS) {
 
1221
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1222
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
 
1223
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->offset));
 
1224
                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->source_name));
 
1225
                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1226
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_body_type));
 
1227
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->body, r->dgram_body_type));
 
1228
                NDR_CHECK(ndr_push_dgram_message_body(ndr, NDR_SCALARS, &r->body));
 
1229
        }
 
1230
        if (ndr_flags & NDR_BUFFERS) {
 
1231
        }
 
1232
        return NDR_ERR_SUCCESS;
 
1233
}
 
1234
 
 
1235
static enum ndr_err_code ndr_pull_dgram_message(struct ndr_pull *ndr, int ndr_flags, struct dgram_message *r)
 
1236
{
 
1237
        if (ndr_flags & NDR_SCALARS) {
 
1238
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1239
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 
1240
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->offset));
 
1241
                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->source_name));
 
1242
                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1243
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_body_type));
 
1244
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->body, r->dgram_body_type));
 
1245
                NDR_CHECK(ndr_pull_dgram_message_body(ndr, NDR_SCALARS, &r->body));
 
1246
        }
 
1247
        if (ndr_flags & NDR_BUFFERS) {
 
1248
        }
 
1249
        return NDR_ERR_SUCCESS;
 
1250
}
 
1251
 
 
1252
_PUBLIC_ void ndr_print_dgram_message(struct ndr_print *ndr, const char *name, const struct dgram_message *r)
 
1253
{
 
1254
        ndr_print_struct(ndr, name, "dgram_message");
 
1255
        ndr->depth++;
 
1256
        ndr_print_uint16(ndr, "length", r->length);
 
1257
        ndr_print_uint16(ndr, "offset", r->offset);
 
1258
        ndr_print_nbt_name(ndr, "source_name", &r->source_name);
 
1259
        ndr_print_nbt_name(ndr, "dest_name", &r->dest_name);
 
1260
        ndr_print_uint32(ndr, "dgram_body_type", r->dgram_body_type);
 
1261
        ndr_print_set_switch_value(ndr, &r->body, r->dgram_body_type);
 
1262
        ndr_print_dgram_message_body(ndr, "body", &r->body);
 
1263
        ndr->depth--;
 
1264
}
 
1265
 
 
1266
static enum ndr_err_code ndr_push_dgram_err_code(struct ndr_push *ndr, int ndr_flags, enum dgram_err_code r)
 
1267
{
 
1268
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
1269
        return NDR_ERR_SUCCESS;
 
1270
}
 
1271
 
 
1272
static enum ndr_err_code ndr_pull_dgram_err_code(struct ndr_pull *ndr, int ndr_flags, enum dgram_err_code *r)
 
1273
{
 
1274
        uint8_t v;
 
1275
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
1276
        *r = v;
 
1277
        return NDR_ERR_SUCCESS;
 
1278
}
 
1279
 
 
1280
_PUBLIC_ void ndr_print_dgram_err_code(struct ndr_print *ndr, const char *name, enum dgram_err_code r)
 
1281
{
 
1282
        const char *val = NULL;
 
1283
 
 
1284
        switch (r) {
 
1285
                case DGRAM_ERROR_NAME_NOT_PRESENT: val = "DGRAM_ERROR_NAME_NOT_PRESENT"; break;
 
1286
                case DGRAM_ERROR_INVALID_SOURCE: val = "DGRAM_ERROR_INVALID_SOURCE"; break;
 
1287
                case DGRAM_ERROR_INVALID_DEST: val = "DGRAM_ERROR_INVALID_DEST"; break;
 
1288
        }
 
1289
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1290
}
 
1291
 
 
1292
static enum ndr_err_code ndr_push_dgram_data(struct ndr_push *ndr, int ndr_flags, const union dgram_data *r)
 
1293
{
 
1294
        if (ndr_flags & NDR_SCALARS) {
 
1295
                int level = ndr_push_get_switch_value(ndr, r);
 
1296
                switch (level) {
 
1297
                        case DGRAM_DIRECT_UNIQUE: {
 
1298
                                NDR_CHECK(ndr_push_dgram_message(ndr, NDR_SCALARS, &r->msg));
 
1299
                        break; }
 
1300
 
 
1301
                        case DGRAM_DIRECT_GROUP: {
 
1302
                                NDR_CHECK(ndr_push_dgram_message(ndr, NDR_SCALARS, &r->msg));
 
1303
                        break; }
 
1304
 
 
1305
                        case DGRAM_BCAST: {
 
1306
                                NDR_CHECK(ndr_push_dgram_message(ndr, NDR_SCALARS, &r->msg));
 
1307
                        break; }
 
1308
 
 
1309
                        case DGRAM_ERROR: {
 
1310
                                NDR_CHECK(ndr_push_dgram_err_code(ndr, NDR_SCALARS, r->error));
 
1311
                        break; }
 
1312
 
 
1313
                        case DGRAM_QUERY: {
 
1314
                                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1315
                        break; }
 
1316
 
 
1317
                        case DGRAM_QUERY_POSITIVE: {
 
1318
                                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1319
                        break; }
 
1320
 
 
1321
                        case DGRAM_QUERY_NEGATIVE: {
 
1322
                                NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1323
                        break; }
 
1324
 
 
1325
                        default:
 
1326
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1327
                }
 
1328
        }
 
1329
        if (ndr_flags & NDR_BUFFERS) {
 
1330
                int level = ndr_push_get_switch_value(ndr, r);
 
1331
                switch (level) {
 
1332
                        case DGRAM_DIRECT_UNIQUE:
 
1333
                        break;
 
1334
 
 
1335
                        case DGRAM_DIRECT_GROUP:
 
1336
                        break;
 
1337
 
 
1338
                        case DGRAM_BCAST:
 
1339
                        break;
 
1340
 
 
1341
                        case DGRAM_ERROR:
 
1342
                        break;
 
1343
 
 
1344
                        case DGRAM_QUERY:
 
1345
                        break;
 
1346
 
 
1347
                        case DGRAM_QUERY_POSITIVE:
 
1348
                        break;
 
1349
 
 
1350
                        case DGRAM_QUERY_NEGATIVE:
 
1351
                        break;
 
1352
 
 
1353
                        default:
 
1354
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1355
                }
 
1356
        }
 
1357
        return NDR_ERR_SUCCESS;
 
1358
}
 
1359
 
 
1360
static enum ndr_err_code ndr_pull_dgram_data(struct ndr_pull *ndr, int ndr_flags, union dgram_data *r)
 
1361
{
 
1362
        int level;
 
1363
        level = ndr_pull_get_switch_value(ndr, r);
 
1364
        if (ndr_flags & NDR_SCALARS) {
 
1365
                switch (level) {
 
1366
                        case DGRAM_DIRECT_UNIQUE: {
 
1367
                                NDR_CHECK(ndr_pull_dgram_message(ndr, NDR_SCALARS, &r->msg));
 
1368
                        break; }
 
1369
 
 
1370
                        case DGRAM_DIRECT_GROUP: {
 
1371
                                NDR_CHECK(ndr_pull_dgram_message(ndr, NDR_SCALARS, &r->msg));
 
1372
                        break; }
 
1373
 
 
1374
                        case DGRAM_BCAST: {
 
1375
                                NDR_CHECK(ndr_pull_dgram_message(ndr, NDR_SCALARS, &r->msg));
 
1376
                        break; }
 
1377
 
 
1378
                        case DGRAM_ERROR: {
 
1379
                                NDR_CHECK(ndr_pull_dgram_err_code(ndr, NDR_SCALARS, &r->error));
 
1380
                        break; }
 
1381
 
 
1382
                        case DGRAM_QUERY: {
 
1383
                                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1384
                        break; }
 
1385
 
 
1386
                        case DGRAM_QUERY_POSITIVE: {
 
1387
                                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1388
                        break; }
 
1389
 
 
1390
                        case DGRAM_QUERY_NEGATIVE: {
 
1391
                                NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->dest_name));
 
1392
                        break; }
 
1393
 
 
1394
                        default:
 
1395
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1396
                }
 
1397
        }
 
1398
        if (ndr_flags & NDR_BUFFERS) {
 
1399
                switch (level) {
 
1400
                        case DGRAM_DIRECT_UNIQUE:
 
1401
                        break;
 
1402
 
 
1403
                        case DGRAM_DIRECT_GROUP:
 
1404
                        break;
 
1405
 
 
1406
                        case DGRAM_BCAST:
 
1407
                        break;
 
1408
 
 
1409
                        case DGRAM_ERROR:
 
1410
                        break;
 
1411
 
 
1412
                        case DGRAM_QUERY:
 
1413
                        break;
 
1414
 
 
1415
                        case DGRAM_QUERY_POSITIVE:
 
1416
                        break;
 
1417
 
 
1418
                        case DGRAM_QUERY_NEGATIVE:
 
1419
                        break;
 
1420
 
 
1421
                        default:
 
1422
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
1423
                }
 
1424
        }
 
1425
        return NDR_ERR_SUCCESS;
 
1426
}
 
1427
 
 
1428
_PUBLIC_ void ndr_print_dgram_data(struct ndr_print *ndr, const char *name, const union dgram_data *r)
 
1429
{
 
1430
        int level;
 
1431
        level = ndr_print_get_switch_value(ndr, r);
 
1432
        ndr_print_union(ndr, name, level, "dgram_data");
 
1433
        switch (level) {
 
1434
                case DGRAM_DIRECT_UNIQUE:
 
1435
                        ndr_print_dgram_message(ndr, "msg", &r->msg);
 
1436
                break;
 
1437
 
 
1438
                case DGRAM_DIRECT_GROUP:
 
1439
                        ndr_print_dgram_message(ndr, "msg", &r->msg);
 
1440
                break;
 
1441
 
 
1442
                case DGRAM_BCAST:
 
1443
                        ndr_print_dgram_message(ndr, "msg", &r->msg);
 
1444
                break;
 
1445
 
 
1446
                case DGRAM_ERROR:
 
1447
                        ndr_print_dgram_err_code(ndr, "error", r->error);
 
1448
                break;
 
1449
 
 
1450
                case DGRAM_QUERY:
 
1451
                        ndr_print_nbt_name(ndr, "dest_name", &r->dest_name);
 
1452
                break;
 
1453
 
 
1454
                case DGRAM_QUERY_POSITIVE:
 
1455
                        ndr_print_nbt_name(ndr, "dest_name", &r->dest_name);
 
1456
                break;
 
1457
 
 
1458
                case DGRAM_QUERY_NEGATIVE:
 
1459
                        ndr_print_nbt_name(ndr, "dest_name", &r->dest_name);
 
1460
                break;
 
1461
 
 
1462
                default:
 
1463
                        ndr_print_bad_level(ndr, name, level);
 
1464
        }
 
1465
}
 
1466
 
 
1467
_PUBLIC_ enum ndr_err_code ndr_push_nbt_dgram_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_dgram_packet *r)
 
1468
{
 
1469
        {
 
1470
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1471
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
1472
                if (ndr_flags & NDR_SCALARS) {
 
1473
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
1474
                        NDR_CHECK(ndr_push_dgram_msg_type(ndr, NDR_SCALARS, r->msg_type));
 
1475
                        NDR_CHECK(ndr_push_dgram_flags(ndr, NDR_SCALARS, r->flags));
 
1476
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->dgram_id));
 
1477
                        NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->src_addr));
 
1478
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->src_port));
 
1479
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->msg_type));
 
1480
                        NDR_CHECK(ndr_push_dgram_data(ndr, NDR_SCALARS, &r->data));
 
1481
                }
 
1482
                if (ndr_flags & NDR_BUFFERS) {
 
1483
                }
 
1484
                ndr->flags = _flags_save_STRUCT;
 
1485
        }
 
1486
        return NDR_ERR_SUCCESS;
 
1487
}
 
1488
 
 
1489
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_dgram_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_dgram_packet *r)
 
1490
{
 
1491
        {
 
1492
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1493
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
1494
                if (ndr_flags & NDR_SCALARS) {
 
1495
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
1496
                        NDR_CHECK(ndr_pull_dgram_msg_type(ndr, NDR_SCALARS, &r->msg_type));
 
1497
                        NDR_CHECK(ndr_pull_dgram_flags(ndr, NDR_SCALARS, &r->flags));
 
1498
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->dgram_id));
 
1499
                        NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->src_addr));
 
1500
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->src_port));
 
1501
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->msg_type));
 
1502
                        NDR_CHECK(ndr_pull_dgram_data(ndr, NDR_SCALARS, &r->data));
 
1503
                }
 
1504
                if (ndr_flags & NDR_BUFFERS) {
 
1505
                }
 
1506
                ndr->flags = _flags_save_STRUCT;
 
1507
        }
 
1508
        return NDR_ERR_SUCCESS;
 
1509
}
 
1510
 
 
1511
_PUBLIC_ void ndr_print_nbt_dgram_packet(struct ndr_print *ndr, const char *name, const struct nbt_dgram_packet *r)
 
1512
{
 
1513
        ndr_print_struct(ndr, name, "nbt_dgram_packet");
 
1514
        {
 
1515
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1516
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX);
 
1517
                ndr->depth++;
 
1518
                ndr_print_dgram_msg_type(ndr, "msg_type", r->msg_type);
 
1519
                ndr_print_dgram_flags(ndr, "flags", r->flags);
 
1520
                ndr_print_uint16(ndr, "dgram_id", r->dgram_id);
 
1521
                ndr_print_ipv4address(ndr, "src_addr", r->src_addr);
 
1522
                ndr_print_uint16(ndr, "src_port", r->src_port);
 
1523
                ndr_print_set_switch_value(ndr, &r->data, r->msg_type);
 
1524
                ndr_print_dgram_data(ndr, "data", &r->data);
 
1525
                ndr->depth--;
 
1526
                ndr->flags = _flags_save_STRUCT;
 
1527
        }
 
1528
}
 
1529
 
 
1530
_PUBLIC_ enum ndr_err_code ndr_push_nbt_sockaddr(struct ndr_push *ndr, int ndr_flags, const struct nbt_sockaddr *r)
 
1531
{
 
1532
        if (ndr_flags & NDR_SCALARS) {
 
1533
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1534
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sockaddr_family));
 
1535
                {
 
1536
                        uint32_t _flags_save_ipv4address = ndr->flags;
 
1537
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 
1538
                        NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->pdc_ip));
 
1539
                        ndr->flags = _flags_save_ipv4address;
 
1540
                }
 
1541
                {
 
1542
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
1543
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
1544
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
 
1545
                        ndr->flags = _flags_save_DATA_BLOB;
 
1546
                }
 
1547
        }
 
1548
        if (ndr_flags & NDR_BUFFERS) {
 
1549
        }
 
1550
        return NDR_ERR_SUCCESS;
 
1551
}
 
1552
 
 
1553
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_sockaddr(struct ndr_pull *ndr, int ndr_flags, struct nbt_sockaddr *r)
 
1554
{
 
1555
        if (ndr_flags & NDR_SCALARS) {
 
1556
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1557
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sockaddr_family));
 
1558
                {
 
1559
                        uint32_t _flags_save_ipv4address = ndr->flags;
 
1560
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 
1561
                        NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->pdc_ip));
 
1562
                        ndr->flags = _flags_save_ipv4address;
 
1563
                }
 
1564
                {
 
1565
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
1566
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
1567
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
 
1568
                        ndr->flags = _flags_save_DATA_BLOB;
 
1569
                }
 
1570
        }
 
1571
        if (ndr_flags & NDR_BUFFERS) {
 
1572
        }
 
1573
        return NDR_ERR_SUCCESS;
 
1574
}
 
1575
 
 
1576
_PUBLIC_ void ndr_print_nbt_sockaddr(struct ndr_print *ndr, const char *name, const struct nbt_sockaddr *r)
 
1577
{
 
1578
        ndr_print_struct(ndr, name, "nbt_sockaddr");
 
1579
        ndr->depth++;
 
1580
        ndr_print_uint32(ndr, "sockaddr_family", r->sockaddr_family);
 
1581
        ndr_print_ipv4address(ndr, "pdc_ip", r->pdc_ip);
 
1582
        ndr_print_DATA_BLOB(ndr, "remaining", r->remaining);
 
1583
        ndr->depth--;
 
1584
}
 
1585
 
 
1586
_PUBLIC_ size_t ndr_size_nbt_sockaddr(const struct nbt_sockaddr *r, struct smb_iconv_convenience *ic, int flags)
 
1587
{
 
1588
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_nbt_sockaddr, ic);
 
1589
}
 
1590
 
 
1591
_PUBLIC_ enum ndr_err_code ndr_push_nbt_server_type(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
1592
{
 
1593
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
1594
        return NDR_ERR_SUCCESS;
 
1595
}
 
1596
 
 
1597
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_server_type(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
1598
{
 
1599
        uint32_t v;
 
1600
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
1601
        *r = v;
 
1602
        return NDR_ERR_SUCCESS;
 
1603
}
 
1604
 
 
1605
_PUBLIC_ void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name, uint32_t r)
 
1606
{
 
1607
        ndr_print_uint32(ndr, name, r);
 
1608
        ndr->depth++;
 
1609
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_PDC", NBT_SERVER_PDC, r);
 
1610
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_GC", NBT_SERVER_GC, r);
 
1611
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_LDAP", NBT_SERVER_LDAP, r);
 
1612
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_DS", NBT_SERVER_DS, r);
 
1613
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_KDC", NBT_SERVER_KDC, r);
 
1614
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_TIMESERV", NBT_SERVER_TIMESERV, r);
 
1615
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_CLOSEST", NBT_SERVER_CLOSEST, r);
 
1616
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_WRITABLE", NBT_SERVER_WRITABLE, r);
 
1617
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_GOOD_TIMESERV", NBT_SERVER_GOOD_TIMESERV, r);
 
1618
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_NDNC", NBT_SERVER_NDNC, r);
 
1619
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_SELECT_SECRET_DOMAIN_6", NBT_SERVER_SELECT_SECRET_DOMAIN_6, r);
 
1620
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_FULL_SECRET_DOMAIN_6", NBT_SERVER_FULL_SECRET_DOMAIN_6, r);
 
1621
        ndr->depth--;
 
1622
}
 
1623
 
 
1624
_PUBLIC_ enum ndr_err_code ndr_push_netlogon_nt_version_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
1625
{
 
1626
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
1627
        return NDR_ERR_SUCCESS;
 
1628
}
 
1629
 
 
1630
_PUBLIC_ enum ndr_err_code ndr_pull_netlogon_nt_version_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
1631
{
 
1632
        uint32_t v;
 
1633
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
1634
        *r = v;
 
1635
        return NDR_ERR_SUCCESS;
 
1636
}
 
1637
 
 
1638
_PUBLIC_ void ndr_print_netlogon_nt_version_flags(struct ndr_print *ndr, const char *name, uint32_t r)
 
1639
{
 
1640
        ndr_print_uint32(ndr, name, r);
 
1641
        ndr->depth++;
 
1642
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_1", NETLOGON_NT_VERSION_1, r);
 
1643
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_5", NETLOGON_NT_VERSION_5, r);
 
1644
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_5EX", NETLOGON_NT_VERSION_5EX, r);
 
1645
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_5EX_WITH_IP", NETLOGON_NT_VERSION_5EX_WITH_IP, r);
 
1646
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_WITH_CLOSEST_SITE", NETLOGON_NT_VERSION_WITH_CLOSEST_SITE, r);
 
1647
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_AVIOD_NT4EMUL", NETLOGON_NT_VERSION_AVIOD_NT4EMUL, r);
 
1648
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_PDC", NETLOGON_NT_VERSION_PDC, r);
 
1649
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_IP", NETLOGON_NT_VERSION_IP, r);
 
1650
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_LOCAL", NETLOGON_NT_VERSION_LOCAL, r);
 
1651
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_GC", NETLOGON_NT_VERSION_GC, r);
 
1652
        ndr->depth--;
 
1653
}
 
1654
 
 
1655
_PUBLIC_ enum ndr_err_code ndr_push_netlogon_command(struct ndr_push *ndr, int ndr_flags, enum netlogon_command r)
 
1656
{
 
1657
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
1658
        return NDR_ERR_SUCCESS;
 
1659
}
 
1660
 
 
1661
_PUBLIC_ enum ndr_err_code ndr_pull_netlogon_command(struct ndr_pull *ndr, int ndr_flags, enum netlogon_command *r)
 
1662
{
 
1663
        uint16_t v;
 
1664
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
1665
        *r = v;
 
1666
        return NDR_ERR_SUCCESS;
 
1667
}
 
1668
 
 
1669
_PUBLIC_ void ndr_print_netlogon_command(struct ndr_print *ndr, const char *name, enum netlogon_command r)
 
1670
{
 
1671
        const char *val = NULL;
 
1672
 
 
1673
        switch (r) {
 
1674
                case LOGON_PRIMARY_QUERY: val = "LOGON_PRIMARY_QUERY"; break;
 
1675
                case NETLOGON_ANNOUNCE_UAS: val = "NETLOGON_ANNOUNCE_UAS"; break;
 
1676
                case NETLOGON_RESPONSE_FROM_PDC: val = "NETLOGON_RESPONSE_FROM_PDC"; break;
 
1677
                case LOGON_SAM_LOGON_REQUEST: val = "LOGON_SAM_LOGON_REQUEST"; break;
 
1678
                case LOGON_SAM_LOGON_RESPONSE: val = "LOGON_SAM_LOGON_RESPONSE"; break;
 
1679
                case LOGON_SAM_LOGON_PAUSE_RESPONSE: val = "LOGON_SAM_LOGON_PAUSE_RESPONSE"; break;
 
1680
                case LOGON_SAM_LOGON_USER_UNKNOWN: val = "LOGON_SAM_LOGON_USER_UNKNOWN"; break;
 
1681
                case LOGON_SAM_LOGON_RESPONSE_EX: val = "LOGON_SAM_LOGON_RESPONSE_EX"; break;
 
1682
                case LOGON_SAM_LOGON_PAUSE_RESPONSE_EX: val = "LOGON_SAM_LOGON_PAUSE_RESPONSE_EX"; break;
 
1683
                case LOGON_SAM_LOGON_USER_UNKNOWN_EX: val = "LOGON_SAM_LOGON_USER_UNKNOWN_EX"; break;
 
1684
        }
 
1685
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1686
}
 
1687
 
 
1688
_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_REQUEST(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_REQUEST *r)
 
1689
{
 
1690
        ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_REQUEST");
 
1691
        ndr->depth++;
 
1692
        ndr_print_uint16(ndr, "request_count", r->request_count);
 
1693
        ndr_print_string(ndr, "computer_name", r->computer_name);
 
1694
        ndr_print_string(ndr, "user_name", r->user_name);
 
1695
        ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
 
1696
        ndr_print_samr_AcctFlags(ndr, "acct_control", r->acct_control);
 
1697
        ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
 
1698
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
1699
        ndr_print_dom_sid0(ndr, "sid", &r->sid);
 
1700
        ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
 
1701
        ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
 
1702
        ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
 
1703
        ndr->depth--;
 
1704
}
 
1705
 
 
1706
_PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r)
 
1707
{
 
1708
        {
 
1709
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1710
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1711
                if (ndr_flags & NDR_SCALARS) {
 
1712
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
1713
                        NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
 
1714
                        {
 
1715
                                uint32_t _flags_save_string = ndr->flags;
 
1716
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1717
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server));
 
1718
                                ndr->flags = _flags_save_string;
 
1719
                        }
 
1720
                        {
 
1721
                                uint32_t _flags_save_string = ndr->flags;
 
1722
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1723
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
 
1724
                                ndr->flags = _flags_save_string;
 
1725
                        }
 
1726
                        {
 
1727
                                uint32_t _flags_save_string = ndr->flags;
 
1728
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1729
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain));
 
1730
                                ndr->flags = _flags_save_string;
 
1731
                        }
 
1732
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
 
1733
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
 
1734
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
 
1735
                }
 
1736
                if (ndr_flags & NDR_BUFFERS) {
 
1737
                }
 
1738
                ndr->flags = _flags_save_STRUCT;
 
1739
        }
 
1740
        return NDR_ERR_SUCCESS;
 
1741
}
 
1742
 
 
1743
_PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r)
 
1744
{
 
1745
        {
 
1746
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1747
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1748
                if (ndr_flags & NDR_SCALARS) {
 
1749
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
1750
                        NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
 
1751
                        {
 
1752
                                uint32_t _flags_save_string = ndr->flags;
 
1753
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1754
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server));
 
1755
                                ndr->flags = _flags_save_string;
 
1756
                        }
 
1757
                        {
 
1758
                                uint32_t _flags_save_string = ndr->flags;
 
1759
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1760
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
 
1761
                                ndr->flags = _flags_save_string;
 
1762
                        }
 
1763
                        {
 
1764
                                uint32_t _flags_save_string = ndr->flags;
 
1765
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1766
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain));
 
1767
                                ndr->flags = _flags_save_string;
 
1768
                        }
 
1769
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
 
1770
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
 
1771
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
 
1772
                }
 
1773
                if (ndr_flags & NDR_BUFFERS) {
 
1774
                }
 
1775
                ndr->flags = _flags_save_STRUCT;
 
1776
        }
 
1777
        return NDR_ERR_SUCCESS;
 
1778
}
 
1779
 
 
1780
_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r)
 
1781
{
 
1782
        ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_RESPONSE_NT40");
 
1783
        {
 
1784
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1785
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1786
                ndr->depth++;
 
1787
                ndr_print_netlogon_command(ndr, "command", r->command);
 
1788
                ndr_print_string(ndr, "server", r->server);
 
1789
                ndr_print_string(ndr, "user_name", r->user_name);
 
1790
                ndr_print_string(ndr, "domain", r->domain);
 
1791
                ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
 
1792
                ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
 
1793
                ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
 
1794
                ndr->depth--;
 
1795
                ndr->flags = _flags_save_STRUCT;
 
1796
        }
 
1797
}
 
1798
 
 
1799
_PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE *r)
 
1800
{
 
1801
        {
 
1802
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1803
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1804
                if (ndr_flags & NDR_SCALARS) {
 
1805
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
1806
                        NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
 
1807
                        {
 
1808
                                uint32_t _flags_save_string = ndr->flags;
 
1809
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1810
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
 
1811
                                ndr->flags = _flags_save_string;
 
1812
                        }
 
1813
                        {
 
1814
                                uint32_t _flags_save_string = ndr->flags;
 
1815
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1816
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
 
1817
                                ndr->flags = _flags_save_string;
 
1818
                        }
 
1819
                        {
 
1820
                                uint32_t _flags_save_string = ndr->flags;
 
1821
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1822
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
 
1823
                                ndr->flags = _flags_save_string;
 
1824
                        }
 
1825
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
 
1826
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->zero_uuid));
 
1827
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
 
1828
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
 
1829
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
 
1830
                        NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->pdc_ip));
 
1831
                        NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
 
1832
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
 
1833
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
 
1834
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
 
1835
                }
 
1836
                if (ndr_flags & NDR_BUFFERS) {
 
1837
                }
 
1838
                ndr->flags = _flags_save_STRUCT;
 
1839
        }
 
1840
        return NDR_ERR_SUCCESS;
 
1841
}
 
1842
 
 
1843
_PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE *r)
 
1844
{
 
1845
        {
 
1846
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1847
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1848
                if (ndr_flags & NDR_SCALARS) {
 
1849
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
1850
                        NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
 
1851
                        {
 
1852
                                uint32_t _flags_save_string = ndr->flags;
 
1853
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1854
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
 
1855
                                ndr->flags = _flags_save_string;
 
1856
                        }
 
1857
                        {
 
1858
                                uint32_t _flags_save_string = ndr->flags;
 
1859
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1860
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
 
1861
                                ndr->flags = _flags_save_string;
 
1862
                        }
 
1863
                        {
 
1864
                                uint32_t _flags_save_string = ndr->flags;
 
1865
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
1866
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
 
1867
                                ndr->flags = _flags_save_string;
 
1868
                        }
 
1869
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
 
1870
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->zero_uuid));
 
1871
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
 
1872
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
 
1873
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
 
1874
                        NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->pdc_ip));
 
1875
                        NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
 
1876
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
 
1877
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
 
1878
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
 
1879
                }
 
1880
                if (ndr_flags & NDR_BUFFERS) {
 
1881
                }
 
1882
                ndr->flags = _flags_save_STRUCT;
 
1883
        }
 
1884
        return NDR_ERR_SUCCESS;
 
1885
}
 
1886
 
 
1887
_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE *r)
 
1888
{
 
1889
        ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_RESPONSE");
 
1890
        {
 
1891
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1892
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1893
                ndr->depth++;
 
1894
                ndr_print_netlogon_command(ndr, "command", r->command);
 
1895
                ndr_print_string(ndr, "pdc_name", r->pdc_name);
 
1896
                ndr_print_string(ndr, "user_name", r->user_name);
 
1897
                ndr_print_string(ndr, "domain_name", r->domain_name);
 
1898
                ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
 
1899
                ndr_print_GUID(ndr, "zero_uuid", &r->zero_uuid);
 
1900
                ndr_print_nbt_string(ndr, "forest", r->forest);
 
1901
                ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
 
1902
                ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
 
1903
                ndr_print_ipv4address(ndr, "pdc_ip", r->pdc_ip);
 
1904
                ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
 
1905
                ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
 
1906
                ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
 
1907
                ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
 
1908
                ndr->depth--;
 
1909
                ndr->flags = _flags_save_STRUCT;
 
1910
        }
 
1911
}
 
1912
 
 
1913
_PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
 
1914
{
 
1915
        {
 
1916
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1917
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1918
                if (ndr_flags & NDR_SCALARS) {
 
1919
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
1920
                        NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
 
1921
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
 
1922
                        NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
 
1923
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
 
1924
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
 
1925
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
 
1926
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
 
1927
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
 
1928
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
 
1929
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
 
1930
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
 
1931
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
 
1932
                        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags)));
 
1933
                        {
 
1934
                                struct ndr_push *_ndr_sockaddr;
 
1935
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags)));
 
1936
                                NDR_CHECK(ndr_push_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS, &r->sockaddr));
 
1937
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags)));
 
1938
                        }
 
1939
                        NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->next_closest_site));
 
1940
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
 
1941
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
 
1942
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
 
1943
                }
 
1944
                if (ndr_flags & NDR_BUFFERS) {
 
1945
                }
 
1946
                ndr->flags = _flags_save_STRUCT;
 
1947
        }
 
1948
        return NDR_ERR_SUCCESS;
 
1949
}
 
1950
 
 
1951
_PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
 
1952
{
 
1953
        {
 
1954
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1955
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1956
                if (ndr_flags & NDR_SCALARS) {
 
1957
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
1958
                        NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
 
1959
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
 
1960
                        NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
 
1961
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
 
1962
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
 
1963
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
 
1964
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
 
1965
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
 
1966
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
 
1967
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
 
1968
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
 
1969
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
 
1970
                        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sockaddr_size));
 
1971
                        {
 
1972
                                struct ndr_pull *_ndr_sockaddr;
 
1973
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sockaddr, 0, r->sockaddr_size));
 
1974
                                NDR_CHECK(ndr_pull_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS, &r->sockaddr));
 
1975
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sockaddr, 0, r->sockaddr_size));
 
1976
                        }
 
1977
                        NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->next_closest_site));
 
1978
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
 
1979
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
 
1980
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
 
1981
                }
 
1982
                if (ndr_flags & NDR_BUFFERS) {
 
1983
                }
 
1984
                ndr->flags = _flags_save_STRUCT;
 
1985
        }
 
1986
        return NDR_ERR_SUCCESS;
 
1987
}
 
1988
 
 
1989
_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
 
1990
{
 
1991
        ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_RESPONSE_EX");
 
1992
        {
 
1993
                uint32_t _flags_save_STRUCT = ndr->flags;
 
1994
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
1995
                ndr->depth++;
 
1996
                ndr_print_netlogon_command(ndr, "command", r->command);
 
1997
                ndr_print_uint16(ndr, "sbz", r->sbz);
 
1998
                ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
 
1999
                ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
 
2000
                ndr_print_nbt_string(ndr, "forest", r->forest);
 
2001
                ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
 
2002
                ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
 
2003
                ndr_print_nbt_string(ndr, "domain", r->domain);
 
2004
                ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
 
2005
                ndr_print_nbt_string(ndr, "user_name", r->user_name);
 
2006
                ndr_print_nbt_string(ndr, "server_site", r->server_site);
 
2007
                ndr_print_nbt_string(ndr, "client_site", r->client_site);
 
2008
                ndr_print_uint8(ndr, "sockaddr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags):r->sockaddr_size);
 
2009
                ndr_print_nbt_sockaddr(ndr, "sockaddr", &r->sockaddr);
 
2010
                ndr_print_nbt_string(ndr, "next_closest_site", r->next_closest_site);
 
2011
                ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
 
2012
                ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
 
2013
                ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
 
2014
                ndr->depth--;
 
2015
                ndr->flags = _flags_save_STRUCT;
 
2016
        }
 
2017
}
 
2018
 
 
2019
static enum ndr_err_code ndr_push_nbt_netlogon_query_for_pdc(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_query_for_pdc *r)
 
2020
{
 
2021
        if (ndr_flags & NDR_SCALARS) {
 
2022
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2023
                {
 
2024
                        uint32_t _flags_save_string = ndr->flags;
 
2025
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2026
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->computer_name));
 
2027
                        ndr->flags = _flags_save_string;
 
2028
                }
 
2029
                {
 
2030
                        uint32_t _flags_save_string = ndr->flags;
 
2031
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2032
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mailslot_name));
 
2033
                        ndr->flags = _flags_save_string;
 
2034
                }
 
2035
                {
 
2036
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
2037
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
 
2038
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 
2039
                        ndr->flags = _flags_save_DATA_BLOB;
 
2040
                }
 
2041
                {
 
2042
                        uint32_t _flags_save_string = ndr->flags;
 
2043
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2044
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_name));
 
2045
                        ndr->flags = _flags_save_string;
 
2046
                }
 
2047
                NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
 
2048
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
 
2049
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
 
2050
        }
 
2051
        if (ndr_flags & NDR_BUFFERS) {
 
2052
        }
 
2053
        return NDR_ERR_SUCCESS;
 
2054
}
 
2055
 
 
2056
static enum ndr_err_code ndr_pull_nbt_netlogon_query_for_pdc(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_query_for_pdc *r)
 
2057
{
 
2058
        if (ndr_flags & NDR_SCALARS) {
 
2059
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2060
                {
 
2061
                        uint32_t _flags_save_string = ndr->flags;
 
2062
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2063
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
 
2064
                        ndr->flags = _flags_save_string;
 
2065
                }
 
2066
                {
 
2067
                        uint32_t _flags_save_string = ndr->flags;
 
2068
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2069
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mailslot_name));
 
2070
                        ndr->flags = _flags_save_string;
 
2071
                }
 
2072
                {
 
2073
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
2074
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
 
2075
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 
2076
                        ndr->flags = _flags_save_DATA_BLOB;
 
2077
                }
 
2078
                {
 
2079
                        uint32_t _flags_save_string = ndr->flags;
 
2080
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2081
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_name));
 
2082
                        ndr->flags = _flags_save_string;
 
2083
                }
 
2084
                NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
 
2085
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
 
2086
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
 
2087
        }
 
2088
        if (ndr_flags & NDR_BUFFERS) {
 
2089
        }
 
2090
        return NDR_ERR_SUCCESS;
 
2091
}
 
2092
 
 
2093
_PUBLIC_ void ndr_print_nbt_netlogon_query_for_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_query_for_pdc *r)
 
2094
{
 
2095
        ndr_print_struct(ndr, name, "nbt_netlogon_query_for_pdc");
 
2096
        ndr->depth++;
 
2097
        ndr_print_string(ndr, "computer_name", r->computer_name);
 
2098
        ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
 
2099
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
2100
        ndr_print_string(ndr, "unicode_name", r->unicode_name);
 
2101
        ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
 
2102
        ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
 
2103
        ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
 
2104
        ndr->depth--;
 
2105
}
 
2106
 
 
2107
_PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_response_from_pdc(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_response_from_pdc *r)
 
2108
{
 
2109
        {
 
2110
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2111
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
2112
                if (ndr_flags & NDR_SCALARS) {
 
2113
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
2114
                        NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
 
2115
                        {
 
2116
                                uint32_t _flags_save_string = ndr->flags;
 
2117
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2118
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
 
2119
                                ndr->flags = _flags_save_string;
 
2120
                        }
 
2121
                        {
 
2122
                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
2123
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
 
2124
                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 
2125
                                ndr->flags = _flags_save_DATA_BLOB;
 
2126
                        }
 
2127
                        {
 
2128
                                uint32_t _flags_save_string = ndr->flags;
 
2129
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2130
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_pdc_name));
 
2131
                                ndr->flags = _flags_save_string;
 
2132
                        }
 
2133
                        {
 
2134
                                uint32_t _flags_save_string = ndr->flags;
 
2135
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2136
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
 
2137
                                ndr->flags = _flags_save_string;
 
2138
                        }
 
2139
                        NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
 
2140
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
 
2141
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
 
2142
                }
 
2143
                if (ndr_flags & NDR_BUFFERS) {
 
2144
                }
 
2145
                ndr->flags = _flags_save_STRUCT;
 
2146
        }
 
2147
        return NDR_ERR_SUCCESS;
 
2148
}
 
2149
 
 
2150
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_response_from_pdc(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_response_from_pdc *r)
 
2151
{
 
2152
        {
 
2153
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2154
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
2155
                if (ndr_flags & NDR_SCALARS) {
 
2156
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
2157
                        NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
 
2158
                        {
 
2159
                                uint32_t _flags_save_string = ndr->flags;
 
2160
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2161
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
 
2162
                                ndr->flags = _flags_save_string;
 
2163
                        }
 
2164
                        {
 
2165
                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
2166
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
 
2167
                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 
2168
                                ndr->flags = _flags_save_DATA_BLOB;
 
2169
                        }
 
2170
                        {
 
2171
                                uint32_t _flags_save_string = ndr->flags;
 
2172
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2173
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_pdc_name));
 
2174
                                ndr->flags = _flags_save_string;
 
2175
                        }
 
2176
                        {
 
2177
                                uint32_t _flags_save_string = ndr->flags;
 
2178
                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2179
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
 
2180
                                ndr->flags = _flags_save_string;
 
2181
                        }
 
2182
                        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
 
2183
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
 
2184
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
 
2185
                }
 
2186
                if (ndr_flags & NDR_BUFFERS) {
 
2187
                }
 
2188
                ndr->flags = _flags_save_STRUCT;
 
2189
        }
 
2190
        return NDR_ERR_SUCCESS;
 
2191
}
 
2192
 
 
2193
_PUBLIC_ void ndr_print_nbt_netlogon_response_from_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc *r)
 
2194
{
 
2195
        ndr_print_struct(ndr, name, "nbt_netlogon_response_from_pdc");
 
2196
        {
 
2197
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2198
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
2199
                ndr->depth++;
 
2200
                ndr_print_netlogon_command(ndr, "command", r->command);
 
2201
                ndr_print_string(ndr, "pdc_name", r->pdc_name);
 
2202
                ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
2203
                ndr_print_string(ndr, "unicode_pdc_name", r->unicode_pdc_name);
 
2204
                ndr_print_string(ndr, "domain_name", r->domain_name);
 
2205
                ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
 
2206
                ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
 
2207
                ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
 
2208
                ndr->depth--;
 
2209
                ndr->flags = _flags_save_STRUCT;
 
2210
        }
 
2211
}
 
2212
 
 
2213
static enum ndr_err_code ndr_push_nbt_db_change_info(struct ndr_push *ndr, int ndr_flags, const struct nbt_db_change_info *r)
 
2214
{
 
2215
        if (ndr_flags & NDR_SCALARS) {
 
2216
                NDR_CHECK(ndr_push_align(ndr, 8));
 
2217
                NDR_CHECK(ndr_push_netr_SamDatabaseID(ndr, NDR_SCALARS, r->db_index));
 
2218
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->serial));
 
2219
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
 
2220
        }
 
2221
        if (ndr_flags & NDR_BUFFERS) {
 
2222
        }
 
2223
        return NDR_ERR_SUCCESS;
 
2224
}
 
2225
 
 
2226
static enum ndr_err_code ndr_pull_nbt_db_change_info(struct ndr_pull *ndr, int ndr_flags, struct nbt_db_change_info *r)
 
2227
{
 
2228
        if (ndr_flags & NDR_SCALARS) {
 
2229
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
2230
                NDR_CHECK(ndr_pull_netr_SamDatabaseID(ndr, NDR_SCALARS, &r->db_index));
 
2231
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->serial));
 
2232
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
 
2233
        }
 
2234
        if (ndr_flags & NDR_BUFFERS) {
 
2235
        }
 
2236
        return NDR_ERR_SUCCESS;
 
2237
}
 
2238
 
 
2239
_PUBLIC_ void ndr_print_nbt_db_change_info(struct ndr_print *ndr, const char *name, const struct nbt_db_change_info *r)
 
2240
{
 
2241
        ndr_print_struct(ndr, name, "nbt_db_change_info");
 
2242
        ndr->depth++;
 
2243
        ndr_print_netr_SamDatabaseID(ndr, "db_index", r->db_index);
 
2244
        ndr_print_hyper(ndr, "serial", r->serial);
 
2245
        ndr_print_NTTIME(ndr, "timestamp", r->timestamp);
 
2246
        ndr->depth--;
 
2247
}
 
2248
 
 
2249
static enum ndr_err_code ndr_push_NETLOGON_DB_CHANGE(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_DB_CHANGE *r)
 
2250
{
 
2251
        uint32_t cntr_dbchange_0;
 
2252
        if (ndr_flags & NDR_SCALARS) {
 
2253
                NDR_CHECK(ndr_push_align(ndr, 8));
 
2254
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_lo));
 
2255
                NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
 
2256
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pulse));
 
2257
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->random));
 
2258
                {
 
2259
                        uint32_t _flags_save_string = ndr->flags;
 
2260
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2261
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
 
2262
                        ndr->flags = _flags_save_string;
 
2263
                }
 
2264
                {
 
2265
                        uint32_t _flags_save_string = ndr->flags;
 
2266
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2267
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain));
 
2268
                        ndr->flags = _flags_save_string;
 
2269
                }
 
2270
                {
 
2271
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
2272
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
 
2273
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 
2274
                        ndr->flags = _flags_save_DATA_BLOB;
 
2275
                }
 
2276
                {
 
2277
                        uint32_t _flags_save_string = ndr->flags;
 
2278
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2279
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_pdc_name));
 
2280
                        ndr->flags = _flags_save_string;
 
2281
                }
 
2282
                {
 
2283
                        uint32_t _flags_save_string = ndr->flags;
 
2284
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2285
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_domain));
 
2286
                        ndr->flags = _flags_save_string;
 
2287
                }
 
2288
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->db_count));
 
2289
                for (cntr_dbchange_0 = 0; cntr_dbchange_0 < r->db_count; cntr_dbchange_0++) {
 
2290
                        NDR_CHECK(ndr_push_nbt_db_change_info(ndr, NDR_SCALARS, &r->dbchange[cntr_dbchange_0]));
 
2291
                }
 
2292
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->sid, ndr->flags)));
 
2293
                {
 
2294
                        struct ndr_push *_ndr_sid;
 
2295
                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
 
2296
                        NDR_CHECK(ndr_push_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
 
2297
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
 
2298
                }
 
2299
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->message_format_version));
 
2300
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->message_token));
 
2301
        }
 
2302
        if (ndr_flags & NDR_BUFFERS) {
 
2303
        }
 
2304
        return NDR_ERR_SUCCESS;
 
2305
}
 
2306
 
 
2307
static enum ndr_err_code ndr_pull_NETLOGON_DB_CHANGE(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_DB_CHANGE *r)
 
2308
{
 
2309
        uint32_t cntr_dbchange_0;
 
2310
        TALLOC_CTX *_mem_save_dbchange_0;
 
2311
        if (ndr_flags & NDR_SCALARS) {
 
2312
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
2313
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_lo));
 
2314
                NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
 
2315
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pulse));
 
2316
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->random));
 
2317
                {
 
2318
                        uint32_t _flags_save_string = ndr->flags;
 
2319
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2320
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
 
2321
                        ndr->flags = _flags_save_string;
 
2322
                }
 
2323
                {
 
2324
                        uint32_t _flags_save_string = ndr->flags;
 
2325
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2326
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain));
 
2327
                        ndr->flags = _flags_save_string;
 
2328
                }
 
2329
                {
 
2330
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
2331
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
 
2332
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 
2333
                        ndr->flags = _flags_save_DATA_BLOB;
 
2334
                }
 
2335
                {
 
2336
                        uint32_t _flags_save_string = ndr->flags;
 
2337
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2338
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_pdc_name));
 
2339
                        ndr->flags = _flags_save_string;
 
2340
                }
 
2341
                {
 
2342
                        uint32_t _flags_save_string = ndr->flags;
 
2343
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
2344
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_domain));
 
2345
                        ndr->flags = _flags_save_string;
 
2346
                }
 
2347
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->db_count));
 
2348
                NDR_PULL_ALLOC_N(ndr, r->dbchange, r->db_count);
 
2349
                _mem_save_dbchange_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2350
                NDR_PULL_SET_MEM_CTX(ndr, r->dbchange, 0);
 
2351
                for (cntr_dbchange_0 = 0; cntr_dbchange_0 < r->db_count; cntr_dbchange_0++) {
 
2352
                        NDR_CHECK(ndr_pull_nbt_db_change_info(ndr, NDR_SCALARS, &r->dbchange[cntr_dbchange_0]));
 
2353
                }
 
2354
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dbchange_0, 0);
 
2355
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
 
2356
                {
 
2357
                        struct ndr_pull *_ndr_sid;
 
2358
                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
 
2359
                        NDR_CHECK(ndr_pull_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
 
2360
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
 
2361
                }
 
2362
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->message_format_version));
 
2363
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->message_token));
 
2364
        }
 
2365
        if (ndr_flags & NDR_BUFFERS) {
 
2366
        }
 
2367
        return NDR_ERR_SUCCESS;
 
2368
}
 
2369
 
 
2370
_PUBLIC_ void ndr_print_NETLOGON_DB_CHANGE(struct ndr_print *ndr, const char *name, const struct NETLOGON_DB_CHANGE *r)
 
2371
{
 
2372
        uint32_t cntr_dbchange_0;
 
2373
        ndr_print_struct(ndr, name, "NETLOGON_DB_CHANGE");
 
2374
        ndr->depth++;
 
2375
        ndr_print_uint32(ndr, "serial_lo", r->serial_lo);
 
2376
        ndr_print_time_t(ndr, "timestamp", r->timestamp);
 
2377
        ndr_print_uint32(ndr, "pulse", r->pulse);
 
2378
        ndr_print_uint32(ndr, "random", r->random);
 
2379
        ndr_print_string(ndr, "pdc_name", r->pdc_name);
 
2380
        ndr_print_string(ndr, "domain", r->domain);
 
2381
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
2382
        ndr_print_string(ndr, "unicode_pdc_name", r->unicode_pdc_name);
 
2383
        ndr_print_string(ndr, "unicode_domain", r->unicode_domain);
 
2384
        ndr_print_uint32(ndr, "db_count", r->db_count);
 
2385
        ndr->print(ndr, "%s: ARRAY(%d)", "dbchange", (int)r->db_count);
 
2386
        ndr->depth++;
 
2387
        for (cntr_dbchange_0=0;cntr_dbchange_0<r->db_count;cntr_dbchange_0++) {
 
2388
                char *idx_0=NULL;
 
2389
                if (asprintf(&idx_0, "[%d]", cntr_dbchange_0) != -1) {
 
2390
                        ndr_print_nbt_db_change_info(ndr, "dbchange", &r->dbchange[cntr_dbchange_0]);
 
2391
                        free(idx_0);
 
2392
                }
 
2393
        }
 
2394
        ndr->depth--;
 
2395
        ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
 
2396
        ndr_print_dom_sid0(ndr, "sid", &r->sid);
 
2397
        ndr_print_uint32(ndr, "message_format_version", r->message_format_version);
 
2398
        ndr_print_uint32(ndr, "message_token", r->message_token);
 
2399
        ndr->depth--;
 
2400
}
 
2401
 
 
2402
static enum ndr_err_code ndr_push_nbt_netlogon_request(struct ndr_push *ndr, int ndr_flags, const union nbt_netlogon_request *r)
 
2403
{
 
2404
        if (ndr_flags & NDR_SCALARS) {
 
2405
                int level = ndr_push_get_switch_value(ndr, r);
 
2406
                switch (level) {
 
2407
                        case LOGON_SAM_LOGON_REQUEST: {
 
2408
                                NDR_CHECK(ndr_push_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_SCALARS, &r->logon));
 
2409
                        break; }
 
2410
 
 
2411
                        case LOGON_PRIMARY_QUERY: {
 
2412
                                NDR_CHECK(ndr_push_nbt_netlogon_query_for_pdc(ndr, NDR_SCALARS, &r->pdc));
 
2413
                        break; }
 
2414
 
 
2415
                        case NETLOGON_ANNOUNCE_UAS: {
 
2416
                                NDR_CHECK(ndr_push_NETLOGON_DB_CHANGE(ndr, NDR_SCALARS, &r->uas));
 
2417
                        break; }
 
2418
 
 
2419
                        default:
 
2420
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
2421
                }
 
2422
        }
 
2423
        if (ndr_flags & NDR_BUFFERS) {
 
2424
                int level = ndr_push_get_switch_value(ndr, r);
 
2425
                switch (level) {
 
2426
                        case LOGON_SAM_LOGON_REQUEST:
 
2427
                                NDR_CHECK(ndr_push_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_BUFFERS, &r->logon));
 
2428
                        break;
 
2429
 
 
2430
                        case LOGON_PRIMARY_QUERY:
 
2431
                        break;
 
2432
 
 
2433
                        case NETLOGON_ANNOUNCE_UAS:
 
2434
                                NDR_CHECK(ndr_push_NETLOGON_DB_CHANGE(ndr, NDR_BUFFERS, &r->uas));
 
2435
                        break;
 
2436
 
 
2437
                        default:
 
2438
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
2439
                }
 
2440
        }
 
2441
        return NDR_ERR_SUCCESS;
 
2442
}
 
2443
 
 
2444
static enum ndr_err_code ndr_pull_nbt_netlogon_request(struct ndr_pull *ndr, int ndr_flags, union nbt_netlogon_request *r)
 
2445
{
 
2446
        int level;
 
2447
        level = ndr_pull_get_switch_value(ndr, r);
 
2448
        if (ndr_flags & NDR_SCALARS) {
 
2449
                switch (level) {
 
2450
                        case LOGON_SAM_LOGON_REQUEST: {
 
2451
                                NDR_CHECK(ndr_pull_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_SCALARS, &r->logon));
 
2452
                        break; }
 
2453
 
 
2454
                        case LOGON_PRIMARY_QUERY: {
 
2455
                                NDR_CHECK(ndr_pull_nbt_netlogon_query_for_pdc(ndr, NDR_SCALARS, &r->pdc));
 
2456
                        break; }
 
2457
 
 
2458
                        case NETLOGON_ANNOUNCE_UAS: {
 
2459
                                NDR_CHECK(ndr_pull_NETLOGON_DB_CHANGE(ndr, NDR_SCALARS, &r->uas));
 
2460
                        break; }
 
2461
 
 
2462
                        default:
 
2463
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
2464
                }
 
2465
        }
 
2466
        if (ndr_flags & NDR_BUFFERS) {
 
2467
                switch (level) {
 
2468
                        case LOGON_SAM_LOGON_REQUEST:
 
2469
                                NDR_CHECK(ndr_pull_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_BUFFERS, &r->logon));
 
2470
                        break;
 
2471
 
 
2472
                        case LOGON_PRIMARY_QUERY:
 
2473
                        break;
 
2474
 
 
2475
                        case NETLOGON_ANNOUNCE_UAS:
 
2476
                                NDR_CHECK(ndr_pull_NETLOGON_DB_CHANGE(ndr, NDR_BUFFERS, &r->uas));
 
2477
                        break;
 
2478
 
 
2479
                        default:
 
2480
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
2481
                }
 
2482
        }
 
2483
        return NDR_ERR_SUCCESS;
 
2484
}
 
2485
 
 
2486
_PUBLIC_ void ndr_print_nbt_netlogon_request(struct ndr_print *ndr, const char *name, const union nbt_netlogon_request *r)
 
2487
{
 
2488
        int level;
 
2489
        level = ndr_print_get_switch_value(ndr, r);
 
2490
        ndr_print_union(ndr, name, level, "nbt_netlogon_request");
 
2491
        switch (level) {
 
2492
                case LOGON_SAM_LOGON_REQUEST:
 
2493
                        ndr_print_NETLOGON_SAM_LOGON_REQUEST(ndr, "logon", &r->logon);
 
2494
                break;
 
2495
 
 
2496
                case LOGON_PRIMARY_QUERY:
 
2497
                        ndr_print_nbt_netlogon_query_for_pdc(ndr, "pdc", &r->pdc);
 
2498
                break;
 
2499
 
 
2500
                case NETLOGON_ANNOUNCE_UAS:
 
2501
                        ndr_print_NETLOGON_DB_CHANGE(ndr, "uas", &r->uas);
 
2502
                break;
 
2503
 
 
2504
                default:
 
2505
                        ndr_print_bad_level(ndr, name, level);
 
2506
        }
 
2507
}
 
2508
 
 
2509
_PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_packet *r)
 
2510
{
 
2511
        {
 
2512
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2513
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
2514
                if (ndr_flags & NDR_SCALARS) {
 
2515
                        NDR_CHECK(ndr_push_align(ndr, 8));
 
2516
                        NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
 
2517
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->req, r->command));
 
2518
                        NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
 
2519
                }
 
2520
                if (ndr_flags & NDR_BUFFERS) {
 
2521
                        NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
 
2522
                }
 
2523
                ndr->flags = _flags_save_STRUCT;
 
2524
        }
 
2525
        return NDR_ERR_SUCCESS;
 
2526
}
 
2527
 
 
2528
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_packet *r)
 
2529
{
 
2530
        {
 
2531
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2532
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
2533
                if (ndr_flags & NDR_SCALARS) {
 
2534
                        NDR_CHECK(ndr_pull_align(ndr, 8));
 
2535
                        NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
 
2536
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->req, r->command));
 
2537
                        NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
 
2538
                }
 
2539
                if (ndr_flags & NDR_BUFFERS) {
 
2540
                        NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
 
2541
                }
 
2542
                ndr->flags = _flags_save_STRUCT;
 
2543
        }
 
2544
        return NDR_ERR_SUCCESS;
 
2545
}
 
2546
 
 
2547
_PUBLIC_ void ndr_print_nbt_netlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_packet *r)
 
2548
{
 
2549
        ndr_print_struct(ndr, name, "nbt_netlogon_packet");
 
2550
        {
 
2551
                uint32_t _flags_save_STRUCT = ndr->flags;
 
2552
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
2553
                ndr->depth++;
 
2554
                ndr_print_netlogon_command(ndr, "command", r->command);
 
2555
                ndr_print_set_switch_value(ndr, &r->req, r->command);
 
2556
                ndr_print_nbt_netlogon_request(ndr, "req", &r->req);
 
2557
                ndr->depth--;
 
2558
                ndr->flags = _flags_save_STRUCT;
 
2559
        }
 
2560
}
 
2561
 
 
2562
static enum ndr_err_code ndr_push_nbt_browse_opcode(struct ndr_push *ndr, int ndr_flags, enum nbt_browse_opcode r)
 
2563
{
 
2564
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
2565
        return NDR_ERR_SUCCESS;
 
2566
}
 
2567
 
 
2568
static enum ndr_err_code ndr_pull_nbt_browse_opcode(struct ndr_pull *ndr, int ndr_flags, enum nbt_browse_opcode *r)
 
2569
{
 
2570
        uint8_t v;
 
2571
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
2572
        *r = v;
 
2573
        return NDR_ERR_SUCCESS;
 
2574
}
 
2575
 
 
2576
_PUBLIC_ void ndr_print_nbt_browse_opcode(struct ndr_print *ndr, const char *name, enum nbt_browse_opcode r)
 
2577
{
 
2578
        const char *val = NULL;
 
2579
 
 
2580
        switch (r) {
 
2581
                case HostAnnouncement: val = "HostAnnouncement"; break;
 
2582
                case AnnouncementRequest: val = "AnnouncementRequest"; break;
 
2583
                case Election: val = "Election"; break;
 
2584
                case GetBackupListReq: val = "GetBackupListReq"; break;
 
2585
                case GetBackupListResp: val = "GetBackupListResp"; break;
 
2586
                case BecomeBackup: val = "BecomeBackup"; break;
 
2587
                case DomainAnnouncement: val = "DomainAnnouncement"; break;
 
2588
                case MasterAnnouncement: val = "MasterAnnouncement"; break;
 
2589
                case ResetBrowserState: val = "ResetBrowserState"; break;
 
2590
                case LocalMasterAnnouncement: val = "LocalMasterAnnouncement"; break;
 
2591
        }
 
2592
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
2593
}
 
2594
 
 
2595
static enum ndr_err_code ndr_push_nbt_browse_host_announcement(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_host_announcement *r)
 
2596
{
 
2597
        if (ndr_flags & NDR_SCALARS) {
 
2598
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2599
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->UpdateCount));
 
2600
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Periodicity));
 
2601
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ServerName, 16, sizeof(uint8_t), CH_DOS));
 
2602
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->OSMajor));
 
2603
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->OSMinor));
 
2604
                NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->ServerType));
 
2605
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->BroMajorVer));
 
2606
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->BroMinorVer));
 
2607
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Signature));
 
2608
                {
 
2609
                        uint32_t _flags_save_string = ndr->flags;
 
2610
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2611
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Comment));
 
2612
                        ndr->flags = _flags_save_string;
 
2613
                }
 
2614
        }
 
2615
        if (ndr_flags & NDR_BUFFERS) {
 
2616
        }
 
2617
        return NDR_ERR_SUCCESS;
 
2618
}
 
2619
 
 
2620
static enum ndr_err_code ndr_pull_nbt_browse_host_announcement(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_host_announcement *r)
 
2621
{
 
2622
        if (ndr_flags & NDR_SCALARS) {
 
2623
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2624
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->UpdateCount));
 
2625
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Periodicity));
 
2626
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ServerName, 16, sizeof(uint8_t), CH_DOS));
 
2627
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->OSMajor));
 
2628
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->OSMinor));
 
2629
                NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->ServerType));
 
2630
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->BroMajorVer));
 
2631
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->BroMinorVer));
 
2632
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Signature));
 
2633
                {
 
2634
                        uint32_t _flags_save_string = ndr->flags;
 
2635
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2636
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Comment));
 
2637
                        ndr->flags = _flags_save_string;
 
2638
                }
 
2639
        }
 
2640
        if (ndr_flags & NDR_BUFFERS) {
 
2641
        }
 
2642
        return NDR_ERR_SUCCESS;
 
2643
}
 
2644
 
 
2645
_PUBLIC_ void ndr_print_nbt_browse_host_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_host_announcement *r)
 
2646
{
 
2647
        ndr_print_struct(ndr, name, "nbt_browse_host_announcement");
 
2648
        ndr->depth++;
 
2649
        ndr_print_uint8(ndr, "UpdateCount", r->UpdateCount);
 
2650
        ndr_print_uint32(ndr, "Periodicity", r->Periodicity);
 
2651
        ndr_print_string(ndr, "ServerName", r->ServerName);
 
2652
        ndr_print_uint8(ndr, "OSMajor", r->OSMajor);
 
2653
        ndr_print_uint8(ndr, "OSMinor", r->OSMinor);
 
2654
        ndr_print_svcctl_ServerType(ndr, "ServerType", r->ServerType);
 
2655
        ndr_print_uint8(ndr, "BroMajorVer", r->BroMajorVer);
 
2656
        ndr_print_uint8(ndr, "BroMinorVer", r->BroMinorVer);
 
2657
        ndr_print_uint16(ndr, "Signature", r->Signature);
 
2658
        ndr_print_string(ndr, "Comment", r->Comment);
 
2659
        ndr->depth--;
 
2660
}
 
2661
 
 
2662
static enum ndr_err_code ndr_push_nbt_browse_announcement_request(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_announcement_request *r)
 
2663
{
 
2664
        if (ndr_flags & NDR_SCALARS) {
 
2665
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2666
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->Unused));
 
2667
                {
 
2668
                        uint32_t _flags_save_string = ndr->flags;
 
2669
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2670
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->ResponseName));
 
2671
                        ndr->flags = _flags_save_string;
 
2672
                }
 
2673
        }
 
2674
        if (ndr_flags & NDR_BUFFERS) {
 
2675
        }
 
2676
        return NDR_ERR_SUCCESS;
 
2677
}
 
2678
 
 
2679
static enum ndr_err_code ndr_pull_nbt_browse_announcement_request(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_announcement_request *r)
 
2680
{
 
2681
        if (ndr_flags & NDR_SCALARS) {
 
2682
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2683
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->Unused));
 
2684
                {
 
2685
                        uint32_t _flags_save_string = ndr->flags;
 
2686
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2687
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->ResponseName));
 
2688
                        ndr->flags = _flags_save_string;
 
2689
                }
 
2690
        }
 
2691
        if (ndr_flags & NDR_BUFFERS) {
 
2692
        }
 
2693
        return NDR_ERR_SUCCESS;
 
2694
}
 
2695
 
 
2696
_PUBLIC_ void ndr_print_nbt_browse_announcement_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_announcement_request *r)
 
2697
{
 
2698
        ndr_print_struct(ndr, name, "nbt_browse_announcement_request");
 
2699
        ndr->depth++;
 
2700
        ndr_print_uint8(ndr, "Unused", r->Unused);
 
2701
        ndr_print_string(ndr, "ResponseName", r->ResponseName);
 
2702
        ndr->depth--;
 
2703
}
 
2704
 
 
2705
static enum ndr_err_code ndr_push_nbt_browse_election_request(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_election_request *r)
 
2706
{
 
2707
        if (ndr_flags & NDR_SCALARS) {
 
2708
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2709
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->Version));
 
2710
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Criteria));
 
2711
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->UpTime));
 
2712
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Reserved));
 
2713
                {
 
2714
                        uint32_t _flags_save_string = ndr->flags;
 
2715
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2716
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->ServerName));
 
2717
                        ndr->flags = _flags_save_string;
 
2718
                }
 
2719
        }
 
2720
        if (ndr_flags & NDR_BUFFERS) {
 
2721
        }
 
2722
        return NDR_ERR_SUCCESS;
 
2723
}
 
2724
 
 
2725
static enum ndr_err_code ndr_pull_nbt_browse_election_request(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_election_request *r)
 
2726
{
 
2727
        if (ndr_flags & NDR_SCALARS) {
 
2728
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2729
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->Version));
 
2730
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Criteria));
 
2731
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UpTime));
 
2732
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Reserved));
 
2733
                {
 
2734
                        uint32_t _flags_save_string = ndr->flags;
 
2735
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2736
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->ServerName));
 
2737
                        ndr->flags = _flags_save_string;
 
2738
                }
 
2739
        }
 
2740
        if (ndr_flags & NDR_BUFFERS) {
 
2741
        }
 
2742
        return NDR_ERR_SUCCESS;
 
2743
}
 
2744
 
 
2745
_PUBLIC_ void ndr_print_nbt_browse_election_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_election_request *r)
 
2746
{
 
2747
        ndr_print_struct(ndr, name, "nbt_browse_election_request");
 
2748
        ndr->depth++;
 
2749
        ndr_print_uint8(ndr, "Version", r->Version);
 
2750
        ndr_print_uint32(ndr, "Criteria", r->Criteria);
 
2751
        ndr_print_uint32(ndr, "UpTime", r->UpTime);
 
2752
        ndr_print_uint32(ndr, "Reserved", r->Reserved);
 
2753
        ndr_print_string(ndr, "ServerName", r->ServerName);
 
2754
        ndr->depth--;
 
2755
}
 
2756
 
 
2757
static enum ndr_err_code ndr_push_nbt_browse_backup_list_request(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_backup_list_request *r)
 
2758
{
 
2759
        if (ndr_flags & NDR_SCALARS) {
 
2760
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2761
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ReqCount));
 
2762
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Token));
 
2763
        }
 
2764
        if (ndr_flags & NDR_BUFFERS) {
 
2765
        }
 
2766
        return NDR_ERR_SUCCESS;
 
2767
}
 
2768
 
 
2769
static enum ndr_err_code ndr_pull_nbt_browse_backup_list_request(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_backup_list_request *r)
 
2770
{
 
2771
        if (ndr_flags & NDR_SCALARS) {
 
2772
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2773
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ReqCount));
 
2774
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Token));
 
2775
        }
 
2776
        if (ndr_flags & NDR_BUFFERS) {
 
2777
        }
 
2778
        return NDR_ERR_SUCCESS;
 
2779
}
 
2780
 
 
2781
_PUBLIC_ void ndr_print_nbt_browse_backup_list_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_backup_list_request *r)
 
2782
{
 
2783
        ndr_print_struct(ndr, name, "nbt_browse_backup_list_request");
 
2784
        ndr->depth++;
 
2785
        ndr_print_uint8(ndr, "ReqCount", r->ReqCount);
 
2786
        ndr_print_uint32(ndr, "Token", r->Token);
 
2787
        ndr->depth--;
 
2788
}
 
2789
 
 
2790
static enum ndr_err_code ndr_push_nbt_browse_backup_list_response(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_backup_list_response *r)
 
2791
{
 
2792
        uint32_t cntr_BackupServerList_0;
 
2793
        if (ndr_flags & NDR_SCALARS) {
 
2794
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2795
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->BackupCount));
 
2796
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Token));
 
2797
                for (cntr_BackupServerList_0 = 0; cntr_BackupServerList_0 < r->BackupCount; cntr_BackupServerList_0++) {
 
2798
                        NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->BackupServerList[cntr_BackupServerList_0]));
 
2799
                }
 
2800
        }
 
2801
        if (ndr_flags & NDR_BUFFERS) {
 
2802
        }
 
2803
        return NDR_ERR_SUCCESS;
 
2804
}
 
2805
 
 
2806
static enum ndr_err_code ndr_pull_nbt_browse_backup_list_response(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_backup_list_response *r)
 
2807
{
 
2808
        uint32_t cntr_BackupServerList_0;
 
2809
        TALLOC_CTX *_mem_save_BackupServerList_0;
 
2810
        if (ndr_flags & NDR_SCALARS) {
 
2811
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2812
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->BackupCount));
 
2813
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Token));
 
2814
                NDR_PULL_ALLOC_N(ndr, r->BackupServerList, r->BackupCount);
 
2815
                _mem_save_BackupServerList_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2816
                NDR_PULL_SET_MEM_CTX(ndr, r->BackupServerList, 0);
 
2817
                for (cntr_BackupServerList_0 = 0; cntr_BackupServerList_0 < r->BackupCount; cntr_BackupServerList_0++) {
 
2818
                        NDR_CHECK(ndr_pull_nbt_name(ndr, NDR_SCALARS, &r->BackupServerList[cntr_BackupServerList_0]));
 
2819
                }
 
2820
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_BackupServerList_0, 0);
 
2821
        }
 
2822
        if (ndr_flags & NDR_BUFFERS) {
 
2823
        }
 
2824
        return NDR_ERR_SUCCESS;
 
2825
}
 
2826
 
 
2827
_PUBLIC_ void ndr_print_nbt_browse_backup_list_response(struct ndr_print *ndr, const char *name, const struct nbt_browse_backup_list_response *r)
 
2828
{
 
2829
        uint32_t cntr_BackupServerList_0;
 
2830
        ndr_print_struct(ndr, name, "nbt_browse_backup_list_response");
 
2831
        ndr->depth++;
 
2832
        ndr_print_uint8(ndr, "BackupCount", r->BackupCount);
 
2833
        ndr_print_uint32(ndr, "Token", r->Token);
 
2834
        ndr->print(ndr, "%s: ARRAY(%d)", "BackupServerList", (int)r->BackupCount);
 
2835
        ndr->depth++;
 
2836
        for (cntr_BackupServerList_0=0;cntr_BackupServerList_0<r->BackupCount;cntr_BackupServerList_0++) {
 
2837
                char *idx_0=NULL;
 
2838
                if (asprintf(&idx_0, "[%d]", cntr_BackupServerList_0) != -1) {
 
2839
                        ndr_print_nbt_name(ndr, "BackupServerList", &r->BackupServerList[cntr_BackupServerList_0]);
 
2840
                        free(idx_0);
 
2841
                }
 
2842
        }
 
2843
        ndr->depth--;
 
2844
        ndr->depth--;
 
2845
}
 
2846
 
 
2847
static enum ndr_err_code ndr_push_nbt_browse_become_backup(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_become_backup *r)
 
2848
{
 
2849
        if (ndr_flags & NDR_SCALARS) {
 
2850
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2851
                {
 
2852
                        uint32_t _flags_save_string = ndr->flags;
 
2853
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2854
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->BrowserName));
 
2855
                        ndr->flags = _flags_save_string;
 
2856
                }
 
2857
        }
 
2858
        if (ndr_flags & NDR_BUFFERS) {
 
2859
        }
 
2860
        return NDR_ERR_SUCCESS;
 
2861
}
 
2862
 
 
2863
static enum ndr_err_code ndr_pull_nbt_browse_become_backup(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_become_backup *r)
 
2864
{
 
2865
        if (ndr_flags & NDR_SCALARS) {
 
2866
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2867
                {
 
2868
                        uint32_t _flags_save_string = ndr->flags;
 
2869
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2870
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->BrowserName));
 
2871
                        ndr->flags = _flags_save_string;
 
2872
                }
 
2873
        }
 
2874
        if (ndr_flags & NDR_BUFFERS) {
 
2875
        }
 
2876
        return NDR_ERR_SUCCESS;
 
2877
}
 
2878
 
 
2879
_PUBLIC_ void ndr_print_nbt_browse_become_backup(struct ndr_print *ndr, const char *name, const struct nbt_browse_become_backup *r)
 
2880
{
 
2881
        ndr_print_struct(ndr, name, "nbt_browse_become_backup");
 
2882
        ndr->depth++;
 
2883
        ndr_print_string(ndr, "BrowserName", r->BrowserName);
 
2884
        ndr->depth--;
 
2885
}
 
2886
 
 
2887
static enum ndr_err_code ndr_push_nbt_browse_domain_announcement(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_domain_announcement *r)
 
2888
{
 
2889
        if (ndr_flags & NDR_SCALARS) {
 
2890
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2891
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->UpdateCount));
 
2892
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Periodicity));
 
2893
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ServerName, 16, sizeof(uint8_t), CH_DOS));
 
2894
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->OSMajor));
 
2895
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->OSMinor));
 
2896
                NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->ServerType));
 
2897
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->MysteriousField));
 
2898
                {
 
2899
                        uint32_t _flags_save_string = ndr->flags;
 
2900
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2901
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Comment));
 
2902
                        ndr->flags = _flags_save_string;
 
2903
                }
 
2904
        }
 
2905
        if (ndr_flags & NDR_BUFFERS) {
 
2906
        }
 
2907
        return NDR_ERR_SUCCESS;
 
2908
}
 
2909
 
 
2910
static enum ndr_err_code ndr_pull_nbt_browse_domain_announcement(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_domain_announcement *r)
 
2911
{
 
2912
        if (ndr_flags & NDR_SCALARS) {
 
2913
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2914
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->UpdateCount));
 
2915
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Periodicity));
 
2916
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ServerName, 16, sizeof(uint8_t), CH_DOS));
 
2917
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->OSMajor));
 
2918
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->OSMinor));
 
2919
                NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->ServerType));
 
2920
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MysteriousField));
 
2921
                {
 
2922
                        uint32_t _flags_save_string = ndr->flags;
 
2923
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2924
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Comment));
 
2925
                        ndr->flags = _flags_save_string;
 
2926
                }
 
2927
        }
 
2928
        if (ndr_flags & NDR_BUFFERS) {
 
2929
        }
 
2930
        return NDR_ERR_SUCCESS;
 
2931
}
 
2932
 
 
2933
_PUBLIC_ void ndr_print_nbt_browse_domain_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_domain_announcement *r)
 
2934
{
 
2935
        ndr_print_struct(ndr, name, "nbt_browse_domain_announcement");
 
2936
        ndr->depth++;
 
2937
        ndr_print_uint8(ndr, "UpdateCount", r->UpdateCount);
 
2938
        ndr_print_uint32(ndr, "Periodicity", r->Periodicity);
 
2939
        ndr_print_string(ndr, "ServerName", r->ServerName);
 
2940
        ndr_print_uint8(ndr, "OSMajor", r->OSMajor);
 
2941
        ndr_print_uint8(ndr, "OSMinor", r->OSMinor);
 
2942
        ndr_print_svcctl_ServerType(ndr, "ServerType", r->ServerType);
 
2943
        ndr_print_uint32(ndr, "MysteriousField", r->MysteriousField);
 
2944
        ndr_print_string(ndr, "Comment", r->Comment);
 
2945
        ndr->depth--;
 
2946
}
 
2947
 
 
2948
static enum ndr_err_code ndr_push_nbt_browse_master_announcement(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_master_announcement *r)
 
2949
{
 
2950
        if (ndr_flags & NDR_SCALARS) {
 
2951
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2952
                {
 
2953
                        uint32_t _flags_save_string = ndr->flags;
 
2954
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2955
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->ServerName));
 
2956
                        ndr->flags = _flags_save_string;
 
2957
                }
 
2958
        }
 
2959
        if (ndr_flags & NDR_BUFFERS) {
 
2960
        }
 
2961
        return NDR_ERR_SUCCESS;
 
2962
}
 
2963
 
 
2964
static enum ndr_err_code ndr_pull_nbt_browse_master_announcement(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_master_announcement *r)
 
2965
{
 
2966
        if (ndr_flags & NDR_SCALARS) {
 
2967
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2968
                {
 
2969
                        uint32_t _flags_save_string = ndr->flags;
 
2970
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
2971
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->ServerName));
 
2972
                        ndr->flags = _flags_save_string;
 
2973
                }
 
2974
        }
 
2975
        if (ndr_flags & NDR_BUFFERS) {
 
2976
        }
 
2977
        return NDR_ERR_SUCCESS;
 
2978
}
 
2979
 
 
2980
_PUBLIC_ void ndr_print_nbt_browse_master_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_master_announcement *r)
 
2981
{
 
2982
        ndr_print_struct(ndr, name, "nbt_browse_master_announcement");
 
2983
        ndr->depth++;
 
2984
        ndr_print_string(ndr, "ServerName", r->ServerName);
 
2985
        ndr->depth--;
 
2986
}
 
2987
 
 
2988
static enum ndr_err_code ndr_push_nbt_browse_reset_state(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_reset_state *r)
 
2989
{
 
2990
        if (ndr_flags & NDR_SCALARS) {
 
2991
                NDR_CHECK(ndr_push_align(ndr, 1));
 
2992
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->Command));
 
2993
        }
 
2994
        if (ndr_flags & NDR_BUFFERS) {
 
2995
        }
 
2996
        return NDR_ERR_SUCCESS;
 
2997
}
 
2998
 
 
2999
static enum ndr_err_code ndr_pull_nbt_browse_reset_state(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_reset_state *r)
 
3000
{
 
3001
        if (ndr_flags & NDR_SCALARS) {
 
3002
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
3003
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->Command));
 
3004
        }
 
3005
        if (ndr_flags & NDR_BUFFERS) {
 
3006
        }
 
3007
        return NDR_ERR_SUCCESS;
 
3008
}
 
3009
 
 
3010
_PUBLIC_ void ndr_print_nbt_browse_reset_state(struct ndr_print *ndr, const char *name, const struct nbt_browse_reset_state *r)
 
3011
{
 
3012
        ndr_print_struct(ndr, name, "nbt_browse_reset_state");
 
3013
        ndr->depth++;
 
3014
        ndr_print_uint8(ndr, "Command", r->Command);
 
3015
        ndr->depth--;
 
3016
}
 
3017
 
 
3018
static enum ndr_err_code ndr_push_nbt_browse_local_master_announcement(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_local_master_announcement *r)
 
3019
{
 
3020
        if (ndr_flags & NDR_SCALARS) {
 
3021
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3022
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->UpdateCount));
 
3023
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Periodicity));
 
3024
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ServerName, 16, sizeof(uint8_t), CH_DOS));
 
3025
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->OSMajor));
 
3026
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->OSMinor));
 
3027
                NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->ServerType));
 
3028
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->BroMajorVer));
 
3029
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->BroMinorVer));
 
3030
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Signature));
 
3031
                {
 
3032
                        uint32_t _flags_save_string = ndr->flags;
 
3033
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
3034
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Comment));
 
3035
                        ndr->flags = _flags_save_string;
 
3036
                }
 
3037
        }
 
3038
        if (ndr_flags & NDR_BUFFERS) {
 
3039
        }
 
3040
        return NDR_ERR_SUCCESS;
 
3041
}
 
3042
 
 
3043
static enum ndr_err_code ndr_pull_nbt_browse_local_master_announcement(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_local_master_announcement *r)
 
3044
{
 
3045
        if (ndr_flags & NDR_SCALARS) {
 
3046
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3047
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->UpdateCount));
 
3048
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Periodicity));
 
3049
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ServerName, 16, sizeof(uint8_t), CH_DOS));
 
3050
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->OSMajor));
 
3051
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->OSMinor));
 
3052
                NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->ServerType));
 
3053
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->BroMajorVer));
 
3054
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->BroMinorVer));
 
3055
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Signature));
 
3056
                {
 
3057
                        uint32_t _flags_save_string = ndr->flags;
 
3058
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
3059
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Comment));
 
3060
                        ndr->flags = _flags_save_string;
 
3061
                }
 
3062
        }
 
3063
        if (ndr_flags & NDR_BUFFERS) {
 
3064
        }
 
3065
        return NDR_ERR_SUCCESS;
 
3066
}
 
3067
 
 
3068
_PUBLIC_ void ndr_print_nbt_browse_local_master_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_local_master_announcement *r)
 
3069
{
 
3070
        ndr_print_struct(ndr, name, "nbt_browse_local_master_announcement");
 
3071
        ndr->depth++;
 
3072
        ndr_print_uint8(ndr, "UpdateCount", r->UpdateCount);
 
3073
        ndr_print_uint32(ndr, "Periodicity", r->Periodicity);
 
3074
        ndr_print_string(ndr, "ServerName", r->ServerName);
 
3075
        ndr_print_uint8(ndr, "OSMajor", r->OSMajor);
 
3076
        ndr_print_uint8(ndr, "OSMinor", r->OSMinor);
 
3077
        ndr_print_svcctl_ServerType(ndr, "ServerType", r->ServerType);
 
3078
        ndr_print_uint8(ndr, "BroMajorVer", r->BroMajorVer);
 
3079
        ndr_print_uint8(ndr, "BroMinorVer", r->BroMinorVer);
 
3080
        ndr_print_uint16(ndr, "Signature", r->Signature);
 
3081
        ndr_print_string(ndr, "Comment", r->Comment);
 
3082
        ndr->depth--;
 
3083
}
 
3084
 
 
3085
static enum ndr_err_code ndr_push_nbt_browse_payload(struct ndr_push *ndr, int ndr_flags, const union nbt_browse_payload *r)
 
3086
{
 
3087
        if (ndr_flags & NDR_SCALARS) {
 
3088
                int level = ndr_push_get_switch_value(ndr, r);
 
3089
                switch (level) {
 
3090
                        case HostAnnouncement: {
 
3091
                                NDR_CHECK(ndr_push_nbt_browse_host_announcement(ndr, NDR_SCALARS, &r->host_annoucement));
 
3092
                        break; }
 
3093
 
 
3094
                        case AnnouncementRequest: {
 
3095
                                NDR_CHECK(ndr_push_nbt_browse_announcement_request(ndr, NDR_SCALARS, &r->announcement_request));
 
3096
                        break; }
 
3097
 
 
3098
                        case Election: {
 
3099
                                NDR_CHECK(ndr_push_nbt_browse_election_request(ndr, NDR_SCALARS, &r->election_request));
 
3100
                        break; }
 
3101
 
 
3102
                        case GetBackupListReq: {
 
3103
                                NDR_CHECK(ndr_push_nbt_browse_backup_list_request(ndr, NDR_SCALARS, &r->backup_list_request));
 
3104
                        break; }
 
3105
 
 
3106
                        case GetBackupListResp: {
 
3107
                                NDR_CHECK(ndr_push_nbt_browse_backup_list_response(ndr, NDR_SCALARS, &r->backup_list_response));
 
3108
                        break; }
 
3109
 
 
3110
                        case BecomeBackup: {
 
3111
                                NDR_CHECK(ndr_push_nbt_browse_become_backup(ndr, NDR_SCALARS, &r->become_backup));
 
3112
                        break; }
 
3113
 
 
3114
                        case DomainAnnouncement: {
 
3115
                                NDR_CHECK(ndr_push_nbt_browse_domain_announcement(ndr, NDR_SCALARS, &r->domain_announcement));
 
3116
                        break; }
 
3117
 
 
3118
                        case MasterAnnouncement: {
 
3119
                                NDR_CHECK(ndr_push_nbt_browse_master_announcement(ndr, NDR_SCALARS, &r->master_announcement));
 
3120
                        break; }
 
3121
 
 
3122
                        case ResetBrowserState: {
 
3123
                                NDR_CHECK(ndr_push_nbt_browse_reset_state(ndr, NDR_SCALARS, &r->reset_browser_state));
 
3124
                        break; }
 
3125
 
 
3126
                        case LocalMasterAnnouncement: {
 
3127
                                NDR_CHECK(ndr_push_nbt_browse_local_master_announcement(ndr, NDR_SCALARS, &r->local_master_announcement));
 
3128
                        break; }
 
3129
 
 
3130
                        default:
 
3131
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3132
                }
 
3133
        }
 
3134
        if (ndr_flags & NDR_BUFFERS) {
 
3135
                int level = ndr_push_get_switch_value(ndr, r);
 
3136
                switch (level) {
 
3137
                        case HostAnnouncement:
 
3138
                        break;
 
3139
 
 
3140
                        case AnnouncementRequest:
 
3141
                        break;
 
3142
 
 
3143
                        case Election:
 
3144
                        break;
 
3145
 
 
3146
                        case GetBackupListReq:
 
3147
                        break;
 
3148
 
 
3149
                        case GetBackupListResp:
 
3150
                        break;
 
3151
 
 
3152
                        case BecomeBackup:
 
3153
                        break;
 
3154
 
 
3155
                        case DomainAnnouncement:
 
3156
                        break;
 
3157
 
 
3158
                        case MasterAnnouncement:
 
3159
                        break;
 
3160
 
 
3161
                        case ResetBrowserState:
 
3162
                        break;
 
3163
 
 
3164
                        case LocalMasterAnnouncement:
 
3165
                        break;
 
3166
 
 
3167
                        default:
 
3168
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3169
                }
 
3170
        }
 
3171
        return NDR_ERR_SUCCESS;
 
3172
}
 
3173
 
 
3174
static enum ndr_err_code ndr_pull_nbt_browse_payload(struct ndr_pull *ndr, int ndr_flags, union nbt_browse_payload *r)
 
3175
{
 
3176
        int level;
 
3177
        level = ndr_pull_get_switch_value(ndr, r);
 
3178
        if (ndr_flags & NDR_SCALARS) {
 
3179
                switch (level) {
 
3180
                        case HostAnnouncement: {
 
3181
                                NDR_CHECK(ndr_pull_nbt_browse_host_announcement(ndr, NDR_SCALARS, &r->host_annoucement));
 
3182
                        break; }
 
3183
 
 
3184
                        case AnnouncementRequest: {
 
3185
                                NDR_CHECK(ndr_pull_nbt_browse_announcement_request(ndr, NDR_SCALARS, &r->announcement_request));
 
3186
                        break; }
 
3187
 
 
3188
                        case Election: {
 
3189
                                NDR_CHECK(ndr_pull_nbt_browse_election_request(ndr, NDR_SCALARS, &r->election_request));
 
3190
                        break; }
 
3191
 
 
3192
                        case GetBackupListReq: {
 
3193
                                NDR_CHECK(ndr_pull_nbt_browse_backup_list_request(ndr, NDR_SCALARS, &r->backup_list_request));
 
3194
                        break; }
 
3195
 
 
3196
                        case GetBackupListResp: {
 
3197
                                NDR_CHECK(ndr_pull_nbt_browse_backup_list_response(ndr, NDR_SCALARS, &r->backup_list_response));
 
3198
                        break; }
 
3199
 
 
3200
                        case BecomeBackup: {
 
3201
                                NDR_CHECK(ndr_pull_nbt_browse_become_backup(ndr, NDR_SCALARS, &r->become_backup));
 
3202
                        break; }
 
3203
 
 
3204
                        case DomainAnnouncement: {
 
3205
                                NDR_CHECK(ndr_pull_nbt_browse_domain_announcement(ndr, NDR_SCALARS, &r->domain_announcement));
 
3206
                        break; }
 
3207
 
 
3208
                        case MasterAnnouncement: {
 
3209
                                NDR_CHECK(ndr_pull_nbt_browse_master_announcement(ndr, NDR_SCALARS, &r->master_announcement));
 
3210
                        break; }
 
3211
 
 
3212
                        case ResetBrowserState: {
 
3213
                                NDR_CHECK(ndr_pull_nbt_browse_reset_state(ndr, NDR_SCALARS, &r->reset_browser_state));
 
3214
                        break; }
 
3215
 
 
3216
                        case LocalMasterAnnouncement: {
 
3217
                                NDR_CHECK(ndr_pull_nbt_browse_local_master_announcement(ndr, NDR_SCALARS, &r->local_master_announcement));
 
3218
                        break; }
 
3219
 
 
3220
                        default:
 
3221
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3222
                }
 
3223
        }
 
3224
        if (ndr_flags & NDR_BUFFERS) {
 
3225
                switch (level) {
 
3226
                        case HostAnnouncement:
 
3227
                        break;
 
3228
 
 
3229
                        case AnnouncementRequest:
 
3230
                        break;
 
3231
 
 
3232
                        case Election:
 
3233
                        break;
 
3234
 
 
3235
                        case GetBackupListReq:
 
3236
                        break;
 
3237
 
 
3238
                        case GetBackupListResp:
 
3239
                        break;
 
3240
 
 
3241
                        case BecomeBackup:
 
3242
                        break;
 
3243
 
 
3244
                        case DomainAnnouncement:
 
3245
                        break;
 
3246
 
 
3247
                        case MasterAnnouncement:
 
3248
                        break;
 
3249
 
 
3250
                        case ResetBrowserState:
 
3251
                        break;
 
3252
 
 
3253
                        case LocalMasterAnnouncement:
 
3254
                        break;
 
3255
 
 
3256
                        default:
 
3257
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
3258
                }
 
3259
        }
 
3260
        return NDR_ERR_SUCCESS;
 
3261
}
 
3262
 
 
3263
_PUBLIC_ void ndr_print_nbt_browse_payload(struct ndr_print *ndr, const char *name, const union nbt_browse_payload *r)
 
3264
{
 
3265
        int level;
 
3266
        level = ndr_print_get_switch_value(ndr, r);
 
3267
        ndr_print_union(ndr, name, level, "nbt_browse_payload");
 
3268
        switch (level) {
 
3269
                case HostAnnouncement:
 
3270
                        ndr_print_nbt_browse_host_announcement(ndr, "host_annoucement", &r->host_annoucement);
 
3271
                break;
 
3272
 
 
3273
                case AnnouncementRequest:
 
3274
                        ndr_print_nbt_browse_announcement_request(ndr, "announcement_request", &r->announcement_request);
 
3275
                break;
 
3276
 
 
3277
                case Election:
 
3278
                        ndr_print_nbt_browse_election_request(ndr, "election_request", &r->election_request);
 
3279
                break;
 
3280
 
 
3281
                case GetBackupListReq:
 
3282
                        ndr_print_nbt_browse_backup_list_request(ndr, "backup_list_request", &r->backup_list_request);
 
3283
                break;
 
3284
 
 
3285
                case GetBackupListResp:
 
3286
                        ndr_print_nbt_browse_backup_list_response(ndr, "backup_list_response", &r->backup_list_response);
 
3287
                break;
 
3288
 
 
3289
                case BecomeBackup:
 
3290
                        ndr_print_nbt_browse_become_backup(ndr, "become_backup", &r->become_backup);
 
3291
                break;
 
3292
 
 
3293
                case DomainAnnouncement:
 
3294
                        ndr_print_nbt_browse_domain_announcement(ndr, "domain_announcement", &r->domain_announcement);
 
3295
                break;
 
3296
 
 
3297
                case MasterAnnouncement:
 
3298
                        ndr_print_nbt_browse_master_announcement(ndr, "master_announcement", &r->master_announcement);
 
3299
                break;
 
3300
 
 
3301
                case ResetBrowserState:
 
3302
                        ndr_print_nbt_browse_reset_state(ndr, "reset_browser_state", &r->reset_browser_state);
 
3303
                break;
 
3304
 
 
3305
                case LocalMasterAnnouncement:
 
3306
                        ndr_print_nbt_browse_local_master_announcement(ndr, "local_master_announcement", &r->local_master_announcement);
 
3307
                break;
 
3308
 
 
3309
                default:
 
3310
                        ndr_print_bad_level(ndr, name, level);
 
3311
        }
 
3312
}
 
3313
 
 
3314
_PUBLIC_ enum ndr_err_code ndr_push_nbt_browse_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_packet *r)
 
3315
{
 
3316
        {
 
3317
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3318
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
3319
                if (ndr_flags & NDR_SCALARS) {
 
3320
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
3321
                        NDR_CHECK(ndr_push_nbt_browse_opcode(ndr, NDR_SCALARS, r->opcode));
 
3322
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->payload, r->opcode));
 
3323
                        NDR_CHECK(ndr_push_nbt_browse_payload(ndr, NDR_SCALARS, &r->payload));
 
3324
                }
 
3325
                if (ndr_flags & NDR_BUFFERS) {
 
3326
                }
 
3327
                ndr->flags = _flags_save_STRUCT;
 
3328
        }
 
3329
        return NDR_ERR_SUCCESS;
 
3330
}
 
3331
 
 
3332
_PUBLIC_ enum ndr_err_code ndr_pull_nbt_browse_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_packet *r)
 
3333
{
 
3334
        {
 
3335
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3336
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
3337
                if (ndr_flags & NDR_SCALARS) {
 
3338
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
3339
                        NDR_CHECK(ndr_pull_nbt_browse_opcode(ndr, NDR_SCALARS, &r->opcode));
 
3340
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->payload, r->opcode));
 
3341
                        NDR_CHECK(ndr_pull_nbt_browse_payload(ndr, NDR_SCALARS, &r->payload));
 
3342
                }
 
3343
                if (ndr_flags & NDR_BUFFERS) {
 
3344
                }
 
3345
                ndr->flags = _flags_save_STRUCT;
 
3346
        }
 
3347
        return NDR_ERR_SUCCESS;
 
3348
}
 
3349
 
 
3350
_PUBLIC_ void ndr_print_nbt_browse_packet(struct ndr_print *ndr, const char *name, const struct nbt_browse_packet *r)
 
3351
{
 
3352
        ndr_print_struct(ndr, name, "nbt_browse_packet");
 
3353
        {
 
3354
                uint32_t _flags_save_STRUCT = ndr->flags;
 
3355
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 
3356
                ndr->depth++;
 
3357
                ndr_print_nbt_browse_opcode(ndr, "opcode", r->opcode);
 
3358
                ndr_print_set_switch_value(ndr, &r->payload, r->opcode);
 
3359
                ndr_print_nbt_browse_payload(ndr, "payload", &r->payload);
 
3360
                ndr->depth--;
 
3361
                ndr->flags = _flags_save_STRUCT;
 
3362
        }
 
3363
}
 
3364