bin.gen_ndr/default/librpc/gen_ndr/ndr_dcerpc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_dcerpc.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 static enum ndr_err_code ndr_push_dcerpc_ctx_list(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ctx_list *r)
   8 {
   9         uint32_t cntr_transfer_syntaxes_0;
  10         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 4));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
  14                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_transfer_syntaxes));
  15                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
  16                 for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < r->num_transfer_syntaxes; cntr_transfer_syntaxes_0++) {
  17                         NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
  18                 }
  19                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  20         }
  21         if (ndr_flags & NDR_BUFFERS) {
  22         }
  23         return NDR_ERR_SUCCESS;
  24 }
  25
  26 static enum ndr_err_code ndr_pull_dcerpc_ctx_list(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ctx_list *r)
  27 {
  28         uint32_t size_transfer_syntaxes_0 = 0;
  29         uint32_t cntr_transfer_syntaxes_0;
  30         TALLOC_CTX *_mem_save_transfer_syntaxes_0;
  31         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  32         if (ndr_flags & NDR_SCALARS) {
  33                 NDR_CHECK(ndr_pull_align(ndr, 4));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
  35                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_transfer_syntaxes));
  36                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
  37                 size_transfer_syntaxes_0 = r->num_transfer_syntaxes;
  38                 NDR_PULL_ALLOC_N(ndr, r->transfer_syntaxes, size_transfer_syntaxes_0);
  39                 _mem_save_transfer_syntaxes_0 = NDR_PULL_GET_MEM_CTX(ndr);
  40                 NDR_PULL_SET_MEM_CTX(ndr, r->transfer_syntaxes, 0);
  41                 for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < size_transfer_syntaxes_0; cntr_transfer_syntaxes_0++) {
  42                         NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
  43                 }
  44                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transfer_syntaxes_0, 0);
  45                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  46         }
  47         if (ndr_flags & NDR_BUFFERS) {
  48         }
  49         return NDR_ERR_SUCCESS;
  50 }
  51
  52 _PUBLIC_ void ndr_print_dcerpc_ctx_list(struct ndr_print *ndr, const char *name, const struct dcerpc_ctx_list *r)
  53 {
  54         uint32_t cntr_transfer_syntaxes_0;
  55         ndr_print_struct(ndr, name, "dcerpc_ctx_list");
  56         if (r == NULL) { ndr_print_null(ndr); return; }
  57         ndr->depth++;
  58         ndr_print_uint16(ndr, "context_id", r->context_id);
  59         ndr_print_uint8(ndr, "num_transfer_syntaxes", r->num_transfer_syntaxes);
  60         ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
  61         ndr->print(ndr, "%s: ARRAY(%d)", "transfer_syntaxes", (int)r->num_transfer_syntaxes);
  62         ndr->depth++;
  63         for (cntr_transfer_syntaxes_0=0;cntr_transfer_syntaxes_0<r->num_transfer_syntaxes;cntr_transfer_syntaxes_0++) {
  64                 ndr_print_ndr_syntax_id(ndr, "transfer_syntaxes", &r->transfer_syntaxes[cntr_transfer_syntaxes_0]);
  65         }
  66         ndr->depth--;
  67         ndr->depth--;
  68 }
  69
  70 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind *r)
  71 {
  72         uint32_t cntr_ctx_list_0;
  73         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  74         if (ndr_flags & NDR_SCALARS) {
  75                 NDR_CHECK(ndr_push_align(ndr, 4));
  76                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
  77                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
  78                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
  79                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_contexts));
  80                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
  81                         NDR_CHECK(ndr_push_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
  82                 }
  83                 {
  84                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  85                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  86                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
  87                         ndr->flags = _flags_save_DATA_BLOB;
  88                 }
  89                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  90         }
  91         if (ndr_flags & NDR_BUFFERS) {
  92         }
  93         return NDR_ERR_SUCCESS;
  94 }
  95
  96 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind *r)
  97 {
  98         uint32_t size_ctx_list_0 = 0;
  99         uint32_t cntr_ctx_list_0;
 100         TALLOC_CTX *_mem_save_ctx_list_0;
 101         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 102         if (ndr_flags & NDR_SCALARS) {
 103                 NDR_CHECK(ndr_pull_align(ndr, 4));
 104                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
 105                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
 106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
 107                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_contexts));
 108                 size_ctx_list_0 = r->num_contexts;
 109                 NDR_PULL_ALLOC_N(ndr, r->ctx_list, size_ctx_list_0);
 110                 _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
 111                 NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
 112                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < size_ctx_list_0; cntr_ctx_list_0++) {
 113                         NDR_CHECK(ndr_pull_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 114                 }
 115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
 116                 {
 117                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 119                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 120                         ndr->flags = _flags_save_DATA_BLOB;
 121                 }
 122                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 123         }
 124         if (ndr_flags & NDR_BUFFERS) {
 125         }
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 _PUBLIC_ void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r)
 130 {
 131         uint32_t cntr_ctx_list_0;
 132         ndr_print_struct(ndr, name, "dcerpc_bind");
 133         if (r == NULL) { ndr_print_null(ndr); return; }
 134         ndr->depth++;
 135         ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
 136         ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
 137         ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
 138         ndr_print_uint8(ndr, "num_contexts", r->num_contexts);
 139         ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_contexts);
 140         ndr->depth++;
 141         for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_contexts;cntr_ctx_list_0++) {
 142                 ndr_print_dcerpc_ctx_list(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
 143         }
 144         ndr->depth--;
 145         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 146         ndr->depth--;
 147 }
 148
 149 static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_empty *r)
 150 {
 151         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 152         if (ndr_flags & NDR_SCALARS) {
 153                 NDR_CHECK(ndr_push_align(ndr, 1));
 154                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 155         }
 156         if (ndr_flags & NDR_BUFFERS) {
 157         }
 158         return NDR_ERR_SUCCESS;
 159 }
 160
 161 static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_empty *r)
 162 {
 163         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 164         if (ndr_flags & NDR_SCALARS) {
 165                 NDR_CHECK(ndr_pull_align(ndr, 1));
 166                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 167         }
 168         if (ndr_flags & NDR_BUFFERS) {
 169         }
 170         return NDR_ERR_SUCCESS;
 171 }
 172
 173 _PUBLIC_ void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r)
 174 {
 175         ndr_print_struct(ndr, name, "dcerpc_empty");
 176         if (r == NULL) { ndr_print_null(ndr); return; }
 177         ndr->depth++;
 178         ndr->depth--;
 179 }
 180
 181 static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, int ndr_flags, const union dcerpc_object *r)
 182 {
 183         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 184         if (ndr_flags & NDR_SCALARS) {
 185                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 186                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 187                 switch (level) {
 188                         default: {
 189                                 NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
 190                         break; }
 191
 192                         case LIBNDR_FLAG_OBJECT_PRESENT: {
 193                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
 194                         break; }
 195
 196                 }
 197         }
 198         if (ndr_flags & NDR_BUFFERS) {
 199                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 200                 switch (level) {
 201                         default:
 202                         break;
 203
 204                         case LIBNDR_FLAG_OBJECT_PRESENT:
 205                         break;
 206
 207                 }
 208         }
 209         return NDR_ERR_SUCCESS;
 210 }
 211
 212 static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, int ndr_flags, union dcerpc_object *r)
 213 {
 214         uint32_t level;
 215         level = ndr_pull_get_switch_value(ndr, r);
 216         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 217         if (ndr_flags & NDR_SCALARS) {
 218                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 219                 switch (level) {
 220                         default: {
 221                                 NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
 222                         break; }
 223
 224                         case LIBNDR_FLAG_OBJECT_PRESENT: {
 225                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
 226                         break; }
 227
 228                 }
 229         }
 230         if (ndr_flags & NDR_BUFFERS) {
 231                 switch (level) {
 232                         default:
 233                         break;
 234
 235                         case LIBNDR_FLAG_OBJECT_PRESENT:
 236                         break;
 237
 238                 }
 239         }
 240         return NDR_ERR_SUCCESS;
 241 }
 242
 243 _PUBLIC_ void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r)
 244 {
 245         uint32_t level;
 246         level = ndr_print_get_switch_value(ndr, r);
 247         ndr_print_union(ndr, name, level, "dcerpc_object");
 248         switch (level) {
 249                 default:
 250                         ndr_print_dcerpc_empty(ndr, "empty", &r->empty);
 251                 break;
 252
 253                 case LIBNDR_FLAG_OBJECT_PRESENT:
 254                         ndr_print_GUID(ndr, "object", &r->object);
 255                 break;
 256
 257         }
 258 }
 259
 260 static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_request *r)
 261 {
 262         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 263         if (ndr_flags & NDR_SCALARS) {
 264                 NDR_CHECK(ndr_push_align(ndr, 4));
 265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 267                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
 268                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
 269                 NDR_CHECK(ndr_push_dcerpc_object(ndr, NDR_SCALARS, &r->object));
 270                 {
 271                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 273                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 274                         ndr->flags = _flags_save_DATA_BLOB;
 275                 }
 276                 {
 277                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 279                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
 280                         ndr->flags = _flags_save_DATA_BLOB;
 281                 }
 282                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 283         }
 284         if (ndr_flags & NDR_BUFFERS) {
 285         }
 286         return NDR_ERR_SUCCESS;
 287 }
 288
 289 static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_request *r)
 290 {
 291         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 292         if (ndr_flags & NDR_SCALARS) {
 293                 NDR_CHECK(ndr_pull_align(ndr, 4));
 294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 295                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 296                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
 297                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
 298                 NDR_CHECK(ndr_pull_dcerpc_object(ndr, NDR_SCALARS, &r->object));
 299                 {
 300                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 302                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 303                         ndr->flags = _flags_save_DATA_BLOB;
 304                 }
 305                 {
 306                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 308                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
 309                         ndr->flags = _flags_save_DATA_BLOB;
 310                 }
 311                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 312         }
 313         if (ndr_flags & NDR_BUFFERS) {
 314         }
 315         return NDR_ERR_SUCCESS;
 316 }
 317
 318 _PUBLIC_ void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r)
 319 {
 320         ndr_print_struct(ndr, name, "dcerpc_request");
 321         if (r == NULL) { ndr_print_null(ndr); return; }
 322         ndr->depth++;
 323         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 324         ndr_print_uint16(ndr, "context_id", r->context_id);
 325         ndr_print_uint16(ndr, "opnum", r->opnum);
 326         ndr_print_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT);
 327         ndr_print_dcerpc_object(ndr, "object", &r->object);
 328         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 329         ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
 330         ndr->depth--;
 331 }
 332
 333 static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack_ctx *r)
 334 {
 335         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 336         if (ndr_flags & NDR_SCALARS) {
 337                 NDR_CHECK(ndr_push_align(ndr, 4));
 338                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->result));
 339                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reason));
 340                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
 341                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 342         }
 343         if (ndr_flags & NDR_BUFFERS) {
 344         }
 345         return NDR_ERR_SUCCESS;
 346 }
 347
 348 static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack_ctx *r)
 349 {
 350         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 351         if (ndr_flags & NDR_SCALARS) {
 352                 NDR_CHECK(ndr_pull_align(ndr, 4));
 353                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->result));
 354                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reason));
 355                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
 356                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 357         }
 358         if (ndr_flags & NDR_BUFFERS) {
 359         }
 360         return NDR_ERR_SUCCESS;
 361 }
 362
 363 _PUBLIC_ void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r)
 364 {
 365         ndr_print_struct(ndr, name, "dcerpc_ack_ctx");
 366         if (r == NULL) { ndr_print_null(ndr); return; }
 367         ndr->depth++;
 368         ndr_print_uint16(ndr, "result", r->result);
 369         ndr_print_uint16(ndr, "reason", r->reason);
 370         ndr_print_ndr_syntax_id(ndr, "syntax", &r->syntax);
 371         ndr->depth--;
 372 }
 373
 374 static enum ndr_err_code ndr_push_dcerpc_bind_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_ack *r)
 375 {
 376         uint32_t cntr_ctx_list_0;
 377         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 378         if (ndr_flags & NDR_SCALARS) {
 379                 NDR_CHECK(ndr_push_align(ndr, 4));
 380                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
 381                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
 382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
 383                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->secondary_address) + 1));
 384                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->secondary_address, strlen(r->secondary_address) + 1, sizeof(uint8_t), CH_DOS));
 385                 {
 386                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 388                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad1));
 389                         ndr->flags = _flags_save_DATA_BLOB;
 390                 }
 391                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_results));
 392                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
 393                         NDR_CHECK(ndr_push_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 394                 }
 395                 {
 396                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 398                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 399                         ndr->flags = _flags_save_DATA_BLOB;
 400                 }
 401                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 402         }
 403         if (ndr_flags & NDR_BUFFERS) {
 404         }
 405         return NDR_ERR_SUCCESS;
 406 }
 407
 408 static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_ack *r)
 409 {
 410         uint32_t size_secondary_address_0 = 0;
 411         uint32_t size_ctx_list_0 = 0;
 412         uint32_t cntr_ctx_list_0;
 413         TALLOC_CTX *_mem_save_ctx_list_0;
 414         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 415         if (ndr_flags & NDR_SCALARS) {
 416                 NDR_CHECK(ndr_pull_align(ndr, 4));
 417                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
 418                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
 420                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->secondary_address_size));
 421                 size_secondary_address_0 = r->secondary_address_size;
 422                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->secondary_address, size_secondary_address_0, sizeof(uint8_t), CH_DOS));
 423                 {
 424                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 426                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad1));
 427                         ndr->flags = _flags_save_DATA_BLOB;
 428                 }
 429                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_results));
 430                 size_ctx_list_0 = r->num_results;
 431                 NDR_PULL_ALLOC_N(ndr, r->ctx_list, size_ctx_list_0);
 432                 _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
 433                 NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
 434                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < size_ctx_list_0; cntr_ctx_list_0++) {
 435                         NDR_CHECK(ndr_pull_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 436                 }
 437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
 438                 {
 439                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 441                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 442                         ndr->flags = _flags_save_DATA_BLOB;
 443                 }
 444                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 445         }
 446         if (ndr_flags & NDR_BUFFERS) {
 447         }
 448         return NDR_ERR_SUCCESS;
 449 }
 450
 451 _PUBLIC_ void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r)
 452 {
 453         uint32_t cntr_ctx_list_0;
 454         ndr_print_struct(ndr, name, "dcerpc_bind_ack");
 455         if (r == NULL) { ndr_print_null(ndr); return; }
 456         ndr->depth++;
 457         ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
 458         ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
 459         ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
 460         ndr_print_uint16(ndr, "secondary_address_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->secondary_address) + 1:r->secondary_address_size);
 461         ndr_print_string(ndr, "secondary_address", r->secondary_address);
 462         ndr_print_DATA_BLOB(ndr, "_pad1", r->_pad1);
 463         ndr_print_uint8(ndr, "num_results", r->num_results);
 464         ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_results);
 465         ndr->depth++;
 466         for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_results;cntr_ctx_list_0++) {
 467                 ndr_print_dcerpc_ack_ctx(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
 468         }
 469         ndr->depth--;
 470         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 471         ndr->depth--;
 472 }
 473
 474 static enum ndr_err_code ndr_push_dcerpc_bind_nak_versions(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_nak_versions *r)
 475 {
 476         uint32_t cntr_versions_0;
 477         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 478         if (ndr_flags & NDR_SCALARS) {
 479                 NDR_CHECK(ndr_push_align(ndr, 4));
 480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_versions));
 481                 for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
 482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->versions[cntr_versions_0]));
 483                 }
 484                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 485         }
 486         if (ndr_flags & NDR_BUFFERS) {
 487         }
 488         return NDR_ERR_SUCCESS;
 489 }
 490
 491 static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak_versions *r)
 492 {
 493         uint32_t size_versions_0 = 0;
 494         uint32_t cntr_versions_0;
 495         TALLOC_CTX *_mem_save_versions_0;
 496         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 497         if (ndr_flags & NDR_SCALARS) {
 498                 NDR_CHECK(ndr_pull_align(ndr, 4));
 499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_versions));
 500                 size_versions_0 = r->num_versions;
 501                 NDR_PULL_ALLOC_N(ndr, r->versions, size_versions_0);
 502                 _mem_save_versions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 503                 NDR_PULL_SET_MEM_CTX(ndr, r->versions, 0);
 504                 for (cntr_versions_0 = 0; cntr_versions_0 < size_versions_0; cntr_versions_0++) {
 505                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
 506                 }
 507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_versions_0, 0);
 508                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 509         }
 510         if (ndr_flags & NDR_BUFFERS) {
 511         }
 512         return NDR_ERR_SUCCESS;
 513 }
 514
 515 _PUBLIC_ void ndr_print_dcerpc_bind_nak_versions(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_versions *r)
 516 {
 517         uint32_t cntr_versions_0;
 518         ndr_print_struct(ndr, name, "dcerpc_bind_nak_versions");
 519         if (r == NULL) { ndr_print_null(ndr); return; }
 520         ndr->depth++;
 521         ndr_print_uint32(ndr, "num_versions", r->num_versions);
 522         ndr->print(ndr, "%s: ARRAY(%d)", "versions", (int)r->num_versions);
 523         ndr->depth++;
 524         for (cntr_versions_0=0;cntr_versions_0<r->num_versions;cntr_versions_0++) {
 525                 ndr_print_uint32(ndr, "versions", r->versions[cntr_versions_0]);
 526         }
 527         ndr->depth--;
 528         ndr->depth--;
 529 }
 530
 531 static enum ndr_err_code ndr_push_dcerpc_bind_nak_versions_ctr(struct ndr_push *ndr, int ndr_flags, const union dcerpc_bind_nak_versions_ctr *r)
 532 {
 533         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 534         if (ndr_flags & NDR_SCALARS) {
 535                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 536                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 537                 switch (level) {
 538                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
 539                                 NDR_CHECK(ndr_push_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
 540                         break; }
 541
 542                         default: {
 543                         break; }
 544
 545                 }
 546         }
 547         if (ndr_flags & NDR_BUFFERS) {
 548                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 549                 switch (level) {
 550                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 551                         break;
 552
 553                         default:
 554                         break;
 555
 556                 }
 557         }
 558         return NDR_ERR_SUCCESS;
 559 }
 560
 561 static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions_ctr(struct ndr_pull *ndr, int ndr_flags, union dcerpc_bind_nak_versions_ctr *r)
 562 {
 563         uint32_t level;
 564         level = ndr_pull_get_switch_value(ndr, r);
 565         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 568                 switch (level) {
 569                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
 570                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
 571                         break; }
 572
 573                         default: {
 574                         break; }
 575
 576                 }
 577         }
 578         if (ndr_flags & NDR_BUFFERS) {
 579                 switch (level) {
 580                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 581                         break;
 582
 583                         default:
 584                         break;
 585
 586                 }
 587         }
 588         return NDR_ERR_SUCCESS;
 589 }
 590
 591 _PUBLIC_ void ndr_print_dcerpc_bind_nak_versions_ctr(struct ndr_print *ndr, const char *name, const union dcerpc_bind_nak_versions_ctr *r)
 592 {
 593         uint32_t level;
 594         level = ndr_print_get_switch_value(ndr, r);
 595         ndr_print_union(ndr, name, level, "dcerpc_bind_nak_versions_ctr");
 596         switch (level) {
 597                 case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 598                         ndr_print_dcerpc_bind_nak_versions(ndr, "v", &r->v);
 599                 break;
 600
 601                 default:
 602                 break;
 603
 604         }
 605 }
 606
 607 static enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_nak *r)
 608 {
 609         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 610         if (ndr_flags & NDR_SCALARS) {
 611                 NDR_CHECK(ndr_push_align(ndr, 4));
 612                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reject_reason));
 613                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->versions, r->reject_reason));
 614                 NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
 615                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 616         }
 617         if (ndr_flags & NDR_BUFFERS) {
 618                 NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
 619         }
 620         return NDR_ERR_SUCCESS;
 621 }
 622
 623 static enum ndr_err_code ndr_pull_dcerpc_bind_nak(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak *r)
 624 {
 625         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_pull_align(ndr, 4));
 628                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reject_reason));
 629                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->versions, r->reject_reason));
 630                 NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
 631                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 632         }
 633         if (ndr_flags & NDR_BUFFERS) {
 634                 NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
 635         }
 636         return NDR_ERR_SUCCESS;
 637 }
 638
 639 _PUBLIC_ void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r)
 640 {
 641         ndr_print_struct(ndr, name, "dcerpc_bind_nak");
 642         if (r == NULL) { ndr_print_null(ndr); return; }
 643         ndr->depth++;
 644         ndr_print_uint16(ndr, "reject_reason", r->reject_reason);
 645         ndr_print_set_switch_value(ndr, &r->versions, r->reject_reason);
 646         ndr_print_dcerpc_bind_nak_versions_ctr(ndr, "versions", &r->versions);
 647         ndr->depth--;
 648 }
 649
 650 static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_response *r)
 651 {
 652         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 653         if (ndr_flags & NDR_SCALARS) {
 654                 NDR_CHECK(ndr_push_align(ndr, 4));
 655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 656                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 657                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
 658                 {
 659                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 661                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 662                         ndr->flags = _flags_save_DATA_BLOB;
 663                 }
 664                 {
 665                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 667                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
 668                         ndr->flags = _flags_save_DATA_BLOB;
 669                 }
 670                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 671         }
 672         if (ndr_flags & NDR_BUFFERS) {
 673         }
 674         return NDR_ERR_SUCCESS;
 675 }
 676
 677 static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_response *r)
 678 {
 679         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 680         if (ndr_flags & NDR_SCALARS) {
 681                 NDR_CHECK(ndr_pull_align(ndr, 4));
 682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 683                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 684                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
 685                 {
 686                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 688                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 689                         ndr->flags = _flags_save_DATA_BLOB;
 690                 }
 691                 {
 692                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 694                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
 695                         ndr->flags = _flags_save_DATA_BLOB;
 696                 }
 697                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 698         }
 699         if (ndr_flags & NDR_BUFFERS) {
 700         }
 701         return NDR_ERR_SUCCESS;
 702 }
 703
 704 _PUBLIC_ void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r)
 705 {
 706         ndr_print_struct(ndr, name, "dcerpc_response");
 707         if (r == NULL) { ndr_print_null(ndr); return; }
 708         ndr->depth++;
 709         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 710         ndr_print_uint16(ndr, "context_id", r->context_id);
 711         ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
 712         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 713         ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
 714         ndr->depth--;
 715 }
 716
 717 static enum ndr_err_code ndr_push_dcerpc_nca_status(struct ndr_push *ndr, int ndr_flags, enum dcerpc_nca_status r)
 718 {
 719         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 720         return NDR_ERR_SUCCESS;
 721 }
 722
 723 static enum ndr_err_code ndr_pull_dcerpc_nca_status(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_nca_status *r)
 724 {
 725         uint32_t v;
 726         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 727         *r = v;
 728         return NDR_ERR_SUCCESS;
 729 }
 730
 731 _PUBLIC_ void ndr_print_dcerpc_nca_status(struct ndr_print *ndr, const char *name, enum dcerpc_nca_status r)
 732 {
 733         const char *val = NULL;
 734
 735         switch (r) {
 736                 case DCERPC_NCA_S_COMM_FAILURE: val = "DCERPC_NCA_S_COMM_FAILURE"; break;
 737                 case DCERPC_NCA_S_OP_RNG_ERROR: val = "DCERPC_NCA_S_OP_RNG_ERROR"; break;
 738                 case DCERPC_NCA_S_UNKNOWN_IF: val = "DCERPC_NCA_S_UNKNOWN_IF"; break;
 739                 case DCERPC_NCA_S_WRONG_BOOT_TIME: val = "DCERPC_NCA_S_WRONG_BOOT_TIME"; break;
 740                 case DCERPC_NCA_S_YOU_CRASHED: val = "DCERPC_NCA_S_YOU_CRASHED"; break;
 741                 case DCERPC_NCA_S_PROTO_ERROR: val = "DCERPC_NCA_S_PROTO_ERROR"; break;
 742                 case DCERPC_NCA_S_OUT_ARGS_TOO_BIG: val = "DCERPC_NCA_S_OUT_ARGS_TOO_BIG"; break;
 743                 case DCERPC_NCA_S_SERVER_TOO_BUSY: val = "DCERPC_NCA_S_SERVER_TOO_BUSY"; break;
 744                 case DCERPC_NCA_S_FAULT_STRING_TOO_LARGE: val = "DCERPC_NCA_S_FAULT_STRING_TOO_LARGE"; break;
 745                 case DCERPC_NCA_S_UNSUPPORTED_TYPE: val = "DCERPC_NCA_S_UNSUPPORTED_TYPE"; break;
 746                 case DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO"; break;
 747                 case DCERPC_NCA_S_FAULT_ADDR_ERROR: val = "DCERPC_NCA_S_FAULT_ADDR_ERROR"; break;
 748                 case DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO"; break;
 749                 case DCERPC_NCA_S_FAULT_FP_UNDERFLOW: val = "DCERPC_NCA_S_FAULT_FP_UNDERFLOW"; break;
 750                 case DCERPC_NCA_S_FAULT_FP_OVERRFLOW: val = "DCERPC_NCA_S_FAULT_FP_OVERRFLOW"; break;
 751                 case DCERPC_NCA_S_FAULT_INVALID_TAG: val = "DCERPC_NCA_S_FAULT_INVALID_TAG"; break;
 752                 case DCERPC_NCA_S_FAULT_INVALID_BOUND: val = "DCERPC_NCA_S_FAULT_INVALID_BOUND"; break;
 753                 case DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH: val = "DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH"; break;
 754                 case DCERPC_NCA_S_FAULT_UNSPEC_REJECT: val = "DCERPC_NCA_S_FAULT_UNSPEC_REJECT"; break;
 755                 case DCERPC_NCA_S_FAULT_BAD_ACTID: val = "DCERPC_NCA_S_FAULT_BAD_ACTID"; break;
 756                 case DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED: val = "DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED"; break;
 757                 case DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED: val = "DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED"; break;
 758                 case DCERPC_NCA_S_FAULT_CANCEL: val = "DCERPC_NCA_S_FAULT_CANCEL"; break;
 759                 case DCERPC_NCA_S_FAULT_ILL_INST: val = "DCERPC_NCA_S_FAULT_ILL_INST"; break;
 760                 case DCERPC_NCA_S_FAULT_FP_ERROR: val = "DCERPC_NCA_S_FAULT_FP_ERROR"; break;
 761                 case DCERPC_NCA_S_FAULT_INT_OVERFLOW: val = "DCERPC_NCA_S_FAULT_INT_OVERFLOW"; break;
 762                 case DCERPC_NCA_S_UNUSED_1C000011: val = "DCERPC_NCA_S_UNUSED_1C000011"; break;
 763                 case DCERPC_NCA_S_FAULT_UNSPEC: val = "DCERPC_NCA_S_FAULT_UNSPEC"; break;
 764                 case DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE: val = "DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE"; break;
 765                 case DCERPC_NCA_S_FAULT_PIPE_EMPTY: val = "DCERPC_NCA_S_FAULT_PIPE_EMPTY"; break;
 766                 case DCERPC_NCA_S_FAULT_PIPE_CLOSED: val = "DCERPC_NCA_S_FAULT_PIPE_CLOSED"; break;
 767                 case DCERPC_NCA_S_FAULT_PIPE_ORDER: val = "DCERPC_NCA_S_FAULT_PIPE_ORDER"; break;
 768                 case DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE: val = "DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE"; break;
 769                 case DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR: val = "DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR"; break;
 770                 case DCERPC_NCA_S_FAULT_PIPE_MEMORY: val = "DCERPC_NCA_S_FAULT_PIPE_MEMORY"; break;
 771                 case DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH: val = "DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH"; break;
 772                 case DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY: val = "DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY"; break;
 773                 case DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID: val = "DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID"; break;
 774                 case DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL: val = "DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL"; break;
 775                 case DCERPC_NCA_S_UNUSED_1C00001E: val = "DCERPC_NCA_S_UNUSED_1C00001E"; break;
 776                 case DCERPC_NCA_S_INVALID_CHECKSUM: val = "DCERPC_NCA_S_INVALID_CHECKSUM"; break;
 777                 case DCERPC_NCA_S_INVALID_CRC: val = "DCERPC_NCA_S_INVALID_CRC"; break;
 778                 case DCERPC_NCA_S_FAULT_USER_DEFINED: val = "DCERPC_NCA_S_FAULT_USER_DEFINED"; break;
 779                 case DCERPC_NCA_S_FAULT_TX_OPEN_FAILED: val = "DCERPC_NCA_S_FAULT_TX_OPEN_FAILED"; break;
 780                 case DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR: val = "DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR"; break;
 781                 case DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND: val = "DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND"; break;
 782                 case DCERPC_NCA_S_FAULT_NO_CLIENT_STUB: val = "DCERPC_NCA_S_FAULT_NO_CLIENT_STUB"; break;
 783         }
 784         ndr_print_enum(ndr, name, "ENUM", val, r);
 785 }
 786
 787 static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fault *r)
 788 {
 789         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 790         if (ndr_flags & NDR_SCALARS) {
 791                 NDR_CHECK(ndr_push_align(ndr, 4));
 792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 793                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 794                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
 795                 NDR_CHECK(ndr_push_dcerpc_nca_status(ndr, NDR_SCALARS, r->status));
 796                 {
 797                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 799                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 800                         ndr->flags = _flags_save_DATA_BLOB;
 801                 }
 802                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 803         }
 804         if (ndr_flags & NDR_BUFFERS) {
 805         }
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fault *r)
 810 {
 811         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 812         if (ndr_flags & NDR_SCALARS) {
 813                 NDR_CHECK(ndr_pull_align(ndr, 4));
 814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 815                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 816                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
 817                 NDR_CHECK(ndr_pull_dcerpc_nca_status(ndr, NDR_SCALARS, &r->status));
 818                 {
 819                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 821                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 822                         ndr->flags = _flags_save_DATA_BLOB;
 823                 }
 824                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 825         }
 826         if (ndr_flags & NDR_BUFFERS) {
 827         }
 828         return NDR_ERR_SUCCESS;
 829 }
 830
 831 _PUBLIC_ void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r)
 832 {
 833         ndr_print_struct(ndr, name, "dcerpc_fault");
 834         if (r == NULL) { ndr_print_null(ndr); return; }
 835         ndr->depth++;
 836         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 837         ndr_print_uint16(ndr, "context_id", r->context_id);
 838         ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
 839         ndr_print_dcerpc_nca_status(ndr, "status", r->status);
 840         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 841         ndr->depth--;
 842 }
 843
 844 static enum ndr_err_code ndr_push_dcerpc_AuthType(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthType r)
 845 {
 846         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 847         return NDR_ERR_SUCCESS;
 848 }
 849
 850 static enum ndr_err_code ndr_pull_dcerpc_AuthType(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthType *r)
 851 {
 852         uint8_t v;
 853         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 854         *r = v;
 855         return NDR_ERR_SUCCESS;
 856 }
 857
 858 _PUBLIC_ void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r)
 859 {
 860         const char *val = NULL;
 861
 862         switch (r) {
 863                 case DCERPC_AUTH_TYPE_NONE: val = "DCERPC_AUTH_TYPE_NONE"; break;
 864                 case DCERPC_AUTH_TYPE_KRB5_1: val = "DCERPC_AUTH_TYPE_KRB5_1"; break;
 865                 case DCERPC_AUTH_TYPE_SPNEGO: val = "DCERPC_AUTH_TYPE_SPNEGO"; break;
 866                 case DCERPC_AUTH_TYPE_NTLMSSP: val = "DCERPC_AUTH_TYPE_NTLMSSP"; break;
 867                 case DCERPC_AUTH_TYPE_KRB5: val = "DCERPC_AUTH_TYPE_KRB5"; break;
 868                 case DCERPC_AUTH_TYPE_DPA: val = "DCERPC_AUTH_TYPE_DPA"; break;
 869                 case DCERPC_AUTH_TYPE_MSN: val = "DCERPC_AUTH_TYPE_MSN"; break;
 870                 case DCERPC_AUTH_TYPE_DIGEST: val = "DCERPC_AUTH_TYPE_DIGEST"; break;
 871                 case DCERPC_AUTH_TYPE_SCHANNEL: val = "DCERPC_AUTH_TYPE_SCHANNEL"; break;
 872                 case DCERPC_AUTH_TYPE_MSMQ: val = "DCERPC_AUTH_TYPE_MSMQ"; break;
 873                 case DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM: val = "DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM"; break;
 874         }
 875         ndr_print_enum(ndr, name, "ENUM", val, r);
 876 }
 877
 878 static enum ndr_err_code ndr_push_dcerpc_AuthLevel(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthLevel r)
 879 {
 880         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 881         return NDR_ERR_SUCCESS;
 882 }
 883
 884 static enum ndr_err_code ndr_pull_dcerpc_AuthLevel(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthLevel *r)
 885 {
 886         uint8_t v;
 887         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 888         *r = v;
 889         return NDR_ERR_SUCCESS;
 890 }
 891
 892 _PUBLIC_ void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r)
 893 {
 894         const char *val = NULL;
 895
 896         switch (r) {
 897                 case DCERPC_AUTH_LEVEL_NONE: val = "DCERPC_AUTH_LEVEL_NONE"; break;
 898                 case DCERPC_AUTH_LEVEL_CONNECT: val = "DCERPC_AUTH_LEVEL_CONNECT"; break;
 899                 case DCERPC_AUTH_LEVEL_CALL: val = "DCERPC_AUTH_LEVEL_CALL"; break;
 900                 case DCERPC_AUTH_LEVEL_PACKET: val = "DCERPC_AUTH_LEVEL_PACKET"; break;
 901                 case DCERPC_AUTH_LEVEL_INTEGRITY: val = "DCERPC_AUTH_LEVEL_INTEGRITY"; break;
 902                 case DCERPC_AUTH_LEVEL_PRIVACY: val = "DCERPC_AUTH_LEVEL_PRIVACY"; break;
 903         }
 904         ndr_print_enum(ndr, name, "ENUM", val, r);
 905 }
 906
 907 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth *r)
 908 {
 909         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 910         if (ndr_flags & NDR_SCALARS) {
 911                 NDR_CHECK(ndr_push_align(ndr, 4));
 912                 NDR_CHECK(ndr_push_dcerpc_AuthType(ndr, NDR_SCALARS, r->auth_type));
 913                 NDR_CHECK(ndr_push_dcerpc_AuthLevel(ndr, NDR_SCALARS, r->auth_level));
 914                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_pad_length));
 915                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_reserved));
 916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auth_context_id));
 917                 {
 918                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 920                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
 921                         ndr->flags = _flags_save_DATA_BLOB;
 922                 }
 923                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 924         }
 925         if (ndr_flags & NDR_BUFFERS) {
 926         }
 927         return NDR_ERR_SUCCESS;
 928 }
 929
 930 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth *r)
 931 {
 932         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 933         if (ndr_flags & NDR_SCALARS) {
 934                 NDR_CHECK(ndr_pull_align(ndr, 4));
 935                 NDR_CHECK(ndr_pull_dcerpc_AuthType(ndr, NDR_SCALARS, &r->auth_type));
 936                 NDR_CHECK(ndr_pull_dcerpc_AuthLevel(ndr, NDR_SCALARS, &r->auth_level));
 937                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_pad_length));
 938                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_reserved));
 939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auth_context_id));
 940                 {
 941                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 943                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
 944                         ndr->flags = _flags_save_DATA_BLOB;
 945                 }
 946                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 947         }
 948         if (ndr_flags & NDR_BUFFERS) {
 949         }
 950         return NDR_ERR_SUCCESS;
 951 }
 952
 953 _PUBLIC_ void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r)
 954 {
 955         ndr_print_struct(ndr, name, "dcerpc_auth");
 956         if (r == NULL) { ndr_print_null(ndr); return; }
 957         ndr->depth++;
 958         ndr_print_dcerpc_AuthType(ndr, "auth_type", r->auth_type);
 959         ndr_print_dcerpc_AuthLevel(ndr, "auth_level", r->auth_level);
 960         ndr_print_uint8(ndr, "auth_pad_length", r->auth_pad_length);
 961         ndr_print_uint8(ndr, "auth_reserved", r->auth_reserved);
 962         ndr_print_uint32(ndr, "auth_context_id", r->auth_context_id);
 963         ndr_print_DATA_BLOB(ndr, "credentials", r->credentials);
 964         ndr->depth--;
 965 }
 966
 967 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth3 *r)
 968 {
 969         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 970         if (ndr_flags & NDR_SCALARS) {
 971                 NDR_CHECK(ndr_push_align(ndr, 4));
 972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 973                 {
 974                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 976                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 977                         ndr->flags = _flags_save_DATA_BLOB;
 978                 }
 979                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 980         }
 981         if (ndr_flags & NDR_BUFFERS) {
 982         }
 983         return NDR_ERR_SUCCESS;
 984 }
 985
 986 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth3 *r)
 987 {
 988         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 989         if (ndr_flags & NDR_SCALARS) {
 990                 NDR_CHECK(ndr_pull_align(ndr, 4));
 991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 992                 {
 993                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 995                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 996                         ndr->flags = _flags_save_DATA_BLOB;
 997                 }
 998                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 999         }
1000         if (ndr_flags & NDR_BUFFERS) {
1001         }
1002         return NDR_ERR_SUCCESS;
1003 }
1004
1005 _PUBLIC_ void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r)
1006 {
1007         ndr_print_struct(ndr, name, "dcerpc_auth3");
1008         if (r == NULL) { ndr_print_null(ndr); return; }
1009         ndr->depth++;
1010         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
1011         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1012         ndr->depth--;
1013 }
1014
1015 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_orphaned *r)
1016 {
1017         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1018         if (ndr_flags & NDR_SCALARS) {
1019                 NDR_CHECK(ndr_push_align(ndr, 4));
1020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1021                 {
1022                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1024                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
1025                         ndr->flags = _flags_save_DATA_BLOB;
1026                 }
1027                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1028         }
1029         if (ndr_flags & NDR_BUFFERS) {
1030         }
1031         return NDR_ERR_SUCCESS;
1032 }
1033
1034 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_orphaned *r)
1035 {
1036         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1037         if (ndr_flags & NDR_SCALARS) {
1038                 NDR_CHECK(ndr_pull_align(ndr, 4));
1039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
1040                 {
1041                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1043                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
1044                         ndr->flags = _flags_save_DATA_BLOB;
1045                 }
1046                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1047         }
1048         if (ndr_flags & NDR_BUFFERS) {
1049         }
1050         return NDR_ERR_SUCCESS;
1051 }
1052
1053 _PUBLIC_ void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r)
1054 {
1055         ndr_print_struct(ndr, name, "dcerpc_orphaned");
1056         if (r == NULL) { ndr_print_null(ndr); return; }
1057         ndr->depth++;
1058         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
1059         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1060         ndr->depth--;
1061 }
1062
1063 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_co_cancel *r)
1064 {
1065         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1066         if (ndr_flags & NDR_SCALARS) {
1067                 NDR_CHECK(ndr_push_align(ndr, 4));
1068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1069                 {
1070                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1072                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
1073                         ndr->flags = _flags_save_DATA_BLOB;
1074                 }
1075                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1076         }
1077         if (ndr_flags & NDR_BUFFERS) {
1078         }
1079         return NDR_ERR_SUCCESS;
1080 }
1081
1082 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_co_cancel *r)
1083 {
1084         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1085         if (ndr_flags & NDR_SCALARS) {
1086                 NDR_CHECK(ndr_pull_align(ndr, 4));
1087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
1088                 {
1089                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1091                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
1092                         ndr->flags = _flags_save_DATA_BLOB;
1093                 }
1094                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1095         }
1096         if (ndr_flags & NDR_BUFFERS) {
1097         }
1098         return NDR_ERR_SUCCESS;
1099 }
1100
1101 _PUBLIC_ void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r)
1102 {
1103         ndr_print_struct(ndr, name, "dcerpc_co_cancel");
1104         if (r == NULL) { ndr_print_null(ndr); return; }
1105         ndr->depth++;
1106         ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
1107         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1108         ndr->depth--;
1109 }
1110
1111 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cl_cancel *r)
1112 {
1113         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1114         if (ndr_flags & NDR_SCALARS) {
1115                 NDR_CHECK(ndr_push_align(ndr, 4));
1116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1118                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1119         }
1120         if (ndr_flags & NDR_BUFFERS) {
1121         }
1122         return NDR_ERR_SUCCESS;
1123 }
1124
1125 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cl_cancel *r)
1126 {
1127         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1128         if (ndr_flags & NDR_SCALARS) {
1129                 NDR_CHECK(ndr_pull_align(ndr, 4));
1130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1132                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1133         }
1134         if (ndr_flags & NDR_BUFFERS) {
1135         }
1136         return NDR_ERR_SUCCESS;
1137 }
1138
1139 _PUBLIC_ void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r)
1140 {
1141         ndr_print_struct(ndr, name, "dcerpc_cl_cancel");
1142         if (r == NULL) { ndr_print_null(ndr); return; }
1143         ndr->depth++;
1144         ndr_print_uint32(ndr, "version", r->version);
1145         ndr_print_uint32(ndr, "id", r->id);
1146         ndr->depth--;
1147 }
1148
1149 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cancel_ack *r)
1150 {
1151         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1152         if (ndr_flags & NDR_SCALARS) {
1153                 NDR_CHECK(ndr_push_align(ndr, 4));
1154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
1157                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1158         }
1159         if (ndr_flags & NDR_BUFFERS) {
1160         }
1161         return NDR_ERR_SUCCESS;
1162 }
1163
1164 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cancel_ack *r)
1165 {
1166         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1167         if (ndr_flags & NDR_SCALARS) {
1168                 NDR_CHECK(ndr_pull_align(ndr, 4));
1169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
1172                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1173         }
1174         if (ndr_flags & NDR_BUFFERS) {
1175         }
1176         return NDR_ERR_SUCCESS;
1177 }
1178
1179 _PUBLIC_ void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r)
1180 {
1181         ndr_print_struct(ndr, name, "dcerpc_cancel_ack");
1182         if (r == NULL) { ndr_print_null(ndr); return; }
1183         ndr->depth++;
1184         ndr_print_uint32(ndr, "version", r->version);
1185         ndr_print_uint32(ndr, "id", r->id);
1186         ndr_print_uint32(ndr, "server_is_accepting", r->server_is_accepting);
1187         ndr->depth--;
1188 }
1189
1190 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fack *r)
1191 {
1192         uint32_t cntr_selack_0;
1193         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1194         if (ndr_flags & NDR_SCALARS) {
1195                 NDR_CHECK(ndr_push_align(ndr, 4));
1196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1197                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->_pad1));
1198                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->window_size));
1199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_tdsu));
1200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_frag_size));
1201                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->serial_no));
1202                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->selack_size));
1203                 for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
1204                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
1205                 }
1206                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1207         }
1208         if (ndr_flags & NDR_BUFFERS) {
1209         }
1210         return NDR_ERR_SUCCESS;
1211 }
1212
1213 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fack *r)
1214 {
1215         uint32_t size_selack_0 = 0;
1216         uint32_t cntr_selack_0;
1217         TALLOC_CTX *_mem_save_selack_0;
1218         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1219         if (ndr_flags & NDR_SCALARS) {
1220                 NDR_CHECK(ndr_pull_align(ndr, 4));
1221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1222                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->_pad1));
1223                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->window_size));
1224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_tdsu));
1225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_frag_size));
1226                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->serial_no));
1227                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->selack_size));
1228                 size_selack_0 = r->selack_size;
1229                 NDR_PULL_ALLOC_N(ndr, r->selack, size_selack_0);
1230                 _mem_save_selack_0 = NDR_PULL_GET_MEM_CTX(ndr);
1231                 NDR_PULL_SET_MEM_CTX(ndr, r->selack, 0);
1232                 for (cntr_selack_0 = 0; cntr_selack_0 < size_selack_0; cntr_selack_0++) {
1233                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
1234                 }
1235                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
1236                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1237         }
1238         if (ndr_flags & NDR_BUFFERS) {
1239         }
1240         return NDR_ERR_SUCCESS;
1241 }
1242
1243 _PUBLIC_ void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r)
1244 {
1245         uint32_t cntr_selack_0;
1246         ndr_print_struct(ndr, name, "dcerpc_fack");
1247         if (r == NULL) { ndr_print_null(ndr); return; }
1248         ndr->depth++;
1249         ndr_print_uint32(ndr, "version", r->version);
1250         ndr_print_uint8(ndr, "_pad1", r->_pad1);
1251         ndr_print_uint16(ndr, "window_size", r->window_size);
1252         ndr_print_uint32(ndr, "max_tdsu", r->max_tdsu);
1253         ndr_print_uint32(ndr, "max_frag_size", r->max_frag_size);
1254         ndr_print_uint16(ndr, "serial_no", r->serial_no);
1255         ndr_print_uint16(ndr, "selack_size", r->selack_size);
1256         ndr->print(ndr, "%s: ARRAY(%d)", "selack", (int)r->selack_size);
1257         ndr->depth++;
1258         for (cntr_selack_0=0;cntr_selack_0<r->selack_size;cntr_selack_0++) {
1259                 ndr_print_uint32(ndr, "selack", r->selack[cntr_selack_0]);
1260         }
1261         ndr->depth--;
1262         ndr->depth--;
1263 }
1264
1265 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack *r)
1266 {
1267         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1268         if (ndr_flags & NDR_SCALARS) {
1269                 NDR_CHECK(ndr_push_align(ndr, 1));
1270                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1271         }
1272         if (ndr_flags & NDR_BUFFERS) {
1273         }
1274         return NDR_ERR_SUCCESS;
1275 }
1276
1277 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack *r)
1278 {
1279         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1280         if (ndr_flags & NDR_SCALARS) {
1281                 NDR_CHECK(ndr_pull_align(ndr, 1));
1282                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1283         }
1284         if (ndr_flags & NDR_BUFFERS) {
1285         }
1286         return NDR_ERR_SUCCESS;
1287 }
1288
1289 _PUBLIC_ void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r)
1290 {
1291         ndr_print_struct(ndr, name, "dcerpc_ack");
1292         if (r == NULL) { ndr_print_null(ndr); return; }
1293         ndr->depth++;
1294         ndr->depth--;
1295 }
1296
1297 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ping *r)
1298 {
1299         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1300         if (ndr_flags & NDR_SCALARS) {
1301                 NDR_CHECK(ndr_push_align(ndr, 1));
1302                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1303         }
1304         if (ndr_flags & NDR_BUFFERS) {
1305         }
1306         return NDR_ERR_SUCCESS;
1307 }
1308
1309 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ping *r)
1310 {
1311         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1312         if (ndr_flags & NDR_SCALARS) {
1313                 NDR_CHECK(ndr_pull_align(ndr, 1));
1314                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1315         }
1316         if (ndr_flags & NDR_BUFFERS) {
1317         }
1318         return NDR_ERR_SUCCESS;
1319 }
1320
1321 _PUBLIC_ void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r)
1322 {
1323         ndr_print_struct(ndr, name, "dcerpc_ping");
1324         if (r == NULL) { ndr_print_null(ndr); return; }
1325         ndr->depth++;
1326         ndr->depth--;
1327 }
1328
1329 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_shutdown *r)
1330 {
1331         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1332         if (ndr_flags & NDR_SCALARS) {
1333                 NDR_CHECK(ndr_push_align(ndr, 1));
1334                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1335         }
1336         if (ndr_flags & NDR_BUFFERS) {
1337         }
1338         return NDR_ERR_SUCCESS;
1339 }
1340
1341 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_shutdown *r)
1342 {
1343         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1344         if (ndr_flags & NDR_SCALARS) {
1345                 NDR_CHECK(ndr_pull_align(ndr, 1));
1346                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1347         }
1348         if (ndr_flags & NDR_BUFFERS) {
1349         }
1350         return NDR_ERR_SUCCESS;
1351 }
1352
1353 _PUBLIC_ void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r)
1354 {
1355         ndr_print_struct(ndr, name, "dcerpc_shutdown");
1356         if (r == NULL) { ndr_print_null(ndr); return; }
1357         ndr->depth++;
1358         ndr->depth--;
1359 }
1360
1361 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_working *r)
1362 {
1363         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1364         if (ndr_flags & NDR_SCALARS) {
1365                 NDR_CHECK(ndr_push_align(ndr, 1));
1366                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1367         }
1368         if (ndr_flags & NDR_BUFFERS) {
1369         }
1370         return NDR_ERR_SUCCESS;
1371 }
1372
1373 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_working *r)
1374 {
1375         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1376         if (ndr_flags & NDR_SCALARS) {
1377                 NDR_CHECK(ndr_pull_align(ndr, 1));
1378                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1379         }
1380         if (ndr_flags & NDR_BUFFERS) {
1381         }
1382         return NDR_ERR_SUCCESS;
1383 }
1384
1385 _PUBLIC_ void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r)
1386 {
1387         ndr_print_struct(ndr, name, "dcerpc_working");
1388         if (r == NULL) { ndr_print_null(ndr); return; }
1389         ndr->depth++;
1390         ndr->depth--;
1391 }
1392
1393 _PUBLIC_ enum ndr_err_code ndr_push_RTSCookie(struct ndr_push *ndr, int ndr_flags, const struct RTSCookie *r)
1394 {
1395         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1396         if (ndr_flags & NDR_SCALARS) {
1397                 NDR_CHECK(ndr_push_align(ndr, 4));
1398                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->Cookie));
1399                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1400         }
1401         if (ndr_flags & NDR_BUFFERS) {
1402         }
1403         return NDR_ERR_SUCCESS;
1404 }
1405
1406 _PUBLIC_ enum ndr_err_code ndr_pull_RTSCookie(struct ndr_pull *ndr, int ndr_flags, struct RTSCookie *r)
1407 {
1408         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1409         if (ndr_flags & NDR_SCALARS) {
1410                 NDR_CHECK(ndr_pull_align(ndr, 4));
1411                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->Cookie));
1412                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1413         }
1414         if (ndr_flags & NDR_BUFFERS) {
1415         }
1416         return NDR_ERR_SUCCESS;
1417 }
1418
1419 _PUBLIC_ void ndr_print_RTSCookie(struct ndr_print *ndr, const char *name, const struct RTSCookie *r)
1420 {
1421         ndr_print_struct(ndr, name, "RTSCookie");
1422         if (r == NULL) { ndr_print_null(ndr); return; }
1423         ndr->depth++;
1424         ndr_print_GUID(ndr, "Cookie", &r->Cookie);
1425         ndr->depth--;
1426 }
1427
1428 _PUBLIC_ enum ndr_err_code ndr_push_AddressType(struct ndr_push *ndr, int ndr_flags, enum AddressType r)
1429 {
1430         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1431         return NDR_ERR_SUCCESS;
1432 }
1433
1434 _PUBLIC_ enum ndr_err_code ndr_pull_AddressType(struct ndr_pull *ndr, int ndr_flags, enum AddressType *r)
1435 {
1436         uint32_t v;
1437         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1438         *r = v;
1439         return NDR_ERR_SUCCESS;
1440 }
1441
1442 _PUBLIC_ void ndr_print_AddressType(struct ndr_print *ndr, const char *name, enum AddressType r)
1443 {
1444         const char *val = NULL;
1445
1446         switch (r) {
1447                 case RTS_IPV4: val = "RTS_IPV4"; break;
1448                 case RTS_IPV6: val = "RTS_IPV6"; break;
1449         }
1450         ndr_print_enum(ndr, name, "ENUM", val, r);
1451 }
1452
1453 static enum ndr_err_code ndr_push_ClientAddressType(struct ndr_push *ndr, int ndr_flags, const union ClientAddressType *r)
1454 {
1455         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1456         if (ndr_flags & NDR_SCALARS) {
1457                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1458                 NDR_CHECK(ndr_push_union_align(ndr, 4));
1459                 switch (level) {
1460                         case RTS_IPV4: {
1461                                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ClientAddressIPV4));
1462                         break; }
1463
1464                         case RTS_IPV6: {
1465                                 NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ClientAddressIPV6));
1466                         break; }
1467
1468                         default:
1469                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1470                 }
1471         }
1472         if (ndr_flags & NDR_BUFFERS) {
1473                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1474                 switch (level) {
1475                         case RTS_IPV4:
1476                         break;
1477
1478                         case RTS_IPV6:
1479                         break;
1480
1481                         default:
1482                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1483                 }
1484         }
1485         return NDR_ERR_SUCCESS;
1486 }
1487
1488 static enum ndr_err_code ndr_pull_ClientAddressType(struct ndr_pull *ndr, int ndr_flags, union ClientAddressType *r)
1489 {
1490         uint32_t level;
1491         level = ndr_pull_get_switch_value(ndr, r);
1492         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1493         if (ndr_flags & NDR_SCALARS) {
1494                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
1495                 switch (level) {
1496                         case RTS_IPV4: {
1497                                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ClientAddressIPV4));
1498                         break; }
1499
1500                         case RTS_IPV6: {
1501                                 NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ClientAddressIPV6));
1502                         break; }
1503
1504                         default:
1505                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1506                 }
1507         }
1508         if (ndr_flags & NDR_BUFFERS) {
1509                 switch (level) {
1510                         case RTS_IPV4:
1511                         break;
1512
1513                         case RTS_IPV6:
1514                         break;
1515
1516                         default:
1517                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1518                 }
1519         }
1520         return NDR_ERR_SUCCESS;
1521 }
1522
1523 _PUBLIC_ void ndr_print_ClientAddressType(struct ndr_print *ndr, const char *name, const union ClientAddressType *r)
1524 {
1525         uint32_t level;
1526         level = ndr_print_get_switch_value(ndr, r);
1527         ndr_print_union(ndr, name, level, "ClientAddressType");
1528         switch (level) {
1529                 case RTS_IPV4:
1530                         ndr_print_ipv4address(ndr, "ClientAddressIPV4", r->ClientAddressIPV4);
1531                 break;
1532
1533                 case RTS_IPV6:
1534                         ndr_print_ipv6address(ndr, "ClientAddressIPV6", r->ClientAddressIPV6);
1535                 break;
1536
1537                 default:
1538                         ndr_print_bad_level(ndr, name, level);
1539         }
1540 }
1541
1542 _PUBLIC_ enum ndr_err_code ndr_push_ClientAddress(struct ndr_push *ndr, int ndr_flags, const struct ClientAddress *r)
1543 {
1544         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1545         if (ndr_flags & NDR_SCALARS) {
1546                 NDR_CHECK(ndr_push_align(ndr, 4));
1547                 NDR_CHECK(ndr_push_AddressType(ndr, NDR_SCALARS, r->AddressType));
1548                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
1549                 NDR_CHECK(ndr_push_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
1550                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, 12));
1551                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1552         }
1553         if (ndr_flags & NDR_BUFFERS) {
1554         }
1555         return NDR_ERR_SUCCESS;
1556 }
1557
1558 _PUBLIC_ enum ndr_err_code ndr_pull_ClientAddress(struct ndr_pull *ndr, int ndr_flags, struct ClientAddress *r)
1559 {
1560         uint32_t size_Padding_0 = 0;
1561         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1562         if (ndr_flags & NDR_SCALARS) {
1563                 NDR_CHECK(ndr_pull_align(ndr, 4));
1564                 NDR_CHECK(ndr_pull_AddressType(ndr, NDR_SCALARS, &r->AddressType));
1565                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
1566                 NDR_CHECK(ndr_pull_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
1567                 size_Padding_0 = 12;
1568                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, size_Padding_0));
1569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1570         }
1571         if (ndr_flags & NDR_BUFFERS) {
1572         }
1573         return NDR_ERR_SUCCESS;
1574 }
1575
1576 _PUBLIC_ void ndr_print_ClientAddress(struct ndr_print *ndr, const char *name, const struct ClientAddress *r)
1577 {
1578         ndr_print_struct(ndr, name, "ClientAddress");
1579         if (r == NULL) { ndr_print_null(ndr); return; }
1580         ndr->depth++;
1581         ndr_print_AddressType(ndr, "AddressType", r->AddressType);
1582         ndr_print_set_switch_value(ndr, &r->ClientAddress, r->AddressType);
1583         ndr_print_ClientAddressType(ndr, "ClientAddress", &r->ClientAddress);
1584         ndr_print_array_uint8(ndr, "Padding", r->Padding, 12);
1585         ndr->depth--;
1586 }
1587
1588 _PUBLIC_ enum ndr_err_code ndr_push_ForwardDestination(struct ndr_push *ndr, int ndr_flags, enum ForwardDestination r)
1589 {
1590         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1591         return NDR_ERR_SUCCESS;
1592 }
1593
1594 _PUBLIC_ enum ndr_err_code ndr_pull_ForwardDestination(struct ndr_pull *ndr, int ndr_flags, enum ForwardDestination *r)
1595 {
1596         uint32_t v;
1597         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1598         *r = v;
1599         return NDR_ERR_SUCCESS;
1600 }
1601
1602 _PUBLIC_ void ndr_print_ForwardDestination(struct ndr_print *ndr, const char *name, enum ForwardDestination r)
1603 {
1604         const char *val = NULL;
1605
1606         switch (r) {
1607                 case FDClient: val = "FDClient"; break;
1608                 case FDInProxy: val = "FDInProxy"; break;
1609                 case FDServer: val = "FDServer"; break;
1610                 case FDOutProxy: val = "FDOutProxy"; break;
1611         }
1612         ndr_print_enum(ndr, name, "ENUM", val, r);
1613 }
1614
1615 _PUBLIC_ enum ndr_err_code ndr_push_FlowControlAcknowledgment(struct ndr_push *ndr, int ndr_flags, const struct FlowControlAcknowledgment *r)
1616 {
1617         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1618         if (ndr_flags & NDR_SCALARS) {
1619                 NDR_CHECK(ndr_push_align(ndr, 4));
1620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BytesReceived));
1621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->AvailableWindow));
1622                 NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
1623                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1624         }
1625         if (ndr_flags & NDR_BUFFERS) {
1626         }
1627         return NDR_ERR_SUCCESS;
1628 }
1629
1630 _PUBLIC_ enum ndr_err_code ndr_pull_FlowControlAcknowledgment(struct ndr_pull *ndr, int ndr_flags, struct FlowControlAcknowledgment *r)
1631 {
1632         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1633         if (ndr_flags & NDR_SCALARS) {
1634                 NDR_CHECK(ndr_pull_align(ndr, 4));
1635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BytesReceived));
1636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->AvailableWindow));
1637                 NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
1638                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1639         }
1640         if (ndr_flags & NDR_BUFFERS) {
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 _PUBLIC_ void ndr_print_FlowControlAcknowledgment(struct ndr_print *ndr, const char *name, const struct FlowControlAcknowledgment *r)
1646 {
1647         ndr_print_struct(ndr, name, "FlowControlAcknowledgment");
1648         if (r == NULL) { ndr_print_null(ndr); return; }
1649         ndr->depth++;
1650         ndr_print_uint32(ndr, "BytesReceived", r->BytesReceived);
1651         ndr_print_uint32(ndr, "AvailableWindow", r->AvailableWindow);
1652         ndr_print_RTSCookie(ndr, "ChannelCookie", &r->ChannelCookie);
1653         ndr->depth--;
1654 }
1655
1656 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1657 {
1658         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1659         if (ndr_flags & NDR_SCALARS) {
1660                 NDR_CHECK(ndr_push_align(ndr, 4));
1661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ReceiveWindowSize));
1662                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1663         }
1664         if (ndr_flags & NDR_BUFFERS) {
1665         }
1666         return NDR_ERR_SUCCESS;
1667 }
1668
1669 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1670 {
1671         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1672         if (ndr_flags & NDR_SCALARS) {
1673                 NDR_CHECK(ndr_pull_align(ndr, 4));
1674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
1675                 if (r->ReceiveWindowSize > 0x40000) {
1676                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1677                 }
1678                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1679         }
1680         if (ndr_flags & NDR_BUFFERS) {
1681         }
1682         return NDR_ERR_SUCCESS;
1683 }
1684
1685 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1686 {
1687         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ReceiveWindowSize");
1688         if (r == NULL) { ndr_print_null(ndr); return; }
1689         ndr->depth++;
1690         ndr_print_uint32(ndr, "ReceiveWindowSize", r->ReceiveWindowSize);
1691         ndr->depth--;
1692 }
1693
1694 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_FlowControlAck(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_FlowControlAck *r)
1695 {
1696         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1697         if (ndr_flags & NDR_SCALARS) {
1698                 NDR_CHECK(ndr_push_align(ndr, 4));
1699                 NDR_CHECK(ndr_push_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
1700                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1701         }
1702         if (ndr_flags & NDR_BUFFERS) {
1703         }
1704         return NDR_ERR_SUCCESS;
1705 }
1706
1707 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_FlowControlAck(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_FlowControlAck *r)
1708 {
1709         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1710         if (ndr_flags & NDR_SCALARS) {
1711                 NDR_CHECK(ndr_pull_align(ndr, 4));
1712                 NDR_CHECK(ndr_pull_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
1713                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1714         }
1715         if (ndr_flags & NDR_BUFFERS) {
1716         }
1717         return NDR_ERR_SUCCESS;
1718 }
1719
1720 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_FlowControlAck(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_FlowControlAck *r)
1721 {
1722         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_FlowControlAck");
1723         if (r == NULL) { ndr_print_null(ndr); return; }
1724         ndr->depth++;
1725         ndr_print_FlowControlAcknowledgment(ndr, "Ack", &r->Ack);
1726         ndr->depth--;
1727 }
1728
1729 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
1730 {
1731         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1732         if (ndr_flags & NDR_SCALARS) {
1733                 NDR_CHECK(ndr_push_align(ndr, 4));
1734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConnectionTimeout));
1735                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1736         }
1737         if (ndr_flags & NDR_BUFFERS) {
1738         }
1739         return NDR_ERR_SUCCESS;
1740 }
1741
1742 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ConnectionTimeout *r)
1743 {
1744         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1745         if (ndr_flags & NDR_SCALARS) {
1746                 NDR_CHECK(ndr_pull_align(ndr, 4));
1747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConnectionTimeout));
1748                 if (r->ConnectionTimeout > 0xDBBA00) {
1749                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1750                 }
1751                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1752         }
1753         if (ndr_flags & NDR_BUFFERS) {
1754         }
1755         return NDR_ERR_SUCCESS;
1756 }
1757
1758 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
1759 {
1760         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ConnectionTimeout");
1761         if (r == NULL) { ndr_print_null(ndr); return; }
1762         ndr->depth++;
1763         ndr_print_uint32(ndr, "ConnectionTimeout", r->ConnectionTimeout);
1764         ndr->depth--;
1765 }
1766
1767 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Cookie(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Cookie *r)
1768 {
1769         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1770         if (ndr_flags & NDR_SCALARS) {
1771                 NDR_CHECK(ndr_push_align(ndr, 4));
1772                 NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
1773                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1774         }
1775         if (ndr_flags & NDR_BUFFERS) {
1776         }
1777         return NDR_ERR_SUCCESS;
1778 }
1779
1780 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Cookie(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Cookie *r)
1781 {
1782         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1783         if (ndr_flags & NDR_SCALARS) {
1784                 NDR_CHECK(ndr_pull_align(ndr, 4));
1785                 NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
1786                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1787         }
1788         if (ndr_flags & NDR_BUFFERS) {
1789         }
1790         return NDR_ERR_SUCCESS;
1791 }
1792
1793 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Cookie(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Cookie *r)
1794 {
1795         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Cookie");
1796         if (r == NULL) { ndr_print_null(ndr); return; }
1797         ndr->depth++;
1798         ndr_print_RTSCookie(ndr, "Cookie", &r->Cookie);
1799         ndr->depth--;
1800 }
1801
1802 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ChannelLifetime(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ChannelLifetime *r)
1803 {
1804         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1805         if (ndr_flags & NDR_SCALARS) {
1806                 NDR_CHECK(ndr_push_align(ndr, 4));
1807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ChannelLifetime));
1808                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1809         }
1810         if (ndr_flags & NDR_BUFFERS) {
1811         }
1812         return NDR_ERR_SUCCESS;
1813 }
1814
1815 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ChannelLifetime(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ChannelLifetime *r)
1816 {
1817         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1818         if (ndr_flags & NDR_SCALARS) {
1819                 NDR_CHECK(ndr_pull_align(ndr, 4));
1820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ChannelLifetime));
1821                 if (r->ChannelLifetime > 0x80000000) {
1822                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1823                 }
1824                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1825         }
1826         if (ndr_flags & NDR_BUFFERS) {
1827         }
1828         return NDR_ERR_SUCCESS;
1829 }
1830
1831 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ChannelLifetime(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ChannelLifetime *r)
1832 {
1833         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ChannelLifetime");
1834         if (r == NULL) { ndr_print_null(ndr); return; }
1835         ndr->depth++;
1836         ndr_print_uint32(ndr, "ChannelLifetime", r->ChannelLifetime);
1837         ndr->depth--;
1838 }
1839
1840 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientKeepalive(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ClientKeepalive *r)
1841 {
1842         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1843         if (ndr_flags & NDR_SCALARS) {
1844                 NDR_CHECK(ndr_push_align(ndr, 4));
1845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClientKeepalive));
1846                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1847         }
1848         if (ndr_flags & NDR_BUFFERS) {
1849         }
1850         return NDR_ERR_SUCCESS;
1851 }
1852
1853 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientKeepalive(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ClientKeepalive *r)
1854 {
1855         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1856         if (ndr_flags & NDR_SCALARS) {
1857                 NDR_CHECK(ndr_pull_align(ndr, 4));
1858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClientKeepalive));
1859                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1860         }
1861         if (ndr_flags & NDR_BUFFERS) {
1862         }
1863         return NDR_ERR_SUCCESS;
1864 }
1865
1866 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientKeepalive(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientKeepalive *r)
1867 {
1868         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientKeepalive");
1869         if (r == NULL) { ndr_print_null(ndr); return; }
1870         ndr->depth++;
1871         ndr_print_uint32(ndr, "ClientKeepalive", r->ClientKeepalive);
1872         ndr->depth--;
1873 }
1874
1875 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Version(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Version *r)
1876 {
1877         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1878         if (ndr_flags & NDR_SCALARS) {
1879                 NDR_CHECK(ndr_push_align(ndr, 4));
1880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Version));
1881                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1882         }
1883         if (ndr_flags & NDR_BUFFERS) {
1884         }
1885         return NDR_ERR_SUCCESS;
1886 }
1887
1888 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Version(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Version *r)
1889 {
1890         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1891         if (ndr_flags & NDR_SCALARS) {
1892                 NDR_CHECK(ndr_pull_align(ndr, 4));
1893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
1894                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1895         }
1896         if (ndr_flags & NDR_BUFFERS) {
1897         }
1898         return NDR_ERR_SUCCESS;
1899 }
1900
1901 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Version(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Version *r)
1902 {
1903         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Version");
1904         if (r == NULL) { ndr_print_null(ndr); return; }
1905         ndr->depth++;
1906         ndr_print_uint32(ndr, "Version", r->Version);
1907         ndr->depth--;
1908 }
1909
1910 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Empty(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Empty *r)
1911 {
1912         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1913         if (ndr_flags & NDR_SCALARS) {
1914                 NDR_CHECK(ndr_push_align(ndr, 1));
1915                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1916         }
1917         if (ndr_flags & NDR_BUFFERS) {
1918         }
1919         return NDR_ERR_SUCCESS;
1920 }
1921
1922 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Empty(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Empty *r)
1923 {
1924         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1925         if (ndr_flags & NDR_SCALARS) {
1926                 NDR_CHECK(ndr_pull_align(ndr, 1));
1927                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1928         }
1929         if (ndr_flags & NDR_BUFFERS) {
1930         }
1931         return NDR_ERR_SUCCESS;
1932 }
1933
1934 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Empty(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Empty *r)
1935 {
1936         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Empty");
1937         if (r == NULL) { ndr_print_null(ndr); return; }
1938         ndr->depth++;
1939         ndr->depth--;
1940 }
1941
1942 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Padding(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Padding *r)
1943 {
1944         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1945         if (ndr_flags & NDR_SCALARS) {
1946                 NDR_CHECK(ndr_push_align(ndr, 4));
1947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConformanceCount));
1948                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, r->ConformanceCount));
1949                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1950         }
1951         if (ndr_flags & NDR_BUFFERS) {
1952         }
1953         return NDR_ERR_SUCCESS;
1954 }
1955
1956 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Padding(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Padding *r)
1957 {
1958         uint32_t size_Padding_0 = 0;
1959         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_pull_align(ndr, 4));
1962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConformanceCount));
1963                 if (r->ConformanceCount > 0xFFFF) {
1964                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1965                 }
1966                 size_Padding_0 = r->ConformanceCount;
1967                 NDR_PULL_ALLOC_N(ndr, r->Padding, size_Padding_0);
1968                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, size_Padding_0));
1969                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1970         }
1971         if (ndr_flags & NDR_BUFFERS) {
1972         }
1973         return NDR_ERR_SUCCESS;
1974 }
1975
1976 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Padding(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Padding *r)
1977 {
1978         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Padding");
1979         if (r == NULL) { ndr_print_null(ndr); return; }
1980         ndr->depth++;
1981         ndr_print_uint32(ndr, "ConformanceCount", r->ConformanceCount);
1982         ndr_print_array_uint8(ndr, "Padding", r->Padding, r->ConformanceCount);
1983         ndr->depth--;
1984 }
1985
1986 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_NegativeANCE(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_NegativeANCE *r)
1987 {
1988         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1989         if (ndr_flags & NDR_SCALARS) {
1990                 NDR_CHECK(ndr_push_align(ndr, 1));
1991                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1992         }
1993         if (ndr_flags & NDR_BUFFERS) {
1994         }
1995         return NDR_ERR_SUCCESS;
1996 }
1997
1998 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_NegativeANCE(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_NegativeANCE *r)
1999 {
2000         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2001         if (ndr_flags & NDR_SCALARS) {
2002                 NDR_CHECK(ndr_pull_align(ndr, 1));
2003                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2004         }
2005         if (ndr_flags & NDR_BUFFERS) {
2006         }
2007         return NDR_ERR_SUCCESS;
2008 }
2009
2010 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_NegativeANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_NegativeANCE *r)
2011 {
2012         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_NegativeANCE");
2013         if (r == NULL) { ndr_print_null(ndr); return; }
2014         ndr->depth++;
2015         ndr->depth--;
2016 }
2017
2018 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ANCE(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ANCE *r)
2019 {
2020         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2021         if (ndr_flags & NDR_SCALARS) {
2022                 NDR_CHECK(ndr_push_align(ndr, 1));
2023                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2024         }
2025         if (ndr_flags & NDR_BUFFERS) {
2026         }
2027         return NDR_ERR_SUCCESS;
2028 }
2029
2030 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ANCE(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ANCE *r)
2031 {
2032         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2033         if (ndr_flags & NDR_SCALARS) {
2034                 NDR_CHECK(ndr_pull_align(ndr, 1));
2035                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2036         }
2037         if (ndr_flags & NDR_BUFFERS) {
2038         }
2039         return NDR_ERR_SUCCESS;
2040 }
2041
2042 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ANCE *r)
2043 {
2044         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ANCE");
2045         if (r == NULL) { ndr_print_null(ndr); return; }
2046         ndr->depth++;
2047         ndr->depth--;
2048 }
2049
2050 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientAddress(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ClientAddress *r)
2051 {
2052         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2053         if (ndr_flags & NDR_SCALARS) {
2054                 NDR_CHECK(ndr_push_align(ndr, 4));
2055                 NDR_CHECK(ndr_push_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2056                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2057         }
2058         if (ndr_flags & NDR_BUFFERS) {
2059         }
2060         return NDR_ERR_SUCCESS;
2061 }
2062
2063 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientAddress(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ClientAddress *r)
2064 {
2065         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2066         if (ndr_flags & NDR_SCALARS) {
2067                 NDR_CHECK(ndr_pull_align(ndr, 4));
2068                 NDR_CHECK(ndr_pull_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2069                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2070         }
2071         if (ndr_flags & NDR_BUFFERS) {
2072         }
2073         return NDR_ERR_SUCCESS;
2074 }
2075
2076 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientAddress(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientAddress *r)
2077 {
2078         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientAddress");
2079         if (r == NULL) { ndr_print_null(ndr); return; }
2080         ndr->depth++;
2081         ndr_print_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
2082         ndr->depth--;
2083 }
2084
2085 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_AssociationGroupId(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_AssociationGroupId *r)
2086 {
2087         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2088         if (ndr_flags & NDR_SCALARS) {
2089                 NDR_CHECK(ndr_push_align(ndr, 4));
2090                 NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
2091                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2092         }
2093         if (ndr_flags & NDR_BUFFERS) {
2094         }
2095         return NDR_ERR_SUCCESS;
2096 }
2097
2098 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_AssociationGroupId(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_AssociationGroupId *r)
2099 {
2100         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2101         if (ndr_flags & NDR_SCALARS) {
2102                 NDR_CHECK(ndr_pull_align(ndr, 4));
2103                 NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
2104                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2105         }
2106         if (ndr_flags & NDR_BUFFERS) {
2107         }
2108         return NDR_ERR_SUCCESS;
2109 }
2110
2111 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_AssociationGroupId(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_AssociationGroupId *r)
2112 {
2113         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_AssociationGroupId");
2114         if (r == NULL) { ndr_print_null(ndr); return; }
2115         ndr->depth++;
2116         ndr_print_RTSCookie(ndr, "AssociationGroupId", &r->AssociationGroupId);
2117         ndr->depth--;
2118 }
2119
2120 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Destination(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Destination *r)
2121 {
2122         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2123         if (ndr_flags & NDR_SCALARS) {
2124                 NDR_CHECK(ndr_push_align(ndr, 4));
2125                 NDR_CHECK(ndr_push_ForwardDestination(ndr, NDR_SCALARS, r->ForwardDestination));
2126                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2127         }
2128         if (ndr_flags & NDR_BUFFERS) {
2129         }
2130         return NDR_ERR_SUCCESS;
2131 }
2132
2133 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Destination(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Destination *r)
2134 {
2135         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2136         if (ndr_flags & NDR_SCALARS) {
2137                 NDR_CHECK(ndr_pull_align(ndr, 4));
2138                 NDR_CHECK(ndr_pull_ForwardDestination(ndr, NDR_SCALARS, &r->ForwardDestination));
2139                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2140         }
2141         if (ndr_flags & NDR_BUFFERS) {
2142         }
2143         return NDR_ERR_SUCCESS;
2144 }
2145
2146 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Destination(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Destination *r)
2147 {
2148         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Destination");
2149         if (r == NULL) { ndr_print_null(ndr); return; }
2150         ndr->depth++;
2151         ndr_print_ForwardDestination(ndr, "ForwardDestination", r->ForwardDestination);
2152         ndr->depth--;
2153 }
2154
2155 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2156 {
2157         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2158         if (ndr_flags & NDR_SCALARS) {
2159                 NDR_CHECK(ndr_push_align(ndr, 4));
2160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->PingTrafficSent));
2161                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2162         }
2163         if (ndr_flags & NDR_BUFFERS) {
2164         }
2165         return NDR_ERR_SUCCESS;
2166 }
2167
2168 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2169 {
2170         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2171         if (ndr_flags & NDR_SCALARS) {
2172                 NDR_CHECK(ndr_pull_align(ndr, 4));
2173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->PingTrafficSent));
2174                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2175         }
2176         if (ndr_flags & NDR_BUFFERS) {
2177         }
2178         return NDR_ERR_SUCCESS;
2179 }
2180
2181 _PUBLIC_ void ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2182 {
2183         ndr_print_struct(ndr, name, "dcerpc_rts_cmd_PingTrafficSentNotify");
2184         if (r == NULL) { ndr_print_null(ndr); return; }
2185         ndr->depth++;
2186         ndr_print_uint32(ndr, "PingTrafficSent", r->PingTrafficSent);
2187         ndr->depth--;
2188 }
2189
2190 static enum ndr_err_code ndr_push_dcerpc_rts_cmds(struct ndr_push *ndr, int ndr_flags, const union dcerpc_rts_cmds *r)
2191 {
2192         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2193         if (ndr_flags & NDR_SCALARS) {
2194                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2195                 NDR_CHECK(ndr_push_union_align(ndr, 4));
2196                 switch (level) {
2197                         case 0x0: {
2198                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
2199                         break; }
2200
2201                         case 0x1: {
2202                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
2203                         break; }
2204
2205                         case 0x2: {
2206                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
2207                         break; }
2208
2209                         case 0x3: {
2210                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
2211                         break; }
2212
2213                         case 0x4: {
2214                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
2215                         break; }
2216
2217                         case 0x5: {
2218                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
2219                         break; }
2220
2221                         case 0x6: {
2222                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
2223                         break; }
2224
2225                         case 0x7: {
2226                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
2227                         break; }
2228
2229                         case 0x8: {
2230                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
2231                         break; }
2232
2233                         case 0x9: {
2234                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
2235                         break; }
2236
2237                         case 0xA: {
2238                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
2239                         break; }
2240
2241                         case 0xB: {
2242                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2243                         break; }
2244
2245                         case 0xC: {
2246                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
2247                         break; }
2248
2249                         case 0xD: {
2250                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
2251                         break; }
2252
2253                         case 0xE: {
2254                                 NDR_CHECK(ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
2255                         break; }
2256
2257                         default:
2258                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2259                 }
2260         }
2261         if (ndr_flags & NDR_BUFFERS) {
2262                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2263                 switch (level) {
2264                         case 0x0:
2265                         break;
2266
2267                         case 0x1:
2268                         break;
2269
2270                         case 0x2:
2271                         break;
2272
2273                         case 0x3:
2274                         break;
2275
2276                         case 0x4:
2277                         break;
2278
2279                         case 0x5:
2280                         break;
2281
2282                         case 0x6:
2283                         break;
2284
2285                         case 0x7:
2286                         break;
2287
2288                         case 0x8:
2289                         break;
2290
2291                         case 0x9:
2292                         break;
2293
2294                         case 0xA:
2295                         break;
2296
2297                         case 0xB:
2298                         break;
2299
2300                         case 0xC:
2301                         break;
2302
2303                         case 0xD:
2304                         break;
2305
2306                         case 0xE:
2307                         break;
2308
2309                         default:
2310                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2311                 }
2312         }
2313         return NDR_ERR_SUCCESS;
2314 }
2315
2316 static enum ndr_err_code ndr_pull_dcerpc_rts_cmds(struct ndr_pull *ndr, int ndr_flags, union dcerpc_rts_cmds *r)
2317 {
2318         uint32_t level;
2319         level = ndr_pull_get_switch_value(ndr, r);
2320         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2321         if (ndr_flags & NDR_SCALARS) {
2322                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
2323                 switch (level) {
2324                         case 0x0: {
2325                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
2326                         break; }
2327
2328                         case 0x1: {
2329                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
2330                         break; }
2331
2332                         case 0x2: {
2333                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
2334                         break; }
2335
2336                         case 0x3: {
2337                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
2338                         break; }
2339
2340                         case 0x4: {
2341                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
2342                         break; }
2343
2344                         case 0x5: {
2345                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
2346                         break; }
2347
2348                         case 0x6: {
2349                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
2350                         break; }
2351
2352                         case 0x7: {
2353                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
2354                         break; }
2355
2356                         case 0x8: {
2357                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
2358                         break; }
2359
2360                         case 0x9: {
2361                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
2362                         break; }
2363
2364                         case 0xA: {
2365                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
2366                         break; }
2367
2368                         case 0xB: {
2369                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2370                         break; }
2371
2372                         case 0xC: {
2373                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
2374                         break; }
2375
2376                         case 0xD: {
2377                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
2378                         break; }
2379
2380                         case 0xE: {
2381                                 NDR_CHECK(ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
2382                         break; }
2383
2384                         default:
2385                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2386                 }
2387         }
2388         if (ndr_flags & NDR_BUFFERS) {
2389                 switch (level) {
2390                         case 0x0:
2391                         break;
2392
2393                         case 0x1:
2394                         break;
2395
2396                         case 0x2:
2397                         break;
2398
2399                         case 0x3:
2400                         break;
2401
2402                         case 0x4:
2403                         break;
2404
2405                         case 0x5:
2406                         break;
2407
2408                         case 0x6:
2409                         break;
2410
2411                         case 0x7:
2412                         break;
2413
2414                         case 0x8:
2415                         break;
2416
2417                         case 0x9:
2418                         break;
2419
2420                         case 0xA:
2421                         break;
2422
2423                         case 0xB:
2424                         break;
2425
2426                         case 0xC:
2427                         break;
2428
2429                         case 0xD:
2430                         break;
2431
2432                         case 0xE:
2433                         break;
2434
2435                         default:
2436                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2437                 }
2438         }
2439         return NDR_ERR_SUCCESS;
2440 }
2441
2442 _PUBLIC_ void ndr_print_dcerpc_rts_cmds(struct ndr_print *ndr, const char *name, const union dcerpc_rts_cmds *r)
2443 {
2444         uint32_t level;
2445         level = ndr_print_get_switch_value(ndr, r);
2446         ndr_print_union(ndr, name, level, "dcerpc_rts_cmds");
2447         switch (level) {
2448                 case 0x0:
2449                         ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(ndr, "ReceiveWindowSize", &r->ReceiveWindowSize);
2450                 break;
2451
2452                 case 0x1:
2453                         ndr_print_dcerpc_rts_cmd_FlowControlAck(ndr, "FlowControlAck", &r->FlowControlAck);
2454                 break;
2455
2456                 case 0x2:
2457                         ndr_print_dcerpc_rts_cmd_ConnectionTimeout(ndr, "ConnectionTimeout", &r->ConnectionTimeout);
2458                 break;
2459
2460                 case 0x3:
2461                         ndr_print_dcerpc_rts_cmd_Cookie(ndr, "Cookie", &r->Cookie);
2462                 break;
2463
2464                 case 0x4:
2465                         ndr_print_dcerpc_rts_cmd_ChannelLifetime(ndr, "ChannelLifetime", &r->ChannelLifetime);
2466                 break;
2467
2468                 case 0x5:
2469                         ndr_print_dcerpc_rts_cmd_ClientKeepalive(ndr, "ClientKeepalive", &r->ClientKeepalive);
2470                 break;
2471
2472                 case 0x6:
2473                         ndr_print_dcerpc_rts_cmd_Version(ndr, "Version", &r->Version);
2474                 break;
2475
2476                 case 0x7:
2477                         ndr_print_dcerpc_rts_cmd_Empty(ndr, "Empty", &r->Empty);
2478                 break;
2479
2480                 case 0x8:
2481                         ndr_print_dcerpc_rts_cmd_Padding(ndr, "Padding", &r->Padding);
2482                 break;
2483
2484                 case 0x9:
2485                         ndr_print_dcerpc_rts_cmd_NegativeANCE(ndr, "NegativeANCE", &r->NegativeANCE);
2486                 break;
2487
2488                 case 0xA:
2489                         ndr_print_dcerpc_rts_cmd_ANCE(ndr, "ANCE", &r->ANCE);
2490                 break;
2491
2492                 case 0xB:
2493                         ndr_print_dcerpc_rts_cmd_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
2494                 break;
2495
2496                 case 0xC:
2497                         ndr_print_dcerpc_rts_cmd_AssociationGroupId(ndr, "AssociationGroupId", &r->AssociationGroupId);
2498                 break;
2499
2500                 case 0xD:
2501                         ndr_print_dcerpc_rts_cmd_Destination(ndr, "Destination", &r->Destination);
2502                 break;
2503
2504                 case 0xE:
2505                         ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, "PingTrafficSentNotify", &r->PingTrafficSentNotify);
2506                 break;
2507
2508                 default:
2509                         ndr_print_bad_level(ndr, name, level);
2510         }
2511 }
2512
2513 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd *r)
2514 {
2515         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2516         if (ndr_flags & NDR_SCALARS) {
2517                 NDR_CHECK(ndr_push_align(ndr, 4));
2518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CommandType));
2519                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Command, r->CommandType));
2520                 NDR_CHECK(ndr_push_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
2521                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2522         }
2523         if (ndr_flags & NDR_BUFFERS) {
2524         }
2525         return NDR_ERR_SUCCESS;
2526 }
2527
2528 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd *r)
2529 {
2530         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2531         if (ndr_flags & NDR_SCALARS) {
2532                 NDR_CHECK(ndr_pull_align(ndr, 4));
2533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CommandType));
2534                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Command, r->CommandType));
2535                 NDR_CHECK(ndr_pull_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
2536                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2537         }
2538         if (ndr_flags & NDR_BUFFERS) {
2539         }
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_dcerpc_rts_cmd(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd *r)
2544 {
2545         ndr_print_struct(ndr, name, "dcerpc_rts_cmd");
2546         if (r == NULL) { ndr_print_null(ndr); return; }
2547         ndr->depth++;
2548         ndr_print_uint32(ndr, "CommandType", r->CommandType);
2549         ndr_print_set_switch_value(ndr, &r->Command, r->CommandType);
2550         ndr_print_dcerpc_rts_cmds(ndr, "Command", &r->Command);
2551         ndr->depth--;
2552 }
2553
2554 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_flags(struct ndr_push *ndr, int ndr_flags, uint16_t r)
2555 {
2556         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2557         return NDR_ERR_SUCCESS;
2558 }
2559
2560 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_flags(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
2561 {
2562         uint16_t v;
2563         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2564         *r = v;
2565         return NDR_ERR_SUCCESS;
2566 }
2567
2568 _PUBLIC_ void ndr_print_dcerpc_rts_flags(struct ndr_print *ndr, const char *name, uint16_t r)
2569 {
2570         ndr_print_uint16(ndr, name, r);
2571         ndr->depth++;
2572         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_NONE", RTS_FLAG_NONE, r);
2573         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_PING", RTS_FLAG_PING, r);
2574         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OTHER_CMD", RTS_FLAG_OTHER_CMD, r);
2575         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_RECYCLE_CHANNEL", RTS_FLAG_RECYCLE_CHANNEL, r);
2576         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_IN_CHANNEL", RTS_FLAG_IN_CHANNEL, r);
2577         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OUT_CHANNEL", RTS_FLAG_OUT_CHANNEL, r);
2578         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_EOF", RTS_FLAG_EOF, r);
2579         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_ECHO", RTS_FLAG_ECHO, r);
2580         ndr->depth--;
2581 }
2582
2583 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts *r)
2584 {
2585         uint32_t cntr_Commands_0;
2586         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2587         if (ndr_flags & NDR_SCALARS) {
2588                 NDR_CHECK(ndr_push_align(ndr, 4));
2589                 NDR_CHECK(ndr_push_dcerpc_rts_flags(ndr, NDR_SCALARS, r->Flags));
2590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumberOfCommands));
2591                 for (cntr_Commands_0 = 0; cntr_Commands_0 < r->NumberOfCommands; cntr_Commands_0++) {
2592                         NDR_CHECK(ndr_push_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
2593                 }
2594                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2595         }
2596         if (ndr_flags & NDR_BUFFERS) {
2597         }
2598         return NDR_ERR_SUCCESS;
2599 }
2600
2601 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts *r)
2602 {
2603         uint32_t size_Commands_0 = 0;
2604         uint32_t cntr_Commands_0;
2605         TALLOC_CTX *_mem_save_Commands_0;
2606         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2607         if (ndr_flags & NDR_SCALARS) {
2608                 NDR_CHECK(ndr_pull_align(ndr, 4));
2609                 NDR_CHECK(ndr_pull_dcerpc_rts_flags(ndr, NDR_SCALARS, &r->Flags));
2610                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumberOfCommands));
2611                 size_Commands_0 = r->NumberOfCommands;
2612                 NDR_PULL_ALLOC_N(ndr, r->Commands, size_Commands_0);
2613                 _mem_save_Commands_0 = NDR_PULL_GET_MEM_CTX(ndr);
2614                 NDR_PULL_SET_MEM_CTX(ndr, r->Commands, 0);
2615                 for (cntr_Commands_0 = 0; cntr_Commands_0 < size_Commands_0; cntr_Commands_0++) {
2616                         NDR_CHECK(ndr_pull_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
2617                 }
2618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Commands_0, 0);
2619                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2620         }
2621         if (ndr_flags & NDR_BUFFERS) {
2622         }
2623         return NDR_ERR_SUCCESS;
2624 }
2625
2626 _PUBLIC_ void ndr_print_dcerpc_rts(struct ndr_print *ndr, const char *name, const struct dcerpc_rts *r)
2627 {
2628         uint32_t cntr_Commands_0;
2629         ndr_print_struct(ndr, name, "dcerpc_rts");
2630         if (r == NULL) { ndr_print_null(ndr); return; }
2631         ndr->depth++;
2632         ndr_print_dcerpc_rts_flags(ndr, "Flags", r->Flags);
2633         ndr_print_uint16(ndr, "NumberOfCommands", r->NumberOfCommands);
2634         ndr->print(ndr, "%s: ARRAY(%d)", "Commands", (int)r->NumberOfCommands);
2635         ndr->depth++;
2636         for (cntr_Commands_0=0;cntr_Commands_0<r->NumberOfCommands;cntr_Commands_0++) {
2637                 ndr_print_dcerpc_rts_cmd(ndr, "Commands", &r->Commands[cntr_Commands_0]);
2638         }
2639         ndr->depth--;
2640         ndr->depth--;
2641 }
2642
2643 static enum ndr_err_code ndr_push_dcerpc_pkt_type(struct ndr_push *ndr, int ndr_flags, enum dcerpc_pkt_type r)
2644 {
2645         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
2646         return NDR_ERR_SUCCESS;
2647 }
2648
2649 static enum ndr_err_code ndr_pull_dcerpc_pkt_type(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_pkt_type *r)
2650 {
2651         uint8_t v;
2652         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
2653         *r = v;
2654         return NDR_ERR_SUCCESS;
2655 }
2656
2657 _PUBLIC_ void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r)
2658 {
2659         const char *val = NULL;
2660
2661         switch (r) {
2662                 case DCERPC_PKT_REQUEST: val = "DCERPC_PKT_REQUEST"; break;
2663                 case DCERPC_PKT_PING: val = "DCERPC_PKT_PING"; break;
2664                 case DCERPC_PKT_RESPONSE: val = "DCERPC_PKT_RESPONSE"; break;
2665                 case DCERPC_PKT_FAULT: val = "DCERPC_PKT_FAULT"; break;
2666                 case DCERPC_PKT_WORKING: val = "DCERPC_PKT_WORKING"; break;
2667                 case DCERPC_PKT_NOCALL: val = "DCERPC_PKT_NOCALL"; break;
2668                 case DCERPC_PKT_REJECT: val = "DCERPC_PKT_REJECT"; break;
2669                 case DCERPC_PKT_ACK: val = "DCERPC_PKT_ACK"; break;
2670                 case DCERPC_PKT_CL_CANCEL: val = "DCERPC_PKT_CL_CANCEL"; break;
2671                 case DCERPC_PKT_FACK: val = "DCERPC_PKT_FACK"; break;
2672                 case DCERPC_PKT_CANCEL_ACK: val = "DCERPC_PKT_CANCEL_ACK"; break;
2673                 case DCERPC_PKT_BIND: val = "DCERPC_PKT_BIND"; break;
2674                 case DCERPC_PKT_BIND_ACK: val = "DCERPC_PKT_BIND_ACK"; break;
2675                 case DCERPC_PKT_BIND_NAK: val = "DCERPC_PKT_BIND_NAK"; break;
2676                 case DCERPC_PKT_ALTER: val = "DCERPC_PKT_ALTER"; break;
2677                 case DCERPC_PKT_ALTER_RESP: val = "DCERPC_PKT_ALTER_RESP"; break;
2678                 case DCERPC_PKT_AUTH3: val = "DCERPC_PKT_AUTH3"; break;
2679                 case DCERPC_PKT_SHUTDOWN: val = "DCERPC_PKT_SHUTDOWN"; break;
2680                 case DCERPC_PKT_CO_CANCEL: val = "DCERPC_PKT_CO_CANCEL"; break;
2681                 case DCERPC_PKT_ORPHANED: val = "DCERPC_PKT_ORPHANED"; break;
2682                 case DCERPC_PKT_RTS: val = "DCERPC_PKT_RTS"; break;
2683         }
2684         ndr_print_enum(ndr, name, "ENUM", val, r);
2685 }
2686
2687 static enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, int ndr_flags, const union dcerpc_payload *r)
2688 {
2689         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2690         if (ndr_flags & NDR_SCALARS) {
2691                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2692                 NDR_CHECK(ndr_push_union_align(ndr, 4));
2693                 switch (level) {
2694                         case DCERPC_PKT_REQUEST: {
2695                                 NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
2696                         break; }
2697
2698                         case DCERPC_PKT_PING: {
2699                                 NDR_CHECK(ndr_push_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
2700                         break; }
2701
2702                         case DCERPC_PKT_RESPONSE: {
2703                                 NDR_CHECK(ndr_push_dcerpc_response(ndr, NDR_SCALARS, &r->response));
2704                         break; }
2705
2706                         case DCERPC_PKT_FAULT: {
2707                                 NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
2708                         break; }
2709
2710                         case DCERPC_PKT_WORKING: {
2711                                 NDR_CHECK(ndr_push_dcerpc_working(ndr, NDR_SCALARS, &r->working));
2712                         break; }
2713
2714                         case DCERPC_PKT_NOCALL: {
2715                                 NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
2716                         break; }
2717
2718                         case DCERPC_PKT_REJECT: {
2719                                 NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
2720                         break; }
2721
2722                         case DCERPC_PKT_ACK: {
2723                                 NDR_CHECK(ndr_push_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
2724                         break; }
2725
2726                         case DCERPC_PKT_CL_CANCEL: {
2727                                 NDR_CHECK(ndr_push_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
2728                         break; }
2729
2730                         case DCERPC_PKT_FACK: {
2731                                 NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
2732                         break; }
2733
2734                         case DCERPC_PKT_CANCEL_ACK: {
2735                                 NDR_CHECK(ndr_push_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
2736                         break; }
2737
2738                         case DCERPC_PKT_BIND: {
2739                                 NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
2740                         break; }
2741
2742                         case DCERPC_PKT_BIND_ACK: {
2743                                 NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
2744                         break; }
2745
2746                         case DCERPC_PKT_BIND_NAK: {
2747                                 NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
2748                         break; }
2749
2750                         case DCERPC_PKT_ALTER: {
2751                                 NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
2752                         break; }
2753
2754                         case DCERPC_PKT_ALTER_RESP: {
2755                                 NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
2756                         break; }
2757
2758                         case DCERPC_PKT_SHUTDOWN: {
2759                                 NDR_CHECK(ndr_push_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
2760                         break; }
2761
2762                         case DCERPC_PKT_CO_CANCEL: {
2763                                 NDR_CHECK(ndr_push_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
2764                         break; }
2765
2766                         case DCERPC_PKT_ORPHANED: {
2767                                 NDR_CHECK(ndr_push_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
2768                         break; }
2769
2770                         case DCERPC_PKT_AUTH3: {
2771                                 NDR_CHECK(ndr_push_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
2772                         break; }
2773
2774                         case DCERPC_PKT_RTS: {
2775                                 NDR_CHECK(ndr_push_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
2776                         break; }
2777
2778                         default:
2779                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2780                 }
2781         }
2782         if (ndr_flags & NDR_BUFFERS) {
2783                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2784                 switch (level) {
2785                         case DCERPC_PKT_REQUEST:
2786                         break;
2787
2788                         case DCERPC_PKT_PING:
2789                         break;
2790
2791                         case DCERPC_PKT_RESPONSE:
2792                         break;
2793
2794                         case DCERPC_PKT_FAULT:
2795                         break;
2796
2797                         case DCERPC_PKT_WORKING:
2798                         break;
2799
2800                         case DCERPC_PKT_NOCALL:
2801                         break;
2802
2803                         case DCERPC_PKT_REJECT:
2804                         break;
2805
2806                         case DCERPC_PKT_ACK:
2807                         break;
2808
2809                         case DCERPC_PKT_CL_CANCEL:
2810                         break;
2811
2812                         case DCERPC_PKT_FACK:
2813                         break;
2814
2815                         case DCERPC_PKT_CANCEL_ACK:
2816                         break;
2817
2818                         case DCERPC_PKT_BIND:
2819                         break;
2820
2821                         case DCERPC_PKT_BIND_ACK:
2822                         break;
2823
2824                         case DCERPC_PKT_BIND_NAK:
2825                                 NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
2826                         break;
2827
2828                         case DCERPC_PKT_ALTER:
2829                         break;
2830
2831                         case DCERPC_PKT_ALTER_RESP:
2832                         break;
2833
2834                         case DCERPC_PKT_SHUTDOWN:
2835                         break;
2836
2837                         case DCERPC_PKT_CO_CANCEL:
2838                         break;
2839
2840                         case DCERPC_PKT_ORPHANED:
2841                         break;
2842
2843                         case DCERPC_PKT_AUTH3:
2844                         break;
2845
2846                         case DCERPC_PKT_RTS:
2847                         break;
2848
2849                         default:
2850                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2851                 }
2852         }
2853         return NDR_ERR_SUCCESS;
2854 }
2855
2856 static enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, int ndr_flags, union dcerpc_payload *r)
2857 {
2858         uint32_t level;
2859         level = ndr_pull_get_switch_value(ndr, r);
2860         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2861         if (ndr_flags & NDR_SCALARS) {
2862                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
2863                 switch (level) {
2864                         case DCERPC_PKT_REQUEST: {
2865                                 NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
2866                         break; }
2867
2868                         case DCERPC_PKT_PING: {
2869                                 NDR_CHECK(ndr_pull_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
2870                         break; }
2871
2872                         case DCERPC_PKT_RESPONSE: {
2873                                 NDR_CHECK(ndr_pull_dcerpc_response(ndr, NDR_SCALARS, &r->response));
2874                         break; }
2875
2876                         case DCERPC_PKT_FAULT: {
2877                                 NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
2878                         break; }
2879
2880                         case DCERPC_PKT_WORKING: {
2881                                 NDR_CHECK(ndr_pull_dcerpc_working(ndr, NDR_SCALARS, &r->working));
2882                         break; }
2883
2884                         case DCERPC_PKT_NOCALL: {
2885                                 NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
2886                         break; }
2887
2888                         case DCERPC_PKT_REJECT: {
2889                                 NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
2890                         break; }
2891
2892                         case DCERPC_PKT_ACK: {
2893                                 NDR_CHECK(ndr_pull_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
2894                         break; }
2895
2896                         case DCERPC_PKT_CL_CANCEL: {
2897                                 NDR_CHECK(ndr_pull_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
2898                         break; }
2899
2900                         case DCERPC_PKT_FACK: {
2901                                 NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
2902                         break; }
2903
2904                         case DCERPC_PKT_CANCEL_ACK: {
2905                                 NDR_CHECK(ndr_pull_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
2906                         break; }
2907
2908                         case DCERPC_PKT_BIND: {
2909                                 NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
2910                         break; }
2911
2912                         case DCERPC_PKT_BIND_ACK: {
2913                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
2914                         break; }
2915
2916                         case DCERPC_PKT_BIND_NAK: {
2917                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
2918                         break; }
2919
2920                         case DCERPC_PKT_ALTER: {
2921                                 NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
2922                         break; }
2923
2924                         case DCERPC_PKT_ALTER_RESP: {
2925                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
2926                         break; }
2927
2928                         case DCERPC_PKT_SHUTDOWN: {
2929                                 NDR_CHECK(ndr_pull_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
2930                         break; }
2931
2932                         case DCERPC_PKT_CO_CANCEL: {
2933                                 NDR_CHECK(ndr_pull_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
2934                         break; }
2935
2936                         case DCERPC_PKT_ORPHANED: {
2937                                 NDR_CHECK(ndr_pull_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
2938                         break; }
2939
2940                         case DCERPC_PKT_AUTH3: {
2941                                 NDR_CHECK(ndr_pull_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
2942                         break; }
2943
2944                         case DCERPC_PKT_RTS: {
2945                                 NDR_CHECK(ndr_pull_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
2946                         break; }
2947
2948                         default:
2949                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2950                 }
2951         }
2952         if (ndr_flags & NDR_BUFFERS) {
2953                 switch (level) {
2954                         case DCERPC_PKT_REQUEST:
2955                         break;
2956
2957                         case DCERPC_PKT_PING:
2958                         break;
2959
2960                         case DCERPC_PKT_RESPONSE:
2961                         break;
2962
2963                         case DCERPC_PKT_FAULT:
2964                         break;
2965
2966                         case DCERPC_PKT_WORKING:
2967                         break;
2968
2969                         case DCERPC_PKT_NOCALL:
2970                         break;
2971
2972                         case DCERPC_PKT_REJECT:
2973                         break;
2974
2975                         case DCERPC_PKT_ACK:
2976                         break;
2977
2978                         case DCERPC_PKT_CL_CANCEL:
2979                         break;
2980
2981                         case DCERPC_PKT_FACK:
2982                         break;
2983
2984                         case DCERPC_PKT_CANCEL_ACK:
2985                         break;
2986
2987                         case DCERPC_PKT_BIND:
2988                         break;
2989
2990                         case DCERPC_PKT_BIND_ACK:
2991                         break;
2992
2993                         case DCERPC_PKT_BIND_NAK:
2994                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
2995                         break;
2996
2997                         case DCERPC_PKT_ALTER:
2998                         break;
2999
3000                         case DCERPC_PKT_ALTER_RESP:
3001                         break;
3002
3003                         case DCERPC_PKT_SHUTDOWN:
3004                         break;
3005
3006                         case DCERPC_PKT_CO_CANCEL:
3007                         break;
3008
3009                         case DCERPC_PKT_ORPHANED:
3010                         break;
3011
3012                         case DCERPC_PKT_AUTH3:
3013                         break;
3014
3015                         case DCERPC_PKT_RTS:
3016                         break;
3017
3018                         default:
3019                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3020                 }
3021         }
3022         return NDR_ERR_SUCCESS;
3023 }
3024
3025 _PUBLIC_ void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r)
3026 {
3027         uint32_t level;
3028         level = ndr_print_get_switch_value(ndr, r);
3029         ndr_print_union(ndr, name, level, "dcerpc_payload");
3030         switch (level) {
3031                 case DCERPC_PKT_REQUEST:
3032                         ndr_print_dcerpc_request(ndr, "request", &r->request);
3033                 break;
3034
3035                 case DCERPC_PKT_PING:
3036                         ndr_print_dcerpc_ping(ndr, "ping", &r->ping);
3037                 break;
3038
3039                 case DCERPC_PKT_RESPONSE:
3040                         ndr_print_dcerpc_response(ndr, "response", &r->response);
3041                 break;
3042
3043                 case DCERPC_PKT_FAULT:
3044                         ndr_print_dcerpc_fault(ndr, "fault", &r->fault);
3045                 break;
3046
3047                 case DCERPC_PKT_WORKING:
3048                         ndr_print_dcerpc_working(ndr, "working", &r->working);
3049                 break;
3050
3051                 case DCERPC_PKT_NOCALL:
3052                         ndr_print_dcerpc_fack(ndr, "nocall", &r->nocall);
3053                 break;
3054
3055                 case DCERPC_PKT_REJECT:
3056                         ndr_print_dcerpc_fault(ndr, "reject", &r->reject);
3057                 break;
3058
3059                 case DCERPC_PKT_ACK:
3060                         ndr_print_dcerpc_ack(ndr, "ack", &r->ack);
3061                 break;
3062
3063                 case DCERPC_PKT_CL_CANCEL:
3064                         ndr_print_dcerpc_cl_cancel(ndr, "cl_cancel", &r->cl_cancel);
3065                 break;
3066
3067                 case DCERPC_PKT_FACK:
3068                         ndr_print_dcerpc_fack(ndr, "fack", &r->fack);
3069                 break;
3070
3071                 case DCERPC_PKT_CANCEL_ACK:
3072                         ndr_print_dcerpc_cancel_ack(ndr, "cancel_ack", &r->cancel_ack);
3073                 break;
3074
3075                 case DCERPC_PKT_BIND:
3076                         ndr_print_dcerpc_bind(ndr, "bind", &r->bind);
3077                 break;
3078
3079                 case DCERPC_PKT_BIND_ACK:
3080                         ndr_print_dcerpc_bind_ack(ndr, "bind_ack", &r->bind_ack);
3081                 break;
3082
3083                 case DCERPC_PKT_BIND_NAK:
3084                         ndr_print_dcerpc_bind_nak(ndr, "bind_nak", &r->bind_nak);
3085                 break;
3086
3087                 case DCERPC_PKT_ALTER:
3088                         ndr_print_dcerpc_bind(ndr, "alter", &r->alter);
3089                 break;
3090
3091                 case DCERPC_PKT_ALTER_RESP:
3092                         ndr_print_dcerpc_bind_ack(ndr, "alter_resp", &r->alter_resp);
3093                 break;
3094
3095                 case DCERPC_PKT_SHUTDOWN:
3096                         ndr_print_dcerpc_shutdown(ndr, "shutdown", &r->shutdown);
3097                 break;
3098
3099                 case DCERPC_PKT_CO_CANCEL:
3100                         ndr_print_dcerpc_co_cancel(ndr, "co_cancel", &r->co_cancel);
3101                 break;
3102
3103                 case DCERPC_PKT_ORPHANED:
3104                         ndr_print_dcerpc_orphaned(ndr, "orphaned", &r->orphaned);
3105                 break;
3106
3107                 case DCERPC_PKT_AUTH3:
3108                         ndr_print_dcerpc_auth3(ndr, "auth3", &r->auth3);
3109                 break;
3110
3111                 case DCERPC_PKT_RTS:
3112                         ndr_print_dcerpc_rts(ndr, "rts", &r->rts);
3113                 break;
3114
3115                 default:
3116                         ndr_print_bad_level(ndr, name, level);
3117         }
3118 }
3119
3120 _PUBLIC_ enum ndr_err_code ndr_push_ncacn_packet(struct ndr_push *ndr, int ndr_flags, const struct ncacn_packet *r)
3121 {
3122         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3123         if (ndr_flags & NDR_SCALARS) {
3124                 NDR_CHECK(ndr_push_align(ndr, 4));
3125                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
3126                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers_minor));
3127                 NDR_CHECK(ndr_push_dcerpc_pkt_type(ndr, NDR_SCALARS, r->ptype));
3128                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
3129                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
3130                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->frag_length));
3131                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->auth_length));
3132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
3133                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
3134                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
3135                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3136         }
3137         if (ndr_flags & NDR_BUFFERS) {
3138                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
3139         }
3140         return NDR_ERR_SUCCESS;
3141 }
3142
3143 _PUBLIC_ enum ndr_err_code ndr_pull_ncacn_packet(struct ndr_pull *ndr, int ndr_flags, struct ncacn_packet *r)
3144 {
3145         uint32_t size_drep_0 = 0;
3146         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3147         if (ndr_flags & NDR_SCALARS) {
3148                 NDR_CHECK(ndr_pull_align(ndr, 4));
3149                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
3150                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers_minor));
3151                 NDR_CHECK(ndr_pull_dcerpc_pkt_type(ndr, NDR_SCALARS, &r->ptype));
3152                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
3153                 size_drep_0 = 4;
3154                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, size_drep_0));
3155                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->frag_length));
3156                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->auth_length));
3157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
3158                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
3159                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
3160                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3161         }
3162         if (ndr_flags & NDR_BUFFERS) {
3163                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
3164         }
3165         return NDR_ERR_SUCCESS;
3166 }
3167
3168 _PUBLIC_ void ndr_print_ncacn_packet(struct ndr_print *ndr, const char *name, const struct ncacn_packet *r)
3169 {
3170         ndr_print_struct(ndr, name, "ncacn_packet");
3171         if (r == NULL) { ndr_print_null(ndr); return; }
3172         ndr->depth++;
3173         ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
3174         ndr_print_uint8(ndr, "rpc_vers_minor", r->rpc_vers_minor);
3175         ndr_print_dcerpc_pkt_type(ndr, "ptype", r->ptype);
3176         ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
3177         ndr_print_array_uint8(ndr, "drep", r->drep, 4);
3178         ndr_print_uint16(ndr, "frag_length", r->frag_length);
3179         ndr_print_uint16(ndr, "auth_length", r->auth_length);
3180         ndr_print_uint32(ndr, "call_id", r->call_id);
3181         ndr_print_set_switch_value(ndr, &r->u, r->ptype);
3182         ndr_print_dcerpc_payload(ndr, "u", &r->u);
3183         ndr->depth--;
3184 }
3185
3186 _PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, int ndr_flags, const struct ncadg_packet *r)
3187 {
3188         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3189         if (ndr_flags & NDR_SCALARS) {
3190                 NDR_CHECK(ndr_push_align(ndr, 4));
3191                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
3192                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ptype));
3193                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
3194                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ncadg_flags));
3195                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
3196                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_high));
3197                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
3198                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iface));
3199                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->activity));
3200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_boot));
3201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iface_version));
3202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->seq_num));
3203                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
3204                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ihint));
3205                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ahint));
3206                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->len));
3207                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->fragnum));
3208                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_proto));
3209                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
3210                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
3211                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
3212                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3213         }
3214         if (ndr_flags & NDR_BUFFERS) {
3215                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
3216         }
3217         return NDR_ERR_SUCCESS;
3218 }
3219
3220 _PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, int ndr_flags, struct ncadg_packet *r)
3221 {
3222         uint32_t size_drep_0 = 0;
3223         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3224         if (ndr_flags & NDR_SCALARS) {
3225                 NDR_CHECK(ndr_pull_align(ndr, 4));
3226                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
3227                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ptype));
3228                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
3229                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ncadg_flags));
3230                 size_drep_0 = 3;
3231                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, size_drep_0));
3232                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_high));
3233                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
3234                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iface));
3235                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->activity));
3236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_boot));
3237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iface_version));
3238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->seq_num));
3239                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
3240                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ihint));
3241                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ahint));
3242                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->len));
3243                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->fragnum));
3244                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_proto));
3245                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
3246                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
3247                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
3248                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3249         }
3250         if (ndr_flags & NDR_BUFFERS) {
3251                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
3252         }
3253         return NDR_ERR_SUCCESS;
3254 }
3255
3256 _PUBLIC_ void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r)
3257 {
3258         ndr_print_struct(ndr, name, "ncadg_packet");
3259         if (r == NULL) { ndr_print_null(ndr); return; }
3260         ndr->depth++;
3261         ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
3262         ndr_print_uint8(ndr, "ptype", r->ptype);
3263         ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
3264         ndr_print_uint8(ndr, "ncadg_flags", r->ncadg_flags);
3265         ndr_print_array_uint8(ndr, "drep", r->drep, 3);
3266         ndr_print_uint8(ndr, "serial_high", r->serial_high);
3267         ndr_print_GUID(ndr, "object", &r->object);
3268         ndr_print_GUID(ndr, "iface", &r->iface);
3269         ndr_print_GUID(ndr, "activity", &r->activity);
3270         ndr_print_uint32(ndr, "server_boot", r->server_boot);
3271         ndr_print_uint32(ndr, "iface_version", r->iface_version);
3272         ndr_print_uint32(ndr, "seq_num", r->seq_num);
3273         ndr_print_uint16(ndr, "opnum", r->opnum);
3274         ndr_print_uint16(ndr, "ihint", r->ihint);
3275         ndr_print_uint16(ndr, "ahint", r->ahint);
3276         ndr_print_uint16(ndr, "len", r->len);
3277         ndr_print_uint16(ndr, "fragnum", r->fragnum);
3278         ndr_print_uint8(ndr, "auth_proto", r->auth_proto);
3279         ndr_print_uint8(ndr, "serial_low", r->serial_low);
3280         ndr_print_set_switch_value(ndr, &r->u, r->ptype);
3281         ndr_print_dcerpc_payload(ndr, "u", &r->u);
3282         ndr->depth--;
3283 }
3284