LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_drsblobs.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 2064 3741 55.2 %
Date: 2021-09-23 10:06:22 Functions: 143 277 51.6 %

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

Generated by: LCOV version 1.13