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