librpc/gen_ndr/ndr_dcerpc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../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         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
  13                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_transfer_syntaxes));
  14                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
  15                 for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < r->num_transfer_syntaxes; cntr_transfer_syntaxes_0++) {
  16                         NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
  17                 }
  18                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  19         }
  20         if (ndr_flags & NDR_BUFFERS) {
  21         }
  22         return NDR_ERR_SUCCESS;
  23 }
  24
  25 static enum ndr_err_code ndr_pull_dcerpc_ctx_list(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ctx_list *r)
  26 {
  27         uint32_t cntr_transfer_syntaxes_0;
  28         TALLOC_CTX *_mem_save_transfer_syntaxes_0;
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 4));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
  32                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_transfer_syntaxes));
  33                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
  34                 NDR_PULL_ALLOC_N(ndr, r->transfer_syntaxes, r->num_transfer_syntaxes);
  35                 _mem_save_transfer_syntaxes_0 = NDR_PULL_GET_MEM_CTX(ndr);
  36                 NDR_PULL_SET_MEM_CTX(ndr, r->transfer_syntaxes, 0);
  37                 for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < r->num_transfer_syntaxes; cntr_transfer_syntaxes_0++) {
  38                         NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
  39                 }
  40                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transfer_syntaxes_0, 0);
  41                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  42         }
  43         if (ndr_flags & NDR_BUFFERS) {
  44         }
  45         return NDR_ERR_SUCCESS;
  46 }
  47
  48 _PUBLIC_ void ndr_print_dcerpc_ctx_list(struct ndr_print *ndr, const char *name, const struct dcerpc_ctx_list *r)
  49 {
  50         uint32_t cntr_transfer_syntaxes_0;
  51         ndr_print_struct(ndr, name, "dcerpc_ctx_list");
  52         ndr->depth++;
  53         ndr_print_uint16(ndr, "context_id", r->context_id);
  54         ndr_print_uint8(ndr, "num_transfer_syntaxes", r->num_transfer_syntaxes);
  55         ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
  56         ndr->print(ndr, "%s: ARRAY(%d)", "transfer_syntaxes", (int)r->num_transfer_syntaxes);
  57         ndr->depth++;
  58         for (cntr_transfer_syntaxes_0=0;cntr_transfer_syntaxes_0<r->num_transfer_syntaxes;cntr_transfer_syntaxes_0++) {
  59                 char *idx_0=NULL;
  60                 if (asprintf(&idx_0, "[%d]", cntr_transfer_syntaxes_0) != -1) {
  61                         ndr_print_ndr_syntax_id(ndr, "transfer_syntaxes", &r->transfer_syntaxes[cntr_transfer_syntaxes_0]);
  62                         free(idx_0);
  63                 }
  64         }
  65         ndr->depth--;
  66         ndr->depth--;
  67 }
  68
  69 static enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind *r)
  70 {
  71         uint32_t cntr_ctx_list_0;
  72         if (ndr_flags & NDR_SCALARS) {
  73                 NDR_CHECK(ndr_push_align(ndr, 4));
  74                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
  75                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
  76                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
  77                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_contexts));
  78                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
  79                         NDR_CHECK(ndr_push_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
  80                 }
  81                 {
  82                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  83                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
  84                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
  85                         ndr->flags = _flags_save_DATA_BLOB;
  86                 }
  87                 {
  88                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
  89                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
  90                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
  91                         ndr->flags = _flags_save_DATA_BLOB;
  92                 }
  93                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  94         }
  95         if (ndr_flags & NDR_BUFFERS) {
  96         }
  97         return NDR_ERR_SUCCESS;
  98 }
  99
 100 static enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind *r)
 101 {
 102         uint32_t cntr_ctx_list_0;
 103         TALLOC_CTX *_mem_save_ctx_list_0;
 104         if (ndr_flags & NDR_SCALARS) {
 105                 NDR_CHECK(ndr_pull_align(ndr, 4));
 106                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
 107                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
 108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
 109                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_contexts));
 110                 NDR_PULL_ALLOC_N(ndr, r->ctx_list, r->num_contexts);
 111                 _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
 112                 NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
 113                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
 114                         NDR_CHECK(ndr_pull_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 115                 }
 116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
 117                 {
 118                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 120                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 121                         ndr->flags = _flags_save_DATA_BLOB;
 122                 }
 123                 {
 124                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 126                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 127                         ndr->flags = _flags_save_DATA_BLOB;
 128                 }
 129                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 130         }
 131         if (ndr_flags & NDR_BUFFERS) {
 132         }
 133         return NDR_ERR_SUCCESS;
 134 }
 135
 136 _PUBLIC_ void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r)
 137 {
 138         uint32_t cntr_ctx_list_0;
 139         ndr_print_struct(ndr, name, "dcerpc_bind");
 140         ndr->depth++;
 141         ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
 142         ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
 143         ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
 144         ndr_print_uint8(ndr, "num_contexts", r->num_contexts);
 145         ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_contexts);
 146         ndr->depth++;
 147         for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_contexts;cntr_ctx_list_0++) {
 148                 char *idx_0=NULL;
 149                 if (asprintf(&idx_0, "[%d]", cntr_ctx_list_0) != -1) {
 150                         ndr_print_dcerpc_ctx_list(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
 151                         free(idx_0);
 152                 }
 153         }
 154         ndr->depth--;
 155         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 156         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 157         ndr->depth--;
 158 }
 159
 160 static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_empty *r)
 161 {
 162         if (ndr_flags & NDR_SCALARS) {
 163                 NDR_CHECK(ndr_push_align(ndr, 1));
 164                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 165         }
 166         if (ndr_flags & NDR_BUFFERS) {
 167         }
 168         return NDR_ERR_SUCCESS;
 169 }
 170
 171 static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_empty *r)
 172 {
 173         if (ndr_flags & NDR_SCALARS) {
 174                 NDR_CHECK(ndr_pull_align(ndr, 1));
 175                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 176         }
 177         if (ndr_flags & NDR_BUFFERS) {
 178         }
 179         return NDR_ERR_SUCCESS;
 180 }
 181
 182 _PUBLIC_ void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r)
 183 {
 184         ndr_print_struct(ndr, name, "dcerpc_empty");
 185         ndr->depth++;
 186         ndr->depth--;
 187 }
 188
 189 static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, int ndr_flags, const union dcerpc_object *r)
 190 {
 191         if (ndr_flags & NDR_SCALARS) {
 192                 int level = ndr_push_get_switch_value(ndr, r);
 193                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 194                 switch (level) {
 195                         default: {
 196                                 NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
 197                         break; }
 198
 199                         case LIBNDR_FLAG_OBJECT_PRESENT: {
 200                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
 201                         break; }
 202
 203                 }
 204         }
 205         if (ndr_flags & NDR_BUFFERS) {
 206                 int level = ndr_push_get_switch_value(ndr, r);
 207                 switch (level) {
 208                         default:
 209                         break;
 210
 211                         case LIBNDR_FLAG_OBJECT_PRESENT:
 212                         break;
 213
 214                 }
 215         }
 216         return NDR_ERR_SUCCESS;
 217 }
 218
 219 static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, int ndr_flags, union dcerpc_object *r)
 220 {
 221         int level;
 222         level = ndr_pull_get_switch_value(ndr, r);
 223         if (ndr_flags & NDR_SCALARS) {
 224                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 225                 switch (level) {
 226                         default: {
 227                                 NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
 228                         break; }
 229
 230                         case LIBNDR_FLAG_OBJECT_PRESENT: {
 231                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
 232                         break; }
 233
 234                 }
 235         }
 236         if (ndr_flags & NDR_BUFFERS) {
 237                 switch (level) {
 238                         default:
 239                         break;
 240
 241                         case LIBNDR_FLAG_OBJECT_PRESENT:
 242                         break;
 243
 244                 }
 245         }
 246         return NDR_ERR_SUCCESS;
 247 }
 248
 249 _PUBLIC_ void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r)
 250 {
 251         int level;
 252         level = ndr_print_get_switch_value(ndr, r);
 253         ndr_print_union(ndr, name, level, "dcerpc_object");
 254         switch (level) {
 255                 default:
 256                         ndr_print_dcerpc_empty(ndr, "empty", &r->empty);
 257                 break;
 258
 259                 case LIBNDR_FLAG_OBJECT_PRESENT:
 260                         ndr_print_GUID(ndr, "object", &r->object);
 261                 break;
 262
 263         }
 264 }
 265
 266 static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_request *r)
 267 {
 268         if (ndr_flags & NDR_SCALARS) {
 269                 NDR_CHECK(ndr_push_align(ndr, 4));
 270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 271                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 272                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
 273                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
 274                 NDR_CHECK(ndr_push_dcerpc_object(ndr, NDR_SCALARS, &r->object));
 275                 {
 276                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 278                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 279                         ndr->flags = _flags_save_DATA_BLOB;
 280                 }
 281                 {
 282                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 284                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
 285                         ndr->flags = _flags_save_DATA_BLOB;
 286                 }
 287                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 288         }
 289         if (ndr_flags & NDR_BUFFERS) {
 290         }
 291         return NDR_ERR_SUCCESS;
 292 }
 293
 294 static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_request *r)
 295 {
 296         if (ndr_flags & NDR_SCALARS) {
 297                 NDR_CHECK(ndr_pull_align(ndr, 4));
 298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 299                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 300                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
 301                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
 302                 NDR_CHECK(ndr_pull_dcerpc_object(ndr, NDR_SCALARS, &r->object));
 303                 {
 304                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 306                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 307                         ndr->flags = _flags_save_DATA_BLOB;
 308                 }
 309                 {
 310                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 312                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
 313                         ndr->flags = _flags_save_DATA_BLOB;
 314                 }
 315                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 316         }
 317         if (ndr_flags & NDR_BUFFERS) {
 318         }
 319         return NDR_ERR_SUCCESS;
 320 }
 321
 322 _PUBLIC_ void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r)
 323 {
 324         ndr_print_struct(ndr, name, "dcerpc_request");
 325         ndr->depth++;
 326         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 327         ndr_print_uint16(ndr, "context_id", r->context_id);
 328         ndr_print_uint16(ndr, "opnum", r->opnum);
 329         ndr_print_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT);
 330         ndr_print_dcerpc_object(ndr, "object", &r->object);
 331         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 332         ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
 333         ndr->depth--;
 334 }
 335
 336 static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack_ctx *r)
 337 {
 338         if (ndr_flags & NDR_SCALARS) {
 339                 NDR_CHECK(ndr_push_align(ndr, 4));
 340                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->result));
 341                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reason));
 342                 NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
 343                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 344         }
 345         if (ndr_flags & NDR_BUFFERS) {
 346         }
 347         return NDR_ERR_SUCCESS;
 348 }
 349
 350 static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack_ctx *r)
 351 {
 352         if (ndr_flags & NDR_SCALARS) {
 353                 NDR_CHECK(ndr_pull_align(ndr, 4));
 354                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->result));
 355                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reason));
 356                 NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
 357                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 358         }
 359         if (ndr_flags & NDR_BUFFERS) {
 360         }
 361         return NDR_ERR_SUCCESS;
 362 }
 363
 364 _PUBLIC_ void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r)
 365 {
 366         ndr_print_struct(ndr, name, "dcerpc_ack_ctx");
 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         if (ndr_flags & NDR_SCALARS) {
 378                 NDR_CHECK(ndr_push_align(ndr, 4));
 379                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
 380                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
 381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
 382                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->secondary_address) + 1));
 383                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->secondary_address, strlen(r->secondary_address) + 1, sizeof(uint8_t), CH_DOS));
 384                 {
 385                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 387                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad1));
 388                         ndr->flags = _flags_save_DATA_BLOB;
 389                 }
 390                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_results));
 391                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
 392                         NDR_CHECK(ndr_push_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 393                 }
 394                 {
 395                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 397                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 398                         ndr->flags = _flags_save_DATA_BLOB;
 399                 }
 400                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 401         }
 402         if (ndr_flags & NDR_BUFFERS) {
 403         }
 404         return NDR_ERR_SUCCESS;
 405 }
 406
 407 static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_ack *r)
 408 {
 409         uint32_t cntr_ctx_list_0;
 410         TALLOC_CTX *_mem_save_ctx_list_0;
 411         if (ndr_flags & NDR_SCALARS) {
 412                 NDR_CHECK(ndr_pull_align(ndr, 4));
 413                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
 414                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
 416                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->secondary_address_size));
 417                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->secondary_address, r->secondary_address_size, sizeof(uint8_t), CH_DOS));
 418                 {
 419                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 421                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad1));
 422                         ndr->flags = _flags_save_DATA_BLOB;
 423                 }
 424                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_results));
 425                 NDR_PULL_ALLOC_N(ndr, r->ctx_list, r->num_results);
 426                 _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
 427                 NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
 428                 for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
 429                         NDR_CHECK(ndr_pull_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 430                 }
 431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
 432                 {
 433                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 435                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 436                         ndr->flags = _flags_save_DATA_BLOB;
 437                 }
 438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 439         }
 440         if (ndr_flags & NDR_BUFFERS) {
 441         }
 442         return NDR_ERR_SUCCESS;
 443 }
 444
 445 _PUBLIC_ void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r)
 446 {
 447         uint32_t cntr_ctx_list_0;
 448         ndr_print_struct(ndr, name, "dcerpc_bind_ack");
 449         ndr->depth++;
 450         ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
 451         ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
 452         ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
 453         ndr_print_uint16(ndr, "secondary_address_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->secondary_address) + 1:r->secondary_address_size);
 454         ndr_print_string(ndr, "secondary_address", r->secondary_address);
 455         ndr_print_DATA_BLOB(ndr, "_pad1", r->_pad1);
 456         ndr_print_uint8(ndr, "num_results", r->num_results);
 457         ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_results);
 458         ndr->depth++;
 459         for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_results;cntr_ctx_list_0++) {
 460                 char *idx_0=NULL;
 461                 if (asprintf(&idx_0, "[%d]", cntr_ctx_list_0) != -1) {
 462                         ndr_print_dcerpc_ack_ctx(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
 463                         free(idx_0);
 464                 }
 465         }
 466         ndr->depth--;
 467         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 468         ndr->depth--;
 469 }
 470
 471 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)
 472 {
 473         uint32_t cntr_versions_0;
 474         if (ndr_flags & NDR_SCALARS) {
 475                 NDR_CHECK(ndr_push_align(ndr, 4));
 476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_versions));
 477                 for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
 478                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->versions[cntr_versions_0]));
 479                 }
 480                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 481         }
 482         if (ndr_flags & NDR_BUFFERS) {
 483         }
 484         return NDR_ERR_SUCCESS;
 485 }
 486
 487 static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak_versions *r)
 488 {
 489         uint32_t cntr_versions_0;
 490         TALLOC_CTX *_mem_save_versions_0;
 491         if (ndr_flags & NDR_SCALARS) {
 492                 NDR_CHECK(ndr_pull_align(ndr, 4));
 493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_versions));
 494                 NDR_PULL_ALLOC_N(ndr, r->versions, r->num_versions);
 495                 _mem_save_versions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 496                 NDR_PULL_SET_MEM_CTX(ndr, r->versions, 0);
 497                 for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
 498                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
 499                 }
 500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_versions_0, 0);
 501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 502         }
 503         if (ndr_flags & NDR_BUFFERS) {
 504         }
 505         return NDR_ERR_SUCCESS;
 506 }
 507
 508 _PUBLIC_ void ndr_print_dcerpc_bind_nak_versions(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_versions *r)
 509 {
 510         uint32_t cntr_versions_0;
 511         ndr_print_struct(ndr, name, "dcerpc_bind_nak_versions");
 512         ndr->depth++;
 513         ndr_print_uint32(ndr, "num_versions", r->num_versions);
 514         ndr->print(ndr, "%s: ARRAY(%d)", "versions", (int)r->num_versions);
 515         ndr->depth++;
 516         for (cntr_versions_0=0;cntr_versions_0<r->num_versions;cntr_versions_0++) {
 517                 char *idx_0=NULL;
 518                 if (asprintf(&idx_0, "[%d]", cntr_versions_0) != -1) {
 519                         ndr_print_uint32(ndr, "versions", r->versions[cntr_versions_0]);
 520                         free(idx_0);
 521                 }
 522         }
 523         ndr->depth--;
 524         ndr->depth--;
 525 }
 526
 527 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)
 528 {
 529         if (ndr_flags & NDR_SCALARS) {
 530                 int level = ndr_push_get_switch_value(ndr, r);
 531                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 532                 switch (level) {
 533                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
 534                                 NDR_CHECK(ndr_push_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
 535                         break; }
 536
 537                         default: {
 538                         break; }
 539
 540                 }
 541         }
 542         if (ndr_flags & NDR_BUFFERS) {
 543                 int level = ndr_push_get_switch_value(ndr, r);
 544                 switch (level) {
 545                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 546                         break;
 547
 548                         default:
 549                         break;
 550
 551                 }
 552         }
 553         return NDR_ERR_SUCCESS;
 554 }
 555
 556 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)
 557 {
 558         int level;
 559         level = ndr_pull_get_switch_value(ndr, r);
 560         if (ndr_flags & NDR_SCALARS) {
 561                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 562                 switch (level) {
 563                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
 564                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
 565                         break; }
 566
 567                         default: {
 568                         break; }
 569
 570                 }
 571         }
 572         if (ndr_flags & NDR_BUFFERS) {
 573                 switch (level) {
 574                         case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 575                         break;
 576
 577                         default:
 578                         break;
 579
 580                 }
 581         }
 582         return NDR_ERR_SUCCESS;
 583 }
 584
 585 _PUBLIC_ void ndr_print_dcerpc_bind_nak_versions_ctr(struct ndr_print *ndr, const char *name, const union dcerpc_bind_nak_versions_ctr *r)
 586 {
 587         int level;
 588         level = ndr_print_get_switch_value(ndr, r);
 589         ndr_print_union(ndr, name, level, "dcerpc_bind_nak_versions_ctr");
 590         switch (level) {
 591                 case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 592                         ndr_print_dcerpc_bind_nak_versions(ndr, "v", &r->v);
 593                 break;
 594
 595                 default:
 596                 break;
 597
 598         }
 599 }
 600
 601 static enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_nak *r)
 602 {
 603         if (ndr_flags & NDR_SCALARS) {
 604                 NDR_CHECK(ndr_push_align(ndr, 4));
 605                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reject_reason));
 606                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->versions, r->reject_reason));
 607                 NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
 608                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 609         }
 610         if (ndr_flags & NDR_BUFFERS) {
 611                 NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
 612         }
 613         return NDR_ERR_SUCCESS;
 614 }
 615
 616 static enum ndr_err_code ndr_pull_dcerpc_bind_nak(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak *r)
 617 {
 618         if (ndr_flags & NDR_SCALARS) {
 619                 NDR_CHECK(ndr_pull_align(ndr, 4));
 620                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reject_reason));
 621                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->versions, r->reject_reason));
 622                 NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
 623                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 624         }
 625         if (ndr_flags & NDR_BUFFERS) {
 626                 NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
 627         }
 628         return NDR_ERR_SUCCESS;
 629 }
 630
 631 _PUBLIC_ void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r)
 632 {
 633         ndr_print_struct(ndr, name, "dcerpc_bind_nak");
 634         ndr->depth++;
 635         ndr_print_uint16(ndr, "reject_reason", r->reject_reason);
 636         ndr_print_set_switch_value(ndr, &r->versions, r->reject_reason);
 637         ndr_print_dcerpc_bind_nak_versions_ctr(ndr, "versions", &r->versions);
 638         ndr->depth--;
 639 }
 640
 641 static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_response *r)
 642 {
 643         if (ndr_flags & NDR_SCALARS) {
 644                 NDR_CHECK(ndr_push_align(ndr, 4));
 645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 646                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 647                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
 648                 {
 649                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 651                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 652                         ndr->flags = _flags_save_DATA_BLOB;
 653                 }
 654                 {
 655                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 657                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
 658                         ndr->flags = _flags_save_DATA_BLOB;
 659                 }
 660                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 661         }
 662         if (ndr_flags & NDR_BUFFERS) {
 663         }
 664         return NDR_ERR_SUCCESS;
 665 }
 666
 667 static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_response *r)
 668 {
 669         if (ndr_flags & NDR_SCALARS) {
 670                 NDR_CHECK(ndr_pull_align(ndr, 4));
 671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 672                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 673                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
 674                 {
 675                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 677                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 678                         ndr->flags = _flags_save_DATA_BLOB;
 679                 }
 680                 {
 681                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 683                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
 684                         ndr->flags = _flags_save_DATA_BLOB;
 685                 }
 686                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 687         }
 688         if (ndr_flags & NDR_BUFFERS) {
 689         }
 690         return NDR_ERR_SUCCESS;
 691 }
 692
 693 _PUBLIC_ void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r)
 694 {
 695         ndr_print_struct(ndr, name, "dcerpc_response");
 696         ndr->depth++;
 697         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 698         ndr_print_uint16(ndr, "context_id", r->context_id);
 699         ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
 700         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 701         ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
 702         ndr->depth--;
 703 }
 704
 705 static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fault *r)
 706 {
 707         if (ndr_flags & NDR_SCALARS) {
 708                 NDR_CHECK(ndr_push_align(ndr, 4));
 709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 710                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 711                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
 712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 713                 {
 714                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 716                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 717                         ndr->flags = _flags_save_DATA_BLOB;
 718                 }
 719                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 720         }
 721         if (ndr_flags & NDR_BUFFERS) {
 722         }
 723         return NDR_ERR_SUCCESS;
 724 }
 725
 726 static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fault *r)
 727 {
 728         if (ndr_flags & NDR_SCALARS) {
 729                 NDR_CHECK(ndr_pull_align(ndr, 4));
 730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 731                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 732                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
 733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 734                 {
 735                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 737                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 738                         ndr->flags = _flags_save_DATA_BLOB;
 739                 }
 740                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 741         }
 742         if (ndr_flags & NDR_BUFFERS) {
 743         }
 744         return NDR_ERR_SUCCESS;
 745 }
 746
 747 _PUBLIC_ void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r)
 748 {
 749         ndr_print_struct(ndr, name, "dcerpc_fault");
 750         ndr->depth++;
 751         ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 752         ndr_print_uint16(ndr, "context_id", r->context_id);
 753         ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
 754         ndr_print_uint32(ndr, "status", r->status);
 755         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 756         ndr->depth--;
 757 }
 758
 759 static enum ndr_err_code ndr_push_dcerpc_AuthType(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthType r)
 760 {
 761         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 762         return NDR_ERR_SUCCESS;
 763 }
 764
 765 static enum ndr_err_code ndr_pull_dcerpc_AuthType(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthType *r)
 766 {
 767         uint8_t v;
 768         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 769         *r = v;
 770         return NDR_ERR_SUCCESS;
 771 }
 772
 773 _PUBLIC_ void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r)
 774 {
 775         const char *val = NULL;
 776
 777         switch (r) {
 778                 case DCERPC_AUTH_TYPE_NONE: val = "DCERPC_AUTH_TYPE_NONE"; break;
 779                 case DCERPC_AUTH_TYPE_KRB5_1: val = "DCERPC_AUTH_TYPE_KRB5_1"; break;
 780                 case DCERPC_AUTH_TYPE_SPNEGO: val = "DCERPC_AUTH_TYPE_SPNEGO"; break;
 781                 case DCERPC_AUTH_TYPE_NTLMSSP: val = "DCERPC_AUTH_TYPE_NTLMSSP"; break;
 782                 case DCERPC_AUTH_TYPE_KRB5: val = "DCERPC_AUTH_TYPE_KRB5"; break;
 783                 case DCERPC_AUTH_TYPE_DPA: val = "DCERPC_AUTH_TYPE_DPA"; break;
 784                 case DCERPC_AUTH_TYPE_MSN: val = "DCERPC_AUTH_TYPE_MSN"; break;
 785                 case DCERPC_AUTH_TYPE_DIGEST: val = "DCERPC_AUTH_TYPE_DIGEST"; break;
 786                 case DCERPC_AUTH_TYPE_SCHANNEL: val = "DCERPC_AUTH_TYPE_SCHANNEL"; break;
 787                 case DCERPC_AUTH_TYPE_MSMQ: val = "DCERPC_AUTH_TYPE_MSMQ"; break;
 788         }
 789         ndr_print_enum(ndr, name, "ENUM", val, r);
 790 }
 791
 792 static enum ndr_err_code ndr_push_dcerpc_AuthLevel(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthLevel r)
 793 {
 794         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 static enum ndr_err_code ndr_pull_dcerpc_AuthLevel(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthLevel *r)
 799 {
 800         uint8_t v;
 801         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 802         *r = v;
 803         return NDR_ERR_SUCCESS;
 804 }
 805
 806 _PUBLIC_ void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r)
 807 {
 808         const char *val = NULL;
 809
 810         switch (r) {
 811                 case DCERPC_AUTH_LEVEL_NONE: val = "DCERPC_AUTH_LEVEL_NONE"; break;
 812                 case DCERPC_AUTH_LEVEL_CONNECT: val = "DCERPC_AUTH_LEVEL_CONNECT"; break;
 813                 case DCERPC_AUTH_LEVEL_CALL: val = "DCERPC_AUTH_LEVEL_CALL"; break;
 814                 case DCERPC_AUTH_LEVEL_PACKET: val = "DCERPC_AUTH_LEVEL_PACKET"; break;
 815                 case DCERPC_AUTH_LEVEL_INTEGRITY: val = "DCERPC_AUTH_LEVEL_INTEGRITY"; break;
 816                 case DCERPC_AUTH_LEVEL_PRIVACY: val = "DCERPC_AUTH_LEVEL_PRIVACY"; break;
 817         }
 818         ndr_print_enum(ndr, name, "ENUM", val, r);
 819 }
 820
 821 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth *r)
 822 {
 823         if (ndr_flags & NDR_SCALARS) {
 824                 NDR_CHECK(ndr_push_align(ndr, 4));
 825                 NDR_CHECK(ndr_push_dcerpc_AuthType(ndr, NDR_SCALARS, r->auth_type));
 826                 NDR_CHECK(ndr_push_dcerpc_AuthLevel(ndr, NDR_SCALARS, r->auth_level));
 827                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_pad_length));
 828                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_reserved));
 829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auth_context_id));
 830                 {
 831                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 833                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
 834                         ndr->flags = _flags_save_DATA_BLOB;
 835                 }
 836                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 837         }
 838         if (ndr_flags & NDR_BUFFERS) {
 839         }
 840         return NDR_ERR_SUCCESS;
 841 }
 842
 843 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth *r)
 844 {
 845         if (ndr_flags & NDR_SCALARS) {
 846                 NDR_CHECK(ndr_pull_align(ndr, 4));
 847                 NDR_CHECK(ndr_pull_dcerpc_AuthType(ndr, NDR_SCALARS, &r->auth_type));
 848                 NDR_CHECK(ndr_pull_dcerpc_AuthLevel(ndr, NDR_SCALARS, &r->auth_level));
 849                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_pad_length));
 850                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_reserved));
 851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auth_context_id));
 852                 {
 853                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 855                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
 856                         ndr->flags = _flags_save_DATA_BLOB;
 857                 }
 858                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 859         }
 860         if (ndr_flags & NDR_BUFFERS) {
 861         }
 862         return NDR_ERR_SUCCESS;
 863 }
 864
 865 _PUBLIC_ void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r)
 866 {
 867         ndr_print_struct(ndr, name, "dcerpc_auth");
 868         ndr->depth++;
 869         ndr_print_dcerpc_AuthType(ndr, "auth_type", r->auth_type);
 870         ndr_print_dcerpc_AuthLevel(ndr, "auth_level", r->auth_level);
 871         ndr_print_uint8(ndr, "auth_pad_length", r->auth_pad_length);
 872         ndr_print_uint8(ndr, "auth_reserved", r->auth_reserved);
 873         ndr_print_uint32(ndr, "auth_context_id", r->auth_context_id);
 874         ndr_print_DATA_BLOB(ndr, "credentials", r->credentials);
 875         ndr->depth--;
 876 }
 877
 878 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth3 *r)
 879 {
 880         if (ndr_flags & NDR_SCALARS) {
 881                 NDR_CHECK(ndr_push_align(ndr, 4));
 882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_pad));
 883                 {
 884                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 886                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 887                         ndr->flags = _flags_save_DATA_BLOB;
 888                 }
 889                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 890         }
 891         if (ndr_flags & NDR_BUFFERS) {
 892         }
 893         return NDR_ERR_SUCCESS;
 894 }
 895
 896 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth3 *r)
 897 {
 898         if (ndr_flags & NDR_SCALARS) {
 899                 NDR_CHECK(ndr_pull_align(ndr, 4));
 900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 901                 {
 902                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 904                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 905                         ndr->flags = _flags_save_DATA_BLOB;
 906                 }
 907                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 908         }
 909         if (ndr_flags & NDR_BUFFERS) {
 910         }
 911         return NDR_ERR_SUCCESS;
 912 }
 913
 914 _PUBLIC_ void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r)
 915 {
 916         ndr_print_struct(ndr, name, "dcerpc_auth3");
 917         ndr->depth++;
 918         ndr_print_uint32(ndr, "_pad", r->_pad);
 919         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 920         ndr->depth--;
 921 }
 922
 923 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_orphaned *r)
 924 {
 925         if (ndr_flags & NDR_SCALARS) {
 926                 NDR_CHECK(ndr_push_align(ndr, 4));
 927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_pad));
 928                 {
 929                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 931                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 932                         ndr->flags = _flags_save_DATA_BLOB;
 933                 }
 934                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 935         }
 936         if (ndr_flags & NDR_BUFFERS) {
 937         }
 938         return NDR_ERR_SUCCESS;
 939 }
 940
 941 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_orphaned *r)
 942 {
 943         if (ndr_flags & NDR_SCALARS) {
 944                 NDR_CHECK(ndr_pull_align(ndr, 4));
 945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 946                 {
 947                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 949                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 950                         ndr->flags = _flags_save_DATA_BLOB;
 951                 }
 952                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 953         }
 954         if (ndr_flags & NDR_BUFFERS) {
 955         }
 956         return NDR_ERR_SUCCESS;
 957 }
 958
 959 _PUBLIC_ void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r)
 960 {
 961         ndr_print_struct(ndr, name, "dcerpc_orphaned");
 962         ndr->depth++;
 963         ndr_print_uint32(ndr, "_pad", r->_pad);
 964         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 965         ndr->depth--;
 966 }
 967
 968 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_co_cancel *r)
 969 {
 970         if (ndr_flags & NDR_SCALARS) {
 971                 NDR_CHECK(ndr_push_align(ndr, 4));
 972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_pad));
 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_co_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_co_cancel *r)
 987 {
 988         if (ndr_flags & NDR_SCALARS) {
 989                 NDR_CHECK(ndr_pull_align(ndr, 4));
 990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 991                 {
 992                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 994                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 995                         ndr->flags = _flags_save_DATA_BLOB;
 996                 }
 997                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 998         }
 999         if (ndr_flags & NDR_BUFFERS) {
1000         }
1001         return NDR_ERR_SUCCESS;
1002 }
1003
1004 _PUBLIC_ void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r)
1005 {
1006         ndr_print_struct(ndr, name, "dcerpc_co_cancel");
1007         ndr->depth++;
1008         ndr_print_uint32(ndr, "_pad", r->_pad);
1009         ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1010         ndr->depth--;
1011 }
1012
1013 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cl_cancel *r)
1014 {
1015         if (ndr_flags & NDR_SCALARS) {
1016                 NDR_CHECK(ndr_push_align(ndr, 4));
1017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1019                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1020         }
1021         if (ndr_flags & NDR_BUFFERS) {
1022         }
1023         return NDR_ERR_SUCCESS;
1024 }
1025
1026 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cl_cancel *r)
1027 {
1028         if (ndr_flags & NDR_SCALARS) {
1029                 NDR_CHECK(ndr_pull_align(ndr, 4));
1030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1032                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1033         }
1034         if (ndr_flags & NDR_BUFFERS) {
1035         }
1036         return NDR_ERR_SUCCESS;
1037 }
1038
1039 _PUBLIC_ void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r)
1040 {
1041         ndr_print_struct(ndr, name, "dcerpc_cl_cancel");
1042         ndr->depth++;
1043         ndr_print_uint32(ndr, "version", r->version);
1044         ndr_print_uint32(ndr, "id", r->id);
1045         ndr->depth--;
1046 }
1047
1048 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cancel_ack *r)
1049 {
1050         if (ndr_flags & NDR_SCALARS) {
1051                 NDR_CHECK(ndr_push_align(ndr, 4));
1052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
1055                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1056         }
1057         if (ndr_flags & NDR_BUFFERS) {
1058         }
1059         return NDR_ERR_SUCCESS;
1060 }
1061
1062 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cancel_ack *r)
1063 {
1064         if (ndr_flags & NDR_SCALARS) {
1065                 NDR_CHECK(ndr_pull_align(ndr, 4));
1066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
1069                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1070         }
1071         if (ndr_flags & NDR_BUFFERS) {
1072         }
1073         return NDR_ERR_SUCCESS;
1074 }
1075
1076 _PUBLIC_ void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r)
1077 {
1078         ndr_print_struct(ndr, name, "dcerpc_cancel_ack");
1079         ndr->depth++;
1080         ndr_print_uint32(ndr, "version", r->version);
1081         ndr_print_uint32(ndr, "id", r->id);
1082         ndr_print_uint32(ndr, "server_is_accepting", r->server_is_accepting);
1083         ndr->depth--;
1084 }
1085
1086 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fack *r)
1087 {
1088         uint32_t cntr_selack_0;
1089         if (ndr_flags & NDR_SCALARS) {
1090                 NDR_CHECK(ndr_push_align(ndr, 4));
1091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1092                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->_pad1));
1093                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->window_size));
1094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_tdsu));
1095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_frag_size));
1096                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->serial_no));
1097                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->selack_size));
1098                 for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
1099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
1100                 }
1101                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1102         }
1103         if (ndr_flags & NDR_BUFFERS) {
1104         }
1105         return NDR_ERR_SUCCESS;
1106 }
1107
1108 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fack *r)
1109 {
1110         uint32_t cntr_selack_0;
1111         TALLOC_CTX *_mem_save_selack_0;
1112         if (ndr_flags & NDR_SCALARS) {
1113                 NDR_CHECK(ndr_pull_align(ndr, 4));
1114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1115                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->_pad1));
1116                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->window_size));
1117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_tdsu));
1118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_frag_size));
1119                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->serial_no));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->selack_size));
1121                 NDR_PULL_ALLOC_N(ndr, r->selack, r->selack_size);
1122                 _mem_save_selack_0 = NDR_PULL_GET_MEM_CTX(ndr);
1123                 NDR_PULL_SET_MEM_CTX(ndr, r->selack, 0);
1124                 for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
1125                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
1126                 }
1127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
1128                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1129         }
1130         if (ndr_flags & NDR_BUFFERS) {
1131         }
1132         return NDR_ERR_SUCCESS;
1133 }
1134
1135 _PUBLIC_ void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r)
1136 {
1137         uint32_t cntr_selack_0;
1138         ndr_print_struct(ndr, name, "dcerpc_fack");
1139         ndr->depth++;
1140         ndr_print_uint32(ndr, "version", r->version);
1141         ndr_print_uint8(ndr, "_pad1", r->_pad1);
1142         ndr_print_uint16(ndr, "window_size", r->window_size);
1143         ndr_print_uint32(ndr, "max_tdsu", r->max_tdsu);
1144         ndr_print_uint32(ndr, "max_frag_size", r->max_frag_size);
1145         ndr_print_uint16(ndr, "serial_no", r->serial_no);
1146         ndr_print_uint16(ndr, "selack_size", r->selack_size);
1147         ndr->print(ndr, "%s: ARRAY(%d)", "selack", (int)r->selack_size);
1148         ndr->depth++;
1149         for (cntr_selack_0=0;cntr_selack_0<r->selack_size;cntr_selack_0++) {
1150                 char *idx_0=NULL;
1151                 if (asprintf(&idx_0, "[%d]", cntr_selack_0) != -1) {
1152                         ndr_print_uint32(ndr, "selack", r->selack[cntr_selack_0]);
1153                         free(idx_0);
1154                 }
1155         }
1156         ndr->depth--;
1157         ndr->depth--;
1158 }
1159
1160 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack *r)
1161 {
1162         if (ndr_flags & NDR_SCALARS) {
1163                 NDR_CHECK(ndr_push_align(ndr, 1));
1164                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1165         }
1166         if (ndr_flags & NDR_BUFFERS) {
1167         }
1168         return NDR_ERR_SUCCESS;
1169 }
1170
1171 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack *r)
1172 {
1173         if (ndr_flags & NDR_SCALARS) {
1174                 NDR_CHECK(ndr_pull_align(ndr, 1));
1175                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1176         }
1177         if (ndr_flags & NDR_BUFFERS) {
1178         }
1179         return NDR_ERR_SUCCESS;
1180 }
1181
1182 _PUBLIC_ void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r)
1183 {
1184         ndr_print_struct(ndr, name, "dcerpc_ack");
1185         ndr->depth++;
1186         ndr->depth--;
1187 }
1188
1189 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ping *r)
1190 {
1191         if (ndr_flags & NDR_SCALARS) {
1192                 NDR_CHECK(ndr_push_align(ndr, 1));
1193                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1194         }
1195         if (ndr_flags & NDR_BUFFERS) {
1196         }
1197         return NDR_ERR_SUCCESS;
1198 }
1199
1200 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ping *r)
1201 {
1202         if (ndr_flags & NDR_SCALARS) {
1203                 NDR_CHECK(ndr_pull_align(ndr, 1));
1204                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1205         }
1206         if (ndr_flags & NDR_BUFFERS) {
1207         }
1208         return NDR_ERR_SUCCESS;
1209 }
1210
1211 _PUBLIC_ void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r)
1212 {
1213         ndr_print_struct(ndr, name, "dcerpc_ping");
1214         ndr->depth++;
1215         ndr->depth--;
1216 }
1217
1218 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_shutdown *r)
1219 {
1220         if (ndr_flags & NDR_SCALARS) {
1221                 NDR_CHECK(ndr_push_align(ndr, 1));
1222                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1223         }
1224         if (ndr_flags & NDR_BUFFERS) {
1225         }
1226         return NDR_ERR_SUCCESS;
1227 }
1228
1229 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_shutdown *r)
1230 {
1231         if (ndr_flags & NDR_SCALARS) {
1232                 NDR_CHECK(ndr_pull_align(ndr, 1));
1233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1234         }
1235         if (ndr_flags & NDR_BUFFERS) {
1236         }
1237         return NDR_ERR_SUCCESS;
1238 }
1239
1240 _PUBLIC_ void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r)
1241 {
1242         ndr_print_struct(ndr, name, "dcerpc_shutdown");
1243         ndr->depth++;
1244         ndr->depth--;
1245 }
1246
1247 _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_working *r)
1248 {
1249         if (ndr_flags & NDR_SCALARS) {
1250                 NDR_CHECK(ndr_push_align(ndr, 1));
1251                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1252         }
1253         if (ndr_flags & NDR_BUFFERS) {
1254         }
1255         return NDR_ERR_SUCCESS;
1256 }
1257
1258 _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_working *r)
1259 {
1260         if (ndr_flags & NDR_SCALARS) {
1261                 NDR_CHECK(ndr_pull_align(ndr, 1));
1262                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1263         }
1264         if (ndr_flags & NDR_BUFFERS) {
1265         }
1266         return NDR_ERR_SUCCESS;
1267 }
1268
1269 _PUBLIC_ void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r)
1270 {
1271         ndr_print_struct(ndr, name, "dcerpc_working");
1272         ndr->depth++;
1273         ndr->depth--;
1274 }
1275
1276 static enum ndr_err_code ndr_push_dcerpc_pkt_type(struct ndr_push *ndr, int ndr_flags, enum dcerpc_pkt_type r)
1277 {
1278         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
1279         return NDR_ERR_SUCCESS;
1280 }
1281
1282 static enum ndr_err_code ndr_pull_dcerpc_pkt_type(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_pkt_type *r)
1283 {
1284         uint8_t v;
1285         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
1286         *r = v;
1287         return NDR_ERR_SUCCESS;
1288 }
1289
1290 _PUBLIC_ void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r)
1291 {
1292         const char *val = NULL;
1293
1294         switch (r) {
1295                 case DCERPC_PKT_REQUEST: val = "DCERPC_PKT_REQUEST"; break;
1296                 case DCERPC_PKT_PING: val = "DCERPC_PKT_PING"; break;
1297                 case DCERPC_PKT_RESPONSE: val = "DCERPC_PKT_RESPONSE"; break;
1298                 case DCERPC_PKT_FAULT: val = "DCERPC_PKT_FAULT"; break;
1299                 case DCERPC_PKT_WORKING: val = "DCERPC_PKT_WORKING"; break;
1300                 case DCERPC_PKT_NOCALL: val = "DCERPC_PKT_NOCALL"; break;
1301                 case DCERPC_PKT_REJECT: val = "DCERPC_PKT_REJECT"; break;
1302                 case DCERPC_PKT_ACK: val = "DCERPC_PKT_ACK"; break;
1303                 case DCERPC_PKT_CL_CANCEL: val = "DCERPC_PKT_CL_CANCEL"; break;
1304                 case DCERPC_PKT_FACK: val = "DCERPC_PKT_FACK"; break;
1305                 case DCERPC_PKT_CANCEL_ACK: val = "DCERPC_PKT_CANCEL_ACK"; break;
1306                 case DCERPC_PKT_BIND: val = "DCERPC_PKT_BIND"; break;
1307                 case DCERPC_PKT_BIND_ACK: val = "DCERPC_PKT_BIND_ACK"; break;
1308                 case DCERPC_PKT_BIND_NAK: val = "DCERPC_PKT_BIND_NAK"; break;
1309                 case DCERPC_PKT_ALTER: val = "DCERPC_PKT_ALTER"; break;
1310                 case DCERPC_PKT_ALTER_RESP: val = "DCERPC_PKT_ALTER_RESP"; break;
1311                 case DCERPC_PKT_AUTH3: val = "DCERPC_PKT_AUTH3"; break;
1312                 case DCERPC_PKT_SHUTDOWN: val = "DCERPC_PKT_SHUTDOWN"; break;
1313                 case DCERPC_PKT_CO_CANCEL: val = "DCERPC_PKT_CO_CANCEL"; break;
1314                 case DCERPC_PKT_ORPHANED: val = "DCERPC_PKT_ORPHANED"; break;
1315         }
1316         ndr_print_enum(ndr, name, "ENUM", val, r);
1317 }
1318
1319 static enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, int ndr_flags, const union dcerpc_payload *r)
1320 {
1321         if (ndr_flags & NDR_SCALARS) {
1322                 int level = ndr_push_get_switch_value(ndr, r);
1323                 NDR_CHECK(ndr_push_union_align(ndr, 4));
1324                 switch (level) {
1325                         case DCERPC_PKT_REQUEST: {
1326                                 NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
1327                         break; }
1328
1329                         case DCERPC_PKT_PING: {
1330                                 NDR_CHECK(ndr_push_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
1331                         break; }
1332
1333                         case DCERPC_PKT_RESPONSE: {
1334                                 NDR_CHECK(ndr_push_dcerpc_response(ndr, NDR_SCALARS, &r->response));
1335                         break; }
1336
1337                         case DCERPC_PKT_FAULT: {
1338                                 NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
1339                         break; }
1340
1341                         case DCERPC_PKT_WORKING: {
1342                                 NDR_CHECK(ndr_push_dcerpc_working(ndr, NDR_SCALARS, &r->working));
1343                         break; }
1344
1345                         case DCERPC_PKT_NOCALL: {
1346                                 NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
1347                         break; }
1348
1349                         case DCERPC_PKT_REJECT: {
1350                                 NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
1351                         break; }
1352
1353                         case DCERPC_PKT_ACK: {
1354                                 NDR_CHECK(ndr_push_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
1355                         break; }
1356
1357                         case DCERPC_PKT_CL_CANCEL: {
1358                                 NDR_CHECK(ndr_push_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
1359                         break; }
1360
1361                         case DCERPC_PKT_FACK: {
1362                                 NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
1363                         break; }
1364
1365                         case DCERPC_PKT_CANCEL_ACK: {
1366                                 NDR_CHECK(ndr_push_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
1367                         break; }
1368
1369                         case DCERPC_PKT_BIND: {
1370                                 NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
1371                         break; }
1372
1373                         case DCERPC_PKT_BIND_ACK: {
1374                                 NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
1375                         break; }
1376
1377                         case DCERPC_PKT_BIND_NAK: {
1378                                 NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
1379                         break; }
1380
1381                         case DCERPC_PKT_ALTER: {
1382                                 NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
1383                         break; }
1384
1385                         case DCERPC_PKT_ALTER_RESP: {
1386                                 NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
1387                         break; }
1388
1389                         case DCERPC_PKT_SHUTDOWN: {
1390                                 NDR_CHECK(ndr_push_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
1391                         break; }
1392
1393                         case DCERPC_PKT_CO_CANCEL: {
1394                                 NDR_CHECK(ndr_push_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
1395                         break; }
1396
1397                         case DCERPC_PKT_ORPHANED: {
1398                                 NDR_CHECK(ndr_push_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
1399                         break; }
1400
1401                         case DCERPC_PKT_AUTH3: {
1402                                 NDR_CHECK(ndr_push_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
1403                         break; }
1404
1405                         default:
1406                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1407                 }
1408         }
1409         if (ndr_flags & NDR_BUFFERS) {
1410                 int level = ndr_push_get_switch_value(ndr, r);
1411                 switch (level) {
1412                         case DCERPC_PKT_REQUEST:
1413                         break;
1414
1415                         case DCERPC_PKT_PING:
1416                         break;
1417
1418                         case DCERPC_PKT_RESPONSE:
1419                         break;
1420
1421                         case DCERPC_PKT_FAULT:
1422                         break;
1423
1424                         case DCERPC_PKT_WORKING:
1425                         break;
1426
1427                         case DCERPC_PKT_NOCALL:
1428                         break;
1429
1430                         case DCERPC_PKT_REJECT:
1431                         break;
1432
1433                         case DCERPC_PKT_ACK:
1434                         break;
1435
1436                         case DCERPC_PKT_CL_CANCEL:
1437                         break;
1438
1439                         case DCERPC_PKT_FACK:
1440                         break;
1441
1442                         case DCERPC_PKT_CANCEL_ACK:
1443                         break;
1444
1445                         case DCERPC_PKT_BIND:
1446                         break;
1447
1448                         case DCERPC_PKT_BIND_ACK:
1449                         break;
1450
1451                         case DCERPC_PKT_BIND_NAK:
1452                                 NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
1453                         break;
1454
1455                         case DCERPC_PKT_ALTER:
1456                         break;
1457
1458                         case DCERPC_PKT_ALTER_RESP:
1459                         break;
1460
1461                         case DCERPC_PKT_SHUTDOWN:
1462                         break;
1463
1464                         case DCERPC_PKT_CO_CANCEL:
1465                         break;
1466
1467                         case DCERPC_PKT_ORPHANED:
1468                         break;
1469
1470                         case DCERPC_PKT_AUTH3:
1471                         break;
1472
1473                         default:
1474                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1475                 }
1476         }
1477         return NDR_ERR_SUCCESS;
1478 }
1479
1480 static enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, int ndr_flags, union dcerpc_payload *r)
1481 {
1482         int level;
1483         level = ndr_pull_get_switch_value(ndr, r);
1484         if (ndr_flags & NDR_SCALARS) {
1485                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
1486                 switch (level) {
1487                         case DCERPC_PKT_REQUEST: {
1488                                 NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
1489                         break; }
1490
1491                         case DCERPC_PKT_PING: {
1492                                 NDR_CHECK(ndr_pull_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
1493                         break; }
1494
1495                         case DCERPC_PKT_RESPONSE: {
1496                                 NDR_CHECK(ndr_pull_dcerpc_response(ndr, NDR_SCALARS, &r->response));
1497                         break; }
1498
1499                         case DCERPC_PKT_FAULT: {
1500                                 NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
1501                         break; }
1502
1503                         case DCERPC_PKT_WORKING: {
1504                                 NDR_CHECK(ndr_pull_dcerpc_working(ndr, NDR_SCALARS, &r->working));
1505                         break; }
1506
1507                         case DCERPC_PKT_NOCALL: {
1508                                 NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
1509                         break; }
1510
1511                         case DCERPC_PKT_REJECT: {
1512                                 NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
1513                         break; }
1514
1515                         case DCERPC_PKT_ACK: {
1516                                 NDR_CHECK(ndr_pull_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
1517                         break; }
1518
1519                         case DCERPC_PKT_CL_CANCEL: {
1520                                 NDR_CHECK(ndr_pull_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
1521                         break; }
1522
1523                         case DCERPC_PKT_FACK: {
1524                                 NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
1525                         break; }
1526
1527                         case DCERPC_PKT_CANCEL_ACK: {
1528                                 NDR_CHECK(ndr_pull_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
1529                         break; }
1530
1531                         case DCERPC_PKT_BIND: {
1532                                 NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
1533                         break; }
1534
1535                         case DCERPC_PKT_BIND_ACK: {
1536                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
1537                         break; }
1538
1539                         case DCERPC_PKT_BIND_NAK: {
1540                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
1541                         break; }
1542
1543                         case DCERPC_PKT_ALTER: {
1544                                 NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
1545                         break; }
1546
1547                         case DCERPC_PKT_ALTER_RESP: {
1548                                 NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
1549                         break; }
1550
1551                         case DCERPC_PKT_SHUTDOWN: {
1552                                 NDR_CHECK(ndr_pull_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
1553                         break; }
1554
1555                         case DCERPC_PKT_CO_CANCEL: {
1556                                 NDR_CHECK(ndr_pull_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
1557                         break; }
1558
1559                         case DCERPC_PKT_ORPHANED: {
1560                                 NDR_CHECK(ndr_pull_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
1561                         break; }
1562
1563                         case DCERPC_PKT_AUTH3: {
1564                                 NDR_CHECK(ndr_pull_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
1565                         break; }
1566
1567                         default:
1568                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1569                 }
1570         }
1571         if (ndr_flags & NDR_BUFFERS) {
1572                 switch (level) {
1573                         case DCERPC_PKT_REQUEST:
1574                         break;
1575
1576                         case DCERPC_PKT_PING:
1577                         break;
1578
1579                         case DCERPC_PKT_RESPONSE:
1580                         break;
1581
1582                         case DCERPC_PKT_FAULT:
1583                         break;
1584
1585                         case DCERPC_PKT_WORKING:
1586                         break;
1587
1588                         case DCERPC_PKT_NOCALL:
1589                         break;
1590
1591                         case DCERPC_PKT_REJECT:
1592                         break;
1593
1594                         case DCERPC_PKT_ACK:
1595                         break;
1596
1597                         case DCERPC_PKT_CL_CANCEL:
1598                         break;
1599
1600                         case DCERPC_PKT_FACK:
1601                         break;
1602
1603                         case DCERPC_PKT_CANCEL_ACK:
1604                         break;
1605
1606                         case DCERPC_PKT_BIND:
1607                         break;
1608
1609                         case DCERPC_PKT_BIND_ACK:
1610                         break;
1611
1612                         case DCERPC_PKT_BIND_NAK:
1613                                 NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
1614                         break;
1615
1616                         case DCERPC_PKT_ALTER:
1617                         break;
1618
1619                         case DCERPC_PKT_ALTER_RESP:
1620                         break;
1621
1622                         case DCERPC_PKT_SHUTDOWN:
1623                         break;
1624
1625                         case DCERPC_PKT_CO_CANCEL:
1626                         break;
1627
1628                         case DCERPC_PKT_ORPHANED:
1629                         break;
1630
1631                         case DCERPC_PKT_AUTH3:
1632                         break;
1633
1634                         default:
1635                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1636                 }
1637         }
1638         return NDR_ERR_SUCCESS;
1639 }
1640
1641 _PUBLIC_ void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r)
1642 {
1643         int level;
1644         level = ndr_print_get_switch_value(ndr, r);
1645         ndr_print_union(ndr, name, level, "dcerpc_payload");
1646         switch (level) {
1647                 case DCERPC_PKT_REQUEST:
1648                         ndr_print_dcerpc_request(ndr, "request", &r->request);
1649                 break;
1650
1651                 case DCERPC_PKT_PING:
1652                         ndr_print_dcerpc_ping(ndr, "ping", &r->ping);
1653                 break;
1654
1655                 case DCERPC_PKT_RESPONSE:
1656                         ndr_print_dcerpc_response(ndr, "response", &r->response);
1657                 break;
1658
1659                 case DCERPC_PKT_FAULT:
1660                         ndr_print_dcerpc_fault(ndr, "fault", &r->fault);
1661                 break;
1662
1663                 case DCERPC_PKT_WORKING:
1664                         ndr_print_dcerpc_working(ndr, "working", &r->working);
1665                 break;
1666
1667                 case DCERPC_PKT_NOCALL:
1668                         ndr_print_dcerpc_fack(ndr, "nocall", &r->nocall);
1669                 break;
1670
1671                 case DCERPC_PKT_REJECT:
1672                         ndr_print_dcerpc_fault(ndr, "reject", &r->reject);
1673                 break;
1674
1675                 case DCERPC_PKT_ACK:
1676                         ndr_print_dcerpc_ack(ndr, "ack", &r->ack);
1677                 break;
1678
1679                 case DCERPC_PKT_CL_CANCEL:
1680                         ndr_print_dcerpc_cl_cancel(ndr, "cl_cancel", &r->cl_cancel);
1681                 break;
1682
1683                 case DCERPC_PKT_FACK:
1684                         ndr_print_dcerpc_fack(ndr, "fack", &r->fack);
1685                 break;
1686
1687                 case DCERPC_PKT_CANCEL_ACK:
1688                         ndr_print_dcerpc_cancel_ack(ndr, "cancel_ack", &r->cancel_ack);
1689                 break;
1690
1691                 case DCERPC_PKT_BIND:
1692                         ndr_print_dcerpc_bind(ndr, "bind", &r->bind);
1693                 break;
1694
1695                 case DCERPC_PKT_BIND_ACK:
1696                         ndr_print_dcerpc_bind_ack(ndr, "bind_ack", &r->bind_ack);
1697                 break;
1698
1699                 case DCERPC_PKT_BIND_NAK:
1700                         ndr_print_dcerpc_bind_nak(ndr, "bind_nak", &r->bind_nak);
1701                 break;
1702
1703                 case DCERPC_PKT_ALTER:
1704                         ndr_print_dcerpc_bind(ndr, "alter", &r->alter);
1705                 break;
1706
1707                 case DCERPC_PKT_ALTER_RESP:
1708                         ndr_print_dcerpc_bind_ack(ndr, "alter_resp", &r->alter_resp);
1709                 break;
1710
1711                 case DCERPC_PKT_SHUTDOWN:
1712                         ndr_print_dcerpc_shutdown(ndr, "shutdown", &r->shutdown);
1713                 break;
1714
1715                 case DCERPC_PKT_CO_CANCEL:
1716                         ndr_print_dcerpc_co_cancel(ndr, "co_cancel", &r->co_cancel);
1717                 break;
1718
1719                 case DCERPC_PKT_ORPHANED:
1720                         ndr_print_dcerpc_orphaned(ndr, "orphaned", &r->orphaned);
1721                 break;
1722
1723                 case DCERPC_PKT_AUTH3:
1724                         ndr_print_dcerpc_auth3(ndr, "auth3", &r->auth3);
1725                 break;
1726
1727                 default:
1728                         ndr_print_bad_level(ndr, name, level);
1729         }
1730 }
1731
1732 _PUBLIC_ enum ndr_err_code ndr_push_ncacn_packet(struct ndr_push *ndr, int ndr_flags, const struct ncacn_packet *r)
1733 {
1734         if (ndr_flags & NDR_SCALARS) {
1735                 NDR_CHECK(ndr_push_align(ndr, 4));
1736                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
1737                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers_minor));
1738                 NDR_CHECK(ndr_push_dcerpc_pkt_type(ndr, NDR_SCALARS, r->ptype));
1739                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
1740                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
1741                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->frag_length));
1742                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->auth_length));
1743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
1744                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
1745                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1746                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1747         }
1748         if (ndr_flags & NDR_BUFFERS) {
1749                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1750         }
1751         return NDR_ERR_SUCCESS;
1752 }
1753
1754 _PUBLIC_ enum ndr_err_code ndr_pull_ncacn_packet(struct ndr_pull *ndr, int ndr_flags, struct ncacn_packet *r)
1755 {
1756         if (ndr_flags & NDR_SCALARS) {
1757                 NDR_CHECK(ndr_pull_align(ndr, 4));
1758                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
1759                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers_minor));
1760                 NDR_CHECK(ndr_pull_dcerpc_pkt_type(ndr, NDR_SCALARS, &r->ptype));
1761                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
1762                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
1763                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->frag_length));
1764                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->auth_length));
1765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
1766                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
1767                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1769         }
1770         if (ndr_flags & NDR_BUFFERS) {
1771                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1772         }
1773         return NDR_ERR_SUCCESS;
1774 }
1775
1776 _PUBLIC_ void ndr_print_ncacn_packet(struct ndr_print *ndr, const char *name, const struct ncacn_packet *r)
1777 {
1778         ndr_print_struct(ndr, name, "ncacn_packet");
1779         ndr->depth++;
1780         ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
1781         ndr_print_uint8(ndr, "rpc_vers_minor", r->rpc_vers_minor);
1782         ndr_print_dcerpc_pkt_type(ndr, "ptype", r->ptype);
1783         ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
1784         ndr_print_array_uint8(ndr, "drep", r->drep, 4);
1785         ndr_print_uint16(ndr, "frag_length", r->frag_length);
1786         ndr_print_uint16(ndr, "auth_length", r->auth_length);
1787         ndr_print_uint32(ndr, "call_id", r->call_id);
1788         ndr_print_set_switch_value(ndr, &r->u, r->ptype);
1789         ndr_print_dcerpc_payload(ndr, "u", &r->u);
1790         ndr->depth--;
1791 }
1792
1793 _PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, int ndr_flags, const struct ncadg_packet *r)
1794 {
1795         if (ndr_flags & NDR_SCALARS) {
1796                 NDR_CHECK(ndr_push_align(ndr, 4));
1797                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
1798                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ptype));
1799                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
1800                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ncadg_flags));
1801                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
1802                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_high));
1803                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
1804                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iface));
1805                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->activity));
1806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_boot));
1807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iface_version));
1808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->seq_num));
1809                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
1810                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ihint));
1811                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ahint));
1812                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->len));
1813                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->fragnum));
1814                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_proto));
1815                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
1816                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
1817                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1818                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1819         }
1820         if (ndr_flags & NDR_BUFFERS) {
1821                 NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1822         }
1823         return NDR_ERR_SUCCESS;
1824 }
1825
1826 _PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, int ndr_flags, struct ncadg_packet *r)
1827 {
1828         if (ndr_flags & NDR_SCALARS) {
1829                 NDR_CHECK(ndr_pull_align(ndr, 4));
1830                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
1831                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ptype));
1832                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
1833                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ncadg_flags));
1834                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
1835                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_high));
1836                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
1837                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iface));
1838                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->activity));
1839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_boot));
1840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iface_version));
1841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->seq_num));
1842                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
1843                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ihint));
1844                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ahint));
1845                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->len));
1846                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->fragnum));
1847                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_proto));
1848                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
1849                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
1850                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1852         }
1853         if (ndr_flags & NDR_BUFFERS) {
1854                 NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1855         }
1856         return NDR_ERR_SUCCESS;
1857 }
1858
1859 _PUBLIC_ void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r)
1860 {
1861         ndr_print_struct(ndr, name, "ncadg_packet");
1862         ndr->depth++;
1863         ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
1864         ndr_print_uint8(ndr, "ptype", r->ptype);
1865         ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
1866         ndr_print_uint8(ndr, "ncadg_flags", r->ncadg_flags);
1867         ndr_print_array_uint8(ndr, "drep", r->drep, 3);
1868         ndr_print_uint8(ndr, "serial_high", r->serial_high);
1869         ndr_print_GUID(ndr, "object", &r->object);
1870         ndr_print_GUID(ndr, "iface", &r->iface);
1871         ndr_print_GUID(ndr, "activity", &r->activity);
1872         ndr_print_uint32(ndr, "server_boot", r->server_boot);
1873         ndr_print_uint32(ndr, "iface_version", r->iface_version);
1874         ndr_print_uint32(ndr, "seq_num", r->seq_num);
1875         ndr_print_uint16(ndr, "opnum", r->opnum);
1876         ndr_print_uint16(ndr, "ihint", r->ihint);
1877         ndr_print_uint16(ndr, "ahint", r->ahint);
1878         ndr_print_uint16(ndr, "len", r->len);
1879         ndr_print_uint16(ndr, "fragnum", r->fragnum);
1880         ndr_print_uint8(ndr, "auth_proto", r->auth_proto);
1881         ndr_print_uint8(ndr, "serial_low", r->serial_low);
1882         ndr_print_set_switch_value(ndr, &r->u, r->ptype);
1883         ndr_print_dcerpc_payload(ndr, "u", &r->u);
1884         ndr->depth--;
1885 }
1886