librpc/gen_ndr/ndr_drsblobs.c

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