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