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