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 _PUBLIC_ enum ndr_err_code ndr_push_schemaInfoBlob(struct ndr_push *ndr, int ndr_flags, const struct schemaInfoBlob *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, 4));
1228                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0xFF));
1229                         {
1230                                 uint32_t _flags_save_uint32 = ndr->flags;
1231                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1232                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->revision));
1233                                 ndr->flags = _flags_save_uint32;
1234                         }
1235                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->invocation_id));
1236                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1237                 }
1238                 if (ndr_flags & NDR_BUFFERS) {
1239                 }
1240                 ndr->flags = _flags_save_STRUCT;
1241         }
1242         return NDR_ERR_SUCCESS;
1243 }
1244
1245 _PUBLIC_ enum ndr_err_code ndr_pull_schemaInfoBlob(struct ndr_pull *ndr, int ndr_flags, struct schemaInfoBlob *r)
1246 {
1247         {
1248                 uint32_t _flags_save_STRUCT = ndr->flags;
1249                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1250                 if (ndr_flags & NDR_SCALARS) {
1251                         NDR_CHECK(ndr_pull_align(ndr, 4));
1252                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->marker));
1253                         {
1254                                 uint32_t _flags_save_uint32 = ndr->flags;
1255                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1256                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->revision));
1257                                 ndr->flags = _flags_save_uint32;
1258                         }
1259                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->invocation_id));
1260                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1261                 }
1262                 if (ndr_flags & NDR_BUFFERS) {
1263                 }
1264                 ndr->flags = _flags_save_STRUCT;
1265         }
1266         return NDR_ERR_SUCCESS;
1267 }
1268
1269 _PUBLIC_ void ndr_print_schemaInfoBlob(struct ndr_print *ndr, const char *name, const struct schemaInfoBlob *r)
1270 {
1271         ndr_print_struct(ndr, name, "schemaInfoBlob");
1272         {
1273                 uint32_t _flags_save_STRUCT = ndr->flags;
1274                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1275                 ndr->depth++;
1276                 ndr_print_uint8(ndr, "marker", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0xFF:r->marker);
1277                 ndr_print_uint32(ndr, "revision", r->revision);
1278                 ndr_print_GUID(ndr, "invocation_id", &r->invocation_id);
1279                 ndr->depth--;
1280                 ndr->flags = _flags_save_STRUCT;
1281         }
1282 }
1283
1284 static enum ndr_err_code ndr_push_drsuapi_MSPrefixMap_Entry(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_MSPrefixMap_Entry *r)
1285 {
1286         {
1287                 uint32_t _flags_save_STRUCT = ndr->flags;
1288                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1289                 if (ndr_flags & NDR_SCALARS) {
1290                         NDR_CHECK(ndr_push_align(ndr, 2));
1291                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->entryID));
1292                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
1293                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1294                         NDR_CHECK(ndr_push_trailer_align(ndr, 2));
1295                 }
1296                 if (ndr_flags & NDR_BUFFERS) {
1297                 }
1298                 ndr->flags = _flags_save_STRUCT;
1299         }
1300         return NDR_ERR_SUCCESS;
1301 }
1302
1303 static enum ndr_err_code ndr_pull_drsuapi_MSPrefixMap_Entry(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_MSPrefixMap_Entry *r)
1304 {
1305         {
1306                 uint32_t _flags_save_STRUCT = ndr->flags;
1307                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1308                 if (ndr_flags & NDR_SCALARS) {
1309                         NDR_CHECK(ndr_pull_align(ndr, 2));
1310                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->entryID));
1311                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
1312                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, r->length);
1313                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1314                         NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
1315                 }
1316                 if (ndr_flags & NDR_BUFFERS) {
1317                 }
1318                 ndr->flags = _flags_save_STRUCT;
1319         }
1320         return NDR_ERR_SUCCESS;
1321 }
1322
1323 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_MSPrefixMap_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_MSPrefixMap_Ctr *r)
1324 {
1325         uint32_t cntr_entries_0;
1326         if (ndr_flags & NDR_SCALARS) {
1327                 NDR_CHECK(ndr_push_align(ndr, 4));
1328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_entries));
1329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->iconv_convenience, ndr->flags)));
1330                 for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
1331                         NDR_CHECK(ndr_push_drsuapi_MSPrefixMap_Entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
1332                 }
1333                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1334         }
1335         if (ndr_flags & NDR_BUFFERS) {
1336         }
1337         return NDR_ERR_SUCCESS;
1338 }
1339
1340 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_MSPrefixMap_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_MSPrefixMap_Ctr *r)
1341 {
1342         uint32_t cntr_entries_0;
1343         TALLOC_CTX *_mem_save_entries_0;
1344         if (ndr_flags & NDR_SCALARS) {
1345                 NDR_CHECK(ndr_pull_align(ndr, 4));
1346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_entries));
1347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1348                 NDR_PULL_ALLOC_N(ndr, r->entries, r->num_entries);
1349                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1350                 NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
1351                 for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
1352                         NDR_CHECK(ndr_pull_drsuapi_MSPrefixMap_Entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
1353                 }
1354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1355                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1356         }
1357         if (ndr_flags & NDR_BUFFERS) {
1358         }
1359         return NDR_ERR_SUCCESS;
1360 }
1361
1362 _PUBLIC_ void ndr_print_drsuapi_MSPrefixMap_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_MSPrefixMap_Ctr *r)
1363 {
1364         uint32_t cntr_entries_0;
1365         ndr_print_struct(ndr, name, "drsuapi_MSPrefixMap_Ctr");
1366         ndr->depth++;
1367         ndr_print_uint32(ndr, "num_entries", r->num_entries);
1368         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);
1369         ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->num_entries);
1370         ndr->depth++;
1371         for (cntr_entries_0=0;cntr_entries_0<r->num_entries;cntr_entries_0++) {
1372                 char *idx_0=NULL;
1373                 if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
1374                         ndr_print_drsuapi_MSPrefixMap_Entry(ndr, "entries", &r->entries[cntr_entries_0]);
1375                         free(idx_0);
1376                 }
1377         }
1378         ndr->depth--;
1379         ndr->depth--;
1380 }
1381
1382 _PUBLIC_ size_t ndr_size_drsuapi_MSPrefixMap_Ctr(const struct drsuapi_MSPrefixMap_Ctr *r, struct smb_iconv_convenience *ic, int flags)
1383 {
1384         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_MSPrefixMap_Ctr, ic);
1385 }
1386
1387 static enum ndr_err_code ndr_push_prefixMapVersion(struct ndr_push *ndr, int ndr_flags, enum prefixMapVersion r)
1388 {
1389         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1390         return NDR_ERR_SUCCESS;
1391 }
1392
1393 static enum ndr_err_code ndr_pull_prefixMapVersion(struct ndr_pull *ndr, int ndr_flags, enum prefixMapVersion *r)
1394 {
1395         uint32_t v;
1396         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1397         *r = v;
1398         return NDR_ERR_SUCCESS;
1399 }
1400
1401 _PUBLIC_ void ndr_print_prefixMapVersion(struct ndr_print *ndr, const char *name, enum prefixMapVersion r)
1402 {
1403         const char *val = NULL;
1404
1405         switch (r) {
1406                 case PREFIX_MAP_VERSION_DSDB: val = "PREFIX_MAP_VERSION_DSDB"; break;
1407         }
1408         ndr_print_enum(ndr, name, "ENUM", val, r);
1409 }
1410
1411 static enum ndr_err_code ndr_push_prefixMapCtr(struct ndr_push *ndr, int ndr_flags, const union prefixMapCtr *r)
1412 {
1413         if (ndr_flags & NDR_SCALARS) {
1414                 int level = ndr_push_get_switch_value(ndr, r);
1415                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1416                 switch (level) {
1417                         case PREFIX_MAP_VERSION_DSDB: {
1418                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
1419                         break; }
1420
1421                         default:
1422                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1423                 }
1424         }
1425         if (ndr_flags & NDR_BUFFERS) {
1426                 int level = ndr_push_get_switch_value(ndr, r);
1427                 switch (level) {
1428                         case PREFIX_MAP_VERSION_DSDB:
1429                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
1430                         break;
1431
1432                         default:
1433                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1434                 }
1435         }
1436         return NDR_ERR_SUCCESS;
1437 }
1438
1439 static enum ndr_err_code ndr_pull_prefixMapCtr(struct ndr_pull *ndr, int ndr_flags, union prefixMapCtr *r)
1440 {
1441         int level;
1442         level = ndr_pull_get_switch_value(ndr, r);
1443         if (ndr_flags & NDR_SCALARS) {
1444                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1445                 switch (level) {
1446                         case PREFIX_MAP_VERSION_DSDB: {
1447                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
1448                         break; }
1449
1450                         default:
1451                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1452                 }
1453         }
1454         if (ndr_flags & NDR_BUFFERS) {
1455                 switch (level) {
1456                         case PREFIX_MAP_VERSION_DSDB:
1457                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
1458                         break;
1459
1460                         default:
1461                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1462                 }
1463         }
1464         return NDR_ERR_SUCCESS;
1465 }
1466
1467 _PUBLIC_ void ndr_print_prefixMapCtr(struct ndr_print *ndr, const char *name, const union prefixMapCtr *r)
1468 {
1469         int level;
1470         level = ndr_print_get_switch_value(ndr, r);
1471         ndr_print_union(ndr, name, level, "prefixMapCtr");
1472         switch (level) {
1473                 case PREFIX_MAP_VERSION_DSDB:
1474                         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "dsdb", &r->dsdb);
1475                 break;
1476
1477                 default:
1478                         ndr_print_bad_level(ndr, name, level);
1479         }
1480 }
1481
1482 _PUBLIC_ enum ndr_err_code ndr_push_prefixMapBlob(struct ndr_push *ndr, int ndr_flags, const struct prefixMapBlob *r)
1483 {
1484         if (ndr_flags & NDR_SCALARS) {
1485                 NDR_CHECK(ndr_push_align(ndr, 5));
1486                 NDR_CHECK(ndr_push_prefixMapVersion(ndr, NDR_SCALARS, r->version));
1487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1488                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1489                 NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
1490                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1491         }
1492         if (ndr_flags & NDR_BUFFERS) {
1493                 NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
1494         }
1495         return NDR_ERR_SUCCESS;
1496 }
1497
1498 _PUBLIC_ enum ndr_err_code ndr_pull_prefixMapBlob(struct ndr_pull *ndr, int ndr_flags, struct prefixMapBlob *r)
1499 {
1500         if (ndr_flags & NDR_SCALARS) {
1501                 NDR_CHECK(ndr_pull_align(ndr, 5));
1502                 NDR_CHECK(ndr_pull_prefixMapVersion(ndr, NDR_SCALARS, &r->version));
1503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1504                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1505                 NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
1506                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1507         }
1508         if (ndr_flags & NDR_BUFFERS) {
1509                 NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
1510         }
1511         return NDR_ERR_SUCCESS;
1512 }
1513
1514 _PUBLIC_ void ndr_print_prefixMapBlob(struct ndr_print *ndr, const char *name, const struct prefixMapBlob *r)
1515 {
1516         ndr_print_struct(ndr, name, "prefixMapBlob");
1517         ndr->depth++;
1518         ndr_print_prefixMapVersion(ndr, "version", r->version);
1519         ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1520         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1521         ndr_print_prefixMapCtr(ndr, "ctr", &r->ctr);
1522         ndr->depth--;
1523 }
1524
1525 static enum ndr_err_code ndr_push_ldapControlDirSyncExtra(struct ndr_push *ndr, int ndr_flags, const union ldapControlDirSyncExtra *r)
1526 {
1527         if (ndr_flags & NDR_SCALARS) {
1528                 int level = ndr_push_get_switch_value(ndr, r);
1529                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1530                 switch (level) {
1531                         case 0: {
1532                         break; }
1533
1534                         default: {
1535                                 NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1536                         break; }
1537
1538                 }
1539         }
1540         if (ndr_flags & NDR_BUFFERS) {
1541                 int level = ndr_push_get_switch_value(ndr, r);
1542                 switch (level) {
1543                         case 0:
1544                         break;
1545
1546                         default:
1547                         break;
1548
1549                 }
1550         }
1551         return NDR_ERR_SUCCESS;
1552 }
1553
1554 static enum ndr_err_code ndr_pull_ldapControlDirSyncExtra(struct ndr_pull *ndr, int ndr_flags, union ldapControlDirSyncExtra *r)
1555 {
1556         int level;
1557         level = ndr_pull_get_switch_value(ndr, r);
1558         if (ndr_flags & NDR_SCALARS) {
1559                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1560                 switch (level) {
1561                         case 0: {
1562                         break; }
1563
1564                         default: {
1565                                 NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1566                         break; }
1567
1568                 }
1569         }
1570         if (ndr_flags & NDR_BUFFERS) {
1571                 switch (level) {
1572                         case 0:
1573                         break;
1574
1575                         default:
1576                         break;
1577
1578                 }
1579         }
1580         return NDR_ERR_SUCCESS;
1581 }
1582
1583 _PUBLIC_ void ndr_print_ldapControlDirSyncExtra(struct ndr_print *ndr, const char *name, const union ldapControlDirSyncExtra *r)
1584 {
1585         int level;
1586         level = ndr_print_get_switch_value(ndr, r);
1587         ndr_print_union(ndr, name, level, "ldapControlDirSyncExtra");
1588         switch (level) {
1589                 case 0:
1590                 break;
1591
1592                 default:
1593                         ndr_print_replUpToDateVectorBlob(ndr, "uptodateness_vector", &r->uptodateness_vector);
1594                 break;
1595
1596         }
1597 }
1598
1599 static size_t ndr_size_ldapControlDirSyncExtra(const union ldapControlDirSyncExtra *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
1600 {
1601         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ldapControlDirSyncExtra, ic);
1602 }
1603
1604 static enum ndr_err_code ndr_push_ldapControlDirSyncBlob(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncBlob *r)
1605 {
1606         if (ndr_flags & NDR_SCALARS) {
1607                 NDR_CHECK(ndr_push_align(ndr, 8));
1608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 3));
1609                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
1610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
1611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
1612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, ndr->iconv_convenience, 0)));
1613                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1614                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
1615                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->extra, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, ndr->iconv_convenience, 0)));
1616                 NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1617                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1618         }
1619         if (ndr_flags & NDR_BUFFERS) {
1620                 NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1621         }
1622         return NDR_ERR_SUCCESS;
1623 }
1624
1625 static enum ndr_err_code ndr_pull_ldapControlDirSyncBlob(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncBlob *r)
1626 {
1627         if (ndr_flags & NDR_SCALARS) {
1628                 NDR_CHECK(ndr_pull_align(ndr, 8));
1629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
1630                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
1631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
1632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
1633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->extra_length));
1634                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1635                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
1636                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->extra, r->extra_length));
1637                 NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1638                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1639         }
1640         if (ndr_flags & NDR_BUFFERS) {
1641                 NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1642         }
1643         return NDR_ERR_SUCCESS;
1644 }
1645
1646 _PUBLIC_ void ndr_print_ldapControlDirSyncBlob(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncBlob *r)
1647 {
1648         ndr_print_struct(ndr, name, "ldapControlDirSyncBlob");
1649         ndr->depth++;
1650         ndr_print_uint32(ndr, "u1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?3:r->u1);
1651         ndr_print_NTTIME(ndr, "time", r->time);
1652         ndr_print_uint32(ndr, "u2", r->u2);
1653         ndr_print_uint32(ndr, "u3", r->u3);
1654         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);
1655         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1656         ndr_print_GUID(ndr, "guid1", &r->guid1);
1657         ndr_print_set_switch_value(ndr, &r->extra, r->extra_length);
1658         ndr_print_ldapControlDirSyncExtra(ndr, "extra", &r->extra);
1659         ndr->depth--;
1660 }
1661
1662 _PUBLIC_ enum ndr_err_code ndr_push_ldapControlDirSyncCookie(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncCookie *r)
1663 {
1664         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
1665         if (ndr_flags & NDR_SCALARS) {
1666                 NDR_CHECK(ndr_push_align(ndr, 8));
1667                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1668                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "MSDS", 4, sizeof(uint8_t), CH_DOS));
1669                 {
1670                         struct ndr_push *_ndr_blob;
1671                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_blob, 0, -1));
1672                         NDR_CHECK(ndr_push_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1673                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0, -1));
1674                 }
1675                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1676         }
1677         if (ndr_flags & NDR_BUFFERS) {
1678                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
1679         }
1680         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
1681         return NDR_ERR_SUCCESS;
1682 }
1683
1684 _PUBLIC_ enum ndr_err_code ndr_pull_ldapControlDirSyncCookie(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncCookie *r)
1685 {
1686         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
1687         if (ndr_flags & NDR_SCALARS) {
1688                 NDR_CHECK(ndr_pull_align(ndr, 8));
1689                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
1690                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->msds, 4, sizeof(uint8_t), CH_DOS));
1691                 {
1692                         struct ndr_pull *_ndr_blob;
1693                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_blob, 0, -1));
1694                         NDR_CHECK(ndr_pull_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1695                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0, -1));
1696                 }
1697                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1698         }
1699         if (ndr_flags & NDR_BUFFERS) {
1700                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
1701         }
1702         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
1703         return NDR_ERR_SUCCESS;
1704 }
1705
1706 _PUBLIC_ void ndr_print_ldapControlDirSyncCookie(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncCookie *r)
1707 {
1708         ndr_print_struct(ndr, name, "ldapControlDirSyncCookie");
1709         ndr->depth++;
1710         ndr_print_string(ndr, "msds", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"MSDS":r->msds);
1711         ndr_print_ldapControlDirSyncBlob(ndr, "blob", &r->blob);
1712         ndr->depth--;
1713 }
1714
1715 static enum ndr_err_code ndr_push_supplementalCredentialsPackage(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsPackage *r)
1716 {
1717         if (ndr_flags & NDR_SCALARS) {
1718                 NDR_CHECK(ndr_push_align(ndr, 2));
1719                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->name)));
1720                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->data)));
1721                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
1722                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 2 * strlen_m(r->name), sizeof(uint8_t), CH_UTF16));
1723                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data, strlen(r->data), sizeof(uint8_t), CH_DOS));
1724                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
1725         }
1726         if (ndr_flags & NDR_BUFFERS) {
1727         }
1728         return NDR_ERR_SUCCESS;
1729 }
1730
1731 static enum ndr_err_code ndr_pull_supplementalCredentialsPackage(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsPackage *r)
1732 {
1733         if (ndr_flags & NDR_SCALARS) {
1734                 NDR_CHECK(ndr_pull_align(ndr, 2));
1735                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
1736                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data_len));
1737                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
1738                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, r->name_len, sizeof(uint8_t), CH_UTF16));
1739                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data, r->data_len, sizeof(uint8_t), CH_DOS));
1740                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
1741         }
1742         if (ndr_flags & NDR_BUFFERS) {
1743         }
1744         return NDR_ERR_SUCCESS;
1745 }
1746
1747 _PUBLIC_ void ndr_print_supplementalCredentialsPackage(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsPackage *r)
1748 {
1749         ndr_print_struct(ndr, name, "supplementalCredentialsPackage");
1750         ndr->depth++;
1751         ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->name):r->name_len);
1752         ndr_print_uint16(ndr, "data_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->data):r->data_len);
1753         ndr_print_uint16(ndr, "reserved", r->reserved);
1754         ndr_print_string(ndr, "name", r->name);
1755         ndr_print_string(ndr, "data", r->data);
1756         ndr->depth--;
1757 }
1758
1759 static enum ndr_err_code ndr_push_supplementalCredentialsSignature(struct ndr_push *ndr, int ndr_flags, enum supplementalCredentialsSignature r)
1760 {
1761         {
1762                 uint32_t _flags_save_ENUM = ndr->flags;
1763                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1764                 NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1765                 ndr->flags = _flags_save_ENUM;
1766         }
1767         return NDR_ERR_SUCCESS;
1768 }
1769
1770 static enum ndr_err_code ndr_pull_supplementalCredentialsSignature(struct ndr_pull *ndr, int ndr_flags, enum supplementalCredentialsSignature *r)
1771 {
1772         uint16_t v;
1773         {
1774                 uint32_t _flags_save_ENUM = ndr->flags;
1775                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1776                 NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1777                 *r = v;
1778                 ndr->flags = _flags_save_ENUM;
1779         }
1780         return NDR_ERR_SUCCESS;
1781 }
1782
1783 _PUBLIC_ void ndr_print_supplementalCredentialsSignature(struct ndr_print *ndr, const char *name, enum supplementalCredentialsSignature r)
1784 {
1785         const char *val = NULL;
1786
1787         {
1788                 uint32_t _flags_save_ENUM = ndr->flags;
1789                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1790                 switch (r) {
1791                         case SUPPLEMENTAL_CREDENTIALS_SIGNATURE: val = "SUPPLEMENTAL_CREDENTIALS_SIGNATURE"; break;
1792                 }
1793                 ndr_print_enum(ndr, name, "ENUM", val, r);
1794                 ndr->flags = _flags_save_ENUM;
1795         }
1796 }
1797
1798 static enum ndr_err_code ndr_push_supplementalCredentialsSubBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsSubBlob *r)
1799 {
1800         uint32_t cntr_packages_0;
1801         if (ndr_flags & NDR_SCALARS) {
1802                 NDR_CHECK(ndr_push_align(ndr, 3));
1803                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_PREFIX, 0x30, sizeof(uint16_t), CH_UTF16));
1804                 NDR_CHECK(ndr_push_supplementalCredentialsSignature(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_SIGNATURE));
1805                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_packages));
1806                 for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1807                         NDR_CHECK(ndr_push_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1808                 }
1809                 NDR_CHECK(ndr_push_trailer_align(ndr, 3));
1810         }
1811         if (ndr_flags & NDR_BUFFERS) {
1812         }
1813         return NDR_ERR_SUCCESS;
1814 }
1815
1816 static enum ndr_err_code ndr_pull_supplementalCredentialsSubBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsSubBlob *r)
1817 {
1818         uint32_t cntr_packages_0;
1819         TALLOC_CTX *_mem_save_packages_0;
1820         if (ndr_flags & NDR_SCALARS) {
1821                 NDR_CHECK(ndr_pull_align(ndr, 3));
1822                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->prefix, 0x30, sizeof(uint16_t), CH_UTF16));
1823                 NDR_CHECK(ndr_pull_supplementalCredentialsSignature(ndr, NDR_SCALARS, &r->signature));
1824                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_packages));
1825                 NDR_PULL_ALLOC_N(ndr, r->packages, r->num_packages);
1826                 _mem_save_packages_0 = NDR_PULL_GET_MEM_CTX(ndr);
1827                 NDR_PULL_SET_MEM_CTX(ndr, r->packages, 0);
1828                 for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1829                         NDR_CHECK(ndr_pull_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1830                 }
1831                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_packages_0, 0);
1832                 NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
1833         }
1834         if (ndr_flags & NDR_BUFFERS) {
1835         }
1836         return NDR_ERR_SUCCESS;
1837 }
1838
1839 _PUBLIC_ void ndr_print_supplementalCredentialsSubBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsSubBlob *r)
1840 {
1841         uint32_t cntr_packages_0;
1842         ndr_print_struct(ndr, name, "supplementalCredentialsSubBlob");
1843         ndr->depth++;
1844         ndr_print_string(ndr, "prefix", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_PREFIX:r->prefix);
1845         ndr_print_supplementalCredentialsSignature(ndr, "signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_SIGNATURE:r->signature);
1846         ndr_print_uint16(ndr, "num_packages", r->num_packages);
1847         ndr->print(ndr, "%s: ARRAY(%d)", "packages", (int)r->num_packages);
1848         ndr->depth++;
1849         for (cntr_packages_0=0;cntr_packages_0<r->num_packages;cntr_packages_0++) {
1850                 char *idx_0=NULL;
1851                 if (asprintf(&idx_0, "[%d]", cntr_packages_0) != -1) {
1852                         ndr_print_supplementalCredentialsPackage(ndr, "packages", &r->packages[cntr_packages_0]);
1853                         free(idx_0);
1854                 }
1855         }
1856         ndr->depth--;
1857         ndr->depth--;
1858 }
1859
1860 static size_t ndr_size_supplementalCredentialsSubBlob(const struct supplementalCredentialsSubBlob *r, struct smb_iconv_convenience *ic, int flags)
1861 {
1862         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_supplementalCredentialsSubBlob, ic);
1863 }
1864
1865 _PUBLIC_ enum ndr_err_code ndr_push_supplementalCredentialsBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsBlob *r)
1866 {
1867         if (ndr_flags & NDR_SCALARS) {
1868                 NDR_CHECK(ndr_push_align(ndr, 4));
1869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
1871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1872                 {
1873                         struct ndr_push *_ndr_sub;
1874                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
1875                         NDR_CHECK(ndr_push_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1876                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->iconv_convenience, ndr->flags)));
1877                 }
1878                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
1879                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1880         }
1881         if (ndr_flags & NDR_BUFFERS) {
1882         }
1883         return NDR_ERR_SUCCESS;
1884 }
1885
1886 _PUBLIC_ enum ndr_err_code ndr_pull_supplementalCredentialsBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsBlob *r)
1887 {
1888         if (ndr_flags & NDR_SCALARS) {
1889                 NDR_CHECK(ndr_pull_align(ndr, 4));
1890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
1891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
1893                 {
1894                         struct ndr_pull *_ndr_sub;
1895                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sub, 0, r->__ndr_size));
1896                         NDR_CHECK(ndr_pull_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1897                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sub, 0, r->__ndr_size));
1898                 }
1899                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown3));
1900                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1901         }
1902         if (ndr_flags & NDR_BUFFERS) {
1903         }
1904         return NDR_ERR_SUCCESS;
1905 }
1906
1907 _PUBLIC_ void ndr_print_supplementalCredentialsBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsBlob *r)
1908 {
1909         ndr_print_struct(ndr, name, "supplementalCredentialsBlob");
1910         ndr->depth++;
1911         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown1);
1912         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);
1913         ndr_print_uint32(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown2);
1914         ndr_print_supplementalCredentialsSubBlob(ndr, "sub", &r->sub);
1915         ndr_print_uint8(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
1916         ndr->depth--;
1917 }
1918
1919 _PUBLIC_ enum ndr_err_code ndr_push_package_PackagesBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PackagesBlob *r)
1920 {
1921         if (ndr_flags & NDR_SCALARS) {
1922                 NDR_CHECK(ndr_push_align(ndr, 4));
1923                 {
1924                         uint32_t _flags_save_string_array = ndr->flags;
1925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1926                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->names));
1927                         ndr->flags = _flags_save_string_array;
1928                 }
1929                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1930         }
1931         if (ndr_flags & NDR_BUFFERS) {
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ enum ndr_err_code ndr_pull_package_PackagesBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PackagesBlob *r)
1937 {
1938         if (ndr_flags & NDR_SCALARS) {
1939                 NDR_CHECK(ndr_pull_align(ndr, 4));
1940                 {
1941                         uint32_t _flags_save_string_array = ndr->flags;
1942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1943                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->names));
1944                         ndr->flags = _flags_save_string_array;
1945                 }
1946                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1947         }
1948         if (ndr_flags & NDR_BUFFERS) {
1949         }
1950         return NDR_ERR_SUCCESS;
1951 }
1952
1953 _PUBLIC_ void ndr_print_package_PackagesBlob(struct ndr_print *ndr, const char *name, const struct package_PackagesBlob *r)
1954 {
1955         ndr_print_struct(ndr, name, "package_PackagesBlob");
1956         ndr->depth++;
1957         ndr_print_string_array(ndr, "names", r->names);
1958         ndr->depth--;
1959 }
1960
1961 static enum ndr_err_code ndr_push_package_PrimaryKerberosString(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosString *r)
1962 {
1963         if (ndr_flags & NDR_SCALARS) {
1964                 NDR_CHECK(ndr_push_align(ndr, 5));
1965                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1966                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1967                 {
1968                         uint32_t _flags_save_string = ndr->flags;
1969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1970                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->string));
1971                         ndr->flags = _flags_save_string;
1972                 }
1973                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976                 {
1977                         uint32_t _flags_save_string = ndr->flags;
1978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1979                         if (r->string) {
1980                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->string));
1981                                 {
1982                                         struct ndr_push *_ndr_string;
1983                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_string, 0, 2 * strlen_m(r->string)));
1984                                         NDR_CHECK(ndr_push_string(_ndr_string, NDR_SCALARS, r->string));
1985                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_string, 0, 2 * strlen_m(r->string)));
1986                                 }
1987                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->string));
1988                         }
1989                         ndr->flags = _flags_save_string;
1990                 }
1991         }
1992         return NDR_ERR_SUCCESS;
1993 }
1994
1995 static enum ndr_err_code ndr_pull_package_PrimaryKerberosString(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosString *r)
1996 {
1997         uint32_t _ptr_string;
1998         TALLOC_CTX *_mem_save_string_0;
1999         if (ndr_flags & NDR_SCALARS) {
2000                 NDR_CHECK(ndr_pull_align(ndr, 5));
2001                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
2002                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
2003                 {
2004                         uint32_t _flags_save_string = ndr->flags;
2005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
2006                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
2007                         if (_ptr_string) {
2008                                 NDR_PULL_ALLOC(ndr, r->string);
2009                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->string, _ptr_string));
2010                         } else {
2011                                 r->string = NULL;
2012                         }
2013                         ndr->flags = _flags_save_string;
2014                 }
2015                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2016         }
2017         if (ndr_flags & NDR_BUFFERS) {
2018                 {
2019                         uint32_t _flags_save_string = ndr->flags;
2020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
2021                         if (r->string) {
2022                                 uint32_t _relative_save_offset;
2023                                 _relative_save_offset = ndr->offset;
2024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->string));
2025                                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
2026                                 NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
2027                                 {
2028                                         struct ndr_pull *_ndr_string;
2029                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_string, 0, r->size));
2030                                         NDR_CHECK(ndr_pull_string(_ndr_string, NDR_SCALARS, &r->string));
2031                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_string, 0, r->size));
2032                                 }
2033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
2034                                 if (ndr->offset > ndr->relative_highest_offset) {
2035                                         ndr->relative_highest_offset = ndr->offset;
2036                                 }
2037                                 ndr->offset = _relative_save_offset;
2038                         }
2039                         ndr->flags = _flags_save_string;
2040                 }
2041         }
2042         return NDR_ERR_SUCCESS;
2043 }
2044
2045 _PUBLIC_ void ndr_print_package_PrimaryKerberosString(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosString *r)
2046 {
2047         ndr_print_struct(ndr, name, "package_PrimaryKerberosString");
2048         ndr->depth++;
2049         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
2050         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
2051         ndr_print_ptr(ndr, "string", r->string);
2052         ndr->depth++;
2053         if (r->string) {
2054                 ndr_print_string(ndr, "string", r->string);
2055         }
2056         ndr->depth--;
2057         ndr->depth--;
2058 }
2059
2060 static enum ndr_err_code ndr_push_package_PrimaryKerberosKey3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey3 *r)
2061 {
2062         if (ndr_flags & NDR_SCALARS) {
2063                 NDR_CHECK(ndr_push_align(ndr, 5));
2064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
2068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
2069                 {
2070                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2072                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
2073                         ndr->flags = _flags_save_DATA_BLOB;
2074                 }
2075                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2076         }
2077         if (ndr_flags & NDR_BUFFERS) {
2078                 {
2079                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2081                         if (r->value) {
2082                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value));
2083                                 {
2084                                         struct ndr_push *_ndr_value;
2085                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
2086                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
2087                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
2088                                 }
2089                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value));
2090                         }
2091                         ndr->flags = _flags_save_DATA_BLOB;
2092                 }
2093         }
2094         return NDR_ERR_SUCCESS;
2095 }
2096
2097 static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey3 *r)
2098 {
2099         uint32_t _ptr_value;
2100         TALLOC_CTX *_mem_save_value_0;
2101         if (ndr_flags & NDR_SCALARS) {
2102                 NDR_CHECK(ndr_pull_align(ndr, 5));
2103                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
2104                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
2105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
2106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
2107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
2108                 {
2109                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2111                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
2112                         if (_ptr_value) {
2113                                 NDR_PULL_ALLOC(ndr, r->value);
2114                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
2115                         } else {
2116                                 r->value = NULL;
2117                         }
2118                         ndr->flags = _flags_save_DATA_BLOB;
2119                 }
2120                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2121         }
2122         if (ndr_flags & NDR_BUFFERS) {
2123                 {
2124                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2126                         if (r->value) {
2127                                 uint32_t _relative_save_offset;
2128                                 _relative_save_offset = ndr->offset;
2129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
2130                                 _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
2131                                 NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
2132                                 {
2133                                         struct ndr_pull *_ndr_value;
2134                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
2135                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
2136                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
2137                                 }
2138                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
2139                                 if (ndr->offset > ndr->relative_highest_offset) {
2140                                         ndr->relative_highest_offset = ndr->offset;
2141                                 }
2142                                 ndr->offset = _relative_save_offset;
2143                         }
2144                         ndr->flags = _flags_save_DATA_BLOB;
2145                 }
2146         }
2147         return NDR_ERR_SUCCESS;
2148 }
2149
2150 _PUBLIC_ void ndr_print_package_PrimaryKerberosKey3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey3 *r)
2151 {
2152         ndr_print_struct(ndr, name, "package_PrimaryKerberosKey3");
2153         ndr->depth++;
2154         ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2155         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2156         ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
2157         ndr_print_uint32(ndr, "keytype", r->keytype);
2158         ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
2159         ndr_print_ptr(ndr, "value", r->value);
2160         ndr->depth++;
2161         if (r->value) {
2162                 ndr_print_DATA_BLOB(ndr, "value", *r->value);
2163         }
2164         ndr->depth--;
2165         ndr->depth--;
2166 }
2167
2168 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr3 *r)
2169 {
2170         uint32_t cntr_keys_0;
2171         uint32_t cntr_old_keys_0;
2172         if (ndr_flags & NDR_SCALARS) {
2173                 NDR_CHECK(ndr_push_align(ndr, 5));
2174                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
2175                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
2176                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2177                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2178                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2179                 }
2180                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2181                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2182                 }
2183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2188                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2189         }
2190         if (ndr_flags & NDR_BUFFERS) {
2191                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2192                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2193                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2194                 }
2195                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2196                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2197                 }
2198         }
2199         return NDR_ERR_SUCCESS;
2200 }
2201
2202 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr3 *r)
2203 {
2204         uint32_t cntr_keys_0;
2205         TALLOC_CTX *_mem_save_keys_0;
2206         uint32_t cntr_old_keys_0;
2207         TALLOC_CTX *_mem_save_old_keys_0;
2208         if (ndr_flags & NDR_SCALARS) {
2209                 NDR_CHECK(ndr_pull_align(ndr, 5));
2210                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
2211                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
2212                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2213                 NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
2214                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2215                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2216                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2217                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2218                 }
2219                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2220                 NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
2221                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2222                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2223                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2224                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2225                 }
2226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding1));
2228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding2));
2229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding3));
2230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding4));
2231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding5));
2232                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2233         }
2234         if (ndr_flags & NDR_BUFFERS) {
2235                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2236                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2237                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2238                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2239                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2240                 }
2241                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2242                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2243                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2244                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2245                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2246                 }
2247                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2248         }
2249         return NDR_ERR_SUCCESS;
2250 }
2251
2252 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr3 *r)
2253 {
2254         uint32_t cntr_keys_0;
2255         uint32_t cntr_old_keys_0;
2256         ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr3");
2257         ndr->depth++;
2258         ndr_print_uint16(ndr, "num_keys", r->num_keys);
2259         ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
2260         ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
2261         ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
2262         ndr->depth++;
2263         for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
2264                 char *idx_0=NULL;
2265                 if (asprintf(&idx_0, "[%d]", cntr_keys_0) != -1) {
2266                         ndr_print_package_PrimaryKerberosKey3(ndr, "keys", &r->keys[cntr_keys_0]);
2267                         free(idx_0);
2268                 }
2269         }
2270         ndr->depth--;
2271         ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2272         ndr->depth++;
2273         for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2274                 char *idx_0=NULL;
2275                 if (asprintf(&idx_0, "[%d]", cntr_old_keys_0) != -1) {
2276                         ndr_print_package_PrimaryKerberosKey3(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2277                         free(idx_0);
2278                 }
2279         }
2280         ndr->depth--;
2281         ndr_print_uint32(ndr, "padding1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding1);
2282         ndr_print_uint32(ndr, "padding2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding2);
2283         ndr_print_uint32(ndr, "padding3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding3);
2284         ndr_print_uint32(ndr, "padding4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding4);
2285         ndr_print_uint32(ndr, "padding5", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding5);
2286         ndr->depth--;
2287 }
2288
2289 static enum ndr_err_code ndr_push_package_PrimaryKerberosKey4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey4 *r)
2290 {
2291         if (ndr_flags & NDR_SCALARS) {
2292                 NDR_CHECK(ndr_push_align(ndr, 5));
2293                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2294                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iteration_count));
2297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
2298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
2299                 {
2300                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
2303                         ndr->flags = _flags_save_DATA_BLOB;
2304                 }
2305                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2306         }
2307         if (ndr_flags & NDR_BUFFERS) {
2308                 {
2309                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2310                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2311                         if (r->value) {
2312                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value));
2313                                 {
2314                                         struct ndr_push *_ndr_value;
2315                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
2316                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
2317                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
2318                                 }
2319                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value));
2320                         }
2321                         ndr->flags = _flags_save_DATA_BLOB;
2322                 }
2323         }
2324         return NDR_ERR_SUCCESS;
2325 }
2326
2327 static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey4 *r)
2328 {
2329         uint32_t _ptr_value;
2330         TALLOC_CTX *_mem_save_value_0;
2331         if (ndr_flags & NDR_SCALARS) {
2332                 NDR_CHECK(ndr_pull_align(ndr, 5));
2333                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
2334                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
2335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
2336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iteration_count));
2337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
2338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
2339                 {
2340                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
2343                         if (_ptr_value) {
2344                                 NDR_PULL_ALLOC(ndr, r->value);
2345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
2346                         } else {
2347                                 r->value = NULL;
2348                         }
2349                         ndr->flags = _flags_save_DATA_BLOB;
2350                 }
2351                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2352         }
2353         if (ndr_flags & NDR_BUFFERS) {
2354                 {
2355                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2357                         if (r->value) {
2358                                 uint32_t _relative_save_offset;
2359                                 _relative_save_offset = ndr->offset;
2360                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
2361                                 _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
2362                                 NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
2363                                 {
2364                                         struct ndr_pull *_ndr_value;
2365                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
2366                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
2367                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
2368                                 }
2369                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
2370                                 if (ndr->offset > ndr->relative_highest_offset) {
2371                                         ndr->relative_highest_offset = ndr->offset;
2372                                 }
2373                                 ndr->offset = _relative_save_offset;
2374                         }
2375                         ndr->flags = _flags_save_DATA_BLOB;
2376                 }
2377         }
2378         return NDR_ERR_SUCCESS;
2379 }
2380
2381 _PUBLIC_ void ndr_print_package_PrimaryKerberosKey4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey4 *r)
2382 {
2383         ndr_print_struct(ndr, name, "package_PrimaryKerberosKey4");
2384         ndr->depth++;
2385         ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2386         ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2387         ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
2388         ndr_print_uint32(ndr, "iteration_count", r->iteration_count);
2389         ndr_print_uint32(ndr, "keytype", r->keytype);
2390         ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
2391         ndr_print_ptr(ndr, "value", r->value);
2392         ndr->depth++;
2393         if (r->value) {
2394                 ndr_print_DATA_BLOB(ndr, "value", *r->value);
2395         }
2396         ndr->depth--;
2397         ndr->depth--;
2398 }
2399
2400 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr4 *r)
2401 {
2402         uint32_t cntr_keys_0;
2403         uint32_t cntr_old_keys_0;
2404         uint32_t cntr_older_keys_0;
2405         if (ndr_flags & NDR_SCALARS) {
2406                 NDR_CHECK(ndr_push_align(ndr, 5));
2407                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
2408                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2409                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
2410                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_older_keys));
2411                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->default_iteration_count));
2413                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2414                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2415                 }
2416                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2417                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2418                 }
2419                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2420                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
2421                 }
2422                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2423         }
2424         if (ndr_flags & NDR_BUFFERS) {
2425                 NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2426                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2427                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2428                 }
2429                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2430                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2431                 }
2432                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2433                         NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
2434                 }
2435         }
2436         return NDR_ERR_SUCCESS;
2437 }
2438
2439 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr4 *r)
2440 {
2441         uint32_t cntr_keys_0;
2442         TALLOC_CTX *_mem_save_keys_0;
2443         uint32_t cntr_service_keys_0;
2444         TALLOC_CTX *_mem_save_service_keys_0;
2445         uint32_t cntr_old_keys_0;
2446         TALLOC_CTX *_mem_save_old_keys_0;
2447         uint32_t cntr_older_keys_0;
2448         TALLOC_CTX *_mem_save_older_keys_0;
2449         if (ndr_flags & NDR_SCALARS) {
2450                 NDR_CHECK(ndr_pull_align(ndr, 5));
2451                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
2452                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_service_keys));
2453                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
2454                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_older_keys));
2455                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->default_iteration_count));
2457                 NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
2458                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2459                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2460                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2461                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2462                 }
2463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2464                 NDR_PULL_ALLOC_N(ndr, r->service_keys, r->num_service_keys);
2465                 _mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2466                 NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
2467                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
2468                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->service_keys[cntr_service_keys_0]));
2469                 }
2470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
2471                 NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
2472                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2473                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2474                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2475                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2476                 }
2477                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2478                 NDR_PULL_ALLOC_N(ndr, r->older_keys, r->num_older_keys);
2479                 _mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2480                 NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
2481                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2482                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
2483                 }
2484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
2485                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2486         }
2487         if (ndr_flags & NDR_BUFFERS) {
2488                 NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2489                 _mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490                 NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2491                 for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2492                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2493                 }
2494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2495                 _mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                 NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
2497                 for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
2498                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->service_keys[cntr_service_keys_0]));
2499                 }
2500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
2501                 _mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2502                 NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2503                 for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2504                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2505                 }
2506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2507                 _mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                 NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
2509                 for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2510                         NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
2511                 }
2512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
2513         }
2514         return NDR_ERR_SUCCESS;
2515 }
2516
2517 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr4 *r)
2518 {
2519         uint32_t cntr_keys_0;
2520         uint32_t cntr_service_keys_0;
2521         uint32_t cntr_old_keys_0;
2522         uint32_t cntr_older_keys_0;
2523         ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr4");
2524         ndr->depth++;
2525         ndr_print_uint16(ndr, "num_keys", r->num_keys);
2526         ndr_print_uint16(ndr, "num_service_keys", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->num_service_keys);
2527         ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
2528         ndr_print_uint16(ndr, "num_older_keys", r->num_older_keys);
2529         ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
2530         ndr_print_uint32(ndr, "default_iteration_count", r->default_iteration_count);
2531         ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
2532         ndr->depth++;
2533         for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
2534                 char *idx_0=NULL;
2535                 if (asprintf(&idx_0, "[%d]", cntr_keys_0) != -1) {
2536                         ndr_print_package_PrimaryKerberosKey4(ndr, "keys", &r->keys[cntr_keys_0]);
2537                         free(idx_0);
2538                 }
2539         }
2540         ndr->depth--;
2541         ndr->print(ndr, "%s: ARRAY(%d)", "service_keys", (int)r->num_service_keys);
2542         ndr->depth++;
2543         for (cntr_service_keys_0=0;cntr_service_keys_0<r->num_service_keys;cntr_service_keys_0++) {
2544                 char *idx_0=NULL;
2545                 if (asprintf(&idx_0, "[%d]", cntr_service_keys_0) != -1) {
2546                         ndr_print_package_PrimaryKerberosKey4(ndr, "service_keys", &r->service_keys[cntr_service_keys_0]);
2547                         free(idx_0);
2548                 }
2549         }
2550         ndr->depth--;
2551         ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2552         ndr->depth++;
2553         for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2554                 char *idx_0=NULL;
2555                 if (asprintf(&idx_0, "[%d]", cntr_old_keys_0) != -1) {
2556                         ndr_print_package_PrimaryKerberosKey4(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2557                         free(idx_0);
2558                 }
2559         }
2560         ndr->depth--;
2561         ndr->print(ndr, "%s: ARRAY(%d)", "older_keys", (int)r->num_older_keys);
2562         ndr->depth++;
2563         for (cntr_older_keys_0=0;cntr_older_keys_0<r->num_older_keys;cntr_older_keys_0++) {
2564                 char *idx_0=NULL;
2565                 if (asprintf(&idx_0, "[%d]", cntr_older_keys_0) != -1) {
2566                         ndr_print_package_PrimaryKerberosKey4(ndr, "older_keys", &r->older_keys[cntr_older_keys_0]);
2567                         free(idx_0);
2568                 }
2569         }
2570         ndr->depth--;
2571         ndr->depth--;
2572 }
2573
2574 static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr(struct ndr_push *ndr, int ndr_flags, const union package_PrimaryKerberosCtr *r)
2575 {
2576         if (ndr_flags & NDR_SCALARS) {
2577                 int level = ndr_push_get_switch_value(ndr, r);
2578                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2579                 switch (level) {
2580                         case 3: {
2581                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2582                         break; }
2583
2584                         case 4: {
2585                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2586                         break; }
2587
2588                         default:
2589                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2590                 }
2591         }
2592         if (ndr_flags & NDR_BUFFERS) {
2593                 int level = ndr_push_get_switch_value(ndr, r);
2594                 switch (level) {
2595                         case 3:
2596                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2597                         break;
2598
2599                         case 4:
2600                                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2601                         break;
2602
2603                         default:
2604                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2605                 }
2606         }
2607         return NDR_ERR_SUCCESS;
2608 }
2609
2610 static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr(struct ndr_pull *ndr, int ndr_flags, union package_PrimaryKerberosCtr *r)
2611 {
2612         int level;
2613         level = ndr_pull_get_switch_value(ndr, r);
2614         if (ndr_flags & NDR_SCALARS) {
2615                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2616                 switch (level) {
2617                         case 3: {
2618                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2619                         break; }
2620
2621                         case 4: {
2622                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2623                         break; }
2624
2625                         default:
2626                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2627                 }
2628         }
2629         if (ndr_flags & NDR_BUFFERS) {
2630                 switch (level) {
2631                         case 3:
2632                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2633                         break;
2634
2635                         case 4:
2636                                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2637                         break;
2638
2639                         default:
2640                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2641                 }
2642         }
2643         return NDR_ERR_SUCCESS;
2644 }
2645
2646 _PUBLIC_ void ndr_print_package_PrimaryKerberosCtr(struct ndr_print *ndr, const char *name, const union package_PrimaryKerberosCtr *r)
2647 {
2648         int level;
2649         level = ndr_print_get_switch_value(ndr, r);
2650         ndr_print_union(ndr, name, level, "package_PrimaryKerberosCtr");
2651         switch (level) {
2652                 case 3:
2653                         ndr_print_package_PrimaryKerberosCtr3(ndr, "ctr3", &r->ctr3);
2654                 break;
2655
2656                 case 4:
2657                         ndr_print_package_PrimaryKerberosCtr4(ndr, "ctr4", &r->ctr4);
2658                 break;
2659
2660                 default:
2661                         ndr_print_bad_level(ndr, name, level);
2662         }
2663 }
2664
2665 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryKerberosBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosBlob *r)
2666 {
2667         if (ndr_flags & NDR_SCALARS) {
2668                 NDR_CHECK(ndr_push_align(ndr, 5));
2669                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
2670                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2671                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
2672                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2673                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2674         }
2675         if (ndr_flags & NDR_BUFFERS) {
2676                 NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2677         }
2678         return NDR_ERR_SUCCESS;
2679 }
2680
2681 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryKerberosBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosBlob *r)
2682 {
2683         if (ndr_flags & NDR_SCALARS) {
2684                 NDR_CHECK(ndr_pull_align(ndr, 5));
2685                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
2686                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
2687                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
2688                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2689                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2690         }
2691         if (ndr_flags & NDR_BUFFERS) {
2692                 NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2693         }
2694         return NDR_ERR_SUCCESS;
2695 }
2696
2697 _PUBLIC_ void ndr_print_package_PrimaryKerberosBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosBlob *r)
2698 {
2699         ndr_print_struct(ndr, name, "package_PrimaryKerberosBlob");
2700         ndr->depth++;
2701         ndr_print_uint16(ndr, "version", r->version);
2702         ndr_print_uint16(ndr, "flags", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flags);
2703         ndr_print_set_switch_value(ndr, &r->ctr, r->version);
2704         ndr_print_package_PrimaryKerberosCtr(ndr, "ctr", &r->ctr);
2705         ndr->depth--;
2706 }
2707
2708 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryCLEARTEXTBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryCLEARTEXTBlob *r)
2709 {
2710         if (ndr_flags & NDR_SCALARS) {
2711                 NDR_CHECK(ndr_push_align(ndr, 4));
2712                 {
2713                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2715                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->cleartext));
2716                         ndr->flags = _flags_save_DATA_BLOB;
2717                 }
2718                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2719         }
2720         if (ndr_flags & NDR_BUFFERS) {
2721         }
2722         return NDR_ERR_SUCCESS;
2723 }
2724
2725 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryCLEARTEXTBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryCLEARTEXTBlob *r)
2726 {
2727         if (ndr_flags & NDR_SCALARS) {
2728                 NDR_CHECK(ndr_pull_align(ndr, 4));
2729                 {
2730                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2732                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->cleartext));
2733                         ndr->flags = _flags_save_DATA_BLOB;
2734                 }
2735                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2736         }
2737         if (ndr_flags & NDR_BUFFERS) {
2738         }
2739         return NDR_ERR_SUCCESS;
2740 }
2741
2742 _PUBLIC_ void ndr_print_package_PrimaryCLEARTEXTBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryCLEARTEXTBlob *r)
2743 {
2744         ndr_print_struct(ndr, name, "package_PrimaryCLEARTEXTBlob");
2745         ndr->depth++;
2746         ndr_print_DATA_BLOB(ndr, "cleartext", r->cleartext);
2747         ndr->depth--;
2748 }
2749
2750 static enum ndr_err_code ndr_push_package_PrimaryWDigestHash(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestHash *r)
2751 {
2752         {
2753                 uint32_t _flags_save_STRUCT = ndr->flags;
2754                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2755                 if (ndr_flags & NDR_SCALARS) {
2756                         NDR_CHECK(ndr_push_align(ndr, 1));
2757                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2758                         NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2759                 }
2760                 if (ndr_flags & NDR_BUFFERS) {
2761                 }
2762                 ndr->flags = _flags_save_STRUCT;
2763         }
2764         return NDR_ERR_SUCCESS;
2765 }
2766
2767 static enum ndr_err_code ndr_pull_package_PrimaryWDigestHash(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestHash *r)
2768 {
2769         {
2770                 uint32_t _flags_save_STRUCT = ndr->flags;
2771                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2772                 if (ndr_flags & NDR_SCALARS) {
2773                         NDR_CHECK(ndr_pull_align(ndr, 1));
2774                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2775                         NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2776                 }
2777                 if (ndr_flags & NDR_BUFFERS) {
2778                 }
2779                 ndr->flags = _flags_save_STRUCT;
2780         }
2781         return NDR_ERR_SUCCESS;
2782 }
2783
2784 _PUBLIC_ void ndr_print_package_PrimaryWDigestHash(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestHash *r)
2785 {
2786         ndr_print_struct(ndr, name, "package_PrimaryWDigestHash");
2787         {
2788                 uint32_t _flags_save_STRUCT = ndr->flags;
2789                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2790                 ndr->depth++;
2791                 ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2792                 ndr->depth--;
2793                 ndr->flags = _flags_save_STRUCT;
2794         }
2795 }
2796
2797 _PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryWDigestBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestBlob *r)
2798 {
2799         uint32_t cntr_hashes_0;
2800         if (ndr_flags & NDR_SCALARS) {
2801                 NDR_CHECK(ndr_push_align(ndr, 4));
2802                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0x31));
2803                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0x01));
2804                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_hashes));
2805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2806                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, 0));
2807                 for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2808                         NDR_CHECK(ndr_push_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2809                 }
2810                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2811         }
2812         if (ndr_flags & NDR_BUFFERS) {
2813         }
2814         return NDR_ERR_SUCCESS;
2815 }
2816
2817 _PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryWDigestBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestBlob *r)
2818 {
2819         uint32_t cntr_hashes_0;
2820         TALLOC_CTX *_mem_save_hashes_0;
2821         if (ndr_flags & NDR_SCALARS) {
2822                 NDR_CHECK(ndr_pull_align(ndr, 4));
2823                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
2824                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown2));
2825                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_hashes));
2826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
2827                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->uuknown4));
2828                 NDR_PULL_ALLOC_N(ndr, r->hashes, r->num_hashes);
2829                 _mem_save_hashes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2830                 NDR_PULL_SET_MEM_CTX(ndr, r->hashes, 0);
2831                 for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2832                         NDR_CHECK(ndr_pull_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2833                 }
2834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hashes_0, 0);
2835                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2836         }
2837         if (ndr_flags & NDR_BUFFERS) {
2838         }
2839         return NDR_ERR_SUCCESS;
2840 }
2841
2842 _PUBLIC_ void ndr_print_package_PrimaryWDigestBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestBlob *r)
2843 {
2844         uint32_t cntr_hashes_0;
2845         ndr_print_struct(ndr, name, "package_PrimaryWDigestBlob");
2846         ndr->depth++;
2847         ndr_print_uint16(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x31:r->unknown1);
2848         ndr_print_uint8(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x01:r->unknown2);
2849         ndr_print_uint8(ndr, "num_hashes", r->num_hashes);
2850         ndr_print_uint32(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
2851         ndr_print_udlong(ndr, "uuknown4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->uuknown4);
2852         ndr->print(ndr, "%s: ARRAY(%d)", "hashes", (int)r->num_hashes);
2853         ndr->depth++;
2854         for (cntr_hashes_0=0;cntr_hashes_0<r->num_hashes;cntr_hashes_0++) {
2855                 char *idx_0=NULL;
2856                 if (asprintf(&idx_0, "[%d]", cntr_hashes_0) != -1) {
2857                         ndr_print_package_PrimaryWDigestHash(ndr, "hashes", &r->hashes[cntr_hashes_0]);
2858                         free(idx_0);
2859                 }
2860         }
2861         ndr->depth--;
2862         ndr->depth--;
2863 }
2864
2865 static enum ndr_err_code ndr_push_AuthInfoNone(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoNone *r)
2866 {
2867         if (ndr_flags & NDR_SCALARS) {
2868                 NDR_CHECK(ndr_push_align(ndr, 4));
2869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2870                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2871         }
2872         if (ndr_flags & NDR_BUFFERS) {
2873         }
2874         return NDR_ERR_SUCCESS;
2875 }
2876
2877 static enum ndr_err_code ndr_pull_AuthInfoNone(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoNone *r)
2878 {
2879         if (ndr_flags & NDR_SCALARS) {
2880                 NDR_CHECK(ndr_pull_align(ndr, 4));
2881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2882                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2883         }
2884         if (ndr_flags & NDR_BUFFERS) {
2885         }
2886         return NDR_ERR_SUCCESS;
2887 }
2888
2889 _PUBLIC_ void ndr_print_AuthInfoNone(struct ndr_print *ndr, const char *name, const struct AuthInfoNone *r)
2890 {
2891         ndr_print_struct(ndr, name, "AuthInfoNone");
2892         ndr->depth++;
2893         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->size);
2894         ndr->depth--;
2895 }
2896
2897 static enum ndr_err_code ndr_push_AuthInfoNT4Owf(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoNT4Owf *r)
2898 {
2899         if (ndr_flags & NDR_SCALARS) {
2900                 NDR_CHECK(ndr_push_align(ndr, 4));
2901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 16));
2902                 NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->password));
2903                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2904         }
2905         if (ndr_flags & NDR_BUFFERS) {
2906         }
2907         return NDR_ERR_SUCCESS;
2908 }
2909
2910 static enum ndr_err_code ndr_pull_AuthInfoNT4Owf(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoNT4Owf *r)
2911 {
2912         if (ndr_flags & NDR_SCALARS) {
2913                 NDR_CHECK(ndr_pull_align(ndr, 4));
2914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2915                 NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->password));
2916                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2917         }
2918         if (ndr_flags & NDR_BUFFERS) {
2919         }
2920         return NDR_ERR_SUCCESS;
2921 }
2922
2923 _PUBLIC_ void ndr_print_AuthInfoNT4Owf(struct ndr_print *ndr, const char *name, const struct AuthInfoNT4Owf *r)
2924 {
2925         ndr_print_struct(ndr, name, "AuthInfoNT4Owf");
2926         ndr->depth++;
2927         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?16:r->size);
2928         ndr_print_samr_Password(ndr, "password", &r->password);
2929         ndr->depth--;
2930 }
2931
2932 static enum ndr_err_code ndr_push_AuthInfoClear(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoClear *r)
2933 {
2934         if (ndr_flags & NDR_SCALARS) {
2935                 NDR_CHECK(ndr_push_align(ndr, 4));
2936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2937                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
2938                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2939         }
2940         if (ndr_flags & NDR_BUFFERS) {
2941         }
2942         return NDR_ERR_SUCCESS;
2943 }
2944
2945 static enum ndr_err_code ndr_pull_AuthInfoClear(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoClear *r)
2946 {
2947         if (ndr_flags & NDR_SCALARS) {
2948                 NDR_CHECK(ndr_pull_align(ndr, 4));
2949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2950                 NDR_PULL_ALLOC_N(ndr, r->password, r->size);
2951                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
2952                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2953         }
2954         if (ndr_flags & NDR_BUFFERS) {
2955         }
2956         return NDR_ERR_SUCCESS;
2957 }
2958
2959 _PUBLIC_ void ndr_print_AuthInfoClear(struct ndr_print *ndr, const char *name, const struct AuthInfoClear *r)
2960 {
2961         ndr_print_struct(ndr, name, "AuthInfoClear");
2962         ndr->depth++;
2963         ndr_print_uint32(ndr, "size", r->size);
2964         ndr_print_array_uint8(ndr, "password", r->password, r->size);
2965         ndr->depth--;
2966 }
2967
2968 static enum ndr_err_code ndr_push_AuthInfoVersion(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoVersion *r)
2969 {
2970         if (ndr_flags & NDR_SCALARS) {
2971                 NDR_CHECK(ndr_push_align(ndr, 4));
2972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 4));
2973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2974                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2975         }
2976         if (ndr_flags & NDR_BUFFERS) {
2977         }
2978         return NDR_ERR_SUCCESS;
2979 }
2980
2981 static enum ndr_err_code ndr_pull_AuthInfoVersion(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoVersion *r)
2982 {
2983         if (ndr_flags & NDR_SCALARS) {
2984                 NDR_CHECK(ndr_pull_align(ndr, 4));
2985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2987                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2988         }
2989         if (ndr_flags & NDR_BUFFERS) {
2990         }
2991         return NDR_ERR_SUCCESS;
2992 }
2993
2994 _PUBLIC_ void ndr_print_AuthInfoVersion(struct ndr_print *ndr, const char *name, const struct AuthInfoVersion *r)
2995 {
2996         ndr_print_struct(ndr, name, "AuthInfoVersion");
2997         ndr->depth++;
2998         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?4:r->size);
2999         ndr_print_uint32(ndr, "version", r->version);
3000         ndr->depth--;
3001 }
3002
3003 static enum ndr_err_code ndr_push_AuthInfo(struct ndr_push *ndr, int ndr_flags, const union AuthInfo *r)
3004 {
3005         if (ndr_flags & NDR_SCALARS) {
3006                 int level = ndr_push_get_switch_value(ndr, r);
3007                 NDR_CHECK(ndr_push_union_align(ndr, 4));
3008                 switch (level) {
3009                         case TRUST_AUTH_TYPE_NONE: {
3010                                 NDR_CHECK(ndr_push_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
3011                         break; }
3012
3013                         case TRUST_AUTH_TYPE_NT4OWF: {
3014                                 NDR_CHECK(ndr_push_AuthInfoNT4Owf(ndr, NDR_SCALARS, &r->nt4owf));
3015                         break; }
3016
3017                         case TRUST_AUTH_TYPE_CLEAR: {
3018                                 NDR_CHECK(ndr_push_AuthInfoClear(ndr, NDR_SCALARS, &r->clear));
3019                         break; }
3020
3021                         case TRUST_AUTH_TYPE_VERSION: {
3022                                 NDR_CHECK(ndr_push_AuthInfoVersion(ndr, NDR_SCALARS, &r->version));
3023                         break; }
3024
3025                         default:
3026                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3027                 }
3028         }
3029         if (ndr_flags & NDR_BUFFERS) {
3030                 int level = ndr_push_get_switch_value(ndr, r);
3031                 switch (level) {
3032                         case TRUST_AUTH_TYPE_NONE:
3033                         break;
3034
3035                         case TRUST_AUTH_TYPE_NT4OWF:
3036                         break;
3037
3038                         case TRUST_AUTH_TYPE_CLEAR:
3039                         break;
3040
3041                         case TRUST_AUTH_TYPE_VERSION:
3042                         break;
3043
3044                         default:
3045                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3046                 }
3047         }
3048         return NDR_ERR_SUCCESS;
3049 }
3050
3051 static enum ndr_err_code ndr_pull_AuthInfo(struct ndr_pull *ndr, int ndr_flags, union AuthInfo *r)
3052 {
3053         int level;
3054         level = ndr_pull_get_switch_value(ndr, r);
3055         if (ndr_flags & NDR_SCALARS) {
3056                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
3057                 switch (level) {
3058                         case TRUST_AUTH_TYPE_NONE: {
3059                                 NDR_CHECK(ndr_pull_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
3060                         break; }
3061
3062                         case TRUST_AUTH_TYPE_NT4OWF: {
3063                                 NDR_CHECK(ndr_pull_AuthInfoNT4Owf(ndr, NDR_SCALARS, &r->nt4owf));
3064                         break; }
3065
3066                         case TRUST_AUTH_TYPE_CLEAR: {
3067                                 NDR_CHECK(ndr_pull_AuthInfoClear(ndr, NDR_SCALARS, &r->clear));
3068                         break; }
3069
3070                         case TRUST_AUTH_TYPE_VERSION: {
3071                                 NDR_CHECK(ndr_pull_AuthInfoVersion(ndr, NDR_SCALARS, &r->version));
3072                         break; }
3073
3074                         default:
3075                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3076                 }
3077         }
3078         if (ndr_flags & NDR_BUFFERS) {
3079                 switch (level) {
3080                         case TRUST_AUTH_TYPE_NONE:
3081                         break;
3082
3083                         case TRUST_AUTH_TYPE_NT4OWF:
3084                         break;
3085
3086                         case TRUST_AUTH_TYPE_CLEAR:
3087                         break;
3088
3089                         case TRUST_AUTH_TYPE_VERSION:
3090                         break;
3091
3092                         default:
3093                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3094                 }
3095         }
3096         return NDR_ERR_SUCCESS;
3097 }
3098
3099 _PUBLIC_ void ndr_print_AuthInfo(struct ndr_print *ndr, const char *name, const union AuthInfo *r)
3100 {
3101         int level;
3102         level = ndr_print_get_switch_value(ndr, r);
3103         ndr_print_union(ndr, name, level, "AuthInfo");
3104         switch (level) {
3105                 case TRUST_AUTH_TYPE_NONE:
3106                         ndr_print_AuthInfoNone(ndr, "none", &r->none);
3107                 break;
3108
3109                 case TRUST_AUTH_TYPE_NT4OWF:
3110                         ndr_print_AuthInfoNT4Owf(ndr, "nt4owf", &r->nt4owf);
3111                 break;
3112
3113                 case TRUST_AUTH_TYPE_CLEAR:
3114                         ndr_print_AuthInfoClear(ndr, "clear", &r->clear);
3115                 break;
3116
3117                 case TRUST_AUTH_TYPE_VERSION:
3118                         ndr_print_AuthInfoVersion(ndr, "version", &r->version);
3119                 break;
3120
3121                 default:
3122                         ndr_print_bad_level(ndr, name, level);
3123         }
3124 }
3125
3126 _PUBLIC_ enum ndr_err_code ndr_push_AuthenticationInformation(struct ndr_push *ndr, int ndr_flags, const struct AuthenticationInformation *r)
3127 {
3128         if (ndr_flags & NDR_SCALARS) {
3129                 NDR_CHECK(ndr_push_align(ndr, 4));
3130                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->LastUpdateTime));
3131                 NDR_CHECK(ndr_push_lsa_TrustAuthType(ndr, NDR_SCALARS, r->AuthType));
3132                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->AuthInfo, r->AuthType));
3133                 NDR_CHECK(ndr_push_AuthInfo(ndr, NDR_SCALARS, &r->AuthInfo));
3134                 {
3135                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
3136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3137                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
3138                         ndr->flags = _flags_save_DATA_BLOB;
3139                 }
3140                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3141         }
3142         if (ndr_flags & NDR_BUFFERS) {
3143         }
3144         return NDR_ERR_SUCCESS;
3145 }
3146
3147 _PUBLIC_ enum ndr_err_code ndr_pull_AuthenticationInformation(struct ndr_pull *ndr, int ndr_flags, struct AuthenticationInformation *r)
3148 {
3149         if (ndr_flags & NDR_SCALARS) {
3150                 NDR_CHECK(ndr_pull_align(ndr, 4));
3151                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->LastUpdateTime));
3152                 NDR_CHECK(ndr_pull_lsa_TrustAuthType(ndr, NDR_SCALARS, &r->AuthType));
3153                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->AuthInfo, r->AuthType));
3154                 NDR_CHECK(ndr_pull_AuthInfo(ndr, NDR_SCALARS, &r->AuthInfo));
3155                 {
3156                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
3157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3158                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
3159                         ndr->flags = _flags_save_DATA_BLOB;
3160                 }
3161                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3162         }
3163         if (ndr_flags & NDR_BUFFERS) {
3164         }
3165         return NDR_ERR_SUCCESS;
3166 }
3167
3168 _PUBLIC_ void ndr_print_AuthenticationInformation(struct ndr_print *ndr, const char *name, const struct AuthenticationInformation *r)
3169 {
3170         ndr_print_struct(ndr, name, "AuthenticationInformation");
3171         ndr->depth++;
3172         ndr_print_NTTIME(ndr, "LastUpdateTime", r->LastUpdateTime);
3173         ndr_print_lsa_TrustAuthType(ndr, "AuthType", r->AuthType);
3174         ndr_print_set_switch_value(ndr, &r->AuthInfo, r->AuthType);
3175         ndr_print_AuthInfo(ndr, "AuthInfo", &r->AuthInfo);
3176         ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
3177         ndr->depth--;
3178 }
3179
3180 _PUBLIC_ size_t ndr_size_trustAuthInOutBlob(const struct trustAuthInOutBlob *r, struct smb_iconv_convenience *ic, int flags)
3181 {
3182         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob, ic);
3183 }
3184
3185 _PUBLIC_ enum ndr_err_code ndr_push_trustCurrentPasswords(struct ndr_push *ndr, int ndr_flags, const struct trustCurrentPasswords *r)
3186 {
3187         uint32_t cntr_current_0;
3188         if (ndr_flags & NDR_SCALARS) {
3189                 NDR_CHECK(ndr_push_align(ndr, 5));
3190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3191                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3192                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->current[cntr_current_0]));
3193                 }
3194                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3195         }
3196         if (ndr_flags & NDR_BUFFERS) {
3197                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3198                         if (r->current[cntr_current_0]) {
3199                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->current[cntr_current_0]));
3200                                 NDR_CHECK(ndr_push_AuthenticationInformation(ndr, NDR_SCALARS, r->current[cntr_current_0]));
3201                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->current[cntr_current_0]));
3202                         }
3203                 }
3204         }
3205         return NDR_ERR_SUCCESS;
3206 }
3207
3208 _PUBLIC_ enum ndr_err_code ndr_pull_trustCurrentPasswords(struct ndr_pull *ndr, int ndr_flags, struct trustCurrentPasswords *r)
3209 {
3210         uint32_t _ptr_current;
3211         uint32_t cntr_current_0;
3212         TALLOC_CTX *_mem_save_current_0;
3213         TALLOC_CTX *_mem_save_current_1;
3214         if (ndr_flags & NDR_SCALARS) {
3215                 NDR_CHECK(ndr_pull_align(ndr, 5));
3216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3217                 NDR_PULL_ALLOC_N(ndr, r->current, r->count);
3218                 _mem_save_current_0 = NDR_PULL_GET_MEM_CTX(ndr);
3219                 NDR_PULL_SET_MEM_CTX(ndr, r->current, 0);
3220                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3221                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_current));
3222                         if (_ptr_current) {
3223                                 NDR_PULL_ALLOC(ndr, r->current[cntr_current_0]);
3224                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->current[cntr_current_0], _ptr_current));
3225                         } else {
3226                                 r->current[cntr_current_0] = NULL;
3227                         }
3228                 }
3229                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_0, 0);
3230                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3231         }
3232         if (ndr_flags & NDR_BUFFERS) {
3233                 _mem_save_current_0 = NDR_PULL_GET_MEM_CTX(ndr);
3234                 NDR_PULL_SET_MEM_CTX(ndr, r->current, 0);
3235                 for (cntr_current_0 = 0; cntr_current_0 < r->count; cntr_current_0++) {
3236                         if (r->current[cntr_current_0]) {
3237                                 uint32_t _relative_save_offset;
3238                                 _relative_save_offset = ndr->offset;
3239                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->current[cntr_current_0]));
3240                                 _mem_save_current_1 = NDR_PULL_GET_MEM_CTX(ndr);
3241                                 NDR_PULL_SET_MEM_CTX(ndr, r->current[cntr_current_0], 0);
3242                                 NDR_CHECK(ndr_pull_AuthenticationInformation(ndr, NDR_SCALARS, r->current[cntr_current_0]));
3243                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_1, 0);
3244                                 if (ndr->offset > ndr->relative_highest_offset) {
3245                                         ndr->relative_highest_offset = ndr->offset;
3246                                 }
3247                                 ndr->offset = _relative_save_offset;
3248                         }
3249                 }
3250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_current_0, 0);
3251         }
3252         return NDR_ERR_SUCCESS;
3253 }
3254
3255 _PUBLIC_ void ndr_print_trustCurrentPasswords(struct ndr_print *ndr, const char *name, const struct trustCurrentPasswords *r)
3256 {
3257         uint32_t cntr_current_0;
3258         ndr_print_struct(ndr, name, "trustCurrentPasswords");
3259         ndr->depth++;
3260         ndr_print_uint32(ndr, "count", r->count);
3261         ndr->print(ndr, "%s: ARRAY(%d)", "current", (int)r->count);
3262         ndr->depth++;
3263         for (cntr_current_0=0;cntr_current_0<r->count;cntr_current_0++) {
3264                 char *idx_0=NULL;
3265                 if (asprintf(&idx_0, "[%d]", cntr_current_0) != -1) {
3266                         ndr_print_ptr(ndr, "current", r->current[cntr_current_0]);
3267                         ndr->depth++;
3268                         if (r->current[cntr_current_0]) {
3269                                 ndr_print_AuthenticationInformation(ndr, "current", r->current[cntr_current_0]);
3270                         }
3271                         ndr->depth--;
3272                         free(idx_0);
3273                 }
3274         }
3275         ndr->depth--;
3276         ndr->depth--;
3277 }
3278
3279 _PUBLIC_ size_t ndr_size_trustCurrentPasswords(const struct trustCurrentPasswords *r, struct smb_iconv_convenience *ic, int flags)
3280 {
3281         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_trustCurrentPasswords, ic);
3282 }
3283
3284 _PUBLIC_ enum ndr_err_code ndr_push_trustDomainPasswords(struct ndr_push *ndr, int ndr_flags, const struct trustDomainPasswords *r)
3285 {
3286         if (ndr_flags & NDR_SCALARS) {
3287                 NDR_CHECK(ndr_push_align(ndr, 5));
3288                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->confounder, 512));
3289                 {
3290                         struct ndr_push *_ndr_outgoing;
3291                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_outgoing, 0, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
3292                         NDR_CHECK(ndr_push_trustCurrentPasswords(_ndr_outgoing, NDR_SCALARS|NDR_BUFFERS, &r->outgoing));
3293                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_outgoing, 0, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
3294                 }
3295                 {
3296                         struct ndr_push *_ndr_incoming;
3297                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_incoming, 0, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
3298                         NDR_CHECK(ndr_push_trustCurrentPasswords(_ndr_incoming, NDR_SCALARS|NDR_BUFFERS, &r->incoming));
3299                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_incoming, 0, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
3300                 }
3301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustCurrentPasswords(&r->outgoing, ndr->iconv_convenience, ndr->flags)));
3302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustCurrentPasswords(&r->incoming, ndr->iconv_convenience, ndr->flags)));
3303                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3304         }
3305         if (ndr_flags & NDR_BUFFERS) {
3306         }
3307         return NDR_ERR_SUCCESS;
3308 }
3309
3310 _PUBLIC_ void ndr_print_trustDomainPasswords(struct ndr_print *ndr, const char *name, const struct trustDomainPasswords *r)
3311 {
3312         ndr_print_struct(ndr, name, "trustDomainPasswords");
3313         ndr->depth++;
3314         ndr_print_array_uint8(ndr, "confounder", r->confounder, 512);
3315         ndr_print_trustCurrentPasswords(ndr, "outgoing", &r->outgoing);
3316         ndr_print_trustCurrentPasswords(ndr, "incoming", &r->incoming);
3317         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);
3318         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);
3319         ndr->depth--;
3320 }
3321
3322 _PUBLIC_ enum ndr_err_code ndr_push_DsCompressedChunk(struct ndr_push *ndr, int ndr_flags, const struct DsCompressedChunk *r)
3323 {
3324         if (ndr_flags & NDR_SCALARS) {
3325                 NDR_CHECK(ndr_push_align(ndr, 4));
3326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->marker));
3327                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
3328                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3329         }
3330         if (ndr_flags & NDR_BUFFERS) {
3331         }
3332         return NDR_ERR_SUCCESS;
3333 }
3334
3335 _PUBLIC_ enum ndr_err_code ndr_pull_DsCompressedChunk(struct ndr_pull *ndr, int ndr_flags, struct DsCompressedChunk *r)
3336 {
3337         if (ndr_flags & NDR_SCALARS) {
3338                 NDR_CHECK(ndr_pull_align(ndr, 4));
3339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->marker));
3340                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
3341                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3342         }
3343         if (ndr_flags & NDR_BUFFERS) {
3344         }
3345         return NDR_ERR_SUCCESS;
3346 }
3347
3348 _PUBLIC_ void ndr_print_DsCompressedChunk(struct ndr_print *ndr, const char *name, const struct DsCompressedChunk *r)
3349 {
3350         ndr_print_struct(ndr, name, "DsCompressedChunk");
3351         ndr->depth++;
3352         ndr_print_uint32(ndr, "marker", r->marker);
3353         ndr_print_DATA_BLOB(ndr, "data", r->data);
3354         ndr->depth--;
3355 }
3356
3357 static enum ndr_err_code ndr_push_ExtendedErrorAString(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorAString *r)
3358 {
3359         if (ndr_flags & NDR_SCALARS) {
3360                 NDR_CHECK(ndr_push_align(ndr, 5));
3361                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
3362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3363                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3364         }
3365         if (ndr_flags & NDR_BUFFERS) {
3366                 if (r->string) {
3367                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->__size));
3368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->__size, sizeof(uint8_t), CH_DOS));
3369                 }
3370         }
3371         return NDR_ERR_SUCCESS;
3372 }
3373
3374 static enum ndr_err_code ndr_pull_ExtendedErrorAString(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorAString *r)
3375 {
3376         uint32_t _ptr_string;
3377         TALLOC_CTX *_mem_save_string_0;
3378         if (ndr_flags & NDR_SCALARS) {
3379                 NDR_CHECK(ndr_pull_align(ndr, 5));
3380                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__size));
3381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3382                 if (_ptr_string) {
3383                         NDR_PULL_ALLOC(ndr, r->string);
3384                 } else {
3385                         r->string = NULL;
3386                 }
3387                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3388         }
3389         if (ndr_flags & NDR_BUFFERS) {
3390                 if (r->string) {
3391                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3392                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3393                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
3394                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint8_t), CH_DOS));
3395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3396                 }
3397                 if (r->string) {
3398                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->__size));
3399                 }
3400         }
3401         return NDR_ERR_SUCCESS;
3402 }
3403
3404 _PUBLIC_ void ndr_print_ExtendedErrorAString(struct ndr_print *ndr, const char *name, const struct ExtendedErrorAString *r)
3405 {
3406         ndr_print_struct(ndr, name, "ExtendedErrorAString");
3407         ndr->depth++;
3408         ndr_print_uint16(ndr, "__size", r->__size);
3409         ndr_print_ptr(ndr, "string", r->string);
3410         ndr->depth++;
3411         if (r->string) {
3412                 ndr_print_string(ndr, "string", r->string);
3413         }
3414         ndr->depth--;
3415         ndr->depth--;
3416 }
3417
3418 static enum ndr_err_code ndr_push_ExtendedErrorUString(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorUString *r)
3419 {
3420         if (ndr_flags & NDR_SCALARS) {
3421                 NDR_CHECK(ndr_push_align(ndr, 5));
3422                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
3423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3424                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3425         }
3426         if (ndr_flags & NDR_BUFFERS) {
3427                 if (r->string) {
3428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->__size));
3429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->__size, sizeof(uint16_t), CH_UTF16));
3430                 }
3431         }
3432         return NDR_ERR_SUCCESS;
3433 }
3434
3435 static enum ndr_err_code ndr_pull_ExtendedErrorUString(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorUString *r)
3436 {
3437         uint32_t _ptr_string;
3438         TALLOC_CTX *_mem_save_string_0;
3439         if (ndr_flags & NDR_SCALARS) {
3440                 NDR_CHECK(ndr_pull_align(ndr, 5));
3441                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__size));
3442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3443                 if (_ptr_string) {
3444                         NDR_PULL_ALLOC(ndr, r->string);
3445                 } else {
3446                         r->string = NULL;
3447                 }
3448                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3449         }
3450         if (ndr_flags & NDR_BUFFERS) {
3451                 if (r->string) {
3452                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3453                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
3455                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
3456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3457                 }
3458                 if (r->string) {
3459                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->__size));
3460                 }
3461         }
3462         return NDR_ERR_SUCCESS;
3463 }
3464
3465 _PUBLIC_ void ndr_print_ExtendedErrorUString(struct ndr_print *ndr, const char *name, const struct ExtendedErrorUString *r)
3466 {
3467         ndr_print_struct(ndr, name, "ExtendedErrorUString");
3468         ndr->depth++;
3469         ndr_print_uint16(ndr, "__size", r->__size);
3470         ndr_print_ptr(ndr, "string", r->string);
3471         ndr->depth++;
3472         if (r->string) {
3473                 ndr_print_string(ndr, "string", r->string);
3474         }
3475         ndr->depth--;
3476         ndr->depth--;
3477 }
3478
3479 static enum ndr_err_code ndr_push_ExtendedErrorBlob(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorBlob *r)
3480 {
3481         if (ndr_flags & NDR_SCALARS) {
3482                 NDR_CHECK(ndr_push_align(ndr, 5));
3483                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
3484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
3485                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3486         }
3487         if (ndr_flags & NDR_BUFFERS) {
3488                 if (r->data) {
3489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
3490                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
3491                 }
3492         }
3493         return NDR_ERR_SUCCESS;
3494 }
3495
3496 static enum ndr_err_code ndr_pull_ExtendedErrorBlob(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorBlob *r)
3497 {
3498         uint32_t _ptr_data;
3499         TALLOC_CTX *_mem_save_data_0;
3500         if (ndr_flags & NDR_SCALARS) {
3501                 NDR_CHECK(ndr_pull_align(ndr, 5));
3502                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
3503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
3504                 if (_ptr_data) {
3505                         NDR_PULL_ALLOC(ndr, r->data);
3506                 } else {
3507                         r->data = NULL;
3508                 }
3509                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3510         }
3511         if (ndr_flags & NDR_BUFFERS) {
3512                 if (r->data) {
3513                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
3514                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
3515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
3516                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
3517                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
3518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
3519                 }
3520                 if (r->data) {
3521                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
3522                 }
3523         }
3524         return NDR_ERR_SUCCESS;
3525 }
3526
3527 _PUBLIC_ void ndr_print_ExtendedErrorBlob(struct ndr_print *ndr, const char *name, const struct ExtendedErrorBlob *r)
3528 {
3529         ndr_print_struct(ndr, name, "ExtendedErrorBlob");
3530         ndr->depth++;
3531         ndr_print_uint16(ndr, "length", r->length);
3532         ndr_print_ptr(ndr, "data", r->data);
3533         ndr->depth++;
3534         if (r->data) {
3535                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
3536         }
3537         ndr->depth--;
3538         ndr->depth--;
3539 }
3540
3541 static enum ndr_err_code ndr_push_ExtendedErrorComputerNamePresent(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent r)
3542 {
3543         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
3544         return NDR_ERR_SUCCESS;
3545 }
3546
3547 static enum ndr_err_code ndr_pull_ExtendedErrorComputerNamePresent(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent *r)
3548 {
3549         uint16_t v;
3550         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
3551         *r = v;
3552         return NDR_ERR_SUCCESS;
3553 }
3554
3555 _PUBLIC_ void ndr_print_ExtendedErrorComputerNamePresent(struct ndr_print *ndr, const char *name, enum ExtendedErrorComputerNamePresent r)
3556 {
3557         const char *val = NULL;
3558
3559         switch (r) {
3560                 case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: val = "EXTENDED_ERROR_COMPUTER_NAME_PRESENT"; break;
3561                 case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: val = "EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT"; break;
3562         }
3563         ndr_print_enum(ndr, name, "ENUM", val, r);
3564 }
3565
3566 static enum ndr_err_code ndr_push_ExtendedErrorComputerNameU(struct ndr_push *ndr, int ndr_flags, const union ExtendedErrorComputerNameU *r)
3567 {
3568         if (ndr_flags & NDR_SCALARS) {
3569                 int level = ndr_push_get_switch_value(ndr, r);
3570                 NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, level));
3571                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3572                 switch (level) {
3573                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
3574                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
3575                         break; }
3576
3577                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: {
3578                         break; }
3579
3580                         default:
3581                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3582                 }
3583         }
3584         if (ndr_flags & NDR_BUFFERS) {
3585                 int level = ndr_push_get_switch_value(ndr, r);
3586                 switch (level) {
3587                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3588                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->name));
3589                         break;
3590
3591                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3592                         break;
3593
3594                         default:
3595                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3596                 }
3597         }
3598         return NDR_ERR_SUCCESS;
3599 }
3600
3601 static enum ndr_err_code ndr_pull_ExtendedErrorComputerNameU(struct ndr_pull *ndr, int ndr_flags, union ExtendedErrorComputerNameU *r)
3602 {
3603         int level;
3604         uint16_t _level;
3605         level = ndr_pull_get_switch_value(ndr, r);
3606         if (ndr_flags & NDR_SCALARS) {
3607                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
3608                 if (_level != level) {
3609                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3610                 }
3611                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3612                 switch (level) {
3613                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
3614                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
3615                         break; }
3616
3617                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: {
3618                         break; }
3619
3620                         default:
3621                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3622                 }
3623         }
3624         if (ndr_flags & NDR_BUFFERS) {
3625                 switch (level) {
3626                         case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3627                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->name));
3628                         break;
3629
3630                         case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3631                         break;
3632
3633                         default:
3634                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3635                 }
3636         }
3637         return NDR_ERR_SUCCESS;
3638 }
3639
3640 _PUBLIC_ void ndr_print_ExtendedErrorComputerNameU(struct ndr_print *ndr, const char *name, const union ExtendedErrorComputerNameU *r)
3641 {
3642         int level;
3643         level = ndr_print_get_switch_value(ndr, r);
3644         ndr_print_union(ndr, name, level, "ExtendedErrorComputerNameU");
3645         switch (level) {
3646                 case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3647                         ndr_print_ExtendedErrorUString(ndr, "name", &r->name);
3648                 break;
3649
3650                 case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3651                 break;
3652
3653                 default:
3654                         ndr_print_bad_level(ndr, name, level);
3655         }
3656 }
3657
3658 static enum ndr_err_code ndr_push_ExtendedErrorComputerName(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorComputerName *r)
3659 {
3660         if (ndr_flags & NDR_SCALARS) {
3661                 NDR_CHECK(ndr_push_align(ndr, 5));
3662                 NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, r->present));
3663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->n, r->present));
3664                 NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
3665                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3666         }
3667         if (ndr_flags & NDR_BUFFERS) {
3668                 NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
3669         }
3670         return NDR_ERR_SUCCESS;
3671 }
3672
3673 static enum ndr_err_code ndr_pull_ExtendedErrorComputerName(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorComputerName *r)
3674 {
3675         if (ndr_flags & NDR_SCALARS) {
3676                 NDR_CHECK(ndr_pull_align(ndr, 5));
3677                 NDR_CHECK(ndr_pull_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, &r->present));
3678                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->n, r->present));
3679                 NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
3680                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3681         }
3682         if (ndr_flags & NDR_BUFFERS) {
3683                 NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
3684         }
3685         return NDR_ERR_SUCCESS;
3686 }
3687
3688 _PUBLIC_ void ndr_print_ExtendedErrorComputerName(struct ndr_print *ndr, const char *name, const struct ExtendedErrorComputerName *r)
3689 {
3690         ndr_print_struct(ndr, name, "ExtendedErrorComputerName");
3691         ndr->depth++;
3692         ndr_print_ExtendedErrorComputerNamePresent(ndr, "present", r->present);
3693         ndr_print_set_switch_value(ndr, &r->n, r->present);
3694         ndr_print_ExtendedErrorComputerNameU(ndr, "n", &r->n);
3695         ndr->depth--;
3696 }
3697
3698 static enum ndr_err_code ndr_push_ExtendedErrorParamType(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorParamType r)
3699 {
3700         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
3701         return NDR_ERR_SUCCESS;
3702 }
3703
3704 static enum ndr_err_code ndr_pull_ExtendedErrorParamType(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorParamType *r)
3705 {
3706         uint16_t v;
3707         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
3708         *r = v;
3709         return NDR_ERR_SUCCESS;
3710 }
3711
3712 _PUBLIC_ void ndr_print_ExtendedErrorParamType(struct ndr_print *ndr, const char *name, enum ExtendedErrorParamType r)
3713 {
3714         const char *val = NULL;
3715
3716         switch (r) {
3717                 case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: val = "EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING"; break;
3718                 case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: val = "EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING"; break;
3719                 case EXTENDED_ERROR_PARAM_TYPE_UINT32: val = "EXTENDED_ERROR_PARAM_TYPE_UINT32"; break;
3720                 case EXTENDED_ERROR_PARAM_TYPE_UINT16: val = "EXTENDED_ERROR_PARAM_TYPE_UINT16"; break;
3721                 case EXTENDED_ERROR_PARAM_TYPE_UINT64: val = "EXTENDED_ERROR_PARAM_TYPE_UINT64"; break;
3722                 case EXTENDED_ERROR_PARAM_TYPE_NONE: val = "EXTENDED_ERROR_PARAM_TYPE_NONE"; break;
3723                 case EXTENDED_ERROR_PARAM_TYPE_BLOB: val = "EXTENDED_ERROR_PARAM_TYPE_BLOB"; break;
3724         }
3725         ndr_print_enum(ndr, name, "ENUM", val, r);
3726 }
3727
3728 static enum ndr_err_code ndr_push_ExtendedErrorParamU(struct ndr_push *ndr, int ndr_flags, const union ExtendedErrorParamU *r)
3729 {
3730         if (ndr_flags & NDR_SCALARS) {
3731                 int level = ndr_push_get_switch_value(ndr, r);
3732                 NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, level));
3733                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3734                 switch (level) {
3735                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
3736                                 NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
3737                         break; }
3738
3739                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: {
3740                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->u_string));
3741                         break; }
3742
3743                         case EXTENDED_ERROR_PARAM_TYPE_UINT32: {
3744                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->uint32));
3745                         break; }
3746
3747                         case EXTENDED_ERROR_PARAM_TYPE_UINT16: {
3748                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->uint16));
3749                         break; }
3750
3751                         case EXTENDED_ERROR_PARAM_TYPE_UINT64: {
3752                                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uint64));
3753                         break; }
3754
3755                         case EXTENDED_ERROR_PARAM_TYPE_NONE: {
3756                         break; }
3757
3758                         case EXTENDED_ERROR_PARAM_TYPE_BLOB: {
3759                                 NDR_CHECK(ndr_push_ExtendedErrorBlob(ndr, NDR_SCALARS, &r->blob));
3760                         break; }
3761
3762                         default:
3763                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3764                 }
3765         }
3766         if (ndr_flags & NDR_BUFFERS) {
3767                 int level = ndr_push_get_switch_value(ndr, r);
3768                 switch (level) {
3769                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3770                                 NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_BUFFERS, &r->a_string));
3771                         break;
3772
3773                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3774                                 NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->u_string));
3775                         break;
3776
3777                         case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3778                         break;
3779
3780                         case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3781                         break;
3782
3783                         case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3784                         break;
3785
3786                         case EXTENDED_ERROR_PARAM_TYPE_NONE:
3787                         break;
3788
3789                         case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3790                                 NDR_CHECK(ndr_push_ExtendedErrorBlob(ndr, NDR_BUFFERS, &r->blob));
3791                         break;
3792
3793                         default:
3794                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3795                 }
3796         }
3797         return NDR_ERR_SUCCESS;
3798 }
3799
3800 static enum ndr_err_code ndr_pull_ExtendedErrorParamU(struct ndr_pull *ndr, int ndr_flags, union ExtendedErrorParamU *r)
3801 {
3802         int level;
3803         uint16_t _level;
3804         level = ndr_pull_get_switch_value(ndr, r);
3805         if (ndr_flags & NDR_SCALARS) {
3806                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
3807                 if (_level != level) {
3808                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3809                 }
3810                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3811                 switch (level) {
3812                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
3813                                 NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
3814                         break; }
3815
3816                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: {
3817                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->u_string));
3818                         break; }
3819
3820                         case EXTENDED_ERROR_PARAM_TYPE_UINT32: {
3821                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->uint32));
3822                         break; }
3823
3824                         case EXTENDED_ERROR_PARAM_TYPE_UINT16: {
3825                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->uint16));
3826                         break; }
3827
3828                         case EXTENDED_ERROR_PARAM_TYPE_UINT64: {
3829                                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uint64));
3830                         break; }
3831
3832                         case EXTENDED_ERROR_PARAM_TYPE_NONE: {
3833                         break; }
3834
3835                         case EXTENDED_ERROR_PARAM_TYPE_BLOB: {
3836                                 NDR_CHECK(ndr_pull_ExtendedErrorBlob(ndr, NDR_SCALARS, &r->blob));
3837                         break; }
3838
3839                         default:
3840                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3841                 }
3842         }
3843         if (ndr_flags & NDR_BUFFERS) {
3844                 switch (level) {
3845                         case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3846                                 NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_BUFFERS, &r->a_string));
3847                         break;
3848
3849                         case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3850                                 NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->u_string));
3851                         break;
3852
3853                         case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3854                         break;
3855
3856                         case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3857                         break;
3858
3859                         case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3860                         break;
3861
3862                         case EXTENDED_ERROR_PARAM_TYPE_NONE:
3863                         break;
3864
3865                         case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3866                                 NDR_CHECK(ndr_pull_ExtendedErrorBlob(ndr, NDR_BUFFERS, &r->blob));
3867                         break;
3868
3869                         default:
3870                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3871                 }
3872         }
3873         return NDR_ERR_SUCCESS;
3874 }
3875
3876 _PUBLIC_ void ndr_print_ExtendedErrorParamU(struct ndr_print *ndr, const char *name, const union ExtendedErrorParamU *r)
3877 {
3878         int level;
3879         level = ndr_print_get_switch_value(ndr, r);
3880         ndr_print_union(ndr, name, level, "ExtendedErrorParamU");
3881         switch (level) {
3882                 case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3883                         ndr_print_ExtendedErrorAString(ndr, "a_string", &r->a_string);
3884                 break;
3885
3886                 case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3887                         ndr_print_ExtendedErrorUString(ndr, "u_string", &r->u_string);
3888                 break;
3889
3890                 case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3891                         ndr_print_uint32(ndr, "uint32", r->uint32);
3892                 break;
3893
3894                 case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3895                         ndr_print_uint16(ndr, "uint16", r->uint16);
3896                 break;
3897
3898                 case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3899                         ndr_print_hyper(ndr, "uint64", r->uint64);
3900                 break;
3901
3902                 case EXTENDED_ERROR_PARAM_TYPE_NONE:
3903                 break;
3904
3905                 case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3906                         ndr_print_ExtendedErrorBlob(ndr, "blob", &r->blob);
3907                 break;
3908
3909                 default:
3910                         ndr_print_bad_level(ndr, name, level);
3911         }
3912 }
3913
3914 static enum ndr_err_code ndr_push_ExtendedErrorParam(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorParam *r)
3915 {
3916         if (ndr_flags & NDR_SCALARS) {
3917                 NDR_CHECK(ndr_push_align(ndr, 8));
3918                 NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, r->type));
3919                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->p, r->type));
3920                 NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
3921                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
3922         }
3923         if (ndr_flags & NDR_BUFFERS) {
3924                 NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
3925         }
3926         return NDR_ERR_SUCCESS;
3927 }
3928
3929 static enum ndr_err_code ndr_pull_ExtendedErrorParam(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorParam *r)
3930 {
3931         if (ndr_flags & NDR_SCALARS) {
3932                 NDR_CHECK(ndr_pull_align(ndr, 8));
3933                 NDR_CHECK(ndr_pull_ExtendedErrorParamType(ndr, NDR_SCALARS, &r->type));
3934                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->p, r->type));
3935                 NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
3936                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3937         }
3938         if (ndr_flags & NDR_BUFFERS) {
3939                 NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
3940         }
3941         return NDR_ERR_SUCCESS;
3942 }
3943
3944 _PUBLIC_ void ndr_print_ExtendedErrorParam(struct ndr_print *ndr, const char *name, const struct ExtendedErrorParam *r)
3945 {
3946         ndr_print_struct(ndr, name, "ExtendedErrorParam");
3947         ndr->depth++;
3948         ndr_print_ExtendedErrorParamType(ndr, "type", r->type);
3949         ndr_print_set_switch_value(ndr, &r->p, r->type);
3950         ndr_print_ExtendedErrorParamU(ndr, "p", &r->p);
3951         ndr->depth--;
3952 }
3953
3954 _PUBLIC_ enum ndr_err_code ndr_push_ExtendedErrorInfo(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorInfo *r)
3955 {
3956         uint32_t cntr_params_0;
3957         if (ndr_flags & NDR_SCALARS) {
3958                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_params));
3959                 NDR_CHECK(ndr_push_align(ndr, 8));
3960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
3961                 NDR_CHECK(ndr_push_ExtendedErrorComputerName(ndr, NDR_SCALARS, &r->computer_name));
3962                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->pid));
3963                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
3964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->generating_component));
3965                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
3966                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->detection_location));
3967                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->flags));
3968                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_params));
3969                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3970                         NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
3971                 }
3972                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
3973         }
3974         if (ndr_flags & NDR_BUFFERS) {
3975                 if (r->next) {
3976                         NDR_CHECK(ndr_push_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
3977                 }
3978                 NDR_CHECK(ndr_push_ExtendedErrorComputerName(ndr, NDR_BUFFERS, &r->computer_name));
3979                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3980                         NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_BUFFERS, &r->params[cntr_params_0]));
3981                 }
3982         }
3983         return NDR_ERR_SUCCESS;
3984 }
3985
3986 _PUBLIC_ enum ndr_err_code ndr_pull_ExtendedErrorInfo(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorInfo *r)
3987 {
3988         uint32_t _ptr_next;
3989         TALLOC_CTX *_mem_save_next_0;
3990         uint32_t cntr_params_0;
3991         TALLOC_CTX *_mem_save_params_0;
3992         if (ndr_flags & NDR_SCALARS) {
3993                 NDR_CHECK(ndr_pull_array_size(ndr, &r->params));
3994                 NDR_CHECK(ndr_pull_align(ndr, 8));
3995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
3996                 if (_ptr_next) {
3997                         NDR_PULL_ALLOC(ndr, r->next);
3998                 } else {
3999                         r->next = NULL;
4000                 }
4001                 NDR_CHECK(ndr_pull_ExtendedErrorComputerName(ndr, NDR_SCALARS, &r->computer_name));
4002                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->pid));
4003                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
4004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->generating_component));
4005                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
4006                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->detection_location));
4007                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
4008                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_params));
4009                 NDR_PULL_ALLOC_N(ndr, r->params, ndr_get_array_size(ndr, &r->params));
4010                 _mem_save_params_0 = NDR_PULL_GET_MEM_CTX(ndr);
4011                 NDR_PULL_SET_MEM_CTX(ndr, r->params, 0);
4012                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
4013                         NDR_CHECK(ndr_pull_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
4014                 }
4015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_params_0, 0);
4016                 if (r->params) {
4017                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->params, r->num_params));
4018                 }
4019                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
4020         }
4021         if (ndr_flags & NDR_BUFFERS) {
4022                 if (r->next) {
4023                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
4024                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
4025                         NDR_CHECK(ndr_pull_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
4026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
4027                 }
4028                 NDR_CHECK(ndr_pull_ExtendedErrorComputerName(ndr, NDR_BUFFERS, &r->computer_name));
4029                 _mem_save_params_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                 NDR_PULL_SET_MEM_CTX(ndr, r->params, 0);
4031                 for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
4032                         NDR_CHECK(ndr_pull_ExtendedErrorParam(ndr, NDR_BUFFERS, &r->params[cntr_params_0]));
4033                 }
4034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_params_0, 0);
4035         }
4036         return NDR_ERR_SUCCESS;
4037 }
4038
4039 _PUBLIC_ void ndr_print_ExtendedErrorInfo(struct ndr_print *ndr, const char *name, const struct ExtendedErrorInfo *r)
4040 {
4041         uint32_t cntr_params_0;
4042         ndr_print_struct(ndr, name, "ExtendedErrorInfo");
4043         ndr->depth++;
4044         ndr_print_ptr(ndr, "next", r->next);
4045         ndr->depth++;
4046         if (r->next) {
4047                 ndr_print_ExtendedErrorInfo(ndr, "next", r->next);
4048         }
4049         ndr->depth--;
4050         ndr_print_ExtendedErrorComputerName(ndr, "computer_name", &r->computer_name);
4051         ndr_print_hyper(ndr, "pid", r->pid);
4052         ndr_print_NTTIME(ndr, "time", r->time);
4053         ndr_print_uint32(ndr, "generating_component", r->generating_component);
4054         ndr_print_WERROR(ndr, "status", r->status);
4055         ndr_print_uint16(ndr, "detection_location", r->detection_location);
4056         ndr_print_uint16(ndr, "flags", r->flags);
4057         ndr_print_uint16(ndr, "num_params", r->num_params);
4058         ndr->print(ndr, "%s: ARRAY(%d)", "params", (int)r->num_params);
4059         ndr->depth++;
4060         for (cntr_params_0=0;cntr_params_0<r->num_params;cntr_params_0++) {
4061                 char *idx_0=NULL;
4062                 if (asprintf(&idx_0, "[%d]", cntr_params_0) != -1) {
4063                         ndr_print_ExtendedErrorParam(ndr, "params", &r->params[cntr_params_0]);
4064                         free(idx_0);
4065                 }
4066         }
4067         ndr->depth--;
4068         ndr->depth--;
4069 }
4070
4071 static enum ndr_err_code ndr_push_ExtendedErrorInfoPtr(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorInfoPtr *r)
4072 {
4073         if (ndr_flags & NDR_SCALARS) {
4074                 NDR_CHECK(ndr_push_align(ndr, 5));
4075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
4076                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4077         }
4078         if (ndr_flags & NDR_BUFFERS) {
4079                 if (r->info) {
4080                         NDR_CHECK(ndr_push_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
4081                 }
4082         }
4083         return NDR_ERR_SUCCESS;
4084 }
4085
4086 static enum ndr_err_code ndr_pull_ExtendedErrorInfoPtr(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorInfoPtr *r)
4087 {
4088         uint32_t _ptr_info;
4089         TALLOC_CTX *_mem_save_info_0;
4090         if (ndr_flags & NDR_SCALARS) {
4091                 NDR_CHECK(ndr_pull_align(ndr, 5));
4092                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4093                 if (_ptr_info) {
4094                         NDR_PULL_ALLOC(ndr, r->info);
4095                 } else {
4096                         r->info = NULL;
4097                 }
4098                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4099         }
4100         if (ndr_flags & NDR_BUFFERS) {
4101                 if (r->info) {
4102                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4103                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
4104                         NDR_CHECK(ndr_pull_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
4105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4106                 }
4107         }
4108         return NDR_ERR_SUCCESS;
4109 }
4110
4111 _PUBLIC_ void ndr_print_ExtendedErrorInfoPtr(struct ndr_print *ndr, const char *name, const struct ExtendedErrorInfoPtr *r)
4112 {
4113         ndr_print_struct(ndr, name, "ExtendedErrorInfoPtr");
4114         ndr->depth++;
4115         ndr_print_ptr(ndr, "info", r->info);
4116         ndr->depth++;
4117         if (r->info) {
4118                 ndr_print_ExtendedErrorInfo(ndr, "info", r->info);
4119         }
4120         ndr->depth--;
4121         ndr->depth--;
4122 }
4123
4124 static enum ndr_err_code ndr_push_ForestTrustString(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustString *r)
4125 {
4126         if (ndr_flags & NDR_SCALARS) {
4127                 NDR_CHECK(ndr_push_align(ndr, 4));
4128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
4129                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, strlen_m(r->string), sizeof(uint8_t), CH_UTF8));
4130                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4131         }
4132         if (ndr_flags & NDR_BUFFERS) {
4133         }
4134         return NDR_ERR_SUCCESS;
4135 }
4136
4137 static enum ndr_err_code ndr_pull_ForestTrustString(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustString *r)
4138 {
4139         if (ndr_flags & NDR_SCALARS) {
4140                 NDR_CHECK(ndr_pull_align(ndr, 4));
4141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4142                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, r->size, sizeof(uint8_t), CH_UTF8));
4143                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4144         }
4145         if (ndr_flags & NDR_BUFFERS) {
4146         }
4147         return NDR_ERR_SUCCESS;
4148 }
4149
4150 _PUBLIC_ void ndr_print_ForestTrustString(struct ndr_print *ndr, const char *name, const struct ForestTrustString *r)
4151 {
4152         ndr_print_struct(ndr, name, "ForestTrustString");
4153         ndr->depth++;
4154         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->size);
4155         ndr_print_string(ndr, "string", r->string);
4156         ndr->depth--;
4157 }
4158
4159 static enum ndr_err_code ndr_push_ForestTrustDataDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustDataDomainInfo *r)
4160 {
4161         {
4162                 uint32_t _flags_save_STRUCT = ndr->flags;
4163                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4164                 if (ndr_flags & NDR_SCALARS) {
4165                         NDR_CHECK(ndr_push_align(ndr, 4));
4166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->sid, ndr->flags)));
4167                         {
4168                                 struct ndr_push *_ndr_sid;
4169                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
4170                                 NDR_CHECK(ndr_push_dom_sid(_ndr_sid, NDR_SCALARS, &r->sid));
4171                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
4172                         }
4173                         NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->dns_name));
4174                         NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->netbios_name));
4175                         NDR_CHECK(ndr_push_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 static enum ndr_err_code ndr_pull_ForestTrustDataDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustDataDomainInfo *r)
4185 {
4186         {
4187                 uint32_t _flags_save_STRUCT = ndr->flags;
4188                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4189                 if (ndr_flags & NDR_SCALARS) {
4190                         NDR_CHECK(ndr_pull_align(ndr, 4));
4191                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
4192                         {
4193                                 struct ndr_pull *_ndr_sid;
4194                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
4195                                 NDR_CHECK(ndr_pull_dom_sid(_ndr_sid, NDR_SCALARS, &r->sid));
4196                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
4197                         }
4198                         NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->dns_name));
4199                         NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->netbios_name));
4200                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4201                 }
4202                 if (ndr_flags & NDR_BUFFERS) {
4203                 }
4204                 ndr->flags = _flags_save_STRUCT;
4205         }
4206         return NDR_ERR_SUCCESS;
4207 }
4208
4209 _PUBLIC_ void ndr_print_ForestTrustDataDomainInfo(struct ndr_print *ndr, const char *name, const struct ForestTrustDataDomainInfo *r)
4210 {
4211         ndr_print_struct(ndr, name, "ForestTrustDataDomainInfo");
4212         {
4213                 uint32_t _flags_save_STRUCT = ndr->flags;
4214                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4215                 ndr->depth++;
4216                 ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
4217                 ndr_print_dom_sid(ndr, "sid", &r->sid);
4218                 ndr_print_ForestTrustString(ndr, "dns_name", &r->dns_name);
4219                 ndr_print_ForestTrustString(ndr, "netbios_name", &r->netbios_name);
4220                 ndr->depth--;
4221                 ndr->flags = _flags_save_STRUCT;
4222         }
4223 }
4224
4225 static enum ndr_err_code ndr_push_ForestTrustDataBinaryData(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustDataBinaryData *r)
4226 {
4227         {
4228                 uint32_t _flags_save_STRUCT = ndr->flags;
4229                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4230                 if (ndr_flags & NDR_SCALARS) {
4231                         NDR_CHECK(ndr_push_align(ndr, 4));
4232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4233                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
4234                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4235                 }
4236                 if (ndr_flags & NDR_BUFFERS) {
4237                 }
4238                 ndr->flags = _flags_save_STRUCT;
4239         }
4240         return NDR_ERR_SUCCESS;
4241 }
4242
4243 static enum ndr_err_code ndr_pull_ForestTrustDataBinaryData(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustDataBinaryData *r)
4244 {
4245         {
4246                 uint32_t _flags_save_STRUCT = ndr->flags;
4247                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4248                 if (ndr_flags & NDR_SCALARS) {
4249                         NDR_CHECK(ndr_pull_align(ndr, 4));
4250                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4251                         NDR_PULL_ALLOC_N(ndr, r->data, r->size);
4252                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
4253                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4254                 }
4255                 if (ndr_flags & NDR_BUFFERS) {
4256                 }
4257                 ndr->flags = _flags_save_STRUCT;
4258         }
4259         return NDR_ERR_SUCCESS;
4260 }
4261
4262 _PUBLIC_ void ndr_print_ForestTrustDataBinaryData(struct ndr_print *ndr, const char *name, const struct ForestTrustDataBinaryData *r)
4263 {
4264         ndr_print_struct(ndr, name, "ForestTrustDataBinaryData");
4265         {
4266                 uint32_t _flags_save_STRUCT = ndr->flags;
4267                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4268                 ndr->depth++;
4269                 ndr_print_uint32(ndr, "size", r->size);
4270                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
4271                 ndr->depth--;
4272                 ndr->flags = _flags_save_STRUCT;
4273         }
4274 }
4275
4276 static enum ndr_err_code ndr_push_ForestTrustData(struct ndr_push *ndr, int ndr_flags, const union ForestTrustData *r)
4277 {
4278         if (ndr_flags & NDR_SCALARS) {
4279                 int level = ndr_push_get_switch_value(ndr, r);
4280                 NDR_CHECK(ndr_push_union_align(ndr, 4));
4281                 switch (level) {
4282                         case FOREST_TRUST_TOP_LEVEL_NAME: {
4283                                 NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4284                         break; }
4285
4286                         case FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4287                                 NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4288                         break; }
4289
4290                         case FOREST_TRUST_DOMAIN_INFO: {
4291                                 NDR_CHECK(ndr_push_ForestTrustDataDomainInfo(ndr, NDR_SCALARS, &r->info));
4292                         break; }
4293
4294                         default: {
4295                                 NDR_CHECK(ndr_push_ForestTrustDataBinaryData(ndr, NDR_SCALARS, &r->data));
4296                         break; }
4297
4298                 }
4299         }
4300         if (ndr_flags & NDR_BUFFERS) {
4301                 int level = ndr_push_get_switch_value(ndr, r);
4302                 switch (level) {
4303                         case FOREST_TRUST_TOP_LEVEL_NAME:
4304                         break;
4305
4306                         case FOREST_TRUST_TOP_LEVEL_NAME_EX:
4307                         break;
4308
4309                         case FOREST_TRUST_DOMAIN_INFO:
4310                         break;
4311
4312                         default:
4313                         break;
4314
4315                 }
4316         }
4317         return NDR_ERR_SUCCESS;
4318 }
4319
4320 static enum ndr_err_code ndr_pull_ForestTrustData(struct ndr_pull *ndr, int ndr_flags, union ForestTrustData *r)
4321 {
4322         int level;
4323         level = ndr_pull_get_switch_value(ndr, r);
4324         if (ndr_flags & NDR_SCALARS) {
4325                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
4326                 switch (level) {
4327                         case FOREST_TRUST_TOP_LEVEL_NAME: {
4328                                 NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4329                         break; }
4330
4331                         case FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4332                                 NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4333                         break; }
4334
4335                         case FOREST_TRUST_DOMAIN_INFO: {
4336                                 NDR_CHECK(ndr_pull_ForestTrustDataDomainInfo(ndr, NDR_SCALARS, &r->info));
4337                         break; }
4338
4339                         default: {
4340                                 NDR_CHECK(ndr_pull_ForestTrustDataBinaryData(ndr, NDR_SCALARS, &r->data));
4341                         break; }
4342
4343                 }
4344         }
4345         if (ndr_flags & NDR_BUFFERS) {
4346                 switch (level) {
4347                         case FOREST_TRUST_TOP_LEVEL_NAME:
4348                         break;
4349
4350                         case FOREST_TRUST_TOP_LEVEL_NAME_EX:
4351                         break;
4352
4353                         case FOREST_TRUST_DOMAIN_INFO:
4354                         break;
4355
4356                         default:
4357                         break;
4358
4359                 }
4360         }
4361         return NDR_ERR_SUCCESS;
4362 }
4363
4364 _PUBLIC_ void ndr_print_ForestTrustData(struct ndr_print *ndr, const char *name, const union ForestTrustData *r)
4365 {
4366         int level;
4367         level = ndr_print_get_switch_value(ndr, r);
4368         ndr_print_union(ndr, name, level, "ForestTrustData");
4369         switch (level) {
4370                 case FOREST_TRUST_TOP_LEVEL_NAME:
4371                         ndr_print_ForestTrustString(ndr, "name", &r->name);
4372                 break;
4373
4374                 case FOREST_TRUST_TOP_LEVEL_NAME_EX:
4375                         ndr_print_ForestTrustString(ndr, "name", &r->name);
4376                 break;
4377
4378                 case FOREST_TRUST_DOMAIN_INFO:
4379                         ndr_print_ForestTrustDataDomainInfo(ndr, "info", &r->info);
4380                 break;
4381
4382                 default:
4383                         ndr_print_ForestTrustDataBinaryData(ndr, "data", &r->data);
4384                 break;
4385
4386         }
4387 }
4388
4389 static enum ndr_err_code ndr_push_ForestTrustInfoRecordType(struct ndr_push *ndr, int ndr_flags, enum ForestTrustInfoRecordType r)
4390 {
4391         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
4392         return NDR_ERR_SUCCESS;
4393 }
4394
4395 static enum ndr_err_code ndr_pull_ForestTrustInfoRecordType(struct ndr_pull *ndr, int ndr_flags, enum ForestTrustInfoRecordType *r)
4396 {
4397         uint8_t v;
4398         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
4399         *r = v;
4400         return NDR_ERR_SUCCESS;
4401 }
4402
4403 _PUBLIC_ void ndr_print_ForestTrustInfoRecordType(struct ndr_print *ndr, const char *name, enum ForestTrustInfoRecordType r)
4404 {
4405         const char *val = NULL;
4406
4407         switch (r) {
4408                 case FOREST_TRUST_TOP_LEVEL_NAME: val = "FOREST_TRUST_TOP_LEVEL_NAME"; break;
4409                 case FOREST_TRUST_TOP_LEVEL_NAME_EX: val = "FOREST_TRUST_TOP_LEVEL_NAME_EX"; break;
4410                 case FOREST_TRUST_DOMAIN_INFO: val = "FOREST_TRUST_DOMAIN_INFO"; break;
4411         }
4412         ndr_print_enum(ndr, name, "ENUM", val, r);
4413 }
4414
4415 _PUBLIC_ enum ndr_err_code ndr_push_ForestTrustInfoRecord(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustInfoRecord *r)
4416 {
4417         {
4418                 uint32_t _flags_save_STRUCT = ndr->flags;
4419                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4420                 if (ndr_flags & NDR_SCALARS) {
4421                         NDR_CHECK(ndr_push_align(ndr, 4));
4422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4423                         NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
4424                         NDR_CHECK(ndr_push_ForestTrustInfoRecordType(ndr, NDR_SCALARS, r->type));
4425                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->type));
4426                         NDR_CHECK(ndr_push_ForestTrustData(ndr, NDR_SCALARS, &r->data));
4427                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4428                 }
4429                 if (ndr_flags & NDR_BUFFERS) {
4430                 }
4431                 ndr->flags = _flags_save_STRUCT;
4432         }
4433         return NDR_ERR_SUCCESS;
4434 }
4435
4436 _PUBLIC_ enum ndr_err_code ndr_pull_ForestTrustInfoRecord(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustInfoRecord *r)
4437 {
4438         {
4439                 uint32_t _flags_save_STRUCT = ndr->flags;
4440                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4441                 if (ndr_flags & NDR_SCALARS) {
4442                         NDR_CHECK(ndr_pull_align(ndr, 4));
4443                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4444                         NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
4445                         NDR_CHECK(ndr_pull_ForestTrustInfoRecordType(ndr, NDR_SCALARS, &r->type));
4446                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->type));
4447                         NDR_CHECK(ndr_pull_ForestTrustData(ndr, NDR_SCALARS, &r->data));
4448                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4449                 }
4450                 if (ndr_flags & NDR_BUFFERS) {
4451                 }
4452                 ndr->flags = _flags_save_STRUCT;
4453         }
4454         return NDR_ERR_SUCCESS;
4455 }
4456
4457 _PUBLIC_ void ndr_print_ForestTrustInfoRecord(struct ndr_print *ndr, const char *name, const struct ForestTrustInfoRecord *r)
4458 {
4459         ndr_print_struct(ndr, name, "ForestTrustInfoRecord");
4460         {
4461                 uint32_t _flags_save_STRUCT = ndr->flags;
4462                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4463                 ndr->depth++;
4464                 ndr_print_uint32(ndr, "flags", r->flags);
4465                 ndr_print_NTTIME(ndr, "timestamp", r->timestamp);
4466                 ndr_print_ForestTrustInfoRecordType(ndr, "type", r->type);
4467                 ndr_print_set_switch_value(ndr, &r->data, r->type);
4468                 ndr_print_ForestTrustData(ndr, "data", &r->data);
4469                 ndr->depth--;
4470                 ndr->flags = _flags_save_STRUCT;
4471         }
4472 }
4473
4474 _PUBLIC_ size_t ndr_size_ForestTrustInfoRecord(const struct ForestTrustInfoRecord *r, struct smb_iconv_convenience *ic, int flags)
4475 {
4476         flags |= LIBNDR_FLAG_NOALIGN;
4477         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ForestTrustInfoRecord, ic);
4478 }
4479
4480 static enum ndr_err_code ndr_push_ForestTrustInfoRecordArmor(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustInfoRecordArmor *r)
4481 {
4482         {
4483                 uint32_t _flags_save_STRUCT = ndr->flags;
4484                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4485                 if (ndr_flags & NDR_SCALARS) {
4486                         NDR_CHECK(ndr_push_align(ndr, 4));
4487                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ForestTrustInfoRecord(&r->record, ndr->iconv_convenience, ndr->flags)));
4488                         NDR_CHECK(ndr_push_ForestTrustInfoRecord(ndr, NDR_SCALARS, &r->record));
4489                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4490                 }
4491                 if (ndr_flags & NDR_BUFFERS) {
4492                 }
4493                 ndr->flags = _flags_save_STRUCT;
4494         }
4495         return NDR_ERR_SUCCESS;
4496 }
4497
4498 static enum ndr_err_code ndr_pull_ForestTrustInfoRecordArmor(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustInfoRecordArmor *r)
4499 {
4500         {
4501                 uint32_t _flags_save_STRUCT = ndr->flags;
4502                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4503                 if (ndr_flags & NDR_SCALARS) {
4504                         NDR_CHECK(ndr_pull_align(ndr, 4));
4505                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->record_size));
4506                         NDR_CHECK(ndr_pull_ForestTrustInfoRecord(ndr, NDR_SCALARS, &r->record));
4507                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4508                 }
4509                 if (ndr_flags & NDR_BUFFERS) {
4510                 }
4511                 ndr->flags = _flags_save_STRUCT;
4512         }
4513         return NDR_ERR_SUCCESS;
4514 }
4515
4516 _PUBLIC_ void ndr_print_ForestTrustInfoRecordArmor(struct ndr_print *ndr, const char *name, const struct ForestTrustInfoRecordArmor *r)
4517 {
4518         ndr_print_struct(ndr, name, "ForestTrustInfoRecordArmor");
4519         {
4520                 uint32_t _flags_save_STRUCT = ndr->flags;
4521                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4522                 ndr->depth++;
4523                 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);
4524                 ndr_print_ForestTrustInfoRecord(ndr, "record", &r->record);
4525                 ndr->depth--;
4526                 ndr->flags = _flags_save_STRUCT;
4527         }
4528 }
4529
4530 _PUBLIC_ enum ndr_err_code ndr_push_ForestTrustInfo(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustInfo *r)
4531 {
4532         uint32_t cntr_records_0;
4533         {
4534                 uint32_t _flags_save_STRUCT = ndr->flags;
4535                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4536                 if (ndr_flags & NDR_SCALARS) {
4537                         NDR_CHECK(ndr_push_align(ndr, 4));
4538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
4539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4540                         for (cntr_records_0 = 0; cntr_records_0 < r->count; cntr_records_0++) {
4541                                 NDR_CHECK(ndr_push_ForestTrustInfoRecordArmor(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
4542                         }
4543                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4544                 }
4545                 if (ndr_flags & NDR_BUFFERS) {
4546                 }
4547                 ndr->flags = _flags_save_STRUCT;
4548         }
4549         return NDR_ERR_SUCCESS;
4550 }
4551
4552 _PUBLIC_ enum ndr_err_code ndr_pull_ForestTrustInfo(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustInfo *r)
4553 {
4554         uint32_t cntr_records_0;
4555         TALLOC_CTX *_mem_save_records_0;
4556         {
4557                 uint32_t _flags_save_STRUCT = ndr->flags;
4558                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4559                 if (ndr_flags & NDR_SCALARS) {
4560                         NDR_CHECK(ndr_pull_align(ndr, 4));
4561                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
4562                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4563                         NDR_PULL_ALLOC_N(ndr, r->records, r->count);
4564                         _mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
4565                         NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);
4566                         for (cntr_records_0 = 0; cntr_records_0 < r->count; cntr_records_0++) {
4567                                 NDR_CHECK(ndr_pull_ForestTrustInfoRecordArmor(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
4568                         }
4569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
4570                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4571                 }
4572                 if (ndr_flags & NDR_BUFFERS) {
4573                 }
4574                 ndr->flags = _flags_save_STRUCT;
4575         }
4576         return NDR_ERR_SUCCESS;
4577 }
4578
4579 _PUBLIC_ void ndr_print_ForestTrustInfo(struct ndr_print *ndr, const char *name, const struct ForestTrustInfo *r)
4580 {
4581         uint32_t cntr_records_0;
4582         ndr_print_struct(ndr, name, "ForestTrustInfo");
4583         {
4584                 uint32_t _flags_save_STRUCT = ndr->flags;
4585                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4586                 ndr->depth++;
4587                 ndr_print_uint32(ndr, "version", r->version);
4588                 ndr_print_uint32(ndr, "count", r->count);
4589                 ndr->print(ndr, "%s: ARRAY(%d)", "records", (int)r->count);
4590                 ndr->depth++;
4591                 for (cntr_records_0=0;cntr_records_0<r->count;cntr_records_0++) {
4592                         char *idx_0=NULL;
4593                         if (asprintf(&idx_0, "[%d]", cntr_records_0) != -1) {
4594                                 ndr_print_ForestTrustInfoRecordArmor(ndr, "records", &r->records[cntr_records_0]);
4595                                 free(idx_0);
4596                         }
4597                 }
4598                 ndr->depth--;
4599                 ndr->depth--;
4600                 ndr->flags = _flags_save_STRUCT;
4601         }
4602 }
4603
4604 static enum ndr_err_code ndr_push_decode_replPropertyMetaData(struct ndr_push *ndr, int flags, const struct decode_replPropertyMetaData *r)
4605 {
4606         if (flags & NDR_IN) {
4607                 NDR_CHECK(ndr_push_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
4608         }
4609         if (flags & NDR_OUT) {
4610         }
4611         return NDR_ERR_SUCCESS;
4612 }
4613
4614 static enum ndr_err_code ndr_pull_decode_replPropertyMetaData(struct ndr_pull *ndr, int flags, struct decode_replPropertyMetaData *r)
4615 {
4616         if (flags & NDR_IN) {
4617                 NDR_CHECK(ndr_pull_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
4618         }
4619         if (flags & NDR_OUT) {
4620         }
4621         return NDR_ERR_SUCCESS;
4622 }
4623
4624 _PUBLIC_ void ndr_print_decode_replPropertyMetaData(struct ndr_print *ndr, const char *name, int flags, const struct decode_replPropertyMetaData *r)
4625 {
4626         ndr_print_struct(ndr, name, "decode_replPropertyMetaData");
4627         ndr->depth++;
4628         if (flags & NDR_SET_VALUES) {
4629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4630         }
4631         if (flags & NDR_IN) {
4632                 ndr_print_struct(ndr, "in", "decode_replPropertyMetaData");
4633                 ndr->depth++;
4634                 ndr_print_replPropertyMetaDataBlob(ndr, "blob", &r->in.blob);
4635                 ndr->depth--;
4636         }
4637         if (flags & NDR_OUT) {
4638                 ndr_print_struct(ndr, "out", "decode_replPropertyMetaData");
4639                 ndr->depth++;
4640                 ndr->depth--;
4641         }
4642         ndr->depth--;
4643 }
4644
4645 static enum ndr_err_code ndr_push_decode_replUpToDateVector(struct ndr_push *ndr, int flags, const struct decode_replUpToDateVector *r)
4646 {
4647         if (flags & NDR_IN) {
4648                 NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
4649         }
4650         if (flags & NDR_OUT) {
4651         }
4652         return NDR_ERR_SUCCESS;
4653 }
4654
4655 static enum ndr_err_code ndr_pull_decode_replUpToDateVector(struct ndr_pull *ndr, int flags, struct decode_replUpToDateVector *r)
4656 {
4657         if (flags & NDR_IN) {
4658                 NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
4659         }
4660         if (flags & NDR_OUT) {
4661         }
4662         return NDR_ERR_SUCCESS;
4663 }
4664
4665 _PUBLIC_ void ndr_print_decode_replUpToDateVector(struct ndr_print *ndr, const char *name, int flags, const struct decode_replUpToDateVector *r)
4666 {
4667         ndr_print_struct(ndr, name, "decode_replUpToDateVector");
4668         ndr->depth++;
4669         if (flags & NDR_SET_VALUES) {
4670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4671         }
4672         if (flags & NDR_IN) {
4673                 ndr_print_struct(ndr, "in", "decode_replUpToDateVector");
4674                 ndr->depth++;
4675                 ndr_print_replUpToDateVectorBlob(ndr, "blob", &r->in.blob);
4676                 ndr->depth--;
4677         }
4678         if (flags & NDR_OUT) {
4679                 ndr_print_struct(ndr, "out", "decode_replUpToDateVector");
4680                 ndr->depth++;
4681                 ndr->depth--;
4682         }
4683         ndr->depth--;
4684 }
4685
4686 static enum ndr_err_code ndr_push_decode_repsFromTo(struct ndr_push *ndr, int flags, const struct decode_repsFromTo *r)
4687 {
4688         if (flags & NDR_IN) {
4689                 NDR_CHECK(ndr_push_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4690         }
4691         if (flags & NDR_OUT) {
4692         }
4693         return NDR_ERR_SUCCESS;
4694 }
4695
4696 static enum ndr_err_code ndr_pull_decode_repsFromTo(struct ndr_pull *ndr, int flags, struct decode_repsFromTo *r)
4697 {
4698         if (flags & NDR_IN) {
4699                 NDR_CHECK(ndr_pull_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4700         }
4701         if (flags & NDR_OUT) {
4702         }
4703         return NDR_ERR_SUCCESS;
4704 }
4705
4706 _PUBLIC_ void ndr_print_decode_repsFromTo(struct ndr_print *ndr, const char *name, int flags, const struct decode_repsFromTo *r)
4707 {
4708         ndr_print_struct(ndr, name, "decode_repsFromTo");
4709         ndr->depth++;
4710         if (flags & NDR_SET_VALUES) {
4711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4712         }
4713         if (flags & NDR_IN) {
4714                 ndr_print_struct(ndr, "in", "decode_repsFromTo");
4715                 ndr->depth++;
4716                 ndr_print_repsFromToBlob(ndr, "blob", &r->in.blob);
4717                 ndr->depth--;
4718         }
4719         if (flags & NDR_OUT) {
4720                 ndr_print_struct(ndr, "out", "decode_repsFromTo");
4721                 ndr->depth++;
4722                 ndr->depth--;
4723         }
4724         ndr->depth--;
4725 }
4726
4727 static enum ndr_err_code ndr_push_decode_partialAttributeSet(struct ndr_push *ndr, int flags, const struct decode_partialAttributeSet *r)
4728 {
4729         if (flags & NDR_IN) {
4730                 NDR_CHECK(ndr_push_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
4731         }
4732         if (flags & NDR_OUT) {
4733         }
4734         return NDR_ERR_SUCCESS;
4735 }
4736
4737 static enum ndr_err_code ndr_pull_decode_partialAttributeSet(struct ndr_pull *ndr, int flags, struct decode_partialAttributeSet *r)
4738 {
4739         if (flags & NDR_IN) {
4740                 NDR_CHECK(ndr_pull_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
4741         }
4742         if (flags & NDR_OUT) {
4743         }
4744         return NDR_ERR_SUCCESS;
4745 }
4746
4747 _PUBLIC_ void ndr_print_decode_partialAttributeSet(struct ndr_print *ndr, const char *name, int flags, const struct decode_partialAttributeSet *r)
4748 {
4749         ndr_print_struct(ndr, name, "decode_partialAttributeSet");
4750         ndr->depth++;
4751         if (flags & NDR_SET_VALUES) {
4752                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4753         }
4754         if (flags & NDR_IN) {
4755                 ndr_print_struct(ndr, "in", "decode_partialAttributeSet");
4756                 ndr->depth++;
4757                 ndr_print_partialAttributeSetBlob(ndr, "blob", &r->in.blob);
4758                 ndr->depth--;
4759         }
4760         if (flags & NDR_OUT) {
4761                 ndr_print_struct(ndr, "out", "decode_partialAttributeSet");
4762                 ndr->depth++;
4763                 ndr->depth--;
4764         }
4765         ndr->depth--;
4766 }
4767
4768 static enum ndr_err_code ndr_push_decode_prefixMap(struct ndr_push *ndr, int flags, const struct decode_prefixMap *r)
4769 {
4770         if (flags & NDR_IN) {
4771                 NDR_CHECK(ndr_push_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4772         }
4773         if (flags & NDR_OUT) {
4774         }
4775         return NDR_ERR_SUCCESS;
4776 }
4777
4778 static enum ndr_err_code ndr_pull_decode_prefixMap(struct ndr_pull *ndr, int flags, struct decode_prefixMap *r)
4779 {
4780         if (flags & NDR_IN) {
4781                 NDR_CHECK(ndr_pull_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4782         }
4783         if (flags & NDR_OUT) {
4784         }
4785         return NDR_ERR_SUCCESS;
4786 }
4787
4788 _PUBLIC_ void ndr_print_decode_prefixMap(struct ndr_print *ndr, const char *name, int flags, const struct decode_prefixMap *r)
4789 {
4790         ndr_print_struct(ndr, name, "decode_prefixMap");
4791         ndr->depth++;
4792         if (flags & NDR_SET_VALUES) {
4793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4794         }
4795         if (flags & NDR_IN) {
4796                 ndr_print_struct(ndr, "in", "decode_prefixMap");
4797                 ndr->depth++;
4798                 ndr_print_prefixMapBlob(ndr, "blob", &r->in.blob);
4799                 ndr->depth--;
4800         }
4801         if (flags & NDR_OUT) {
4802                 ndr_print_struct(ndr, "out", "decode_prefixMap");
4803                 ndr->depth++;
4804                 ndr->depth--;
4805         }
4806         ndr->depth--;
4807 }
4808
4809 static enum ndr_err_code ndr_push_decode_ldapControlDirSync(struct ndr_push *ndr, int flags, const struct decode_ldapControlDirSync *r)
4810 {
4811         if (flags & NDR_IN) {
4812                 NDR_CHECK(ndr_push_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
4813         }
4814         if (flags & NDR_OUT) {
4815         }
4816         return NDR_ERR_SUCCESS;
4817 }
4818
4819 static enum ndr_err_code ndr_pull_decode_ldapControlDirSync(struct ndr_pull *ndr, int flags, struct decode_ldapControlDirSync *r)
4820 {
4821         if (flags & NDR_IN) {
4822                 NDR_CHECK(ndr_pull_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
4823         }
4824         if (flags & NDR_OUT) {
4825         }
4826         return NDR_ERR_SUCCESS;
4827 }
4828
4829 _PUBLIC_ void ndr_print_decode_ldapControlDirSync(struct ndr_print *ndr, const char *name, int flags, const struct decode_ldapControlDirSync *r)
4830 {
4831         ndr_print_struct(ndr, name, "decode_ldapControlDirSync");
4832         ndr->depth++;
4833         if (flags & NDR_SET_VALUES) {
4834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4835         }
4836         if (flags & NDR_IN) {
4837                 ndr_print_struct(ndr, "in", "decode_ldapControlDirSync");
4838                 ndr->depth++;
4839                 ndr_print_ldapControlDirSyncCookie(ndr, "cookie", &r->in.cookie);
4840                 ndr->depth--;
4841         }
4842         if (flags & NDR_OUT) {
4843                 ndr_print_struct(ndr, "out", "decode_ldapControlDirSync");
4844                 ndr->depth++;
4845                 ndr->depth--;
4846         }
4847         ndr->depth--;
4848 }
4849
4850 static enum ndr_err_code ndr_push_decode_supplementalCredentials(struct ndr_push *ndr, int flags, const struct decode_supplementalCredentials *r)
4851 {
4852         if (flags & NDR_IN) {
4853                 NDR_CHECK(ndr_push_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
4854         }
4855         if (flags & NDR_OUT) {
4856         }
4857         return NDR_ERR_SUCCESS;
4858 }
4859
4860 static enum ndr_err_code ndr_pull_decode_supplementalCredentials(struct ndr_pull *ndr, int flags, struct decode_supplementalCredentials *r)
4861 {
4862         if (flags & NDR_IN) {
4863                 NDR_CHECK(ndr_pull_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
4864         }
4865         if (flags & NDR_OUT) {
4866         }
4867         return NDR_ERR_SUCCESS;
4868 }
4869
4870 _PUBLIC_ void ndr_print_decode_supplementalCredentials(struct ndr_print *ndr, const char *name, int flags, const struct decode_supplementalCredentials *r)
4871 {
4872         ndr_print_struct(ndr, name, "decode_supplementalCredentials");
4873         ndr->depth++;
4874         if (flags & NDR_SET_VALUES) {
4875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4876         }
4877         if (flags & NDR_IN) {
4878                 ndr_print_struct(ndr, "in", "decode_supplementalCredentials");
4879                 ndr->depth++;
4880                 ndr_print_supplementalCredentialsBlob(ndr, "blob", &r->in.blob);
4881                 ndr->depth--;
4882         }
4883         if (flags & NDR_OUT) {
4884                 ndr_print_struct(ndr, "out", "decode_supplementalCredentials");
4885                 ndr->depth++;
4886                 ndr->depth--;
4887         }
4888         ndr->depth--;
4889 }
4890
4891 static enum ndr_err_code ndr_push_decode_Packages(struct ndr_push *ndr, int flags, const struct decode_Packages *r)
4892 {
4893         if (flags & NDR_IN) {
4894                 NDR_CHECK(ndr_push_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
4895         }
4896         if (flags & NDR_OUT) {
4897         }
4898         return NDR_ERR_SUCCESS;
4899 }
4900
4901 static enum ndr_err_code ndr_pull_decode_Packages(struct ndr_pull *ndr, int flags, struct decode_Packages *r)
4902 {
4903         if (flags & NDR_IN) {
4904                 NDR_CHECK(ndr_pull_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
4905         }
4906         if (flags & NDR_OUT) {
4907         }
4908         return NDR_ERR_SUCCESS;
4909 }
4910
4911 _PUBLIC_ void ndr_print_decode_Packages(struct ndr_print *ndr, const char *name, int flags, const struct decode_Packages *r)
4912 {
4913         ndr_print_struct(ndr, name, "decode_Packages");
4914         ndr->depth++;
4915         if (flags & NDR_SET_VALUES) {
4916                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4917         }
4918         if (flags & NDR_IN) {
4919                 ndr_print_struct(ndr, "in", "decode_Packages");
4920                 ndr->depth++;
4921                 ndr_print_package_PackagesBlob(ndr, "blob", &r->in.blob);
4922                 ndr->depth--;
4923         }
4924         if (flags & NDR_OUT) {
4925                 ndr_print_struct(ndr, "out", "decode_Packages");
4926                 ndr->depth++;
4927                 ndr->depth--;
4928         }
4929         ndr->depth--;
4930 }
4931
4932 static enum ndr_err_code ndr_push_decode_PrimaryKerberos(struct ndr_push *ndr, int flags, const struct decode_PrimaryKerberos *r)
4933 {
4934         if (flags & NDR_IN) {
4935                 NDR_CHECK(ndr_push_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4936         }
4937         if (flags & NDR_OUT) {
4938         }
4939         return NDR_ERR_SUCCESS;
4940 }
4941
4942 static enum ndr_err_code ndr_pull_decode_PrimaryKerberos(struct ndr_pull *ndr, int flags, struct decode_PrimaryKerberos *r)
4943 {
4944         if (flags & NDR_IN) {
4945                 NDR_CHECK(ndr_pull_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4946         }
4947         if (flags & NDR_OUT) {
4948         }
4949         return NDR_ERR_SUCCESS;
4950 }
4951
4952 _PUBLIC_ void ndr_print_decode_PrimaryKerberos(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryKerberos *r)
4953 {
4954         ndr_print_struct(ndr, name, "decode_PrimaryKerberos");
4955         ndr->depth++;
4956         if (flags & NDR_SET_VALUES) {
4957                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4958         }
4959         if (flags & NDR_IN) {
4960                 ndr_print_struct(ndr, "in", "decode_PrimaryKerberos");
4961                 ndr->depth++;
4962                 ndr_print_package_PrimaryKerberosBlob(ndr, "blob", &r->in.blob);
4963                 ndr->depth--;
4964         }
4965         if (flags & NDR_OUT) {
4966                 ndr_print_struct(ndr, "out", "decode_PrimaryKerberos");
4967                 ndr->depth++;
4968                 ndr->depth--;
4969         }
4970         ndr->depth--;
4971 }
4972
4973 static enum ndr_err_code ndr_push_decode_PrimaryCLEARTEXT(struct ndr_push *ndr, int flags, const struct decode_PrimaryCLEARTEXT *r)
4974 {
4975         if (flags & NDR_IN) {
4976                 NDR_CHECK(ndr_push_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
4977         }
4978         if (flags & NDR_OUT) {
4979         }
4980         return NDR_ERR_SUCCESS;
4981 }
4982
4983 static enum ndr_err_code ndr_pull_decode_PrimaryCLEARTEXT(struct ndr_pull *ndr, int flags, struct decode_PrimaryCLEARTEXT *r)
4984 {
4985         if (flags & NDR_IN) {
4986                 NDR_CHECK(ndr_pull_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
4987         }
4988         if (flags & NDR_OUT) {
4989         }
4990         return NDR_ERR_SUCCESS;
4991 }
4992
4993 _PUBLIC_ void ndr_print_decode_PrimaryCLEARTEXT(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryCLEARTEXT *r)
4994 {
4995         ndr_print_struct(ndr, name, "decode_PrimaryCLEARTEXT");
4996         ndr->depth++;
4997         if (flags & NDR_SET_VALUES) {
4998                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4999         }
5000         if (flags & NDR_IN) {
5001                 ndr_print_struct(ndr, "in", "decode_PrimaryCLEARTEXT");
5002                 ndr->depth++;
5003                 ndr_print_package_PrimaryCLEARTEXTBlob(ndr, "blob", &r->in.blob);
5004                 ndr->depth--;
5005         }
5006         if (flags & NDR_OUT) {
5007                 ndr_print_struct(ndr, "out", "decode_PrimaryCLEARTEXT");
5008                 ndr->depth++;
5009                 ndr->depth--;
5010         }
5011         ndr->depth--;
5012 }
5013
5014 static enum ndr_err_code ndr_push_decode_PrimaryWDigest(struct ndr_push *ndr, int flags, const struct decode_PrimaryWDigest *r)
5015 {
5016         if (flags & NDR_IN) {
5017                 NDR_CHECK(ndr_push_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
5018         }
5019         if (flags & NDR_OUT) {
5020         }
5021         return NDR_ERR_SUCCESS;
5022 }
5023
5024 static enum ndr_err_code ndr_pull_decode_PrimaryWDigest(struct ndr_pull *ndr, int flags, struct decode_PrimaryWDigest *r)
5025 {
5026         if (flags & NDR_IN) {
5027                 NDR_CHECK(ndr_pull_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
5028         }
5029         if (flags & NDR_OUT) {
5030         }
5031         return NDR_ERR_SUCCESS;
5032 }
5033
5034 _PUBLIC_ void ndr_print_decode_PrimaryWDigest(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryWDigest *r)
5035 {
5036         ndr_print_struct(ndr, name, "decode_PrimaryWDigest");
5037         ndr->depth++;
5038         if (flags & NDR_SET_VALUES) {
5039                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5040         }
5041         if (flags & NDR_IN) {
5042                 ndr_print_struct(ndr, "in", "decode_PrimaryWDigest");
5043                 ndr->depth++;
5044                 ndr_print_package_PrimaryWDigestBlob(ndr, "blob", &r->in.blob);
5045                 ndr->depth--;
5046         }
5047         if (flags & NDR_OUT) {
5048                 ndr_print_struct(ndr, "out", "decode_PrimaryWDigest");
5049                 ndr->depth++;
5050                 ndr->depth--;
5051         }
5052         ndr->depth--;
5053 }
5054
5055 static enum ndr_err_code ndr_push_decode_trustAuthInOut(struct ndr_push *ndr, int flags, const struct decode_trustAuthInOut *r)
5056 {
5057         if (flags & NDR_IN) {
5058                 NDR_CHECK(ndr_push_trustAuthInOutBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
5059         }
5060         if (flags & NDR_OUT) {
5061         }
5062         return NDR_ERR_SUCCESS;
5063 }
5064
5065 static enum ndr_err_code ndr_pull_decode_trustAuthInOut(struct ndr_pull *ndr, int flags, struct decode_trustAuthInOut *r)
5066 {
5067         if (flags & NDR_IN) {
5068                 NDR_CHECK(ndr_pull_trustAuthInOutBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
5069         }
5070         if (flags & NDR_OUT) {
5071         }
5072         return NDR_ERR_SUCCESS;
5073 }
5074
5075 _PUBLIC_ void ndr_print_decode_trustAuthInOut(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustAuthInOut *r)
5076 {
5077         ndr_print_struct(ndr, name, "decode_trustAuthInOut");
5078         ndr->depth++;
5079         if (flags & NDR_SET_VALUES) {
5080                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5081         }
5082         if (flags & NDR_IN) {
5083                 ndr_print_struct(ndr, "in", "decode_trustAuthInOut");
5084                 ndr->depth++;
5085                 ndr_print_trustAuthInOutBlob(ndr, "blob", &r->in.blob);
5086                 ndr->depth--;
5087         }
5088         if (flags & NDR_OUT) {
5089                 ndr_print_struct(ndr, "out", "decode_trustAuthInOut");
5090                 ndr->depth++;
5091                 ndr->depth--;
5092         }
5093         ndr->depth--;
5094 }
5095
5096 static enum ndr_err_code ndr_push_decode_trustDomainPasswords(struct ndr_push *ndr, int flags, const struct decode_trustDomainPasswords *r)
5097 {
5098         if (flags & NDR_IN) {
5099                 NDR_CHECK(ndr_push_trustDomainPasswords(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
5100         }
5101         if (flags & NDR_OUT) {
5102         }
5103         return NDR_ERR_SUCCESS;
5104 }
5105
5106 static enum ndr_err_code ndr_pull_decode_trustDomainPasswords(struct ndr_pull *ndr, int flags, struct decode_trustDomainPasswords *r)
5107 {
5108         if (flags & NDR_IN) {
5109                 NDR_CHECK(ndr_pull_trustDomainPasswords(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
5110         }
5111         if (flags & NDR_OUT) {
5112         }
5113         return NDR_ERR_SUCCESS;
5114 }
5115
5116 _PUBLIC_ void ndr_print_decode_trustDomainPasswords(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustDomainPasswords *r)
5117 {
5118         ndr_print_struct(ndr, name, "decode_trustDomainPasswords");
5119         ndr->depth++;
5120         if (flags & NDR_SET_VALUES) {
5121                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5122         }
5123         if (flags & NDR_IN) {
5124                 ndr_print_struct(ndr, "in", "decode_trustDomainPasswords");
5125                 ndr->depth++;
5126                 ndr_print_trustDomainPasswords(ndr, "blob", &r->in.blob);
5127                 ndr->depth--;
5128         }
5129         if (flags & NDR_OUT) {
5130                 ndr_print_struct(ndr, "out", "decode_trustDomainPasswords");
5131                 ndr->depth++;
5132                 ndr->depth--;
5133         }
5134         ndr->depth--;
5135 }
5136
5137 static enum ndr_err_code ndr_push_decode_ExtendedErrorInfo(struct ndr_push *ndr, int flags, const struct decode_ExtendedErrorInfo *r)
5138 {
5139         if (flags & NDR_IN) {
5140                 {
5141                         struct ndr_push *_ndr_ptr;
5142                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ptr, 0xFFFFFC01, -1));
5143                         NDR_CHECK(ndr_push_ExtendedErrorInfoPtr(_ndr_ptr, NDR_SCALARS|NDR_BUFFERS, &r->in.ptr));
5144                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ptr, 0xFFFFFC01, -1));
5145                 }
5146         }
5147         if (flags & NDR_OUT) {
5148         }
5149         return NDR_ERR_SUCCESS;
5150 }
5151
5152 static enum ndr_err_code ndr_pull_decode_ExtendedErrorInfo(struct ndr_pull *ndr, int flags, struct decode_ExtendedErrorInfo *r)
5153 {
5154         if (flags & NDR_IN) {
5155                 {
5156                         struct ndr_pull *_ndr_ptr;
5157                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ptr, 0xFFFFFC01, -1));
5158                         NDR_CHECK(ndr_pull_ExtendedErrorInfoPtr(_ndr_ptr, NDR_SCALARS|NDR_BUFFERS, &r->in.ptr));
5159                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ptr, 0xFFFFFC01, -1));
5160                 }
5161         }
5162         if (flags & NDR_OUT) {
5163         }
5164         return NDR_ERR_SUCCESS;
5165 }
5166
5167 _PUBLIC_ void ndr_print_decode_ExtendedErrorInfo(struct ndr_print *ndr, const char *name, int flags, const struct decode_ExtendedErrorInfo *r)
5168 {
5169         ndr_print_struct(ndr, name, "decode_ExtendedErrorInfo");
5170         ndr->depth++;
5171         if (flags & NDR_SET_VALUES) {
5172                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5173         }
5174         if (flags & NDR_IN) {
5175                 ndr_print_struct(ndr, "in", "decode_ExtendedErrorInfo");
5176                 ndr->depth++;
5177                 ndr_print_ExtendedErrorInfoPtr(ndr, "ptr", &r->in.ptr);
5178                 ndr->depth--;
5179         }
5180         if (flags & NDR_OUT) {
5181                 ndr_print_struct(ndr, "out", "decode_ExtendedErrorInfo");
5182                 ndr->depth++;
5183                 ndr->depth--;
5184         }
5185         ndr->depth--;
5186 }
5187
5188 static enum ndr_err_code ndr_push_decode_ForestTrustInfo(struct ndr_push *ndr, int flags, const struct decode_ForestTrustInfo *r)
5189 {
5190         if (flags & NDR_IN) {
5191                 NDR_CHECK(ndr_push_ForestTrustInfo(ndr, NDR_SCALARS, &r->in.blob));
5192         }
5193         if (flags & NDR_OUT) {
5194         }
5195         return NDR_ERR_SUCCESS;
5196 }
5197
5198 static enum ndr_err_code ndr_pull_decode_ForestTrustInfo(struct ndr_pull *ndr, int flags, struct decode_ForestTrustInfo *r)
5199 {
5200         if (flags & NDR_IN) {
5201                 NDR_CHECK(ndr_pull_ForestTrustInfo(ndr, NDR_SCALARS, &r->in.blob));
5202         }
5203         if (flags & NDR_OUT) {
5204         }
5205         return NDR_ERR_SUCCESS;
5206 }
5207
5208 _PUBLIC_ void ndr_print_decode_ForestTrustInfo(struct ndr_print *ndr, const char *name, int flags, const struct decode_ForestTrustInfo *r)
5209 {
5210         ndr_print_struct(ndr, name, "decode_ForestTrustInfo");
5211         ndr->depth++;
5212         if (flags & NDR_SET_VALUES) {
5213                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5214         }
5215         if (flags & NDR_IN) {
5216                 ndr_print_struct(ndr, "in", "decode_ForestTrustInfo");
5217                 ndr->depth++;
5218                 ndr_print_ForestTrustInfo(ndr, "blob", &r->in.blob);
5219                 ndr->depth--;
5220         }
5221         if (flags & NDR_OUT) {
5222                 ndr_print_struct(ndr, "out", "decode_ForestTrustInfo");
5223                 ndr->depth++;
5224                 ndr->depth--;
5225         }
5226         ndr->depth--;
5227 }
5228
5229 static const struct ndr_interface_call drsblobs_calls[] = {
5230         {
5231                 "decode_replPropertyMetaData",
5232                 sizeof(struct decode_replPropertyMetaData),
5233                 (ndr_push_flags_fn_t) ndr_push_decode_replPropertyMetaData,
5234                 (ndr_pull_flags_fn_t) ndr_pull_decode_replPropertyMetaData,
5235                 (ndr_print_function_t) ndr_print_decode_replPropertyMetaData,
5236                 false,
5237         },
5238         {
5239                 "decode_replUpToDateVector",
5240                 sizeof(struct decode_replUpToDateVector),
5241                 (ndr_push_flags_fn_t) ndr_push_decode_replUpToDateVector,
5242                 (ndr_pull_flags_fn_t) ndr_pull_decode_replUpToDateVector,
5243                 (ndr_print_function_t) ndr_print_decode_replUpToDateVector,
5244                 false,
5245         },
5246         {
5247                 "decode_repsFromTo",
5248                 sizeof(struct decode_repsFromTo),
5249                 (ndr_push_flags_fn_t) ndr_push_decode_repsFromTo,
5250                 (ndr_pull_flags_fn_t) ndr_pull_decode_repsFromTo,
5251                 (ndr_print_function_t) ndr_print_decode_repsFromTo,
5252                 false,
5253         },
5254         {
5255                 "decode_partialAttributeSet",
5256                 sizeof(struct decode_partialAttributeSet),
5257                 (ndr_push_flags_fn_t) ndr_push_decode_partialAttributeSet,
5258                 (ndr_pull_flags_fn_t) ndr_pull_decode_partialAttributeSet,
5259                 (ndr_print_function_t) ndr_print_decode_partialAttributeSet,
5260                 false,
5261         },
5262         {
5263                 "decode_prefixMap",
5264                 sizeof(struct decode_prefixMap),
5265                 (ndr_push_flags_fn_t) ndr_push_decode_prefixMap,
5266                 (ndr_pull_flags_fn_t) ndr_pull_decode_prefixMap,
5267                 (ndr_print_function_t) ndr_print_decode_prefixMap,
5268                 false,
5269         },
5270         {
5271                 "decode_ldapControlDirSync",
5272                 sizeof(struct decode_ldapControlDirSync),
5273                 (ndr_push_flags_fn_t) ndr_push_decode_ldapControlDirSync,
5274                 (ndr_pull_flags_fn_t) ndr_pull_decode_ldapControlDirSync,
5275                 (ndr_print_function_t) ndr_print_decode_ldapControlDirSync,
5276                 false,
5277         },
5278         {
5279                 "decode_supplementalCredentials",
5280                 sizeof(struct decode_supplementalCredentials),
5281                 (ndr_push_flags_fn_t) ndr_push_decode_supplementalCredentials,
5282                 (ndr_pull_flags_fn_t) ndr_pull_decode_supplementalCredentials,
5283                 (ndr_print_function_t) ndr_print_decode_supplementalCredentials,
5284                 false,
5285         },
5286         {
5287                 "decode_Packages",
5288                 sizeof(struct decode_Packages),
5289                 (ndr_push_flags_fn_t) ndr_push_decode_Packages,
5290                 (ndr_pull_flags_fn_t) ndr_pull_decode_Packages,
5291                 (ndr_print_function_t) ndr_print_decode_Packages,
5292                 false,
5293         },
5294         {
5295                 "decode_PrimaryKerberos",
5296                 sizeof(struct decode_PrimaryKerberos),
5297                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryKerberos,
5298                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryKerberos,
5299                 (ndr_print_function_t) ndr_print_decode_PrimaryKerberos,
5300                 false,
5301         },
5302         {
5303                 "decode_PrimaryCLEARTEXT",
5304                 sizeof(struct decode_PrimaryCLEARTEXT),
5305                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryCLEARTEXT,
5306                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryCLEARTEXT,
5307                 (ndr_print_function_t) ndr_print_decode_PrimaryCLEARTEXT,
5308                 false,
5309         },
5310         {
5311                 "decode_PrimaryWDigest",
5312                 sizeof(struct decode_PrimaryWDigest),
5313                 (ndr_push_flags_fn_t) ndr_push_decode_PrimaryWDigest,
5314                 (ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryWDigest,
5315                 (ndr_print_function_t) ndr_print_decode_PrimaryWDigest,
5316                 false,
5317         },
5318         {
5319                 "decode_trustAuthInOut",
5320                 sizeof(struct decode_trustAuthInOut),
5321                 (ndr_push_flags_fn_t) ndr_push_decode_trustAuthInOut,
5322                 (ndr_pull_flags_fn_t) ndr_pull_decode_trustAuthInOut,
5323                 (ndr_print_function_t) ndr_print_decode_trustAuthInOut,
5324                 false,
5325         },
5326         {
5327                 "decode_trustDomainPasswords",
5328                 sizeof(struct decode_trustDomainPasswords),
5329                 (ndr_push_flags_fn_t) ndr_push_decode_trustDomainPasswords,
5330                 (ndr_pull_flags_fn_t) ndr_pull_decode_trustDomainPasswords,
5331                 (ndr_print_function_t) ndr_print_decode_trustDomainPasswords,
5332                 false,
5333         },
5334         {
5335                 "decode_ExtendedErrorInfo",
5336                 sizeof(struct decode_ExtendedErrorInfo),
5337                 (ndr_push_flags_fn_t) ndr_push_decode_ExtendedErrorInfo,
5338                 (ndr_pull_flags_fn_t) ndr_pull_decode_ExtendedErrorInfo,
5339                 (ndr_print_function_t) ndr_print_decode_ExtendedErrorInfo,
5340                 false,
5341         },
5342         {
5343                 "decode_ForestTrustInfo",
5344                 sizeof(struct decode_ForestTrustInfo),
5345                 (ndr_push_flags_fn_t) ndr_push_decode_ForestTrustInfo,
5346                 (ndr_pull_flags_fn_t) ndr_pull_decode_ForestTrustInfo,
5347                 (ndr_print_function_t) ndr_print_decode_ForestTrustInfo,
5348                 false,
5349         },
5350         { NULL, 0, NULL, NULL, NULL, false }
5351 };
5352
5353 static const char * const drsblobs_endpoint_strings[] = {
5354         "ncacn_np:[\\pipe\\drsblobs]",
5355 };
5356
5357 static const struct ndr_interface_string_array drsblobs_endpoints = {
5358         .count  = 1,
5359         .names  = drsblobs_endpoint_strings
5360 };
5361
5362 static const char * const drsblobs_authservice_strings[] = {
5363         "host",
5364 };
5365
5366 static const struct ndr_interface_string_array drsblobs_authservices = {
5367         .count  = 1,
5368         .names  = drsblobs_authservice_strings
5369 };
5370
5371
5372 const struct ndr_interface_table ndr_table_drsblobs = {
5373         .name           = "drsblobs",
5374         .syntax_id      = {
5375                 {0x12345778,0x1234,0xabcd,{0x00,0x01},{0x00,0x00,0x00,0x01}},
5376                 NDR_DRSBLOBS_VERSION
5377         },
5378         .helpstring     = NDR_DRSBLOBS_HELPSTRING,
5379         .num_calls      = 15,
5380         .calls          = drsblobs_calls,
5381         .endpoints      = &drsblobs_endpoints,
5382         .authservices   = &drsblobs_authservices
5383 };
5384