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