source3/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 static enum ndr_err_code ndr_push_replPropertyMetaData1(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaData1 *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 8));
  12                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
  13                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
  14                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
  15                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
  16                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
  17                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
  18         }
  19         if (ndr_flags & NDR_BUFFERS) {
  20         }
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 static enum ndr_err_code ndr_pull_replPropertyMetaData1(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaData1 *r)
  25 {
  26         if (ndr_flags & NDR_SCALARS) {
  27                 NDR_CHECK(ndr_pull_align(ndr, 8));
  28                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
  29                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
  30                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
  31                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
  32                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
  33                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
  34         }
  35         if (ndr_flags & NDR_BUFFERS) {
  36         }
  37         return NDR_ERR_SUCCESS;
  38 }
  39
  40 _PUBLIC_ void ndr_print_replPropertyMetaData1(struct ndr_print *ndr, const char *name, const struct replPropertyMetaData1 *r)
  41 {
  42         ndr_print_struct(ndr, name, "replPropertyMetaData1");
  43         ndr->depth++;
  44         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
  45         ndr_print_uint32(ndr, "version", r->version);
  46         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
  47         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
  48         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
  49         ndr_print_hyper(ndr, "local_usn", r->local_usn);
  50         ndr->depth--;
  51 }
  52
  53 static enum ndr_err_code ndr_push_replPropertyMetaDataCtr1(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaDataCtr1 *r)
  54 {
  55         uint32_t cntr_array_0;
  56         if (ndr_flags & NDR_SCALARS) {
  57                 NDR_CHECK(ndr_push_align(ndr, 8));
  58                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
  59                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
  60                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
  61                         NDR_CHECK(ndr_push_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
  62                 }
  63         }
  64         if (ndr_flags & NDR_BUFFERS) {
  65         }
  66         return NDR_ERR_SUCCESS;
  67 }
  68
  69 static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr1(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaDataCtr1 *r)
  70 {
  71         uint32_t cntr_array_0;
  72         TALLOC_CTX *_mem_save_array_0;
  73         if (ndr_flags & NDR_SCALARS) {
  74                 NDR_CHECK(ndr_pull_align(ndr, 8));
  75                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
  76                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
  77                 NDR_PULL_ALLOC_N(ndr, r->array, r->count);
  78                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
  79                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
  80                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
  81                         NDR_CHECK(ndr_pull_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
  82                 }
  83                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
  84         }
  85         if (ndr_flags & NDR_BUFFERS) {
  86         }
  87         return NDR_ERR_SUCCESS;
  88 }
  89
  90 _PUBLIC_ void ndr_print_replPropertyMetaDataCtr1(struct ndr_print *ndr, const char *name, const struct replPropertyMetaDataCtr1 *r)
  91 {
  92         uint32_t cntr_array_0;
  93         ndr_print_struct(ndr, name, "replPropertyMetaDataCtr1");
  94         ndr->depth++;
  95         ndr_print_uint32(ndr, "count", r->count);
  96         ndr_print_uint32(ndr, "reserved", r->reserved);
  97         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
  98         ndr->depth++;
  99         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
 100                 char *idx_0=NULL;
 101                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
 102                         ndr_print_replPropertyMetaData1(ndr, "array", &r->array[cntr_array_0]);
 103                         free(idx_0);
 104                 }
 105         }
 106         ndr->depth--;
 107         ndr->depth--;
 108 }
 109
 110 static enum ndr_err_code ndr_push_replPropertyMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const union replPropertyMetaDataCtr *r)
 111 {
 112         if (ndr_flags & NDR_SCALARS) {
 113                 int level = ndr_push_get_switch_value(ndr, r);
 114                 switch (level) {
 115                         case 1: {
 116                                 NDR_CHECK(ndr_push_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
 117                         break; }
 118
 119                         default:
 120                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 121                 }
 122         }
 123         if (ndr_flags & NDR_BUFFERS) {
 124                 int level = ndr_push_get_switch_value(ndr, r);
 125                 switch (level) {
 126                         case 1:
 127                         break;
 128
 129                         default:
 130                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 131                 }
 132         }
 133         return NDR_ERR_SUCCESS;
 134 }
 135
 136 static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, union replPropertyMetaDataCtr *r)
 137 {
 138         int level;
 139         level = ndr_pull_get_switch_value(ndr, r);
 140         if (ndr_flags & NDR_SCALARS) {
 141                 switch (level) {
 142                         case 1: {
 143                                 NDR_CHECK(ndr_pull_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
 144                         break; }
 145
 146                         default:
 147                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 148                 }
 149         }
 150         if (ndr_flags & NDR_BUFFERS) {
 151                 switch (level) {
 152                         case 1:
 153                         break;
 154
 155                         default:
 156                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 157                 }
 158         }
 159         return NDR_ERR_SUCCESS;
 160 }
 161
 162 _PUBLIC_ void ndr_print_replPropertyMetaDataCtr(struct ndr_print *ndr, const char *name, const union replPropertyMetaDataCtr *r)
 163 {
 164         int level;
 165         level = ndr_print_get_switch_value(ndr, r);
 166         ndr_print_union(ndr, name, level, "replPropertyMetaDataCtr");
 167         switch (level) {
 168                 case 1:
 169                         ndr_print_replPropertyMetaDataCtr1(ndr, "ctr1", &r->ctr1);
 170                 break;
 171
 172                 default:
 173                         ndr_print_bad_level(ndr, name, level);
 174         }
 175 }
 176
 177 _PUBLIC_ enum ndr_err_code ndr_push_replPropertyMetaDataBlob(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaDataBlob *r)
 178 {
 179         if (ndr_flags & NDR_SCALARS) {
 180                 NDR_CHECK(ndr_push_align(ndr, 8));
 181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 183                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 184                 NDR_CHECK(ndr_push_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
 185         }
 186         if (ndr_flags & NDR_BUFFERS) {
 187         }
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ enum ndr_err_code ndr_pull_replPropertyMetaDataBlob(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaDataBlob *r)
 192 {
 193         if (ndr_flags & NDR_SCALARS) {
 194                 NDR_CHECK(ndr_pull_align(ndr, 8));
 195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 197                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 198                 NDR_CHECK(ndr_pull_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
 199         }
 200         if (ndr_flags & NDR_BUFFERS) {
 201         }
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 _PUBLIC_ void ndr_print_replPropertyMetaDataBlob(struct ndr_print *ndr, const char *name, const struct replPropertyMetaDataBlob *r)
 206 {
 207         ndr_print_struct(ndr, name, "replPropertyMetaDataBlob");
 208         ndr->depth++;
 209         ndr_print_uint32(ndr, "version", r->version);
 210         ndr_print_uint32(ndr, "reserved", r->reserved);
 211         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
 212         ndr_print_replPropertyMetaDataCtr(ndr, "ctr", &r->ctr);
 213         ndr->depth--;
 214 }
 215
 216 static enum ndr_err_code ndr_push_replUpToDateVectorCtr1(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorCtr1 *r)
 217 {
 218         uint32_t cntr_cursors_0;
 219         if (ndr_flags & NDR_SCALARS) {
 220                 NDR_CHECK(ndr_push_align(ndr, 8));
 221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 223                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 224                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 225                 }
 226         }
 227         if (ndr_flags & NDR_BUFFERS) {
 228         }
 229         return NDR_ERR_SUCCESS;
 230 }
 231
 232 static enum ndr_err_code ndr_pull_replUpToDateVectorCtr1(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorCtr1 *r)
 233 {
 234         uint32_t cntr_cursors_0;
 235         TALLOC_CTX *_mem_save_cursors_0;
 236         if (ndr_flags & NDR_SCALARS) {
 237                 NDR_CHECK(ndr_pull_align(ndr, 8));
 238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 240                 NDR_PULL_ALLOC_N(ndr, r->cursors, r->count);
 241                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 242                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 243                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 244                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 245                 }
 246                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 247         }
 248         if (ndr_flags & NDR_BUFFERS) {
 249         }
 250         return NDR_ERR_SUCCESS;
 251 }
 252
 253 _PUBLIC_ void ndr_print_replUpToDateVectorCtr1(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorCtr1 *r)
 254 {
 255         uint32_t cntr_cursors_0;
 256         ndr_print_struct(ndr, name, "replUpToDateVectorCtr1");
 257         ndr->depth++;
 258         ndr_print_uint32(ndr, "count", r->count);
 259         ndr_print_uint32(ndr, "reserved", r->reserved);
 260         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 261         ndr->depth++;
 262         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 263                 char *idx_0=NULL;
 264                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 265                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 266                         free(idx_0);
 267                 }
 268         }
 269         ndr->depth--;
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_replUpToDateVectorCtr2(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorCtr2 *r)
 274 {
 275         uint32_t cntr_cursors_0;
 276         if (ndr_flags & NDR_SCALARS) {
 277                 NDR_CHECK(ndr_push_align(ndr, 8));
 278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 280                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 281                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 282                 }
 283         }
 284         if (ndr_flags & NDR_BUFFERS) {
 285         }
 286         return NDR_ERR_SUCCESS;
 287 }
 288
 289 static enum ndr_err_code ndr_pull_replUpToDateVectorCtr2(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorCtr2 *r)
 290 {
 291         uint32_t cntr_cursors_0;
 292         TALLOC_CTX *_mem_save_cursors_0;
 293         if (ndr_flags & NDR_SCALARS) {
 294                 NDR_CHECK(ndr_pull_align(ndr, 8));
 295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 297                 NDR_PULL_ALLOC_N(ndr, r->cursors, r->count);
 298                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 299                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 300                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 301                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 302                 }
 303                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 304         }
 305         if (ndr_flags & NDR_BUFFERS) {
 306         }
 307         return NDR_ERR_SUCCESS;
 308 }
 309
 310 _PUBLIC_ void ndr_print_replUpToDateVectorCtr2(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorCtr2 *r)
 311 {
 312         uint32_t cntr_cursors_0;
 313         ndr_print_struct(ndr, name, "replUpToDateVectorCtr2");
 314         ndr->depth++;
 315         ndr_print_uint32(ndr, "count", r->count);
 316         ndr_print_uint32(ndr, "reserved", r->reserved);
 317         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 318         ndr->depth++;
 319         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 320                 char *idx_0=NULL;
 321                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 322                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 323                         free(idx_0);
 324                 }
 325         }
 326         ndr->depth--;
 327         ndr->depth--;
 328 }
 329
 330 static enum ndr_err_code ndr_push_replUpToDateVectorCtr(struct ndr_push *ndr, int ndr_flags, const union replUpToDateVectorCtr *r)
 331 {
 332         if (ndr_flags & NDR_SCALARS) {
 333                 int level = ndr_push_get_switch_value(ndr, r);
 334                 switch (level) {
 335                         case 1: {
 336                                 NDR_CHECK(ndr_push_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
 337                         break; }
 338
 339                         case 2: {
 340                                 NDR_CHECK(ndr_push_replUpToDateVectorCtr2(ndr, NDR_SCALARS, &r->ctr2));
 341                         break; }
 342
 343                         default:
 344                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 345                 }
 346         }
 347         if (ndr_flags & NDR_BUFFERS) {
 348                 int level = ndr_push_get_switch_value(ndr, r);
 349                 switch (level) {
 350                         case 1:
 351                         break;
 352
 353                         case 2:
 354                         break;
 355
 356                         default:
 357                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 358                 }
 359         }
 360         return NDR_ERR_SUCCESS;
 361 }
 362
 363 static enum ndr_err_code ndr_pull_replUpToDateVectorCtr(struct ndr_pull *ndr, int ndr_flags, union replUpToDateVectorCtr *r)
 364 {
 365         int level;
 366         level = ndr_pull_get_switch_value(ndr, r);
 367         if (ndr_flags & NDR_SCALARS) {
 368                 switch (level) {
 369                         case 1: {
 370                                 NDR_CHECK(ndr_pull_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
 371                         break; }
 372
 373                         case 2: {
 374                                 NDR_CHECK(ndr_pull_replUpToDateVectorCtr2(ndr, NDR_SCALARS, &r->ctr2));
 375                         break; }
 376
 377                         default:
 378                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 379                 }
 380         }
 381         if (ndr_flags & NDR_BUFFERS) {
 382                 switch (level) {
 383                         case 1:
 384                         break;
 385
 386                         case 2:
 387                         break;
 388
 389                         default:
 390                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 391                 }
 392         }
 393         return NDR_ERR_SUCCESS;
 394 }
 395
 396 _PUBLIC_ void ndr_print_replUpToDateVectorCtr(struct ndr_print *ndr, const char *name, const union replUpToDateVectorCtr *r)
 397 {
 398         int level;
 399         level = ndr_print_get_switch_value(ndr, r);
 400         ndr_print_union(ndr, name, level, "replUpToDateVectorCtr");
 401         switch (level) {
 402                 case 1:
 403                         ndr_print_replUpToDateVectorCtr1(ndr, "ctr1", &r->ctr1);
 404                 break;
 405
 406                 case 2:
 407                         ndr_print_replUpToDateVectorCtr2(ndr, "ctr2", &r->ctr2);
 408                 break;
 409
 410                 default:
 411                         ndr_print_bad_level(ndr, name, level);
 412         }
 413 }
 414
 415 _PUBLIC_ enum ndr_err_code ndr_push_replUpToDateVectorBlob(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorBlob *r)
 416 {
 417         if (ndr_flags & NDR_SCALARS) {
 418                 NDR_CHECK(ndr_push_align(ndr, 8));
 419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 421                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 422                 NDR_CHECK(ndr_push_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
 423         }
 424         if (ndr_flags & NDR_BUFFERS) {
 425         }
 426         return NDR_ERR_SUCCESS;
 427 }
 428
 429 _PUBLIC_ enum ndr_err_code ndr_pull_replUpToDateVectorBlob(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorBlob *r)
 430 {
 431         if (ndr_flags & NDR_SCALARS) {
 432                 NDR_CHECK(ndr_pull_align(ndr, 8));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 435                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 436                 NDR_CHECK(ndr_pull_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
 437         }
 438         if (ndr_flags & NDR_BUFFERS) {
 439         }
 440         return NDR_ERR_SUCCESS;
 441 }
 442
 443 _PUBLIC_ void ndr_print_replUpToDateVectorBlob(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorBlob *r)
 444 {
 445         ndr_print_struct(ndr, name, "replUpToDateVectorBlob");
 446         ndr->depth++;
 447         ndr_print_uint32(ndr, "version", r->version);
 448         ndr_print_uint32(ndr, "reserved", r->reserved);
 449         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
 450         ndr_print_replUpToDateVectorCtr(ndr, "ctr", &r->ctr);
 451         ndr->depth--;
 452 }
 453
 454 _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1OtherInfo(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo1OtherInfo *r)
 455 {
 456         if (ndr_flags & NDR_SCALARS) {
 457                 NDR_CHECK(ndr_push_align(ndr, 4));
 458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->dns_name) + 1));
 459                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, strlen(r->dns_name) + 1, sizeof(uint8_t), CH_DOS));
 460         }
 461         if (ndr_flags & NDR_BUFFERS) {
 462         }
 463         return NDR_ERR_SUCCESS;
 464 }
 465
 466 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1OtherInfo(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo1OtherInfo *r)
 467 {
 468         if (ndr_flags & NDR_SCALARS) {
 469                 NDR_CHECK(ndr_pull_align(ndr, 4));
 470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__dns_name_size));
 471                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, r->__dns_name_size, sizeof(uint8_t), CH_DOS));
 472         }
 473         if (ndr_flags & NDR_BUFFERS) {
 474         }
 475         return NDR_ERR_SUCCESS;
 476 }
 477
 478 _PUBLIC_ void ndr_print_repsFromTo1OtherInfo(struct ndr_print *ndr, const char *name, const struct repsFromTo1OtherInfo *r)
 479 {
 480         ndr_print_struct(ndr, name, "repsFromTo1OtherInfo");
 481         ndr->depth++;
 482         ndr_print_uint32(ndr, "__dns_name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->dns_name) + 1:r->__dns_name_size);
 483         ndr_print_string(ndr, "dns_name", r->dns_name);
 484         ndr->depth--;
 485 }
 486
 487 _PUBLIC_ size_t ndr_size_repsFromTo1OtherInfo(const struct repsFromTo1OtherInfo *r, int flags)
 488 {
 489         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo1OtherInfo);
 490 }
 491
 492 _PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo1 *r)
 493 {
 494         {
 495                 uint32_t _flags_save_STRUCT = ndr->flags;
 496                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 497                 if (ndr_flags & NDR_SCALARS) {
 498                         NDR_CHECK(ndr_push_align(ndr, 8));
 499                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo1(r, ndr->flags) + 8));
 500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
 501                         NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_success));
 502                         NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_attempt));
 503                         NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
 504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->other_info));
 505                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo1OtherInfo(r->other_info, ndr->flags)));
 506                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
 507                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
 508                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 509                         NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
 510                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
 511                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 512                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
 513                 }
 514                 if (ndr_flags & NDR_BUFFERS) {
 515                         if (r->other_info) {
 516                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->other_info));
 517                                 NDR_CHECK(ndr_push_repsFromTo1OtherInfo(ndr, NDR_SCALARS, r->other_info));
 518                         }
 519                 }
 520                 ndr->flags = _flags_save_STRUCT;
 521         }
 522         return NDR_ERR_SUCCESS;
 523 }
 524
 525 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo1 *r)
 526 {
 527         uint32_t _ptr_other_info;
 528         TALLOC_CTX *_mem_save_other_info_0;
 529         {
 530                 uint32_t _flags_save_STRUCT = ndr->flags;
 531                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 532                 if (ndr_flags & NDR_SCALARS) {
 533                         NDR_CHECK(ndr_pull_align(ndr, 8));
 534                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blobsize));
 535                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
 536                         NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_success));
 537                         NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_attempt));
 538                         NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
 539                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 540                         if (_ptr_other_info) {
 541                                 NDR_PULL_ALLOC(ndr, r->other_info);
 542                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->other_info, _ptr_other_info));
 543                         } else {
 544                                 r->other_info = NULL;
 545                         }
 546                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->other_info_length));
 547                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
 548                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
 549                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 550                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
 551                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
 552                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 553                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
 554                 }
 555                 if (ndr_flags & NDR_BUFFERS) {
 556                         if (r->other_info) {
 557                                 uint32_t _relative_save_offset;
 558                                 _relative_save_offset = ndr->offset;
 559                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->other_info));
 560                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 561                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 562                                 NDR_CHECK(ndr_pull_repsFromTo1OtherInfo(ndr, NDR_SCALARS, r->other_info));
 563                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 564                                 ndr->offset = _relative_save_offset;
 565                         }
 566                 }
 567                 ndr->flags = _flags_save_STRUCT;
 568         }
 569         return NDR_ERR_SUCCESS;
 570 }
 571
 572 _PUBLIC_ void ndr_print_repsFromTo1(struct ndr_print *ndr, const char *name, const struct repsFromTo1 *r)
 573 {
 574         ndr_print_struct(ndr, name, "repsFromTo1");
 575         {
 576                 uint32_t _flags_save_STRUCT = ndr->flags;
 577                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 578                 ndr->depth++;
 579                 ndr_print_uint32(ndr, "blobsize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo1(r, ndr->flags) + 8:r->blobsize);
 580                 ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
 581                 ndr_print_NTTIME_1sec(ndr, "last_success", r->last_success);
 582                 ndr_print_NTTIME_1sec(ndr, "last_attempt", r->last_attempt);
 583                 ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
 584                 ndr_print_ptr(ndr, "other_info", r->other_info);
 585                 ndr->depth++;
 586                 if (r->other_info) {
 587                         ndr_print_repsFromTo1OtherInfo(ndr, "other_info", r->other_info);
 588                 }
 589                 ndr->depth--;
 590                 ndr_print_uint32(ndr, "other_info_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo1OtherInfo(r->other_info, ndr->flags):r->other_info_length);
 591                 ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
 592                 ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
 593                 ndr_print_uint32(ndr, "reserved", r->reserved);
 594                 ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
 595                 ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
 596                 ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 597                 ndr_print_GUID(ndr, "transport_guid", &r->transport_guid);
 598                 ndr->depth--;
 599                 ndr->flags = _flags_save_STRUCT;
 600         }
 601 }
 602
 603 _PUBLIC_ size_t ndr_size_repsFromTo1(const struct repsFromTo1 *r, int flags)
 604 {
 605         flags |= LIBNDR_PRINT_ARRAY_HEX;
 606         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo1);
 607 }
 608
 609 static enum ndr_err_code ndr_push_repsFromTo(struct ndr_push *ndr, int ndr_flags, const union repsFromTo *r)
 610 {
 611         if (ndr_flags & NDR_SCALARS) {
 612                 int level = ndr_push_get_switch_value(ndr, r);
 613                 switch (level) {
 614                         case 1: {
 615                                 NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
 616                         break; }
 617
 618                         default:
 619                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 620                 }
 621         }
 622         if (ndr_flags & NDR_BUFFERS) {
 623                 int level = ndr_push_get_switch_value(ndr, r);
 624                 switch (level) {
 625                         case 1:
 626                                 NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_BUFFERS, &r->ctr1));
 627                         break;
 628
 629                         default:
 630                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 631                 }
 632         }
 633         return NDR_ERR_SUCCESS;
 634 }
 635
 636 static enum ndr_err_code ndr_pull_repsFromTo(struct ndr_pull *ndr, int ndr_flags, union repsFromTo *r)
 637 {
 638         int level;
 639         level = ndr_pull_get_switch_value(ndr, r);
 640         if (ndr_flags & NDR_SCALARS) {
 641                 switch (level) {
 642                         case 1: {
 643                                 NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
 644                         break; }
 645
 646                         default:
 647                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 648                 }
 649         }
 650         if (ndr_flags & NDR_BUFFERS) {
 651                 switch (level) {
 652                         case 1:
 653                                 NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_BUFFERS, &r->ctr1));
 654                         break;
 655
 656                         default:
 657                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 658                 }
 659         }
 660         return NDR_ERR_SUCCESS;
 661 }
 662
 663 _PUBLIC_ void ndr_print_repsFromTo(struct ndr_print *ndr, const char *name, const union repsFromTo *r)
 664 {
 665         int level;
 666         level = ndr_print_get_switch_value(ndr, r);
 667         ndr_print_union(ndr, name, level, "repsFromTo");
 668         switch (level) {
 669                 case 1:
 670                         ndr_print_repsFromTo1(ndr, "ctr1", &r->ctr1);
 671                 break;
 672
 673                 default:
 674                         ndr_print_bad_level(ndr, name, level);
 675         }
 676 }
 677
 678 _PUBLIC_ enum ndr_err_code ndr_push_repsFromToBlob(struct ndr_push *ndr, int ndr_flags, const struct repsFromToBlob *r)
 679 {
 680         if (ndr_flags & NDR_SCALARS) {
 681                 NDR_CHECK(ndr_push_align(ndr, 8));
 682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 684                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 685                 NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
 686         }
 687         if (ndr_flags & NDR_BUFFERS) {
 688                 NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
 689         }
 690         return NDR_ERR_SUCCESS;
 691 }
 692
 693 _PUBLIC_ enum ndr_err_code ndr_pull_repsFromToBlob(struct ndr_pull *ndr, int ndr_flags, struct repsFromToBlob *r)
 694 {
 695         if (ndr_flags & NDR_SCALARS) {
 696                 NDR_CHECK(ndr_pull_align(ndr, 8));
 697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 699                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 700                 NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
 701         }
 702         if (ndr_flags & NDR_BUFFERS) {
 703                 NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
 704         }
 705         return NDR_ERR_SUCCESS;
 706 }
 707
 708 _PUBLIC_ void ndr_print_repsFromToBlob(struct ndr_print *ndr, const char *name, const struct repsFromToBlob *r)
 709 {
 710         ndr_print_struct(ndr, name, "repsFromToBlob");
 711         ndr->depth++;
 712         ndr_print_uint32(ndr, "version", r->version);
 713         ndr_print_uint32(ndr, "reserved", r->reserved);
 714         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
 715         ndr_print_repsFromTo(ndr, "ctr", &r->ctr);
 716         ndr->depth--;
 717 }
 718
 719 static enum ndr_err_code ndr_push_partialAttributeSetCtr1(struct ndr_push *ndr, int ndr_flags, const struct partialAttributeSetCtr1 *r)
 720 {
 721         uint32_t cntr_array_0;
 722         if (ndr_flags & NDR_SCALARS) {
 723                 NDR_CHECK(ndr_push_align(ndr, 4));
 724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 725                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
 726                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->array[cntr_array_0]));
 727                 }
 728         }
 729         if (ndr_flags & NDR_BUFFERS) {
 730         }
 731         return NDR_ERR_SUCCESS;
 732 }
 733
 734 static enum ndr_err_code ndr_pull_partialAttributeSetCtr1(struct ndr_pull *ndr, int ndr_flags, struct partialAttributeSetCtr1 *r)
 735 {
 736         uint32_t cntr_array_0;
 737         TALLOC_CTX *_mem_save_array_0;
 738         if (ndr_flags & NDR_SCALARS) {
 739                 NDR_CHECK(ndr_pull_align(ndr, 4));
 740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 741                 NDR_PULL_ALLOC_N(ndr, r->array, r->count);
 742                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 743                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 744                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
 745                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
 746                 }
 747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 748         }
 749         if (ndr_flags & NDR_BUFFERS) {
 750         }
 751         return NDR_ERR_SUCCESS;
 752 }
 753
 754 _PUBLIC_ void ndr_print_partialAttributeSetCtr1(struct ndr_print *ndr, const char *name, const struct partialAttributeSetCtr1 *r)
 755 {
 756         uint32_t cntr_array_0;
 757         ndr_print_struct(ndr, name, "partialAttributeSetCtr1");
 758         ndr->depth++;
 759         ndr_print_uint32(ndr, "count", r->count);
 760         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 761         ndr->depth++;
 762         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
 763                 char *idx_0=NULL;
 764                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
 765                         ndr_print_drsuapi_DsAttributeId(ndr, "array", r->array[cntr_array_0]);
 766                         free(idx_0);
 767                 }
 768         }
 769         ndr->depth--;
 770         ndr->depth--;
 771 }
 772
 773 static enum ndr_err_code ndr_push_partialAttributeSetCtr(struct ndr_push *ndr, int ndr_flags, const union partialAttributeSetCtr *r)
 774 {
 775         if (ndr_flags & NDR_SCALARS) {
 776                 int level = ndr_push_get_switch_value(ndr, r);
 777                 switch (level) {
 778                         case 1: {
 779                                 NDR_CHECK(ndr_push_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
 780                         break; }
 781
 782                         default:
 783                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 784                 }
 785         }
 786         if (ndr_flags & NDR_BUFFERS) {
 787                 int level = ndr_push_get_switch_value(ndr, r);
 788                 switch (level) {
 789                         case 1:
 790                         break;
 791
 792                         default:
 793                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 794                 }
 795         }
 796         return NDR_ERR_SUCCESS;
 797 }
 798
 799 static enum ndr_err_code ndr_pull_partialAttributeSetCtr(struct ndr_pull *ndr, int ndr_flags, union partialAttributeSetCtr *r)
 800 {
 801         int level;
 802         level = ndr_pull_get_switch_value(ndr, r);
 803         if (ndr_flags & NDR_SCALARS) {
 804                 switch (level) {
 805                         case 1: {
 806                                 NDR_CHECK(ndr_pull_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
 807                         break; }
 808
 809                         default:
 810                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 811                 }
 812         }
 813         if (ndr_flags & NDR_BUFFERS) {
 814                 switch (level) {
 815                         case 1:
 816                         break;
 817
 818                         default:
 819                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 820                 }
 821         }
 822         return NDR_ERR_SUCCESS;
 823 }
 824
 825 _PUBLIC_ void ndr_print_partialAttributeSetCtr(struct ndr_print *ndr, const char *name, const union partialAttributeSetCtr *r)
 826 {
 827         int level;
 828         level = ndr_print_get_switch_value(ndr, r);
 829         ndr_print_union(ndr, name, level, "partialAttributeSetCtr");
 830         switch (level) {
 831                 case 1:
 832                         ndr_print_partialAttributeSetCtr1(ndr, "ctr1", &r->ctr1);
 833                 break;
 834
 835                 default:
 836                         ndr_print_bad_level(ndr, name, level);
 837         }
 838 }
 839
 840 _PUBLIC_ enum ndr_err_code ndr_push_partialAttributeSetBlob(struct ndr_push *ndr, int ndr_flags, const struct partialAttributeSetBlob *r)
 841 {
 842         if (ndr_flags & NDR_SCALARS) {
 843                 NDR_CHECK(ndr_push_align(ndr, 4));
 844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 846                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 847                 NDR_CHECK(ndr_push_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
 848         }
 849         if (ndr_flags & NDR_BUFFERS) {
 850         }
 851         return NDR_ERR_SUCCESS;
 852 }
 853
 854 _PUBLIC_ enum ndr_err_code ndr_pull_partialAttributeSetBlob(struct ndr_pull *ndr, int ndr_flags, struct partialAttributeSetBlob *r)
 855 {
 856         if (ndr_flags & NDR_SCALARS) {
 857                 NDR_CHECK(ndr_pull_align(ndr, 4));
 858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 860                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 861                 NDR_CHECK(ndr_pull_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
 862         }
 863         if (ndr_flags & NDR_BUFFERS) {
 864         }
 865         return NDR_ERR_SUCCESS;
 866 }
 867
 868 _PUBLIC_ void ndr_print_partialAttributeSetBlob(struct ndr_print *ndr, const char *name, const struct partialAttributeSetBlob *r)
 869 {
 870         ndr_print_struct(ndr, name, "partialAttributeSetBlob");
 871         ndr->depth++;
 872         ndr_print_uint32(ndr, "version", r->version);
 873         ndr_print_uint32(ndr, "reserved", r->reserved);
 874         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
 875         ndr_print_partialAttributeSetCtr(ndr, "ctr", &r->ctr);
 876         ndr->depth--;
 877 }
 878
 879 static enum ndr_err_code ndr_push_prefixMapVersion(struct ndr_push *ndr, int ndr_flags, enum prefixMapVersion r)
 880 {
 881         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 882         return NDR_ERR_SUCCESS;
 883 }
 884
 885 static enum ndr_err_code ndr_pull_prefixMapVersion(struct ndr_pull *ndr, int ndr_flags, enum prefixMapVersion *r)
 886 {
 887         uint32_t v;
 888         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 889         *r = v;
 890         return NDR_ERR_SUCCESS;
 891 }
 892
 893 _PUBLIC_ void ndr_print_prefixMapVersion(struct ndr_print *ndr, const char *name, enum prefixMapVersion r)
 894 {
 895         const char *val = NULL;
 896
 897         switch (r) {
 898                 case PREFIX_MAP_VERSION_DSDB: val = "PREFIX_MAP_VERSION_DSDB"; break;
 899         }
 900         ndr_print_enum(ndr, name, "ENUM", val, r);
 901 }
 902
 903 static enum ndr_err_code ndr_push_prefixMapCtr(struct ndr_push *ndr, int ndr_flags, const union prefixMapCtr *r)
 904 {
 905         if (ndr_flags & NDR_SCALARS) {
 906                 int level = ndr_push_get_switch_value(ndr, r);
 907                 switch (level) {
 908                         case PREFIX_MAP_VERSION_DSDB: {
 909                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
 910                         break; }
 911
 912                         default:
 913                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 914                 }
 915         }
 916         if (ndr_flags & NDR_BUFFERS) {
 917                 int level = ndr_push_get_switch_value(ndr, r);
 918                 switch (level) {
 919                         case PREFIX_MAP_VERSION_DSDB:
 920                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
 921                         break;
 922
 923                         default:
 924                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 925                 }
 926         }
 927         return NDR_ERR_SUCCESS;
 928 }
 929
 930 static enum ndr_err_code ndr_pull_prefixMapCtr(struct ndr_pull *ndr, int ndr_flags, union prefixMapCtr *r)
 931 {
 932         int level;
 933         level = ndr_pull_get_switch_value(ndr, r);
 934         if (ndr_flags & NDR_SCALARS) {
 935                 switch (level) {
 936                         case PREFIX_MAP_VERSION_DSDB: {
 937                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
 938                         break; }
 939
 940                         default:
 941                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 942                 }
 943         }
 944         if (ndr_flags & NDR_BUFFERS) {
 945                 switch (level) {
 946                         case PREFIX_MAP_VERSION_DSDB:
 947                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
 948                         break;
 949
 950                         default:
 951                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 952                 }
 953         }
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 _PUBLIC_ void ndr_print_prefixMapCtr(struct ndr_print *ndr, const char *name, const union prefixMapCtr *r)
 958 {
 959         int level;
 960         level = ndr_print_get_switch_value(ndr, r);
 961         ndr_print_union(ndr, name, level, "prefixMapCtr");
 962         switch (level) {
 963                 case PREFIX_MAP_VERSION_DSDB:
 964                         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "dsdb", &r->dsdb);
 965                 break;
 966
 967                 default:
 968                         ndr_print_bad_level(ndr, name, level);
 969         }
 970 }
 971
 972 _PUBLIC_ enum ndr_err_code ndr_push_prefixMapBlob(struct ndr_push *ndr, int ndr_flags, const struct prefixMapBlob *r)
 973 {
 974         if (ndr_flags & NDR_SCALARS) {
 975                 NDR_CHECK(ndr_push_align(ndr, 4));
 976                 NDR_CHECK(ndr_push_prefixMapVersion(ndr, NDR_SCALARS, r->version));
 977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 978                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
 979                 NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
 980         }
 981         if (ndr_flags & NDR_BUFFERS) {
 982                 NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
 983         }
 984         return NDR_ERR_SUCCESS;
 985 }
 986
 987 _PUBLIC_ enum ndr_err_code ndr_pull_prefixMapBlob(struct ndr_pull *ndr, int ndr_flags, struct prefixMapBlob *r)
 988 {
 989         if (ndr_flags & NDR_SCALARS) {
 990                 NDR_CHECK(ndr_pull_align(ndr, 4));
 991                 NDR_CHECK(ndr_pull_prefixMapVersion(ndr, NDR_SCALARS, &r->version));
 992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 993                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
 994                 NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
 995         }
 996         if (ndr_flags & NDR_BUFFERS) {
 997                 NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
 998         }
 999         return NDR_ERR_SUCCESS;
1000 }
1001
1002 _PUBLIC_ void ndr_print_prefixMapBlob(struct ndr_print *ndr, const char *name, const struct prefixMapBlob *r)
1003 {
1004         ndr_print_struct(ndr, name, "prefixMapBlob");
1005         ndr->depth++;
1006         ndr_print_prefixMapVersion(ndr, "version", r->version);
1007         ndr_print_uint32(ndr, "reserved", r->reserved);
1008         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1009         ndr_print_prefixMapCtr(ndr, "ctr", &r->ctr);
1010         ndr->depth--;
1011 }
1012
1013 static enum ndr_err_code ndr_push_ldapControlDirSyncExtra(struct ndr_push *ndr, int ndr_flags, const union ldapControlDirSyncExtra *r)
1014 {
1015         if (ndr_flags & NDR_SCALARS) {
1016                 int level = ndr_push_get_switch_value(ndr, r);
1017                 switch (level) {
1018                         case 0: {
1019                         break; }
1020
1021                         default: {
1022                                 NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1023                         break; }
1024
1025                 }
1026         }
1027         if (ndr_flags & NDR_BUFFERS) {
1028                 int level = ndr_push_get_switch_value(ndr, r);
1029                 switch (level) {
1030                         case 0:
1031                         break;
1032
1033                         default:
1034                         break;
1035
1036                 }
1037         }
1038         return NDR_ERR_SUCCESS;
1039 }
1040
1041 static enum ndr_err_code ndr_pull_ldapControlDirSyncExtra(struct ndr_pull *ndr, int ndr_flags, union ldapControlDirSyncExtra *r)
1042 {
1043         int level;
1044         level = ndr_pull_get_switch_value(ndr, r);
1045         if (ndr_flags & NDR_SCALARS) {
1046                 switch (level) {
1047                         case 0: {
1048                         break; }
1049
1050                         default: {
1051                                 NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1052                         break; }
1053
1054                 }
1055         }
1056         if (ndr_flags & NDR_BUFFERS) {
1057                 switch (level) {
1058                         case 0:
1059                         break;
1060
1061                         default:
1062                         break;
1063
1064                 }
1065         }
1066         return NDR_ERR_SUCCESS;
1067 }
1068
1069 _PUBLIC_ void ndr_print_ldapControlDirSyncExtra(struct ndr_print *ndr, const char *name, const union ldapControlDirSyncExtra *r)
1070 {
1071         int level;
1072         level = ndr_print_get_switch_value(ndr, r);
1073         ndr_print_union(ndr, name, level, "ldapControlDirSyncExtra");
1074         switch (level) {
1075                 case 0:
1076                 break;
1077
1078                 default:
1079                         ndr_print_replUpToDateVectorBlob(ndr, "uptodateness_vector", &r->uptodateness_vector);
1080                 break;
1081
1082         }
1083 }
1084
1085 static size_t ndr_size_ldapControlDirSyncExtra(const union ldapControlDirSyncExtra *r, uint32_t level, int flags)
1086 {
1087         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ldapControlDirSyncExtra);
1088 }
1089
1090 static enum ndr_err_code ndr_push_ldapControlDirSyncBlob(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncBlob *r)
1091 {
1092         if (ndr_flags & NDR_SCALARS) {
1093                 NDR_CHECK(ndr_push_align(ndr, 8));
1094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 3));
1095                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
1096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
1097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
1098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, 0)));
1099                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1100                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
1101                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->extra, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, 0)));
1102                 NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1103         }
1104         if (ndr_flags & NDR_BUFFERS) {
1105                 NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1106         }
1107         return NDR_ERR_SUCCESS;
1108 }
1109
1110 static enum ndr_err_code ndr_pull_ldapControlDirSyncBlob(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncBlob *r)
1111 {
1112         if (ndr_flags & NDR_SCALARS) {
1113                 NDR_CHECK(ndr_pull_align(ndr, 8));
1114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
1115                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
1116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
1117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
1118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->extra_length));
1119                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1120                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
1121                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->extra, r->extra_length));
1122                 NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1123         }
1124         if (ndr_flags & NDR_BUFFERS) {
1125                 NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1126         }
1127         return NDR_ERR_SUCCESS;
1128 }
1129
1130 _PUBLIC_ void ndr_print_ldapControlDirSyncBlob(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncBlob *r)
1131 {
1132         ndr_print_struct(ndr, name, "ldapControlDirSyncBlob");
1133         ndr->depth++;
1134         ndr_print_uint32(ndr, "u1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?3:r->u1);
1135         ndr_print_NTTIME(ndr, "time", r->time);
1136         ndr_print_uint32(ndr, "u2", r->u2);
1137         ndr_print_uint32(ndr, "u3", r->u3);
1138         ndr_print_uint32(ndr, "extra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, 0):r->extra_length);
1139         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1140         ndr_print_GUID(ndr, "guid1", &r->guid1);
1141         ndr_print_set_switch_value(ndr, &r->extra, r->extra_length);
1142         ndr_print_ldapControlDirSyncExtra(ndr, "extra", &r->extra);
1143         ndr->depth--;
1144 }
1145
1146 _PUBLIC_ enum ndr_err_code ndr_push_ldapControlDirSyncCookie(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncCookie *r)
1147 {
1148         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
1149         if (ndr_flags & NDR_SCALARS) {
1150                 NDR_CHECK(ndr_push_align(ndr, 8));
1151                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1152                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "MSDS", 4, sizeof(uint8_t), CH_DOS));
1153                 {
1154                         struct ndr_push *_ndr_blob;
1155                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_blob, 0, -1));
1156                         NDR_CHECK(ndr_push_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1157                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0, -1));
1158                 }
1159         }
1160         if (ndr_flags & NDR_BUFFERS) {
1161                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
1162         }
1163         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 _PUBLIC_ enum ndr_err_code ndr_pull_ldapControlDirSyncCookie(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncCookie *r)
1168 {
1169         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
1170         if (ndr_flags & NDR_SCALARS) {
1171                 NDR_CHECK(ndr_pull_align(ndr, 8));
1172                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
1173                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->msds, 4, sizeof(uint8_t), CH_DOS));
1174                 {
1175                         struct ndr_pull *_ndr_blob;
1176                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_blob, 0, -1));
1177                         NDR_CHECK(ndr_pull_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1178                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0, -1));
1179                 }
1180         }
1181         if (ndr_flags & NDR_BUFFERS) {
1182                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
1183         }
1184         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
1185         return NDR_ERR_SUCCESS;
1186 }
1187
1188 _PUBLIC_ void ndr_print_ldapControlDirSyncCookie(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncCookie *r)
1189 {
1190         ndr_print_struct(ndr, name, "ldapControlDirSyncCookie");
1191         ndr->depth++;
1192         ndr_print_string(ndr, "msds", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"MSDS":r->msds);
1193         ndr_print_ldapControlDirSyncBlob(ndr, "blob", &r->blob);
1194         ndr->depth--;
1195 }
1196
1197 static enum ndr_err_code ndr_push_supplementalCredentialsPackage(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsPackage *r)
1198 {
1199         if (ndr_flags & NDR_SCALARS) {
1200                 NDR_CHECK(ndr_push_align(ndr, 2));
1201                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->name)));
1202                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->data)));
1203                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
1204                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 2 * strlen_m(r->name), sizeof(uint8_t), CH_UTF16));
1205                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data, strlen(r->data), sizeof(uint8_t), CH_DOS));
1206         }
1207         if (ndr_flags & NDR_BUFFERS) {
1208         }
1209         return NDR_ERR_SUCCESS;
1210 }
1211
1212 static enum ndr_err_code ndr_pull_supplementalCredentialsPackage(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsPackage *r)
1213 {
1214         if (ndr_flags & NDR_SCALARS) {
1215                 NDR_CHECK(ndr_pull_align(ndr, 2));
1216                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
1217                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data_len));
1218                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
1219                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, r->name_len, sizeof(uint8_t), CH_UTF16));
1220                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data, r->data_len, sizeof(uint8_t), CH_DOS));
1221         }
1222         if (ndr_flags & NDR_BUFFERS) {
1223         }
1224         return NDR_ERR_SUCCESS;
1225 }
1226
1227 _PUBLIC_ void ndr_print_supplementalCredentialsPackage(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsPackage *r)
1228 {
1229         ndr_print_struct(ndr, name, "supplementalCredentialsPackage");
1230         ndr->depth++;
1231         ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->name):r->name_len);
1232         ndr_print_uint16(ndr, "data_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->data):r->data_len);
1233         ndr_print_uint16(ndr, "reserved", r->reserved);
1234         ndr_print_string(ndr, "name", r->name);
1235         ndr_print_string(ndr, "data", r->data);
1236         ndr->depth--;
1237 }
1238
1239 static enum ndr_err_code ndr_push_supplementalCredentialsSignature(struct ndr_push *ndr, int ndr_flags, enum supplementalCredentialsSignature r)
1240 {
1241         {
1242                 uint32_t _flags_save_ENUM = ndr->flags;
1243                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1244                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1245                 ndr->flags = _flags_save_ENUM;
1246         }
1247         return NDR_ERR_SUCCESS;
1248 }
1249
1250 static enum ndr_err_code ndr_pull_supplementalCredentialsSignature(struct ndr_pull *ndr, int ndr_flags, enum supplementalCredentialsSignature *r)
1251 {
1252         uint16_t v;
1253         {
1254                 uint32_t _flags_save_ENUM = ndr->flags;
1255                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1256                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1257                 *r = v;
1258                 ndr->flags = _flags_save_ENUM;
1259         }
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 _PUBLIC_ void ndr_print_supplementalCredentialsSignature(struct ndr_print *ndr, const char *name, enum supplementalCredentialsSignature r)
1264 {
1265         const char *val = NULL;
1266
1267         {
1268                 uint32_t _flags_save_ENUM = ndr->flags;
1269                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1270                 switch (r) {
1271                         case SUPPLEMENTAL_CREDENTIALS_SIGNATURE: val = "SUPPLEMENTAL_CREDENTIALS_SIGNATURE"; break;
1272                 }
1273                 ndr_print_enum(ndr, name, "ENUM", val, r);
1274                 ndr->flags = _flags_save_ENUM;
1275         }
1276 }
1277
1278 static enum ndr_err_code ndr_push_supplementalCredentialsSubBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsSubBlob *r)
1279 {
1280         uint32_t cntr_packages_0;
1281         if (ndr_flags & NDR_SCALARS) {
1282                 NDR_CHECK(ndr_push_align(ndr, 2));
1283                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_PREFIX, 0x30, sizeof(uint16_t), CH_UTF16));
1284                 NDR_CHECK(ndr_push_supplementalCredentialsSignature(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_SIGNATURE));
1285                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_packages));
1286                 for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1287                         NDR_CHECK(ndr_push_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1288                 }
1289         }
1290         if (ndr_flags & NDR_BUFFERS) {
1291         }
1292         return NDR_ERR_SUCCESS;
1293 }
1294
1295 static enum ndr_err_code ndr_pull_supplementalCredentialsSubBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsSubBlob *r)
1296 {
1297         uint32_t cntr_packages_0;
1298         TALLOC_CTX *_mem_save_packages_0;
1299         if (ndr_flags & NDR_SCALARS) {
1300                 NDR_CHECK(ndr_pull_align(ndr, 2));
1301                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->prefix, 0x30, sizeof(uint16_t), CH_UTF16));
1302                 NDR_CHECK(ndr_pull_supplementalCredentialsSignature(ndr, NDR_SCALARS, &r->signature));
1303                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_packages));
1304                 NDR_PULL_ALLOC_N(ndr, r->packages, r->num_packages);
1305                 _mem_save_packages_0 = NDR_PULL_GET_MEM_CTX(ndr);
1306                 NDR_PULL_SET_MEM_CTX(ndr, r->packages, 0);
1307                 for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1308                         NDR_CHECK(ndr_pull_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1309                 }
1310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_packages_0, 0);
1311         }
1312         if (ndr_flags & NDR_BUFFERS) {
1313         }
1314         return NDR_ERR_SUCCESS;
1315 }
1316
1317 _PUBLIC_ void ndr_print_supplementalCredentialsSubBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsSubBlob *r)
1318 {
1319         uint32_t cntr_packages_0;
1320         ndr_print_struct(ndr, name, "supplementalCredentialsSubBlob");
1321         ndr->depth++;
1322         ndr_print_string(ndr, "prefix", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_PREFIX:r->prefix);
1323         ndr_print_supplementalCredentialsSignature(ndr, "signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_SIGNATURE:r->signature);
1324         ndr_print_uint16(ndr, "num_packages", r->num_packages);
1325         ndr->print(ndr, "%s: ARRAY(%d)", "packages", (int)r->num_packages);
1326         ndr->depth++;
1327         for (cntr_packages_0=0;cntr_packages_0<r->num_packages;cntr_packages_0++) {
1328                 char *idx_0=NULL;
1329                 if (asprintf(&idx_0, "[%d]", cntr_packages_0) != -1) {
1330                         ndr_print_supplementalCredentialsPackage(ndr, "packages", &r->packages[cntr_packages_0]);
1331                         free(idx_0);
1332                 }
1333         }
1334         ndr->depth--;
1335         ndr->depth--;
1336 }
1337
1338 static size_t ndr_size_supplementalCredentialsSubBlob(const struct supplementalCredentialsSubBlob *r, int flags)
1339 {
1340         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_supplementalCredentialsSubBlob);
1341 }
1342
1343 _PUBLIC_ enum ndr_err_code ndr_push_supplementalCredentialsBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsBlob *r)
1344 {
1345         if (ndr_flags & NDR_SCALARS) {
1346                 NDR_CHECK(ndr_push_align(ndr, 4));
1347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags)));
1349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1350                 {
1351                         struct ndr_push *_ndr_sub;
1352                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags)));
1353                         NDR_CHECK(ndr_push_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1354                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags)));
1355                 }
1356                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
1357         }
1358         if (ndr_flags & NDR_BUFFERS) {
1359         }
1360         return NDR_ERR_SUCCESS;
1361 }
1362
1363 _PUBLIC_ enum ndr_err_code ndr_pull_supplementalCredentialsBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsBlob *r)
1364 {
1365         if (ndr_flags & NDR_SCALARS) {
1366                 NDR_CHECK(ndr_pull_align(ndr, 4));
1367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
1368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
1370                 {
1371                         struct ndr_pull *_ndr_sub;
1372                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sub, 0, r->__ndr_size));
1373                         NDR_CHECK(ndr_pull_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1374                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sub, 0, r->__ndr_size));
1375                 }
1376                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown3));
1377         }
1378         if (ndr_flags & NDR_BUFFERS) {
1379         }
1380         return NDR_ERR_SUCCESS;
1381 }
1382
1383 _PUBLIC_ void ndr_print_supplementalCredentialsBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsBlob *r)
1384 {
1385         ndr_print_struct(ndr, name, "supplementalCredentialsBlob");
1386         ndr->depth++;
1387         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown1);
1388         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags):r->__ndr_size);
1389         ndr_print_uint32(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown2);
1390         ndr_print_supplementalCredentialsSubBlob(ndr, "sub", &r->sub);
1391         ndr_print_uint8(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
1392         ndr->depth--;
1393 }
1394
1395 _PUBLIC_ enum ndr_err_code ndr_push_package_PackagesBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PackagesBlob *r)
1396 {
1397         if (ndr_flags & NDR_SCALARS) {
1398                 NDR_CHECK(ndr_push_align(ndr, 4));
1399                 {
1400                         uint32_t _flags_save_string_array = ndr->flags;
1401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1402                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->names));
1403                         ndr->flags = _flags_save_string_array;
1404                 }
1405         }
1406         if (ndr_flags & NDR_BUFFERS) {
1407         }
1408         return NDR_ERR_SUCCESS;
1409 }
1410
1411 _PUBLIC_ enum ndr_err_code ndr_pull_package_PackagesBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PackagesBlob *r)
1412 {
1413         if (ndr_flags & NDR_SCALARS) {
1414                 NDR_CHECK(ndr_pull_align(ndr, 4));
1415                 {
1416                         uint32_t _flags_save_string_array = ndr->flags;
1417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1418                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->names));
1419                         ndr->flags = _flags_save_string_array;
1420                 }
1421         }
1422         if (ndr_flags & NDR_BUFFERS) {
1423         }
1424         return NDR_ERR_SUCCESS;
1425 }
1426
1427 _PUBLIC_ void ndr_print_package_PackagesBlob(struct ndr_print *ndr, const char *name, const struct package_PackagesBlob *r)
1428 {
1429         ndr_print_struct(ndr, name, "package_PackagesBlob");
1430         ndr->depth++;
1431         ndr_print_string_array(ndr, "names", r->names);
1432         ndr->depth--;
1433 }
1434
1435 static enum ndr_err_code ndr_push_package_PrimaryKerberosString(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosString *r)
1436 {
1437         if (ndr_flags & NDR_SCALARS) {
1438                 NDR_CHECK(ndr_push_align(ndr, 4));
1439                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1440                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1441                 {
1442                         uint32_t _flags_save_string = ndr->flags;
1443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1444                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->string));
1445                         ndr->flags = _flags_save_string;
1446                 }
1447         }
1448         if (ndr_flags & NDR_BUFFERS) {
1449                 {
1450                         uint32_t _flags_save_string = ndr->flags;
1451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1452                         if (r->string) {
1453                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->string));
1454                                 {
1455                                         struct ndr_push *_ndr_string;
1456                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_string, 0, 2 * strlen_m(r->string)));
1457                                         NDR_CHECK(ndr_push_string(_ndr_string, NDR_SCALARS, r->string));
1458                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_string, 0, 2 * strlen_m(r->string)));
1459                                 }
1460                         }
1461                         ndr->flags = _flags_save_string;
1462                 }
1463         }
1464         return NDR_ERR_SUCCESS;
1465 }
1466
1467 static enum ndr_err_code ndr_pull_package_PrimaryKerberosString(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosString *r)
1468 {
1469         uint32_t _ptr_string;
1470         TALLOC_CTX *_mem_save_string_0;
1471         if (ndr_flags & NDR_SCALARS) {
1472                 NDR_CHECK(ndr_pull_align(ndr, 4));
1473                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
1474                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1475                 {
1476                         uint32_t _flags_save_string = ndr->flags;
1477                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1478                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
1479                         if (_ptr_string) {
1480                                 NDR_PULL_ALLOC(ndr, r->string);
1481                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->string, _ptr_string));
1482                         } else {
1483                                 r->string = NULL;
1484                         }
1485                         ndr->flags = _flags_save_string;
1486                 }
1487         }
1488         if (ndr_flags & NDR_BUFFERS) {
1489                 {
1490                         uint32_t _flags_save_string = ndr->flags;
1491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1492                         if (r->string) {
1493                                 uint32_t _relative_save_offset;
1494                                 _relative_save_offset = ndr->offset;
1495                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->string));
1496                                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
1497                                 NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
1498                                 {
1499                                         struct ndr_pull *_ndr_string;
1500                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_string, 0, r->size));
1501                                         NDR_CHECK(ndr_pull_string(_ndr_string, NDR_SCALARS, &r->string));
1502                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_string, 0, r->size));
1503                                 }
1504                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
1505                                 ndr->offset = _relative_save_offset;
1506                         }
1507                         ndr->flags = _flags_save_string;
1508                 }
1509         }
1510         return NDR_ERR_SUCCESS;
1511 }
1512
1513 _PUBLIC_ void ndr_print_package_PrimaryKerberosString(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosString *r)
1514 {
1515         ndr_print_struct(ndr, name, "package_PrimaryKerberosString");
1516         ndr->depth++;
1517         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
1518         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
1519         ndr_print_ptr(ndr, "string", r->string);
1520         ndr->depth++;
1521         if (r->string) {
1522                 ndr_print_string(ndr, "string", r->string);
1523         }
1524         ndr->depth--;
1525         ndr->depth--;
1526 }
1527
1528 static enum ndr_err_code ndr_push_package_PrimaryKerberosKey3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey3 *r)
1529 {
1530         if (ndr_flags & NDR_SCALARS) {
1531                 NDR_CHECK(ndr_push_align(ndr, 4));
1532                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1533                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
1536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
1537                 {
1538                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1540                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
1541                         ndr->flags = _flags_save_DATA_BLOB;
1542                 }
1543         }
1544         if (ndr_flags & NDR_BUFFERS) {
1545                 {
1546                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1548                         if (r->value) {
1549                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value));
1550                                 {
1551                                         struct ndr_push *_ndr_value;
1552                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
1553                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
1554                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
1555                                 }
1556                         }
1557                         ndr->flags = _flags_save_DATA_BLOB;
1558                 }
1559         }
1560         return NDR_ERR_SUCCESS;
1561 }
1562
1563 static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey3 *r)
1564 {
1565         uint32_t _ptr_value;
1566         TALLOC_CTX *_mem_save_value_0;
1567         if (ndr_flags & NDR_SCALARS) {
1568                 NDR_CHECK(ndr_pull_align(ndr, 4));
1569                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
1570                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
1571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
1572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
1573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
1574                 {
1575                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1577                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
1578                         if (_ptr_value) {
1579                                 NDR_PULL_ALLOC(ndr, r->value);
1580                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
1581                         } else {
1582                                 r->value = NULL;
1583                         }
1584                         ndr->flags = _flags_save_DATA_BLOB;
1585                 }
1586         }
1587         if (ndr_flags & NDR_BUFFERS) {
1588                 {
1589                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1591                         if (r->value) {
1592                                 uint32_t _relative_save_offset;
1593                                 _relative_save_offset = ndr->offset;
1594                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
1595                                 _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
1596                                 NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
1597                                 {
1598                                         struct ndr_pull *_ndr_value;
1599                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
1600                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
1601                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
1602                                 }
1603                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
1604                                 ndr->offset = _relative_save_offset;
1605                         }
1606                         ndr->flags = _flags_save_DATA_BLOB;
1607                 }
1608         }
1609         return NDR_ERR_SUCCESS;
1610 }
1611
1612 _PUBLIC_ void ndr_print_package_PrimaryKerberosKey3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey3 *r)
1613 {
1614         ndr_print_struct(ndr, name, "package_PrimaryKerberosKey3");
1615         ndr->depth++;
1616         ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1617         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1618         ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
1619         ndr_print_uint32(ndr, "keytype", r->keytype);
1620         ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
1621         ndr_print_ptr(ndr, "value", r->value);
1622         ndr->depth++;
1623         if (r->value) {
1624                 ndr_print_DATA_BLOB(ndr, "value", *r->value);
1625         }
1626         ndr->depth--;
1627         ndr->depth--;
1628 }
1629
1630 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr3 *r)
1631 {
1632         uint32_t cntr_keys_0;
1633         uint32_t cntr_old_keys_0;
1634         if (ndr_flags & NDR_SCALARS) {
1635                 NDR_CHECK(ndr_push_align(ndr, 4));
1636                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
1637                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
1638                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
1639                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1640                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
1641                 }
1642                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1643                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
1644                 }
1645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1650         }
1651         if (ndr_flags & NDR_BUFFERS) {
1652                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
1653                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1654                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
1655                 }
1656                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1657                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
1658                 }
1659         }
1660         return NDR_ERR_SUCCESS;
1661 }
1662
1663 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr3 *r)
1664 {
1665         uint32_t cntr_keys_0;
1666         TALLOC_CTX *_mem_save_keys_0;
1667         uint32_t cntr_old_keys_0;
1668         TALLOC_CTX *_mem_save_old_keys_0;
1669         if (ndr_flags & NDR_SCALARS) {
1670                 NDR_CHECK(ndr_pull_align(ndr, 4));
1671                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
1672                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
1673                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
1674                 NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
1675                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1676                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
1677                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1678                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
1679                 }
1680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
1681                 NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
1682                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1683                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
1684                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1685                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
1686                 }
1687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
1688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding1));
1689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding2));
1690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding3));
1691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding4));
1692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding5));
1693         }
1694         if (ndr_flags & NDR_BUFFERS) {
1695                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
1696                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1697                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
1698                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1699                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
1700                 }
1701                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
1702                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1703                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
1704                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1705                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
1706                 }
1707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
1708         }
1709         return NDR_ERR_SUCCESS;
1710 }
1711
1712 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr3 *r)
1713 {
1714         uint32_t cntr_keys_0;
1715         uint32_t cntr_old_keys_0;
1716         ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr3");
1717         ndr->depth++;
1718         ndr_print_uint16(ndr, "num_keys", r->num_keys);
1719         ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
1720         ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
1721         ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
1722         ndr->depth++;
1723         for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
1724                 char *idx_0=NULL;
1725                 if (asprintf(&idx_0, "[%d]", cntr_keys_0) != -1) {
1726                         ndr_print_package_PrimaryKerberosKey3(ndr, "keys", &r->keys[cntr_keys_0]);
1727                         free(idx_0);
1728                 }
1729         }
1730         ndr->depth--;
1731         ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
1732         ndr->depth++;
1733         for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
1734                 char *idx_0=NULL;
1735                 if (asprintf(&idx_0, "[%d]", cntr_old_keys_0) != -1) {
1736                         ndr_print_package_PrimaryKerberosKey3(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
1737                         free(idx_0);
1738                 }
1739         }
1740         ndr->depth--;
1741         ndr_print_uint32(ndr, "padding1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding1);
1742         ndr_print_uint32(ndr, "padding2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding2);
1743         ndr_print_uint32(ndr, "padding3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding3);
1744         ndr_print_uint32(ndr, "padding4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding4);
1745         ndr_print_uint32(ndr, "padding5", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding5);
1746         ndr->depth--;
1747 }
1748
1749 static enum ndr_err_code ndr_push_package_PrimaryKerberosKey4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey4 *r)
1750 {
1751         if (ndr_flags & NDR_SCALARS) {
1752                 NDR_CHECK(ndr_push_align(ndr, 4));
1753                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1754                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iteration_count));
1757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
1758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
1759                 {
1760                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1762                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
1763                         ndr->flags = _flags_save_DATA_BLOB;
1764                 }
1765         }
1766         if (ndr_flags & NDR_BUFFERS) {
1767                 {
1768                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1770                         if (r->value) {
1771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value));
1772                                 {
1773                                         struct ndr_push *_ndr_value;
1774                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
1775                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
1776                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
1777                                 }
1778                         }
1779                         ndr->flags = _flags_save_DATA_BLOB;
1780                 }
1781         }
1782         return NDR_ERR_SUCCESS;
1783 }
1784
1785 static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey4 *r)
1786 {
1787         uint32_t _ptr_value;
1788         TALLOC_CTX *_mem_save_value_0;
1789         if (ndr_flags & NDR_SCALARS) {
1790                 NDR_CHECK(ndr_pull_align(ndr, 4));
1791                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
1792                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
1793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
1794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iteration_count));
1795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
1796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
1797                 {
1798                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
1801                         if (_ptr_value) {
1802                                 NDR_PULL_ALLOC(ndr, r->value);
1803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
1804                         } else {
1805                                 r->value = NULL;
1806                         }
1807                         ndr->flags = _flags_save_DATA_BLOB;
1808                 }
1809         }
1810         if (ndr_flags & NDR_BUFFERS) {
1811                 {
1812                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1814                         if (r->value) {
1815                                 uint32_t _relative_save_offset;
1816                                 _relative_save_offset = ndr->offset;
1817                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
1818                                 _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
1819                                 NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
1820                                 {
1821                                         struct ndr_pull *_ndr_value;
1822                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
1823                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
1824                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
1825                                 }
1826                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
1827                                 ndr->offset = _relative_save_offset;
1828                         }
1829                         ndr->flags = _flags_save_DATA_BLOB;
1830                 }
1831         }
1832         return NDR_ERR_SUCCESS;
1833 }
1834
1835 _PUBLIC_ void ndr_print_package_PrimaryKerberosKey4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey4 *r)
1836 {
1837         ndr_print_struct(ndr, name, "package_PrimaryKerberosKey4");
1838         ndr->depth++;
1839         ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1840         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1841         ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
1842         ndr_print_uint32(ndr, "iteration_count", r->iteration_count);
1843         ndr_print_uint32(ndr, "keytype", r->keytype);
1844         ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
1845         ndr_print_ptr(ndr, "value", r->value);
1846         ndr->depth++;
1847         if (r->value) {
1848                 ndr_print_DATA_BLOB(ndr, "value", *r->value);
1849         }
1850         ndr->depth--;
1851         ndr->depth--;
1852 }
1853
1854 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr4 *r)
1855 {
1856         uint32_t cntr_keys_0;
1857         uint32_t cntr_service_keys_0;
1858         uint32_t cntr_old_keys_0;
1859         uint32_t cntr_older_keys_0;
1860         if (ndr_flags & NDR_SCALARS) {
1861                 NDR_CHECK(ndr_push_align(ndr, 4));
1862                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
1863                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1864                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
1865                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_older_keys));
1866                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
1867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->default_iteration_count));
1868                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1869                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
1870                 }
1871                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < 0; cntr_service_keys_0++) {
1872                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->service_keys[cntr_service_keys_0]));
1873                 }
1874                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1875                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
1876                 }
1877                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
1878                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
1879                 }
1880         }
1881         if (ndr_flags & NDR_BUFFERS) {
1882                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
1883                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1884                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
1885                 }
1886                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < 0; cntr_service_keys_0++) {
1887                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->service_keys[cntr_service_keys_0]));
1888                 }
1889                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1890                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
1891                 }
1892                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
1893                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
1894                 }
1895         }
1896         return NDR_ERR_SUCCESS;
1897 }
1898
1899 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr4 *r)
1900 {
1901         uint32_t cntr_keys_0;
1902         TALLOC_CTX *_mem_save_keys_0;
1903         uint32_t cntr_service_keys_0;
1904         TALLOC_CTX *_mem_save_service_keys_0;
1905         uint32_t cntr_old_keys_0;
1906         TALLOC_CTX *_mem_save_old_keys_0;
1907         uint32_t cntr_older_keys_0;
1908         TALLOC_CTX *_mem_save_older_keys_0;
1909         if (ndr_flags & NDR_SCALARS) {
1910                 NDR_CHECK(ndr_pull_align(ndr, 4));
1911                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
1912                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_service_keys));
1913                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
1914                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_older_keys));
1915                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
1916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->default_iteration_count));
1917                 NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
1918                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1919                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
1920                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1921                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
1922                 }
1923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
1924                 NDR_PULL_ALLOC_N(ndr, r->service_keys, r->num_service_keys);
1925                 _mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1926                 NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
1927                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
1928                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->service_keys[cntr_service_keys_0]));
1929                 }
1930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
1931                 NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
1932                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1933                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
1934                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1935                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
1936                 }
1937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
1938                 NDR_PULL_ALLOC_N(ndr, r->older_keys, r->num_older_keys);
1939                 _mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1940                 NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
1941                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
1942                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
1943                 }
1944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
1945         }
1946         if (ndr_flags & NDR_BUFFERS) {
1947                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
1948                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1949                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
1950                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
1951                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
1952                 }
1953                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
1954                 _mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1955                 NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
1956                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
1957                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->service_keys[cntr_service_keys_0]));
1958                 }
1959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
1960                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1961                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
1962                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
1963                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
1964                 }
1965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
1966                 _mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
1967                 NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
1968                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
1969                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
1970                 }
1971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
1972         }
1973         return NDR_ERR_SUCCESS;
1974 }
1975
1976 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr4 *r)
1977 {
1978         uint32_t cntr_keys_0;
1979         uint32_t cntr_service_keys_0;
1980         uint32_t cntr_old_keys_0;
1981         uint32_t cntr_older_keys_0;
1982         ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr4");
1983         ndr->depth++;
1984         ndr_print_uint16(ndr, "num_keys", r->num_keys);
1985         ndr_print_uint16(ndr, "num_service_keys", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->num_service_keys);
1986         ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
1987         ndr_print_uint16(ndr, "num_older_keys", r->num_older_keys);
1988         ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
1989         ndr_print_uint32(ndr, "default_iteration_count", r->default_iteration_count);
1990         ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
1991         ndr->depth++;
1992         for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
1993                 char *idx_0=NULL;
1994                 if (asprintf(&idx_0, "[%d]", cntr_keys_0) != -1) {
1995                         ndr_print_package_PrimaryKerberosKey4(ndr, "keys", &r->keys[cntr_keys_0]);
1996                         free(idx_0);
1997                 }
1998         }
1999         ndr->depth--;
2000         ndr->print(ndr, "%s: ARRAY(%d)", "service_keys", (int)r->num_service_keys);
2001         ndr->depth++;
2002         for (cntr_service_keys_0=0;cntr_service_keys_0<r->num_service_keys;cntr_service_keys_0++) {
2003                 char *idx_0=NULL;
2004                 if (asprintf(&idx_0, "[%d]", cntr_service_keys_0) != -1) {
2005                         ndr_print_package_PrimaryKerberosKey4(ndr, "service_keys", &r->service_keys[cntr_service_keys_0]);
2006                         free(idx_0);
2007                 }
2008         }
2009         ndr->depth--;
2010         ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2011         ndr->depth++;
2012         for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2013                 char *idx_0=NULL;
2014                 if (asprintf(&idx_0, "[%d]", cntr_old_keys_0) != -1) {
2015                         ndr_print_package_PrimaryKerberosKey4(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2016                         free(idx_0);
2017                 }
2018         }
2019         ndr->depth--;
2020         ndr->print(ndr, "%s: ARRAY(%d)", "older_keys", (int)r->num_older_keys);
2021         ndr->depth++;
2022         for (cntr_older_keys_0=0;cntr_older_keys_0<r->num_older_keys;cntr_older_keys_0++) {
2023                 char *idx_0=NULL;
2024                 if (asprintf(&idx_0, "[%d]", cntr_older_keys_0) != -1) {
2025                         ndr_print_package_PrimaryKerberosKey4(ndr, "older_keys", &r->older_keys[cntr_older_keys_0]);
2026                         free(idx_0);
2027                 }
2028         }
2029         ndr->depth--;
2030         ndr->depth--;
2031 }
2032
2033 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr(struct ndr_push *ndr, int ndr_flags, const union package_PrimaryKerberosCtr *r)
2034 {
2035         if (ndr_flags & NDR_SCALARS) {
2036                 int level = ndr_push_get_switch_value(ndr, r);
2037                 switch (level) {
2038                         case 3: {
2039                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2040                         break; }
2041
2042                         case 4: {
2043                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2044                         break; }
2045
2046                         default:
2047                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2048                 }
2049         }
2050         if (ndr_flags & NDR_BUFFERS) {
2051                 int level = ndr_push_get_switch_value(ndr, r);
2052                 switch (level) {
2053                         case 3:
2054                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2055                         break;
2056
2057                         case 4:
2058                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2059                         break;
2060
2061                         default:
2062                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2063                 }
2064         }
2065         return NDR_ERR_SUCCESS;
2066 }
2067
2068 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr(struct ndr_pull *ndr, int ndr_flags, union package_PrimaryKerberosCtr *r)
2069 {
2070         int level;
2071         level = ndr_pull_get_switch_value(ndr, r);
2072         if (ndr_flags & NDR_SCALARS) {
2073                 switch (level) {
2074                         case 3: {
2075                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2076                         break; }
2077
2078                         case 4: {
2079                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2080                         break; }
2081
2082                         default:
2083                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2084                 }
2085         }
2086         if (ndr_flags & NDR_BUFFERS) {
2087                 switch (level) {
2088                         case 3:
2089                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2090                         break;
2091
2092                         case 4:
2093                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2094                         break;
2095
2096                         default:
2097                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2098                 }
2099         }
2100         return NDR_ERR_SUCCESS;
2101 }
2102
2103 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr(struct ndr_print *ndr, const char *name, const union package_PrimaryKerberosCtr *r)
2104 {
2105         int level;
2106         level = ndr_print_get_switch_value(ndr, r);
2107         ndr_print_union(ndr, name, level, "package_PrimaryKerberosCtr");
2108         switch (level) {
2109                 case 3:
2110                         ndr_print_package_PrimaryKerberosCtr3(ndr, "ctr3", &r->ctr3);
2111                 break;
2112
2113                 case 4:
2114                         ndr_print_package_PrimaryKerberosCtr4(ndr, "ctr4", &r->ctr4);
2115                 break;
2116
2117                 default:
2118                         ndr_print_bad_level(ndr, name, level);
2119         }
2120 }
2121
2122 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryKerberosBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosBlob *r)
2123 {
2124         if (ndr_flags & NDR_SCALARS) {
2125                 NDR_CHECK(ndr_push_align(ndr, 4));
2126                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
2127                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2128                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
2129                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2130         }
2131         if (ndr_flags & NDR_BUFFERS) {
2132                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2133         }
2134         return NDR_ERR_SUCCESS;
2135 }
2136
2137 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryKerberosBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosBlob *r)
2138 {
2139         if (ndr_flags & NDR_SCALARS) {
2140                 NDR_CHECK(ndr_pull_align(ndr, 4));
2141                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
2142                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
2143                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
2144                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2145         }
2146         if (ndr_flags & NDR_BUFFERS) {
2147                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2148         }
2149         return NDR_ERR_SUCCESS;
2150 }
2151
2152 _PUBLIC_ void ndr_print_package_PrimaryKerberosBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosBlob *r)
2153 {
2154         ndr_print_struct(ndr, name, "package_PrimaryKerberosBlob");
2155         ndr->depth++;
2156         ndr_print_uint16(ndr, "version", r->version);
2157         ndr_print_uint16(ndr, "flags", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flags);
2158         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
2159         ndr_print_package_PrimaryKerberosCtr(ndr, "ctr", &r->ctr);
2160         ndr->depth--;
2161 }
2162
2163 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryCLEARTEXTBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryCLEARTEXTBlob *r)
2164 {
2165         if (ndr_flags & NDR_SCALARS) {
2166                 NDR_CHECK(ndr_push_align(ndr, 4));
2167                 {
2168                         uint32_t _flags_save_string = ndr->flags;
2169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
2170                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->cleartext));
2171                         ndr->flags = _flags_save_string;
2172                 }
2173         }
2174         if (ndr_flags & NDR_BUFFERS) {
2175         }
2176         return NDR_ERR_SUCCESS;
2177 }
2178
2179 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryCLEARTEXTBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryCLEARTEXTBlob *r)
2180 {
2181         if (ndr_flags & NDR_SCALARS) {
2182                 NDR_CHECK(ndr_pull_align(ndr, 4));
2183                 {
2184                         uint32_t _flags_save_string = ndr->flags;
2185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
2186                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->cleartext));
2187                         ndr->flags = _flags_save_string;
2188                 }
2189         }
2190         if (ndr_flags & NDR_BUFFERS) {
2191         }
2192         return NDR_ERR_SUCCESS;
2193 }
2194
2195 _PUBLIC_ void ndr_print_package_PrimaryCLEARTEXTBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryCLEARTEXTBlob *r)
2196 {
2197         ndr_print_struct(ndr, name, "package_PrimaryCLEARTEXTBlob");
2198         ndr->depth++;
2199         ndr_print_string(ndr, "cleartext", r->cleartext);
2200         ndr->depth--;
2201 }
2202
2203 static enum ndr_err_code ndr_push_package_PrimaryWDigestHash(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestHash *r)
2204 {
2205         {
2206                 uint32_t _flags_save_STRUCT = ndr->flags;
2207                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2208                 if (ndr_flags & NDR_SCALARS) {
2209                         NDR_CHECK(ndr_push_align(ndr, 1));
2210                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2211                 }
2212                 if (ndr_flags & NDR_BUFFERS) {
2213                 }
2214                 ndr->flags = _flags_save_STRUCT;
2215         }
2216         return NDR_ERR_SUCCESS;
2217 }
2218
2219 static enum ndr_err_code ndr_pull_package_PrimaryWDigestHash(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestHash *r)
2220 {
2221         {
2222                 uint32_t _flags_save_STRUCT = ndr->flags;
2223                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2224                 if (ndr_flags & NDR_SCALARS) {
2225                         NDR_CHECK(ndr_pull_align(ndr, 1));
2226                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2227                 }
2228                 if (ndr_flags & NDR_BUFFERS) {
2229                 }
2230                 ndr->flags = _flags_save_STRUCT;
2231         }
2232         return NDR_ERR_SUCCESS;
2233 }
2234
2235 _PUBLIC_ void ndr_print_package_PrimaryWDigestHash(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestHash *r)
2236 {
2237         ndr_print_struct(ndr, name, "package_PrimaryWDigestHash");
2238         {
2239                 uint32_t _flags_save_STRUCT = ndr->flags;
2240                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2241                 ndr->depth++;
2242                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2243                 ndr->depth--;
2244                 ndr->flags = _flags_save_STRUCT;
2245         }
2246 }
2247
2248 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryWDigestBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestBlob *r)
2249 {
2250         uint32_t cntr_hashes_0;
2251         if (ndr_flags & NDR_SCALARS) {
2252                 NDR_CHECK(ndr_push_align(ndr, 4));
2253                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0x31));
2254                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0x01));
2255                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_hashes));
2256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2257                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, 0));
2258                 for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2259                         NDR_CHECK(ndr_push_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2260                 }
2261         }
2262         if (ndr_flags & NDR_BUFFERS) {
2263         }
2264         return NDR_ERR_SUCCESS;
2265 }
2266
2267 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryWDigestBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestBlob *r)
2268 {
2269         uint32_t cntr_hashes_0;
2270         TALLOC_CTX *_mem_save_hashes_0;
2271         if (ndr_flags & NDR_SCALARS) {
2272                 NDR_CHECK(ndr_pull_align(ndr, 4));
2273                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
2274                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown2));
2275                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_hashes));
2276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
2277                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->uuknown4));
2278                 NDR_PULL_ALLOC_N(ndr, r->hashes, r->num_hashes);
2279                 _mem_save_hashes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2280                 NDR_PULL_SET_MEM_CTX(ndr, r->hashes, 0);
2281                 for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2282                         NDR_CHECK(ndr_pull_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2283                 }
2284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hashes_0, 0);
2285         }
2286         if (ndr_flags & NDR_BUFFERS) {
2287         }
2288         return NDR_ERR_SUCCESS;
2289 }
2290
2291 _PUBLIC_ void ndr_print_package_PrimaryWDigestBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestBlob *r)
2292 {
2293         uint32_t cntr_hashes_0;
2294         ndr_print_struct(ndr, name, "package_PrimaryWDigestBlob");
2295         ndr->depth++;
2296         ndr_print_uint16(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x31:r->unknown1);
2297         ndr_print_uint8(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x01:r->unknown2);
2298         ndr_print_uint8(ndr, "num_hashes", r->num_hashes);
2299         ndr_print_uint32(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
2300         ndr_print_udlong(ndr, "uuknown4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->uuknown4);
2301         ndr->print(ndr, "%s: ARRAY(%d)", "hashes", (int)r->num_hashes);
2302         ndr->depth++;
2303         for (cntr_hashes_0=0;cntr_hashes_0<r->num_hashes;cntr_hashes_0++) {
2304                 char *idx_0=NULL;
2305                 if (asprintf(&idx_0, "[%d]", cntr_hashes_0) != -1) {
2306                         ndr_print_package_PrimaryWDigestHash(ndr, "hashes", &r->hashes[cntr_hashes_0]);
2307                         free(idx_0);
2308                 }
2309         }
2310         ndr->depth--;
2311         ndr->depth--;
2312 }
2313
2314 static enum ndr_err_code ndr_push_trustAuthInOutSecret1(struct ndr_push *ndr, int ndr_flags, const struct trustAuthInOutSecret1 *r)
2315 {
2316         if (ndr_flags & NDR_SCALARS) {
2317                 NDR_CHECK(ndr_push_align(ndr, 4));
2318                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time1));
2319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
2320                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
2321                 {
2322                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2324                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
2325                         ndr->flags = _flags_save_DATA_BLOB;
2326                 }
2327         }
2328         if (ndr_flags & NDR_BUFFERS) {
2329         }
2330         return NDR_ERR_SUCCESS;
2331 }
2332
2333 static enum ndr_err_code ndr_pull_trustAuthInOutSecret1(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutSecret1 *r)
2334 {
2335         if (ndr_flags & NDR_SCALARS) {
2336                 NDR_CHECK(ndr_pull_align(ndr, 4));
2337                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time1));
2338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
2339                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
2340                 {
2341                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2343                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
2344                         ndr->flags = _flags_save_DATA_BLOB;
2345                 }
2346         }
2347         if (ndr_flags & NDR_BUFFERS) {
2348         }
2349         return NDR_ERR_SUCCESS;
2350 }
2351
2352 _PUBLIC_ void ndr_print_trustAuthInOutSecret1(struct ndr_print *ndr, const char *name, const struct trustAuthInOutSecret1 *r)
2353 {
2354         ndr_print_struct(ndr, name, "trustAuthInOutSecret1");
2355         ndr->depth++;
2356         ndr_print_NTTIME(ndr, "time1", r->time1);
2357         ndr_print_uint32(ndr, "unknown1", r->unknown1);
2358         ndr_print_DATA_BLOB(ndr, "value", r->value);
2359         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
2360         ndr->depth--;
2361 }
2362
2363 static enum ndr_err_code ndr_push_trustAuthInOutCtr1(struct ndr_push *ndr, int ndr_flags, const struct trustAuthInOutCtr1 *r)
2364 {
2365         if (ndr_flags & NDR_SCALARS) {
2366                 NDR_CHECK(ndr_push_align(ndr, 4));
2367                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value1));
2368                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value2));
2369         }
2370         if (ndr_flags & NDR_BUFFERS) {
2371                 if (r->value1) {
2372                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value1));
2373                         NDR_CHECK(ndr_push_trustAuthInOutSecret1(ndr, NDR_SCALARS, r->value1));
2374                 }
2375                 if (r->value2) {
2376                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value2));
2377                         NDR_CHECK(ndr_push_trustAuthInOutSecret1(ndr, NDR_SCALARS, r->value2));
2378                 }
2379         }
2380         return NDR_ERR_SUCCESS;
2381 }
2382
2383 static enum ndr_err_code ndr_pull_trustAuthInOutCtr1(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutCtr1 *r)
2384 {
2385         uint32_t _ptr_value1;
2386         TALLOC_CTX *_mem_save_value1_0;
2387         uint32_t _ptr_value2;
2388         TALLOC_CTX *_mem_save_value2_0;
2389         if (ndr_flags & NDR_SCALARS) {
2390                 NDR_CHECK(ndr_pull_align(ndr, 4));
2391                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value1));
2392                 if (_ptr_value1) {
2393                         NDR_PULL_ALLOC(ndr, r->value1);
2394                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value1, _ptr_value1));
2395                 } else {
2396                         r->value1 = NULL;
2397                 }
2398                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value2));
2399                 if (_ptr_value2) {
2400                         NDR_PULL_ALLOC(ndr, r->value2);
2401                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value2, _ptr_value2));
2402                 } else {
2403                         r->value2 = NULL;
2404                 }
2405         }
2406         if (ndr_flags & NDR_BUFFERS) {
2407                 if (r->value1) {
2408                         uint32_t _relative_save_offset;
2409                         _relative_save_offset = ndr->offset;
2410                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value1));
2411                         _mem_save_value1_0 = NDR_PULL_GET_MEM_CTX(ndr);
2412                         NDR_PULL_SET_MEM_CTX(ndr, r->value1, 0);
2413                         NDR_CHECK(ndr_pull_trustAuthInOutSecret1(ndr, NDR_SCALARS, r->value1));
2414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value1_0, 0);
2415                         ndr->offset = _relative_save_offset;
2416                 }
2417                 if (r->value2) {
2418                         uint32_t _relative_save_offset;
2419                         _relative_save_offset = ndr->offset;
2420                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value2));
2421                         _mem_save_value2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2422                         NDR_PULL_SET_MEM_CTX(ndr, r->value2, 0);
2423                         NDR_CHECK(ndr_pull_trustAuthInOutSecret1(ndr, NDR_SCALARS, r->value2));
2424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value2_0, 0);
2425                         ndr->offset = _relative_save_offset;
2426                 }
2427         }
2428         return NDR_ERR_SUCCESS;
2429 }
2430
2431 _PUBLIC_ void ndr_print_trustAuthInOutCtr1(struct ndr_print *ndr, const char *name, const struct trustAuthInOutCtr1 *r)
2432 {
2433         ndr_print_struct(ndr, name, "trustAuthInOutCtr1");
2434         ndr->depth++;
2435         ndr_print_ptr(ndr, "value1", r->value1);
2436         ndr->depth++;
2437         if (r->value1) {
2438                 ndr_print_trustAuthInOutSecret1(ndr, "value1", r->value1);
2439         }
2440         ndr->depth--;
2441         ndr_print_ptr(ndr, "value2", r->value2);
2442         ndr->depth++;
2443         if (r->value2) {
2444                 ndr_print_trustAuthInOutSecret1(ndr, "value2", r->value2);
2445         }
2446         ndr->depth--;
2447         ndr->depth--;
2448 }
2449
2450 static enum ndr_err_code ndr_push_trustAuthInOutSecret2V1(struct ndr_push *ndr, int ndr_flags, const struct trustAuthInOutSecret2V1 *r)
2451 {
2452         if (ndr_flags & NDR_SCALARS) {
2453                 NDR_CHECK(ndr_push_align(ndr, 4));
2454                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time1));
2455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
2456                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
2457                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
2458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
2459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
2460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
2461                 {
2462                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2464                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
2465                         ndr->flags = _flags_save_DATA_BLOB;
2466                 }
2467         }
2468         if (ndr_flags & NDR_BUFFERS) {
2469         }
2470         return NDR_ERR_SUCCESS;
2471 }
2472
2473 static enum ndr_err_code ndr_pull_trustAuthInOutSecret2V1(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutSecret2V1 *r)
2474 {
2475         if (ndr_flags & NDR_SCALARS) {
2476                 NDR_CHECK(ndr_pull_align(ndr, 4));
2477                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time1));
2478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
2479                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
2480                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
2481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
2482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
2483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
2484                 {
2485                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2487                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
2488                         ndr->flags = _flags_save_DATA_BLOB;
2489                 }
2490         }
2491         if (ndr_flags & NDR_BUFFERS) {
2492         }
2493         return NDR_ERR_SUCCESS;
2494 }
2495
2496 _PUBLIC_ void ndr_print_trustAuthInOutSecret2V1(struct ndr_print *ndr, const char *name, const struct trustAuthInOutSecret2V1 *r)
2497 {
2498         ndr_print_struct(ndr, name, "trustAuthInOutSecret2V1");
2499         ndr->depth++;
2500         ndr_print_NTTIME(ndr, "time1", r->time1);
2501         ndr_print_uint32(ndr, "unknown1", r->unknown1);
2502         ndr_print_DATA_BLOB(ndr, "value", r->value);
2503         ndr_print_NTTIME(ndr, "time2", r->time2);
2504         ndr_print_uint32(ndr, "unknown2", r->unknown2);
2505         ndr_print_uint32(ndr, "unknown3", r->unknown3);
2506         ndr_print_uint32(ndr, "unknown4", r->unknown4);
2507         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
2508         ndr->depth--;
2509 }
2510
2511 static enum ndr_err_code ndr_push_trustAuthInOutSecret2V2(struct ndr_push *ndr, int ndr_flags, const struct trustAuthInOutSecret2V2 *r)
2512 {
2513         if (ndr_flags & NDR_SCALARS) {
2514                 NDR_CHECK(ndr_push_align(ndr, 4));
2515                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time1));
2516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
2517                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
2518                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
2519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
2520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
2521                 {
2522                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2524                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
2525                         ndr->flags = _flags_save_DATA_BLOB;
2526                 }
2527         }
2528         if (ndr_flags & NDR_BUFFERS) {
2529         }
2530         return NDR_ERR_SUCCESS;
2531 }
2532
2533 static enum ndr_err_code ndr_pull_trustAuthInOutSecret2V2(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutSecret2V2 *r)
2534 {
2535         if (ndr_flags & NDR_SCALARS) {
2536                 NDR_CHECK(ndr_pull_align(ndr, 4));
2537                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time1));
2538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
2539                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
2540                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
2541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
2542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
2543                 {
2544                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2546                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
2547                         ndr->flags = _flags_save_DATA_BLOB;
2548                 }
2549         }
2550         if (ndr_flags & NDR_BUFFERS) {
2551         }
2552         return NDR_ERR_SUCCESS;
2553 }
2554
2555 _PUBLIC_ void ndr_print_trustAuthInOutSecret2V2(struct ndr_print *ndr, const char *name, const struct trustAuthInOutSecret2V2 *r)
2556 {
2557         ndr_print_struct(ndr, name, "trustAuthInOutSecret2V2");
2558         ndr->depth++;
2559         ndr_print_NTTIME(ndr, "time1", r->time1);
2560         ndr_print_uint32(ndr, "unknown1", r->unknown1);
2561         ndr_print_DATA_BLOB(ndr, "value", r->value);
2562         ndr_print_NTTIME(ndr, "time2", r->time2);
2563         ndr_print_uint32(ndr, "unknown2", r->unknown2);
2564         ndr_print_uint32(ndr, "unknown3", r->unknown3);
2565         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
2566         ndr->depth--;
2567 }
2568
2569 static enum ndr_err_code ndr_push_trustAuthInOutCtr2(struct ndr_push *ndr, int ndr_flags, const struct trustAuthInOutCtr2 *r)
2570 {
2571         if (ndr_flags & NDR_SCALARS) {
2572                 NDR_CHECK(ndr_push_align(ndr, 4));
2573                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value1));
2574                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value2));
2575         }
2576         if (ndr_flags & NDR_BUFFERS) {
2577                 if (r->value1) {
2578                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value1));
2579                         NDR_CHECK(ndr_push_trustAuthInOutSecret2V1(ndr, NDR_SCALARS, r->value1));
2580                 }
2581                 if (r->value2) {
2582                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value2));
2583                         NDR_CHECK(ndr_push_trustAuthInOutSecret2V2(ndr, NDR_SCALARS, r->value2));
2584                 }
2585         }
2586         return NDR_ERR_SUCCESS;
2587 }
2588
2589 static enum ndr_err_code ndr_pull_trustAuthInOutCtr2(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutCtr2 *r)
2590 {
2591         uint32_t _ptr_value1;
2592         TALLOC_CTX *_mem_save_value1_0;
2593         uint32_t _ptr_value2;
2594         TALLOC_CTX *_mem_save_value2_0;
2595         if (ndr_flags & NDR_SCALARS) {
2596                 NDR_CHECK(ndr_pull_align(ndr, 4));
2597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value1));
2598                 if (_ptr_value1) {
2599                         NDR_PULL_ALLOC(ndr, r->value1);
2600                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value1, _ptr_value1));
2601                 } else {
2602                         r->value1 = NULL;
2603                 }
2604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value2));
2605                 if (_ptr_value2) {
2606                         NDR_PULL_ALLOC(ndr, r->value2);
2607                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value2, _ptr_value2));
2608                 } else {
2609                         r->value2 = NULL;
2610                 }
2611         }
2612         if (ndr_flags & NDR_BUFFERS) {
2613                 if (r->value1) {
2614                         uint32_t _relative_save_offset;
2615                         _relative_save_offset = ndr->offset;
2616                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value1));
2617                         _mem_save_value1_0 = NDR_PULL_GET_MEM_CTX(ndr);
2618                         NDR_PULL_SET_MEM_CTX(ndr, r->value1, 0);
2619                         NDR_CHECK(ndr_pull_trustAuthInOutSecret2V1(ndr, NDR_SCALARS, r->value1));
2620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value1_0, 0);
2621                         ndr->offset = _relative_save_offset;
2622                 }
2623                 if (r->value2) {
2624                         uint32_t _relative_save_offset;
2625                         _relative_save_offset = ndr->offset;
2626                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value2));
2627                         _mem_save_value2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2628                         NDR_PULL_SET_MEM_CTX(ndr, r->value2, 0);
2629                         NDR_CHECK(ndr_pull_trustAuthInOutSecret2V2(ndr, NDR_SCALARS, r->value2));
2630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value2_0, 0);
2631                         ndr->offset = _relative_save_offset;
2632                 }
2633         }
2634         return NDR_ERR_SUCCESS;
2635 }
2636
2637 _PUBLIC_ void ndr_print_trustAuthInOutCtr2(struct ndr_print *ndr, const char *name, const struct trustAuthInOutCtr2 *r)
2638 {
2639         ndr_print_struct(ndr, name, "trustAuthInOutCtr2");
2640         ndr->depth++;
2641         ndr_print_ptr(ndr, "value1", r->value1);
2642         ndr->depth++;
2643         if (r->value1) {
2644                 ndr_print_trustAuthInOutSecret2V1(ndr, "value1", r->value1);
2645         }
2646         ndr->depth--;
2647         ndr_print_ptr(ndr, "value2", r->value2);
2648         ndr->depth++;
2649         if (r->value2) {
2650                 ndr_print_trustAuthInOutSecret2V2(ndr, "value2", r->value2);
2651         }
2652         ndr->depth--;
2653         ndr->depth--;
2654 }
2655
2656 static enum ndr_err_code ndr_push_trustAuthInOutCtr(struct ndr_push *ndr, int ndr_flags, const union trustAuthInOutCtr *r)
2657 {
2658         if (ndr_flags & NDR_SCALARS) {
2659                 int level = ndr_push_get_switch_value(ndr, r);
2660                 switch (level) {
2661                         case 1: {
2662                                 NDR_CHECK(ndr_push_trustAuthInOutCtr1(ndr, NDR_SCALARS, &r->ctr1));
2663                         break; }
2664
2665                         case 2: {
2666                                 NDR_CHECK(ndr_push_trustAuthInOutCtr2(ndr, NDR_SCALARS, &r->ctr2));
2667                         break; }
2668
2669                         default:
2670                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2671                 }
2672         }
2673         if (ndr_flags & NDR_BUFFERS) {
2674                 int level = ndr_push_get_switch_value(ndr, r);
2675                 switch (level) {
2676                         case 1:
2677                                 NDR_CHECK(ndr_push_trustAuthInOutCtr1(ndr, NDR_BUFFERS, &r->ctr1));
2678                         break;
2679
2680                         case 2:
2681                                 NDR_CHECK(ndr_push_trustAuthInOutCtr2(ndr, NDR_BUFFERS, &r->ctr2));
2682                         break;
2683
2684                         default:
2685                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2686                 }
2687         }
2688         return NDR_ERR_SUCCESS;
2689 }
2690
2691 static enum ndr_err_code ndr_pull_trustAuthInOutCtr(struct ndr_pull *ndr, int ndr_flags, union trustAuthInOutCtr *r)
2692 {
2693         int level;
2694         level = ndr_pull_get_switch_value(ndr, r);
2695         if (ndr_flags & NDR_SCALARS) {
2696                 switch (level) {
2697                         case 1: {
2698                                 NDR_CHECK(ndr_pull_trustAuthInOutCtr1(ndr, NDR_SCALARS, &r->ctr1));
2699                         break; }
2700
2701                         case 2: {
2702                                 NDR_CHECK(ndr_pull_trustAuthInOutCtr2(ndr, NDR_SCALARS, &r->ctr2));
2703                         break; }
2704
2705                         default:
2706                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2707                 }
2708         }
2709         if (ndr_flags & NDR_BUFFERS) {
2710                 switch (level) {
2711                         case 1:
2712                                 NDR_CHECK(ndr_pull_trustAuthInOutCtr1(ndr, NDR_BUFFERS, &r->ctr1));
2713                         break;
2714
2715                         case 2:
2716                                 NDR_CHECK(ndr_pull_trustAuthInOutCtr2(ndr, NDR_BUFFERS, &r->ctr2));
2717                         break;
2718
2719                         default:
2720                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2721                 }
2722         }
2723         return NDR_ERR_SUCCESS;
2724 }
2725
2726 _PUBLIC_ void ndr_print_trustAuthInOutCtr(struct ndr_print *ndr, const char *name, const union trustAuthInOutCtr *r)
2727 {
2728         int level;
2729         level = ndr_print_get_switch_value(ndr, r);
2730         ndr_print_union(ndr, name, level, "trustAuthInOutCtr");
2731         switch (level) {
2732                 case 1:
2733                         ndr_print_trustAuthInOutCtr1(ndr, "ctr1", &r->ctr1);
2734                 break;
2735
2736                 case 2:
2737                         ndr_print_trustAuthInOutCtr2(ndr, "ctr2", &r->ctr2);
2738                 break;
2739
2740                 default:
2741                         ndr_print_bad_level(ndr, name, level);
2742         }
2743 }
2744
2745 _PUBLIC_ enum ndr_err_code ndr_push_trustAuthInOutBlob(struct ndr_push *ndr, int ndr_flags, const struct trustAuthInOutBlob *r)
2746 {
2747         if (ndr_flags & NDR_SCALARS) {
2748                 NDR_CHECK(ndr_push_align(ndr, 4));
2749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2750                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
2751                 NDR_CHECK(ndr_push_trustAuthInOutCtr(ndr, NDR_SCALARS, &r->ctr));
2752         }
2753         if (ndr_flags & NDR_BUFFERS) {
2754                 NDR_CHECK(ndr_push_trustAuthInOutCtr(ndr, NDR_BUFFERS, &r->ctr));
2755         }
2756         return NDR_ERR_SUCCESS;
2757 }
2758
2759 _PUBLIC_ enum ndr_err_code ndr_pull_trustAuthInOutBlob(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutBlob *r)
2760 {
2761         if (ndr_flags & NDR_SCALARS) {
2762                 NDR_CHECK(ndr_pull_align(ndr, 4));
2763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2764                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
2765                 NDR_CHECK(ndr_pull_trustAuthInOutCtr(ndr, NDR_SCALARS, &r->ctr));
2766         }
2767         if (ndr_flags & NDR_BUFFERS) {
2768                 NDR_CHECK(ndr_pull_trustAuthInOutCtr(ndr, NDR_BUFFERS, &r->ctr));
2769         }
2770         return NDR_ERR_SUCCESS;
2771 }
2772
2773 _PUBLIC_ void ndr_print_trustAuthInOutBlob(struct ndr_print *ndr, const char *name, const struct trustAuthInOutBlob *r)
2774 {
2775         ndr_print_struct(ndr, name, "trustAuthInOutBlob");
2776         ndr->depth++;
2777         ndr_print_uint32(ndr, "version", r->version);
2778         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
2779         ndr_print_trustAuthInOutCtr(ndr, "ctr", &r->ctr);
2780         ndr->depth--;
2781 }
2782
2783 _PUBLIC_ enum ndr_err_code ndr_push_DsCompressedChunk(struct ndr_push *ndr, int ndr_flags, const struct DsCompressedChunk *r)
2784 {
2785         if (ndr_flags & NDR_SCALARS) {
2786                 NDR_CHECK(ndr_push_align(ndr, 4));
2787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->marker));
2788                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
2789         }
2790         if (ndr_flags & NDR_BUFFERS) {
2791         }
2792         return NDR_ERR_SUCCESS;
2793 }
2794
2795 _PUBLIC_ enum ndr_err_code ndr_pull_DsCompressedChunk(struct ndr_pull *ndr, int ndr_flags, struct DsCompressedChunk *r)
2796 {
2797         if (ndr_flags & NDR_SCALARS) {
2798                 NDR_CHECK(ndr_pull_align(ndr, 4));
2799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->marker));
2800                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
2801         }
2802         if (ndr_flags & NDR_BUFFERS) {
2803         }
2804         return NDR_ERR_SUCCESS;
2805 }
2806
2807 _PUBLIC_ void ndr_print_DsCompressedChunk(struct ndr_print *ndr, const char *name, const struct DsCompressedChunk *r)
2808 {
2809         ndr_print_struct(ndr, name, "DsCompressedChunk");
2810         ndr->depth++;
2811         ndr_print_uint32(ndr, "marker", r->marker);
2812         ndr_print_DATA_BLOB(ndr, "data", r->data);
2813         ndr->depth--;
2814 }
2815
2816 _PUBLIC_ enum ndr_err_code ndr_push_DsCompressedBlob(struct ndr_push *ndr, int ndr_flags, const struct DsCompressedBlob *r)
2817 {
2818         uint32_t cntr_chunks_0;
2819         if (ndr_flags & NDR_SCALARS) {
2820                 NDR_CHECK(ndr_push_align(ndr, 4));
2821                 for (cntr_chunks_0 = 0; cntr_chunks_0 < 5; cntr_chunks_0++) {
2822                         NDR_CHECK(ndr_push_DsCompressedChunk(ndr, NDR_SCALARS, &r->chunks[cntr_chunks_0]));
2823                 }
2824         }
2825         if (ndr_flags & NDR_BUFFERS) {
2826         }
2827         return NDR_ERR_SUCCESS;
2828 }
2829
2830 _PUBLIC_ enum ndr_err_code ndr_pull_DsCompressedBlob(struct ndr_pull *ndr, int ndr_flags, struct DsCompressedBlob *r)
2831 {
2832         uint32_t cntr_chunks_0;
2833         if (ndr_flags & NDR_SCALARS) {
2834                 NDR_CHECK(ndr_pull_align(ndr, 4));
2835                 for (cntr_chunks_0 = 0; cntr_chunks_0 < 5; cntr_chunks_0++) {
2836                         NDR_CHECK(ndr_pull_DsCompressedChunk(ndr, NDR_SCALARS, &r->chunks[cntr_chunks_0]));
2837                 }
2838         }
2839         if (ndr_flags & NDR_BUFFERS) {
2840         }
2841         return NDR_ERR_SUCCESS;
2842 }
2843
2844 _PUBLIC_ void ndr_print_DsCompressedBlob(struct ndr_print *ndr, const char *name, const struct DsCompressedBlob *r)
2845 {
2846         uint32_t cntr_chunks_0;
2847         ndr_print_struct(ndr, name, "DsCompressedBlob");
2848         ndr->depth++;
2849         ndr->print(ndr, "%s: ARRAY(%d)", "chunks", (int)5);
2850         ndr->depth++;
2851         for (cntr_chunks_0=0;cntr_chunks_0<5;cntr_chunks_0++) {
2852                 char *idx_0=NULL;
2853                 if (asprintf(&idx_0, "[%d]", cntr_chunks_0) != -1) {
2854                         ndr_print_DsCompressedChunk(ndr, "chunks", &r->chunks[cntr_chunks_0]);
2855                         free(idx_0);
2856                 }
2857         }
2858         ndr->depth--;
2859         ndr->depth--;
2860 }
2861
2862 static enum ndr_err_code ndr_push_decode_replPropertyMetaData(struct ndr_push *ndr, int flags, const struct decode_replPropertyMetaData *r)
2863 {
2864         if (flags & NDR_IN) {
2865                 NDR_CHECK(ndr_push_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
2866         }
2867         if (flags & NDR_OUT) {
2868         }
2869         return NDR_ERR_SUCCESS;
2870 }
2871
2872 static enum ndr_err_code ndr_pull_decode_replPropertyMetaData(struct ndr_pull *ndr, int flags, struct decode_replPropertyMetaData *r)
2873 {
2874         if (flags & NDR_IN) {
2875                 NDR_CHECK(ndr_pull_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
2876         }
2877         if (flags & NDR_OUT) {
2878         }
2879         return NDR_ERR_SUCCESS;
2880 }
2881
2882 _PUBLIC_ void ndr_print_decode_replPropertyMetaData(struct ndr_print *ndr, const char *name, int flags, const struct decode_replPropertyMetaData *r)
2883 {
2884         ndr_print_struct(ndr, name, "decode_replPropertyMetaData");
2885         ndr->depth++;
2886         if (flags & NDR_SET_VALUES) {
2887                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2888         }
2889         if (flags & NDR_IN) {
2890                 ndr_print_struct(ndr, "in", "decode_replPropertyMetaData");
2891                 ndr->depth++;
2892                 ndr_print_replPropertyMetaDataBlob(ndr, "blob", &r->in.blob);
2893                 ndr->depth--;
2894         }
2895         if (flags & NDR_OUT) {
2896                 ndr_print_struct(ndr, "out", "decode_replPropertyMetaData");
2897                 ndr->depth++;
2898                 ndr->depth--;
2899         }
2900         ndr->depth--;
2901 }
2902
2903 static enum ndr_err_code ndr_push_decode_replUpToDateVector(struct ndr_push *ndr, int flags, const struct decode_replUpToDateVector *r)
2904 {
2905         if (flags & NDR_IN) {
2906                 NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
2907         }
2908         if (flags & NDR_OUT) {
2909         }
2910         return NDR_ERR_SUCCESS;
2911 }
2912
2913 static enum ndr_err_code ndr_pull_decode_replUpToDateVector(struct ndr_pull *ndr, int flags, struct decode_replUpToDateVector *r)
2914 {
2915         if (flags & NDR_IN) {
2916                 NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
2917         }
2918         if (flags & NDR_OUT) {
2919         }
2920         return NDR_ERR_SUCCESS;
2921 }
2922
2923 _PUBLIC_ void ndr_print_decode_replUpToDateVector(struct ndr_print *ndr, const char *name, int flags, const struct decode_replUpToDateVector *r)
2924 {
2925         ndr_print_struct(ndr, name, "decode_replUpToDateVector");
2926         ndr->depth++;
2927         if (flags & NDR_SET_VALUES) {
2928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2929         }
2930         if (flags & NDR_IN) {
2931                 ndr_print_struct(ndr, "in", "decode_replUpToDateVector");
2932                 ndr->depth++;
2933                 ndr_print_replUpToDateVectorBlob(ndr, "blob", &r->in.blob);
2934                 ndr->depth--;
2935         }
2936         if (flags & NDR_OUT) {
2937                 ndr_print_struct(ndr, "out", "decode_replUpToDateVector");
2938                 ndr->depth++;
2939                 ndr->depth--;
2940         }
2941         ndr->depth--;
2942 }
2943
2944 static enum ndr_err_code ndr_push_decode_repsFromTo(struct ndr_push *ndr, int flags, const struct decode_repsFromTo *r)
2945 {
2946         if (flags & NDR_IN) {
2947                 NDR_CHECK(ndr_push_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
2948         }
2949         if (flags & NDR_OUT) {
2950         }
2951         return NDR_ERR_SUCCESS;
2952 }
2953
2954 static enum ndr_err_code ndr_pull_decode_repsFromTo(struct ndr_pull *ndr, int flags, struct decode_repsFromTo *r)
2955 {
2956         if (flags & NDR_IN) {
2957                 NDR_CHECK(ndr_pull_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
2958         }
2959         if (flags & NDR_OUT) {
2960         }
2961         return NDR_ERR_SUCCESS;
2962 }
2963
2964 _PUBLIC_ void ndr_print_decode_repsFromTo(struct ndr_print *ndr, const char *name, int flags, const struct decode_repsFromTo *r)
2965 {
2966         ndr_print_struct(ndr, name, "decode_repsFromTo");
2967         ndr->depth++;
2968         if (flags & NDR_SET_VALUES) {
2969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2970         }
2971         if (flags & NDR_IN) {
2972                 ndr_print_struct(ndr, "in", "decode_repsFromTo");
2973                 ndr->depth++;
2974                 ndr_print_repsFromToBlob(ndr, "blob", &r->in.blob);
2975                 ndr->depth--;
2976         }
2977         if (flags & NDR_OUT) {
2978                 ndr_print_struct(ndr, "out", "decode_repsFromTo");
2979                 ndr->depth++;
2980                 ndr->depth--;
2981         }
2982         ndr->depth--;
2983 }
2984
2985 static enum ndr_err_code ndr_push_decode_partialAttributeSet(struct ndr_push *ndr, int flags, const struct decode_partialAttributeSet *r)
2986 {
2987         if (flags & NDR_IN) {
2988                 NDR_CHECK(ndr_push_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
2989         }
2990         if (flags & NDR_OUT) {
2991         }
2992         return NDR_ERR_SUCCESS;
2993 }
2994
2995 static enum ndr_err_code ndr_pull_decode_partialAttributeSet(struct ndr_pull *ndr, int flags, struct decode_partialAttributeSet *r)
2996 {
2997         if (flags & NDR_IN) {
2998                 NDR_CHECK(ndr_pull_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
2999         }
3000         if (flags & NDR_OUT) {
3001         }
3002         return NDR_ERR_SUCCESS;
3003 }
3004
3005 _PUBLIC_ void ndr_print_decode_partialAttributeSet(struct ndr_print *ndr, const char *name, int flags, const struct decode_partialAttributeSet *r)
3006 {
3007         ndr_print_struct(ndr, name, "decode_partialAttributeSet");
3008         ndr->depth++;
3009         if (flags & NDR_SET_VALUES) {
3010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3011         }
3012         if (flags & NDR_IN) {
3013                 ndr_print_struct(ndr, "in", "decode_partialAttributeSet");
3014                 ndr->depth++;
3015                 ndr_print_partialAttributeSetBlob(ndr, "blob", &r->in.blob);
3016                 ndr->depth--;
3017         }
3018         if (flags & NDR_OUT) {
3019                 ndr_print_struct(ndr, "out", "decode_partialAttributeSet");
3020                 ndr->depth++;
3021                 ndr->depth--;
3022         }
3023         ndr->depth--;
3024 }
3025
3026 static enum ndr_err_code ndr_push_decode_prefixMap(struct ndr_push *ndr, int flags, const struct decode_prefixMap *r)
3027 {
3028         if (flags & NDR_IN) {
3029                 NDR_CHECK(ndr_push_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
3030         }
3031         if (flags & NDR_OUT) {
3032         }
3033         return NDR_ERR_SUCCESS;
3034 }
3035
3036 static enum ndr_err_code ndr_pull_decode_prefixMap(struct ndr_pull *ndr, int flags, struct decode_prefixMap *r)
3037 {
3038         if (flags & NDR_IN) {
3039                 NDR_CHECK(ndr_pull_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
3040         }
3041         if (flags & NDR_OUT) {
3042         }
3043         return NDR_ERR_SUCCESS;
3044 }
3045
3046 _PUBLIC_ void ndr_print_decode_prefixMap(struct ndr_print *ndr, const char *name, int flags, const struct decode_prefixMap *r)
3047 {
3048         ndr_print_struct(ndr, name, "decode_prefixMap");
3049         ndr->depth++;
3050         if (flags & NDR_SET_VALUES) {
3051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3052         }
3053         if (flags & NDR_IN) {
3054                 ndr_print_struct(ndr, "in", "decode_prefixMap");
3055                 ndr->depth++;
3056                 ndr_print_prefixMapBlob(ndr, "blob", &r->in.blob);
3057                 ndr->depth--;
3058         }
3059         if (flags & NDR_OUT) {
3060                 ndr_print_struct(ndr, "out", "decode_prefixMap");
3061                 ndr->depth++;
3062                 ndr->depth--;
3063         }
3064         ndr->depth--;
3065 }
3066
3067 static enum ndr_err_code ndr_push_decode_ldapControlDirSync(struct ndr_push *ndr, int flags, const struct decode_ldapControlDirSync *r)
3068 {
3069         if (flags & NDR_IN) {
3070                 NDR_CHECK(ndr_push_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
3071         }
3072         if (flags & NDR_OUT) {
3073         }
3074         return NDR_ERR_SUCCESS;
3075 }
3076
3077 static enum ndr_err_code ndr_pull_decode_ldapControlDirSync(struct ndr_pull *ndr, int flags, struct decode_ldapControlDirSync *r)
3078 {
3079         if (flags & NDR_IN) {
3080                 NDR_CHECK(ndr_pull_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
3081         }
3082         if (flags & NDR_OUT) {
3083         }
3084         return NDR_ERR_SUCCESS;
3085 }
3086
3087 _PUBLIC_ void ndr_print_decode_ldapControlDirSync(struct ndr_print *ndr, const char *name, int flags, const struct decode_ldapControlDirSync *r)
3088 {
3089         ndr_print_struct(ndr, name, "decode_ldapControlDirSync");
3090         ndr->depth++;
3091         if (flags & NDR_SET_VALUES) {
3092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3093         }
3094         if (flags & NDR_IN) {
3095                 ndr_print_struct(ndr, "in", "decode_ldapControlDirSync");
3096                 ndr->depth++;
3097                 ndr_print_ldapControlDirSyncCookie(ndr, "cookie", &r->in.cookie);
3098                 ndr->depth--;
3099         }
3100         if (flags & NDR_OUT) {
3101                 ndr_print_struct(ndr, "out", "decode_ldapControlDirSync");
3102                 ndr->depth++;
3103                 ndr->depth--;
3104         }
3105         ndr->depth--;
3106 }
3107
3108 static enum ndr_err_code ndr_push_decode_supplementalCredentials(struct ndr_push *ndr, int flags, const struct decode_supplementalCredentials *r)
3109 {
3110         if (flags & NDR_IN) {
3111                 NDR_CHECK(ndr_push_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
3112         }
3113         if (flags & NDR_OUT) {
3114         }
3115         return NDR_ERR_SUCCESS;
3116 }
3117
3118 static enum ndr_err_code ndr_pull_decode_supplementalCredentials(struct ndr_pull *ndr, int flags, struct decode_supplementalCredentials *r)
3119 {
3120         if (flags & NDR_IN) {
3121                 NDR_CHECK(ndr_pull_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
3122         }
3123         if (flags & NDR_OUT) {
3124         }
3125         return NDR_ERR_SUCCESS;
3126 }
3127
3128 _PUBLIC_ void ndr_print_decode_supplementalCredentials(struct ndr_print *ndr, const char *name, int flags, const struct decode_supplementalCredentials *r)
3129 {
3130         ndr_print_struct(ndr, name, "decode_supplementalCredentials");
3131         ndr->depth++;
3132         if (flags & NDR_SET_VALUES) {
3133                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3134         }
3135         if (flags & NDR_IN) {
3136                 ndr_print_struct(ndr, "in", "decode_supplementalCredentials");
3137                 ndr->depth++;
3138                 ndr_print_supplementalCredentialsBlob(ndr, "blob", &r->in.blob);
3139                 ndr->depth--;
3140         }
3141         if (flags & NDR_OUT) {
3142                 ndr_print_struct(ndr, "out", "decode_supplementalCredentials");
3143                 ndr->depth++;
3144                 ndr->depth--;
3145         }
3146         ndr->depth--;
3147 }
3148
3149 static enum ndr_err_code ndr_push_decode_Packages(struct ndr_push *ndr, int flags, const struct decode_Packages *r)
3150 {
3151         if (flags & NDR_IN) {
3152                 NDR_CHECK(ndr_push_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
3153         }
3154         if (flags & NDR_OUT) {
3155         }
3156         return NDR_ERR_SUCCESS;
3157 }
3158
3159 static enum ndr_err_code ndr_pull_decode_Packages(struct ndr_pull *ndr, int flags, struct decode_Packages *r)
3160 {
3161         if (flags & NDR_IN) {
3162                 NDR_CHECK(ndr_pull_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
3163         }
3164         if (flags & NDR_OUT) {
3165         }
3166         return NDR_ERR_SUCCESS;
3167 }
3168
3169 _PUBLIC_ void ndr_print_decode_Packages(struct ndr_print *ndr, const char *name, int flags, const struct decode_Packages *r)
3170 {
3171         ndr_print_struct(ndr, name, "decode_Packages");
3172         ndr->depth++;
3173         if (flags & NDR_SET_VALUES) {
3174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3175         }
3176         if (flags & NDR_IN) {
3177                 ndr_print_struct(ndr, "in", "decode_Packages");
3178                 ndr->depth++;
3179                 ndr_print_package_PackagesBlob(ndr, "blob", &r->in.blob);
3180                 ndr->depth--;
3181         }
3182         if (flags & NDR_OUT) {
3183                 ndr_print_struct(ndr, "out", "decode_Packages");
3184                 ndr->depth++;
3185                 ndr->depth--;
3186         }
3187         ndr->depth--;
3188 }
3189
3190 static enum ndr_err_code ndr_push_decode_PrimaryKerberos(struct ndr_push *ndr, int flags, const struct decode_PrimaryKerberos *r)
3191 {
3192         if (flags & NDR_IN) {
3193                 NDR_CHECK(ndr_push_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
3194         }
3195         if (flags & NDR_OUT) {
3196         }
3197         return NDR_ERR_SUCCESS;
3198 }
3199
3200 static enum ndr_err_code ndr_pull_decode_PrimaryKerberos(struct ndr_pull *ndr, int flags, struct decode_PrimaryKerberos *r)
3201 {
3202         if (flags & NDR_IN) {
3203                 NDR_CHECK(ndr_pull_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
3204         }
3205         if (flags & NDR_OUT) {
3206         }
3207         return NDR_ERR_SUCCESS;
3208 }
3209
3210 _PUBLIC_ void ndr_print_decode_PrimaryKerberos(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryKerberos *r)
3211 {
3212         ndr_print_struct(ndr, name, "decode_PrimaryKerberos");
3213         ndr->depth++;
3214         if (flags & NDR_SET_VALUES) {
3215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3216         }
3217         if (flags & NDR_IN) {
3218                 ndr_print_struct(ndr, "in", "decode_PrimaryKerberos");
3219                 ndr->depth++;
3220                 ndr_print_package_PrimaryKerberosBlob(ndr, "blob", &r->in.blob);
3221                 ndr->depth--;
3222         }
3223         if (flags & NDR_OUT) {
3224                 ndr_print_struct(ndr, "out", "decode_PrimaryKerberos");
3225                 ndr->depth++;
3226                 ndr->depth--;
3227         }
3228         ndr->depth--;
3229 }
3230
3231 static enum ndr_err_code ndr_push_decode_PrimaryCLEARTEXT(struct ndr_push *ndr, int flags, const struct decode_PrimaryCLEARTEXT *r)
3232 {
3233         if (flags & NDR_IN) {
3234                 NDR_CHECK(ndr_push_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
3235         }
3236         if (flags & NDR_OUT) {
3237         }
3238         return NDR_ERR_SUCCESS;
3239 }
3240
3241 static enum ndr_err_code ndr_pull_decode_PrimaryCLEARTEXT(struct ndr_pull *ndr, int flags, struct decode_PrimaryCLEARTEXT *r)
3242 {
3243         if (flags & NDR_IN) {
3244                 NDR_CHECK(ndr_pull_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
3245         }
3246         if (flags & NDR_OUT) {
3247         }
3248         return NDR_ERR_SUCCESS;
3249 }
3250
3251 _PUBLIC_ void ndr_print_decode_PrimaryCLEARTEXT(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryCLEARTEXT *r)
3252 {
3253         ndr_print_struct(ndr, name, "decode_PrimaryCLEARTEXT");
3254         ndr->depth++;
3255         if (flags & NDR_SET_VALUES) {
3256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3257         }
3258         if (flags & NDR_IN) {
3259                 ndr_print_struct(ndr, "in", "decode_PrimaryCLEARTEXT");
3260                 ndr->depth++;
3261                 ndr_print_package_PrimaryCLEARTEXTBlob(ndr, "blob", &r->in.blob);
3262                 ndr->depth--;
3263         }
3264         if (flags & NDR_OUT) {
3265                 ndr_print_struct(ndr, "out", "decode_PrimaryCLEARTEXT");
3266                 ndr->depth++;
3267                 ndr->depth--;
3268         }
3269         ndr->depth--;
3270 }
3271
3272 static enum ndr_err_code ndr_push_decode_PrimaryWDigest(struct ndr_push *ndr, int flags, const struct decode_PrimaryWDigest *r)
3273 {
3274         if (flags & NDR_IN) {
3275                 NDR_CHECK(ndr_push_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
3276         }
3277         if (flags & NDR_OUT) {
3278         }
3279         return NDR_ERR_SUCCESS;
3280 }
3281
3282 static enum ndr_err_code ndr_pull_decode_PrimaryWDigest(struct ndr_pull *ndr, int flags, struct decode_PrimaryWDigest *r)
3283 {
3284         if (flags & NDR_IN) {
3285                 NDR_CHECK(ndr_pull_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
3286         }
3287         if (flags & NDR_OUT) {
3288         }
3289         return NDR_ERR_SUCCESS;
3290 }
3291
3292 _PUBLIC_ void ndr_print_decode_PrimaryWDigest(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryWDigest *r)
3293 {
3294         ndr_print_struct(ndr, name, "decode_PrimaryWDigest");
3295         ndr->depth++;
3296         if (flags & NDR_SET_VALUES) {
3297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3298         }
3299         if (flags & NDR_IN) {
3300                 ndr_print_struct(ndr, "in", "decode_PrimaryWDigest");
3301                 ndr->depth++;
3302                 ndr_print_package_PrimaryWDigestBlob(ndr, "blob", &r->in.blob);
3303                 ndr->depth--;
3304         }
3305         if (flags & NDR_OUT) {
3306                 ndr_print_struct(ndr, "out", "decode_PrimaryWDigest");
3307                 ndr->depth++;
3308                 ndr->depth--;
3309         }
3310         ndr->depth--;
3311 }
3312
3313 static enum ndr_err_code ndr_push_decode_trustAuthInOut(struct ndr_push *ndr, int flags, const struct decode_trustAuthInOut *r)
3314 {
3315         if (flags & NDR_IN) {
3316                 NDR_CHECK(ndr_push_trustAuthInOutBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
3317         }
3318         if (flags & NDR_OUT) {
3319         }
3320         return NDR_ERR_SUCCESS;
3321 }
3322
3323 static enum ndr_err_code ndr_pull_decode_trustAuthInOut(struct ndr_pull *ndr, int flags, struct decode_trustAuthInOut *r)
3324 {
3325         if (flags & NDR_IN) {
3326                 NDR_CHECK(ndr_pull_trustAuthInOutBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
3327         }
3328         if (flags & NDR_OUT) {
3329         }
3330         return NDR_ERR_SUCCESS;
3331 }
3332
3333 _PUBLIC_ void ndr_print_decode_trustAuthInOut(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustAuthInOut *r)
3334 {
3335         ndr_print_struct(ndr, name, "decode_trustAuthInOut");
3336         ndr->depth++;
3337         if (flags & NDR_SET_VALUES) {
3338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3339         }
3340         if (flags & NDR_IN) {
3341                 ndr_print_struct(ndr, "in", "decode_trustAuthInOut");
3342                 ndr->depth++;
3343                 ndr_print_trustAuthInOutBlob(ndr, "blob", &r->in.blob);
3344                 ndr->depth--;
3345         }
3346         if (flags & NDR_OUT) {
3347                 ndr_print_struct(ndr, "out", "decode_trustAuthInOut");
3348                 ndr->depth++;
3349                 ndr->depth--;
3350         }
3351         ndr->depth--;
3352 }
3353
3354 static enum ndr_err_code ndr_push_decode_DsCompressed(struct ndr_push *ndr, int flags, const struct decode_DsCompressed *r)
3355 {
3356         if (flags & NDR_IN) {
3357                 NDR_CHECK(ndr_push_DsCompressedBlob(ndr, NDR_SCALARS, &r->in.blob));
3358         }
3359         if (flags & NDR_OUT) {
3360         }
3361         return NDR_ERR_SUCCESS;
3362 }
3363
3364 static enum ndr_err_code ndr_pull_decode_DsCompressed(struct ndr_pull *ndr, int flags, struct decode_DsCompressed *r)
3365 {
3366         if (flags & NDR_IN) {
3367                 NDR_CHECK(ndr_pull_DsCompressedBlob(ndr, NDR_SCALARS, &r->in.blob));
3368         }
3369         if (flags & NDR_OUT) {
3370         }
3371         return NDR_ERR_SUCCESS;
3372 }
3373
3374 _PUBLIC_ void ndr_print_decode_DsCompressed(struct ndr_print *ndr, const char *name, int flags, const struct decode_DsCompressed *r)
3375 {
3376         ndr_print_struct(ndr, name, "decode_DsCompressed");
3377         ndr->depth++;
3378         if (flags & NDR_SET_VALUES) {
3379                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3380         }
3381         if (flags & NDR_IN) {
3382                 ndr_print_struct(ndr, "in", "decode_DsCompressed");
3383                 ndr->depth++;
3384                 ndr_print_DsCompressedBlob(ndr, "blob", &r->in.blob);
3385                 ndr->depth--;
3386         }
3387         if (flags & NDR_OUT) {
3388                 ndr_print_struct(ndr, "out", "decode_DsCompressed");
3389                 ndr->depth++;
3390                 ndr->depth--;
3391         }
3392         ndr->depth--;
3393 }
3394
3395 static const struct ndr_interface_call drsblobs_calls[] = {
3396         {
3397                 "decode_replPropertyMetaData",
3398                 sizeof(struct decode_replPropertyMetaData),
3399                 (ndr_push_flags_fn_t) ndr_push_decode_replPropertyMetaData,
3400                 (ndr_pull_flags_fn_t) ndr_pull_decode_replPropertyMetaData,
3401                 (ndr_print_function_t) ndr_print_decode_replPropertyMetaData,
3402                 false,
3403         },
3404         {
3405                 "decode_replUpToDateVector",
3406                 sizeof(struct decode_replUpToDateVector),
3407                 (ndr_push_flags_fn_t) ndr_push_decode_replUpToDateVector,
3408                 (ndr_pull_flags_fn_t) ndr_pull_decode_replUpToDateVector,
3409                 (ndr_print_function_t) ndr_print_decode_replUpToDateVector,
3410                 false,
3411         },
3412         {
3413                 "decode_repsFromTo",
3414                 sizeof(struct decode_repsFromTo),
3415                 (ndr_push_flags_fn_t) ndr_push_decode_repsFromTo,
3416                 (ndr_pull_flags_fn_t) ndr_pull_decode_repsFromTo,
3417                 (ndr_print_function_t) ndr_print_decode_repsFromTo,
3418                 false,
3419         },
3420         {
3421                 "decode_partialAttributeSet",
3422                 sizeof(struct decode_partialAttributeSet),
3423                 (ndr_push_flags_fn_t) ndr_push_decode_partialAttributeSet,
3424                 (ndr_pull_flags_fn_t) ndr_pull_decode_partialAttributeSet,
3425                 (ndr_print_function_t) ndr_print_decode_partialAttributeSet,
3426                 false,
3427         },
3428         {
3429                 "decode_prefixMap",
3430                 sizeof(struct decode_prefixMap),
3431                 (ndr_push_flags_fn_t) ndr_push_decode_prefixMap,
3432                 (ndr_pull_flags_fn_t) ndr_pull_decode_prefixMap,
3433                 (ndr_print_function_t) ndr_print_decode_prefixMap,
3434                 false,
3435         },
3436         {
3437                 "decode_ldapControlDirSync",
3438                 sizeof(struct decode_ldapControlDirSync),
3439                 (ndr_push_flags_fn_t) ndr_push_decode_ldapControlDirSync,
3440                 (ndr_pull_flags_fn_t) ndr_pull_decode_ldapControlDirSync,
3441                 (ndr_print_function_t) ndr_print_decode_ldapControlDirSync,
3442                 false,
3443         },
3444         {
3445                 "decode_supplementalCredentials",
3446                 sizeof(struct decode_supplementalCredentials),
3447                 (ndr_push_flags_fn_t) ndr_push_decode_supplementalCredentials,
3448                 (ndr_pull_flags_fn_t) ndr_pull_decode_supplementalCredentials,
3449                 (ndr_print_function_t) ndr_print_decode_supplementalCredentials,
3450                 false,
3451         },
3452         {
3453                 "decode_Packages",
3454                 sizeof(struct decode_Packages),
3455                 (ndr_push_flags_fn_t) ndr_push_decode_Packages,
3456                 (ndr_pull_flags_fn_t) ndr_pull_decode_Packages,
3457                 (ndr_print_function_t) ndr_print_decode_Packages,
3458                 false,
3459         },
3460         {
3461                 "decode_PrimaryKerberos",
3462                 sizeof(struct decode_PrimaryKerberos),
3463                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryKerberos,
3464                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryKerberos,
3465                 (ndr_print_function_t) ndr_print_decode_PrimaryKerberos,
3466                 false,
3467         },
3468         {
3469                 "decode_PrimaryCLEARTEXT",
3470                 sizeof(struct decode_PrimaryCLEARTEXT),
3471                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryCLEARTEXT,
3472                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryCLEARTEXT,
3473                 (ndr_print_function_t) ndr_print_decode_PrimaryCLEARTEXT,
3474                 false,
3475         },
3476         {
3477                 "decode_PrimaryWDigest",
3478                 sizeof(struct decode_PrimaryWDigest),
3479                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryWDigest,
3480                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryWDigest,
3481                 (ndr_print_function_t) ndr_print_decode_PrimaryWDigest,
3482                 false,
3483         },
3484         {
3485                 "decode_trustAuthInOut",
3486                 sizeof(struct decode_trustAuthInOut),
3487                 (ndr_push_flags_fn_t) ndr_push_decode_trustAuthInOut,
3488                 (ndr_pull_flags_fn_t) ndr_pull_decode_trustAuthInOut,
3489                 (ndr_print_function_t) ndr_print_decode_trustAuthInOut,
3490                 false,
3491         },
3492         {
3493                 "decode_DsCompressed",
3494                 sizeof(struct decode_DsCompressed),
3495                 (ndr_push_flags_fn_t) ndr_push_decode_DsCompressed,
3496                 (ndr_pull_flags_fn_t) ndr_pull_decode_DsCompressed,
3497                 (ndr_print_function_t) ndr_print_decode_DsCompressed,
3498                 false,
3499         },
3500         { NULL, 0, NULL, NULL, NULL, false }
3501 };
3502
3503 static const char * const drsblobs_endpoint_strings[] = {
3504         "ncacn_np:[\\pipe\\drsblobs]",
3505 };
3506
3507 static const struct ndr_interface_string_array drsblobs_endpoints = {
3508         .count  = 1,
3509         .names  = drsblobs_endpoint_strings
3510 };
3511
3512 static const char * const drsblobs_authservice_strings[] = {
3513         "host",
3514 };
3515
3516 static const struct ndr_interface_string_array drsblobs_authservices = {
3517         .count  = 1,
3518         .names  = drsblobs_authservice_strings
3519 };
3520
3521
3522 const struct ndr_interface_table ndr_table_drsblobs = {
3523         .name           = "drsblobs",
3524         .syntax_id      = {
3525                 {0x12345778,0x1234,0xabcd,{0x00,0x01},{0x00,0x00,0x00,0x01}},
3526                 NDR_DRSBLOBS_VERSION
3527         },
3528         .helpstring     = NDR_DRSBLOBS_HELPSTRING,
3529         .num_calls      = 13,
3530         .calls          = drsblobs_calls,
3531         .endpoints      = &drsblobs_endpoints,
3532         .authservices   = &drsblobs_authservices
3533 };
3534