librpc/gen_ndr/ndr_drsblobs.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_drsblobs.h"
   5
   6 #include "librpc/gen_ndr/ndr_drsuapi.h"
   7 #include "librpc/gen_ndr/ndr_misc.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/gen_ndr/ndr_lsa.h"
  10 static enum ndr_err_code ndr_push_replPropertyMetaData1(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaData1 *r)
  11 {
  12         if (ndr_flags & NDR_SCALARS) {
  13                 NDR_CHECK(ndr_push_align(ndr, 8));
  14                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
  16                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
  17                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
  18                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
  19                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
  20                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_replPropertyMetaData1(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaData1 *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 8));
  31                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
  32                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
  33                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
  34                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
  35                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
  36                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
  37                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
  38         }
  39         if (ndr_flags & NDR_BUFFERS) {
  40         }
  41         return NDR_ERR_SUCCESS;
  42 }
  43
  44 _PUBLIC_ void ndr_print_replPropertyMetaData1(struct ndr_print *ndr, const char *name, const struct replPropertyMetaData1 *r)
  45 {
  46         ndr_print_struct(ndr, name, "replPropertyMetaData1");
  47         ndr->depth++;
  48         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
  49         ndr_print_uint32(ndr, "version", r->version);
  50         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
  51         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
  52         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
  53         ndr_print_hyper(ndr, "local_usn", r->local_usn);
  54         ndr->depth--;
  55 }
  56
  57 static enum ndr_err_code ndr_push_replPropertyMetaDataCtr1(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaDataCtr1 *r)
  58 {
  59         uint32_t cntr_array_0;
  60         if (ndr_flags & NDR_SCALARS) {
  61                 NDR_CHECK(ndr_push_align(ndr, 8));
  62                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
  63                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  64                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
  65                         NDR_CHECK(ndr_push_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
  66                 }
  67                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
  68         }
  69         if (ndr_flags & NDR_BUFFERS) {
  70         }
  71         return NDR_ERR_SUCCESS;
  72 }
  73
  74 static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr1(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaDataCtr1 *r)
  75 {
  76         uint32_t cntr_array_0;
  77         TALLOC_CTX *_mem_save_array_0;
  78         if (ndr_flags & NDR_SCALARS) {
  79                 NDR_CHECK(ndr_pull_align(ndr, 8));
  80                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
  81                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
  82                 NDR_PULL_ALLOC_N(ndr, r->array, r->count);
  83                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
  84                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
  85                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
  86                         NDR_CHECK(ndr_pull_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
  87                 }
  88                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
  89                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
  90         }
  91         if (ndr_flags & NDR_BUFFERS) {
  92         }
  93         return NDR_ERR_SUCCESS;
  94 }
  95
  96 _PUBLIC_ void ndr_print_replPropertyMetaDataCtr1(struct ndr_print *ndr, const char *name, const struct replPropertyMetaDataCtr1 *r)
  97 {
  98         uint32_t cntr_array_0;
  99         ndr_print_struct(ndr, name, "replPropertyMetaDataCtr1");
 100         ndr->depth++;
 101         ndr_print_uint32(ndr, "count", r->count);
 102         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 103         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 104         ndr->depth++;
 105         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
 106                 char *idx_0=NULL;
 107                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
 108                         ndr_print_replPropertyMetaData1(ndr, "array", &r->array[cntr_array_0]);
 109                         free(idx_0);
 110                 }
 111         }
 112         ndr->depth--;
 113         ndr->depth--;
 114 }
 115
 116 static enum ndr_err_code ndr_push_replPropertyMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const union replPropertyMetaDataCtr *r)
 117 {
 118         if (ndr_flags & NDR_SCALARS) {
 119                 int level = ndr_push_get_switch_value(ndr, r);
 120                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 121                 switch (level) {
 122                         case 1: {
 123                                 NDR_CHECK(ndr_push_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
 124                         break; }
 125
 126                         default:
 127                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 128                 }
 129         }
 130         if (ndr_flags & NDR_BUFFERS) {
 131                 int level = ndr_push_get_switch_value(ndr, r);
 132                 switch (level) {
 133                         case 1:
 134                         break;
 135
 136                         default:
 137                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 138                 }
 139         }
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, union replPropertyMetaDataCtr *r)
 144 {
 145         int level;
 146         level = ndr_pull_get_switch_value(ndr, r);
 147         if (ndr_flags & NDR_SCALARS) {
 148                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
 149                 switch (level) {
 150                         case 1: {
 151                                 NDR_CHECK(ndr_pull_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
 152                         break; }
 153
 154                         default:
 155                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 156                 }
 157         }
 158         if (ndr_flags & NDR_BUFFERS) {
 159                 switch (level) {
 160                         case 1:
 161                         break;
 162
 163                         default:
 164                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 165                 }
 166         }
 167         return NDR_ERR_SUCCESS;
 168 }
 169
 170 _PUBLIC_ void ndr_print_replPropertyMetaDataCtr(struct ndr_print *ndr, const char *name, const union replPropertyMetaDataCtr *r)
 171 {
 172         int level;
 173         level = ndr_print_get_switch_value(ndr, r);
 174         ndr_print_union(ndr, name, level, "replPropertyMetaDataCtr");
 175         switch (level) {
 176                 case 1:
 177                         ndr_print_replPropertyMetaDataCtr1(ndr, "ctr1", &r->ctr1);
 178                 break;
 179
 180                 default:
 181                         ndr_print_bad_level(ndr, name, level);
 182         }
 183 }
 184
 185 _PUBLIC_ enum ndr_err_code ndr_push_replPropertyMetaDataBlob(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaDataBlob *r)
 186 {
 187         if (ndr_flags & NDR_SCALARS) {
 188                 NDR_CHECK(ndr_push_align(ndr, 8));
 189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 191                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 192                 NDR_CHECK(ndr_push_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
 193                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 194         }
 195         if (ndr_flags & NDR_BUFFERS) {
 196         }
 197         return NDR_ERR_SUCCESS;
 198 }
 199
 200 _PUBLIC_ enum ndr_err_code ndr_pull_replPropertyMetaDataBlob(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaDataBlob *r)
 201 {
 202         if (ndr_flags & NDR_SCALARS) {
 203                 NDR_CHECK(ndr_pull_align(ndr, 8));
 204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 206                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 207                 NDR_CHECK(ndr_pull_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
 208                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 209         }
 210         if (ndr_flags & NDR_BUFFERS) {
 211         }
 212         return NDR_ERR_SUCCESS;
 213 }
 214
 215 _PUBLIC_ void ndr_print_replPropertyMetaDataBlob(struct ndr_print *ndr, const char *name, const struct replPropertyMetaDataBlob *r)
 216 {
 217         ndr_print_struct(ndr, name, "replPropertyMetaDataBlob");
 218         ndr->depth++;
 219         ndr_print_uint32(ndr, "version", r->version);
 220         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 221         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
 222         ndr_print_replPropertyMetaDataCtr(ndr, "ctr", &r->ctr);
 223         ndr->depth--;
 224 }
 225
 226 static enum ndr_err_code ndr_push_replUpToDateVectorCtr1(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorCtr1 *r)
 227 {
 228         uint32_t cntr_cursors_0;
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 8));
 231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 233                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 234                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 235                 }
 236                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 237         }
 238         if (ndr_flags & NDR_BUFFERS) {
 239         }
 240         return NDR_ERR_SUCCESS;
 241 }
 242
 243 static enum ndr_err_code ndr_pull_replUpToDateVectorCtr1(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorCtr1 *r)
 244 {
 245         uint32_t cntr_cursors_0;
 246         TALLOC_CTX *_mem_save_cursors_0;
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_pull_align(ndr, 8));
 249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 251                 NDR_PULL_ALLOC_N(ndr, r->cursors, r->count);
 252                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 253                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 254                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 255                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 256                 }
 257                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 258                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 259         }
 260         if (ndr_flags & NDR_BUFFERS) {
 261         }
 262         return NDR_ERR_SUCCESS;
 263 }
 264
 265 _PUBLIC_ void ndr_print_replUpToDateVectorCtr1(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorCtr1 *r)
 266 {
 267         uint32_t cntr_cursors_0;
 268         ndr_print_struct(ndr, name, "replUpToDateVectorCtr1");
 269         ndr->depth++;
 270         ndr_print_uint32(ndr, "count", r->count);
 271         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 272         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 273         ndr->depth++;
 274         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 275                 char *idx_0=NULL;
 276                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 277                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 278                         free(idx_0);
 279                 }
 280         }
 281         ndr->depth--;
 282         ndr->depth--;
 283 }
 284
 285 static enum ndr_err_code ndr_push_replUpToDateVectorCtr2(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorCtr2 *r)
 286 {
 287         uint32_t cntr_cursors_0;
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_push_align(ndr, 8));
 290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 292                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 293                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 294                 }
 295                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 296         }
 297         if (ndr_flags & NDR_BUFFERS) {
 298         }
 299         return NDR_ERR_SUCCESS;
 300 }
 301
 302 static enum ndr_err_code ndr_pull_replUpToDateVectorCtr2(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorCtr2 *r)
 303 {
 304         uint32_t cntr_cursors_0;
 305         TALLOC_CTX *_mem_save_cursors_0;
 306         if (ndr_flags & NDR_SCALARS) {
 307                 NDR_CHECK(ndr_pull_align(ndr, 8));
 308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 310                 NDR_PULL_ALLOC_N(ndr, r->cursors, r->count);
 311                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 312                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 313                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 314                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 315                 }
 316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 317                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 318         }
 319         if (ndr_flags & NDR_BUFFERS) {
 320         }
 321         return NDR_ERR_SUCCESS;
 322 }
 323
 324 _PUBLIC_ void ndr_print_replUpToDateVectorCtr2(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorCtr2 *r)
 325 {
 326         uint32_t cntr_cursors_0;
 327         ndr_print_struct(ndr, name, "replUpToDateVectorCtr2");
 328         ndr->depth++;
 329         ndr_print_uint32(ndr, "count", r->count);
 330         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 331         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 332         ndr->depth++;
 333         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 334                 char *idx_0=NULL;
 335                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 336                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 337                         free(idx_0);
 338                 }
 339         }
 340         ndr->depth--;
 341         ndr->depth--;
 342 }
 343
 344 static enum ndr_err_code ndr_push_replUpToDateVectorCtr(struct ndr_push *ndr, int ndr_flags, const union replUpToDateVectorCtr *r)
 345 {
 346         if (ndr_flags & NDR_SCALARS) {
 347                 int level = ndr_push_get_switch_value(ndr, r);
 348                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 349                 switch (level) {
 350                         case 1: {
 351                                 NDR_CHECK(ndr_push_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
 352                         break; }
 353
 354                         case 2: {
 355                                 NDR_CHECK(ndr_push_replUpToDateVectorCtr2(ndr, NDR_SCALARS, &r->ctr2));
 356                         break; }
 357
 358                         default:
 359                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 360                 }
 361         }
 362         if (ndr_flags & NDR_BUFFERS) {
 363                 int level = ndr_push_get_switch_value(ndr, r);
 364                 switch (level) {
 365                         case 1:
 366                         break;
 367
 368                         case 2:
 369                         break;
 370
 371                         default:
 372                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 373                 }
 374         }
 375         return NDR_ERR_SUCCESS;
 376 }
 377
 378 static enum ndr_err_code ndr_pull_replUpToDateVectorCtr(struct ndr_pull *ndr, int ndr_flags, union replUpToDateVectorCtr *r)
 379 {
 380         int level;
 381         level = ndr_pull_get_switch_value(ndr, r);
 382         if (ndr_flags & NDR_SCALARS) {
 383                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
 384                 switch (level) {
 385                         case 1: {
 386                                 NDR_CHECK(ndr_pull_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
 387                         break; }
 388
 389                         case 2: {
 390                                 NDR_CHECK(ndr_pull_replUpToDateVectorCtr2(ndr, NDR_SCALARS, &r->ctr2));
 391                         break; }
 392
 393                         default:
 394                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 395                 }
 396         }
 397         if (ndr_flags & NDR_BUFFERS) {
 398                 switch (level) {
 399                         case 1:
 400                         break;
 401
 402                         case 2:
 403                         break;
 404
 405                         default:
 406                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 407                 }
 408         }
 409         return NDR_ERR_SUCCESS;
 410 }
 411
 412 _PUBLIC_ void ndr_print_replUpToDateVectorCtr(struct ndr_print *ndr, const char *name, const union replUpToDateVectorCtr *r)
 413 {
 414         int level;
 415         level = ndr_print_get_switch_value(ndr, r);
 416         ndr_print_union(ndr, name, level, "replUpToDateVectorCtr");
 417         switch (level) {
 418                 case 1:
 419                         ndr_print_replUpToDateVectorCtr1(ndr, "ctr1", &r->ctr1);
 420                 break;
 421
 422                 case 2:
 423                         ndr_print_replUpToDateVectorCtr2(ndr, "ctr2", &r->ctr2);
 424                 break;
 425
 426                 default:
 427                         ndr_print_bad_level(ndr, name, level);
 428         }
 429 }
 430
 431 _PUBLIC_ enum ndr_err_code ndr_push_replUpToDateVectorBlob(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorBlob *r)
 432 {
 433         if (ndr_flags & NDR_SCALARS) {
 434                 NDR_CHECK(ndr_push_align(ndr, 8));
 435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 437                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 438                 NDR_CHECK(ndr_push_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
 439                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 440         }
 441         if (ndr_flags & NDR_BUFFERS) {
 442         }
 443         return NDR_ERR_SUCCESS;
 444 }
 445
 446 _PUBLIC_ enum ndr_err_code ndr_pull_replUpToDateVectorBlob(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorBlob *r)
 447 {
 448         if (ndr_flags & NDR_SCALARS) {
 449                 NDR_CHECK(ndr_pull_align(ndr, 8));
 450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 452                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 453                 NDR_CHECK(ndr_pull_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
 454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 455         }
 456         if (ndr_flags & NDR_BUFFERS) {
 457         }
 458         return NDR_ERR_SUCCESS;
 459 }
 460
 461 _PUBLIC_ void ndr_print_replUpToDateVectorBlob(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorBlob *r)
 462 {
 463         ndr_print_struct(ndr, name, "replUpToDateVectorBlob");
 464         ndr->depth++;
 465         ndr_print_uint32(ndr, "version", r->version);
 466         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 467         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
 468         ndr_print_replUpToDateVectorCtr(ndr, "ctr", &r->ctr);
 469         ndr->depth--;
 470 }
 471
 472 _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1OtherInfo(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo1OtherInfo *r)
 473 {
 474         if (ndr_flags & NDR_SCALARS) {
 475                 NDR_CHECK(ndr_push_align(ndr, 4));
 476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->dns_name) + 1));
 477                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, strlen(r->dns_name) + 1, sizeof(uint8_t), CH_DOS));
 478                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 479         }
 480         if (ndr_flags & NDR_BUFFERS) {
 481         }
 482         return NDR_ERR_SUCCESS;
 483 }
 484
 485 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1OtherInfo(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo1OtherInfo *r)
 486 {
 487         if (ndr_flags & NDR_SCALARS) {
 488                 NDR_CHECK(ndr_pull_align(ndr, 4));
 489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__dns_name_size));
 490                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, r->__dns_name_size, sizeof(uint8_t), CH_DOS));
 491                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 492         }
 493         if (ndr_flags & NDR_BUFFERS) {
 494         }
 495         return NDR_ERR_SUCCESS;
 496 }
 497
 498 _PUBLIC_ void ndr_print_repsFromTo1OtherInfo(struct ndr_print *ndr, const char *name, const struct repsFromTo1OtherInfo *r)
 499 {
 500         ndr_print_struct(ndr, name, "repsFromTo1OtherInfo");
 501         ndr->depth++;
 502         ndr_print_uint32(ndr, "__dns_name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->dns_name) + 1:r->__dns_name_size);
 503         ndr_print_string(ndr, "dns_name", r->dns_name);
 504         ndr->depth--;
 505 }
 506
 507 _PUBLIC_ size_t ndr_size_repsFromTo1OtherInfo(const struct repsFromTo1OtherInfo *r, struct smb_iconv_convenience *ic, int flags)
 508 {
 509         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo1OtherInfo, ic);
 510 }
 511
 512 _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo1 *r)
 513 {
 514         {
 515                 uint32_t _flags_save_STRUCT = ndr->flags;
 516                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 517                 if (ndr_flags & NDR_SCALARS) {
 518                         NDR_CHECK(ndr_push_align(ndr, 8));
 519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo1(r, ndr->iconv_convenience, ndr->flags) + 8));
 520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
 521                         NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_success));
 522                         NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_attempt));
 523                         NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
 524                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->other_info));
 525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo1OtherInfo(r->other_info, ndr->iconv_convenience, ndr->flags)));
 526                         NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
 527                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
 528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 529                         NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
 530                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
 531                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 532                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
 533                         NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 534                 }
 535                 if (ndr_flags & NDR_BUFFERS) {
 536                         if (r->other_info) {
 537                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->other_info));
 538                                 NDR_CHECK(ndr_push_repsFromTo1OtherInfo(ndr, NDR_SCALARS, r->other_info));
 539                         }
 540                 }
 541                 ndr->flags = _flags_save_STRUCT;
 542         }
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo1 *r)
 547 {
 548         uint32_t _ptr_other_info;
 549         TALLOC_CTX *_mem_save_other_info_0;
 550         {
 551                 uint32_t _flags_save_STRUCT = ndr->flags;
 552                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 553                 if (ndr_flags & NDR_SCALARS) {
 554                         NDR_CHECK(ndr_pull_align(ndr, 8));
 555                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blobsize));
 556                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
 557                         NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_success));
 558                         NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_attempt));
 559                         NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
 560                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 561                         if (_ptr_other_info) {
 562                                 NDR_PULL_ALLOC(ndr, r->other_info);
 563                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->other_info, _ptr_other_info));
 564                         } else {
 565                                 r->other_info = NULL;
 566                         }
 567                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->other_info_length));
 568                         NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
 569                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
 570                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 571                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
 572                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
 573                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 574                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
 575                         NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 576                 }
 577                 if (ndr_flags & NDR_BUFFERS) {
 578                         if (r->other_info) {
 579                                 uint32_t _relative_save_offset;
 580                                 _relative_save_offset = ndr->offset;
 581                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->other_info));
 582                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 583                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 584                                 NDR_CHECK(ndr_pull_repsFromTo1OtherInfo(ndr, NDR_SCALARS, r->other_info));
 585                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 586                                 if (ndr->offset > ndr->relative_highest_offset) {
 587                                         ndr->relative_highest_offset = ndr->offset;
 588                                 }
 589                                 ndr->offset = _relative_save_offset;
 590                         }
 591                 }
 592                 ndr->flags = _flags_save_STRUCT;
 593         }
 594         return NDR_ERR_SUCCESS;
 595 }
 596
 597 _PUBLIC_ void ndr_print_repsFromTo1(struct ndr_print *ndr, const char *name, const struct repsFromTo1 *r)
 598 {
 599         ndr_print_struct(ndr, name, "repsFromTo1");
 600         {
 601                 uint32_t _flags_save_STRUCT = ndr->flags;
 602                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 603                 ndr->depth++;
 604                 ndr_print_uint32(ndr, "blobsize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo1(r, ndr->iconv_convenience, ndr->flags) + 8:r->blobsize);
 605                 ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
 606                 ndr_print_NTTIME_1sec(ndr, "last_success", r->last_success);
 607                 ndr_print_NTTIME_1sec(ndr, "last_attempt", r->last_attempt);
 608                 ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
 609                 ndr_print_ptr(ndr, "other_info", r->other_info);
 610                 ndr->depth++;
 611                 if (r->other_info) {
 612                         ndr_print_repsFromTo1OtherInfo(ndr, "other_info", r->other_info);
 613                 }
 614                 ndr->depth--;
 615                 ndr_print_uint32(ndr, "other_info_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo1OtherInfo(r->other_info, ndr->iconv_convenience, ndr->flags):r->other_info_length);
 616                 ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
 617                 ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
 618                 ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 619                 ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
 620                 ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
 621                 ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 622                 ndr_print_GUID(ndr, "transport_guid", &r->transport_guid);
 623                 ndr->depth--;
 624                 ndr->flags = _flags_save_STRUCT;
 625         }
 626 }
 627
 628 _PUBLIC_ size_t ndr_size_repsFromTo1(const struct repsFromTo1 *r, struct smb_iconv_convenience *ic, int flags)
 629 {
 630         flags |= LIBNDR_PRINT_ARRAY_HEX;
 631         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo1, ic);
 632 }
 633
 634 _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo2OtherInfo(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo2OtherInfo *r)
 635 {
 636         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
 637         if (ndr_flags & NDR_SCALARS) {
 638                 NDR_CHECK(ndr_push_align(ndr, 8));
 639                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
 640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo2OtherInfo(r, ndr->iconv_convenience, ndr->flags)));
 641                 {
 642                         uint32_t _flags_save_string = ndr->flags;
 643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dns_name1));
 645                         ndr->flags = _flags_save_string;
 646                 }
 647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
 648                 {
 649                         uint32_t _flags_save_string = ndr->flags;
 650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dns_name2));
 652                         ndr->flags = _flags_save_string;
 653                 }
 654                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
 655                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 656         }
 657         if (ndr_flags & NDR_BUFFERS) {
 658                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
 659                 {
 660                         uint32_t _flags_save_string = ndr->flags;
 661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 662                         if (r->dns_name1) {
 663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dns_name1));
 664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dns_name1));
 665                         }
 666                         ndr->flags = _flags_save_string;
 667                 }
 668                 {
 669                         uint32_t _flags_save_string = ndr->flags;
 670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 671                         if (r->dns_name2) {
 672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dns_name2));
 673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dns_name2));
 674                         }
 675                         ndr->flags = _flags_save_string;
 676                 }
 677         }
 678         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
 679         return NDR_ERR_SUCCESS;
 680 }
 681
 682 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo2OtherInfo(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo2OtherInfo *r)
 683 {
 684         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
 685         uint32_t _ptr_dns_name1;
 686         TALLOC_CTX *_mem_save_dns_name1_0;
 687         uint32_t _ptr_dns_name2;
 688         TALLOC_CTX *_mem_save_dns_name2_0;
 689         if (ndr_flags & NDR_SCALARS) {
 690                 NDR_CHECK(ndr_pull_align(ndr, 8));
 691                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
 692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 693                 {
 694                         uint32_t _flags_save_string = ndr->flags;
 695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name1));
 697                         if (_ptr_dns_name1) {
 698                                 NDR_PULL_ALLOC(ndr, r->dns_name1);
 699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dns_name1, _ptr_dns_name1));
 700                         } else {
 701                                 r->dns_name1 = NULL;
 702                         }
 703                         ndr->flags = _flags_save_string;
 704                 }
 705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
 706                 {
 707                         uint32_t _flags_save_string = ndr->flags;
 708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 709                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name2));
 710                         if (_ptr_dns_name2) {
 711                                 NDR_PULL_ALLOC(ndr, r->dns_name2);
 712                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dns_name2, _ptr_dns_name2));
 713                         } else {
 714                                 r->dns_name2 = NULL;
 715                         }
 716                         ndr->flags = _flags_save_string;
 717                 }
 718                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
 719                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 720         }
 721         if (ndr_flags & NDR_BUFFERS) {
 722                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
 723                 {
 724                         uint32_t _flags_save_string = ndr->flags;
 725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 726                         if (r->dns_name1) {
 727                                 uint32_t _relative_save_offset;
 728                                 _relative_save_offset = ndr->offset;
 729                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dns_name1));
 730                                 _mem_save_dns_name1_0 = NDR_PULL_GET_MEM_CTX(ndr);
 731                                 NDR_PULL_SET_MEM_CTX(ndr, r->dns_name1, 0);
 732                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dns_name1));
 733                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name1_0, 0);
 734                                 if (ndr->offset > ndr->relative_highest_offset) {
 735                                         ndr->relative_highest_offset = ndr->offset;
 736                                 }
 737                                 ndr->offset = _relative_save_offset;
 738                         }
 739                         ndr->flags = _flags_save_string;
 740                 }
 741                 {
 742                         uint32_t _flags_save_string = ndr->flags;
 743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 744                         if (r->dns_name2) {
 745                                 uint32_t _relative_save_offset;
 746                                 _relative_save_offset = ndr->offset;
 747                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dns_name2));
 748                                 _mem_save_dns_name2_0 = NDR_PULL_GET_MEM_CTX(ndr);
 749                                 NDR_PULL_SET_MEM_CTX(ndr, r->dns_name2, 0);
 750                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dns_name2));
 751                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name2_0, 0);
 752                                 if (ndr->offset > ndr->relative_highest_offset) {
 753                                         ndr->relative_highest_offset = ndr->offset;
 754                                 }
 755                                 ndr->offset = _relative_save_offset;
 756                         }
 757                         ndr->flags = _flags_save_string;
 758                 }
 759         }
 760         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
 761         return NDR_ERR_SUCCESS;
 762 }
 763
 764 _PUBLIC_ void ndr_print_repsFromTo2OtherInfo(struct ndr_print *ndr, const char *name, const struct repsFromTo2OtherInfo *r)
 765 {
 766         ndr_print_struct(ndr, name, "repsFromTo2OtherInfo");
 767         ndr->depth++;
 768         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo2OtherInfo(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
 769         ndr_print_ptr(ndr, "dns_name1", r->dns_name1);
 770         ndr->depth++;
 771         if (r->dns_name1) {
 772                 ndr_print_string(ndr, "dns_name1", r->dns_name1);
 773         }
 774         ndr->depth--;
 775         ndr_print_uint32(ndr, "unknown1", r->unknown1);
 776         ndr_print_ptr(ndr, "dns_name2", r->dns_name2);
 777         ndr->depth++;
 778         if (r->dns_name2) {
 779                 ndr_print_string(ndr, "dns_name2", r->dns_name2);
 780         }
 781         ndr->depth--;
 782         ndr_print_hyper(ndr, "unknown2", r->unknown2);
 783         ndr->depth--;
 784 }
 785
 786 _PUBLIC_ size_t ndr_size_repsFromTo2OtherInfo(const struct repsFromTo2OtherInfo *r, struct smb_iconv_convenience *ic, int flags)
 787 {
 788         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo2OtherInfo, ic);
 789 }
 790
 791 _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo2(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo2 *r)
 792 {
 793         {
 794                 uint32_t _flags_save_STRUCT = ndr->flags;
 795                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 796                 if (ndr_flags & NDR_SCALARS) {
 797                         NDR_CHECK(ndr_push_align(ndr, 8));
 798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo2(r, ndr->iconv_convenience, ndr->flags) + 8));
 799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
 800                         NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_success));
 801                         NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_attempt));
 802                         NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
 803                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->other_info));
 804                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo2OtherInfo(r->other_info, ndr->iconv_convenience, ndr->flags)));
 805                         NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
 806                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
 807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 808                         NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
 809                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
 810                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 811                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
 812                         NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
 813                         NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 814                 }
 815                 if (ndr_flags & NDR_BUFFERS) {
 816                         if (r->other_info) {
 817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->other_info));
 818                                 NDR_CHECK(ndr_push_repsFromTo2OtherInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->other_info));
 819                         }
 820                 }
 821                 ndr->flags = _flags_save_STRUCT;
 822         }
 823         return NDR_ERR_SUCCESS;
 824 }
 825
 826 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo2(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo2 *r)
 827 {
 828         uint32_t _ptr_other_info;
 829         TALLOC_CTX *_mem_save_other_info_0;
 830         {
 831                 uint32_t _flags_save_STRUCT = ndr->flags;
 832                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 833                 if (ndr_flags & NDR_SCALARS) {
 834                         NDR_CHECK(ndr_pull_align(ndr, 8));
 835                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blobsize));
 836                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
 837                         NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_success));
 838                         NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_attempt));
 839                         NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
 840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 841                         if (_ptr_other_info) {
 842                                 NDR_PULL_ALLOC(ndr, r->other_info);
 843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->other_info, _ptr_other_info));
 844                         } else {
 845                                 r->other_info = NULL;
 846                         }
 847                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->other_info_length));
 848                         NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
 849                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
 850                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 851                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
 852                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
 853                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 854                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
 855                         NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
 856                         NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 857                 }
 858                 if (ndr_flags & NDR_BUFFERS) {
 859                         if (r->other_info) {
 860                                 uint32_t _relative_save_offset;
 861                                 _relative_save_offset = ndr->offset;
 862                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->other_info));
 863                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 864                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 865                                 NDR_CHECK(ndr_pull_repsFromTo2OtherInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->other_info));
 866                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 867                                 if (ndr->offset > ndr->relative_highest_offset) {
 868                                         ndr->relative_highest_offset = ndr->offset;
 869                                 }
 870                                 ndr->offset = _relative_save_offset;
 871                         }
 872                 }
 873                 ndr->flags = _flags_save_STRUCT;
 874         }
 875         return NDR_ERR_SUCCESS;
 876 }
 877
 878 _PUBLIC_ void ndr_print_repsFromTo2(struct ndr_print *ndr, const char *name, const struct repsFromTo2 *r)
 879 {
 880         ndr_print_struct(ndr, name, "repsFromTo2");
 881         {
 882                 uint32_t _flags_save_STRUCT = ndr->flags;
 883                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 884                 ndr->depth++;
 885                 ndr_print_uint32(ndr, "blobsize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo2(r, ndr->iconv_convenience, ndr->flags) + 8:r->blobsize);
 886                 ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
 887                 ndr_print_NTTIME_1sec(ndr, "last_success", r->last_success);
 888                 ndr_print_NTTIME_1sec(ndr, "last_attempt", r->last_attempt);
 889                 ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
 890                 ndr_print_ptr(ndr, "other_info", r->other_info);
 891                 ndr->depth++;
 892                 if (r->other_info) {
 893                         ndr_print_repsFromTo2OtherInfo(ndr, "other_info", r->other_info);
 894                 }
 895                 ndr->depth--;
 896                 ndr_print_uint32(ndr, "other_info_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo2OtherInfo(r->other_info, ndr->iconv_convenience, ndr->flags):r->other_info_length);
 897                 ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
 898                 ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
 899                 ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
 900                 ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
 901                 ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
 902                 ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 903                 ndr_print_GUID(ndr, "transport_guid", &r->transport_guid);
 904                 ndr_print_hyper(ndr, "unknown1", r->unknown1);
 905                 ndr->depth--;
 906                 ndr->flags = _flags_save_STRUCT;
 907         }
 908 }
 909
 910 _PUBLIC_ size_t ndr_size_repsFromTo2(const struct repsFromTo2 *r, struct smb_iconv_convenience *ic, int flags)
 911 {
 912         flags |= LIBNDR_PRINT_ARRAY_HEX;
 913         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo2, ic);
 914 }
 915
 916 static enum ndr_err_code ndr_push_repsFromTo(struct ndr_push *ndr, int ndr_flags, const union repsFromTo *r)
 917 {
 918         if (ndr_flags & NDR_SCALARS) {
 919                 int level = ndr_push_get_switch_value(ndr, r);
 920                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 921                 switch (level) {
 922                         case 1: {
 923                                 NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
 924                         break; }
 925
 926                         case 2: {
 927                                 NDR_CHECK(ndr_push_repsFromTo2(ndr, NDR_SCALARS, &r->ctr2));
 928                         break; }
 929
 930                         default:
 931                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 932                 }
 933         }
 934         if (ndr_flags & NDR_BUFFERS) {
 935                 int level = ndr_push_get_switch_value(ndr, r);
 936                 switch (level) {
 937                         case 1:
 938                                 NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_BUFFERS, &r->ctr1));
 939                         break;
 940
 941                         case 2:
 942                                 NDR_CHECK(ndr_push_repsFromTo2(ndr, NDR_BUFFERS, &r->ctr2));
 943                         break;
 944
 945                         default:
 946                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 947                 }
 948         }
 949         return NDR_ERR_SUCCESS;
 950 }
 951
 952 static enum ndr_err_code ndr_pull_repsFromTo(struct ndr_pull *ndr, int ndr_flags, union repsFromTo *r)
 953 {
 954         int level;
 955         level = ndr_pull_get_switch_value(ndr, r);
 956         if (ndr_flags & NDR_SCALARS) {
 957                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
 958                 switch (level) {
 959                         case 1: {
 960                                 NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
 961                         break; }
 962
 963                         case 2: {
 964                                 NDR_CHECK(ndr_pull_repsFromTo2(ndr, NDR_SCALARS, &r->ctr2));
 965                         break; }
 966
 967                         default:
 968                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 969                 }
 970         }
 971         if (ndr_flags & NDR_BUFFERS) {
 972                 switch (level) {
 973                         case 1:
 974                                 NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_BUFFERS, &r->ctr1));
 975                         break;
 976
 977                         case 2:
 978                                 NDR_CHECK(ndr_pull_repsFromTo2(ndr, NDR_BUFFERS, &r->ctr2));
 979                         break;
 980
 981                         default:
 982                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 983                 }
 984         }
 985         return NDR_ERR_SUCCESS;
 986 }
 987
 988 _PUBLIC_ void ndr_print_repsFromTo(struct ndr_print *ndr, const char *name, const union repsFromTo *r)
 989 {
 990         int level;
 991         level = ndr_print_get_switch_value(ndr, r);
 992         ndr_print_union(ndr, name, level, "repsFromTo");
 993         switch (level) {
 994                 case 1:
 995                         ndr_print_repsFromTo1(ndr, "ctr1", &r->ctr1);
 996                 break;
 997
 998                 case 2:
 999                         ndr_print_repsFromTo2(ndr, "ctr2", &r->ctr2);
1000                 break;
1001
1002                 default:
1003                         ndr_print_bad_level(ndr, name, level);
1004         }
1005 }
1006
1007 _PUBLIC_ enum ndr_err_code ndr_push_repsFromToBlob(struct ndr_push *ndr, int ndr_flags, const struct repsFromToBlob *r)
1008 {
1009         if (ndr_flags & NDR_SCALARS) {
1010                 NDR_CHECK(ndr_push_align(ndr, 8));
1011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1013                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1014                 NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
1015                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1016         }
1017         if (ndr_flags & NDR_BUFFERS) {
1018                 NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
1019         }
1020         return NDR_ERR_SUCCESS;
1021 }
1022
1023 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromToBlob(struct ndr_pull *ndr, int ndr_flags, struct repsFromToBlob *r)
1024 {
1025         if (ndr_flags & NDR_SCALARS) {
1026                 NDR_CHECK(ndr_pull_align(ndr, 8));
1027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1029                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1030                 NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
1031                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1032         }
1033         if (ndr_flags & NDR_BUFFERS) {
1034                 NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
1035         }
1036         return NDR_ERR_SUCCESS;
1037 }
1038
1039 _PUBLIC_ void ndr_print_repsFromToBlob(struct ndr_print *ndr, const char *name, const struct repsFromToBlob *r)
1040 {
1041         ndr_print_struct(ndr, name, "repsFromToBlob");
1042         ndr->depth++;
1043         ndr_print_uint32(ndr, "version", r->version);
1044         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1045         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1046         ndr_print_repsFromTo(ndr, "ctr", &r->ctr);
1047         ndr->depth--;
1048 }
1049
1050 static enum ndr_err_code ndr_push_partialAttributeSetCtr1(struct ndr_push *ndr, int ndr_flags, const struct partialAttributeSetCtr1 *r)
1051 {
1052         uint32_t cntr_array_0;
1053         if (ndr_flags & NDR_SCALARS) {
1054                 NDR_CHECK(ndr_push_align(ndr, 4));
1055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1056                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
1057                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->array[cntr_array_0]));
1058                 }
1059                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1060         }
1061         if (ndr_flags & NDR_BUFFERS) {
1062         }
1063         return NDR_ERR_SUCCESS;
1064 }
1065
1066 static enum ndr_err_code ndr_pull_partialAttributeSetCtr1(struct ndr_pull *ndr, int ndr_flags, struct partialAttributeSetCtr1 *r)
1067 {
1068         uint32_t cntr_array_0;
1069         TALLOC_CTX *_mem_save_array_0;
1070         if (ndr_flags & NDR_SCALARS) {
1071                 NDR_CHECK(ndr_pull_align(ndr, 4));
1072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1073                 NDR_PULL_ALLOC_N(ndr, r->array, r->count);
1074                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1075                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1076                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
1077                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
1078                 }
1079                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1080                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1081         }
1082         if (ndr_flags & NDR_BUFFERS) {
1083         }
1084         return NDR_ERR_SUCCESS;
1085 }
1086
1087 _PUBLIC_ void ndr_print_partialAttributeSetCtr1(struct ndr_print *ndr, const char *name, const struct partialAttributeSetCtr1 *r)
1088 {
1089         uint32_t cntr_array_0;
1090         ndr_print_struct(ndr, name, "partialAttributeSetCtr1");
1091         ndr->depth++;
1092         ndr_print_uint32(ndr, "count", r->count);
1093         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1094         ndr->depth++;
1095         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
1096                 char *idx_0=NULL;
1097                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
1098                         ndr_print_drsuapi_DsAttributeId(ndr, "array", r->array[cntr_array_0]);
1099                         free(idx_0);
1100                 }
1101         }
1102         ndr->depth--;
1103         ndr->depth--;
1104 }
1105
1106 static enum ndr_err_code ndr_push_partialAttributeSetCtr(struct ndr_push *ndr, int ndr_flags, const union partialAttributeSetCtr *r)
1107 {
1108         if (ndr_flags & NDR_SCALARS) {
1109                 int level = ndr_push_get_switch_value(ndr, r);
1110                 NDR_CHECK(ndr_push_union_align(ndr, 4));
1111                 switch (level) {
1112                         case 1: {
1113                                 NDR_CHECK(ndr_push_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
1114                         break; }
1115
1116                         default:
1117                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1118                 }
1119         }
1120         if (ndr_flags & NDR_BUFFERS) {
1121                 int level = ndr_push_get_switch_value(ndr, r);
1122                 switch (level) {
1123                         case 1:
1124                         break;
1125
1126                         default:
1127                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1128                 }
1129         }
1130         return NDR_ERR_SUCCESS;
1131 }
1132
1133 static enum ndr_err_code ndr_pull_partialAttributeSetCtr(struct ndr_pull *ndr, int ndr_flags, union partialAttributeSetCtr *r)
1134 {
1135         int level;
1136         level = ndr_pull_get_switch_value(ndr, r);
1137         if (ndr_flags & NDR_SCALARS) {
1138                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
1139                 switch (level) {
1140                         case 1: {
1141                                 NDR_CHECK(ndr_pull_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
1142                         break; }
1143
1144                         default:
1145                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1146                 }
1147         }
1148         if (ndr_flags & NDR_BUFFERS) {
1149                 switch (level) {
1150                         case 1:
1151                         break;
1152
1153                         default:
1154                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1155                 }
1156         }
1157         return NDR_ERR_SUCCESS;
1158 }
1159
1160 _PUBLIC_ void ndr_print_partialAttributeSetCtr(struct ndr_print *ndr, const char *name, const union partialAttributeSetCtr *r)
1161 {
1162         int level;
1163         level = ndr_print_get_switch_value(ndr, r);
1164         ndr_print_union(ndr, name, level, "partialAttributeSetCtr");
1165         switch (level) {
1166                 case 1:
1167                         ndr_print_partialAttributeSetCtr1(ndr, "ctr1", &r->ctr1);
1168                 break;
1169
1170                 default:
1171                         ndr_print_bad_level(ndr, name, level);
1172         }
1173 }
1174
1175 _PUBLIC_ enum ndr_err_code ndr_push_partialAttributeSetBlob(struct ndr_push *ndr, int ndr_flags, const struct partialAttributeSetBlob *r)
1176 {
1177         if (ndr_flags & NDR_SCALARS) {
1178                 NDR_CHECK(ndr_push_align(ndr, 4));
1179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1181                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1182                 NDR_CHECK(ndr_push_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
1183                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1184         }
1185         if (ndr_flags & NDR_BUFFERS) {
1186         }
1187         return NDR_ERR_SUCCESS;
1188 }
1189
1190 _PUBLIC_ enum ndr_err_code ndr_pull_partialAttributeSetBlob(struct ndr_pull *ndr, int ndr_flags, struct partialAttributeSetBlob *r)
1191 {
1192         if (ndr_flags & NDR_SCALARS) {
1193                 NDR_CHECK(ndr_pull_align(ndr, 4));
1194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1196                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1197                 NDR_CHECK(ndr_pull_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
1198                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1199         }
1200         if (ndr_flags & NDR_BUFFERS) {
1201         }
1202         return NDR_ERR_SUCCESS;
1203 }
1204
1205 _PUBLIC_ void ndr_print_partialAttributeSetBlob(struct ndr_print *ndr, const char *name, const struct partialAttributeSetBlob *r)
1206 {
1207         ndr_print_struct(ndr, name, "partialAttributeSetBlob");
1208         ndr->depth++;
1209         ndr_print_uint32(ndr, "version", r->version);
1210         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1211         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1212         ndr_print_partialAttributeSetCtr(ndr, "ctr", &r->ctr);
1213         ndr->depth--;
1214 }
1215
1216 static enum ndr_err_code ndr_push_drsuapi_MSPrefixMap_Entry(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_MSPrefixMap_Entry *r)
1217 {
1218         {
1219                 uint32_t _flags_save_STRUCT = ndr->flags;
1220                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1221                 if (ndr_flags & NDR_SCALARS) {
1222                         NDR_CHECK(ndr_push_align(ndr, 2));
1223                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->entryID));
1224                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
1225                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1226                         NDR_CHECK(ndr_push_trailer_align(ndr, 2));
1227                 }
1228                 if (ndr_flags & NDR_BUFFERS) {
1229                 }
1230                 ndr->flags = _flags_save_STRUCT;
1231         }
1232         return NDR_ERR_SUCCESS;
1233 }
1234
1235 static enum ndr_err_code ndr_pull_drsuapi_MSPrefixMap_Entry(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_MSPrefixMap_Entry *r)
1236 {
1237         {
1238                 uint32_t _flags_save_STRUCT = ndr->flags;
1239                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1240                 if (ndr_flags & NDR_SCALARS) {
1241                         NDR_CHECK(ndr_pull_align(ndr, 2));
1242                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->entryID));
1243                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
1244                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, r->length);
1245                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1246                         NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
1247                 }
1248                 if (ndr_flags & NDR_BUFFERS) {
1249                 }
1250                 ndr->flags = _flags_save_STRUCT;
1251         }
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_MSPrefixMap_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_MSPrefixMap_Ctr *r)
1256 {
1257         uint32_t cntr_entries_0;
1258         if (ndr_flags & NDR_SCALARS) {
1259                 NDR_CHECK(ndr_push_align(ndr, 4));
1260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_entries));
1261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->iconv_convenience, ndr->flags)));
1262                 for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
1263                         NDR_CHECK(ndr_push_drsuapi_MSPrefixMap_Entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
1264                 }
1265                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1266         }
1267         if (ndr_flags & NDR_BUFFERS) {
1268         }
1269         return NDR_ERR_SUCCESS;
1270 }
1271
1272 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_MSPrefixMap_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_MSPrefixMap_Ctr *r)
1273 {
1274         uint32_t cntr_entries_0;
1275         TALLOC_CTX *_mem_save_entries_0;
1276         if (ndr_flags & NDR_SCALARS) {
1277                 NDR_CHECK(ndr_pull_align(ndr, 4));
1278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_entries));
1279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1280                 NDR_PULL_ALLOC_N(ndr, r->entries, r->num_entries);
1281                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1282                 NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
1283                 for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
1284                         NDR_CHECK(ndr_pull_drsuapi_MSPrefixMap_Entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
1285                 }
1286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1287                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1288         }
1289         if (ndr_flags & NDR_BUFFERS) {
1290         }
1291         return NDR_ERR_SUCCESS;
1292 }
1293
1294 _PUBLIC_ void ndr_print_drsuapi_MSPrefixMap_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_MSPrefixMap_Ctr *r)
1295 {
1296         uint32_t cntr_entries_0;
1297         ndr_print_struct(ndr, name, "drsuapi_MSPrefixMap_Ctr");
1298         ndr->depth++;
1299         ndr_print_uint32(ndr, "num_entries", r->num_entries);
1300         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
1301         ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->num_entries);
1302         ndr->depth++;
1303         for (cntr_entries_0=0;cntr_entries_0<r->num_entries;cntr_entries_0++) {
1304                 char *idx_0=NULL;
1305                 if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
1306                         ndr_print_drsuapi_MSPrefixMap_Entry(ndr, "entries", &r->entries[cntr_entries_0]);
1307                         free(idx_0);
1308                 }
1309         }
1310         ndr->depth--;
1311         ndr->depth--;
1312 }
1313
1314 _PUBLIC_ size_t ndr_size_drsuapi_MSPrefixMap_Ctr(const struct drsuapi_MSPrefixMap_Ctr *r, struct smb_iconv_convenience *ic, int flags)
1315 {
1316         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_MSPrefixMap_Ctr, ic);
1317 }
1318
1319 static enum ndr_err_code ndr_push_prefixMapVersion(struct ndr_push *ndr, int ndr_flags, enum prefixMapVersion r)
1320 {
1321         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1322         return NDR_ERR_SUCCESS;
1323 }
1324
1325 static enum ndr_err_code ndr_pull_prefixMapVersion(struct ndr_pull *ndr, int ndr_flags, enum prefixMapVersion *r)
1326 {
1327         uint32_t v;
1328         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1329         *r = v;
1330         return NDR_ERR_SUCCESS;
1331 }
1332
1333 _PUBLIC_ void ndr_print_prefixMapVersion(struct ndr_print *ndr, const char *name, enum prefixMapVersion r)
1334 {
1335         const char *val = NULL;
1336
1337         switch (r) {
1338                 case PREFIX_MAP_VERSION_DSDB: val = "PREFIX_MAP_VERSION_DSDB"; break;
1339         }
1340         ndr_print_enum(ndr, name, "ENUM", val, r);
1341 }
1342
1343 static enum ndr_err_code ndr_push_prefixMapCtr(struct ndr_push *ndr, int ndr_flags, const union prefixMapCtr *r)
1344 {
1345         if (ndr_flags & NDR_SCALARS) {
1346                 int level = ndr_push_get_switch_value(ndr, r);
1347                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1348                 switch (level) {
1349                         case PREFIX_MAP_VERSION_DSDB: {
1350                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
1351                         break; }
1352
1353                         default:
1354                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1355                 }
1356         }
1357         if (ndr_flags & NDR_BUFFERS) {
1358                 int level = ndr_push_get_switch_value(ndr, r);
1359                 switch (level) {
1360                         case PREFIX_MAP_VERSION_DSDB:
1361                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
1362                         break;
1363
1364                         default:
1365                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1366                 }
1367         }
1368         return NDR_ERR_SUCCESS;
1369 }
1370
1371 static enum ndr_err_code ndr_pull_prefixMapCtr(struct ndr_pull *ndr, int ndr_flags, union prefixMapCtr *r)
1372 {
1373         int level;
1374         level = ndr_pull_get_switch_value(ndr, r);
1375         if (ndr_flags & NDR_SCALARS) {
1376                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1377                 switch (level) {
1378                         case PREFIX_MAP_VERSION_DSDB: {
1379                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
1380                         break; }
1381
1382                         default:
1383                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1384                 }
1385         }
1386         if (ndr_flags & NDR_BUFFERS) {
1387                 switch (level) {
1388                         case PREFIX_MAP_VERSION_DSDB:
1389                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
1390                         break;
1391
1392                         default:
1393                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1394                 }
1395         }
1396         return NDR_ERR_SUCCESS;
1397 }
1398
1399 _PUBLIC_ void ndr_print_prefixMapCtr(struct ndr_print *ndr, const char *name, const union prefixMapCtr *r)
1400 {
1401         int level;
1402         level = ndr_print_get_switch_value(ndr, r);
1403         ndr_print_union(ndr, name, level, "prefixMapCtr");
1404         switch (level) {
1405                 case PREFIX_MAP_VERSION_DSDB:
1406                         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "dsdb", &r->dsdb);
1407                 break;
1408
1409                 default:
1410                         ndr_print_bad_level(ndr, name, level);
1411         }
1412 }
1413
1414 _PUBLIC_ enum ndr_err_code ndr_push_prefixMapBlob(struct ndr_push *ndr, int ndr_flags, const struct prefixMapBlob *r)
1415 {
1416         if (ndr_flags & NDR_SCALARS) {
1417                 NDR_CHECK(ndr_push_align(ndr, 5));
1418                 NDR_CHECK(ndr_push_prefixMapVersion(ndr, NDR_SCALARS, r->version));
1419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1420                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1421                 NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
1422                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1423         }
1424         if (ndr_flags & NDR_BUFFERS) {
1425                 NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
1426         }
1427         return NDR_ERR_SUCCESS;
1428 }
1429
1430 _PUBLIC_ enum ndr_err_code ndr_pull_prefixMapBlob(struct ndr_pull *ndr, int ndr_flags, struct prefixMapBlob *r)
1431 {
1432         if (ndr_flags & NDR_SCALARS) {
1433                 NDR_CHECK(ndr_pull_align(ndr, 5));
1434                 NDR_CHECK(ndr_pull_prefixMapVersion(ndr, NDR_SCALARS, &r->version));
1435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1436                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1437                 NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
1438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1439         }
1440         if (ndr_flags & NDR_BUFFERS) {
1441                 NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
1442         }
1443         return NDR_ERR_SUCCESS;
1444 }
1445
1446 _PUBLIC_ void ndr_print_prefixMapBlob(struct ndr_print *ndr, const char *name, const struct prefixMapBlob *r)
1447 {
1448         ndr_print_struct(ndr, name, "prefixMapBlob");
1449         ndr->depth++;
1450         ndr_print_prefixMapVersion(ndr, "version", r->version);
1451         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1452         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1453         ndr_print_prefixMapCtr(ndr, "ctr", &r->ctr);
1454         ndr->depth--;
1455 }
1456
1457 static enum ndr_err_code ndr_push_ldapControlDirSyncExtra(struct ndr_push *ndr, int ndr_flags, const union ldapControlDirSyncExtra *r)
1458 {
1459         if (ndr_flags & NDR_SCALARS) {
1460                 int level = ndr_push_get_switch_value(ndr, r);
1461                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1462                 switch (level) {
1463                         case 0: {
1464                         break; }
1465
1466                         default: {
1467                                 NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1468                         break; }
1469
1470                 }
1471         }
1472         if (ndr_flags & NDR_BUFFERS) {
1473                 int level = ndr_push_get_switch_value(ndr, r);
1474                 switch (level) {
1475                         case 0:
1476                         break;
1477
1478                         default:
1479                         break;
1480
1481                 }
1482         }
1483         return NDR_ERR_SUCCESS;
1484 }
1485
1486 static enum ndr_err_code ndr_pull_ldapControlDirSyncExtra(struct ndr_pull *ndr, int ndr_flags, union ldapControlDirSyncExtra *r)
1487 {
1488         int level;
1489         level = ndr_pull_get_switch_value(ndr, r);
1490         if (ndr_flags & NDR_SCALARS) {
1491                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1492                 switch (level) {
1493                         case 0: {
1494                         break; }
1495
1496                         default: {
1497                                 NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1498                         break; }
1499
1500                 }
1501         }
1502         if (ndr_flags & NDR_BUFFERS) {
1503                 switch (level) {
1504                         case 0:
1505                         break;
1506
1507                         default:
1508                         break;
1509
1510                 }
1511         }
1512         return NDR_ERR_SUCCESS;
1513 }
1514
1515 _PUBLIC_ void ndr_print_ldapControlDirSyncExtra(struct ndr_print *ndr, const char *name, const union ldapControlDirSyncExtra *r)
1516 {
1517         int level;
1518         level = ndr_print_get_switch_value(ndr, r);
1519         ndr_print_union(ndr, name, level, "ldapControlDirSyncExtra");
1520         switch (level) {
1521                 case 0:
1522                 break;
1523
1524                 default:
1525                         ndr_print_replUpToDateVectorBlob(ndr, "uptodateness_vector", &r->uptodateness_vector);
1526                 break;
1527
1528         }
1529 }
1530
1531 static size_t ndr_size_ldapControlDirSyncExtra(const union ldapControlDirSyncExtra *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
1532 {
1533         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ldapControlDirSyncExtra, ic);
1534 }
1535
1536 static enum ndr_err_code ndr_push_ldapControlDirSyncBlob(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncBlob *r)
1537 {
1538         if (ndr_flags & NDR_SCALARS) {
1539                 NDR_CHECK(ndr_push_align(ndr, 8));
1540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 3));
1541                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
1542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
1543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
1544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, ndr->iconv_convenience, 0)));
1545                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1546                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
1547                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->extra, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, ndr->iconv_convenience, 0)));
1548                 NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1549                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1550         }
1551         if (ndr_flags & NDR_BUFFERS) {
1552                 NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1553         }
1554         return NDR_ERR_SUCCESS;
1555 }
1556
1557 static enum ndr_err_code ndr_pull_ldapControlDirSyncBlob(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncBlob *r)
1558 {
1559         if (ndr_flags & NDR_SCALARS) {
1560                 NDR_CHECK(ndr_pull_align(ndr, 8));
1561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
1562                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
1563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
1564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
1565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->extra_length));
1566                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1567                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
1568                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->extra, r->extra_length));
1569                 NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1570                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1571         }
1572         if (ndr_flags & NDR_BUFFERS) {
1573                 NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1574         }
1575         return NDR_ERR_SUCCESS;
1576 }
1577
1578 _PUBLIC_ void ndr_print_ldapControlDirSyncBlob(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncBlob *r)
1579 {
1580         ndr_print_struct(ndr, name, "ldapControlDirSyncBlob");
1581         ndr->depth++;
1582         ndr_print_uint32(ndr, "u1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?3:r->u1);
1583         ndr_print_NTTIME(ndr, "time", r->time);
1584         ndr_print_uint32(ndr, "u2", r->u2);
1585         ndr_print_uint32(ndr, "u3", r->u3);
1586         ndr_print_uint32(ndr, "extra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, ndr->iconv_convenience, 0):r->extra_length);
1587         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1588         ndr_print_GUID(ndr, "guid1", &r->guid1);
1589         ndr_print_set_switch_value(ndr, &r->extra, r->extra_length);
1590         ndr_print_ldapControlDirSyncExtra(ndr, "extra", &r->extra);
1591         ndr->depth--;
1592 }
1593
1594 _PUBLIC_ enum ndr_err_code ndr_push_ldapControlDirSyncCookie(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncCookie *r)
1595 {
1596         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
1597         if (ndr_flags & NDR_SCALARS) {
1598                 NDR_CHECK(ndr_push_align(ndr, 8));
1599                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1600                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "MSDS", 4, sizeof(uint8_t), CH_DOS));
1601                 {
1602                         struct ndr_push *_ndr_blob;
1603                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_blob, 0, -1));
1604                         NDR_CHECK(ndr_push_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1605                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0, -1));
1606                 }
1607                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1608         }
1609         if (ndr_flags & NDR_BUFFERS) {
1610                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
1611         }
1612         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
1613         return NDR_ERR_SUCCESS;
1614 }
1615
1616 _PUBLIC_ enum ndr_err_code ndr_pull_ldapControlDirSyncCookie(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncCookie *r)
1617 {
1618         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
1619         if (ndr_flags & NDR_SCALARS) {
1620                 NDR_CHECK(ndr_pull_align(ndr, 8));
1621                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
1622                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->msds, 4, sizeof(uint8_t), CH_DOS));
1623                 {
1624                         struct ndr_pull *_ndr_blob;
1625                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_blob, 0, -1));
1626                         NDR_CHECK(ndr_pull_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1627                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0, -1));
1628                 }
1629                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1630         }
1631         if (ndr_flags & NDR_BUFFERS) {
1632                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
1633         }
1634         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
1635         return NDR_ERR_SUCCESS;
1636 }
1637
1638 _PUBLIC_ void ndr_print_ldapControlDirSyncCookie(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncCookie *r)
1639 {
1640         ndr_print_struct(ndr, name, "ldapControlDirSyncCookie");
1641         ndr->depth++;
1642         ndr_print_string(ndr, "msds", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"MSDS":r->msds);
1643         ndr_print_ldapControlDirSyncBlob(ndr, "blob", &r->blob);
1644         ndr->depth--;
1645 }
1646
1647 static enum ndr_err_code ndr_push_supplementalCredentialsPackage(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsPackage *r)
1648 {
1649         if (ndr_flags & NDR_SCALARS) {
1650                 NDR_CHECK(ndr_push_align(ndr, 2));
1651                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->name)));
1652                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->data)));
1653                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
1654                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 2 * strlen_m(r->name), sizeof(uint8_t), CH_UTF16));
1655                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data, strlen(r->data), sizeof(uint8_t), CH_DOS));
1656                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
1657         }
1658         if (ndr_flags & NDR_BUFFERS) {
1659         }
1660         return NDR_ERR_SUCCESS;
1661 }
1662
1663 static enum ndr_err_code ndr_pull_supplementalCredentialsPackage(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsPackage *r)
1664 {
1665         if (ndr_flags & NDR_SCALARS) {
1666                 NDR_CHECK(ndr_pull_align(ndr, 2));
1667                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
1668                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data_len));
1669                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
1670                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, r->name_len, sizeof(uint8_t), CH_UTF16));
1671                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data, r->data_len, sizeof(uint8_t), CH_DOS));
1672                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
1673         }
1674         if (ndr_flags & NDR_BUFFERS) {
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 _PUBLIC_ void ndr_print_supplementalCredentialsPackage(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsPackage *r)
1680 {
1681         ndr_print_struct(ndr, name, "supplementalCredentialsPackage");
1682         ndr->depth++;
1683         ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->name):r->name_len);
1684         ndr_print_uint16(ndr, "data_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->data):r->data_len);
1685         ndr_print_uint16(ndr, "reserved", r->reserved);
1686         ndr_print_string(ndr, "name", r->name);
1687         ndr_print_string(ndr, "data", r->data);
1688         ndr->depth--;
1689 }
1690
1691 static enum ndr_err_code ndr_push_supplementalCredentialsSignature(struct ndr_push *ndr, int ndr_flags, enum supplementalCredentialsSignature r)
1692 {
1693         {
1694                 uint32_t _flags_save_ENUM = ndr->flags;
1695                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1696                 NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1697                 ndr->flags = _flags_save_ENUM;
1698         }
1699         return NDR_ERR_SUCCESS;
1700 }
1701
1702 static enum ndr_err_code ndr_pull_supplementalCredentialsSignature(struct ndr_pull *ndr, int ndr_flags, enum supplementalCredentialsSignature *r)
1703 {
1704         uint16_t v;
1705         {
1706                 uint32_t _flags_save_ENUM = ndr->flags;
1707                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1708                 NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1709                 *r = v;
1710                 ndr->flags = _flags_save_ENUM;
1711         }
1712         return NDR_ERR_SUCCESS;
1713 }
1714
1715 _PUBLIC_ void ndr_print_supplementalCredentialsSignature(struct ndr_print *ndr, const char *name, enum supplementalCredentialsSignature r)
1716 {
1717         const char *val = NULL;
1718
1719         {
1720                 uint32_t _flags_save_ENUM = ndr->flags;
1721                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1722                 switch (r) {
1723                         case SUPPLEMENTAL_CREDENTIALS_SIGNATURE: val = "SUPPLEMENTAL_CREDENTIALS_SIGNATURE"; break;
1724                 }
1725                 ndr_print_enum(ndr, name, "ENUM", val, r);
1726                 ndr->flags = _flags_save_ENUM;
1727         }
1728 }
1729
1730 static enum ndr_err_code ndr_push_supplementalCredentialsSubBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsSubBlob *r)
1731 {
1732         uint32_t cntr_packages_0;
1733         if (ndr_flags & NDR_SCALARS) {
1734                 NDR_CHECK(ndr_push_align(ndr, 3));
1735                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_PREFIX, 0x30, sizeof(uint16_t), CH_UTF16));
1736                 NDR_CHECK(ndr_push_supplementalCredentialsSignature(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_SIGNATURE));
1737                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_packages));
1738                 for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1739                         NDR_CHECK(ndr_push_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1740                 }
1741                 NDR_CHECK(ndr_push_trailer_align(ndr, 3));
1742         }
1743         if (ndr_flags & NDR_BUFFERS) {
1744         }
1745         return NDR_ERR_SUCCESS;
1746 }
1747
1748 static enum ndr_err_code ndr_pull_supplementalCredentialsSubBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsSubBlob *r)
1749 {
1750         uint32_t cntr_packages_0;
1751         TALLOC_CTX *_mem_save_packages_0;
1752         if (ndr_flags & NDR_SCALARS) {
1753                 NDR_CHECK(ndr_pull_align(ndr, 3));
1754                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->prefix, 0x30, sizeof(uint16_t), CH_UTF16));
1755                 NDR_CHECK(ndr_pull_supplementalCredentialsSignature(ndr, NDR_SCALARS, &r->signature));
1756                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_packages));
1757                 NDR_PULL_ALLOC_N(ndr, r->packages, r->num_packages);
1758                 _mem_save_packages_0 = NDR_PULL_GET_MEM_CTX(ndr);
1759                 NDR_PULL_SET_MEM_CTX(ndr, r->packages, 0);
1760                 for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1761                         NDR_CHECK(ndr_pull_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1762                 }
1763                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_packages_0, 0);
1764                 NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
1765         }
1766         if (ndr_flags & NDR_BUFFERS) {
1767         }
1768         return NDR_ERR_SUCCESS;
1769 }
1770
1771 _PUBLIC_ void ndr_print_supplementalCredentialsSubBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsSubBlob *r)
1772 {
1773         uint32_t cntr_packages_0;
1774         ndr_print_struct(ndr, name, "supplementalCredentialsSubBlob");
1775         ndr->depth++;
1776         ndr_print_string(ndr, "prefix", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_PREFIX:r->prefix);
1777         ndr_print_supplementalCredentialsSignature(ndr, "signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_SIGNATURE:r->signature);
1778         ndr_print_uint16(ndr, "num_packages", r->num_packages);
1779         ndr->print(ndr, "%s: ARRAY(%d)", "packages", (int)r->num_packages);
1780         ndr->depth++;
1781         for (cntr_packages_0=0;cntr_packages_0<r->num_packages;cntr_packages_0++) {
1782                 char *idx_0=NULL;
1783                 if (asprintf(&idx_0, "[%d]", cntr_packages_0) != -1) {
1784                         ndr_print_supplementalCredentialsPackage(ndr, "packages", &r->packages[cntr_packages_0]);
1785                         free(idx_0);
1786                 }
1787         }
1788         ndr->depth--;
1789         ndr->depth--;
1790 }
1791
1792 static size_t ndr_size_supplementalCredentialsSubBlob(const struct supplementalCredentialsSubBlob *r, struct smb_iconv_convenience *ic, int flags)
1793 {
1794         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_supplementalCredentialsSubBlob, ic);
1795 }
1796
1797 _PUBLIC_ enum ndr_err_code ndr_push_supplementalCredentialsBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsBlob *r)
1798 {
1799         if (ndr_flags & NDR_SCALARS) {
1800                 NDR_CHECK(ndr_push_align(ndr, 4));
1801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
1803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1804                 {
1805                         struct ndr_push *_ndr_sub;
1806                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
1807                         NDR_CHECK(ndr_push_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1808                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
1809                 }
1810                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
1811                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1812         }
1813         if (ndr_flags & NDR_BUFFERS) {
1814         }
1815         return NDR_ERR_SUCCESS;
1816 }
1817
1818 _PUBLIC_ enum ndr_err_code ndr_pull_supplementalCredentialsBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsBlob *r)
1819 {
1820         if (ndr_flags & NDR_SCALARS) {
1821                 NDR_CHECK(ndr_pull_align(ndr, 4));
1822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
1823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
1825                 {
1826                         struct ndr_pull *_ndr_sub;
1827                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sub, 0, r->__ndr_size));
1828                         NDR_CHECK(ndr_pull_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1829                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sub, 0, r->__ndr_size));
1830                 }
1831                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown3));
1832                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1833         }
1834         if (ndr_flags & NDR_BUFFERS) {
1835         }
1836         return NDR_ERR_SUCCESS;
1837 }
1838
1839 _PUBLIC_ void ndr_print_supplementalCredentialsBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsBlob *r)
1840 {
1841         ndr_print_struct(ndr, name, "supplementalCredentialsBlob");
1842         ndr->depth++;
1843         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown1);
1844         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
1845         ndr_print_uint32(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown2);
1846         ndr_print_supplementalCredentialsSubBlob(ndr, "sub", &r->sub);
1847         ndr_print_uint8(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
1848         ndr->depth--;
1849 }
1850
1851 _PUBLIC_ enum ndr_err_code ndr_push_package_PackagesBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PackagesBlob *r)
1852 {
1853         if (ndr_flags & NDR_SCALARS) {
1854                 NDR_CHECK(ndr_push_align(ndr, 4));
1855                 {
1856                         uint32_t _flags_save_string_array = ndr->flags;
1857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1858                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->names));
1859                         ndr->flags = _flags_save_string_array;
1860                 }
1861                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1862         }
1863         if (ndr_flags & NDR_BUFFERS) {
1864         }
1865         return NDR_ERR_SUCCESS;
1866 }
1867
1868 _PUBLIC_ enum ndr_err_code ndr_pull_package_PackagesBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PackagesBlob *r)
1869 {
1870         if (ndr_flags & NDR_SCALARS) {
1871                 NDR_CHECK(ndr_pull_align(ndr, 4));
1872                 {
1873                         uint32_t _flags_save_string_array = ndr->flags;
1874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1875                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->names));
1876                         ndr->flags = _flags_save_string_array;
1877                 }
1878                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1879         }
1880         if (ndr_flags & NDR_BUFFERS) {
1881         }
1882         return NDR_ERR_SUCCESS;
1883 }
1884
1885 _PUBLIC_ void ndr_print_package_PackagesBlob(struct ndr_print *ndr, const char *name, const struct package_PackagesBlob *r)
1886 {
1887         ndr_print_struct(ndr, name, "package_PackagesBlob");
1888         ndr->depth++;
1889         ndr_print_string_array(ndr, "names", r->names);
1890         ndr->depth--;
1891 }
1892
1893 static enum ndr_err_code ndr_push_package_PrimaryKerberosString(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosString *r)
1894 {
1895         if (ndr_flags & NDR_SCALARS) {
1896                 NDR_CHECK(ndr_push_align(ndr, 5));
1897                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1898                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1899                 {
1900                         uint32_t _flags_save_string = ndr->flags;
1901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1902                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->string));
1903                         ndr->flags = _flags_save_string;
1904                 }
1905                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1906         }
1907         if (ndr_flags & NDR_BUFFERS) {
1908                 {
1909                         uint32_t _flags_save_string = ndr->flags;
1910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1911                         if (r->string) {
1912                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->string));
1913                                 {
1914                                         struct ndr_push *_ndr_string;
1915                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_string, 0, 2 * strlen_m(r->string)));
1916                                         NDR_CHECK(ndr_push_string(_ndr_string, NDR_SCALARS, r->string));
1917                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_string, 0, 2 * strlen_m(r->string)));
1918                                 }
1919                         }
1920                         ndr->flags = _flags_save_string;
1921                 }
1922         }
1923         return NDR_ERR_SUCCESS;
1924 }
1925
1926 static enum ndr_err_code ndr_pull_package_PrimaryKerberosString(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosString *r)
1927 {
1928         uint32_t _ptr_string;
1929         TALLOC_CTX *_mem_save_string_0;
1930         if (ndr_flags & NDR_SCALARS) {
1931                 NDR_CHECK(ndr_pull_align(ndr, 5));
1932                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
1933                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1934                 {
1935                         uint32_t _flags_save_string = ndr->flags;
1936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1937                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
1938                         if (_ptr_string) {
1939                                 NDR_PULL_ALLOC(ndr, r->string);
1940                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->string, _ptr_string));
1941                         } else {
1942                                 r->string = NULL;
1943                         }
1944                         ndr->flags = _flags_save_string;
1945                 }
1946                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1947         }
1948         if (ndr_flags & NDR_BUFFERS) {
1949                 {
1950                         uint32_t _flags_save_string = ndr->flags;
1951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1952                         if (r->string) {
1953                                 uint32_t _relative_save_offset;
1954                                 _relative_save_offset = ndr->offset;
1955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->string));
1956                                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
1957                                 NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
1958                                 {
1959                                         struct ndr_pull *_ndr_string;
1960                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_string, 0, r->size));
1961                                         NDR_CHECK(ndr_pull_string(_ndr_string, NDR_SCALARS, &r->string));
1962                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_string, 0, r->size));
1963                                 }
1964                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
1965                                 if (ndr->offset > ndr->relative_highest_offset) {
1966                                         ndr->relative_highest_offset = ndr->offset;
1967                                 }
1968                                 ndr->offset = _relative_save_offset;
1969                         }
1970                         ndr->flags = _flags_save_string;
1971                 }
1972         }
1973         return NDR_ERR_SUCCESS;
1974 }
1975
1976 _PUBLIC_ void ndr_print_package_PrimaryKerberosString(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosString *r)
1977 {
1978         ndr_print_struct(ndr, name, "package_PrimaryKerberosString");
1979         ndr->depth++;
1980         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
1981         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
1982         ndr_print_ptr(ndr, "string", r->string);
1983         ndr->depth++;
1984         if (r->string) {
1985                 ndr_print_string(ndr, "string", r->string);
1986         }
1987         ndr->depth--;
1988         ndr->depth--;
1989 }
1990
1991 static enum ndr_err_code ndr_push_package_PrimaryKerberosKey3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey3 *r)
1992 {
1993         if (ndr_flags & NDR_SCALARS) {
1994                 NDR_CHECK(ndr_push_align(ndr, 5));
1995                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1996                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
1999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
2000                 {
2001                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2003                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
2004                         ndr->flags = _flags_save_DATA_BLOB;
2005                 }
2006                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2007         }
2008         if (ndr_flags & NDR_BUFFERS) {
2009                 {
2010                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2012                         if (r->value) {
2013                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value));
2014                                 {
2015                                         struct ndr_push *_ndr_value;
2016                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
2017                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
2018                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
2019                                 }
2020                         }
2021                         ndr->flags = _flags_save_DATA_BLOB;
2022                 }
2023         }
2024         return NDR_ERR_SUCCESS;
2025 }
2026
2027 static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey3 *r)
2028 {
2029         uint32_t _ptr_value;
2030         TALLOC_CTX *_mem_save_value_0;
2031         if (ndr_flags & NDR_SCALARS) {
2032                 NDR_CHECK(ndr_pull_align(ndr, 5));
2033                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
2034                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
2035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
2036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
2037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
2038                 {
2039                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2041                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
2042                         if (_ptr_value) {
2043                                 NDR_PULL_ALLOC(ndr, r->value);
2044                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
2045                         } else {
2046                                 r->value = NULL;
2047                         }
2048                         ndr->flags = _flags_save_DATA_BLOB;
2049                 }
2050                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2051         }
2052         if (ndr_flags & NDR_BUFFERS) {
2053                 {
2054                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2056                         if (r->value) {
2057                                 uint32_t _relative_save_offset;
2058                                 _relative_save_offset = ndr->offset;
2059                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
2060                                 _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
2061                                 NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
2062                                 {
2063                                         struct ndr_pull *_ndr_value;
2064                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
2065                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
2066                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
2067                                 }
2068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
2069                                 if (ndr->offset > ndr->relative_highest_offset) {
2070                                         ndr->relative_highest_offset = ndr->offset;
2071                                 }
2072                                 ndr->offset = _relative_save_offset;
2073                         }
2074                         ndr->flags = _flags_save_DATA_BLOB;
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_package_PrimaryKerberosKey3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey3 *r)
2081 {
2082         ndr_print_struct(ndr, name, "package_PrimaryKerberosKey3");
2083         ndr->depth++;
2084         ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2085         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2086         ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
2087         ndr_print_uint32(ndr, "keytype", r->keytype);
2088         ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
2089         ndr_print_ptr(ndr, "value", r->value);
2090         ndr->depth++;
2091         if (r->value) {
2092                 ndr_print_DATA_BLOB(ndr, "value", *r->value);
2093         }
2094         ndr->depth--;
2095         ndr->depth--;
2096 }
2097
2098 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr3 *r)
2099 {
2100         uint32_t cntr_keys_0;
2101         uint32_t cntr_old_keys_0;
2102         if (ndr_flags & NDR_SCALARS) {
2103                 NDR_CHECK(ndr_push_align(ndr, 5));
2104                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
2105                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
2106                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2107                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2108                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2109                 }
2110                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2111                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2112                 }
2113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2118                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2119         }
2120         if (ndr_flags & NDR_BUFFERS) {
2121                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2122                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2123                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2124                 }
2125                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2126                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2127                 }
2128         }
2129         return NDR_ERR_SUCCESS;
2130 }
2131
2132 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr3 *r)
2133 {
2134         uint32_t cntr_keys_0;
2135         TALLOC_CTX *_mem_save_keys_0;
2136         uint32_t cntr_old_keys_0;
2137         TALLOC_CTX *_mem_save_old_keys_0;
2138         if (ndr_flags & NDR_SCALARS) {
2139                 NDR_CHECK(ndr_pull_align(ndr, 5));
2140                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
2141                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
2142                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2143                 NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
2144                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2145                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2146                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2147                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2148                 }
2149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2150                 NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
2151                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2152                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2153                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2154                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2155                 }
2156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding1));
2158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding2));
2159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding3));
2160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding4));
2161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding5));
2162                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2163         }
2164         if (ndr_flags & NDR_BUFFERS) {
2165                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2166                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2167                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2168                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2169                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2170                 }
2171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2172                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2173                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2174                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2175                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2176                 }
2177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2178         }
2179         return NDR_ERR_SUCCESS;
2180 }
2181
2182 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr3 *r)
2183 {
2184         uint32_t cntr_keys_0;
2185         uint32_t cntr_old_keys_0;
2186         ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr3");
2187         ndr->depth++;
2188         ndr_print_uint16(ndr, "num_keys", r->num_keys);
2189         ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
2190         ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
2191         ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
2192         ndr->depth++;
2193         for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
2194                 char *idx_0=NULL;
2195                 if (asprintf(&idx_0, "[%d]", cntr_keys_0) != -1) {
2196                         ndr_print_package_PrimaryKerberosKey3(ndr, "keys", &r->keys[cntr_keys_0]);
2197                         free(idx_0);
2198                 }
2199         }
2200         ndr->depth--;
2201         ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2202         ndr->depth++;
2203         for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2204                 char *idx_0=NULL;
2205                 if (asprintf(&idx_0, "[%d]", cntr_old_keys_0) != -1) {
2206                         ndr_print_package_PrimaryKerberosKey3(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2207                         free(idx_0);
2208                 }
2209         }
2210         ndr->depth--;
2211         ndr_print_uint32(ndr, "padding1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding1);
2212         ndr_print_uint32(ndr, "padding2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding2);
2213         ndr_print_uint32(ndr, "padding3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding3);
2214         ndr_print_uint32(ndr, "padding4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding4);
2215         ndr_print_uint32(ndr, "padding5", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding5);
2216         ndr->depth--;
2217 }
2218
2219 static enum ndr_err_code ndr_push_package_PrimaryKerberosKey4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey4 *r)
2220 {
2221         if (ndr_flags & NDR_SCALARS) {
2222                 NDR_CHECK(ndr_push_align(ndr, 5));
2223                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2224                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iteration_count));
2227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
2228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
2229                 {
2230                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2231                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2232                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
2233                         ndr->flags = _flags_save_DATA_BLOB;
2234                 }
2235                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2236         }
2237         if (ndr_flags & NDR_BUFFERS) {
2238                 {
2239                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2241                         if (r->value) {
2242                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value));
2243                                 {
2244                                         struct ndr_push *_ndr_value;
2245                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
2246                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
2247                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
2248                                 }
2249                         }
2250                         ndr->flags = _flags_save_DATA_BLOB;
2251                 }
2252         }
2253         return NDR_ERR_SUCCESS;
2254 }
2255
2256 static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey4 *r)
2257 {
2258         uint32_t _ptr_value;
2259         TALLOC_CTX *_mem_save_value_0;
2260         if (ndr_flags & NDR_SCALARS) {
2261                 NDR_CHECK(ndr_pull_align(ndr, 5));
2262                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
2263                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
2264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
2265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iteration_count));
2266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
2267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
2268                 {
2269                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2271                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
2272                         if (_ptr_value) {
2273                                 NDR_PULL_ALLOC(ndr, r->value);
2274                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
2275                         } else {
2276                                 r->value = NULL;
2277                         }
2278                         ndr->flags = _flags_save_DATA_BLOB;
2279                 }
2280                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2281         }
2282         if (ndr_flags & NDR_BUFFERS) {
2283                 {
2284                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2286                         if (r->value) {
2287                                 uint32_t _relative_save_offset;
2288                                 _relative_save_offset = ndr->offset;
2289                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
2290                                 _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
2291                                 NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
2292                                 {
2293                                         struct ndr_pull *_ndr_value;
2294                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
2295                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
2296                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
2297                                 }
2298                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
2299                                 if (ndr->offset > ndr->relative_highest_offset) {
2300                                         ndr->relative_highest_offset = ndr->offset;
2301                                 }
2302                                 ndr->offset = _relative_save_offset;
2303                         }
2304                         ndr->flags = _flags_save_DATA_BLOB;
2305                 }
2306         }
2307         return NDR_ERR_SUCCESS;
2308 }
2309
2310 _PUBLIC_ void ndr_print_package_PrimaryKerberosKey4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey4 *r)
2311 {
2312         ndr_print_struct(ndr, name, "package_PrimaryKerberosKey4");
2313         ndr->depth++;
2314         ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2315         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2316         ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
2317         ndr_print_uint32(ndr, "iteration_count", r->iteration_count);
2318         ndr_print_uint32(ndr, "keytype", r->keytype);
2319         ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
2320         ndr_print_ptr(ndr, "value", r->value);
2321         ndr->depth++;
2322         if (r->value) {
2323                 ndr_print_DATA_BLOB(ndr, "value", *r->value);
2324         }
2325         ndr->depth--;
2326         ndr->depth--;
2327 }
2328
2329 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr4 *r)
2330 {
2331         uint32_t cntr_keys_0;
2332         uint32_t cntr_old_keys_0;
2333         uint32_t cntr_older_keys_0;
2334         if (ndr_flags & NDR_SCALARS) {
2335                 NDR_CHECK(ndr_push_align(ndr, 5));
2336                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
2337                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2338                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
2339                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_older_keys));
2340                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->default_iteration_count));
2342                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2343                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2344                 }
2345                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2346                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2347                 }
2348                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2349                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
2350                 }
2351                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2352         }
2353         if (ndr_flags & NDR_BUFFERS) {
2354                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2355                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2356                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2357                 }
2358                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2359                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2360                 }
2361                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2362                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
2363                 }
2364         }
2365         return NDR_ERR_SUCCESS;
2366 }
2367
2368 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr4 *r)
2369 {
2370         uint32_t cntr_keys_0;
2371         TALLOC_CTX *_mem_save_keys_0;
2372         uint32_t cntr_service_keys_0;
2373         TALLOC_CTX *_mem_save_service_keys_0;
2374         uint32_t cntr_old_keys_0;
2375         TALLOC_CTX *_mem_save_old_keys_0;
2376         uint32_t cntr_older_keys_0;
2377         TALLOC_CTX *_mem_save_older_keys_0;
2378         if (ndr_flags & NDR_SCALARS) {
2379                 NDR_CHECK(ndr_pull_align(ndr, 5));
2380                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
2381                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_service_keys));
2382                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
2383                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_older_keys));
2384                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->default_iteration_count));
2386                 NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
2387                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2388                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2389                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2390                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2391                 }
2392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2393                 NDR_PULL_ALLOC_N(ndr, r->service_keys, r->num_service_keys);
2394                 _mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2395                 NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
2396                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
2397                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->service_keys[cntr_service_keys_0]));
2398                 }
2399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
2400                 NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
2401                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2402                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2403                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2404                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2405                 }
2406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2407                 NDR_PULL_ALLOC_N(ndr, r->older_keys, r->num_older_keys);
2408                 _mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2409                 NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
2410                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2411                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
2412                 }
2413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
2414                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2415         }
2416         if (ndr_flags & NDR_BUFFERS) {
2417                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2418                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2419                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2420                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2421                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2422                 }
2423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2424                 _mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2425                 NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
2426                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
2427                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->service_keys[cntr_service_keys_0]));
2428                 }
2429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
2430                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2431                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2432                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2433                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2434                 }
2435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2436                 _mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2437                 NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
2438                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2439                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
2440                 }
2441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
2442         }
2443         return NDR_ERR_SUCCESS;
2444 }
2445
2446 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr4 *r)
2447 {
2448         uint32_t cntr_keys_0;
2449         uint32_t cntr_service_keys_0;
2450         uint32_t cntr_old_keys_0;
2451         uint32_t cntr_older_keys_0;
2452         ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr4");
2453         ndr->depth++;
2454         ndr_print_uint16(ndr, "num_keys", r->num_keys);
2455         ndr_print_uint16(ndr, "num_service_keys", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->num_service_keys);
2456         ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
2457         ndr_print_uint16(ndr, "num_older_keys", r->num_older_keys);
2458         ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
2459         ndr_print_uint32(ndr, "default_iteration_count", r->default_iteration_count);
2460         ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
2461         ndr->depth++;
2462         for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
2463                 char *idx_0=NULL;
2464                 if (asprintf(&idx_0, "[%d]", cntr_keys_0) != -1) {
2465                         ndr_print_package_PrimaryKerberosKey4(ndr, "keys", &r->keys[cntr_keys_0]);
2466                         free(idx_0);
2467                 }
2468         }
2469         ndr->depth--;
2470         ndr->print(ndr, "%s: ARRAY(%d)", "service_keys", (int)r->num_service_keys);
2471         ndr->depth++;
2472         for (cntr_service_keys_0=0;cntr_service_keys_0<r->num_service_keys;cntr_service_keys_0++) {
2473                 char *idx_0=NULL;
2474                 if (asprintf(&idx_0, "[%d]", cntr_service_keys_0) != -1) {
2475                         ndr_print_package_PrimaryKerberosKey4(ndr, "service_keys", &r->service_keys[cntr_service_keys_0]);
2476                         free(idx_0);
2477                 }
2478         }
2479         ndr->depth--;
2480         ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2481         ndr->depth++;
2482         for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2483                 char *idx_0=NULL;
2484                 if (asprintf(&idx_0, "[%d]", cntr_old_keys_0) != -1) {
2485                         ndr_print_package_PrimaryKerberosKey4(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2486                         free(idx_0);
2487                 }
2488         }
2489         ndr->depth--;
2490         ndr->print(ndr, "%s: ARRAY(%d)", "older_keys", (int)r->num_older_keys);
2491         ndr->depth++;
2492         for (cntr_older_keys_0=0;cntr_older_keys_0<r->num_older_keys;cntr_older_keys_0++) {
2493                 char *idx_0=NULL;
2494                 if (asprintf(&idx_0, "[%d]", cntr_older_keys_0) != -1) {
2495                         ndr_print_package_PrimaryKerberosKey4(ndr, "older_keys", &r->older_keys[cntr_older_keys_0]);
2496                         free(idx_0);
2497                 }
2498         }
2499         ndr->depth--;
2500         ndr->depth--;
2501 }
2502
2503 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr(struct ndr_push *ndr, int ndr_flags, const union package_PrimaryKerberosCtr *r)
2504 {
2505         if (ndr_flags & NDR_SCALARS) {
2506                 int level = ndr_push_get_switch_value(ndr, r);
2507                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2508                 switch (level) {
2509                         case 3: {
2510                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2511                         break; }
2512
2513                         case 4: {
2514                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2515                         break; }
2516
2517                         default:
2518                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2519                 }
2520         }
2521         if (ndr_flags & NDR_BUFFERS) {
2522                 int level = ndr_push_get_switch_value(ndr, r);
2523                 switch (level) {
2524                         case 3:
2525                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2526                         break;
2527
2528                         case 4:
2529                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2530                         break;
2531
2532                         default:
2533                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2534                 }
2535         }
2536         return NDR_ERR_SUCCESS;
2537 }
2538
2539 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr(struct ndr_pull *ndr, int ndr_flags, union package_PrimaryKerberosCtr *r)
2540 {
2541         int level;
2542         level = ndr_pull_get_switch_value(ndr, r);
2543         if (ndr_flags & NDR_SCALARS) {
2544                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2545                 switch (level) {
2546                         case 3: {
2547                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2548                         break; }
2549
2550                         case 4: {
2551                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2552                         break; }
2553
2554                         default:
2555                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2556                 }
2557         }
2558         if (ndr_flags & NDR_BUFFERS) {
2559                 switch (level) {
2560                         case 3:
2561                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2562                         break;
2563
2564                         case 4:
2565                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2566                         break;
2567
2568                         default:
2569                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2570                 }
2571         }
2572         return NDR_ERR_SUCCESS;
2573 }
2574
2575 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr(struct ndr_print *ndr, const char *name, const union package_PrimaryKerberosCtr *r)
2576 {
2577         int level;
2578         level = ndr_print_get_switch_value(ndr, r);
2579         ndr_print_union(ndr, name, level, "package_PrimaryKerberosCtr");
2580         switch (level) {
2581                 case 3:
2582                         ndr_print_package_PrimaryKerberosCtr3(ndr, "ctr3", &r->ctr3);
2583                 break;
2584
2585                 case 4:
2586                         ndr_print_package_PrimaryKerberosCtr4(ndr, "ctr4", &r->ctr4);
2587                 break;
2588
2589                 default:
2590                         ndr_print_bad_level(ndr, name, level);
2591         }
2592 }
2593
2594 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryKerberosBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosBlob *r)
2595 {
2596         if (ndr_flags & NDR_SCALARS) {
2597                 NDR_CHECK(ndr_push_align(ndr, 5));
2598                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
2599                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2600                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
2601                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2603         }
2604         if (ndr_flags & NDR_BUFFERS) {
2605                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2606         }
2607         return NDR_ERR_SUCCESS;
2608 }
2609
2610 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryKerberosBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosBlob *r)
2611 {
2612         if (ndr_flags & NDR_SCALARS) {
2613                 NDR_CHECK(ndr_pull_align(ndr, 5));
2614                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
2615                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
2616                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
2617                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2618                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2619         }
2620         if (ndr_flags & NDR_BUFFERS) {
2621                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2622         }
2623         return NDR_ERR_SUCCESS;
2624 }
2625
2626 _PUBLIC_ void ndr_print_package_PrimaryKerberosBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosBlob *r)
2627 {
2628         ndr_print_struct(ndr, name, "package_PrimaryKerberosBlob");
2629         ndr->depth++;
2630         ndr_print_uint16(ndr, "version", r->version);
2631         ndr_print_uint16(ndr, "flags", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flags);
2632         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
2633         ndr_print_package_PrimaryKerberosCtr(ndr, "ctr", &r->ctr);
2634         ndr->depth--;
2635 }
2636
2637 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryCLEARTEXTBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryCLEARTEXTBlob *r)
2638 {
2639         if (ndr_flags & NDR_SCALARS) {
2640                 NDR_CHECK(ndr_push_align(ndr, 4));
2641                 {
2642                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2644                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->cleartext));
2645                         ndr->flags = _flags_save_DATA_BLOB;
2646                 }
2647                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2648         }
2649         if (ndr_flags & NDR_BUFFERS) {
2650         }
2651         return NDR_ERR_SUCCESS;
2652 }
2653
2654 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryCLEARTEXTBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryCLEARTEXTBlob *r)
2655 {
2656         if (ndr_flags & NDR_SCALARS) {
2657                 NDR_CHECK(ndr_pull_align(ndr, 4));
2658                 {
2659                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2661                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->cleartext));
2662                         ndr->flags = _flags_save_DATA_BLOB;
2663                 }
2664                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2665         }
2666         if (ndr_flags & NDR_BUFFERS) {
2667         }
2668         return NDR_ERR_SUCCESS;
2669 }
2670
2671 _PUBLIC_ void ndr_print_package_PrimaryCLEARTEXTBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryCLEARTEXTBlob *r)
2672 {
2673         ndr_print_struct(ndr, name, "package_PrimaryCLEARTEXTBlob");
2674         ndr->depth++;
2675         ndr_print_DATA_BLOB(ndr, "cleartext", r->cleartext);
2676         ndr->depth--;
2677 }
2678
2679 static enum ndr_err_code ndr_push_package_PrimaryWDigestHash(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestHash *r)
2680 {
2681         {
2682                 uint32_t _flags_save_STRUCT = ndr->flags;
2683                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2684                 if (ndr_flags & NDR_SCALARS) {
2685                         NDR_CHECK(ndr_push_align(ndr, 1));
2686                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2687                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2688                 }
2689                 if (ndr_flags & NDR_BUFFERS) {
2690                 }
2691                 ndr->flags = _flags_save_STRUCT;
2692         }
2693         return NDR_ERR_SUCCESS;
2694 }
2695
2696 static enum ndr_err_code ndr_pull_package_PrimaryWDigestHash(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestHash *r)
2697 {
2698         {
2699                 uint32_t _flags_save_STRUCT = ndr->flags;
2700                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2701                 if (ndr_flags & NDR_SCALARS) {
2702                         NDR_CHECK(ndr_pull_align(ndr, 1));
2703                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2704                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2705                 }
2706                 if (ndr_flags & NDR_BUFFERS) {
2707                 }
2708                 ndr->flags = _flags_save_STRUCT;
2709         }
2710         return NDR_ERR_SUCCESS;
2711 }
2712
2713 _PUBLIC_ void ndr_print_package_PrimaryWDigestHash(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestHash *r)
2714 {
2715         ndr_print_struct(ndr, name, "package_PrimaryWDigestHash");
2716         {
2717                 uint32_t _flags_save_STRUCT = ndr->flags;
2718                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2719                 ndr->depth++;
2720                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2721                 ndr->depth--;
2722                 ndr->flags = _flags_save_STRUCT;
2723         }
2724 }
2725
2726 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryWDigestBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestBlob *r)
2727 {
2728         uint32_t cntr_hashes_0;
2729         if (ndr_flags & NDR_SCALARS) {
2730                 NDR_CHECK(ndr_push_align(ndr, 4));
2731                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0x31));
2732                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0x01));
2733                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_hashes));
2734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2735                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, 0));
2736                 for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2737                         NDR_CHECK(ndr_push_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2738                 }
2739                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2740         }
2741         if (ndr_flags & NDR_BUFFERS) {
2742         }
2743         return NDR_ERR_SUCCESS;
2744 }
2745
2746 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryWDigestBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestBlob *r)
2747 {
2748         uint32_t cntr_hashes_0;
2749         TALLOC_CTX *_mem_save_hashes_0;
2750         if (ndr_flags & NDR_SCALARS) {
2751                 NDR_CHECK(ndr_pull_align(ndr, 4));
2752                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
2753                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown2));
2754                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_hashes));
2755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
2756                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->uuknown4));
2757                 NDR_PULL_ALLOC_N(ndr, r->hashes, r->num_hashes);
2758                 _mem_save_hashes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2759                 NDR_PULL_SET_MEM_CTX(ndr, r->hashes, 0);
2760                 for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2761                         NDR_CHECK(ndr_pull_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2762                 }
2763                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hashes_0, 0);
2764                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2765         }
2766         if (ndr_flags & NDR_BUFFERS) {
2767         }
2768         return NDR_ERR_SUCCESS;
2769 }
2770
2771 _PUBLIC_ void ndr_print_package_PrimaryWDigestBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestBlob *r)
2772 {
2773         uint32_t cntr_hashes_0;
2774         ndr_print_struct(ndr, name, "package_PrimaryWDigestBlob");
2775         ndr->depth++;
2776         ndr_print_uint16(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x31:r->unknown1);
2777         ndr_print_uint8(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x01:r->unknown2);
2778         ndr_print_uint8(ndr, "num_hashes", r->num_hashes);
2779         ndr_print_uint32(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
2780         ndr_print_udlong(ndr, "uuknown4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->uuknown4);
2781         ndr->print(ndr, "%s: ARRAY(%d)", "hashes", (int)r->num_hashes);
2782         ndr->depth++;
2783         for (cntr_hashes_0=0;cntr_hashes_0<r->num_hashes;cntr_hashes_0++) {
2784                 char *idx_0=NULL;
2785                 if (asprintf(&idx_0, "[%d]", cntr_hashes_0) != -1) {
2786                         ndr_print_package_PrimaryWDigestHash(ndr, "hashes", &r->hashes[cntr_hashes_0]);
2787                         free(idx_0);
2788                 }
2789         }
2790         ndr->depth--;
2791         ndr->depth--;
2792 }
2793
2794 static enum ndr_err_code ndr_push_AuthInfoNone(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoNone *r)
2795 {
2796         if (ndr_flags & NDR_SCALARS) {
2797                 NDR_CHECK(ndr_push_align(ndr, 4));
2798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2799                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2800         }
2801         if (ndr_flags & NDR_BUFFERS) {
2802         }
2803         return NDR_ERR_SUCCESS;
2804 }
2805
2806 static enum ndr_err_code ndr_pull_AuthInfoNone(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoNone *r)
2807 {
2808         if (ndr_flags & NDR_SCALARS) {
2809                 NDR_CHECK(ndr_pull_align(ndr, 4));
2810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2811                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2812         }
2813         if (ndr_flags & NDR_BUFFERS) {
2814         }
2815         return NDR_ERR_SUCCESS;
2816 }
2817
2818 _PUBLIC_ void ndr_print_AuthInfoNone(struct ndr_print *ndr, const char *name, const struct AuthInfoNone *r)
2819 {
2820         ndr_print_struct(ndr, name, "AuthInfoNone");
2821         ndr->depth++;
2822         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->size);
2823         ndr->depth--;
2824 }
2825
2826 static enum ndr_err_code ndr_push_AuthInfoNT4Owf(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoNT4Owf *r)
2827 {
2828         if (ndr_flags & NDR_SCALARS) {
2829                 NDR_CHECK(ndr_push_align(ndr, 4));
2830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 16));
2831                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->password));
2832                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2833         }
2834         if (ndr_flags & NDR_BUFFERS) {
2835         }
2836         return NDR_ERR_SUCCESS;
2837 }
2838
2839 static enum ndr_err_code ndr_pull_AuthInfoNT4Owf(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoNT4Owf *r)
2840 {
2841         if (ndr_flags & NDR_SCALARS) {
2842                 NDR_CHECK(ndr_pull_align(ndr, 4));
2843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2844                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->password));
2845                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2846         }
2847         if (ndr_flags & NDR_BUFFERS) {
2848         }
2849         return NDR_ERR_SUCCESS;
2850 }
2851
2852 _PUBLIC_ void ndr_print_AuthInfoNT4Owf(struct ndr_print *ndr, const char *name, const struct AuthInfoNT4Owf *r)
2853 {
2854         ndr_print_struct(ndr, name, "AuthInfoNT4Owf");
2855         ndr->depth++;
2856         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?16:r->size);
2857         ndr_print_samr_Password(ndr, "password", &r->password);
2858         ndr->depth--;
2859 }
2860
2861 static enum ndr_err_code ndr_push_AuthInfoClear(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoClear *r)
2862 {
2863         if (ndr_flags & NDR_SCALARS) {
2864                 NDR_CHECK(ndr_push_align(ndr, 4));
2865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2866                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
2867                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2868         }
2869         if (ndr_flags & NDR_BUFFERS) {
2870         }
2871         return NDR_ERR_SUCCESS;
2872 }
2873
2874 static enum ndr_err_code ndr_pull_AuthInfoClear(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoClear *r)
2875 {
2876         if (ndr_flags & NDR_SCALARS) {
2877                 NDR_CHECK(ndr_pull_align(ndr, 4));
2878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2879                 NDR_PULL_ALLOC_N(ndr, r->password, r->size);
2880                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
2881                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2882         }
2883         if (ndr_flags & NDR_BUFFERS) {
2884         }
2885         return NDR_ERR_SUCCESS;
2886 }
2887
2888 _PUBLIC_ void ndr_print_AuthInfoClear(struct ndr_print *ndr, const char *name, const struct AuthInfoClear *r)
2889 {
2890         ndr_print_struct(ndr, name, "AuthInfoClear");
2891         ndr->depth++;
2892         ndr_print_uint32(ndr, "size", r->size);
2893         ndr_print_array_uint8(ndr, "password", r->password, r->size);
2894         ndr->depth--;
2895 }
2896
2897 static enum ndr_err_code ndr_push_AuthInfoVersion(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoVersion *r)
2898 {
2899         if (ndr_flags & NDR_SCALARS) {
2900                 NDR_CHECK(ndr_push_align(ndr, 4));
2901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 4));
2902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2903                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2904         }
2905         if (ndr_flags & NDR_BUFFERS) {
2906         }
2907         return NDR_ERR_SUCCESS;
2908 }
2909
2910 static enum ndr_err_code ndr_pull_AuthInfoVersion(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoVersion *r)
2911 {
2912         if (ndr_flags & NDR_SCALARS) {
2913                 NDR_CHECK(ndr_pull_align(ndr, 4));
2914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2916                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2917         }
2918         if (ndr_flags & NDR_BUFFERS) {
2919         }
2920         return NDR_ERR_SUCCESS;
2921 }
2922
2923 _PUBLIC_ void ndr_print_AuthInfoVersion(struct ndr_print *ndr, const char *name, const struct AuthInfoVersion *r)
2924 {
2925         ndr_print_struct(ndr, name, "AuthInfoVersion");
2926         ndr->depth++;
2927         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?4:r->size);
2928         ndr_print_uint32(ndr, "version", r->version);
2929         ndr->depth--;
2930 }
2931
2932 static enum ndr_err_code ndr_push_AuthInfo(struct ndr_push *ndr, int ndr_flags, const union AuthInfo *r)
2933 {
2934         if (ndr_flags & NDR_SCALARS) {
2935                 int level = ndr_push_get_switch_value(ndr, r);
2936                 NDR_CHECK(ndr_push_union_align(ndr, 4));
2937                 switch (level) {
2938                         case TRUST_AUTH_TYPE_NONE: {
2939                                 NDR_CHECK(ndr_push_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
2940                         break; }
2941
2942                         case TRUST_AUTH_TYPE_NT4OWF: {
2943                                 NDR_CHECK(ndr_push_AuthInfoNT4Owf(ndr, NDR_SCALARS, &r->nt4owf));
2944                         break; }
2945
2946                         case TRUST_AUTH_TYPE_CLEAR: {
2947                                 NDR_CHECK(ndr_push_AuthInfoClear(ndr, NDR_SCALARS, &r->clear));
2948                         break; }
2949
2950                         case TRUST_AUTH_TYPE_VERSION: {
2951                                 NDR_CHECK(ndr_push_AuthInfoVersion(ndr, NDR_SCALARS, &r->version));
2952                         break; }
2953
2954                         default:
2955                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2956                 }
2957         }
2958         if (ndr_flags & NDR_BUFFERS) {
2959                 int level = ndr_push_get_switch_value(ndr, r);
2960                 switch (level) {
2961                         case TRUST_AUTH_TYPE_NONE:
2962                         break;
2963
2964                         case TRUST_AUTH_TYPE_NT4OWF:
2965                         break;
2966
2967                         case TRUST_AUTH_TYPE_CLEAR:
2968                         break;
2969
2970                         case TRUST_AUTH_TYPE_VERSION:
2971                         break;
2972
2973                         default:
2974                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2975                 }
2976         }
2977         return NDR_ERR_SUCCESS;
2978 }
2979
2980 static enum ndr_err_code ndr_pull_AuthInfo(struct ndr_pull *ndr, int ndr_flags, union AuthInfo *r)
2981 {
2982         int level;
2983         level = ndr_pull_get_switch_value(ndr, r);
2984         if (ndr_flags & NDR_SCALARS) {
2985                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
2986                 switch (level) {
2987                         case TRUST_AUTH_TYPE_NONE: {
2988                                 NDR_CHECK(ndr_pull_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
2989                         break; }
2990
2991                         case TRUST_AUTH_TYPE_NT4OWF: {
2992                                 NDR_CHECK(ndr_pull_AuthInfoNT4Owf(ndr, NDR_SCALARS, &r->nt4owf));
2993                         break; }
2994
2995                         case TRUST_AUTH_TYPE_CLEAR: {
2996                                 NDR_CHECK(ndr_pull_AuthInfoClear(ndr, NDR_SCALARS, &r->clear));
2997                         break; }
2998
2999                         case TRUST_AUTH_TYPE_VERSION: {
3000                                 NDR_CHECK(ndr_pull_AuthInfoVersion(ndr, NDR_SCALARS, &r->version));
3001                         break; }
3002
3003                         default:
3004                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3005                 }
3006         }
3007         if (ndr_flags & NDR_BUFFERS) {
3008                 switch (level) {
3009                         case TRUST_AUTH_TYPE_NONE:
3010                         break;
3011
3012                         case TRUST_AUTH_TYPE_NT4OWF:
3013                         break;
3014
3015                         case TRUST_AUTH_TYPE_CLEAR:
3016                         break;
3017
3018                         case TRUST_AUTH_TYPE_VERSION:
3019                         break;
3020
3021                         default:
3022                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3023                 }
3024         }
3025         return NDR_ERR_SUCCESS;
3026 }
3027
3028 _PUBLIC_ void ndr_print_AuthInfo(struct ndr_print *ndr, const char *name, const union AuthInfo *r)
3029 {
3030         int level;
3031         level = ndr_print_get_switch_value(ndr, r);
3032         ndr_print_union(ndr, name, level, "AuthInfo");
3033         switch (level) {
3034                 case TRUST_AUTH_TYPE_NONE:
3035                         ndr_print_AuthInfoNone(ndr, "none", &r->none);
3036                 break;
3037
3038                 case TRUST_AUTH_TYPE_NT4OWF:
3039                         ndr_print_AuthInfoNT4Owf(ndr, "nt4owf", &r->nt4owf);
3040                 break;
3041
3042                 case TRUST_AUTH_TYPE_CLEAR:
3043                         ndr_print_AuthInfoClear(ndr, "clear", &r->clear);
3044                 break;
3045
3046                 case TRUST_AUTH_TYPE_VERSION:
3047                         ndr_print_AuthInfoVersion(ndr, "version", &r->version);
3048                 break;
3049
3050                 default:
3051                         ndr_print_bad_level(ndr, name, level);
3052         }
3053 }
3054
3055 _PUBLIC_ enum ndr_err_code ndr_push_AuthenticationInformation(struct ndr_push *ndr, int ndr_flags, const struct AuthenticationInformation *r)
3056 {
3057         if (ndr_flags & NDR_SCALARS) {
3058                 NDR_CHECK(ndr_push_align(ndr, 4));
3059                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->LastUpdateTime));
3060                 NDR_CHECK(ndr_push_lsa_TrustAuthType(ndr, NDR_SCALARS, r->AuthType));
3061                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->AuthInfo, r->AuthType));
3062                 NDR_CHECK(ndr_push_AuthInfo(ndr, NDR_SCALARS, &r->AuthInfo));
3063                 {
3064                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
3065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3066                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
3067                         ndr->flags = _flags_save_DATA_BLOB;
3068                 }
3069                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3070         }
3071         if (ndr_flags & NDR_BUFFERS) {
3072         }
3073         return NDR_ERR_SUCCESS;
3074 }
3075
3076 _PUBLIC_ enum ndr_err_code ndr_pull_AuthenticationInformation(struct ndr_pull *ndr, int ndr_flags, struct AuthenticationInformation *r)
3077 {
3078         if (ndr_flags & NDR_SCALARS) {
3079                 NDR_CHECK(ndr_pull_align(ndr, 4));
3080                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->LastUpdateTime));
3081                 NDR_CHECK(ndr_pull_lsa_TrustAuthType(ndr, NDR_SCALARS, &r->AuthType));
3082                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->AuthInfo, r->AuthType));
3083                 NDR_CHECK(ndr_pull_AuthInfo(ndr, NDR_SCALARS, &r->AuthInfo));
3084                 {
3085                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
3086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3087                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
3088                         ndr->flags = _flags_save_DATA_BLOB;
3089                 }
3090                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3091         }
3092         if (ndr_flags & NDR_BUFFERS) {
3093         }
3094         return NDR_ERR_SUCCESS;
3095 }
3096
3097 _PUBLIC_ void ndr_print_AuthenticationInformation(struct ndr_print *ndr, const char *name, const struct AuthenticationInformation *r)
3098 {
3099         ndr_print_struct(ndr, name, "AuthenticationInformation");
3100         ndr->depth++;
3101         ndr_print_NTTIME(ndr, "LastUpdateTime", r->LastUpdateTime);
3102         ndr_print_lsa_TrustAuthType(ndr, "AuthType", r->AuthType);
3103         ndr_print_set_switch_value(ndr, &r->AuthInfo, r->AuthType);
3104         ndr_print_AuthInfo(ndr, "AuthInfo", &r->AuthInfo);
3105         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
3106         ndr->depth--;
3107 }
3108
3109 _PUBLIC_ size_t ndr_size_trustAuthInOutBlob(const struct trustAuthInOutBlob *r, struct smb_iconv_convenience *ic, int flags)
3110 {
3111         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob, ic);
3112 }
3113
3114 _PUBLIC_ enum ndr_err_code ndr_push_trustCurrentPasswords(struct ndr_push *ndr, int ndr_flags, const struct trustCurrentPasswords *r)
3115 {
3116         uint32_t cntr_current_0;
3117         if (ndr_flags & NDR_SCALARS) {
3118                 NDR_CHECK(ndr_push_align(ndr, 5));
3119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3120                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3121                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->current[cntr_current_0]));
3122                 }
3123                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3124         }
3125         if (ndr_flags & NDR_BUFFERS) {
3126                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3127                         if (r->current[cntr_current_0]) {
3128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->current[cntr_current_0]));
3129                                 NDR_CHECK(ndr_push_AuthenticationInformation(ndr, NDR_SCALARS, r->current[cntr_current_0]));
3130                         }
3131                 }
3132         }
3133         return NDR_ERR_SUCCESS;
3134 }
3135
3136 _PUBLIC_ enum ndr_err_code ndr_pull_trustCurrentPasswords(struct ndr_pull *ndr, int ndr_flags, struct trustCurrentPasswords *r)
3137 {
3138         uint32_t _ptr_current;
3139         uint32_t cntr_current_0;
3140         TALLOC_CTX *_mem_save_current_0;
3141         TALLOC_CTX *_mem_save_current_1;
3142         if (ndr_flags & NDR_SCALARS) {
3143                 NDR_CHECK(ndr_pull_align(ndr, 5));
3144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3145                 NDR_PULL_ALLOC_N(ndr, r->current, r->count);
3146                 _mem_save_current_0 = NDR_PULL_GET_MEM_CTX(ndr);
3147                 NDR_PULL_SET_MEM_CTX(ndr, r->current, 0);
3148                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3149                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_current));
3150                         if (_ptr_current) {
3151                                 NDR_PULL_ALLOC(ndr, r->current[cntr_current_0]);
3152                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->current[cntr_current_0], _ptr_current));
3153                         } else {
3154                                 r->current[cntr_current_0] = NULL;
3155                         }
3156                 }
3157                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_0, 0);
3158                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3159         }
3160         if (ndr_flags & NDR_BUFFERS) {
3161                 _mem_save_current_0 = NDR_PULL_GET_MEM_CTX(ndr);
3162                 NDR_PULL_SET_MEM_CTX(ndr, r->current, 0);
3163                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3164                         if (r->current[cntr_current_0]) {
3165                                 uint32_t _relative_save_offset;
3166                                 _relative_save_offset = ndr->offset;
3167                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->current[cntr_current_0]));
3168                                 _mem_save_current_1 = NDR_PULL_GET_MEM_CTX(ndr);
3169                                 NDR_PULL_SET_MEM_CTX(ndr, r->current[cntr_current_0], 0);
3170                                 NDR_CHECK(ndr_pull_AuthenticationInformation(ndr, NDR_SCALARS, r->current[cntr_current_0]));
3171                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_1, 0);
3172                                 if (ndr->offset > ndr->relative_highest_offset) {
3173                                         ndr->relative_highest_offset = ndr->offset;
3174                                 }
3175                                 ndr->offset = _relative_save_offset;
3176                         }
3177                 }
3178                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_0, 0);
3179         }
3180         return NDR_ERR_SUCCESS;
3181 }
3182
3183 _PUBLIC_ void ndr_print_trustCurrentPasswords(struct ndr_print *ndr, const char *name, const struct trustCurrentPasswords *r)
3184 {
3185         uint32_t cntr_current_0;
3186         ndr_print_struct(ndr, name, "trustCurrentPasswords");
3187         ndr->depth++;
3188         ndr_print_uint32(ndr, "count", r->count);
3189         ndr->print(ndr, "%s: ARRAY(%d)", "current", (int)r->count);
3190         ndr->depth++;
3191         for (cntr_current_0=0;cntr_current_0<r->count;cntr_current_0++) {
3192                 char *idx_0=NULL;
3193                 if (asprintf(&idx_0, "[%d]", cntr_current_0) != -1) {
3194                         ndr_print_ptr(ndr, "current", r->current[cntr_current_0]);
3195                         ndr->depth++;
3196                         if (r->current[cntr_current_0]) {
3197                                 ndr_print_AuthenticationInformation(ndr, "current", r->current[cntr_current_0]);
3198                         }
3199                         ndr->depth--;
3200                         free(idx_0);
3201                 }
3202         }
3203         ndr->depth--;
3204         ndr->depth--;
3205 }
3206
3207 _PUBLIC_ size_t ndr_size_trustCurrentPasswords(const struct trustCurrentPasswords *r, struct smb_iconv_convenience *ic, int flags)
3208 {
3209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_trustCurrentPasswords, ic);
3210 }
3211
3212 _PUBLIC_ enum ndr_err_code ndr_push_trustDomainPasswords(struct ndr_push *ndr, int ndr_flags, const struct trustDomainPasswords *r)
3213 {
3214         if (ndr_flags & NDR_SCALARS) {
3215                 NDR_CHECK(ndr_push_align(ndr, 5));
3216                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->confounder, 512));
3217                 {
3218                         struct ndr_push *_ndr_outgoing;
3219                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_outgoing, 0, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
3220                         NDR_CHECK(ndr_push_trustCurrentPasswords(_ndr_outgoing, NDR_SCALARS|NDR_BUFFERS, &r->outgoing));
3221                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_outgoing, 0, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
3222                 }
3223                 {
3224                         struct ndr_push *_ndr_incoming;
3225                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_incoming, 0, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
3226                         NDR_CHECK(ndr_push_trustCurrentPasswords(_ndr_incoming, NDR_SCALARS|NDR_BUFFERS, &r->incoming));
3227                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_incoming, 0, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
3228                 }
3229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
3230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
3231                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3232         }
3233         if (ndr_flags & NDR_BUFFERS) {
3234         }
3235         return NDR_ERR_SUCCESS;
3236 }
3237
3238 _PUBLIC_ void ndr_print_trustDomainPasswords(struct ndr_print *ndr, const char *name, const struct trustDomainPasswords *r)
3239 {
3240         ndr_print_struct(ndr, name, "trustDomainPasswords");
3241         ndr->depth++;
3242         ndr_print_array_uint8(ndr, "confounder", r->confounder, 512);
3243         ndr_print_trustCurrentPasswords(ndr, "outgoing", &r->outgoing);
3244         ndr_print_trustCurrentPasswords(ndr, "incoming", &r->incoming);
3245         ndr_print_uint32(ndr, "outgoing_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags):r->outgoing_size);
3246         ndr_print_uint32(ndr, "incoming_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags):r->incoming_size);
3247         ndr->depth--;
3248 }
3249
3250 _PUBLIC_ enum ndr_err_code ndr_push_DsCompressedChunk(struct ndr_push *ndr, int ndr_flags, const struct DsCompressedChunk *r)
3251 {
3252         if (ndr_flags & NDR_SCALARS) {
3253                 NDR_CHECK(ndr_push_align(ndr, 4));
3254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->marker));
3255                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
3256                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3257         }
3258         if (ndr_flags & NDR_BUFFERS) {
3259         }
3260         return NDR_ERR_SUCCESS;
3261 }
3262
3263 _PUBLIC_ enum ndr_err_code ndr_pull_DsCompressedChunk(struct ndr_pull *ndr, int ndr_flags, struct DsCompressedChunk *r)
3264 {
3265         if (ndr_flags & NDR_SCALARS) {
3266                 NDR_CHECK(ndr_pull_align(ndr, 4));
3267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->marker));
3268                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
3269                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3270         }
3271         if (ndr_flags & NDR_BUFFERS) {
3272         }
3273         return NDR_ERR_SUCCESS;
3274 }
3275
3276 _PUBLIC_ void ndr_print_DsCompressedChunk(struct ndr_print *ndr, const char *name, const struct DsCompressedChunk *r)
3277 {
3278         ndr_print_struct(ndr, name, "DsCompressedChunk");
3279         ndr->depth++;
3280         ndr_print_uint32(ndr, "marker", r->marker);
3281         ndr_print_DATA_BLOB(ndr, "data", r->data);
3282         ndr->depth--;
3283 }
3284
3285 static enum ndr_err_code ndr_push_ExtendedErrorAString(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorAString *r)
3286 {
3287         if (ndr_flags & NDR_SCALARS) {
3288                 NDR_CHECK(ndr_push_align(ndr, 5));
3289                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
3290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3291                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3292         }
3293         if (ndr_flags & NDR_BUFFERS) {
3294                 if (r->string) {
3295                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->__size));
3296                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->__size, sizeof(uint8_t), CH_DOS));
3297                 }
3298         }
3299         return NDR_ERR_SUCCESS;
3300 }
3301
3302 static enum ndr_err_code ndr_pull_ExtendedErrorAString(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorAString *r)
3303 {
3304         uint32_t _ptr_string;
3305         TALLOC_CTX *_mem_save_string_0;
3306         if (ndr_flags & NDR_SCALARS) {
3307                 NDR_CHECK(ndr_pull_align(ndr, 5));
3308                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__size));
3309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3310                 if (_ptr_string) {
3311                         NDR_PULL_ALLOC(ndr, r->string);
3312                 } else {
3313                         r->string = NULL;
3314                 }
3315                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3316         }
3317         if (ndr_flags & NDR_BUFFERS) {
3318                 if (r->string) {
3319                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3320                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
3322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint8_t), CH_DOS));
3323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3324                 }
3325                 if (r->string) {
3326                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->__size));
3327                 }
3328         }
3329         return NDR_ERR_SUCCESS;
3330 }
3331
3332 _PUBLIC_ void ndr_print_ExtendedErrorAString(struct ndr_print *ndr, const char *name, const struct ExtendedErrorAString *r)
3333 {
3334         ndr_print_struct(ndr, name, "ExtendedErrorAString");
3335         ndr->depth++;
3336         ndr_print_uint16(ndr, "__size", r->__size);
3337         ndr_print_ptr(ndr, "string", r->string);
3338         ndr->depth++;
3339         if (r->string) {
3340                 ndr_print_string(ndr, "string", r->string);
3341         }
3342         ndr->depth--;
3343         ndr->depth--;
3344 }
3345
3346 static enum ndr_err_code ndr_push_ExtendedErrorUString(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorUString *r)
3347 {
3348         if (ndr_flags & NDR_SCALARS) {
3349                 NDR_CHECK(ndr_push_align(ndr, 5));
3350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
3351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3352                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3353         }
3354         if (ndr_flags & NDR_BUFFERS) {
3355                 if (r->string) {
3356                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->__size));
3357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->__size, sizeof(uint16_t), CH_UTF16));
3358                 }
3359         }
3360         return NDR_ERR_SUCCESS;
3361 }
3362
3363 static enum ndr_err_code ndr_pull_ExtendedErrorUString(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorUString *r)
3364 {
3365         uint32_t _ptr_string;
3366         TALLOC_CTX *_mem_save_string_0;
3367         if (ndr_flags & NDR_SCALARS) {
3368                 NDR_CHECK(ndr_pull_align(ndr, 5));
3369                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__size));
3370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3371                 if (_ptr_string) {
3372                         NDR_PULL_ALLOC(ndr, r->string);
3373                 } else {
3374                         r->string = NULL;
3375                 }
3376                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3377         }
3378         if (ndr_flags & NDR_BUFFERS) {
3379                 if (r->string) {
3380                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3381                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3382                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
3383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
3384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3385                 }
3386                 if (r->string) {
3387                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->__size));
3388                 }
3389         }
3390         return NDR_ERR_SUCCESS;
3391 }
3392
3393 _PUBLIC_ void ndr_print_ExtendedErrorUString(struct ndr_print *ndr, const char *name, const struct ExtendedErrorUString *r)
3394 {
3395         ndr_print_struct(ndr, name, "ExtendedErrorUString");
3396         ndr->depth++;
3397         ndr_print_uint16(ndr, "__size", r->__size);
3398         ndr_print_ptr(ndr, "string", r->string);
3399         ndr->depth++;
3400         if (r->string) {
3401                 ndr_print_string(ndr, "string", r->string);
3402         }
3403         ndr->depth--;
3404         ndr->depth--;
3405 }
3406
3407 static enum ndr_err_code ndr_push_ExtendedErrorBlob(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorBlob *r)
3408 {
3409         if (ndr_flags & NDR_SCALARS) {
3410                 NDR_CHECK(ndr_push_align(ndr, 5));
3411                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
3412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
3413                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3414         }
3415         if (ndr_flags & NDR_BUFFERS) {
3416                 if (r->data) {
3417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
3418                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
3419                 }
3420         }
3421         return NDR_ERR_SUCCESS;
3422 }
3423
3424 static enum ndr_err_code ndr_pull_ExtendedErrorBlob(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorBlob *r)
3425 {
3426         uint32_t _ptr_data;
3427         TALLOC_CTX *_mem_save_data_0;
3428         if (ndr_flags & NDR_SCALARS) {
3429                 NDR_CHECK(ndr_pull_align(ndr, 5));
3430                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
3431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
3432                 if (_ptr_data) {
3433                         NDR_PULL_ALLOC(ndr, r->data);
3434                 } else {
3435                         r->data = NULL;
3436                 }
3437                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3438         }
3439         if (ndr_flags & NDR_BUFFERS) {
3440                 if (r->data) {
3441                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
3442                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
3443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
3444                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
3445                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
3446                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
3447                 }
3448                 if (r->data) {
3449                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
3450                 }
3451         }
3452         return NDR_ERR_SUCCESS;
3453 }
3454
3455 _PUBLIC_ void ndr_print_ExtendedErrorBlob(struct ndr_print *ndr, const char *name, const struct ExtendedErrorBlob *r)
3456 {
3457         ndr_print_struct(ndr, name, "ExtendedErrorBlob");
3458         ndr->depth++;
3459         ndr_print_uint16(ndr, "length", r->length);
3460         ndr_print_ptr(ndr, "data", r->data);
3461         ndr->depth++;
3462         if (r->data) {
3463                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
3464         }
3465         ndr->depth--;
3466         ndr->depth--;
3467 }
3468
3469 static enum ndr_err_code ndr_push_ExtendedErrorComputerNamePresent(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent r)
3470 {
3471         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
3472         return NDR_ERR_SUCCESS;
3473 }
3474
3475 static enum ndr_err_code ndr_pull_ExtendedErrorComputerNamePresent(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent *r)
3476 {
3477         uint16_t v;
3478         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
3479         *r = v;
3480         return NDR_ERR_SUCCESS;
3481 }
3482
3483 _PUBLIC_ void ndr_print_ExtendedErrorComputerNamePresent(struct ndr_print *ndr, const char *name, enum ExtendedErrorComputerNamePresent r)
3484 {
3485         const char *val = NULL;
3486
3487         switch (r) {
3488                 case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: val = "EXTENDED_ERROR_COMPUTER_NAME_PRESENT"; break;
3489                 case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: val = "EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT"; break;
3490         }
3491         ndr_print_enum(ndr, name, "ENUM", val, r);
3492 }
3493
3494 static enum ndr_err_code ndr_push_ExtendedErrorComputerNameU(struct ndr_push *ndr, int ndr_flags, const union ExtendedErrorComputerNameU *r)
3495 {
3496         if (ndr_flags & NDR_SCALARS) {
3497                 int level = ndr_push_get_switch_value(ndr, r);
3498                 NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, level));
3499                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3500                 switch (level) {
3501                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
3502                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
3503                         break; }
3504
3505                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: {
3506                         break; }
3507
3508                         default:
3509                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3510                 }
3511         }
3512         if (ndr_flags & NDR_BUFFERS) {
3513                 int level = ndr_push_get_switch_value(ndr, r);
3514                 switch (level) {
3515                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3516                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->name));
3517                         break;
3518
3519                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3520                         break;
3521
3522                         default:
3523                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3524                 }
3525         }
3526         return NDR_ERR_SUCCESS;
3527 }
3528
3529 static enum ndr_err_code ndr_pull_ExtendedErrorComputerNameU(struct ndr_pull *ndr, int ndr_flags, union ExtendedErrorComputerNameU *r)
3530 {
3531         int level;
3532         uint16_t _level;
3533         level = ndr_pull_get_switch_value(ndr, r);
3534         if (ndr_flags & NDR_SCALARS) {
3535                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
3536                 if (_level != level) {
3537                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3538                 }
3539                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3540                 switch (level) {
3541                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
3542                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
3543                         break; }
3544
3545                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: {
3546                         break; }
3547
3548                         default:
3549                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3550                 }
3551         }
3552         if (ndr_flags & NDR_BUFFERS) {
3553                 switch (level) {
3554                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3555                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->name));
3556                         break;
3557
3558                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3559                         break;
3560
3561                         default:
3562                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3563                 }
3564         }
3565         return NDR_ERR_SUCCESS;
3566 }
3567
3568 _PUBLIC_ void ndr_print_ExtendedErrorComputerNameU(struct ndr_print *ndr, const char *name, const union ExtendedErrorComputerNameU *r)
3569 {
3570         int level;
3571         level = ndr_print_get_switch_value(ndr, r);
3572         ndr_print_union(ndr, name, level, "ExtendedErrorComputerNameU");
3573         switch (level) {
3574                 case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3575                         ndr_print_ExtendedErrorUString(ndr, "name", &r->name);
3576                 break;
3577
3578                 case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3579                 break;
3580
3581                 default:
3582                         ndr_print_bad_level(ndr, name, level);
3583         }
3584 }
3585
3586 static enum ndr_err_code ndr_push_ExtendedErrorComputerName(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorComputerName *r)
3587 {
3588         if (ndr_flags & NDR_SCALARS) {
3589                 NDR_CHECK(ndr_push_align(ndr, 5));
3590                 NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, r->present));
3591                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->n, r->present));
3592                 NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
3593                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3594         }
3595         if (ndr_flags & NDR_BUFFERS) {
3596                 NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
3597         }
3598         return NDR_ERR_SUCCESS;
3599 }
3600
3601 static enum ndr_err_code ndr_pull_ExtendedErrorComputerName(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorComputerName *r)
3602 {
3603         if (ndr_flags & NDR_SCALARS) {
3604                 NDR_CHECK(ndr_pull_align(ndr, 5));
3605                 NDR_CHECK(ndr_pull_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, &r->present));
3606                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->n, r->present));
3607                 NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
3608                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3609         }
3610         if (ndr_flags & NDR_BUFFERS) {
3611                 NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
3612         }
3613         return NDR_ERR_SUCCESS;
3614 }
3615
3616 _PUBLIC_ void ndr_print_ExtendedErrorComputerName(struct ndr_print *ndr, const char *name, const struct ExtendedErrorComputerName *r)
3617 {
3618         ndr_print_struct(ndr, name, "ExtendedErrorComputerName");
3619         ndr->depth++;
3620         ndr_print_ExtendedErrorComputerNamePresent(ndr, "present", r->present);
3621         ndr_print_set_switch_value(ndr, &r->n, r->present);
3622         ndr_print_ExtendedErrorComputerNameU(ndr, "n", &r->n);
3623         ndr->depth--;
3624 }
3625
3626 static enum ndr_err_code ndr_push_ExtendedErrorParamType(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorParamType r)
3627 {
3628         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
3629         return NDR_ERR_SUCCESS;
3630 }
3631
3632 static enum ndr_err_code ndr_pull_ExtendedErrorParamType(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorParamType *r)
3633 {
3634         uint16_t v;
3635         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
3636         *r = v;
3637         return NDR_ERR_SUCCESS;
3638 }
3639
3640 _PUBLIC_ void ndr_print_ExtendedErrorParamType(struct ndr_print *ndr, const char *name, enum ExtendedErrorParamType r)
3641 {
3642         const char *val = NULL;
3643
3644         switch (r) {
3645                 case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: val = "EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING"; break;
3646                 case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: val = "EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING"; break;
3647                 case EXTENDED_ERROR_PARAM_TYPE_UINT32: val = "EXTENDED_ERROR_PARAM_TYPE_UINT32"; break;
3648                 case EXTENDED_ERROR_PARAM_TYPE_UINT16: val = "EXTENDED_ERROR_PARAM_TYPE_UINT16"; break;
3649                 case EXTENDED_ERROR_PARAM_TYPE_UINT64: val = "EXTENDED_ERROR_PARAM_TYPE_UINT64"; break;
3650                 case EXTENDED_ERROR_PARAM_TYPE_NONE: val = "EXTENDED_ERROR_PARAM_TYPE_NONE"; break;
3651                 case EXTENDED_ERROR_PARAM_TYPE_BLOB: val = "EXTENDED_ERROR_PARAM_TYPE_BLOB"; break;
3652         }
3653         ndr_print_enum(ndr, name, "ENUM", val, r);
3654 }
3655
3656 static enum ndr_err_code ndr_push_ExtendedErrorParamU(struct ndr_push *ndr, int ndr_flags, const union ExtendedErrorParamU *r)
3657 {
3658         if (ndr_flags & NDR_SCALARS) {
3659                 int level = ndr_push_get_switch_value(ndr, r);
3660                 NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, level));
3661                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3662                 switch (level) {
3663                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
3664                                 NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
3665                         break; }
3666
3667                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: {
3668                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->u_string));
3669                         break; }
3670
3671                         case EXTENDED_ERROR_PARAM_TYPE_UINT32: {
3672                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->uint32));
3673                         break; }
3674
3675                         case EXTENDED_ERROR_PARAM_TYPE_UINT16: {
3676                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->uint16));
3677                         break; }
3678
3679                         case EXTENDED_ERROR_PARAM_TYPE_UINT64: {
3680                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uint64));
3681                         break; }
3682
3683                         case EXTENDED_ERROR_PARAM_TYPE_NONE: {
3684                         break; }
3685
3686                         case EXTENDED_ERROR_PARAM_TYPE_BLOB: {
3687                                 NDR_CHECK(ndr_push_ExtendedErrorBlob(ndr, NDR_SCALARS, &r->blob));
3688                         break; }
3689
3690                         default:
3691                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3692                 }
3693         }
3694         if (ndr_flags & NDR_BUFFERS) {
3695                 int level = ndr_push_get_switch_value(ndr, r);
3696                 switch (level) {
3697                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3698                                 NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_BUFFERS, &r->a_string));
3699                         break;
3700
3701                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3702                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->u_string));
3703                         break;
3704
3705                         case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3706                         break;
3707
3708                         case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3709                         break;
3710
3711                         case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3712                         break;
3713
3714                         case EXTENDED_ERROR_PARAM_TYPE_NONE:
3715                         break;
3716
3717                         case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3718                                 NDR_CHECK(ndr_push_ExtendedErrorBlob(ndr, NDR_BUFFERS, &r->blob));
3719                         break;
3720
3721                         default:
3722                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3723                 }
3724         }
3725         return NDR_ERR_SUCCESS;
3726 }
3727
3728 static enum ndr_err_code ndr_pull_ExtendedErrorParamU(struct ndr_pull *ndr, int ndr_flags, union ExtendedErrorParamU *r)
3729 {
3730         int level;
3731         uint16_t _level;
3732         level = ndr_pull_get_switch_value(ndr, r);
3733         if (ndr_flags & NDR_SCALARS) {
3734                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
3735                 if (_level != level) {
3736                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3737                 }
3738                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3739                 switch (level) {
3740                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
3741                                 NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
3742                         break; }
3743
3744                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: {
3745                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->u_string));
3746                         break; }
3747
3748                         case EXTENDED_ERROR_PARAM_TYPE_UINT32: {
3749                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->uint32));
3750                         break; }
3751
3752                         case EXTENDED_ERROR_PARAM_TYPE_UINT16: {
3753                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->uint16));
3754                         break; }
3755
3756                         case EXTENDED_ERROR_PARAM_TYPE_UINT64: {
3757                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uint64));
3758                         break; }
3759
3760                         case EXTENDED_ERROR_PARAM_TYPE_NONE: {
3761                         break; }
3762
3763                         case EXTENDED_ERROR_PARAM_TYPE_BLOB: {
3764                                 NDR_CHECK(ndr_pull_ExtendedErrorBlob(ndr, NDR_SCALARS, &r->blob));
3765                         break; }
3766
3767                         default:
3768                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3769                 }
3770         }
3771         if (ndr_flags & NDR_BUFFERS) {
3772                 switch (level) {
3773                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3774                                 NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_BUFFERS, &r->a_string));
3775                         break;
3776
3777                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3778                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->u_string));
3779                         break;
3780
3781                         case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3782                         break;
3783
3784                         case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3785                         break;
3786
3787                         case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3788                         break;
3789
3790                         case EXTENDED_ERROR_PARAM_TYPE_NONE:
3791                         break;
3792
3793                         case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3794                                 NDR_CHECK(ndr_pull_ExtendedErrorBlob(ndr, NDR_BUFFERS, &r->blob));
3795                         break;
3796
3797                         default:
3798                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3799                 }
3800         }
3801         return NDR_ERR_SUCCESS;
3802 }
3803
3804 _PUBLIC_ void ndr_print_ExtendedErrorParamU(struct ndr_print *ndr, const char *name, const union ExtendedErrorParamU *r)
3805 {
3806         int level;
3807         level = ndr_print_get_switch_value(ndr, r);
3808         ndr_print_union(ndr, name, level, "ExtendedErrorParamU");
3809         switch (level) {
3810                 case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3811                         ndr_print_ExtendedErrorAString(ndr, "a_string", &r->a_string);
3812                 break;
3813
3814                 case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3815                         ndr_print_ExtendedErrorUString(ndr, "u_string", &r->u_string);
3816                 break;
3817
3818                 case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3819                         ndr_print_uint32(ndr, "uint32", r->uint32);
3820                 break;
3821
3822                 case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3823                         ndr_print_uint16(ndr, "uint16", r->uint16);
3824                 break;
3825
3826                 case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3827                         ndr_print_hyper(ndr, "uint64", r->uint64);
3828                 break;
3829
3830                 case EXTENDED_ERROR_PARAM_TYPE_NONE:
3831                 break;
3832
3833                 case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3834                         ndr_print_ExtendedErrorBlob(ndr, "blob", &r->blob);
3835                 break;
3836
3837                 default:
3838                         ndr_print_bad_level(ndr, name, level);
3839         }
3840 }
3841
3842 static enum ndr_err_code ndr_push_ExtendedErrorParam(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorParam *r)
3843 {
3844         if (ndr_flags & NDR_SCALARS) {
3845                 NDR_CHECK(ndr_push_align(ndr, 8));
3846                 NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, r->type));
3847                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->p, r->type));
3848                 NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
3849                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
3850         }
3851         if (ndr_flags & NDR_BUFFERS) {
3852                 NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
3853         }
3854         return NDR_ERR_SUCCESS;
3855 }
3856
3857 static enum ndr_err_code ndr_pull_ExtendedErrorParam(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorParam *r)
3858 {
3859         if (ndr_flags & NDR_SCALARS) {
3860                 NDR_CHECK(ndr_pull_align(ndr, 8));
3861                 NDR_CHECK(ndr_pull_ExtendedErrorParamType(ndr, NDR_SCALARS, &r->type));
3862                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->p, r->type));
3863                 NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
3864                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3865         }
3866         if (ndr_flags & NDR_BUFFERS) {
3867                 NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
3868         }
3869         return NDR_ERR_SUCCESS;
3870 }
3871
3872 _PUBLIC_ void ndr_print_ExtendedErrorParam(struct ndr_print *ndr, const char *name, const struct ExtendedErrorParam *r)
3873 {
3874         ndr_print_struct(ndr, name, "ExtendedErrorParam");
3875         ndr->depth++;
3876         ndr_print_ExtendedErrorParamType(ndr, "type", r->type);
3877         ndr_print_set_switch_value(ndr, &r->p, r->type);
3878         ndr_print_ExtendedErrorParamU(ndr, "p", &r->p);
3879         ndr->depth--;
3880 }
3881
3882 _PUBLIC_ enum ndr_err_code ndr_push_ExtendedErrorInfo(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorInfo *r)
3883 {
3884         uint32_t cntr_params_0;
3885         if (ndr_flags & NDR_SCALARS) {
3886                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_params));
3887                 NDR_CHECK(ndr_push_align(ndr, 8));
3888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
3889                 NDR_CHECK(ndr_push_ExtendedErrorComputerName(ndr, NDR_SCALARS, &r->computer_name));
3890                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->pid));
3891                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
3892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->generating_component));
3893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
3894                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->detection_location));
3895                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->flags));
3896                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_params));
3897                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3898                         NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
3899                 }
3900                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
3901         }
3902         if (ndr_flags & NDR_BUFFERS) {
3903                 if (r->next) {
3904                         NDR_CHECK(ndr_push_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
3905                 }
3906                 NDR_CHECK(ndr_push_ExtendedErrorComputerName(ndr, NDR_BUFFERS, &r->computer_name));
3907                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3908                         NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_BUFFERS, &r->params[cntr_params_0]));
3909                 }
3910         }
3911         return NDR_ERR_SUCCESS;
3912 }
3913
3914 _PUBLIC_ enum ndr_err_code ndr_pull_ExtendedErrorInfo(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorInfo *r)
3915 {
3916         uint32_t _ptr_next;
3917         TALLOC_CTX *_mem_save_next_0;
3918         uint32_t cntr_params_0;
3919         TALLOC_CTX *_mem_save_params_0;
3920         if (ndr_flags & NDR_SCALARS) {
3921                 NDR_CHECK(ndr_pull_array_size(ndr, &r->params));
3922                 NDR_CHECK(ndr_pull_align(ndr, 8));
3923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
3924                 if (_ptr_next) {
3925                         NDR_PULL_ALLOC(ndr, r->next);
3926                 } else {
3927                         r->next = NULL;
3928                 }
3929                 NDR_CHECK(ndr_pull_ExtendedErrorComputerName(ndr, NDR_SCALARS, &r->computer_name));
3930                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->pid));
3931                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
3932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->generating_component));
3933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
3934                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->detection_location));
3935                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
3936                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_params));
3937                 NDR_PULL_ALLOC_N(ndr, r->params, ndr_get_array_size(ndr, &r->params));
3938                 _mem_save_params_0 = NDR_PULL_GET_MEM_CTX(ndr);
3939                 NDR_PULL_SET_MEM_CTX(ndr, r->params, 0);
3940                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3941                         NDR_CHECK(ndr_pull_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
3942                 }
3943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_params_0, 0);
3944                 if (r->params) {
3945                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->params, r->num_params));
3946                 }
3947                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3948         }
3949         if (ndr_flags & NDR_BUFFERS) {
3950                 if (r->next) {
3951                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
3952                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
3953                         NDR_CHECK(ndr_pull_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
3954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
3955                 }
3956                 NDR_CHECK(ndr_pull_ExtendedErrorComputerName(ndr, NDR_BUFFERS, &r->computer_name));
3957                 _mem_save_params_0 = NDR_PULL_GET_MEM_CTX(ndr);
3958                 NDR_PULL_SET_MEM_CTX(ndr, r->params, 0);
3959                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3960                         NDR_CHECK(ndr_pull_ExtendedErrorParam(ndr, NDR_BUFFERS, &r->params[cntr_params_0]));
3961                 }
3962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_params_0, 0);
3963         }
3964         return NDR_ERR_SUCCESS;
3965 }
3966
3967 _PUBLIC_ void ndr_print_ExtendedErrorInfo(struct ndr_print *ndr, const char *name, const struct ExtendedErrorInfo *r)
3968 {
3969         uint32_t cntr_params_0;
3970         ndr_print_struct(ndr, name, "ExtendedErrorInfo");
3971         ndr->depth++;
3972         ndr_print_ptr(ndr, "next", r->next);
3973         ndr->depth++;
3974         if (r->next) {
3975                 ndr_print_ExtendedErrorInfo(ndr, "next", r->next);
3976         }
3977         ndr->depth--;
3978         ndr_print_ExtendedErrorComputerName(ndr, "computer_name", &r->computer_name);
3979         ndr_print_hyper(ndr, "pid", r->pid);
3980         ndr_print_NTTIME(ndr, "time", r->time);
3981         ndr_print_uint32(ndr, "generating_component", r->generating_component);
3982         ndr_print_WERROR(ndr, "status", r->status);
3983         ndr_print_uint16(ndr, "detection_location", r->detection_location);
3984         ndr_print_uint16(ndr, "flags", r->flags);
3985         ndr_print_uint16(ndr, "num_params", r->num_params);
3986         ndr->print(ndr, "%s: ARRAY(%d)", "params", (int)r->num_params);
3987         ndr->depth++;
3988         for (cntr_params_0=0;cntr_params_0<r->num_params;cntr_params_0++) {
3989                 char *idx_0=NULL;
3990                 if (asprintf(&idx_0, "[%d]", cntr_params_0) != -1) {
3991                         ndr_print_ExtendedErrorParam(ndr, "params", &r->params[cntr_params_0]);
3992                         free(idx_0);
3993                 }
3994         }
3995         ndr->depth--;
3996         ndr->depth--;
3997 }
3998
3999 static enum ndr_err_code ndr_push_ExtendedErrorInfoPtr(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorInfoPtr *r)
4000 {
4001         if (ndr_flags & NDR_SCALARS) {
4002                 NDR_CHECK(ndr_push_align(ndr, 5));
4003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
4004                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4005         }
4006         if (ndr_flags & NDR_BUFFERS) {
4007                 if (r->info) {
4008                         NDR_CHECK(ndr_push_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
4009                 }
4010         }
4011         return NDR_ERR_SUCCESS;
4012 }
4013
4014 static enum ndr_err_code ndr_pull_ExtendedErrorInfoPtr(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorInfoPtr *r)
4015 {
4016         uint32_t _ptr_info;
4017         TALLOC_CTX *_mem_save_info_0;
4018         if (ndr_flags & NDR_SCALARS) {
4019                 NDR_CHECK(ndr_pull_align(ndr, 5));
4020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4021                 if (_ptr_info) {
4022                         NDR_PULL_ALLOC(ndr, r->info);
4023                 } else {
4024                         r->info = NULL;
4025                 }
4026                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4027         }
4028         if (ndr_flags & NDR_BUFFERS) {
4029                 if (r->info) {
4030                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4031                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
4032                         NDR_CHECK(ndr_pull_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
4033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4034                 }
4035         }
4036         return NDR_ERR_SUCCESS;
4037 }
4038
4039 _PUBLIC_ void ndr_print_ExtendedErrorInfoPtr(struct ndr_print *ndr, const char *name, const struct ExtendedErrorInfoPtr *r)
4040 {
4041         ndr_print_struct(ndr, name, "ExtendedErrorInfoPtr");
4042         ndr->depth++;
4043         ndr_print_ptr(ndr, "info", r->info);
4044         ndr->depth++;
4045         if (r->info) {
4046                 ndr_print_ExtendedErrorInfo(ndr, "info", r->info);
4047         }
4048         ndr->depth--;
4049         ndr->depth--;
4050 }
4051
4052 static enum ndr_err_code ndr_push_decode_replPropertyMetaData(struct ndr_push *ndr, int flags, const struct decode_replPropertyMetaData *r)
4053 {
4054         if (flags & NDR_IN) {
4055                 NDR_CHECK(ndr_push_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
4056         }
4057         if (flags & NDR_OUT) {
4058         }
4059         return NDR_ERR_SUCCESS;
4060 }
4061
4062 static enum ndr_err_code ndr_pull_decode_replPropertyMetaData(struct ndr_pull *ndr, int flags, struct decode_replPropertyMetaData *r)
4063 {
4064         if (flags & NDR_IN) {
4065                 NDR_CHECK(ndr_pull_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
4066         }
4067         if (flags & NDR_OUT) {
4068         }
4069         return NDR_ERR_SUCCESS;
4070 }
4071
4072 _PUBLIC_ void ndr_print_decode_replPropertyMetaData(struct ndr_print *ndr, const char *name, int flags, const struct decode_replPropertyMetaData *r)
4073 {
4074         ndr_print_struct(ndr, name, "decode_replPropertyMetaData");
4075         ndr->depth++;
4076         if (flags & NDR_SET_VALUES) {
4077                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4078         }
4079         if (flags & NDR_IN) {
4080                 ndr_print_struct(ndr, "in", "decode_replPropertyMetaData");
4081                 ndr->depth++;
4082                 ndr_print_replPropertyMetaDataBlob(ndr, "blob", &r->in.blob);
4083                 ndr->depth--;
4084         }
4085         if (flags & NDR_OUT) {
4086                 ndr_print_struct(ndr, "out", "decode_replPropertyMetaData");
4087                 ndr->depth++;
4088                 ndr->depth--;
4089         }
4090         ndr->depth--;
4091 }
4092
4093 static enum ndr_err_code ndr_push_decode_replUpToDateVector(struct ndr_push *ndr, int flags, const struct decode_replUpToDateVector *r)
4094 {
4095         if (flags & NDR_IN) {
4096                 NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
4097         }
4098         if (flags & NDR_OUT) {
4099         }
4100         return NDR_ERR_SUCCESS;
4101 }
4102
4103 static enum ndr_err_code ndr_pull_decode_replUpToDateVector(struct ndr_pull *ndr, int flags, struct decode_replUpToDateVector *r)
4104 {
4105         if (flags & NDR_IN) {
4106                 NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
4107         }
4108         if (flags & NDR_OUT) {
4109         }
4110         return NDR_ERR_SUCCESS;
4111 }
4112
4113 _PUBLIC_ void ndr_print_decode_replUpToDateVector(struct ndr_print *ndr, const char *name, int flags, const struct decode_replUpToDateVector *r)
4114 {
4115         ndr_print_struct(ndr, name, "decode_replUpToDateVector");
4116         ndr->depth++;
4117         if (flags & NDR_SET_VALUES) {
4118                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4119         }
4120         if (flags & NDR_IN) {
4121                 ndr_print_struct(ndr, "in", "decode_replUpToDateVector");
4122                 ndr->depth++;
4123                 ndr_print_replUpToDateVectorBlob(ndr, "blob", &r->in.blob);
4124                 ndr->depth--;
4125         }
4126         if (flags & NDR_OUT) {
4127                 ndr_print_struct(ndr, "out", "decode_replUpToDateVector");
4128                 ndr->depth++;
4129                 ndr->depth--;
4130         }
4131         ndr->depth--;
4132 }
4133
4134 static enum ndr_err_code ndr_push_decode_repsFromTo(struct ndr_push *ndr, int flags, const struct decode_repsFromTo *r)
4135 {
4136         if (flags & NDR_IN) {
4137                 NDR_CHECK(ndr_push_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4138         }
4139         if (flags & NDR_OUT) {
4140         }
4141         return NDR_ERR_SUCCESS;
4142 }
4143
4144 static enum ndr_err_code ndr_pull_decode_repsFromTo(struct ndr_pull *ndr, int flags, struct decode_repsFromTo *r)
4145 {
4146         if (flags & NDR_IN) {
4147                 NDR_CHECK(ndr_pull_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4148         }
4149         if (flags & NDR_OUT) {
4150         }
4151         return NDR_ERR_SUCCESS;
4152 }
4153
4154 _PUBLIC_ void ndr_print_decode_repsFromTo(struct ndr_print *ndr, const char *name, int flags, const struct decode_repsFromTo *r)
4155 {
4156         ndr_print_struct(ndr, name, "decode_repsFromTo");
4157         ndr->depth++;
4158         if (flags & NDR_SET_VALUES) {
4159                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4160         }
4161         if (flags & NDR_IN) {
4162                 ndr_print_struct(ndr, "in", "decode_repsFromTo");
4163                 ndr->depth++;
4164                 ndr_print_repsFromToBlob(ndr, "blob", &r->in.blob);
4165                 ndr->depth--;
4166         }
4167         if (flags & NDR_OUT) {
4168                 ndr_print_struct(ndr, "out", "decode_repsFromTo");
4169                 ndr->depth++;
4170                 ndr->depth--;
4171         }
4172         ndr->depth--;
4173 }
4174
4175 static enum ndr_err_code ndr_push_decode_partialAttributeSet(struct ndr_push *ndr, int flags, const struct decode_partialAttributeSet *r)
4176 {
4177         if (flags & NDR_IN) {
4178                 NDR_CHECK(ndr_push_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
4179         }
4180         if (flags & NDR_OUT) {
4181         }
4182         return NDR_ERR_SUCCESS;
4183 }
4184
4185 static enum ndr_err_code ndr_pull_decode_partialAttributeSet(struct ndr_pull *ndr, int flags, struct decode_partialAttributeSet *r)
4186 {
4187         if (flags & NDR_IN) {
4188                 NDR_CHECK(ndr_pull_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
4189         }
4190         if (flags & NDR_OUT) {
4191         }
4192         return NDR_ERR_SUCCESS;
4193 }
4194
4195 _PUBLIC_ void ndr_print_decode_partialAttributeSet(struct ndr_print *ndr, const char *name, int flags, const struct decode_partialAttributeSet *r)
4196 {
4197         ndr_print_struct(ndr, name, "decode_partialAttributeSet");
4198         ndr->depth++;
4199         if (flags & NDR_SET_VALUES) {
4200                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4201         }
4202         if (flags & NDR_IN) {
4203                 ndr_print_struct(ndr, "in", "decode_partialAttributeSet");
4204                 ndr->depth++;
4205                 ndr_print_partialAttributeSetBlob(ndr, "blob", &r->in.blob);
4206                 ndr->depth--;
4207         }
4208         if (flags & NDR_OUT) {
4209                 ndr_print_struct(ndr, "out", "decode_partialAttributeSet");
4210                 ndr->depth++;
4211                 ndr->depth--;
4212         }
4213         ndr->depth--;
4214 }
4215
4216 static enum ndr_err_code ndr_push_decode_prefixMap(struct ndr_push *ndr, int flags, const struct decode_prefixMap *r)
4217 {
4218         if (flags & NDR_IN) {
4219                 NDR_CHECK(ndr_push_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4220         }
4221         if (flags & NDR_OUT) {
4222         }
4223         return NDR_ERR_SUCCESS;
4224 }
4225
4226 static enum ndr_err_code ndr_pull_decode_prefixMap(struct ndr_pull *ndr, int flags, struct decode_prefixMap *r)
4227 {
4228         if (flags & NDR_IN) {
4229                 NDR_CHECK(ndr_pull_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4230         }
4231         if (flags & NDR_OUT) {
4232         }
4233         return NDR_ERR_SUCCESS;
4234 }
4235
4236 _PUBLIC_ void ndr_print_decode_prefixMap(struct ndr_print *ndr, const char *name, int flags, const struct decode_prefixMap *r)
4237 {
4238         ndr_print_struct(ndr, name, "decode_prefixMap");
4239         ndr->depth++;
4240         if (flags & NDR_SET_VALUES) {
4241                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4242         }
4243         if (flags & NDR_IN) {
4244                 ndr_print_struct(ndr, "in", "decode_prefixMap");
4245                 ndr->depth++;
4246                 ndr_print_prefixMapBlob(ndr, "blob", &r->in.blob);
4247                 ndr->depth--;
4248         }
4249         if (flags & NDR_OUT) {
4250                 ndr_print_struct(ndr, "out", "decode_prefixMap");
4251                 ndr->depth++;
4252                 ndr->depth--;
4253         }
4254         ndr->depth--;
4255 }
4256
4257 static enum ndr_err_code ndr_push_decode_ldapControlDirSync(struct ndr_push *ndr, int flags, const struct decode_ldapControlDirSync *r)
4258 {
4259         if (flags & NDR_IN) {
4260                 NDR_CHECK(ndr_push_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
4261         }
4262         if (flags & NDR_OUT) {
4263         }
4264         return NDR_ERR_SUCCESS;
4265 }
4266
4267 static enum ndr_err_code ndr_pull_decode_ldapControlDirSync(struct ndr_pull *ndr, int flags, struct decode_ldapControlDirSync *r)
4268 {
4269         if (flags & NDR_IN) {
4270                 NDR_CHECK(ndr_pull_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
4271         }
4272         if (flags & NDR_OUT) {
4273         }
4274         return NDR_ERR_SUCCESS;
4275 }
4276
4277 _PUBLIC_ void ndr_print_decode_ldapControlDirSync(struct ndr_print *ndr, const char *name, int flags, const struct decode_ldapControlDirSync *r)
4278 {
4279         ndr_print_struct(ndr, name, "decode_ldapControlDirSync");
4280         ndr->depth++;
4281         if (flags & NDR_SET_VALUES) {
4282                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4283         }
4284         if (flags & NDR_IN) {
4285                 ndr_print_struct(ndr, "in", "decode_ldapControlDirSync");
4286                 ndr->depth++;
4287                 ndr_print_ldapControlDirSyncCookie(ndr, "cookie", &r->in.cookie);
4288                 ndr->depth--;
4289         }
4290         if (flags & NDR_OUT) {
4291                 ndr_print_struct(ndr, "out", "decode_ldapControlDirSync");
4292                 ndr->depth++;
4293                 ndr->depth--;
4294         }
4295         ndr->depth--;
4296 }
4297
4298 static enum ndr_err_code ndr_push_decode_supplementalCredentials(struct ndr_push *ndr, int flags, const struct decode_supplementalCredentials *r)
4299 {
4300         if (flags & NDR_IN) {
4301                 NDR_CHECK(ndr_push_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
4302         }
4303         if (flags & NDR_OUT) {
4304         }
4305         return NDR_ERR_SUCCESS;
4306 }
4307
4308 static enum ndr_err_code ndr_pull_decode_supplementalCredentials(struct ndr_pull *ndr, int flags, struct decode_supplementalCredentials *r)
4309 {
4310         if (flags & NDR_IN) {
4311                 NDR_CHECK(ndr_pull_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
4312         }
4313         if (flags & NDR_OUT) {
4314         }
4315         return NDR_ERR_SUCCESS;
4316 }
4317
4318 _PUBLIC_ void ndr_print_decode_supplementalCredentials(struct ndr_print *ndr, const char *name, int flags, const struct decode_supplementalCredentials *r)
4319 {
4320         ndr_print_struct(ndr, name, "decode_supplementalCredentials");
4321         ndr->depth++;
4322         if (flags & NDR_SET_VALUES) {
4323                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4324         }
4325         if (flags & NDR_IN) {
4326                 ndr_print_struct(ndr, "in", "decode_supplementalCredentials");
4327                 ndr->depth++;
4328                 ndr_print_supplementalCredentialsBlob(ndr, "blob", &r->in.blob);
4329                 ndr->depth--;
4330         }
4331         if (flags & NDR_OUT) {
4332                 ndr_print_struct(ndr, "out", "decode_supplementalCredentials");
4333                 ndr->depth++;
4334                 ndr->depth--;
4335         }
4336         ndr->depth--;
4337 }
4338
4339 static enum ndr_err_code ndr_push_decode_Packages(struct ndr_push *ndr, int flags, const struct decode_Packages *r)
4340 {
4341         if (flags & NDR_IN) {
4342                 NDR_CHECK(ndr_push_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
4343         }
4344         if (flags & NDR_OUT) {
4345         }
4346         return NDR_ERR_SUCCESS;
4347 }
4348
4349 static enum ndr_err_code ndr_pull_decode_Packages(struct ndr_pull *ndr, int flags, struct decode_Packages *r)
4350 {
4351         if (flags & NDR_IN) {
4352                 NDR_CHECK(ndr_pull_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
4353         }
4354         if (flags & NDR_OUT) {
4355         }
4356         return NDR_ERR_SUCCESS;
4357 }
4358
4359 _PUBLIC_ void ndr_print_decode_Packages(struct ndr_print *ndr, const char *name, int flags, const struct decode_Packages *r)
4360 {
4361         ndr_print_struct(ndr, name, "decode_Packages");
4362         ndr->depth++;
4363         if (flags & NDR_SET_VALUES) {
4364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4365         }
4366         if (flags & NDR_IN) {
4367                 ndr_print_struct(ndr, "in", "decode_Packages");
4368                 ndr->depth++;
4369                 ndr_print_package_PackagesBlob(ndr, "blob", &r->in.blob);
4370                 ndr->depth--;
4371         }
4372         if (flags & NDR_OUT) {
4373                 ndr_print_struct(ndr, "out", "decode_Packages");
4374                 ndr->depth++;
4375                 ndr->depth--;
4376         }
4377         ndr->depth--;
4378 }
4379
4380 static enum ndr_err_code ndr_push_decode_PrimaryKerberos(struct ndr_push *ndr, int flags, const struct decode_PrimaryKerberos *r)
4381 {
4382         if (flags & NDR_IN) {
4383                 NDR_CHECK(ndr_push_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4384         }
4385         if (flags & NDR_OUT) {
4386         }
4387         return NDR_ERR_SUCCESS;
4388 }
4389
4390 static enum ndr_err_code ndr_pull_decode_PrimaryKerberos(struct ndr_pull *ndr, int flags, struct decode_PrimaryKerberos *r)
4391 {
4392         if (flags & NDR_IN) {
4393                 NDR_CHECK(ndr_pull_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4394         }
4395         if (flags & NDR_OUT) {
4396         }
4397         return NDR_ERR_SUCCESS;
4398 }
4399
4400 _PUBLIC_ void ndr_print_decode_PrimaryKerberos(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryKerberos *r)
4401 {
4402         ndr_print_struct(ndr, name, "decode_PrimaryKerberos");
4403         ndr->depth++;
4404         if (flags & NDR_SET_VALUES) {
4405                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4406         }
4407         if (flags & NDR_IN) {
4408                 ndr_print_struct(ndr, "in", "decode_PrimaryKerberos");
4409                 ndr->depth++;
4410                 ndr_print_package_PrimaryKerberosBlob(ndr, "blob", &r->in.blob);
4411                 ndr->depth--;
4412         }
4413         if (flags & NDR_OUT) {
4414                 ndr_print_struct(ndr, "out", "decode_PrimaryKerberos");
4415                 ndr->depth++;
4416                 ndr->depth--;
4417         }
4418         ndr->depth--;
4419 }
4420
4421 static enum ndr_err_code ndr_push_decode_PrimaryCLEARTEXT(struct ndr_push *ndr, int flags, const struct decode_PrimaryCLEARTEXT *r)
4422 {
4423         if (flags & NDR_IN) {
4424                 NDR_CHECK(ndr_push_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
4425         }
4426         if (flags & NDR_OUT) {
4427         }
4428         return NDR_ERR_SUCCESS;
4429 }
4430
4431 static enum ndr_err_code ndr_pull_decode_PrimaryCLEARTEXT(struct ndr_pull *ndr, int flags, struct decode_PrimaryCLEARTEXT *r)
4432 {
4433         if (flags & NDR_IN) {
4434                 NDR_CHECK(ndr_pull_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
4435         }
4436         if (flags & NDR_OUT) {
4437         }
4438         return NDR_ERR_SUCCESS;
4439 }
4440
4441 _PUBLIC_ void ndr_print_decode_PrimaryCLEARTEXT(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryCLEARTEXT *r)
4442 {
4443         ndr_print_struct(ndr, name, "decode_PrimaryCLEARTEXT");
4444         ndr->depth++;
4445         if (flags & NDR_SET_VALUES) {
4446                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4447         }
4448         if (flags & NDR_IN) {
4449                 ndr_print_struct(ndr, "in", "decode_PrimaryCLEARTEXT");
4450                 ndr->depth++;
4451                 ndr_print_package_PrimaryCLEARTEXTBlob(ndr, "blob", &r->in.blob);
4452                 ndr->depth--;
4453         }
4454         if (flags & NDR_OUT) {
4455                 ndr_print_struct(ndr, "out", "decode_PrimaryCLEARTEXT");
4456                 ndr->depth++;
4457                 ndr->depth--;
4458         }
4459         ndr->depth--;
4460 }
4461
4462 static enum ndr_err_code ndr_push_decode_PrimaryWDigest(struct ndr_push *ndr, int flags, const struct decode_PrimaryWDigest *r)
4463 {
4464         if (flags & NDR_IN) {
4465                 NDR_CHECK(ndr_push_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
4466         }
4467         if (flags & NDR_OUT) {
4468         }
4469         return NDR_ERR_SUCCESS;
4470 }
4471
4472 static enum ndr_err_code ndr_pull_decode_PrimaryWDigest(struct ndr_pull *ndr, int flags, struct decode_PrimaryWDigest *r)
4473 {
4474         if (flags & NDR_IN) {
4475                 NDR_CHECK(ndr_pull_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
4476         }
4477         if (flags & NDR_OUT) {
4478         }
4479         return NDR_ERR_SUCCESS;
4480 }
4481
4482 _PUBLIC_ void ndr_print_decode_PrimaryWDigest(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryWDigest *r)
4483 {
4484         ndr_print_struct(ndr, name, "decode_PrimaryWDigest");
4485         ndr->depth++;
4486         if (flags & NDR_SET_VALUES) {
4487                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4488         }
4489         if (flags & NDR_IN) {
4490                 ndr_print_struct(ndr, "in", "decode_PrimaryWDigest");
4491                 ndr->depth++;
4492                 ndr_print_package_PrimaryWDigestBlob(ndr, "blob", &r->in.blob);
4493                 ndr->depth--;
4494         }
4495         if (flags & NDR_OUT) {
4496                 ndr_print_struct(ndr, "out", "decode_PrimaryWDigest");
4497                 ndr->depth++;
4498                 ndr->depth--;
4499         }
4500         ndr->depth--;
4501 }
4502
4503 static enum ndr_err_code ndr_push_decode_trustAuthInOut(struct ndr_push *ndr, int flags, const struct decode_trustAuthInOut *r)
4504 {
4505         if (flags & NDR_IN) {
4506                 NDR_CHECK(ndr_push_trustAuthInOutBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4507         }
4508         if (flags & NDR_OUT) {
4509         }
4510         return NDR_ERR_SUCCESS;
4511 }
4512
4513 static enum ndr_err_code ndr_pull_decode_trustAuthInOut(struct ndr_pull *ndr, int flags, struct decode_trustAuthInOut *r)
4514 {
4515         if (flags & NDR_IN) {
4516                 NDR_CHECK(ndr_pull_trustAuthInOutBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4517         }
4518         if (flags & NDR_OUT) {
4519         }
4520         return NDR_ERR_SUCCESS;
4521 }
4522
4523 _PUBLIC_ void ndr_print_decode_trustAuthInOut(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustAuthInOut *r)
4524 {
4525         ndr_print_struct(ndr, name, "decode_trustAuthInOut");
4526         ndr->depth++;
4527         if (flags & NDR_SET_VALUES) {
4528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4529         }
4530         if (flags & NDR_IN) {
4531                 ndr_print_struct(ndr, "in", "decode_trustAuthInOut");
4532                 ndr->depth++;
4533                 ndr_print_trustAuthInOutBlob(ndr, "blob", &r->in.blob);
4534                 ndr->depth--;
4535         }
4536         if (flags & NDR_OUT) {
4537                 ndr_print_struct(ndr, "out", "decode_trustAuthInOut");
4538                 ndr->depth++;
4539                 ndr->depth--;
4540         }
4541         ndr->depth--;
4542 }
4543
4544 static enum ndr_err_code ndr_push_decode_trustDomainPasswords(struct ndr_push *ndr, int flags, const struct decode_trustDomainPasswords *r)
4545 {
4546         if (flags & NDR_IN) {
4547                 NDR_CHECK(ndr_push_trustDomainPasswords(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4548         }
4549         if (flags & NDR_OUT) {
4550         }
4551         return NDR_ERR_SUCCESS;
4552 }
4553
4554 static enum ndr_err_code ndr_pull_decode_trustDomainPasswords(struct ndr_pull *ndr, int flags, struct decode_trustDomainPasswords *r)
4555 {
4556         if (flags & NDR_IN) {
4557                 NDR_CHECK(ndr_pull_trustDomainPasswords(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4558         }
4559         if (flags & NDR_OUT) {
4560         }
4561         return NDR_ERR_SUCCESS;
4562 }
4563
4564 _PUBLIC_ void ndr_print_decode_trustDomainPasswords(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustDomainPasswords *r)
4565 {
4566         ndr_print_struct(ndr, name, "decode_trustDomainPasswords");
4567         ndr->depth++;
4568         if (flags & NDR_SET_VALUES) {
4569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4570         }
4571         if (flags & NDR_IN) {
4572                 ndr_print_struct(ndr, "in", "decode_trustDomainPasswords");
4573                 ndr->depth++;
4574                 ndr_print_trustDomainPasswords(ndr, "blob", &r->in.blob);
4575                 ndr->depth--;
4576         }
4577         if (flags & NDR_OUT) {
4578                 ndr_print_struct(ndr, "out", "decode_trustDomainPasswords");
4579                 ndr->depth++;
4580                 ndr->depth--;
4581         }
4582         ndr->depth--;
4583 }
4584
4585 static enum ndr_err_code ndr_push_decode_ExtendedErrorInfo(struct ndr_push *ndr, int flags, const struct decode_ExtendedErrorInfo *r)
4586 {
4587         if (flags & NDR_IN) {
4588                 {
4589                         struct ndr_push *_ndr_ptr;
4590                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ptr, 0xFFFFFC01, -1));
4591                         NDR_CHECK(ndr_push_ExtendedErrorInfoPtr(_ndr_ptr, NDR_SCALARS|NDR_BUFFERS, &r->in.ptr));
4592                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ptr, 0xFFFFFC01, -1));
4593                 }
4594         }
4595         if (flags & NDR_OUT) {
4596         }
4597         return NDR_ERR_SUCCESS;
4598 }
4599
4600 static enum ndr_err_code ndr_pull_decode_ExtendedErrorInfo(struct ndr_pull *ndr, int flags, struct decode_ExtendedErrorInfo *r)
4601 {
4602         if (flags & NDR_IN) {
4603                 {
4604                         struct ndr_pull *_ndr_ptr;
4605                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ptr, 0xFFFFFC01, -1));
4606                         NDR_CHECK(ndr_pull_ExtendedErrorInfoPtr(_ndr_ptr, NDR_SCALARS|NDR_BUFFERS, &r->in.ptr));
4607                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ptr, 0xFFFFFC01, -1));
4608                 }
4609         }
4610         if (flags & NDR_OUT) {
4611         }
4612         return NDR_ERR_SUCCESS;
4613 }
4614
4615 _PUBLIC_ void ndr_print_decode_ExtendedErrorInfo(struct ndr_print *ndr, const char *name, int flags, const struct decode_ExtendedErrorInfo *r)
4616 {
4617         ndr_print_struct(ndr, name, "decode_ExtendedErrorInfo");
4618         ndr->depth++;
4619         if (flags & NDR_SET_VALUES) {
4620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4621         }
4622         if (flags & NDR_IN) {
4623                 ndr_print_struct(ndr, "in", "decode_ExtendedErrorInfo");
4624                 ndr->depth++;
4625                 ndr_print_ExtendedErrorInfoPtr(ndr, "ptr", &r->in.ptr);
4626                 ndr->depth--;
4627         }
4628         if (flags & NDR_OUT) {
4629                 ndr_print_struct(ndr, "out", "decode_ExtendedErrorInfo");
4630                 ndr->depth++;
4631                 ndr->depth--;
4632         }
4633         ndr->depth--;
4634 }
4635
4636 static const struct ndr_interface_call drsblobs_calls[] = {
4637         {
4638                 "decode_replPropertyMetaData",
4639                 sizeof(struct decode_replPropertyMetaData),
4640                 (ndr_push_flags_fn_t) ndr_push_decode_replPropertyMetaData,
4641                 (ndr_pull_flags_fn_t) ndr_pull_decode_replPropertyMetaData,
4642                 (ndr_print_function_t) ndr_print_decode_replPropertyMetaData,
4643                 false,
4644         },
4645         {
4646                 "decode_replUpToDateVector",
4647                 sizeof(struct decode_replUpToDateVector),
4648                 (ndr_push_flags_fn_t) ndr_push_decode_replUpToDateVector,
4649                 (ndr_pull_flags_fn_t) ndr_pull_decode_replUpToDateVector,
4650                 (ndr_print_function_t) ndr_print_decode_replUpToDateVector,
4651                 false,
4652         },
4653         {
4654                 "decode_repsFromTo",
4655                 sizeof(struct decode_repsFromTo),
4656                 (ndr_push_flags_fn_t) ndr_push_decode_repsFromTo,
4657                 (ndr_pull_flags_fn_t) ndr_pull_decode_repsFromTo,
4658                 (ndr_print_function_t) ndr_print_decode_repsFromTo,
4659                 false,
4660         },
4661         {
4662                 "decode_partialAttributeSet",
4663                 sizeof(struct decode_partialAttributeSet),
4664                 (ndr_push_flags_fn_t) ndr_push_decode_partialAttributeSet,
4665                 (ndr_pull_flags_fn_t) ndr_pull_decode_partialAttributeSet,
4666                 (ndr_print_function_t) ndr_print_decode_partialAttributeSet,
4667                 false,
4668         },
4669         {
4670                 "decode_prefixMap",
4671                 sizeof(struct decode_prefixMap),
4672                 (ndr_push_flags_fn_t) ndr_push_decode_prefixMap,
4673                 (ndr_pull_flags_fn_t) ndr_pull_decode_prefixMap,
4674                 (ndr_print_function_t) ndr_print_decode_prefixMap,
4675                 false,
4676         },
4677         {
4678                 "decode_ldapControlDirSync",
4679                 sizeof(struct decode_ldapControlDirSync),
4680                 (ndr_push_flags_fn_t) ndr_push_decode_ldapControlDirSync,
4681                 (ndr_pull_flags_fn_t) ndr_pull_decode_ldapControlDirSync,
4682                 (ndr_print_function_t) ndr_print_decode_ldapControlDirSync,
4683                 false,
4684         },
4685         {
4686                 "decode_supplementalCredentials",
4687                 sizeof(struct decode_supplementalCredentials),
4688                 (ndr_push_flags_fn_t) ndr_push_decode_supplementalCredentials,
4689                 (ndr_pull_flags_fn_t) ndr_pull_decode_supplementalCredentials,
4690                 (ndr_print_function_t) ndr_print_decode_supplementalCredentials,
4691                 false,
4692         },
4693         {
4694                 "decode_Packages",
4695                 sizeof(struct decode_Packages),
4696                 (ndr_push_flags_fn_t) ndr_push_decode_Packages,
4697                 (ndr_pull_flags_fn_t) ndr_pull_decode_Packages,
4698                 (ndr_print_function_t) ndr_print_decode_Packages,
4699                 false,
4700         },
4701         {
4702                 "decode_PrimaryKerberos",
4703                 sizeof(struct decode_PrimaryKerberos),
4704                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryKerberos,
4705                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryKerberos,
4706                 (ndr_print_function_t) ndr_print_decode_PrimaryKerberos,
4707                 false,
4708         },
4709         {
4710                 "decode_PrimaryCLEARTEXT",
4711                 sizeof(struct decode_PrimaryCLEARTEXT),
4712                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryCLEARTEXT,
4713                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryCLEARTEXT,
4714                 (ndr_print_function_t) ndr_print_decode_PrimaryCLEARTEXT,
4715                 false,
4716         },
4717         {
4718                 "decode_PrimaryWDigest",
4719                 sizeof(struct decode_PrimaryWDigest),
4720                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryWDigest,
4721                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryWDigest,
4722                 (ndr_print_function_t) ndr_print_decode_PrimaryWDigest,
4723                 false,
4724         },
4725         {
4726                 "decode_trustAuthInOut",
4727                 sizeof(struct decode_trustAuthInOut),
4728                 (ndr_push_flags_fn_t) ndr_push_decode_trustAuthInOut,
4729                 (ndr_pull_flags_fn_t) ndr_pull_decode_trustAuthInOut,
4730                 (ndr_print_function_t) ndr_print_decode_trustAuthInOut,
4731                 false,
4732         },
4733         {
4734                 "decode_trustDomainPasswords",
4735                 sizeof(struct decode_trustDomainPasswords),
4736                 (ndr_push_flags_fn_t) ndr_push_decode_trustDomainPasswords,
4737                 (ndr_pull_flags_fn_t) ndr_pull_decode_trustDomainPasswords,
4738                 (ndr_print_function_t) ndr_print_decode_trustDomainPasswords,
4739                 false,
4740         },
4741         {
4742                 "decode_ExtendedErrorInfo",
4743                 sizeof(struct decode_ExtendedErrorInfo),
4744                 (ndr_push_flags_fn_t) ndr_push_decode_ExtendedErrorInfo,
4745                 (ndr_pull_flags_fn_t) ndr_pull_decode_ExtendedErrorInfo,
4746                 (ndr_print_function_t) ndr_print_decode_ExtendedErrorInfo,
4747                 false,
4748         },
4749         { NULL, 0, NULL, NULL, NULL, false }
4750 };
4751
4752 static const char * const drsblobs_endpoint_strings[] = {
4753         "ncacn_np:[\\pipe\\drsblobs]",
4754 };
4755
4756 static const struct ndr_interface_string_array drsblobs_endpoints = {
4757         .count  = 1,
4758         .names  = drsblobs_endpoint_strings
4759 };
4760
4761 static const char * const drsblobs_authservice_strings[] = {
4762         "host",
4763 };
4764
4765 static const struct ndr_interface_string_array drsblobs_authservices = {
4766         .count  = 1,
4767         .names  = drsblobs_authservice_strings
4768 };
4769
4770
4771 const struct ndr_interface_table ndr_table_drsblobs = {
4772         .name           = "drsblobs",
4773         .syntax_id      = {
4774                 {0x12345778,0x1234,0xabcd,{0x00,0x01},{0x00,0x00,0x00,0x01}},
4775                 NDR_DRSBLOBS_VERSION
4776         },
4777         .helpstring     = NDR_DRSBLOBS_HELPSTRING,
4778         .num_calls      = 14,
4779         .calls          = drsblobs_calls,
4780         .endpoints      = &drsblobs_endpoints,
4781         .authservices   = &drsblobs_authservices
4782 };
4783