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