librpc/gen_ndr/ndr_drsblobs.c

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