librpc/gen_ndr/ndr_drsuapi.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_drsuapi.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_misc.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/ndr/ndr_compression.h"
  10 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DrsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  11 {
  12         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DrsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  17 {
  18         uint32_t v;
  19         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_drsuapi_DrsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
  25 {
  26         ndr_print_uint32(ndr, name, r);
  27         ndr->depth++;
  28         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_OP", DRSUAPI_DRS_ASYNC_OP, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GETCHG_CHECK", DRSUAPI_DRS_GETCHG_CHECK, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_UPDATE_NOTIFICATION", DRSUAPI_DRS_UPDATE_NOTIFICATION, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ADD_REF", DRSUAPI_DRS_ADD_REF, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_ALL", DRSUAPI_DRS_SYNC_ALL, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DEL_REF", DRSUAPI_DRS_DEL_REF, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_WRIT_REP", DRSUAPI_DRS_WRIT_REP, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC", DRSUAPI_DRS_INIT_SYNC, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PER_SYNC", DRSUAPI_DRS_PER_SYNC, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_MAIL_REP", DRSUAPI_DRS_MAIL_REP, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_REP", DRSUAPI_DRS_ASYNC_REP, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_IGNORE_ERROR", DRSUAPI_DRS_IGNORE_ERROR, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_TWOWAY_SYNC", DRSUAPI_DRS_TWOWAY_SYNC, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_CRITICAL_ONLY", DRSUAPI_DRS_CRITICAL_ONLY, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ANC", DRSUAPI_DRS_GET_ANC, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_NC_SIZE", DRSUAPI_DRS_GET_NC_SIZE, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_LOCAL_ONLY", DRSUAPI_DRS_LOCAL_ONLY, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NONGC_RO_REP", DRSUAPI_DRS_NONGC_RO_REP, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS", DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_REQUEUE", DRSUAPI_DRS_SYNC_REQUEUE, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_URGENT", DRSUAPI_DRS_SYNC_URGENT, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_DISCARD", DRSUAPI_DRS_NO_DISCARD, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_SYNCED", DRSUAPI_DRS_NEVER_SYNCED, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC_NOW", DRSUAPI_DRS_INIT_SYNC_NOW, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PREEMPTED", DRSUAPI_DRS_PREEMPTED, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
  62         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
  63         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
  64         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
  65         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
  66         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
  67         ndr->depth--;
  68 }
  69
  70 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  71 {
  72         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  77 {
  78         uint32_t v;
  79         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  80         *r = v;
  81         return NDR_ERR_SUCCESS;
  82 }
  83
  84 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  85 {
  86         ndr_print_uint32(ndr, name, r);
  87         ndr->depth++;
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  99         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
 100         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD", DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD, r);
 101         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
 102         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
 103         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
 104         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
 105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
 106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
 107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
 108         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5, r);
 109         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
 110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
 111         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
 112         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
 113         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
 114         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
 115         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
 116         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
 117         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
 118         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
 119         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V10", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V10, r);
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART2", DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART2, r);
 121         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART3", DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART3, r);
 122         ndr->depth--;
 123 }
 124
 125 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 126 {
 127         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 128         return NDR_ERR_SUCCESS;
 129 }
 130
 131 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 132 {
 133         uint32_t v;
 134         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 135         *r = v;
 136         return NDR_ERR_SUCCESS;
 137 }
 138
 139 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
 140 {
 141         ndr_print_uint32(ndr, name, r);
 142         ndr->depth++;
 143         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
 144         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
 145         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RECYCLE_BIN", DRSUAPI_SUPPORTED_EXTENSION_RECYCLE_BIN, r);
 146         ndr->depth--;
 147 }
 148
 149 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
 150 {
 151         if (ndr_flags & NDR_SCALARS) {
 152                 NDR_CHECK(ndr_push_align(ndr, 4));
 153                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 154                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 156                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 157         }
 158         if (ndr_flags & NDR_BUFFERS) {
 159         }
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 NDR_CHECK(ndr_pull_align(ndr, 4));
 167                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 168                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 170                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 171         }
 172         if (ndr_flags & NDR_BUFFERS) {
 173         }
 174         return NDR_ERR_SUCCESS;
 175 }
 176
 177 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 178 {
 179         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 180         ndr->depth++;
 181         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 182         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 183         ndr_print_uint32(ndr, "pid", r->pid);
 184         ndr->depth--;
 185 }
 186
 187 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 188 {
 189         if (ndr_flags & NDR_SCALARS) {
 190                 NDR_CHECK(ndr_push_align(ndr, 4));
 191                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 192                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 195                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 196         }
 197         if (ndr_flags & NDR_BUFFERS) {
 198         }
 199         return NDR_ERR_SUCCESS;
 200 }
 201
 202 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 203 {
 204         if (ndr_flags & NDR_SCALARS) {
 205                 NDR_CHECK(ndr_pull_align(ndr, 4));
 206                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 207                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 211         }
 212         if (ndr_flags & NDR_BUFFERS) {
 213         }
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 218 {
 219         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 220         ndr->depth++;
 221         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 222         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 223         ndr_print_uint32(ndr, "pid", r->pid);
 224         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 225         ndr->depth--;
 226 }
 227
 228 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 229 {
 230         if (ndr_flags & NDR_SCALARS) {
 231                 NDR_CHECK(ndr_push_align(ndr, 4));
 232                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 233                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 236                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 237                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 238                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 239         }
 240         if (ndr_flags & NDR_BUFFERS) {
 241         }
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_pull_align(ndr, 4));
 249                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 250                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 253                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 254                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 255                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 256         }
 257         if (ndr_flags & NDR_BUFFERS) {
 258         }
 259         return NDR_ERR_SUCCESS;
 260 }
 261
 262 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 263 {
 264         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 265         ndr->depth++;
 266         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 267         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 268         ndr_print_uint32(ndr, "pid", r->pid);
 269         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 270         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 271         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 272         ndr->depth--;
 273 }
 274
 275 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 276 {
 277         if (ndr_flags & NDR_SCALARS) {
 278                 NDR_CHECK(ndr_push_align(ndr, 4));
 279                 {
 280                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 282                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 283                         ndr->flags = _flags_save_DATA_BLOB;
 284                 }
 285                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 286         }
 287         if (ndr_flags & NDR_BUFFERS) {
 288         }
 289         return NDR_ERR_SUCCESS;
 290 }
 291
 292 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 293 {
 294         if (ndr_flags & NDR_SCALARS) {
 295                 NDR_CHECK(ndr_pull_align(ndr, 4));
 296                 {
 297                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 299                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 300                         ndr->flags = _flags_save_DATA_BLOB;
 301                 }
 302                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 303         }
 304         if (ndr_flags & NDR_BUFFERS) {
 305         }
 306         return NDR_ERR_SUCCESS;
 307 }
 308
 309 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 310 {
 311         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 312         ndr->depth++;
 313         ndr_print_DATA_BLOB(ndr, "info", r->info);
 314         ndr->depth--;
 315 }
 316
 317 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 318 {
 319         if (ndr_flags & NDR_SCALARS) {
 320                 int level = ndr_push_get_switch_value(ndr, r);
 321                 NDR_CHECK(ndr_push_union_align(ndr, 1));
 322                 switch (level) {
 323                         case 24: {
 324                                 {
 325                                         struct ndr_push *_ndr_info24;
 326                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 327                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 328                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 329                                 }
 330                         break; }
 331
 332                         case 28: {
 333                                 {
 334                                         struct ndr_push *_ndr_info28;
 335                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 336                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 337                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 338                                 }
 339                         break; }
 340
 341                         case 48: {
 342                                 {
 343                                         struct ndr_push *_ndr_info48;
 344                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 345                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 346                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 347                                 }
 348                         break; }
 349
 350                         default: {
 351                                 {
 352                                         struct ndr_push *_ndr_FallBack;
 353                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 354                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 355                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 356                                 }
 357                         break; }
 358
 359                 }
 360         }
 361         if (ndr_flags & NDR_BUFFERS) {
 362                 int level = ndr_push_get_switch_value(ndr, r);
 363                 switch (level) {
 364                         case 24:
 365                         break;
 366
 367                         case 28:
 368                         break;
 369
 370                         case 48:
 371                         break;
 372
 373                         default:
 374                         break;
 375
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 382 {
 383         int level;
 384         level = ndr_pull_get_switch_value(ndr, r);
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
 387                 switch (level) {
 388                         case 24: {
 389                                 {
 390                                         struct ndr_pull *_ndr_info24;
 391                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 392                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 393                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 394                                 }
 395                         break; }
 396
 397                         case 28: {
 398                                 {
 399                                         struct ndr_pull *_ndr_info28;
 400                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 401                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 402                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 403                                 }
 404                         break; }
 405
 406                         case 48: {
 407                                 {
 408                                         struct ndr_pull *_ndr_info48;
 409                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 410                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 411                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 412                                 }
 413                         break; }
 414
 415                         default: {
 416                                 {
 417                                         struct ndr_pull *_ndr_FallBack;
 418                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 419                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 420                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 421                                 }
 422                         break; }
 423
 424                 }
 425         }
 426         if (ndr_flags & NDR_BUFFERS) {
 427                 switch (level) {
 428                         case 24:
 429                         break;
 430
 431                         case 28:
 432                         break;
 433
 434                         case 48:
 435                         break;
 436
 437                         default:
 438                         break;
 439
 440                 }
 441         }
 442         return NDR_ERR_SUCCESS;
 443 }
 444
 445 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 446 {
 447         int level;
 448         level = ndr_print_get_switch_value(ndr, r);
 449         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 450         switch (level) {
 451                 case 24:
 452                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 453                 break;
 454
 455                 case 28:
 456                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 457                 break;
 458
 459                 case 48:
 460                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 461                 break;
 462
 463                 default:
 464                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 465                 break;
 466
 467         }
 468 }
 469
 470 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 471 {
 472         if (ndr_flags & NDR_SCALARS) {
 473                 NDR_CHECK(ndr_push_align(ndr, 4));
 474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 475                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 476                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 477                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 478         }
 479         if (ndr_flags & NDR_BUFFERS) {
 480         }
 481         return NDR_ERR_SUCCESS;
 482 }
 483
 484 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_pull_align(ndr, 4));
 488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 489                 if (r->length < 1 || r->length > 10000) {
 490                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 491                 }
 492                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 493                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 494                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 495         }
 496         if (ndr_flags & NDR_BUFFERS) {
 497         }
 498         return NDR_ERR_SUCCESS;
 499 }
 500
 501 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 502 {
 503         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 504         ndr->depth++;
 505         ndr_print_uint32(ndr, "length", r->length);
 506         ndr_print_set_switch_value(ndr, &r->info, r->length);
 507         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 508         ndr->depth--;
 509 }
 510
 511 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 512 {
 513         if (ndr_flags & NDR_SCALARS) {
 514                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 515                 NDR_CHECK(ndr_push_align(ndr, 4));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 518                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 519                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 521                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 522                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 523         }
 524         if (ndr_flags & NDR_BUFFERS) {
 525                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 526         }
 527         return NDR_ERR_SUCCESS;
 528 }
 529
 530 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 531 {
 532         if (ndr_flags & NDR_SCALARS) {
 533                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 534                 NDR_CHECK(ndr_pull_align(ndr, 4));
 535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 537                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 538                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 540                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 541                 if (r->dn) {
 542                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 543                 }
 544                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 545         }
 546         if (ndr_flags & NDR_BUFFERS) {
 547                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 548         }
 549         return NDR_ERR_SUCCESS;
 550 }
 551
 552 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 553 {
 554         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 555         ndr->depth++;
 556         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4:r->__ndr_size);
 557         ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
 558         ndr_print_GUID(ndr, "guid", &r->guid);
 559         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 560         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 561         ndr_print_string(ndr, "dn", r->dn);
 562         ndr->depth--;
 563 }
 564
 565 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 566 {
 567         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 568 }
 569
 570 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 571 {
 572         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 573         return NDR_ERR_SUCCESS;
 574 }
 575
 576 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 577 {
 578         uint32_t v;
 579         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 580         *r = v;
 581         return NDR_ERR_SUCCESS;
 582 }
 583
 584 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 585 {
 586         ndr_print_uint32(ndr, name, r);
 587         ndr->depth++;
 588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 589         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 590         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 591         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 592         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 593         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 594         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 595         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 596         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 597         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 598         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 599         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 600         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 601         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 602         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 603         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 604         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 607         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 608         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 609         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 610         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 611         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 612         ndr->depth--;
 613 }
 614
 615 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 616 {
 617         if (ndr_flags & NDR_SCALARS) {
 618                 NDR_CHECK(ndr_push_align(ndr, 5));
 619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 620                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 621                 {
 622                         uint32_t _flags_save_string = ndr->flags;
 623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 624                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 625                         ndr->flags = _flags_save_string;
 626                 }
 627                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
 628                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 629         }
 630         if (ndr_flags & NDR_BUFFERS) {
 631                 if (r->naming_context) {
 632                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 633                 }
 634                 {
 635                         uint32_t _flags_save_string = ndr->flags;
 636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 637                         if (r->other_info) {
 638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 639                         }
 640                         ndr->flags = _flags_save_string;
 641                 }
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 647 {
 648         uint32_t _ptr_naming_context;
 649         TALLOC_CTX *_mem_save_naming_context_0;
 650         uint32_t _ptr_other_info;
 651         TALLOC_CTX *_mem_save_other_info_0;
 652         if (ndr_flags & NDR_SCALARS) {
 653                 NDR_CHECK(ndr_pull_align(ndr, 5));
 654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 655                 if (_ptr_naming_context) {
 656                         NDR_PULL_ALLOC(ndr, r->naming_context);
 657                 } else {
 658                         r->naming_context = NULL;
 659                 }
 660                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 661                 {
 662                         uint32_t _flags_save_string = ndr->flags;
 663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 665                         if (_ptr_other_info) {
 666                                 NDR_PULL_ALLOC(ndr, r->other_info);
 667                         } else {
 668                                 r->other_info = NULL;
 669                         }
 670                         ndr->flags = _flags_save_string;
 671                 }
 672                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
 673                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 674         }
 675         if (ndr_flags & NDR_BUFFERS) {
 676                 if (r->naming_context) {
 677                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 678                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 679                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 680                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 681                 }
 682                 {
 683                         uint32_t _flags_save_string = ndr->flags;
 684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 685                         if (r->other_info) {
 686                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 687                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 688                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 689                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 690                         }
 691                         ndr->flags = _flags_save_string;
 692                 }
 693         }
 694         return NDR_ERR_SUCCESS;
 695 }
 696
 697 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 698 {
 699         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 700         ndr->depth++;
 701         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 702         ndr->depth++;
 703         if (r->naming_context) {
 704                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 705         }
 706         ndr->depth--;
 707         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 708         ndr_print_ptr(ndr, "other_info", r->other_info);
 709         ndr->depth++;
 710         if (r->other_info) {
 711                 ndr_print_string(ndr, "other_info", r->other_info);
 712         }
 713         ndr->depth--;
 714         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
 715         ndr->depth--;
 716 }
 717
 718 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 719 {
 720         if (ndr_flags & NDR_SCALARS) {
 721                 int level = ndr_push_get_switch_value(ndr, r);
 722                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 723                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 724                 switch (level) {
 725                         case 1: {
 726                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 727                         break; }
 728
 729                         default:
 730                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 731                 }
 732         }
 733         if (ndr_flags & NDR_BUFFERS) {
 734                 int level = ndr_push_get_switch_value(ndr, r);
 735                 switch (level) {
 736                         case 1:
 737                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 738                         break;
 739
 740                         default:
 741                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 742                 }
 743         }
 744         return NDR_ERR_SUCCESS;
 745 }
 746
 747 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 748 {
 749         int level;
 750         int32_t _level;
 751         level = ndr_pull_get_switch_value(ndr, r);
 752         if (ndr_flags & NDR_SCALARS) {
 753                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 754                 if (_level != level) {
 755                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 756                 }
 757                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 758                 switch (level) {
 759                         case 1: {
 760                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 761                         break; }
 762
 763                         default:
 764                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 765                 }
 766         }
 767         if (ndr_flags & NDR_BUFFERS) {
 768                 switch (level) {
 769                         case 1:
 770                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 771                         break;
 772
 773                         default:
 774                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 775                 }
 776         }
 777         return NDR_ERR_SUCCESS;
 778 }
 779
 780 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 781 {
 782         int level;
 783         level = ndr_print_get_switch_value(ndr, r);
 784         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 785         switch (level) {
 786                 case 1:
 787                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 788                 break;
 789
 790                 default:
 791                         ndr_print_bad_level(ndr, name, level);
 792         }
 793 }
 794
 795 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 796 {
 797         if (ndr_flags & NDR_SCALARS) {
 798                 NDR_CHECK(ndr_push_align(ndr, 8));
 799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 800                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 801                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 802                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 803         }
 804         if (ndr_flags & NDR_BUFFERS) {
 805         }
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 810 {
 811         if (ndr_flags & NDR_SCALARS) {
 812                 NDR_CHECK(ndr_pull_align(ndr, 8));
 813                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 814                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 815                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 816                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 817         }
 818         if (ndr_flags & NDR_BUFFERS) {
 819         }
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 824 {
 825         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 826         ndr->depth++;
 827         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 828         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 829         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 830         ndr->depth--;
 831 }
 832
 833 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 834 {
 835         if (ndr_flags & NDR_SCALARS) {
 836                 NDR_CHECK(ndr_push_align(ndr, 8));
 837                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 838                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 839                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 840         }
 841         if (ndr_flags & NDR_BUFFERS) {
 842         }
 843         return NDR_ERR_SUCCESS;
 844 }
 845
 846 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 847 {
 848         if (ndr_flags & NDR_SCALARS) {
 849                 NDR_CHECK(ndr_pull_align(ndr, 8));
 850                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 851                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 852                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 853         }
 854         if (ndr_flags & NDR_BUFFERS) {
 855         }
 856         return NDR_ERR_SUCCESS;
 857 }
 858
 859 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 860 {
 861         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 862         ndr->depth++;
 863         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 864         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 865         ndr->depth--;
 866 }
 867
 868 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 869 {
 870         uint32_t cntr_cursors_0;
 871         if (ndr_flags & NDR_SCALARS) {
 872                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 873                 NDR_CHECK(ndr_push_align(ndr, 8));
 874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 878                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 879                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 880                 }
 881                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 882         }
 883         if (ndr_flags & NDR_BUFFERS) {
 884         }
 885         return NDR_ERR_SUCCESS;
 886 }
 887
 888 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 889 {
 890         uint32_t cntr_cursors_0;
 891         TALLOC_CTX *_mem_save_cursors_0;
 892         if (ndr_flags & NDR_SCALARS) {
 893                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 894                 NDR_CHECK(ndr_pull_align(ndr, 8));
 895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 898                 if (r->count > 0x100000) {
 899                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 900                 }
 901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 902                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 903                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 905                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 906                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 907                 }
 908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 909                 if (r->cursors) {
 910                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 911                 }
 912                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 913         }
 914         if (ndr_flags & NDR_BUFFERS) {
 915         }
 916         return NDR_ERR_SUCCESS;
 917 }
 918
 919 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 920 {
 921         uint32_t cntr_cursors_0;
 922         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 923         ndr->depth++;
 924         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 925         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 926         ndr_print_uint32(ndr, "count", r->count);
 927         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 928         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 929         ndr->depth++;
 930         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 931                 char *idx_0=NULL;
 932                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 933                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 934                         free(idx_0);
 935                 }
 936         }
 937         ndr->depth--;
 938         ndr->depth--;
 939 }
 940
 941 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 942 {
 943         {
 944                 uint32_t _flags_save_ENUM = ndr->flags;
 945                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 946                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 947                 ndr->flags = _flags_save_ENUM;
 948         }
 949         return NDR_ERR_SUCCESS;
 950 }
 951
 952 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 953 {
 954         uint32_t v;
 955         {
 956                 uint32_t _flags_save_ENUM = ndr->flags;
 957                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 958                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 959                 *r = v;
 960                 ndr->flags = _flags_save_ENUM;
 961         }
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 966 {
 967         const char *val = NULL;
 968
 969         {
 970                 uint32_t _flags_save_ENUM = ndr->flags;
 971                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 972                 switch (r) {
 973                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 974                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 975                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 976                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 977                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 978                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 979                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 980                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 981                 }
 982                 ndr_print_enum(ndr, name, "ENUM", val, r);
 983                 ndr->flags = _flags_save_ENUM;
 984         }
 985 }
 986
 987 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 988 {
 989         {
 990                 uint32_t _flags_save_ENUM = ndr->flags;
 991                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 992                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 993                 ndr->flags = _flags_save_ENUM;
 994         }
 995         return NDR_ERR_SUCCESS;
 996 }
 997
 998 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 999 {
1000         uint32_t v;
1001         {
1002                 uint32_t _flags_save_ENUM = ndr->flags;
1003                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1004                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1005                 *r = v;
1006                 ndr->flags = _flags_save_ENUM;
1007         }
1008         return NDR_ERR_SUCCESS;
1009 }
1010
1011 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
1012 {
1013         const char *val = NULL;
1014
1015         {
1016                 uint32_t _flags_save_ENUM = ndr->flags;
1017                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1018                 switch (r) {
1019                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
1020                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1021                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1022                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1023                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1024                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1025                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1026                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1027                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1028                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1029                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1030                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1031                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1032                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1033                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1034                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1035                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1036                 }
1037                 ndr_print_enum(ndr, name, "ENUM", val, r);
1038                 ndr->flags = _flags_save_ENUM;
1039         }
1040 }
1041
1042 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1043 {
1044         if (ndr_flags & NDR_SCALARS) {
1045                 NDR_CHECK(ndr_push_align(ndr, 8));
1046                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1047                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1048                 if (r->naming_context == NULL) {
1049                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1050                 }
1051                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1052                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1054                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1057                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1058                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1059                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1060         }
1061         if (ndr_flags & NDR_BUFFERS) {
1062                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1063                 if (r->uptodateness_vector) {
1064                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1065                 }
1066         }
1067         return NDR_ERR_SUCCESS;
1068 }
1069
1070 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1071 {
1072         uint32_t _ptr_naming_context;
1073         TALLOC_CTX *_mem_save_naming_context_0;
1074         uint32_t _ptr_uptodateness_vector;
1075         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1076         if (ndr_flags & NDR_SCALARS) {
1077                 NDR_CHECK(ndr_pull_align(ndr, 8));
1078                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1079                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1080                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1081                 if (_ptr_naming_context) {
1082                         NDR_PULL_ALLOC(ndr, r->naming_context);
1083                 } else {
1084                         r->naming_context = NULL;
1085                 }
1086                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1088                 if (_ptr_uptodateness_vector) {
1089                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1090                 } else {
1091                         r->uptodateness_vector = NULL;
1092                 }
1093                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1096                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1097                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1098                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1099         }
1100         if (ndr_flags & NDR_BUFFERS) {
1101                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1102                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1103                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1105                 if (r->uptodateness_vector) {
1106                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1107                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1108                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1110                 }
1111         }
1112         return NDR_ERR_SUCCESS;
1113 }
1114
1115 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1116 {
1117         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1118         ndr->depth++;
1119         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1120         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1121         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1122         ndr->depth++;
1123         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1124         ndr->depth--;
1125         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1126         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1127         ndr->depth++;
1128         if (r->uptodateness_vector) {
1129                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1130         }
1131         ndr->depth--;
1132         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1133         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1134         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1135         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1136         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1137         ndr->depth--;
1138 }
1139
1140 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1141 {
1142         if (ndr_flags & NDR_SCALARS) {
1143                 NDR_CHECK(ndr_push_align(ndr, 5));
1144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1145                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1146                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1147         }
1148         if (ndr_flags & NDR_BUFFERS) {
1149                 if (r->binary_oid) {
1150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1151                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1152                 }
1153         }
1154         return NDR_ERR_SUCCESS;
1155 }
1156
1157 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1158 {
1159         uint32_t _ptr_binary_oid;
1160         TALLOC_CTX *_mem_save_binary_oid_0;
1161         if (ndr_flags & NDR_SCALARS) {
1162                 NDR_CHECK(ndr_pull_align(ndr, 5));
1163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1164                 if (r->length > 10000) {
1165                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1166                 }
1167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1168                 if (_ptr_binary_oid) {
1169                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1170                 } else {
1171                         r->binary_oid = NULL;
1172                 }
1173                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1174         }
1175         if (ndr_flags & NDR_BUFFERS) {
1176                 if (r->binary_oid) {
1177                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1178                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1180                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1181                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1183                 }
1184                 if (r->binary_oid) {
1185                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1192 {
1193         if (ndr_flags & NDR_SCALARS) {
1194                 NDR_CHECK(ndr_push_align(ndr, 5));
1195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1196                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1197                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1198         }
1199         if (ndr_flags & NDR_BUFFERS) {
1200                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1201         }
1202         return NDR_ERR_SUCCESS;
1203 }
1204
1205 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1206 {
1207         if (ndr_flags & NDR_SCALARS) {
1208                 NDR_CHECK(ndr_pull_align(ndr, 5));
1209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1210                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1211                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1212         }
1213         if (ndr_flags & NDR_BUFFERS) {
1214                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1215         }
1216         return NDR_ERR_SUCCESS;
1217 }
1218
1219 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1220 {
1221         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1222         ndr->depth++;
1223         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1224         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1225         ndr->depth--;
1226 }
1227
1228 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1229 {
1230         uint32_t cntr_mappings_1;
1231         if (ndr_flags & NDR_SCALARS) {
1232                 NDR_CHECK(ndr_push_align(ndr, 5));
1233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1235                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1236         }
1237         if (ndr_flags & NDR_BUFFERS) {
1238                 if (r->mappings) {
1239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1240                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1241                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1242                         }
1243                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1244                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1245                         }
1246                 }
1247         }
1248         return NDR_ERR_SUCCESS;
1249 }
1250
1251 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1252 {
1253         uint32_t _ptr_mappings;
1254         uint32_t cntr_mappings_1;
1255         TALLOC_CTX *_mem_save_mappings_0;
1256         TALLOC_CTX *_mem_save_mappings_1;
1257         if (ndr_flags & NDR_SCALARS) {
1258                 NDR_CHECK(ndr_pull_align(ndr, 5));
1259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1260                 if (r->num_mappings > 0x100000) {
1261                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1262                 }
1263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1264                 if (_ptr_mappings) {
1265                         NDR_PULL_ALLOC(ndr, r->mappings);
1266                 } else {
1267                         r->mappings = NULL;
1268                 }
1269                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1270         }
1271         if (ndr_flags & NDR_BUFFERS) {
1272                 if (r->mappings) {
1273                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1274                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1276                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1277                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1278                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1279                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1280                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1281                         }
1282                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1283                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1284                         }
1285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1287                 }
1288                 if (r->mappings) {
1289                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1290                 }
1291         }
1292         return NDR_ERR_SUCCESS;
1293 }
1294
1295 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1296 {
1297         uint32_t cntr_mappings_1;
1298         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1299         ndr->depth++;
1300         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1301         ndr_print_ptr(ndr, "mappings", r->mappings);
1302         ndr->depth++;
1303         if (r->mappings) {
1304                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1305                 ndr->depth++;
1306                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1307                         char *idx_1=NULL;
1308                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1309                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1310                                 free(idx_1);
1311                         }
1312                 }
1313                 ndr->depth--;
1314         }
1315         ndr->depth--;
1316         ndr->depth--;
1317 }
1318
1319 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1320 {
1321         {
1322                 uint32_t _flags_save_ENUM = ndr->flags;
1323                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1324                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1325                 ndr->flags = _flags_save_ENUM;
1326         }
1327         return NDR_ERR_SUCCESS;
1328 }
1329
1330 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1331 {
1332         uint32_t v;
1333         {
1334                 uint32_t _flags_save_ENUM = ndr->flags;
1335                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1336                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1337                 *r = v;
1338                 ndr->flags = _flags_save_ENUM;
1339         }
1340         return NDR_ERR_SUCCESS;
1341 }
1342
1343 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1344 {
1345         const char *val = NULL;
1346
1347         {
1348                 uint32_t _flags_save_ENUM = ndr->flags;
1349                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1350                 switch (r) {
1351                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1352                         case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
1353                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1354                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1355                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1356                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1357                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1358                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1359                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1360                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1361                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1362                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1363                         case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1364                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1365                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1366                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1367                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1368                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1369                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1370                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1371                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1372                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1373                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1374                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1375                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1376                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1377                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1378                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1379                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1380                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1381                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1382                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1383                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1384                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1385                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1386                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1387                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1388                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1389                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1390                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1391                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1392                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1393                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1394                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1395                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1396                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1397                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1398                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1399                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1400                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1401                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1402                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1403                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1404                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1405                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1406                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1407                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1408                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1409                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1410                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1411                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1412                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1413                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1414                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1415                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1416                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1417                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1418                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1419                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1420                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1421                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1422                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1423                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1424                         case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
1425                 }
1426                 ndr_print_enum(ndr, name, "ENUM", val, r);
1427                 ndr->flags = _flags_save_ENUM;
1428         }
1429 }
1430
1431 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1432 {
1433         uint32_t cntr_attids_0;
1434         if (ndr_flags & NDR_SCALARS) {
1435                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1436                 NDR_CHECK(ndr_push_align(ndr, 4));
1437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1440                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1441                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1442                 }
1443                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1444         }
1445         if (ndr_flags & NDR_BUFFERS) {
1446         }
1447         return NDR_ERR_SUCCESS;
1448 }
1449
1450 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1451 {
1452         uint32_t cntr_attids_0;
1453         TALLOC_CTX *_mem_save_attids_0;
1454         if (ndr_flags & NDR_SCALARS) {
1455                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1456                 NDR_CHECK(ndr_pull_align(ndr, 4));
1457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1460                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1461                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1462                 }
1463                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1464                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1465                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1466                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1467                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1468                 }
1469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1470                 if (r->attids) {
1471                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1472                 }
1473                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1474         }
1475         if (ndr_flags & NDR_BUFFERS) {
1476         }
1477         return NDR_ERR_SUCCESS;
1478 }
1479
1480 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1481 {
1482         uint32_t cntr_attids_0;
1483         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1484         ndr->depth++;
1485         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1486         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1487         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1488         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1489         ndr->depth++;
1490         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1491                 char *idx_0=NULL;
1492                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1493                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1494                         free(idx_0);
1495                 }
1496         }
1497         ndr->depth--;
1498         ndr->depth--;
1499 }
1500
1501 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1502 {
1503         if (ndr_flags & NDR_SCALARS) {
1504                 NDR_CHECK(ndr_push_align(ndr, 8));
1505                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1506                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1507                 if (r->naming_context == NULL) {
1508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1509                 }
1510                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1511                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1513                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1516                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1517                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1520                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1521                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1522         }
1523         if (ndr_flags & NDR_BUFFERS) {
1524                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1525                 if (r->uptodateness_vector) {
1526                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1527                 }
1528                 if (r->partial_attribute_set) {
1529                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1530                 }
1531                 if (r->partial_attribute_set_ex) {
1532                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1533                 }
1534                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1535         }
1536         return NDR_ERR_SUCCESS;
1537 }
1538
1539 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1540 {
1541         uint32_t _ptr_naming_context;
1542         TALLOC_CTX *_mem_save_naming_context_0;
1543         uint32_t _ptr_uptodateness_vector;
1544         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1545         uint32_t _ptr_partial_attribute_set;
1546         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1547         uint32_t _ptr_partial_attribute_set_ex;
1548         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1549         if (ndr_flags & NDR_SCALARS) {
1550                 NDR_CHECK(ndr_pull_align(ndr, 8));
1551                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1552                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1553                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1554                 if (_ptr_naming_context) {
1555                         NDR_PULL_ALLOC(ndr, r->naming_context);
1556                 } else {
1557                         r->naming_context = NULL;
1558                 }
1559                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1561                 if (_ptr_uptodateness_vector) {
1562                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1563                 } else {
1564                         r->uptodateness_vector = NULL;
1565                 }
1566                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1569                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1570                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1572                 if (_ptr_partial_attribute_set) {
1573                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1574                 } else {
1575                         r->partial_attribute_set = NULL;
1576                 }
1577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1578                 if (_ptr_partial_attribute_set_ex) {
1579                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1580                 } else {
1581                         r->partial_attribute_set_ex = NULL;
1582                 }
1583                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1584                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1585         }
1586         if (ndr_flags & NDR_BUFFERS) {
1587                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1588                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1589                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1591                 if (r->uptodateness_vector) {
1592                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1593                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1594                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1596                 }
1597                 if (r->partial_attribute_set) {
1598                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1599                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1600                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1602                 }
1603                 if (r->partial_attribute_set_ex) {
1604                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1605                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1606                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1608                 }
1609                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1610         }
1611         return NDR_ERR_SUCCESS;
1612 }
1613
1614 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1615 {
1616         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1617         ndr->depth++;
1618         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1619         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1620         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1621         ndr->depth++;
1622         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1623         ndr->depth--;
1624         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1625         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1626         ndr->depth++;
1627         if (r->uptodateness_vector) {
1628                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1629         }
1630         ndr->depth--;
1631         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1632         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1633         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1634         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1635         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1636         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1637         ndr->depth++;
1638         if (r->partial_attribute_set) {
1639                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1640         }
1641         ndr->depth--;
1642         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1643         ndr->depth++;
1644         if (r->partial_attribute_set_ex) {
1645                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1646         }
1647         ndr->depth--;
1648         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1649         ndr->depth--;
1650 }
1651
1652 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1653 {
1654         if (ndr_flags & NDR_SCALARS) {
1655                 NDR_CHECK(ndr_push_align(ndr, 8));
1656                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1657                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1658                 if (r->naming_context == NULL) {
1659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1660                 }
1661                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1662                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1664                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1667                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1668                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1671                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1673                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1674         }
1675         if (ndr_flags & NDR_BUFFERS) {
1676                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1677                 if (r->uptodateness_vector) {
1678                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1679                 }
1680                 if (r->partial_attribute_set) {
1681                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1682                 }
1683                 if (r->partial_attribute_set_ex) {
1684                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1685                 }
1686                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1687         }
1688         return NDR_ERR_SUCCESS;
1689 }
1690
1691 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1692 {
1693         uint32_t _ptr_naming_context;
1694         TALLOC_CTX *_mem_save_naming_context_0;
1695         uint32_t _ptr_uptodateness_vector;
1696         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1697         uint32_t _ptr_partial_attribute_set;
1698         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1699         uint32_t _ptr_partial_attribute_set_ex;
1700         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1701         if (ndr_flags & NDR_SCALARS) {
1702                 NDR_CHECK(ndr_pull_align(ndr, 8));
1703                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1704                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1705                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1706                 if (_ptr_naming_context) {
1707                         NDR_PULL_ALLOC(ndr, r->naming_context);
1708                 } else {
1709                         r->naming_context = NULL;
1710                 }
1711                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1713                 if (_ptr_uptodateness_vector) {
1714                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1715                 } else {
1716                         r->uptodateness_vector = NULL;
1717                 }
1718                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1721                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1722                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1724                 if (_ptr_partial_attribute_set) {
1725                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1726                 } else {
1727                         r->partial_attribute_set = NULL;
1728                 }
1729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1730                 if (_ptr_partial_attribute_set_ex) {
1731                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1732                 } else {
1733                         r->partial_attribute_set_ex = NULL;
1734                 }
1735                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1737                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1738         }
1739         if (ndr_flags & NDR_BUFFERS) {
1740                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1741                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1742                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1744                 if (r->uptodateness_vector) {
1745                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1746                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1747                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1749                 }
1750                 if (r->partial_attribute_set) {
1751                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1752                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1753                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1755                 }
1756                 if (r->partial_attribute_set_ex) {
1757                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1758                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1759                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1761                 }
1762                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1763         }
1764         return NDR_ERR_SUCCESS;
1765 }
1766
1767 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1768 {
1769         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1770         ndr->depth++;
1771         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1772         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1773         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1774         ndr->depth++;
1775         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1776         ndr->depth--;
1777         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1778         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1779         ndr->depth++;
1780         if (r->uptodateness_vector) {
1781                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1782         }
1783         ndr->depth--;
1784         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1785         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1786         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1787         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1788         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1789         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1790         ndr->depth++;
1791         if (r->partial_attribute_set) {
1792                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1793         }
1794         ndr->depth--;
1795         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1796         ndr->depth++;
1797         if (r->partial_attribute_set_ex) {
1798                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1799         }
1800         ndr->depth--;
1801         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1802         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1803         ndr->depth--;
1804 }
1805
1806 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1807 {
1808         if (ndr_flags & NDR_SCALARS) {
1809                 int level = ndr_push_get_switch_value(ndr, r);
1810                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1811                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1812                 switch (level) {
1813                         case 5: {
1814                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1815                         break; }
1816
1817                         case 8: {
1818                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1819                         break; }
1820
1821                         case 10: {
1822                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1823                         break; }
1824
1825                         default:
1826                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1827                 }
1828         }
1829         if (ndr_flags & NDR_BUFFERS) {
1830                 int level = ndr_push_get_switch_value(ndr, r);
1831                 switch (level) {
1832                         case 5:
1833                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1834                         break;
1835
1836                         case 8:
1837                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1838                         break;
1839
1840                         case 10:
1841                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1842                         break;
1843
1844                         default:
1845                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1846                 }
1847         }
1848         return NDR_ERR_SUCCESS;
1849 }
1850
1851 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1852 {
1853         int level;
1854         int32_t _level;
1855         level = ndr_pull_get_switch_value(ndr, r);
1856         if (ndr_flags & NDR_SCALARS) {
1857                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1858                 if (_level != level) {
1859                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1860                 }
1861                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1862                 switch (level) {
1863                         case 5: {
1864                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1865                         break; }
1866
1867                         case 8: {
1868                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1869                         break; }
1870
1871                         case 10: {
1872                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1873                         break; }
1874
1875                         default:
1876                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1877                 }
1878         }
1879         if (ndr_flags & NDR_BUFFERS) {
1880                 switch (level) {
1881                         case 5:
1882                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1883                         break;
1884
1885                         case 8:
1886                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1887                         break;
1888
1889                         case 10:
1890                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1891                         break;
1892
1893                         default:
1894                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1895                 }
1896         }
1897         return NDR_ERR_SUCCESS;
1898 }
1899
1900 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1901 {
1902         int level;
1903         level = ndr_print_get_switch_value(ndr, r);
1904         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1905         switch (level) {
1906                 case 5:
1907                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1908                 break;
1909
1910                 case 8:
1911                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1912                 break;
1913
1914                 case 10:
1915                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1916                 break;
1917
1918                 default:
1919                         ndr_print_bad_level(ndr, name, level);
1920         }
1921 }
1922
1923 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1924 {
1925         if (ndr_flags & NDR_SCALARS) {
1926                 NDR_CHECK(ndr_push_align(ndr, 8));
1927                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1928                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1929                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1930                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1931         }
1932         if (ndr_flags & NDR_BUFFERS) {
1933         }
1934         return NDR_ERR_SUCCESS;
1935 }
1936
1937 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1938 {
1939         if (ndr_flags & NDR_SCALARS) {
1940                 NDR_CHECK(ndr_pull_align(ndr, 8));
1941                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1942                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1943                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1944                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1945         }
1946         if (ndr_flags & NDR_BUFFERS) {
1947         }
1948         return NDR_ERR_SUCCESS;
1949 }
1950
1951 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1952 {
1953         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1954         ndr->depth++;
1955         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1956         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1957         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1958         ndr->depth--;
1959 }
1960
1961 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1962 {
1963         uint32_t cntr_cursors_0;
1964         if (ndr_flags & NDR_SCALARS) {
1965                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1966                 NDR_CHECK(ndr_push_align(ndr, 8));
1967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1971                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1972                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1973                 }
1974                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1975         }
1976         if (ndr_flags & NDR_BUFFERS) {
1977         }
1978         return NDR_ERR_SUCCESS;
1979 }
1980
1981 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1982 {
1983         uint32_t cntr_cursors_0;
1984         TALLOC_CTX *_mem_save_cursors_0;
1985         if (ndr_flags & NDR_SCALARS) {
1986                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1987                 NDR_CHECK(ndr_pull_align(ndr, 8));
1988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1991                 if (r->count > 0x100000) {
1992                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1993                 }
1994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1995                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1996                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1997                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1998                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1999                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2000                 }
2001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2002                 if (r->cursors) {
2003                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2004                 }
2005                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2006         }
2007         if (ndr_flags & NDR_BUFFERS) {
2008         }
2009         return NDR_ERR_SUCCESS;
2010 }
2011
2012 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2013 {
2014         uint32_t cntr_cursors_0;
2015         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2016         ndr->depth++;
2017         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2018         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2019         ndr_print_uint32(ndr, "count", r->count);
2020         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2021         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2022         ndr->depth++;
2023         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2024                 char *idx_0=NULL;
2025                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2026                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2027                         free(idx_0);
2028                 }
2029         }
2030         ndr->depth--;
2031         ndr->depth--;
2032 }
2033
2034 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2035 {
2036         if (ndr_flags & NDR_SCALARS) {
2037                 NDR_CHECK(ndr_push_align(ndr, 5));
2038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2040                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2041         }
2042         if (ndr_flags & NDR_BUFFERS) {
2043                 if (r->blob) {
2044                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2045                 }
2046         }
2047         return NDR_ERR_SUCCESS;
2048 }
2049
2050 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2051 {
2052         uint32_t _ptr_blob;
2053         TALLOC_CTX *_mem_save_blob_0;
2054         if (ndr_flags & NDR_SCALARS) {
2055                 NDR_CHECK(ndr_pull_align(ndr, 5));
2056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2057                 if (r->__ndr_size > 10485760) {
2058                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2059                 }
2060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2061                 if (_ptr_blob) {
2062                         NDR_PULL_ALLOC(ndr, r->blob);
2063                 } else {
2064                         r->blob = NULL;
2065                 }
2066                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2067         }
2068         if (ndr_flags & NDR_BUFFERS) {
2069                 if (r->blob) {
2070                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2071                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2072                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2074                 }
2075         }
2076         return NDR_ERR_SUCCESS;
2077 }
2078
2079 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2080 {
2081         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2082         ndr->depth++;
2083         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2084         ndr_print_ptr(ndr, "blob", r->blob);
2085         ndr->depth++;
2086         if (r->blob) {
2087                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2088         }
2089         ndr->depth--;
2090         ndr->depth--;
2091 }
2092
2093 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2094 {
2095         uint32_t cntr_values_1;
2096         if (ndr_flags & NDR_SCALARS) {
2097                 NDR_CHECK(ndr_push_align(ndr, 5));
2098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2100                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2101         }
2102         if (ndr_flags & NDR_BUFFERS) {
2103                 if (r->values) {
2104                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2105                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2106                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2107                         }
2108                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2109                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2110                         }
2111                 }
2112         }
2113         return NDR_ERR_SUCCESS;
2114 }
2115
2116 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2117 {
2118         uint32_t _ptr_values;
2119         uint32_t cntr_values_1;
2120         TALLOC_CTX *_mem_save_values_0;
2121         TALLOC_CTX *_mem_save_values_1;
2122         if (ndr_flags & NDR_SCALARS) {
2123                 NDR_CHECK(ndr_pull_align(ndr, 5));
2124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2125                 if (r->num_values > 10485760) {
2126                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2127                 }
2128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2129                 if (_ptr_values) {
2130                         NDR_PULL_ALLOC(ndr, r->values);
2131                 } else {
2132                         r->values = NULL;
2133                 }
2134                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2135         }
2136         if (ndr_flags & NDR_BUFFERS) {
2137                 if (r->values) {
2138                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2139                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2141                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2142                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2143                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2144                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2145                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2146                         }
2147                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2148                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2149                         }
2150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2152                 }
2153                 if (r->values) {
2154                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2155                 }
2156         }
2157         return NDR_ERR_SUCCESS;
2158 }
2159
2160 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2161 {
2162         uint32_t cntr_values_1;
2163         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2164         ndr->depth++;
2165         ndr_print_uint32(ndr, "num_values", r->num_values);
2166         ndr_print_ptr(ndr, "values", r->values);
2167         ndr->depth++;
2168         if (r->values) {
2169                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2170                 ndr->depth++;
2171                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2172                         char *idx_1=NULL;
2173                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2174                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2175                                 free(idx_1);
2176                         }
2177                 }
2178                 ndr->depth--;
2179         }
2180         ndr->depth--;
2181         ndr->depth--;
2182 }
2183
2184 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2185 {
2186         if (ndr_flags & NDR_SCALARS) {
2187                 NDR_CHECK(ndr_push_align(ndr, 4));
2188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2190                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2191                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2193                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2194                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2195         }
2196         if (ndr_flags & NDR_BUFFERS) {
2197                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2198         }
2199         return NDR_ERR_SUCCESS;
2200 }
2201
2202 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2203 {
2204         if (ndr_flags & NDR_SCALARS) {
2205                 NDR_CHECK(ndr_pull_align(ndr, 4));
2206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2208                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2209                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2211                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2212                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2213         }
2214         if (ndr_flags & NDR_BUFFERS) {
2215                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2216         }
2217         return NDR_ERR_SUCCESS;
2218 }
2219
2220 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2221 {
2222         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2223         ndr->depth++;
2224         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
2225         ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
2226         ndr_print_GUID(ndr, "guid", &r->guid);
2227         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2228         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2229         ndr_print_string(ndr, "dn", r->dn);
2230         ndr->depth--;
2231 }
2232
2233 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2234 {
2235         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2236 }
2237
2238 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2239 {
2240         if (ndr_flags & NDR_SCALARS) {
2241                 NDR_CHECK(ndr_push_align(ndr, 4));
2242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2244                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2245                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2247                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2249                 {
2250                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2252                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2253                         ndr->flags = _flags_save_DATA_BLOB;
2254                 }
2255                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2256         }
2257         if (ndr_flags & NDR_BUFFERS) {
2258                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2259         }
2260         return NDR_ERR_SUCCESS;
2261 }
2262
2263 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2264 {
2265         if (ndr_flags & NDR_SCALARS) {
2266                 NDR_CHECK(ndr_pull_align(ndr, 4));
2267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2269                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2270                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2272                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2274                 {
2275                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2277                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2278                         ndr->flags = _flags_save_DATA_BLOB;
2279                 }
2280                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2281         }
2282         if (ndr_flags & NDR_BUFFERS) {
2283                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2284         }
2285         return NDR_ERR_SUCCESS;
2286 }
2287
2288 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2289 {
2290         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2291         ndr->depth++;
2292         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
2293         ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
2294         ndr_print_GUID(ndr, "guid", &r->guid);
2295         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2296         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2297         ndr_print_string(ndr, "dn", r->dn);
2298         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2299         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2300         ndr->depth--;
2301 }
2302
2303 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2304 {
2305         if (ndr_flags & NDR_SCALARS) {
2306                 NDR_CHECK(ndr_push_align(ndr, 5));
2307                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2308                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2309                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2310         }
2311         if (ndr_flags & NDR_BUFFERS) {
2312                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2313         }
2314         return NDR_ERR_SUCCESS;
2315 }
2316
2317 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2318 {
2319         if (ndr_flags & NDR_SCALARS) {
2320                 NDR_CHECK(ndr_pull_align(ndr, 5));
2321                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2322                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2323                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2324         }
2325         if (ndr_flags & NDR_BUFFERS) {
2326                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2327         }
2328         return NDR_ERR_SUCCESS;
2329 }
2330
2331 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2332 {
2333         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2334         ndr->depth++;
2335         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2336         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2337         ndr->depth--;
2338 }
2339
2340 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2341 {
2342         uint32_t cntr_attributes_1;
2343         if (ndr_flags & NDR_SCALARS) {
2344                 NDR_CHECK(ndr_push_align(ndr, 5));
2345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2346                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2347                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2348         }
2349         if (ndr_flags & NDR_BUFFERS) {
2350                 if (r->attributes) {
2351                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2352                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2353                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2354                         }
2355                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2356                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2357                         }
2358                 }
2359         }
2360         return NDR_ERR_SUCCESS;
2361 }
2362
2363 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2364 {
2365         uint32_t _ptr_attributes;
2366         uint32_t cntr_attributes_1;
2367         TALLOC_CTX *_mem_save_attributes_0;
2368         TALLOC_CTX *_mem_save_attributes_1;
2369         if (ndr_flags & NDR_SCALARS) {
2370                 NDR_CHECK(ndr_pull_align(ndr, 5));
2371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2372                 if (r->num_attributes > 1048576) {
2373                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2374                 }
2375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2376                 if (_ptr_attributes) {
2377                         NDR_PULL_ALLOC(ndr, r->attributes);
2378                 } else {
2379                         r->attributes = NULL;
2380                 }
2381                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2382         }
2383         if (ndr_flags & NDR_BUFFERS) {
2384                 if (r->attributes) {
2385                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2386                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2387                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2388                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2389                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2390                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2391                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2392                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2393                         }
2394                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2395                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2396                         }
2397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2399                 }
2400                 if (r->attributes) {
2401                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2402                 }
2403         }
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2408 {
2409         uint32_t cntr_attributes_1;
2410         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2411         ndr->depth++;
2412         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2413         ndr_print_ptr(ndr, "attributes", r->attributes);
2414         ndr->depth++;
2415         if (r->attributes) {
2416                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2417                 ndr->depth++;
2418                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2419                         char *idx_1=NULL;
2420                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2421                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2422                                 free(idx_1);
2423                         }
2424                 }
2425                 ndr->depth--;
2426         }
2427         ndr->depth--;
2428         ndr->depth--;
2429 }
2430
2431 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2432 {
2433         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2434         return NDR_ERR_SUCCESS;
2435 }
2436
2437 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2438 {
2439         uint32_t v;
2440         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2441         *r = v;
2442         return NDR_ERR_SUCCESS;
2443 }
2444
2445 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2446 {
2447         ndr_print_uint32(ndr, name, r);
2448         ndr->depth++;
2449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2452         ndr->depth--;
2453 }
2454
2455 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2456 {
2457         if (ndr_flags & NDR_SCALARS) {
2458                 NDR_CHECK(ndr_push_align(ndr, 5));
2459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2460                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2461                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2462                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2463         }
2464         if (ndr_flags & NDR_BUFFERS) {
2465                 if (r->identifier) {
2466                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2467                 }
2468                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2469         }
2470         return NDR_ERR_SUCCESS;
2471 }
2472
2473 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2474 {
2475         uint32_t _ptr_identifier;
2476         TALLOC_CTX *_mem_save_identifier_0;
2477         if (ndr_flags & NDR_SCALARS) {
2478                 NDR_CHECK(ndr_pull_align(ndr, 5));
2479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2480                 if (_ptr_identifier) {
2481                         NDR_PULL_ALLOC(ndr, r->identifier);
2482                 } else {
2483                         r->identifier = NULL;
2484                 }
2485                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2486                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2487                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2488         }
2489         if (ndr_flags & NDR_BUFFERS) {
2490                 if (r->identifier) {
2491                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2492                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2493                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2495                 }
2496                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2497         }
2498         return NDR_ERR_SUCCESS;
2499 }
2500
2501 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2502 {
2503         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2504         ndr->depth++;
2505         ndr_print_ptr(ndr, "identifier", r->identifier);
2506         ndr->depth++;
2507         if (r->identifier) {
2508                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2509         }
2510         ndr->depth--;
2511         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2512         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2513         ndr->depth--;
2514 }
2515
2516 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2517 {
2518         if (ndr_flags & NDR_SCALARS) {
2519                 NDR_CHECK(ndr_push_align(ndr, 8));
2520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2521                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2522                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2523                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2524                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2525         }
2526         if (ndr_flags & NDR_BUFFERS) {
2527         }
2528         return NDR_ERR_SUCCESS;
2529 }
2530
2531 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2532 {
2533         if (ndr_flags & NDR_SCALARS) {
2534                 NDR_CHECK(ndr_pull_align(ndr, 8));
2535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2536                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2537                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2538                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2539                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2540         }
2541         if (ndr_flags & NDR_BUFFERS) {
2542         }
2543         return NDR_ERR_SUCCESS;
2544 }
2545
2546 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2547 {
2548         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2549         ndr->depth++;
2550         ndr_print_uint32(ndr, "version", r->version);
2551         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2552         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2553         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2554         ndr->depth--;
2555 }
2556
2557 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2558 {
2559         uint32_t cntr_meta_data_0;
2560         if (ndr_flags & NDR_SCALARS) {
2561                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2562                 NDR_CHECK(ndr_push_align(ndr, 8));
2563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2564                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2565                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2566                 }
2567                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2568         }
2569         if (ndr_flags & NDR_BUFFERS) {
2570         }
2571         return NDR_ERR_SUCCESS;
2572 }
2573
2574 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2575 {
2576         uint32_t cntr_meta_data_0;
2577         TALLOC_CTX *_mem_save_meta_data_0;
2578         if (ndr_flags & NDR_SCALARS) {
2579                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2580                 NDR_CHECK(ndr_pull_align(ndr, 8));
2581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2582                 if (r->count > 1048576) {
2583                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2584                 }
2585                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2586                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2587                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2588                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2589                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2590                 }
2591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2592                 if (r->meta_data) {
2593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2594                 }
2595                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2596         }
2597         if (ndr_flags & NDR_BUFFERS) {
2598         }
2599         return NDR_ERR_SUCCESS;
2600 }
2601
2602 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2603 {
2604         uint32_t cntr_meta_data_0;
2605         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2606         ndr->depth++;
2607         ndr_print_uint32(ndr, "count", r->count);
2608         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2609         ndr->depth++;
2610         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2611                 char *idx_0=NULL;
2612                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2613                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2614                         free(idx_0);
2615                 }
2616         }
2617         ndr->depth--;
2618         ndr->depth--;
2619 }
2620
2621 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2622 {
2623         if (ndr_flags & NDR_SCALARS) {
2624                 NDR_CHECK(ndr_push_align(ndr, 5));
2625                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2626                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2630                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2631         }
2632         if (ndr_flags & NDR_BUFFERS) {
2633                 if (r->next_object) {
2634                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2635                 }
2636                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2637                 if (r->parent_object_guid) {
2638                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2639                 }
2640                 if (r->meta_data_ctr) {
2641                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2642                 }
2643         }
2644         return NDR_ERR_SUCCESS;
2645 }
2646
2647 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2648 {
2649         uint32_t _ptr_next_object;
2650         TALLOC_CTX *_mem_save_next_object_0;
2651         uint32_t _ptr_parent_object_guid;
2652         TALLOC_CTX *_mem_save_parent_object_guid_0;
2653         uint32_t _ptr_meta_data_ctr;
2654         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2655         if (ndr_flags & NDR_SCALARS) {
2656                 NDR_CHECK(ndr_pull_align(ndr, 5));
2657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2658                 if (_ptr_next_object) {
2659                         NDR_PULL_ALLOC(ndr, r->next_object);
2660                 } else {
2661                         r->next_object = NULL;
2662                 }
2663                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2666                 if (_ptr_parent_object_guid) {
2667                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2668                 } else {
2669                         r->parent_object_guid = NULL;
2670                 }
2671                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2672                 if (_ptr_meta_data_ctr) {
2673                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2674                 } else {
2675                         r->meta_data_ctr = NULL;
2676                 }
2677                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2678         }
2679         if (ndr_flags & NDR_BUFFERS) {
2680                 if (r->next_object) {
2681                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2682                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2683                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2685                 }
2686                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2687                 if (r->parent_object_guid) {
2688                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2689                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2690                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2692                 }
2693                 if (r->meta_data_ctr) {
2694                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2695                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2696                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2698                 }
2699         }
2700         return NDR_ERR_SUCCESS;
2701 }
2702
2703 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2704 {
2705         if (ndr_flags & NDR_SCALARS) {
2706                 NDR_CHECK(ndr_push_align(ndr, 8));
2707                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2708                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2710                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2711                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2713                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2714                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2719                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2720         }
2721         if (ndr_flags & NDR_BUFFERS) {
2722                 if (r->naming_context) {
2723                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2724                 }
2725                 if (r->uptodateness_vector) {
2726                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2727                 }
2728                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2729                 if (r->first_object) {
2730                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2731                 }
2732         }
2733         return NDR_ERR_SUCCESS;
2734 }
2735
2736 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2737 {
2738         uint32_t _ptr_naming_context;
2739         TALLOC_CTX *_mem_save_naming_context_0;
2740         uint32_t _ptr_uptodateness_vector;
2741         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2742         uint32_t _ptr_first_object;
2743         TALLOC_CTX *_mem_save_first_object_0;
2744         if (ndr_flags & NDR_SCALARS) {
2745                 NDR_CHECK(ndr_pull_align(ndr, 8));
2746                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2747                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2749                 if (_ptr_naming_context) {
2750                         NDR_PULL_ALLOC(ndr, r->naming_context);
2751                 } else {
2752                         r->naming_context = NULL;
2753                 }
2754                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2755                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2757                 if (_ptr_uptodateness_vector) {
2758                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2759                 } else {
2760                         r->uptodateness_vector = NULL;
2761                 }
2762                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2763                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2767                 if (_ptr_first_object) {
2768                         NDR_PULL_ALLOC(ndr, r->first_object);
2769                 } else {
2770                         r->first_object = NULL;
2771                 }
2772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2773                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2774         }
2775         if (ndr_flags & NDR_BUFFERS) {
2776                 if (r->naming_context) {
2777                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2778                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2779                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2781                 }
2782                 if (r->uptodateness_vector) {
2783                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2785                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2787                 }
2788                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2789                 if (r->first_object) {
2790                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2791                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2792                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2794                 }
2795         }
2796         return NDR_ERR_SUCCESS;
2797 }
2798
2799 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2800 {
2801         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2802         ndr->depth++;
2803         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2804         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2805         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2806         ndr->depth++;
2807         if (r->naming_context) {
2808                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2809         }
2810         ndr->depth--;
2811         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2812         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2813         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2814         ndr->depth++;
2815         if (r->uptodateness_vector) {
2816                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2817         }
2818         ndr->depth--;
2819         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2820         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2821         ndr_print_uint32(ndr, "object_count", r->object_count);
2822         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55:r->__ndr_size);
2823         ndr_print_ptr(ndr, "first_object", r->first_object);
2824         ndr->depth++;
2825         if (r->first_object) {
2826                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2827         }
2828         ndr->depth--;
2829         ndr_print_uint32(ndr, "more_data", r->more_data);
2830         ndr->depth--;
2831 }
2832
2833 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2834 {
2835         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2836 }
2837
2838 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2839 {
2840         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2841         return NDR_ERR_SUCCESS;
2842 }
2843
2844 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2845 {
2846         uint32_t v;
2847         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2848         *r = v;
2849         return NDR_ERR_SUCCESS;
2850 }
2851
2852 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2853 {
2854         ndr_print_uint32(ndr, name, r);
2855         ndr->depth++;
2856         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2857         ndr->depth--;
2858 }
2859
2860 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2861 {
2862         if (ndr_flags & NDR_SCALARS) {
2863                 NDR_CHECK(ndr_push_align(ndr, 8));
2864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2865                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2866                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2867                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2868                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2869                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2870                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2871         }
2872         if (ndr_flags & NDR_BUFFERS) {
2873                 if (r->identifier) {
2874                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2875                 }
2876                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2877         }
2878         return NDR_ERR_SUCCESS;
2879 }
2880
2881 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2882 {
2883         uint32_t _ptr_identifier;
2884         TALLOC_CTX *_mem_save_identifier_0;
2885         if (ndr_flags & NDR_SCALARS) {
2886                 NDR_CHECK(ndr_pull_align(ndr, 8));
2887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2888                 if (_ptr_identifier) {
2889                         NDR_PULL_ALLOC(ndr, r->identifier);
2890                 } else {
2891                         r->identifier = NULL;
2892                 }
2893                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2894                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2895                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2896                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2897                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2898                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2899         }
2900         if (ndr_flags & NDR_BUFFERS) {
2901                 if (r->identifier) {
2902                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2903                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2904                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2906                 }
2907                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2908         }
2909         return NDR_ERR_SUCCESS;
2910 }
2911
2912 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2913 {
2914         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2915         ndr->depth++;
2916         ndr_print_ptr(ndr, "identifier", r->identifier);
2917         ndr->depth++;
2918         if (r->identifier) {
2919                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2920         }
2921         ndr->depth--;
2922         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2923         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2924         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2925         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2926         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2927         ndr->depth--;
2928 }
2929
2930 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2931 {
2932         uint32_t cntr_linked_attributes_1;
2933         if (ndr_flags & NDR_SCALARS) {
2934                 NDR_CHECK(ndr_push_align(ndr, 8));
2935                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2936                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2938                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2939                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2941                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2942                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2950                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2951                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2952                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2953         }
2954         if (ndr_flags & NDR_BUFFERS) {
2955                 if (r->naming_context) {
2956                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2957                 }
2958                 if (r->uptodateness_vector) {
2959                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2960                 }
2961                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2962                 if (r->first_object) {
2963                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2964                 }
2965                 if (r->linked_attributes) {
2966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2967                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2968                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2969                         }
2970                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2971                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2972                         }
2973                 }
2974         }
2975         return NDR_ERR_SUCCESS;
2976 }
2977
2978 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2979 {
2980         uint32_t _ptr_naming_context;
2981         TALLOC_CTX *_mem_save_naming_context_0;
2982         uint32_t _ptr_uptodateness_vector;
2983         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2984         uint32_t _ptr_first_object;
2985         TALLOC_CTX *_mem_save_first_object_0;
2986         uint32_t _ptr_linked_attributes;
2987         uint32_t cntr_linked_attributes_1;
2988         TALLOC_CTX *_mem_save_linked_attributes_0;
2989         TALLOC_CTX *_mem_save_linked_attributes_1;
2990         if (ndr_flags & NDR_SCALARS) {
2991                 NDR_CHECK(ndr_pull_align(ndr, 8));
2992                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2995                 if (_ptr_naming_context) {
2996                         NDR_PULL_ALLOC(ndr, r->naming_context);
2997                 } else {
2998                         r->naming_context = NULL;
2999                 }
3000                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
3001                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3003                 if (_ptr_uptodateness_vector) {
3004                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3005                 } else {
3006                         r->uptodateness_vector = NULL;
3007                 }
3008                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3009                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3013                 if (_ptr_first_object) {
3014                         NDR_PULL_ALLOC(ndr, r->first_object);
3015                 } else {
3016                         r->first_object = NULL;
3017                 }
3018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3022                 if (r->linked_attributes_count > 1048576) {
3023                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3024                 }
3025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3026                 if (_ptr_linked_attributes) {
3027                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3028                 } else {
3029                         r->linked_attributes = NULL;
3030                 }
3031                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3032                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3033         }
3034         if (ndr_flags & NDR_BUFFERS) {
3035                 if (r->naming_context) {
3036                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3037                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3038                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3040                 }
3041                 if (r->uptodateness_vector) {
3042                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3043                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3044                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3045                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3046                 }
3047                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3048                 if (r->first_object) {
3049                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3050                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3051                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3053                 }
3054                 if (r->linked_attributes) {
3055                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3056                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3057                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3058                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3059                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3060                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3061                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3062                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3063                         }
3064                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3065                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3066                         }
3067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3069                 }
3070                 if (r->linked_attributes) {
3071                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3072                 }
3073         }
3074         return NDR_ERR_SUCCESS;
3075 }
3076
3077 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3078 {
3079         uint32_t cntr_linked_attributes_1;
3080         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3081         ndr->depth++;
3082         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3083         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3084         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3085         ndr->depth++;
3086         if (r->naming_context) {
3087                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3088         }
3089         ndr->depth--;
3090         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3091         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3092         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3093         ndr->depth++;
3094         if (r->uptodateness_vector) {
3095                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3096         }
3097         ndr->depth--;
3098         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3099         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3100         ndr_print_uint32(ndr, "object_count", r->object_count);
3101         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55:r->__ndr_size);
3102         ndr_print_ptr(ndr, "first_object", r->first_object);
3103         ndr->depth++;
3104         if (r->first_object) {
3105                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3106         }
3107         ndr->depth--;
3108         ndr_print_uint32(ndr, "more_data", r->more_data);
3109         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3110         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3111         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3112         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3113         ndr->depth++;
3114         if (r->linked_attributes) {
3115                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3116                 ndr->depth++;
3117                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3118                         char *idx_1=NULL;
3119                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3120                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3121                                 free(idx_1);
3122                         }
3123                 }
3124                 ndr->depth--;
3125         }
3126         ndr->depth--;
3127         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3128         ndr->depth--;
3129 }
3130
3131 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3132 {
3133         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3134 }
3135
3136 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3137 {
3138         if (ndr_flags & NDR_SCALARS) {
3139                 NDR_CHECK(ndr_push_align(ndr, 1));
3140                 {
3141                         struct ndr_push *_ndr_ctr1;
3142                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3143                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3144                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3145                 }
3146                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3147         }
3148         if (ndr_flags & NDR_BUFFERS) {
3149         }
3150         return NDR_ERR_SUCCESS;
3151 }
3152
3153 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3154 {
3155         if (ndr_flags & NDR_SCALARS) {
3156                 NDR_CHECK(ndr_pull_align(ndr, 1));
3157                 {
3158                         struct ndr_pull *_ndr_ctr1;
3159                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3160                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3161                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3162                 }
3163                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3164         }
3165         if (ndr_flags & NDR_BUFFERS) {
3166         }
3167         return NDR_ERR_SUCCESS;
3168 }
3169
3170 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3171 {
3172         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3173         ndr->depth++;
3174         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3175         ndr->depth--;
3176 }
3177
3178 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3179 {
3180         if (ndr_flags & NDR_SCALARS) {
3181                 NDR_CHECK(ndr_push_align(ndr, 1));
3182                 {
3183                         struct ndr_push *_ndr_ctr6;
3184                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3185                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3186                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3187                 }
3188                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3189         }
3190         if (ndr_flags & NDR_BUFFERS) {
3191         }
3192         return NDR_ERR_SUCCESS;
3193 }
3194
3195 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3196 {
3197         if (ndr_flags & NDR_SCALARS) {
3198                 NDR_CHECK(ndr_pull_align(ndr, 1));
3199                 {
3200                         struct ndr_pull *_ndr_ctr6;
3201                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3202                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3203                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3204                 }
3205                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3206         }
3207         if (ndr_flags & NDR_BUFFERS) {
3208         }
3209         return NDR_ERR_SUCCESS;
3210 }
3211
3212 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3213 {
3214         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3215         ndr->depth++;
3216         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3217         ndr->depth--;
3218 }
3219
3220 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3221 {
3222         uint32_t _ptr_ts;
3223         TALLOC_CTX *_mem_save_ts_0;
3224         if (ndr_flags & NDR_SCALARS) {
3225                 NDR_CHECK(ndr_pull_align(ndr, 5));
3226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3229                 if (_ptr_ts) {
3230                         NDR_PULL_ALLOC(ndr, r->ts);
3231                 } else {
3232                         r->ts = NULL;
3233                 }
3234                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3235         }
3236         if (ndr_flags & NDR_BUFFERS) {
3237                 if (r->ts) {
3238                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3239                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3240                         {
3241                                 struct ndr_pull *_ndr_ts;
3242                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3243                                 {
3244                                         struct ndr_pull *_ndr_ts_compressed;
3245                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3246                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3247                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3248                                 }
3249                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3250                         }
3251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3252                 }
3253         }
3254         return NDR_ERR_SUCCESS;
3255 }
3256
3257 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3258 {
3259         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3260         ndr->depth++;
3261         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3262         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3263         ndr_print_ptr(ndr, "ts", r->ts);
3264         ndr->depth++;
3265         if (r->ts) {
3266                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3267         }
3268         ndr->depth--;
3269         ndr->depth--;
3270 }
3271
3272 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3273 {
3274         uint32_t _ptr_ts;
3275         TALLOC_CTX *_mem_save_ts_0;
3276         if (ndr_flags & NDR_SCALARS) {
3277                 NDR_CHECK(ndr_pull_align(ndr, 5));
3278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3281                 if (_ptr_ts) {
3282                         NDR_PULL_ALLOC(ndr, r->ts);
3283                 } else {
3284                         r->ts = NULL;
3285                 }
3286                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3287         }
3288         if (ndr_flags & NDR_BUFFERS) {
3289                 if (r->ts) {
3290                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3291                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3292                         {
3293                                 struct ndr_pull *_ndr_ts;
3294                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3295                                 {
3296                                         struct ndr_pull *_ndr_ts_compressed;
3297                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3298                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3299                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3300                                 }
3301                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3302                         }
3303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3304                 }
3305         }
3306         return NDR_ERR_SUCCESS;
3307 }
3308
3309 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3310 {
3311         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3312         ndr->depth++;
3313         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3314         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3315         ndr_print_ptr(ndr, "ts", r->ts);
3316         ndr->depth++;
3317         if (r->ts) {
3318                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3319         }
3320         ndr->depth--;
3321         ndr->depth--;
3322 }
3323
3324 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3325 {
3326         uint32_t _ptr_ts;
3327         TALLOC_CTX *_mem_save_ts_0;
3328         if (ndr_flags & NDR_SCALARS) {
3329                 NDR_CHECK(ndr_pull_align(ndr, 5));
3330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3333                 if (_ptr_ts) {
3334                         NDR_PULL_ALLOC(ndr, r->ts);
3335                 } else {
3336                         r->ts = NULL;
3337                 }
3338                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3339         }
3340         if (ndr_flags & NDR_BUFFERS) {
3341                 if (r->ts) {
3342                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3343                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3344                         {
3345                                 struct ndr_pull *_ndr_ts;
3346                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3347                                 {
3348                                         struct ndr_pull *_ndr_ts_compressed;
3349                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3350                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3351                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3352                                 }
3353                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3354                         }
3355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3356                 }
3357         }
3358         return NDR_ERR_SUCCESS;
3359 }
3360
3361 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3362 {
3363         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3364         ndr->depth++;
3365         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3366         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3367         ndr_print_ptr(ndr, "ts", r->ts);
3368         ndr->depth++;
3369         if (r->ts) {
3370                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3371         }
3372         ndr->depth--;
3373         ndr->depth--;
3374 }
3375
3376 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3377 {
3378         uint32_t _ptr_ts;
3379         TALLOC_CTX *_mem_save_ts_0;
3380         if (ndr_flags & NDR_SCALARS) {
3381                 NDR_CHECK(ndr_pull_align(ndr, 5));
3382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3385                 if (_ptr_ts) {
3386                         NDR_PULL_ALLOC(ndr, r->ts);
3387                 } else {
3388                         r->ts = NULL;
3389                 }
3390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3391         }
3392         if (ndr_flags & NDR_BUFFERS) {
3393                 if (r->ts) {
3394                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3395                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3396                         {
3397                                 struct ndr_pull *_ndr_ts;
3398                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3399                                 {
3400                                         struct ndr_pull *_ndr_ts_compressed;
3401                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3402                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3403                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3404                                 }
3405                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3406                         }
3407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3408                 }
3409         }
3410         return NDR_ERR_SUCCESS;
3411 }
3412
3413 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3414 {
3415         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3416         ndr->depth++;
3417         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3418         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3419         ndr_print_ptr(ndr, "ts", r->ts);
3420         ndr->depth++;
3421         if (r->ts) {
3422                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3423         }
3424         ndr->depth--;
3425         ndr->depth--;
3426 }
3427
3428 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3429 {
3430         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3431         return NDR_ERR_SUCCESS;
3432 }
3433
3434 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3435 {
3436         uint16_t v;
3437         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3438         *r = v;
3439         return NDR_ERR_SUCCESS;
3440 }
3441
3442 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3443 {
3444         const char *val = NULL;
3445
3446         switch (r) {
3447                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3448                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3449         }
3450         ndr_print_enum(ndr, name, "ENUM", val, r);
3451 }
3452
3453 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3454 {
3455         {
3456                 uint32_t _flags_save_UNION = ndr->flags;
3457                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3458                 if (ndr_flags & NDR_SCALARS) {
3459                         int level = ndr_push_get_switch_value(ndr, r);
3460                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3461                         switch (level) {
3462                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3463                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3464                                 break; }
3465
3466                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3467                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3468                                 break; }
3469
3470                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3471                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3472                                 break; }
3473
3474                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3475                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3476                                 break; }
3477
3478                                 default:
3479                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3480                         }
3481                 }
3482                 if (ndr_flags & NDR_BUFFERS) {
3483                         int level = ndr_push_get_switch_value(ndr, r);
3484                         switch (level) {
3485                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3486                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3487                                 break;
3488
3489                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3490                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3491                                 break;
3492
3493                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3494                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3495                                 break;
3496
3497                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3498                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3499                                 break;
3500
3501                                 default:
3502                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3503                         }
3504                 }
3505                 ndr->flags = _flags_save_UNION;
3506         }
3507         return NDR_ERR_SUCCESS;
3508 }
3509
3510 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3511 {
3512         int level;
3513         {
3514                 uint32_t _flags_save_UNION = ndr->flags;
3515                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3516                 level = ndr_pull_get_switch_value(ndr, r);
3517                 if (ndr_flags & NDR_SCALARS) {
3518                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3519                         switch (level) {
3520                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3521                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3522                                 break; }
3523
3524                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3525                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3526                                 break; }
3527
3528                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3529                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3530                                 break; }
3531
3532                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3533                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3534                                 break; }
3535
3536                                 default:
3537                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3538                         }
3539                 }
3540                 if (ndr_flags & NDR_BUFFERS) {
3541                         switch (level) {
3542                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3543                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3544                                 break;
3545
3546                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3547                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3548                                 break;
3549
3550                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3551                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3552                                 break;
3553
3554                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3555                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3556                                 break;
3557
3558                                 default:
3559                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3560                         }
3561                 }
3562                 ndr->flags = _flags_save_UNION;
3563         }
3564         return NDR_ERR_SUCCESS;
3565 }
3566
3567 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3568 {
3569         int level;
3570         {
3571                 uint32_t _flags_save_UNION = ndr->flags;
3572                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3573                 level = ndr_print_get_switch_value(ndr, r);
3574                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3575                 switch (level) {
3576                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3577                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3578                         break;
3579
3580                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3581                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3582                         break;
3583
3584                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3585                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3586                         break;
3587
3588                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3589                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3590                         break;
3591
3592                         default:
3593                                 ndr_print_bad_level(ndr, name, level);
3594                 }
3595                 ndr->flags = _flags_save_UNION;
3596         }
3597 }
3598
3599 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3600 {
3601         if (ndr_flags & NDR_SCALARS) {
3602                 NDR_CHECK(ndr_push_align(ndr, 5));
3603                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3604                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3605         }
3606         if (ndr_flags & NDR_BUFFERS) {
3607                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3608         }
3609         return NDR_ERR_SUCCESS;
3610 }
3611
3612 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3613 {
3614         if (ndr_flags & NDR_SCALARS) {
3615                 NDR_CHECK(ndr_pull_align(ndr, 5));
3616                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3617                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3618         }
3619         if (ndr_flags & NDR_BUFFERS) {
3620                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3621         }
3622         return NDR_ERR_SUCCESS;
3623 }
3624
3625 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3626 {
3627         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3628         ndr->depth++;
3629         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3630         ndr->depth--;
3631 }
3632
3633 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3634 {
3635         if (ndr_flags & NDR_SCALARS) {
3636                 NDR_CHECK(ndr_push_align(ndr, 5));
3637                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3638                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3639                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3640                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3641                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3642         }
3643         if (ndr_flags & NDR_BUFFERS) {
3644                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3645         }
3646         return NDR_ERR_SUCCESS;
3647 }
3648
3649 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3650 {
3651         if (ndr_flags & NDR_SCALARS) {
3652                 NDR_CHECK(ndr_pull_align(ndr, 5));
3653                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3654                 if (r->level < 0 || r->level > 6) {
3655                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3656                 }
3657                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3658                 if (r->type < 2 || r->type > 3) {
3659                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3660                 }
3661                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3662                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3663                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3664         }
3665         if (ndr_flags & NDR_BUFFERS) {
3666                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3667         }
3668         return NDR_ERR_SUCCESS;
3669 }
3670
3671 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3672 {
3673         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3674         ndr->depth++;
3675         ndr_print_int32(ndr, "level", r->level);
3676         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3677         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3678         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3679         ndr->depth--;
3680 }
3681
3682 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3683 {
3684         if (ndr_flags & NDR_SCALARS) {
3685                 int level = ndr_push_get_switch_value(ndr, r);
3686                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3687                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3688                 switch (level) {
3689                         case 1: {
3690                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3691                         break; }
3692
3693                         case 2: {
3694                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3695                         break; }
3696
3697                         case 6: {
3698                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3699                         break; }
3700
3701                         case 7: {
3702                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3703                         break; }
3704
3705                         default:
3706                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3707                 }
3708         }
3709         if (ndr_flags & NDR_BUFFERS) {
3710                 int level = ndr_push_get_switch_value(ndr, r);
3711                 switch (level) {
3712                         case 1:
3713                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3714                         break;
3715
3716                         case 2:
3717                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3718                         break;
3719
3720                         case 6:
3721                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3722                         break;
3723
3724                         case 7:
3725                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3726                         break;
3727
3728                         default:
3729                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3730                 }
3731         }
3732         return NDR_ERR_SUCCESS;
3733 }
3734
3735 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3736 {
3737         int level;
3738         int32_t _level;
3739         level = ndr_pull_get_switch_value(ndr, r);
3740         if (ndr_flags & NDR_SCALARS) {
3741                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3742                 if (_level != level) {
3743                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3744                 }
3745                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3746                 switch (level) {
3747                         case 1: {
3748                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3749                         break; }
3750
3751                         case 2: {
3752                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3753                         break; }
3754
3755                         case 6: {
3756                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3757                         break; }
3758
3759                         case 7: {
3760                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3761                         break; }
3762
3763                         default:
3764                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3765                 }
3766         }
3767         if (ndr_flags & NDR_BUFFERS) {
3768                 switch (level) {
3769                         case 1:
3770                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3771                         break;
3772
3773                         case 2:
3774                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3775                         break;
3776
3777                         case 6:
3778                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3779                         break;
3780
3781                         case 7:
3782                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3783                         break;
3784
3785                         default:
3786                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3787                 }
3788         }
3789         return NDR_ERR_SUCCESS;
3790 }
3791
3792 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3793 {
3794         int level;
3795         level = ndr_print_get_switch_value(ndr, r);
3796         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3797         switch (level) {
3798                 case 1:
3799                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3800                 break;
3801
3802                 case 2:
3803                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3804                 break;
3805
3806                 case 6:
3807                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3808                 break;
3809
3810                 case 7:
3811                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3812                 break;
3813
3814                 default:
3815                         ndr_print_bad_level(ndr, name, level);
3816         }
3817 }
3818
3819 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3820 {
3821         if (ndr_flags & NDR_SCALARS) {
3822                 NDR_CHECK(ndr_push_align(ndr, 5));
3823                 if (r->naming_context == NULL) {
3824                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3825                 }
3826                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3827                 if (r->dest_dsa_dns_name == NULL) {
3828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3829                 }
3830                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3831                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3832                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3833                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3834         }
3835         if (ndr_flags & NDR_BUFFERS) {
3836                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3837                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3838                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3839                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3840                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dest_dsa_dns_name, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS), sizeof(uint8_t), CH_DOS));
3841         }
3842         return NDR_ERR_SUCCESS;
3843 }
3844
3845 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3846 {
3847         uint32_t _ptr_naming_context;
3848         TALLOC_CTX *_mem_save_naming_context_0;
3849         uint32_t _ptr_dest_dsa_dns_name;
3850         if (ndr_flags & NDR_SCALARS) {
3851                 NDR_CHECK(ndr_pull_align(ndr, 5));
3852                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3853                 if (_ptr_naming_context) {
3854                         NDR_PULL_ALLOC(ndr, r->naming_context);
3855                 } else {
3856                         r->naming_context = NULL;
3857                 }
3858                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3859                 if (_ptr_dest_dsa_dns_name) {
3860                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3861                 } else {
3862                         r->dest_dsa_dns_name = NULL;
3863                 }
3864                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3865                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3866                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3867         }
3868         if (ndr_flags & NDR_BUFFERS) {
3869                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3870                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3871                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3872                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3873                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3874                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3875                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3876                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dest_dsa_dns_name), ndr_get_array_length(ndr, &r->dest_dsa_dns_name));
3877                 }
3878                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3879                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dest_dsa_dns_name, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t), CH_DOS));
3880         }
3881         return NDR_ERR_SUCCESS;
3882 }
3883
3884 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3885 {
3886         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3887         ndr->depth++;
3888         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3889         ndr->depth++;
3890         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3891         ndr->depth--;
3892         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3893         ndr->depth++;
3894         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3895         ndr->depth--;
3896         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3897         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
3898         ndr->depth--;
3899 }
3900
3901 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3902 {
3903         if (ndr_flags & NDR_SCALARS) {
3904                 int level = ndr_push_get_switch_value(ndr, r);
3905                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3906                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3907                 switch (level) {
3908                         case 1: {
3909                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3910                         break; }
3911
3912                         default:
3913                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3914                 }
3915         }
3916         if (ndr_flags & NDR_BUFFERS) {
3917                 int level = ndr_push_get_switch_value(ndr, r);
3918                 switch (level) {
3919                         case 1:
3920                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3921                         break;
3922
3923                         default:
3924                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3925                 }
3926         }
3927         return NDR_ERR_SUCCESS;
3928 }
3929
3930 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3931 {
3932         int level;
3933         int32_t _level;
3934         level = ndr_pull_get_switch_value(ndr, r);
3935         if (ndr_flags & NDR_SCALARS) {
3936                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3937                 if (_level != level) {
3938                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3939                 }
3940                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3941                 switch (level) {
3942                         case 1: {
3943                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3944                         break; }
3945
3946                         default:
3947                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3948                 }
3949         }
3950         if (ndr_flags & NDR_BUFFERS) {
3951                 switch (level) {
3952                         case 1:
3953                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3954                         break;
3955
3956                         default:
3957                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3958                 }
3959         }
3960         return NDR_ERR_SUCCESS;
3961 }
3962
3963 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3964 {
3965         int level;
3966         level = ndr_print_get_switch_value(ndr, r);
3967         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3968         switch (level) {
3969                 case 1:
3970                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3971                 break;
3972
3973                 default:
3974                         ndr_print_bad_level(ndr, name, level);
3975         }
3976 }
3977
3978 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3979 {
3980         if (ndr_flags & NDR_SCALARS) {
3981                 NDR_CHECK(ndr_push_align(ndr, 5));
3982                 if (r->naming_context == NULL) {
3983                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3984                 }
3985                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3987                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3988                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3989                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3990         }
3991         if (ndr_flags & NDR_BUFFERS) {
3992                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3993                 if (r->source_dsa_address) {
3994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3997                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3998                 }
3999         }
4000         return NDR_ERR_SUCCESS;
4001 }
4002
4003 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4004 {
4005         uint32_t _ptr_naming_context;
4006         TALLOC_CTX *_mem_save_naming_context_0;
4007         uint32_t _ptr_source_dsa_address;
4008         TALLOC_CTX *_mem_save_source_dsa_address_0;
4009         if (ndr_flags & NDR_SCALARS) {
4010                 NDR_CHECK(ndr_pull_align(ndr, 5));
4011                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4012                 if (_ptr_naming_context) {
4013                         NDR_PULL_ALLOC(ndr, r->naming_context);
4014                 } else {
4015                         r->naming_context = NULL;
4016                 }
4017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4018                 if (_ptr_source_dsa_address) {
4019                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4020                 } else {
4021                         r->source_dsa_address = NULL;
4022                 }
4023                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4024                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4025                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4026         }
4027         if (ndr_flags & NDR_BUFFERS) {
4028                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4029                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4030                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4032                 if (r->source_dsa_address) {
4033                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4034                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4037                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4038                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
4039                         }
4040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4041                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
4042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4043                 }
4044         }
4045         return NDR_ERR_SUCCESS;
4046 }
4047
4048 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4049 {
4050         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4051         ndr->depth++;
4052         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4053         ndr->depth++;
4054         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4055         ndr->depth--;
4056         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4057         ndr->depth++;
4058         if (r->source_dsa_address) {
4059                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4060         }
4061         ndr->depth--;
4062         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4063         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4064         ndr->depth--;
4065 }
4066
4067 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4068 {
4069         if (ndr_flags & NDR_SCALARS) {
4070                 NDR_CHECK(ndr_push_align(ndr, 5));
4071                 if (r->naming_context == NULL) {
4072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4073                 }
4074                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4078                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4079                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4080                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4081         }
4082         if (ndr_flags & NDR_BUFFERS) {
4083                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4084                 if (r->source_dsa_dn) {
4085                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4086                 }
4087                 if (r->transport_dn) {
4088                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4089                 }
4090                 if (r->source_dsa_address) {
4091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4094                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4095                 }
4096         }
4097         return NDR_ERR_SUCCESS;
4098 }
4099
4100 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4101 {
4102         uint32_t _ptr_naming_context;
4103         TALLOC_CTX *_mem_save_naming_context_0;
4104         uint32_t _ptr_source_dsa_dn;
4105         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4106         uint32_t _ptr_transport_dn;
4107         TALLOC_CTX *_mem_save_transport_dn_0;
4108         uint32_t _ptr_source_dsa_address;
4109         TALLOC_CTX *_mem_save_source_dsa_address_0;
4110         if (ndr_flags & NDR_SCALARS) {
4111                 NDR_CHECK(ndr_pull_align(ndr, 5));
4112                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4113                 if (_ptr_naming_context) {
4114                         NDR_PULL_ALLOC(ndr, r->naming_context);
4115                 } else {
4116                         r->naming_context = NULL;
4117                 }
4118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4119                 if (_ptr_source_dsa_dn) {
4120                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4121                 } else {
4122                         r->source_dsa_dn = NULL;
4123                 }
4124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4125                 if (_ptr_transport_dn) {
4126                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4127                 } else {
4128                         r->transport_dn = NULL;
4129                 }
4130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4131                 if (_ptr_source_dsa_address) {
4132                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4133                 } else {
4134                         r->source_dsa_address = NULL;
4135                 }
4136                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4137                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4138                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4139         }
4140         if (ndr_flags & NDR_BUFFERS) {
4141                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4142                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4143                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4145                 if (r->source_dsa_dn) {
4146                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4147                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4148                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4150                 }
4151                 if (r->transport_dn) {
4152                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4153                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4154                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4156                 }
4157                 if (r->source_dsa_address) {
4158                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4159                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4162                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4163                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
4164                         }
4165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
4167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4168                 }
4169         }
4170         return NDR_ERR_SUCCESS;
4171 }
4172
4173 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4174 {
4175         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4176         ndr->depth++;
4177         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4178         ndr->depth++;
4179         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4180         ndr->depth--;
4181         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4182         ndr->depth++;
4183         if (r->source_dsa_dn) {
4184                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4185         }
4186         ndr->depth--;
4187         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4188         ndr->depth++;
4189         if (r->transport_dn) {
4190                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4191         }
4192         ndr->depth--;
4193         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4194         ndr->depth++;
4195         if (r->source_dsa_address) {
4196                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4197         }
4198         ndr->depth--;
4199         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4200         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4201         ndr->depth--;
4202 }
4203
4204 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4205 {
4206         if (ndr_flags & NDR_SCALARS) {
4207                 int level = ndr_push_get_switch_value(ndr, r);
4208                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4209                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4210                 switch (level) {
4211                         case 1: {
4212                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4213                         break; }
4214
4215                         case 2: {
4216                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4217                         break; }
4218
4219                         default:
4220                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4221                 }
4222         }
4223         if (ndr_flags & NDR_BUFFERS) {
4224                 int level = ndr_push_get_switch_value(ndr, r);
4225                 switch (level) {
4226                         case 1:
4227                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4228                         break;
4229
4230                         case 2:
4231                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4232                         break;
4233
4234                         default:
4235                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4236                 }
4237         }
4238         return NDR_ERR_SUCCESS;
4239 }
4240
4241 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4242 {
4243         int level;
4244         int32_t _level;
4245         level = ndr_pull_get_switch_value(ndr, r);
4246         if (ndr_flags & NDR_SCALARS) {
4247                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4248                 if (_level != level) {
4249                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4250                 }
4251                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4252                 switch (level) {
4253                         case 1: {
4254                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4255                         break; }
4256
4257                         case 2: {
4258                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4259                         break; }
4260
4261                         default:
4262                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4263                 }
4264         }
4265         if (ndr_flags & NDR_BUFFERS) {
4266                 switch (level) {
4267                         case 1:
4268                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4269                         break;
4270
4271                         case 2:
4272                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4273                         break;
4274
4275                         default:
4276                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4277                 }
4278         }
4279         return NDR_ERR_SUCCESS;
4280 }
4281
4282 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4283 {
4284         int level;
4285         level = ndr_print_get_switch_value(ndr, r);
4286         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4287         switch (level) {
4288                 case 1:
4289                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4290                 break;
4291
4292                 case 2:
4293                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4294                 break;
4295
4296                 default:
4297                         ndr_print_bad_level(ndr, name, level);
4298         }
4299 }
4300
4301 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4302 {
4303         if (ndr_flags & NDR_SCALARS) {
4304                 NDR_CHECK(ndr_push_align(ndr, 5));
4305                 if (r->naming_context == NULL) {
4306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4307                 }
4308                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4310                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4311                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4312         }
4313         if (ndr_flags & NDR_BUFFERS) {
4314                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4315                 if (r->source_dsa_address) {
4316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4319                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4320                 }
4321         }
4322         return NDR_ERR_SUCCESS;
4323 }
4324
4325 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4326 {
4327         uint32_t _ptr_naming_context;
4328         TALLOC_CTX *_mem_save_naming_context_0;
4329         uint32_t _ptr_source_dsa_address;
4330         TALLOC_CTX *_mem_save_source_dsa_address_0;
4331         if (ndr_flags & NDR_SCALARS) {
4332                 NDR_CHECK(ndr_pull_align(ndr, 5));
4333                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4334                 if (_ptr_naming_context) {
4335                         NDR_PULL_ALLOC(ndr, r->naming_context);
4336                 } else {
4337                         r->naming_context = NULL;
4338                 }
4339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4340                 if (_ptr_source_dsa_address) {
4341                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4342                 } else {
4343                         r->source_dsa_address = NULL;
4344                 }
4345                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4346                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4347         }
4348         if (ndr_flags & NDR_BUFFERS) {
4349                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4350                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4351                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4353                 if (r->source_dsa_address) {
4354                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4355                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4358                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4359                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
4360                         }
4361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
4363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4364                 }
4365         }
4366         return NDR_ERR_SUCCESS;
4367 }
4368
4369 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4370 {
4371         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4372         ndr->depth++;
4373         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4374         ndr->depth++;
4375         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4376         ndr->depth--;
4377         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4378         ndr->depth++;
4379         if (r->source_dsa_address) {
4380                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4381         }
4382         ndr->depth--;
4383         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4384         ndr->depth--;
4385 }
4386
4387 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4388 {
4389         if (ndr_flags & NDR_SCALARS) {
4390                 int level = ndr_push_get_switch_value(ndr, r);
4391                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4392                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4393                 switch (level) {
4394                         case 1: {
4395                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4396                         break; }
4397
4398                         default:
4399                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4400                 }
4401         }
4402         if (ndr_flags & NDR_BUFFERS) {
4403                 int level = ndr_push_get_switch_value(ndr, r);
4404                 switch (level) {
4405                         case 1:
4406                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4407                         break;
4408
4409                         default:
4410                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4411                 }
4412         }
4413         return NDR_ERR_SUCCESS;
4414 }
4415
4416 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4417 {
4418         int level;
4419         int32_t _level;
4420         level = ndr_pull_get_switch_value(ndr, r);
4421         if (ndr_flags & NDR_SCALARS) {
4422                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4423                 if (_level != level) {
4424                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4425                 }
4426                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4427                 switch (level) {
4428                         case 1: {
4429                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4430                         break; }
4431
4432                         default:
4433                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4434                 }
4435         }
4436         if (ndr_flags & NDR_BUFFERS) {
4437                 switch (level) {
4438                         case 1:
4439                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4440                         break;
4441
4442                         default:
4443                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4444                 }
4445         }
4446         return NDR_ERR_SUCCESS;
4447 }
4448
4449 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4450 {
4451         int level;
4452         level = ndr_print_get_switch_value(ndr, r);
4453         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4454         switch (level) {
4455                 case 1:
4456                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4457                 break;
4458
4459                 default:
4460                         ndr_print_bad_level(ndr, name, level);
4461         }
4462 }
4463
4464 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4465 {
4466         if (ndr_flags & NDR_SCALARS) {
4467                 NDR_CHECK(ndr_push_align(ndr, 5));
4468                 if (r->naming_context == NULL) {
4469                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4470                 }
4471                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4472                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4474                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4477                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4478                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4479         }
4480         if (ndr_flags & NDR_BUFFERS) {
4481                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4482                 if (r->source_dra_address) {
4483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4486                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dra_address, ndr_charset_length(r->source_dra_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4487                 }
4488         }
4489         return NDR_ERR_SUCCESS;
4490 }
4491
4492 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4493 {
4494         uint32_t _ptr_naming_context;
4495         TALLOC_CTX *_mem_save_naming_context_0;
4496         uint32_t _ptr_source_dra_address;
4497         TALLOC_CTX *_mem_save_source_dra_address_0;
4498         if (ndr_flags & NDR_SCALARS) {
4499                 NDR_CHECK(ndr_pull_align(ndr, 5));
4500                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4501                 if (_ptr_naming_context) {
4502                         NDR_PULL_ALLOC(ndr, r->naming_context);
4503                 } else {
4504                         r->naming_context = NULL;
4505                 }
4506                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4508                 if (_ptr_source_dra_address) {
4509                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4510                 } else {
4511                         r->source_dra_address = NULL;
4512                 }
4513                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4516                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4517                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4518         }
4519         if (ndr_flags & NDR_BUFFERS) {
4520                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4521                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4522                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4524                 if (r->source_dra_address) {
4525                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4526                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4529                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4530                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dra_address), ndr_get_array_length(ndr, &r->source_dra_address));
4531                         }
4532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dra_address, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t), CH_UTF16));
4534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4535                 }
4536         }
4537         return NDR_ERR_SUCCESS;
4538 }
4539
4540 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4541 {
4542         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4543         ndr->depth++;
4544         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4545         ndr->depth++;
4546         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4547         ndr->depth--;
4548         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4549         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4550         ndr->depth++;
4551         if (r->source_dra_address) {
4552                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4553         }
4554         ndr->depth--;
4555         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4556         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4557         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4558         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4559         ndr->depth--;
4560 }
4561
4562 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4563 {
4564         if (ndr_flags & NDR_SCALARS) {
4565                 int level = ndr_push_get_switch_value(ndr, r);
4566                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4567                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4568                 switch (level) {
4569                         case 1: {
4570                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4571                         break; }
4572
4573                         default:
4574                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4575                 }
4576         }
4577         if (ndr_flags & NDR_BUFFERS) {
4578                 int level = ndr_push_get_switch_value(ndr, r);
4579                 switch (level) {
4580                         case 1:
4581                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4582                         break;
4583
4584                         default:
4585                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4586                 }
4587         }
4588         return NDR_ERR_SUCCESS;
4589 }
4590
4591 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4592 {
4593         int level;
4594         int32_t _level;
4595         level = ndr_pull_get_switch_value(ndr, r);
4596         if (ndr_flags & NDR_SCALARS) {
4597                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4598                 if (_level != level) {
4599                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4600                 }
4601                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4602                 switch (level) {
4603                         case 1: {
4604                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4605                         break; }
4606
4607                         default:
4608                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4609                 }
4610         }
4611         if (ndr_flags & NDR_BUFFERS) {
4612                 switch (level) {
4613                         case 1:
4614                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4615                         break;
4616
4617                         default:
4618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4619                 }
4620         }
4621         return NDR_ERR_SUCCESS;
4622 }
4623
4624 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4625 {
4626         int level;
4627         level = ndr_print_get_switch_value(ndr, r);
4628         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4629         switch (level) {
4630                 case 1:
4631                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4632                 break;
4633
4634                 default:
4635                         ndr_print_bad_level(ndr, name, level);
4636         }
4637 }
4638
4639 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4640 {
4641         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4642         return NDR_ERR_SUCCESS;
4643 }
4644
4645 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4646 {
4647         uint32_t v;
4648         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4649         *r = v;
4650         return NDR_ERR_SUCCESS;
4651 }
4652
4653 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4654 {
4655         const char *val = NULL;
4656
4657         switch (r) {
4658                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4659                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4660                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4661                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4662                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4663                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4664                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4665         }
4666         ndr_print_enum(ndr, name, "ENUM", val, r);
4667 }
4668
4669 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4670 {
4671         uint32_t cntr_info_array_1;
4672         uint32_t cntr_group_attrs_1;
4673         uint32_t cntr_sids_1;
4674         if (ndr_flags & NDR_SCALARS) {
4675                 NDR_CHECK(ndr_push_align(ndr, 5));
4676                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4682                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4683         }
4684         if (ndr_flags & NDR_BUFFERS) {
4685                 if (r->info_array) {
4686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4687                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4688                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4689                         }
4690                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4691                                 if (r->info_array[cntr_info_array_1]) {
4692                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4693                                 }
4694                         }
4695                 }
4696                 if (r->group_attrs) {
4697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4698                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4699                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4700                         }
4701                 }
4702                 if (r->sids) {
4703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4704                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4705                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4706                         }
4707                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4708                                 if (r->sids[cntr_sids_1]) {
4709                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4710                                 }
4711                         }
4712                 }
4713         }
4714         return NDR_ERR_SUCCESS;
4715 }
4716
4717 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4718 {
4719         uint32_t _ptr_info_array;
4720         uint32_t cntr_info_array_1;
4721         TALLOC_CTX *_mem_save_info_array_0;
4722         TALLOC_CTX *_mem_save_info_array_1;
4723         TALLOC_CTX *_mem_save_info_array_2;
4724         uint32_t _ptr_group_attrs;
4725         uint32_t cntr_group_attrs_1;
4726         TALLOC_CTX *_mem_save_group_attrs_0;
4727         TALLOC_CTX *_mem_save_group_attrs_1;
4728         uint32_t _ptr_sids;
4729         uint32_t cntr_sids_1;
4730         TALLOC_CTX *_mem_save_sids_0;
4731         TALLOC_CTX *_mem_save_sids_1;
4732         TALLOC_CTX *_mem_save_sids_2;
4733         if (ndr_flags & NDR_SCALARS) {
4734                 NDR_CHECK(ndr_pull_align(ndr, 5));
4735                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4737                 if (r->num_memberships > 10000) {
4738                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4739                 }
4740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4741                 if (r->num_sids > 10000) {
4742                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4743                 }
4744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4745                 if (_ptr_info_array) {
4746                         NDR_PULL_ALLOC(ndr, r->info_array);
4747                 } else {
4748                         r->info_array = NULL;
4749                 }
4750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4751                 if (_ptr_group_attrs) {
4752                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4753                 } else {
4754                         r->group_attrs = NULL;
4755                 }
4756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4757                 if (_ptr_sids) {
4758                         NDR_PULL_ALLOC(ndr, r->sids);
4759                 } else {
4760                         r->sids = NULL;
4761                 }
4762                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4763         }
4764         if (ndr_flags & NDR_BUFFERS) {
4765                 if (r->info_array) {
4766                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4767                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4769                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4770                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4771                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4772                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4773                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4774                                 if (_ptr_info_array) {
4775                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4776                                 } else {
4777                                         r->info_array[cntr_info_array_1] = NULL;
4778                                 }
4779                         }
4780                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4781                                 if (r->info_array[cntr_info_array_1]) {
4782                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4783                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4784                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4785                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4786                                 }
4787                         }
4788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4790                 }
4791                 if (r->group_attrs) {
4792                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4793                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4794                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4795                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4796                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4797                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4798                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4799                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4800                         }
4801                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4803                 }
4804                 if (r->sids) {
4805                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4806                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4807                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4808                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4809                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4810                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4811                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4812                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4813                                 if (_ptr_sids) {
4814                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4815                                 } else {
4816                                         r->sids[cntr_sids_1] = NULL;
4817                                 }
4818                         }
4819                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4820                                 if (r->sids[cntr_sids_1]) {
4821                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4822                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4823                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4824                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4825                                 }
4826                         }
4827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4829                 }
4830                 if (r->info_array) {
4831                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4832                 }
4833                 if (r->group_attrs) {
4834                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4835                 }
4836                 if (r->sids) {
4837                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4838                 }
4839         }
4840         return NDR_ERR_SUCCESS;
4841 }
4842
4843 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4844 {
4845         uint32_t cntr_info_array_1;
4846         uint32_t cntr_group_attrs_1;
4847         uint32_t cntr_sids_1;
4848         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4849         ndr->depth++;
4850         ndr_print_NTSTATUS(ndr, "status", r->status);
4851         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4852         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4853         ndr_print_ptr(ndr, "info_array", r->info_array);
4854         ndr->depth++;
4855         if (r->info_array) {
4856                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4857                 ndr->depth++;
4858                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4859                         char *idx_1=NULL;
4860                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4861                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4862                                 ndr->depth++;
4863                                 if (r->info_array[cntr_info_array_1]) {
4864                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4865                                 }
4866                                 ndr->depth--;
4867                                 free(idx_1);
4868                         }
4869                 }
4870                 ndr->depth--;
4871         }
4872         ndr->depth--;
4873         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4874         ndr->depth++;
4875         if (r->group_attrs) {
4876                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4877                 ndr->depth++;
4878                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4879                         char *idx_1=NULL;
4880                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4881                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4882                                 free(idx_1);
4883                         }
4884                 }
4885                 ndr->depth--;
4886         }
4887         ndr->depth--;
4888         ndr_print_ptr(ndr, "sids", r->sids);
4889         ndr->depth++;
4890         if (r->sids) {
4891                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4892                 ndr->depth++;
4893                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4894                         char *idx_1=NULL;
4895                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4896                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4897                                 ndr->depth++;
4898                                 if (r->sids[cntr_sids_1]) {
4899                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4900                                 }
4901                                 ndr->depth--;
4902                                 free(idx_1);
4903                         }
4904                 }
4905                 ndr->depth--;
4906         }
4907         ndr->depth--;
4908         ndr->depth--;
4909 }
4910
4911 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4912 {
4913         if (ndr_flags & NDR_SCALARS) {
4914                 int level = ndr_push_get_switch_value(ndr, r);
4915                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4916                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4917                 switch (level) {
4918                         case 1: {
4919                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4920                         break; }
4921
4922                         default:
4923                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4924                 }
4925         }
4926         if (ndr_flags & NDR_BUFFERS) {
4927                 int level = ndr_push_get_switch_value(ndr, r);
4928                 switch (level) {
4929                         case 1:
4930                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4931                         break;
4932
4933                         default:
4934                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4935                 }
4936         }
4937         return NDR_ERR_SUCCESS;
4938 }
4939
4940 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4941 {
4942         int level;
4943         int32_t _level;
4944         level = ndr_pull_get_switch_value(ndr, r);
4945         if (ndr_flags & NDR_SCALARS) {
4946                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4947                 if (_level != level) {
4948                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4949                 }
4950                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4951                 switch (level) {
4952                         case 1: {
4953                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4954                         break; }
4955
4956                         default:
4957                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4958                 }
4959         }
4960         if (ndr_flags & NDR_BUFFERS) {
4961                 switch (level) {
4962                         case 1:
4963                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4964                         break;
4965
4966                         default:
4967                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4968                 }
4969         }
4970         return NDR_ERR_SUCCESS;
4971 }
4972
4973 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4974 {
4975         int level;
4976         level = ndr_print_get_switch_value(ndr, r);
4977         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4978         switch (level) {
4979                 case 1:
4980                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4981                 break;
4982
4983                 default:
4984                         ndr_print_bad_level(ndr, name, level);
4985         }
4986 }
4987
4988 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4989 {
4990         uint32_t cntr_info_array_1;
4991         if (ndr_flags & NDR_SCALARS) {
4992                 NDR_CHECK(ndr_push_align(ndr, 5));
4993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4996                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4998                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4999         }
5000         if (ndr_flags & NDR_BUFFERS) {
5001                 if (r->info_array) {
5002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5003                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5004                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5005                         }
5006                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5007                                 if (r->info_array[cntr_info_array_1]) {
5008                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5009                                 }
5010                         }
5011                 }
5012                 if (r->domain) {
5013                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5014                 }
5015         }
5016         return NDR_ERR_SUCCESS;
5017 }
5018
5019 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5020 {
5021         uint32_t _ptr_info_array;
5022         uint32_t cntr_info_array_1;
5023         TALLOC_CTX *_mem_save_info_array_0;
5024         TALLOC_CTX *_mem_save_info_array_1;
5025         TALLOC_CTX *_mem_save_info_array_2;
5026         uint32_t _ptr_domain;
5027         TALLOC_CTX *_mem_save_domain_0;
5028         if (ndr_flags & NDR_SCALARS) {
5029                 NDR_CHECK(ndr_pull_align(ndr, 5));
5030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5031                 if (r->count < 1 || r->count > 10000) {
5032                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5033                 }
5034                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5035                 if (_ptr_info_array) {
5036                         NDR_PULL_ALLOC(ndr, r->info_array);
5037                 } else {
5038                         r->info_array = NULL;
5039                 }
5040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5041                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5043                 if (_ptr_domain) {
5044                         NDR_PULL_ALLOC(ndr, r->domain);
5045                 } else {
5046                         r->domain = NULL;
5047                 }
5048                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5049         }
5050         if (ndr_flags & NDR_BUFFERS) {
5051                 if (r->info_array) {
5052                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5053                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5055                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5056                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5057                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5058                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5059                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5060                                 if (_ptr_info_array) {
5061                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5062                                 } else {
5063                                         r->info_array[cntr_info_array_1] = NULL;
5064                                 }
5065                         }
5066                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5067                                 if (r->info_array[cntr_info_array_1]) {
5068                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5069                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5070                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5071                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5072                                 }
5073                         }
5074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5076                 }
5077                 if (r->domain) {
5078                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5079                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5080                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5082                 }
5083                 if (r->info_array) {
5084                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5085                 }
5086         }
5087         return NDR_ERR_SUCCESS;
5088 }
5089
5090 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5091 {
5092         uint32_t cntr_info_array_1;
5093         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5094         ndr->depth++;
5095         ndr_print_uint32(ndr, "count", r->count);
5096         ndr_print_ptr(ndr, "info_array", r->info_array);
5097         ndr->depth++;
5098         if (r->info_array) {
5099                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5100                 ndr->depth++;
5101                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5102                         char *idx_1=NULL;
5103                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5104                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5105                                 ndr->depth++;
5106                                 if (r->info_array[cntr_info_array_1]) {
5107                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5108                                 }
5109                                 ndr->depth--;
5110                                 free(idx_1);
5111                         }
5112                 }
5113                 ndr->depth--;
5114         }
5115         ndr->depth--;
5116         ndr_print_uint32(ndr, "flags", r->flags);
5117         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5118         ndr_print_ptr(ndr, "domain", r->domain);
5119         ndr->depth++;
5120         if (r->domain) {
5121                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5122         }
5123         ndr->depth--;
5124         ndr->depth--;
5125 }
5126
5127 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5128 {
5129         if (ndr_flags & NDR_SCALARS) {
5130                 int level = ndr_push_get_switch_value(ndr, r);
5131                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5132                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5133                 switch (level) {
5134                         case 1: {
5135                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5136                         break; }
5137
5138                         default:
5139                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5140                 }
5141         }
5142         if (ndr_flags & NDR_BUFFERS) {
5143                 int level = ndr_push_get_switch_value(ndr, r);
5144                 switch (level) {
5145                         case 1:
5146                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5147                         break;
5148
5149                         default:
5150                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5151                 }
5152         }
5153         return NDR_ERR_SUCCESS;
5154 }
5155
5156 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5157 {
5158         int level;
5159         int32_t _level;
5160         level = ndr_pull_get_switch_value(ndr, r);
5161         if (ndr_flags & NDR_SCALARS) {
5162                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5163                 if (_level != level) {
5164                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5165                 }
5166                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5167                 switch (level) {
5168                         case 1: {
5169                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5170                         break; }
5171
5172                         default:
5173                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5174                 }
5175         }
5176         if (ndr_flags & NDR_BUFFERS) {
5177                 switch (level) {
5178                         case 1:
5179                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5180                         break;
5181
5182                         default:
5183                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5184                 }
5185         }
5186         return NDR_ERR_SUCCESS;
5187 }
5188
5189 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5190 {
5191         int level;
5192         level = ndr_print_get_switch_value(ndr, r);
5193         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5194         switch (level) {
5195                 case 1:
5196                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5197                 break;
5198
5199                 default:
5200                         ndr_print_bad_level(ndr, name, level);
5201         }
5202 }
5203
5204 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5205 {
5206         if (ndr_flags & NDR_SCALARS) {
5207                 NDR_CHECK(ndr_push_align(ndr, 5));
5208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5212                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5213         }
5214         if (ndr_flags & NDR_BUFFERS) {
5215                 if (r->data) {
5216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5217                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5218                 }
5219         }
5220         return NDR_ERR_SUCCESS;
5221 }
5222
5223 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5224 {
5225         uint32_t _ptr_data;
5226         TALLOC_CTX *_mem_save_data_0;
5227         if (ndr_flags & NDR_SCALARS) {
5228                 NDR_CHECK(ndr_pull_align(ndr, 5));
5229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5232                 if (r->length > 0x00A00000) {
5233                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5234                 }
5235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5236                 if (_ptr_data) {
5237                         NDR_PULL_ALLOC(ndr, r->data);
5238                 } else {
5239                         r->data = NULL;
5240                 }
5241                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5242         }
5243         if (ndr_flags & NDR_BUFFERS) {
5244                 if (r->data) {
5245                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5246                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5248                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5249                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5251                 }
5252                 if (r->data) {
5253                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5254                 }
5255         }
5256         return NDR_ERR_SUCCESS;
5257 }
5258
5259 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5260 {
5261         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5262         ndr->depth++;
5263         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5264         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5265         ndr_print_uint32(ndr, "length", r->length);
5266         ndr_print_ptr(ndr, "data", r->data);
5267         ndr->depth++;
5268         if (r->data) {
5269                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5270         }
5271         ndr->depth--;
5272         ndr->depth--;
5273 }
5274
5275 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5276 {
5277         if (ndr_flags & NDR_SCALARS) {
5278                 int level = ndr_push_get_switch_value(ndr, r);
5279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5280                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5281                 switch (level) {
5282                         case 1: {
5283                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5284                         break; }
5285
5286                         default:
5287                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5288                 }
5289         }
5290         if (ndr_flags & NDR_BUFFERS) {
5291                 int level = ndr_push_get_switch_value(ndr, r);
5292                 switch (level) {
5293                         case 1:
5294                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5295                         break;
5296
5297                         default:
5298                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5299                 }
5300         }
5301         return NDR_ERR_SUCCESS;
5302 }
5303
5304 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5305 {
5306         int level;
5307         uint32_t _level;
5308         level = ndr_pull_get_switch_value(ndr, r);
5309         if (ndr_flags & NDR_SCALARS) {
5310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5311                 if (_level != level) {
5312                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5313                 }
5314                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5315                 switch (level) {
5316                         case 1: {
5317                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5318                         break; }
5319
5320                         default:
5321                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5322                 }
5323         }
5324         if (ndr_flags & NDR_BUFFERS) {
5325                 switch (level) {
5326                         case 1:
5327                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5328                         break;
5329
5330                         default:
5331                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5332                 }
5333         }
5334         return NDR_ERR_SUCCESS;
5335 }
5336
5337 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5338 {
5339         int level;
5340         level = ndr_print_get_switch_value(ndr, r);
5341         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5342         switch (level) {
5343                 case 1:
5344                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5345                 break;
5346
5347                 default:
5348                         ndr_print_bad_level(ndr, name, level);
5349         }
5350 }
5351
5352 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5353 {
5354         if (ndr_flags & NDR_SCALARS) {
5355                 NDR_CHECK(ndr_push_align(ndr, 8));
5356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5358                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5359                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5360                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5361                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5362                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5363                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5364                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5367                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5368         }
5369         if (ndr_flags & NDR_BUFFERS) {
5370                 if (r->data1) {
5371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5372                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5373                 }
5374                 if (r->data2) {
5375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5376                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5377                 }
5378         }
5379         return NDR_ERR_SUCCESS;
5380 }
5381
5382 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5383 {
5384         uint32_t _ptr_data1;
5385         TALLOC_CTX *_mem_save_data1_0;
5386         uint32_t _ptr_data2;
5387         TALLOC_CTX *_mem_save_data2_0;
5388         if (ndr_flags & NDR_SCALARS) {
5389                 NDR_CHECK(ndr_pull_align(ndr, 8));
5390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5391                 if (r->length1 > 0x00A00000) {
5392                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5393                 }
5394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5395                 if (r->length2 > 0x00A00000) {
5396                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5397                 }
5398                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5399                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5400                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5401                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5402                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5403                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5404                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5406                 if (_ptr_data1) {
5407                         NDR_PULL_ALLOC(ndr, r->data1);
5408                 } else {
5409                         r->data1 = NULL;
5410                 }
5411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5412                 if (_ptr_data2) {
5413                         NDR_PULL_ALLOC(ndr, r->data2);
5414                 } else {
5415                         r->data2 = NULL;
5416                 }
5417                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5418         }
5419         if (ndr_flags & NDR_BUFFERS) {
5420                 if (r->data1) {
5421                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5422                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5424                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5425                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5427                 }
5428                 if (r->data2) {
5429                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5430                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5432                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5433                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5435                 }
5436                 if (r->data1) {
5437                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5438                 }
5439                 if (r->data2) {
5440                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5441                 }
5442         }
5443         return NDR_ERR_SUCCESS;
5444 }
5445
5446 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5447 {
5448         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5449         ndr->depth++;
5450         ndr_print_uint32(ndr, "length1", r->length1);
5451         ndr_print_uint32(ndr, "length2", r->length2);
5452         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5453         ndr_print_NTTIME(ndr, "time2", r->time2);
5454         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5455         ndr_print_NTTIME(ndr, "time4", r->time4);
5456         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5457         ndr_print_NTTIME(ndr, "time6", r->time6);
5458         ndr_print_NTSTATUS(ndr, "status", r->status);
5459         ndr_print_ptr(ndr, "data1", r->data1);
5460         ndr->depth++;
5461         if (r->data1) {
5462                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5463         }
5464         ndr->depth--;
5465         ndr_print_ptr(ndr, "data2", r->data2);
5466         ndr->depth++;
5467         if (r->data2) {
5468                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5469         }
5470         ndr->depth--;
5471         ndr->depth--;
5472 }
5473
5474 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5475 {
5476         if (ndr_flags & NDR_SCALARS) {
5477                 int level = ndr_push_get_switch_value(ndr, r);
5478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5479                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5480                 switch (level) {
5481                         case 1: {
5482                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5483                         break; }
5484
5485                         default:
5486                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5487                 }
5488         }
5489         if (ndr_flags & NDR_BUFFERS) {
5490                 int level = ndr_push_get_switch_value(ndr, r);
5491                 switch (level) {
5492                         case 1:
5493                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5494                         break;
5495
5496                         default:
5497                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5498                 }
5499         }
5500         return NDR_ERR_SUCCESS;
5501 }
5502
5503 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5504 {
5505         int level;
5506         uint32_t _level;
5507         level = ndr_pull_get_switch_value(ndr, r);
5508         if (ndr_flags & NDR_SCALARS) {
5509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5510                 if (_level != level) {
5511                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5512                 }
5513                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5514                 switch (level) {
5515                         case 1: {
5516                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5517                         break; }
5518
5519                         default:
5520                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5521                 }
5522         }
5523         if (ndr_flags & NDR_BUFFERS) {
5524                 switch (level) {
5525                         case 1:
5526                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5527                         break;
5528
5529                         default:
5530                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5531                 }
5532         }
5533         return NDR_ERR_SUCCESS;
5534 }
5535
5536 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5537 {
5538         int level;
5539         level = ndr_print_get_switch_value(ndr, r);
5540         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5541         switch (level) {
5542                 case 1:
5543                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5544                 break;
5545
5546                 default:
5547                         ndr_print_bad_level(ndr, name, level);
5548         }
5549 }
5550
5551 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5552 {
5553         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5554         return NDR_ERR_SUCCESS;
5555 }
5556
5557 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5558 {
5559         uint32_t v;
5560         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5561         *r = v;
5562         return NDR_ERR_SUCCESS;
5563 }
5564
5565 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5566 {
5567         const char *val = NULL;
5568
5569         switch (r) {
5570                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5571                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5572                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5573                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5574                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5575                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5576                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5577                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5578         }
5579         ndr_print_enum(ndr, name, "ENUM", val, r);
5580 }
5581
5582 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5583 {
5584         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5585         return NDR_ERR_SUCCESS;
5586 }
5587
5588 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5589 {
5590         uint32_t v;
5591         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5592         *r = v;
5593         return NDR_ERR_SUCCESS;
5594 }
5595
5596 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5597 {
5598         const char *val = NULL;
5599
5600         switch (r) {
5601                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5602                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5603                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5604                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5605                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5606         }
5607         ndr_print_enum(ndr, name, "ENUM", val, r);
5608 }
5609
5610 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5611 {
5612         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5613         return NDR_ERR_SUCCESS;
5614 }
5615
5616 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5617 {
5618         uint32_t v;
5619         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5620         *r = v;
5621         return NDR_ERR_SUCCESS;
5622 }
5623
5624 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5625 {
5626         const char *val = NULL;
5627
5628         switch (r) {
5629                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5630                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5631                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5632                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5633                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5634                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5635                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5636                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5637                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5638                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5639                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5640         }
5641         ndr_print_enum(ndr, name, "ENUM", val, r);
5642 }
5643
5644 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5645 {
5646         if (ndr_flags & NDR_SCALARS) {
5647                 NDR_CHECK(ndr_push_align(ndr, 5));
5648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5649                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5650         }
5651         if (ndr_flags & NDR_BUFFERS) {
5652                 if (r->str) {
5653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5656                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5657                 }
5658         }
5659         return NDR_ERR_SUCCESS;
5660 }
5661
5662 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5663 {
5664         uint32_t _ptr_str;
5665         TALLOC_CTX *_mem_save_str_0;
5666         if (ndr_flags & NDR_SCALARS) {
5667                 NDR_CHECK(ndr_pull_align(ndr, 5));
5668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5669                 if (_ptr_str) {
5670                         NDR_PULL_ALLOC(ndr, r->str);
5671                 } else {
5672                         r->str = NULL;
5673                 }
5674                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5675         }
5676         if (ndr_flags & NDR_BUFFERS) {
5677                 if (r->str) {
5678                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5679                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5680                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5681                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5682                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5683                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->str), ndr_get_array_length(ndr, &r->str));
5684                         }
5685                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5686                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5688                 }
5689         }
5690         return NDR_ERR_SUCCESS;
5691 }
5692
5693 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5694 {
5695         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5696         ndr->depth++;
5697         ndr_print_ptr(ndr, "str", r->str);
5698         ndr->depth++;
5699         if (r->str) {
5700                 ndr_print_string(ndr, "str", r->str);
5701         }
5702         ndr->depth--;
5703         ndr->depth--;
5704 }
5705
5706 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5707 {
5708         uint32_t cntr_names_1;
5709         if (ndr_flags & NDR_SCALARS) {
5710                 NDR_CHECK(ndr_push_align(ndr, 5));
5711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5713                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5714                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5715                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5718                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5719         }
5720         if (ndr_flags & NDR_BUFFERS) {
5721                 if (r->names) {
5722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5723                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5724                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5725                         }
5726                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5727                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5728                         }
5729                 }
5730         }
5731         return NDR_ERR_SUCCESS;
5732 }
5733
5734 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5735 {
5736         uint32_t _ptr_names;
5737         uint32_t cntr_names_1;
5738         TALLOC_CTX *_mem_save_names_0;
5739         TALLOC_CTX *_mem_save_names_1;
5740         if (ndr_flags & NDR_SCALARS) {
5741                 NDR_CHECK(ndr_pull_align(ndr, 5));
5742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5744                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5745                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5746                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5748                 if (r->count < 1 || r->count > 10000) {
5749                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5750                 }
5751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5752                 if (_ptr_names) {
5753                         NDR_PULL_ALLOC(ndr, r->names);
5754                 } else {
5755                         r->names = NULL;
5756                 }
5757                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5758         }
5759         if (ndr_flags & NDR_BUFFERS) {
5760                 if (r->names) {
5761                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5762                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5764                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5765                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5766                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5767                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5768                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5769                         }
5770                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5771                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5772                         }
5773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5775                 }
5776                 if (r->names) {
5777                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5778                 }
5779         }
5780         return NDR_ERR_SUCCESS;
5781 }
5782
5783 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5784 {
5785         uint32_t cntr_names_1;
5786         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5787         ndr->depth++;
5788         ndr_print_uint32(ndr, "codepage", r->codepage);
5789         ndr_print_uint32(ndr, "language", r->language);
5790         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5791         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5792         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5793         ndr_print_uint32(ndr, "count", r->count);
5794         ndr_print_ptr(ndr, "names", r->names);
5795         ndr->depth++;
5796         if (r->names) {
5797                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5798                 ndr->depth++;
5799                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5800                         char *idx_1=NULL;
5801                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5802                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5803                                 free(idx_1);
5804                         }
5805                 }
5806                 ndr->depth--;
5807         }
5808         ndr->depth--;
5809         ndr->depth--;
5810 }
5811
5812 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5813 {
5814         if (ndr_flags & NDR_SCALARS) {
5815                 int level = ndr_push_get_switch_value(ndr, r);
5816                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5817                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5818                 switch (level) {
5819                         case 1: {
5820                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5821                         break; }
5822
5823                         default:
5824                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5825                 }
5826         }
5827         if (ndr_flags & NDR_BUFFERS) {
5828                 int level = ndr_push_get_switch_value(ndr, r);
5829                 switch (level) {
5830                         case 1:
5831                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5832                         break;
5833
5834                         default:
5835                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5836                 }
5837         }
5838         return NDR_ERR_SUCCESS;
5839 }
5840
5841 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5842 {
5843         int level;
5844         int32_t _level;
5845         level = ndr_pull_get_switch_value(ndr, r);
5846         if (ndr_flags & NDR_SCALARS) {
5847                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5848                 if (_level != level) {
5849                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5850                 }
5851                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5852                 switch (level) {
5853                         case 1: {
5854                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5855                         break; }
5856
5857                         default:
5858                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5859                 }
5860         }
5861         if (ndr_flags & NDR_BUFFERS) {
5862                 switch (level) {
5863                         case 1:
5864                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5865                         break;
5866
5867                         default:
5868                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5869                 }
5870         }
5871         return NDR_ERR_SUCCESS;
5872 }
5873
5874 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5875 {
5876         int level;
5877         level = ndr_print_get_switch_value(ndr, r);
5878         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5879         switch (level) {
5880                 case 1:
5881                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5882                 break;
5883
5884                 default:
5885                         ndr_print_bad_level(ndr, name, level);
5886         }
5887 }
5888
5889 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5890 {
5891         if (ndr_flags & NDR_SCALARS) {
5892                 NDR_CHECK(ndr_push_align(ndr, 5));
5893                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5896                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5897         }
5898         if (ndr_flags & NDR_BUFFERS) {
5899                 if (r->dns_domain_name) {
5900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_domain_name, ndr_charset_length(r->dns_domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5904                 }
5905                 if (r->result_name) {
5906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5910                 }
5911         }
5912         return NDR_ERR_SUCCESS;
5913 }
5914
5915 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5916 {
5917         uint32_t _ptr_dns_domain_name;
5918         TALLOC_CTX *_mem_save_dns_domain_name_0;
5919         uint32_t _ptr_result_name;
5920         TALLOC_CTX *_mem_save_result_name_0;
5921         if (ndr_flags & NDR_SCALARS) {
5922                 NDR_CHECK(ndr_pull_align(ndr, 5));
5923                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5924                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5925                 if (_ptr_dns_domain_name) {
5926                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5927                 } else {
5928                         r->dns_domain_name = NULL;
5929                 }
5930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5931                 if (_ptr_result_name) {
5932                         NDR_PULL_ALLOC(ndr, r->result_name);
5933                 } else {
5934                         r->result_name = NULL;
5935                 }
5936                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5937         }
5938         if (ndr_flags & NDR_BUFFERS) {
5939                 if (r->dns_domain_name) {
5940                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5941                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5942                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5943                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5944                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5945                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_domain_name), ndr_get_array_length(ndr, &r->dns_domain_name));
5946                         }
5947                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5948                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_domain_name, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t), CH_UTF16));
5949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5950                 }
5951                 if (r->result_name) {
5952                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5953                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5956                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5957                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->result_name), ndr_get_array_length(ndr, &r->result_name));
5958                         }
5959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5962                 }
5963         }
5964         return NDR_ERR_SUCCESS;
5965 }
5966
5967 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5968 {
5969         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5970         ndr->depth++;
5971         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5972         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5973         ndr->depth++;
5974         if (r->dns_domain_name) {
5975                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5976         }
5977         ndr->depth--;
5978         ndr_print_ptr(ndr, "result_name", r->result_name);
5979         ndr->depth++;
5980         if (r->result_name) {
5981                 ndr_print_string(ndr, "result_name", r->result_name);
5982         }
5983         ndr->depth--;
5984         ndr->depth--;
5985 }
5986
5987 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5988 {
5989         uint32_t cntr_array_1;
5990         if (ndr_flags & NDR_SCALARS) {
5991                 NDR_CHECK(ndr_push_align(ndr, 5));
5992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5994                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5995         }
5996         if (ndr_flags & NDR_BUFFERS) {
5997                 if (r->array) {
5998                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5999                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6000                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6001                         }
6002                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6003                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6004                         }
6005                 }
6006         }
6007         return NDR_ERR_SUCCESS;
6008 }
6009
6010 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6011 {
6012         uint32_t _ptr_array;
6013         uint32_t cntr_array_1;
6014         TALLOC_CTX *_mem_save_array_0;
6015         TALLOC_CTX *_mem_save_array_1;
6016         if (ndr_flags & NDR_SCALARS) {
6017                 NDR_CHECK(ndr_pull_align(ndr, 5));
6018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6020                 if (_ptr_array) {
6021                         NDR_PULL_ALLOC(ndr, r->array);
6022                 } else {
6023                         r->array = NULL;
6024                 }
6025                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6026         }
6027         if (ndr_flags & NDR_BUFFERS) {
6028                 if (r->array) {
6029                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6030                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6032                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6033                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6034                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6035                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6036                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6037                         }
6038                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6039                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6040                         }
6041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6043                 }
6044                 if (r->array) {
6045                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6046                 }
6047         }
6048         return NDR_ERR_SUCCESS;
6049 }
6050
6051 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6052 {
6053         uint32_t cntr_array_1;
6054         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6055         ndr->depth++;
6056         ndr_print_uint32(ndr, "count", r->count);
6057         ndr_print_ptr(ndr, "array", r->array);
6058         ndr->depth++;
6059         if (r->array) {
6060                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6061                 ndr->depth++;
6062                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6063                         char *idx_1=NULL;
6064                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6065                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6066                                 free(idx_1);
6067                         }
6068                 }
6069                 ndr->depth--;
6070         }
6071         ndr->depth--;
6072         ndr->depth--;
6073 }
6074
6075 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6076 {
6077         if (ndr_flags & NDR_SCALARS) {
6078                 int level = ndr_push_get_switch_value(ndr, r);
6079                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6080                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6081                 switch (level) {
6082                         case 1: {
6083                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6084                         break; }
6085
6086                         default:
6087                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6088                 }
6089         }
6090         if (ndr_flags & NDR_BUFFERS) {
6091                 int level = ndr_push_get_switch_value(ndr, r);
6092                 switch (level) {
6093                         case 1:
6094                                 if (r->ctr1) {
6095                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6096                                 }
6097                         break;
6098
6099                         default:
6100                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6101                 }
6102         }
6103         return NDR_ERR_SUCCESS;
6104 }
6105
6106 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6107 {
6108         int level;
6109         int32_t _level;
6110         TALLOC_CTX *_mem_save_ctr1_0;
6111         level = ndr_pull_get_switch_value(ndr, r);
6112         if (ndr_flags & NDR_SCALARS) {
6113                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6114                 if (_level != level) {
6115                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6116                 }
6117                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6118                 switch (level) {
6119                         case 1: {
6120                                 uint32_t _ptr_ctr1;
6121                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6122                                 if (_ptr_ctr1) {
6123                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6124                                 } else {
6125                                         r->ctr1 = NULL;
6126                                 }
6127                         break; }
6128
6129                         default:
6130                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6131                 }
6132         }
6133         if (ndr_flags & NDR_BUFFERS) {
6134                 switch (level) {
6135                         case 1:
6136                                 if (r->ctr1) {
6137                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6138                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6139                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6140                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6141                                 }
6142                         break;
6143
6144                         default:
6145                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6146                 }
6147         }
6148         return NDR_ERR_SUCCESS;
6149 }
6150
6151 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6152 {
6153         int level;
6154         level = ndr_print_get_switch_value(ndr, r);
6155         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6156         switch (level) {
6157                 case 1:
6158                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6159                         ndr->depth++;
6160                         if (r->ctr1) {
6161                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6162                         }
6163                         ndr->depth--;
6164                 break;
6165
6166                 default:
6167                         ndr_print_bad_level(ndr, name, level);
6168         }
6169 }
6170
6171 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6172 {
6173         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6174         return NDR_ERR_SUCCESS;
6175 }
6176
6177 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6178 {
6179         uint32_t v;
6180         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6181         *r = v;
6182         return NDR_ERR_SUCCESS;
6183 }
6184
6185 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6186 {
6187         const char *val = NULL;
6188
6189         switch (r) {
6190                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6191                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6192                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6193         }
6194         ndr_print_enum(ndr, name, "ENUM", val, r);
6195 }
6196
6197 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6198 {
6199         uint32_t cntr_spn_names_1;
6200         if (ndr_flags & NDR_SCALARS) {
6201                 NDR_CHECK(ndr_push_align(ndr, 5));
6202                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6207                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6208         }
6209         if (ndr_flags & NDR_BUFFERS) {
6210                 if (r->object_dn) {
6211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6214                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6215                 }
6216                 if (r->spn_names) {
6217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6218                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6219                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6220                         }
6221                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6222                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6223                         }
6224                 }
6225         }
6226         return NDR_ERR_SUCCESS;
6227 }
6228
6229 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6230 {
6231         uint32_t _ptr_object_dn;
6232         TALLOC_CTX *_mem_save_object_dn_0;
6233         uint32_t _ptr_spn_names;
6234         uint32_t cntr_spn_names_1;
6235         TALLOC_CTX *_mem_save_spn_names_0;
6236         TALLOC_CTX *_mem_save_spn_names_1;
6237         if (ndr_flags & NDR_SCALARS) {
6238                 NDR_CHECK(ndr_pull_align(ndr, 5));
6239                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6242                 if (_ptr_object_dn) {
6243                         NDR_PULL_ALLOC(ndr, r->object_dn);
6244                 } else {
6245                         r->object_dn = NULL;
6246                 }
6247                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6248                 if (r->count > 10000) {
6249                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6250                 }
6251                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6252                 if (_ptr_spn_names) {
6253                         NDR_PULL_ALLOC(ndr, r->spn_names);
6254                 } else {
6255                         r->spn_names = NULL;
6256                 }
6257                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6258         }
6259         if (ndr_flags & NDR_BUFFERS) {
6260                 if (r->object_dn) {
6261                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6262                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6265                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6266                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
6267                         }
6268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6271                 }
6272                 if (r->spn_names) {
6273                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6274                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6276                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6277                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6278                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6279                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6280                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6281                         }
6282                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6283                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6284                         }
6285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6287                 }
6288                 if (r->spn_names) {
6289                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6290                 }
6291         }
6292         return NDR_ERR_SUCCESS;
6293 }
6294
6295 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6296 {
6297         uint32_t cntr_spn_names_1;
6298         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6299         ndr->depth++;
6300         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6301         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6302         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6303         ndr->depth++;
6304         if (r->object_dn) {
6305                 ndr_print_string(ndr, "object_dn", r->object_dn);
6306         }
6307         ndr->depth--;
6308         ndr_print_uint32(ndr, "count", r->count);
6309         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6310         ndr->depth++;
6311         if (r->spn_names) {
6312                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6313                 ndr->depth++;
6314                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6315                         char *idx_1=NULL;
6316                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6317                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6318                                 free(idx_1);
6319                         }
6320                 }
6321                 ndr->depth--;
6322         }
6323         ndr->depth--;
6324         ndr->depth--;
6325 }
6326
6327 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6328 {
6329         if (ndr_flags & NDR_SCALARS) {
6330                 int level = ndr_push_get_switch_value(ndr, r);
6331                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6332                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6333                 switch (level) {
6334                         case 1: {
6335                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6336                         break; }
6337
6338                         default:
6339                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6340                 }
6341         }
6342         if (ndr_flags & NDR_BUFFERS) {
6343                 int level = ndr_push_get_switch_value(ndr, r);
6344                 switch (level) {
6345                         case 1:
6346                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6347                         break;
6348
6349                         default:
6350                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6351                 }
6352         }
6353         return NDR_ERR_SUCCESS;
6354 }
6355
6356 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6357 {
6358         int level;
6359         int32_t _level;
6360         level = ndr_pull_get_switch_value(ndr, r);
6361         if (ndr_flags & NDR_SCALARS) {
6362                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6363                 if (_level != level) {
6364                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6365                 }
6366                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6367                 switch (level) {
6368                         case 1: {
6369                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6370                         break; }
6371
6372                         default:
6373                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6374                 }
6375         }
6376         if (ndr_flags & NDR_BUFFERS) {
6377                 switch (level) {
6378                         case 1:
6379                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6380                         break;
6381
6382                         default:
6383                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6384                 }
6385         }
6386         return NDR_ERR_SUCCESS;
6387 }
6388
6389 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6390 {
6391         int level;
6392         level = ndr_print_get_switch_value(ndr, r);
6393         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6394         switch (level) {
6395                 case 1:
6396                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6397                 break;
6398
6399                 default:
6400                         ndr_print_bad_level(ndr, name, level);
6401         }
6402 }
6403
6404 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6405 {
6406         if (ndr_flags & NDR_SCALARS) {
6407                 NDR_CHECK(ndr_push_align(ndr, 4));
6408                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6409                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6410         }
6411         if (ndr_flags & NDR_BUFFERS) {
6412         }
6413         return NDR_ERR_SUCCESS;
6414 }
6415
6416 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6417 {
6418         if (ndr_flags & NDR_SCALARS) {
6419                 NDR_CHECK(ndr_pull_align(ndr, 4));
6420                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6421                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6422         }
6423         if (ndr_flags & NDR_BUFFERS) {
6424         }
6425         return NDR_ERR_SUCCESS;
6426 }
6427
6428 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6429 {
6430         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6431         ndr->depth++;
6432         ndr_print_WERROR(ndr, "status", r->status);
6433         ndr->depth--;
6434 }
6435
6436 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6437 {
6438         if (ndr_flags & NDR_SCALARS) {
6439                 int level = ndr_push_get_switch_value(ndr, r);
6440                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6441                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6442                 switch (level) {
6443                         case 1: {
6444                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6445                         break; }
6446
6447                         default:
6448                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6449                 }
6450         }
6451         if (ndr_flags & NDR_BUFFERS) {
6452                 int level = ndr_push_get_switch_value(ndr, r);
6453                 switch (level) {
6454                         case 1:
6455                         break;
6456
6457                         default:
6458                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6459                 }
6460         }
6461         return NDR_ERR_SUCCESS;
6462 }
6463
6464 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6465 {
6466         int level;
6467         int32_t _level;
6468         level = ndr_pull_get_switch_value(ndr, r);
6469         if (ndr_flags & NDR_SCALARS) {
6470                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6471                 if (_level != level) {
6472                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6473                 }
6474                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6475                 switch (level) {
6476                         case 1: {
6477                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6478                         break; }
6479
6480                         default:
6481                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6482                 }
6483         }
6484         if (ndr_flags & NDR_BUFFERS) {
6485                 switch (level) {
6486                         case 1:
6487                         break;
6488
6489                         default:
6490                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6491                 }
6492         }
6493         return NDR_ERR_SUCCESS;
6494 }
6495
6496 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6497 {
6498         int level;
6499         level = ndr_print_get_switch_value(ndr, r);
6500         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6501         switch (level) {
6502                 case 1:
6503                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6504                 break;
6505
6506                 default:
6507                         ndr_print_bad_level(ndr, name, level);
6508         }
6509 }
6510
6511 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6512 {
6513         if (ndr_flags & NDR_SCALARS) {
6514                 NDR_CHECK(ndr_push_align(ndr, 5));
6515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6518                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6519         }
6520         if (ndr_flags & NDR_BUFFERS) {
6521                 if (r->server_dn) {
6522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6525                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6526                 }
6527                 if (r->domain_dn) {
6528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6531                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6532                 }
6533         }
6534         return NDR_ERR_SUCCESS;
6535 }
6536
6537 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6538 {
6539         uint32_t _ptr_server_dn;
6540         TALLOC_CTX *_mem_save_server_dn_0;
6541         uint32_t _ptr_domain_dn;
6542         TALLOC_CTX *_mem_save_domain_dn_0;
6543         if (ndr_flags & NDR_SCALARS) {
6544                 NDR_CHECK(ndr_pull_align(ndr, 5));
6545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6546                 if (_ptr_server_dn) {
6547                         NDR_PULL_ALLOC(ndr, r->server_dn);
6548                 } else {
6549                         r->server_dn = NULL;
6550                 }
6551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6552                 if (_ptr_domain_dn) {
6553                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6554                 } else {
6555                         r->domain_dn = NULL;
6556                 }
6557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6559         }
6560         if (ndr_flags & NDR_BUFFERS) {
6561                 if (r->server_dn) {
6562                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6563                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6566                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
6568                         }
6569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6572                 }
6573                 if (r->domain_dn) {
6574                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6575                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6578                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6579                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_dn), ndr_get_array_length(ndr, &r->domain_dn));
6580                         }
6581                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6582                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6584                 }
6585         }
6586         return NDR_ERR_SUCCESS;
6587 }
6588
6589 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6590 {
6591         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6592         ndr->depth++;
6593         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6594         ndr->depth++;
6595         if (r->server_dn) {
6596                 ndr_print_string(ndr, "server_dn", r->server_dn);
6597         }
6598         ndr->depth--;
6599         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6600         ndr->depth++;
6601         if (r->domain_dn) {
6602                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6603         }
6604         ndr->depth--;
6605         ndr_print_uint32(ndr, "commit", r->commit);
6606         ndr->depth--;
6607 }
6608
6609 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6610 {
6611         if (ndr_flags & NDR_SCALARS) {
6612                 int level = ndr_push_get_switch_value(ndr, r);
6613                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6614                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6615                 switch (level) {
6616                         case 1: {
6617                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6618                         break; }
6619
6620                         default:
6621                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6622                 }
6623         }
6624         if (ndr_flags & NDR_BUFFERS) {
6625                 int level = ndr_push_get_switch_value(ndr, r);
6626                 switch (level) {
6627                         case 1:
6628                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6629                         break;
6630
6631                         default:
6632                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6633                 }
6634         }
6635         return NDR_ERR_SUCCESS;
6636 }
6637
6638 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6639 {
6640         int level;
6641         int32_t _level;
6642         level = ndr_pull_get_switch_value(ndr, r);
6643         if (ndr_flags & NDR_SCALARS) {
6644                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6645                 if (_level != level) {
6646                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6647                 }
6648                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6649                 switch (level) {
6650                         case 1: {
6651                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6652                         break; }
6653
6654                         default:
6655                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6656                 }
6657         }
6658         if (ndr_flags & NDR_BUFFERS) {
6659                 switch (level) {
6660                         case 1:
6661                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6662                         break;
6663
6664                         default:
6665                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6666                 }
6667         }
6668         return NDR_ERR_SUCCESS;
6669 }
6670
6671 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6672 {
6673         int level;
6674         level = ndr_print_get_switch_value(ndr, r);
6675         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6676         switch (level) {
6677                 case 1:
6678                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6679                 break;
6680
6681                 default:
6682                         ndr_print_bad_level(ndr, name, level);
6683         }
6684 }
6685
6686 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6687 {
6688         if (ndr_flags & NDR_SCALARS) {
6689                 NDR_CHECK(ndr_push_align(ndr, 4));
6690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6691                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6692         }
6693         if (ndr_flags & NDR_BUFFERS) {
6694         }
6695         return NDR_ERR_SUCCESS;
6696 }
6697
6698 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6699 {
6700         if (ndr_flags & NDR_SCALARS) {
6701                 NDR_CHECK(ndr_pull_align(ndr, 4));
6702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6703                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6704         }
6705         if (ndr_flags & NDR_BUFFERS) {
6706         }
6707         return NDR_ERR_SUCCESS;
6708 }
6709
6710 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6711 {
6712         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6713         ndr->depth++;
6714         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6715         ndr->depth--;
6716 }
6717
6718 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6719 {
6720         if (ndr_flags & NDR_SCALARS) {
6721                 int level = ndr_push_get_switch_value(ndr, r);
6722                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6723                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6724                 switch (level) {
6725                         case 1: {
6726                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6727                         break; }
6728
6729                         default:
6730                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6731                 }
6732         }
6733         if (ndr_flags & NDR_BUFFERS) {
6734                 int level = ndr_push_get_switch_value(ndr, r);
6735                 switch (level) {
6736                         case 1:
6737                         break;
6738
6739                         default:
6740                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6741                 }
6742         }
6743         return NDR_ERR_SUCCESS;
6744 }
6745
6746 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6747 {
6748         int level;
6749         int32_t _level;
6750         level = ndr_pull_get_switch_value(ndr, r);
6751         if (ndr_flags & NDR_SCALARS) {
6752                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6753                 if (_level != level) {
6754                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6755                 }
6756                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6757                 switch (level) {
6758                         case 1: {
6759                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6760                         break; }
6761
6762                         default:
6763                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6764                 }
6765         }
6766         if (ndr_flags & NDR_BUFFERS) {
6767                 switch (level) {
6768                         case 1:
6769                         break;
6770
6771                         default:
6772                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6773                 }
6774         }
6775         return NDR_ERR_SUCCESS;
6776 }
6777
6778 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6779 {
6780         int level;
6781         level = ndr_print_get_switch_value(ndr, r);
6782         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6783         switch (level) {
6784                 case 1:
6785                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6786                 break;
6787
6788                 default:
6789                         ndr_print_bad_level(ndr, name, level);
6790         }
6791 }
6792
6793 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6794 {
6795         if (ndr_flags & NDR_SCALARS) {
6796                 NDR_CHECK(ndr_push_align(ndr, 5));
6797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6798                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6799                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6800         }
6801         if (ndr_flags & NDR_BUFFERS) {
6802                 if (r->domain_name) {
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6806                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6807                 }
6808         }
6809         return NDR_ERR_SUCCESS;
6810 }
6811
6812 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6813 {
6814         uint32_t _ptr_domain_name;
6815         TALLOC_CTX *_mem_save_domain_name_0;
6816         if (ndr_flags & NDR_SCALARS) {
6817                 NDR_CHECK(ndr_pull_align(ndr, 5));
6818                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6819                 if (_ptr_domain_name) {
6820                         NDR_PULL_ALLOC(ndr, r->domain_name);
6821                 } else {
6822                         r->domain_name = NULL;
6823                 }
6824                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6825                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6826         }
6827         if (ndr_flags & NDR_BUFFERS) {
6828                 if (r->domain_name) {
6829                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6830                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6831                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6832                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6833                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6834                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
6835                         }
6836                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6837                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6839                 }
6840         }
6841         return NDR_ERR_SUCCESS;
6842 }
6843
6844 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6845 {
6846         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6847         ndr->depth++;
6848         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6849         ndr->depth++;
6850         if (r->domain_name) {
6851                 ndr_print_string(ndr, "domain_name", r->domain_name);
6852         }
6853         ndr->depth--;
6854         ndr_print_int32(ndr, "level", r->level);
6855         ndr->depth--;
6856 }
6857
6858 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6859 {
6860         if (ndr_flags & NDR_SCALARS) {
6861                 int level = ndr_push_get_switch_value(ndr, r);
6862                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6863                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6864                 switch (level) {
6865                         case 1: {
6866                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6867                         break; }
6868
6869                         default:
6870                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6871                 }
6872         }
6873         if (ndr_flags & NDR_BUFFERS) {
6874                 int level = ndr_push_get_switch_value(ndr, r);
6875                 switch (level) {
6876                         case 1:
6877                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6878                         break;
6879
6880                         default:
6881                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6882                 }
6883         }
6884         return NDR_ERR_SUCCESS;
6885 }
6886
6887 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6888 {
6889         int level;
6890         int32_t _level;
6891         level = ndr_pull_get_switch_value(ndr, r);
6892         if (ndr_flags & NDR_SCALARS) {
6893                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6894                 if (_level != level) {
6895                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6896                 }
6897                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6898                 switch (level) {
6899                         case 1: {
6900                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6901                         break; }
6902
6903                         default:
6904                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6905                 }
6906         }
6907         if (ndr_flags & NDR_BUFFERS) {
6908                 switch (level) {
6909                         case 1:
6910                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6911                         break;
6912
6913                         default:
6914                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6915                 }
6916         }
6917         return NDR_ERR_SUCCESS;
6918 }
6919
6920 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6921 {
6922         int level;
6923         level = ndr_print_get_switch_value(ndr, r);
6924         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6925         switch (level) {
6926                 case 1:
6927                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6928                 break;
6929
6930                 default:
6931                         ndr_print_bad_level(ndr, name, level);
6932         }
6933 }
6934
6935 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6936 {
6937         if (ndr_flags & NDR_SCALARS) {
6938                 NDR_CHECK(ndr_push_align(ndr, 5));
6939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6946                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6947         }
6948         if (ndr_flags & NDR_BUFFERS) {
6949                 if (r->netbios_name) {
6950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6951                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6952                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6953                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6954                 }
6955                 if (r->dns_name) {
6956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6959                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6960                 }
6961                 if (r->site_name) {
6962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6963                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6964                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6965                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6966                 }
6967                 if (r->computer_dn) {
6968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6969                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6971                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6972                 }
6973                 if (r->server_dn) {
6974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6975                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6976                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6977                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6978                 }
6979         }
6980         return NDR_ERR_SUCCESS;
6981 }
6982
6983 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6984 {
6985         uint32_t _ptr_netbios_name;
6986         TALLOC_CTX *_mem_save_netbios_name_0;
6987         uint32_t _ptr_dns_name;
6988         TALLOC_CTX *_mem_save_dns_name_0;
6989         uint32_t _ptr_site_name;
6990         TALLOC_CTX *_mem_save_site_name_0;
6991         uint32_t _ptr_computer_dn;
6992         TALLOC_CTX *_mem_save_computer_dn_0;
6993         uint32_t _ptr_server_dn;
6994         TALLOC_CTX *_mem_save_server_dn_0;
6995         if (ndr_flags & NDR_SCALARS) {
6996                 NDR_CHECK(ndr_pull_align(ndr, 5));
6997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6998                 if (_ptr_netbios_name) {
6999                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7000                 } else {
7001                         r->netbios_name = NULL;
7002                 }
7003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7004                 if (_ptr_dns_name) {
7005                         NDR_PULL_ALLOC(ndr, r->dns_name);
7006                 } else {
7007                         r->dns_name = NULL;
7008                 }
7009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7010                 if (_ptr_site_name) {
7011                         NDR_PULL_ALLOC(ndr, r->site_name);
7012                 } else {
7013                         r->site_name = NULL;
7014                 }
7015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7016                 if (_ptr_computer_dn) {
7017                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7018                 } else {
7019                         r->computer_dn = NULL;
7020                 }
7021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7022                 if (_ptr_server_dn) {
7023                         NDR_PULL_ALLOC(ndr, r->server_dn);
7024                 } else {
7025                         r->server_dn = NULL;
7026                 }
7027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7029                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7030         }
7031         if (ndr_flags & NDR_BUFFERS) {
7032                 if (r->netbios_name) {
7033                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7034                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7037                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7038                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7039                         }
7040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7041                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7043                 }
7044                 if (r->dns_name) {
7045                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7046                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7048                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7049                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7050                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7051                         }
7052                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7053                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7055                 }
7056                 if (r->site_name) {
7057                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7058                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7059                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7060                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7061                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7062                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_name), ndr_get_array_length(ndr, &r->site_name));
7063                         }
7064                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7065                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7067                 }
7068                 if (r->computer_dn) {
7069                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7070                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7073                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7074                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7075                         }
7076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7077                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7079                 }
7080                 if (r->server_dn) {
7081                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7082                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7083                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7084                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7085                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7086                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7087                         }
7088                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7089                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7091                 }
7092         }
7093         return NDR_ERR_SUCCESS;
7094 }
7095
7096 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7097 {
7098         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7099         ndr->depth++;
7100         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7101         ndr->depth++;
7102         if (r->netbios_name) {
7103                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7104         }
7105         ndr->depth--;
7106         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7107         ndr->depth++;
7108         if (r->dns_name) {
7109                 ndr_print_string(ndr, "dns_name", r->dns_name);
7110         }
7111         ndr->depth--;
7112         ndr_print_ptr(ndr, "site_name", r->site_name);
7113         ndr->depth++;
7114         if (r->site_name) {
7115                 ndr_print_string(ndr, "site_name", r->site_name);
7116         }
7117         ndr->depth--;
7118         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7119         ndr->depth++;
7120         if (r->computer_dn) {
7121                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7122         }
7123         ndr->depth--;
7124         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7125         ndr->depth++;
7126         if (r->server_dn) {
7127                 ndr_print_string(ndr, "server_dn", r->server_dn);
7128         }
7129         ndr->depth--;
7130         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7131         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7132         ndr->depth--;
7133 }
7134
7135 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7136 {
7137         uint32_t cntr_array_1;
7138         if (ndr_flags & NDR_SCALARS) {
7139                 NDR_CHECK(ndr_push_align(ndr, 5));
7140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7141                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7142                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7143         }
7144         if (ndr_flags & NDR_BUFFERS) {
7145                 if (r->array) {
7146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7147                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7148                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7149                         }
7150                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7151                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7152                         }
7153                 }
7154         }
7155         return NDR_ERR_SUCCESS;
7156 }
7157
7158 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7159 {
7160         uint32_t _ptr_array;
7161         uint32_t cntr_array_1;
7162         TALLOC_CTX *_mem_save_array_0;
7163         TALLOC_CTX *_mem_save_array_1;
7164         if (ndr_flags & NDR_SCALARS) {
7165                 NDR_CHECK(ndr_pull_align(ndr, 5));
7166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7167                 if (r->count > 10000) {
7168                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7169                 }
7170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7171                 if (_ptr_array) {
7172                         NDR_PULL_ALLOC(ndr, r->array);
7173                 } else {
7174                         r->array = NULL;
7175                 }
7176                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7177         }
7178         if (ndr_flags & NDR_BUFFERS) {
7179                 if (r->array) {
7180                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7181                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7182                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7183                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7184                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7185                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7186                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7187                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7188                         }
7189                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7190                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7191                         }
7192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7194                 }
7195                 if (r->array) {
7196                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7197                 }
7198         }
7199         return NDR_ERR_SUCCESS;
7200 }
7201
7202 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7203 {
7204         uint32_t cntr_array_1;
7205         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7206         ndr->depth++;
7207         ndr_print_uint32(ndr, "count", r->count);
7208         ndr_print_ptr(ndr, "array", r->array);
7209         ndr->depth++;
7210         if (r->array) {
7211                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7212                 ndr->depth++;
7213                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7214                         char *idx_1=NULL;
7215                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7216                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7217                                 free(idx_1);
7218                         }
7219                 }
7220                 ndr->depth--;
7221         }
7222         ndr->depth--;
7223         ndr->depth--;
7224 }
7225
7226 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7227 {
7228         if (ndr_flags & NDR_SCALARS) {
7229                 NDR_CHECK(ndr_push_align(ndr, 5));
7230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7240                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7241                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7242                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7243                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7244                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7245         }
7246         if (ndr_flags & NDR_BUFFERS) {
7247                 if (r->netbios_name) {
7248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7252                 }
7253                 if (r->dns_name) {
7254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7258                 }
7259                 if (r->site_name) {
7260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7262                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7263                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7264                 }
7265                 if (r->site_dn) {
7266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7267                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7268                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7270                 }
7271                 if (r->computer_dn) {
7272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7273                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7274                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7275                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7276                 }
7277                 if (r->server_dn) {
7278                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7279                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7280                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7281                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7282                 }
7283                 if (r->ntds_dn) {
7284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7288                 }
7289         }
7290         return NDR_ERR_SUCCESS;
7291 }
7292
7293 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7294 {
7295         uint32_t _ptr_netbios_name;
7296         TALLOC_CTX *_mem_save_netbios_name_0;
7297         uint32_t _ptr_dns_name;
7298         TALLOC_CTX *_mem_save_dns_name_0;
7299         uint32_t _ptr_site_name;
7300         TALLOC_CTX *_mem_save_site_name_0;
7301         uint32_t _ptr_site_dn;
7302         TALLOC_CTX *_mem_save_site_dn_0;
7303         uint32_t _ptr_computer_dn;
7304         TALLOC_CTX *_mem_save_computer_dn_0;
7305         uint32_t _ptr_server_dn;
7306         TALLOC_CTX *_mem_save_server_dn_0;
7307         uint32_t _ptr_ntds_dn;
7308         TALLOC_CTX *_mem_save_ntds_dn_0;
7309         if (ndr_flags & NDR_SCALARS) {
7310                 NDR_CHECK(ndr_pull_align(ndr, 5));
7311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7312                 if (_ptr_netbios_name) {
7313                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7314                 } else {
7315                         r->netbios_name = NULL;
7316                 }
7317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7318                 if (_ptr_dns_name) {
7319                         NDR_PULL_ALLOC(ndr, r->dns_name);
7320                 } else {
7321                         r->dns_name = NULL;
7322                 }
7323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7324                 if (_ptr_site_name) {
7325                         NDR_PULL_ALLOC(ndr, r->site_name);
7326                 } else {
7327                         r->site_name = NULL;
7328                 }
7329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7330                 if (_ptr_site_dn) {
7331                         NDR_PULL_ALLOC(ndr, r->site_dn);
7332                 } else {
7333                         r->site_dn = NULL;
7334                 }
7335                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7336                 if (_ptr_computer_dn) {
7337                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7338                 } else {
7339                         r->computer_dn = NULL;
7340                 }
7341                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7342                 if (_ptr_server_dn) {
7343                         NDR_PULL_ALLOC(ndr, r->server_dn);
7344                 } else {
7345                         r->server_dn = NULL;
7346                 }
7347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7348                 if (_ptr_ntds_dn) {
7349                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7350                 } else {
7351                         r->ntds_dn = NULL;
7352                 }
7353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7356                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7357                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7358                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7359                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7360                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7361         }
7362         if (ndr_flags & NDR_BUFFERS) {
7363                 if (r->netbios_name) {
7364                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7365                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7368                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7369                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7370                         }
7371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7374                 }
7375                 if (r->dns_name) {
7376                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7377                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7380                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7381                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7382                         }
7383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7386                 }
7387                 if (r->site_name) {
7388                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7389                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7392                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7393                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_name), ndr_get_array_length(ndr, &r->site_name));
7394                         }
7395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7398                 }
7399                 if (r->site_dn) {
7400                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7401                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7404                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7405                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_dn), ndr_get_array_length(ndr, &r->site_dn));
7406                         }
7407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7410                 }
7411                 if (r->computer_dn) {
7412                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7413                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7416                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7417                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7418                         }
7419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7422                 }
7423                 if (r->server_dn) {
7424                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7425                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7428                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7429                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7430                         }
7431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7434                 }
7435                 if (r->ntds_dn) {
7436                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7437                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7440                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7441                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
7442                         }
7443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7446                 }
7447         }
7448         return NDR_ERR_SUCCESS;
7449 }
7450
7451 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7452 {
7453         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7454         ndr->depth++;
7455         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7456         ndr->depth++;
7457         if (r->netbios_name) {
7458                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7459         }
7460         ndr->depth--;
7461         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7462         ndr->depth++;
7463         if (r->dns_name) {
7464                 ndr_print_string(ndr, "dns_name", r->dns_name);
7465         }
7466         ndr->depth--;
7467         ndr_print_ptr(ndr, "site_name", r->site_name);
7468         ndr->depth++;
7469         if (r->site_name) {
7470                 ndr_print_string(ndr, "site_name", r->site_name);
7471         }
7472         ndr->depth--;
7473         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7474         ndr->depth++;
7475         if (r->site_dn) {
7476                 ndr_print_string(ndr, "site_dn", r->site_dn);
7477         }
7478         ndr->depth--;
7479         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7480         ndr->depth++;
7481         if (r->computer_dn) {
7482                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7483         }
7484         ndr->depth--;
7485         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7486         ndr->depth++;
7487         if (r->server_dn) {
7488                 ndr_print_string(ndr, "server_dn", r->server_dn);
7489         }
7490         ndr->depth--;
7491         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7492         ndr->depth++;
7493         if (r->ntds_dn) {
7494                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7495         }
7496         ndr->depth--;
7497         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7498         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7499         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7500         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7501         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7502         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7503         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7504         ndr->depth--;
7505 }
7506
7507 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7508 {
7509         uint32_t cntr_array_1;
7510         if (ndr_flags & NDR_SCALARS) {
7511                 NDR_CHECK(ndr_push_align(ndr, 5));
7512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7514                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7515         }
7516         if (ndr_flags & NDR_BUFFERS) {
7517                 if (r->array) {
7518                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7519                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7520                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7521                         }
7522                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7523                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7524                         }
7525                 }
7526         }
7527         return NDR_ERR_SUCCESS;
7528 }
7529
7530 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7531 {
7532         uint32_t _ptr_array;
7533         uint32_t cntr_array_1;
7534         TALLOC_CTX *_mem_save_array_0;
7535         TALLOC_CTX *_mem_save_array_1;
7536         if (ndr_flags & NDR_SCALARS) {
7537                 NDR_CHECK(ndr_pull_align(ndr, 5));
7538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7539                 if (r->count > 10000) {
7540                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7541                 }
7542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7543                 if (_ptr_array) {
7544                         NDR_PULL_ALLOC(ndr, r->array);
7545                 } else {
7546                         r->array = NULL;
7547                 }
7548                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7549         }
7550         if (ndr_flags & NDR_BUFFERS) {
7551                 if (r->array) {
7552                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7553                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7555                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7556                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7557                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7558                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7559                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7560                         }
7561                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7562                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7563                         }
7564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7566                 }
7567                 if (r->array) {
7568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7569                 }
7570         }
7571         return NDR_ERR_SUCCESS;
7572 }
7573
7574 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7575 {
7576         uint32_t cntr_array_1;
7577         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7578         ndr->depth++;
7579         ndr_print_uint32(ndr, "count", r->count);
7580         ndr_print_ptr(ndr, "array", r->array);
7581         ndr->depth++;
7582         if (r->array) {
7583                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7584                 ndr->depth++;
7585                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7586                         char *idx_1=NULL;
7587                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7588                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7589                                 free(idx_1);
7590                         }
7591                 }
7592                 ndr->depth--;
7593         }
7594         ndr->depth--;
7595         ndr->depth--;
7596 }
7597
7598 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7599 {
7600         if (ndr_flags & NDR_SCALARS) {
7601                 NDR_CHECK(ndr_push_align(ndr, 5));
7602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7613                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7614                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7615                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7616                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7617                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7618         }
7619         if (ndr_flags & NDR_BUFFERS) {
7620                 if (r->netbios_name) {
7621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7624                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7625                 }
7626                 if (r->dns_name) {
7627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7630                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7631                 }
7632                 if (r->site_name) {
7633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7636                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7637                 }
7638                 if (r->site_dn) {
7639                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7642                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7643                 }
7644                 if (r->computer_dn) {
7645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7648                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7649                 }
7650                 if (r->server_dn) {
7651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7655                 }
7656                 if (r->ntds_dn) {
7657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7661                 }
7662         }
7663         return NDR_ERR_SUCCESS;
7664 }
7665
7666 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7667 {
7668         uint32_t _ptr_netbios_name;
7669         TALLOC_CTX *_mem_save_netbios_name_0;
7670         uint32_t _ptr_dns_name;
7671         TALLOC_CTX *_mem_save_dns_name_0;
7672         uint32_t _ptr_site_name;
7673         TALLOC_CTX *_mem_save_site_name_0;
7674         uint32_t _ptr_site_dn;
7675         TALLOC_CTX *_mem_save_site_dn_0;
7676         uint32_t _ptr_computer_dn;
7677         TALLOC_CTX *_mem_save_computer_dn_0;
7678         uint32_t _ptr_server_dn;
7679         TALLOC_CTX *_mem_save_server_dn_0;
7680         uint32_t _ptr_ntds_dn;
7681         TALLOC_CTX *_mem_save_ntds_dn_0;
7682         if (ndr_flags & NDR_SCALARS) {
7683                 NDR_CHECK(ndr_pull_align(ndr, 5));
7684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7685                 if (_ptr_netbios_name) {
7686                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7687                 } else {
7688                         r->netbios_name = NULL;
7689                 }
7690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7691                 if (_ptr_dns_name) {
7692                         NDR_PULL_ALLOC(ndr, r->dns_name);
7693                 } else {
7694                         r->dns_name = NULL;
7695                 }
7696                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7697                 if (_ptr_site_name) {
7698                         NDR_PULL_ALLOC(ndr, r->site_name);
7699                 } else {
7700                         r->site_name = NULL;
7701                 }
7702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7703                 if (_ptr_site_dn) {
7704                         NDR_PULL_ALLOC(ndr, r->site_dn);
7705                 } else {
7706                         r->site_dn = NULL;
7707                 }
7708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7709                 if (_ptr_computer_dn) {
7710                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7711                 } else {
7712                         r->computer_dn = NULL;
7713                 }
7714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7715                 if (_ptr_server_dn) {
7716                         NDR_PULL_ALLOC(ndr, r->server_dn);
7717                 } else {
7718                         r->server_dn = NULL;
7719                 }
7720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7721                 if (_ptr_ntds_dn) {
7722                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7723                 } else {
7724                         r->ntds_dn = NULL;
7725                 }
7726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7730                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7731                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7732                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7733                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7734                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7735         }
7736         if (ndr_flags & NDR_BUFFERS) {
7737                 if (r->netbios_name) {
7738                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7739                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7742                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7743                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7744                         }
7745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7748                 }
7749                 if (r->dns_name) {
7750                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7751                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7754                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7755                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7756                         }
7757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7760                 }
7761                 if (r->site_name) {
7762                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7763                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7765                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7766                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7767                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_name), ndr_get_array_length(ndr, &r->site_name));
7768                         }
7769                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7770                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7772                 }
7773                 if (r->site_dn) {
7774                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7775                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7776                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7777                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7778                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7779                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_dn), ndr_get_array_length(ndr, &r->site_dn));
7780                         }
7781                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7782                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7784                 }
7785                 if (r->computer_dn) {
7786                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7787                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7788                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7789                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7790                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7791                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7792                         }
7793                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7794                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7796                 }
7797                 if (r->server_dn) {
7798                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7799                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7802                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7803                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7804                         }
7805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7806                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7808                 }
7809                 if (r->ntds_dn) {
7810                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7811                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7812                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7813                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7814                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7815                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
7816                         }
7817                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7818                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7820                 }
7821         }
7822         return NDR_ERR_SUCCESS;
7823 }
7824
7825 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7826 {
7827         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7828         ndr->depth++;
7829         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7830         ndr->depth++;
7831         if (r->netbios_name) {
7832                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7833         }
7834         ndr->depth--;
7835         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7836         ndr->depth++;
7837         if (r->dns_name) {
7838                 ndr_print_string(ndr, "dns_name", r->dns_name);
7839         }
7840         ndr->depth--;
7841         ndr_print_ptr(ndr, "site_name", r->site_name);
7842         ndr->depth++;
7843         if (r->site_name) {
7844                 ndr_print_string(ndr, "site_name", r->site_name);
7845         }
7846         ndr->depth--;
7847         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7848         ndr->depth++;
7849         if (r->site_dn) {
7850                 ndr_print_string(ndr, "site_dn", r->site_dn);
7851         }
7852         ndr->depth--;
7853         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7854         ndr->depth++;
7855         if (r->computer_dn) {
7856                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7857         }
7858         ndr->depth--;
7859         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7860         ndr->depth++;
7861         if (r->server_dn) {
7862                 ndr_print_string(ndr, "server_dn", r->server_dn);
7863         }
7864         ndr->depth--;
7865         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7866         ndr->depth++;
7867         if (r->ntds_dn) {
7868                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7869         }
7870         ndr->depth--;
7871         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7872         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7873         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7874         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7875         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7876         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7877         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7878         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7879         ndr->depth--;
7880 }
7881
7882 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7883 {
7884         uint32_t cntr_array_1;
7885         if (ndr_flags & NDR_SCALARS) {
7886                 NDR_CHECK(ndr_push_align(ndr, 5));
7887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7889                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7890         }
7891         if (ndr_flags & NDR_BUFFERS) {
7892                 if (r->array) {
7893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7894                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7895                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7896                         }
7897                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7898                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7899                         }
7900                 }
7901         }
7902         return NDR_ERR_SUCCESS;
7903 }
7904
7905 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7906 {
7907         uint32_t _ptr_array;
7908         uint32_t cntr_array_1;
7909         TALLOC_CTX *_mem_save_array_0;
7910         TALLOC_CTX *_mem_save_array_1;
7911         if (ndr_flags & NDR_SCALARS) {
7912                 NDR_CHECK(ndr_pull_align(ndr, 5));
7913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7914                 if (r->count > 10000) {
7915                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7916                 }
7917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7918                 if (_ptr_array) {
7919                         NDR_PULL_ALLOC(ndr, r->array);
7920                 } else {
7921                         r->array = NULL;
7922                 }
7923                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7924         }
7925         if (ndr_flags & NDR_BUFFERS) {
7926                 if (r->array) {
7927                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7928                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7930                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7931                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7932                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7933                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7934                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7935                         }
7936                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7937                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7938                         }
7939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7941                 }
7942                 if (r->array) {
7943                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7944                 }
7945         }
7946         return NDR_ERR_SUCCESS;
7947 }
7948
7949 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7950 {
7951         uint32_t cntr_array_1;
7952         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7953         ndr->depth++;
7954         ndr_print_uint32(ndr, "count", r->count);
7955         ndr_print_ptr(ndr, "array", r->array);
7956         ndr->depth++;
7957         if (r->array) {
7958                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7959                 ndr->depth++;
7960                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7961                         char *idx_1=NULL;
7962                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7963                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7964                                 free(idx_1);
7965                         }
7966                 }
7967                 ndr->depth--;
7968         }
7969         ndr->depth--;
7970         ndr->depth--;
7971 }
7972
7973 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7974 {
7975         if (ndr_flags & NDR_SCALARS) {
7976                 NDR_CHECK(ndr_push_align(ndr, 5));
7977                 {
7978                         uint32_t _flags_save_ipv4address = ndr->flags;
7979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7980                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7981                         ndr->flags = _flags_save_ipv4address;
7982                 }
7983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7989                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7990         }
7991         if (ndr_flags & NDR_BUFFERS) {
7992                 if (r->client_account) {
7993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7996                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7997                 }
7998         }
7999         return NDR_ERR_SUCCESS;
8000 }
8001
8002 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8003 {
8004         uint32_t _ptr_client_account;
8005         TALLOC_CTX *_mem_save_client_account_0;
8006         if (ndr_flags & NDR_SCALARS) {
8007                 NDR_CHECK(ndr_pull_align(ndr, 5));
8008                 {
8009                         uint32_t _flags_save_ipv4address = ndr->flags;
8010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8011                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8012                         ndr->flags = _flags_save_ipv4address;
8013                 }
8014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8020                 if (_ptr_client_account) {
8021                         NDR_PULL_ALLOC(ndr, r->client_account);
8022                 } else {
8023                         r->client_account = NULL;
8024                 }
8025                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8026         }
8027         if (ndr_flags & NDR_BUFFERS) {
8028                 if (r->client_account) {
8029                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8030                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8033                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8034                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client_account), ndr_get_array_length(ndr, &r->client_account));
8035                         }
8036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8039                 }
8040         }
8041         return NDR_ERR_SUCCESS;
8042 }
8043
8044 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8045 {
8046         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8047         ndr->depth++;
8048         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8049         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8050         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8051         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8052         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8053         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8054         ndr_print_ptr(ndr, "client_account", r->client_account);
8055         ndr->depth++;
8056         if (r->client_account) {
8057                 ndr_print_string(ndr, "client_account", r->client_account);
8058         }
8059         ndr->depth--;
8060         ndr->depth--;
8061 }
8062
8063 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8064 {
8065         uint32_t cntr_array_1;
8066         if (ndr_flags & NDR_SCALARS) {
8067                 NDR_CHECK(ndr_push_align(ndr, 5));
8068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8070                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8071         }
8072         if (ndr_flags & NDR_BUFFERS) {
8073                 if (r->array) {
8074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8075                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8076                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8077                         }
8078                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8079                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8080                         }
8081                 }
8082         }
8083         return NDR_ERR_SUCCESS;
8084 }
8085
8086 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8087 {
8088         uint32_t _ptr_array;
8089         uint32_t cntr_array_1;
8090         TALLOC_CTX *_mem_save_array_0;
8091         TALLOC_CTX *_mem_save_array_1;
8092         if (ndr_flags & NDR_SCALARS) {
8093                 NDR_CHECK(ndr_pull_align(ndr, 5));
8094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8095                 if (r->count > 10000) {
8096                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8097                 }
8098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8099                 if (_ptr_array) {
8100                         NDR_PULL_ALLOC(ndr, r->array);
8101                 } else {
8102                         r->array = NULL;
8103                 }
8104                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8105         }
8106         if (ndr_flags & NDR_BUFFERS) {
8107                 if (r->array) {
8108                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8109                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8111                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8112                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8113                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8114                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8115                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8116                         }
8117                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8118                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8119                         }
8120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8122                 }
8123                 if (r->array) {
8124                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8125                 }
8126         }
8127         return NDR_ERR_SUCCESS;
8128 }
8129
8130 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8131 {
8132         uint32_t cntr_array_1;
8133         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8134         ndr->depth++;
8135         ndr_print_uint32(ndr, "count", r->count);
8136         ndr_print_ptr(ndr, "array", r->array);
8137         ndr->depth++;
8138         if (r->array) {
8139                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8140                 ndr->depth++;
8141                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8142                         char *idx_1=NULL;
8143                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8144                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8145                                 free(idx_1);
8146                         }
8147                 }
8148                 ndr->depth--;
8149         }
8150         ndr->depth--;
8151         ndr->depth--;
8152 }
8153
8154 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8155 {
8156         if (ndr_flags & NDR_SCALARS) {
8157                 int level = ndr_push_get_switch_value(ndr, r);
8158                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8159                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8160                 switch (level) {
8161                         case DRSUAPI_DC_INFO_CTR_1: {
8162                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8163                         break; }
8164
8165                         case DRSUAPI_DC_INFO_CTR_2: {
8166                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8167                         break; }
8168
8169                         case DRSUAPI_DC_INFO_CTR_3: {
8170                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8171                         break; }
8172
8173                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8174                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8175                         break; }
8176
8177                         default:
8178                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8179                 }
8180         }
8181         if (ndr_flags & NDR_BUFFERS) {
8182                 int level = ndr_push_get_switch_value(ndr, r);
8183                 switch (level) {
8184                         case DRSUAPI_DC_INFO_CTR_1:
8185                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8186                         break;
8187
8188                         case DRSUAPI_DC_INFO_CTR_2:
8189                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8190                         break;
8191
8192                         case DRSUAPI_DC_INFO_CTR_3:
8193                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8194                         break;
8195
8196                         case DRSUAPI_DC_CONNECTION_CTR_01:
8197                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8198                         break;
8199
8200                         default:
8201                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8202                 }
8203         }
8204         return NDR_ERR_SUCCESS;
8205 }
8206
8207 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8208 {
8209         int level;
8210         int32_t _level;
8211         level = ndr_pull_get_switch_value(ndr, r);
8212         if (ndr_flags & NDR_SCALARS) {
8213                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8214                 if (_level != level) {
8215                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8216                 }
8217                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8218                 switch (level) {
8219                         case DRSUAPI_DC_INFO_CTR_1: {
8220                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8221                         break; }
8222
8223                         case DRSUAPI_DC_INFO_CTR_2: {
8224                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8225                         break; }
8226
8227                         case DRSUAPI_DC_INFO_CTR_3: {
8228                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8229                         break; }
8230
8231                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8232                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8233                         break; }
8234
8235                         default:
8236                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8237                 }
8238         }
8239         if (ndr_flags & NDR_BUFFERS) {
8240                 switch (level) {
8241                         case DRSUAPI_DC_INFO_CTR_1:
8242                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8243                         break;
8244
8245                         case DRSUAPI_DC_INFO_CTR_2:
8246                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8247                         break;
8248
8249                         case DRSUAPI_DC_INFO_CTR_3:
8250                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8251                         break;
8252
8253                         case DRSUAPI_DC_CONNECTION_CTR_01:
8254                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8255                         break;
8256
8257                         default:
8258                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8259                 }
8260         }
8261         return NDR_ERR_SUCCESS;
8262 }
8263
8264 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8265 {
8266         int level;
8267         level = ndr_print_get_switch_value(ndr, r);
8268         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8269         switch (level) {
8270                 case DRSUAPI_DC_INFO_CTR_1:
8271                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8272                 break;
8273
8274                 case DRSUAPI_DC_INFO_CTR_2:
8275                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8276                 break;
8277
8278                 case DRSUAPI_DC_INFO_CTR_3:
8279                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8280                 break;
8281
8282                 case DRSUAPI_DC_CONNECTION_CTR_01:
8283                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8284                 break;
8285
8286                 default:
8287                         ndr_print_bad_level(ndr, name, level);
8288         }
8289 }
8290
8291 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8292 {
8293         if (ndr_flags & NDR_SCALARS) {
8294                 NDR_CHECK(ndr_push_align(ndr, 5));
8295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8296                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8297                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8298         }
8299         if (ndr_flags & NDR_BUFFERS) {
8300                 if (r->next_object) {
8301                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8302                 }
8303                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8304         }
8305         return NDR_ERR_SUCCESS;
8306 }
8307
8308 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8309 {
8310         uint32_t _ptr_next_object;
8311         TALLOC_CTX *_mem_save_next_object_0;
8312         if (ndr_flags & NDR_SCALARS) {
8313                 NDR_CHECK(ndr_pull_align(ndr, 5));
8314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8315                 if (_ptr_next_object) {
8316                         NDR_PULL_ALLOC(ndr, r->next_object);
8317                 } else {
8318                         r->next_object = NULL;
8319                 }
8320                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8321                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8322         }
8323         if (ndr_flags & NDR_BUFFERS) {
8324                 if (r->next_object) {
8325                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8326                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8327                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8329                 }
8330                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8331         }
8332         return NDR_ERR_SUCCESS;
8333 }
8334
8335 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8336 {
8337         if (ndr_flags & NDR_SCALARS) {
8338                 NDR_CHECK(ndr_push_align(ndr, 5));
8339                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8341         }
8342         if (ndr_flags & NDR_BUFFERS) {
8343                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8344         }
8345         return NDR_ERR_SUCCESS;
8346 }
8347
8348 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8349 {
8350         if (ndr_flags & NDR_SCALARS) {
8351                 NDR_CHECK(ndr_pull_align(ndr, 5));
8352                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8353                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8354         }
8355         if (ndr_flags & NDR_BUFFERS) {
8356                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8357         }
8358         return NDR_ERR_SUCCESS;
8359 }
8360
8361 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8362 {
8363         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8364         ndr->depth++;
8365         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8366         ndr->depth--;
8367 }
8368
8369 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8370 {
8371         if (ndr_flags & NDR_SCALARS) {
8372                 int level = ndr_push_get_switch_value(ndr, r);
8373                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8374                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8375                 switch (level) {
8376                         case 2: {
8377                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8378                         break; }
8379
8380                         default:
8381                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8382                 }
8383         }
8384         if (ndr_flags & NDR_BUFFERS) {
8385                 int level = ndr_push_get_switch_value(ndr, r);
8386                 switch (level) {
8387                         case 2:
8388                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8389                         break;
8390
8391                         default:
8392                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8393                 }
8394         }
8395         return NDR_ERR_SUCCESS;
8396 }
8397
8398 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8399 {
8400         int level;
8401         int32_t _level;
8402         level = ndr_pull_get_switch_value(ndr, r);
8403         if (ndr_flags & NDR_SCALARS) {
8404                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8405                 if (_level != level) {
8406                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8407                 }
8408                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8409                 switch (level) {
8410                         case 2: {
8411                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8412                         break; }
8413
8414                         default:
8415                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8416                 }
8417         }
8418         if (ndr_flags & NDR_BUFFERS) {
8419                 switch (level) {
8420                         case 2:
8421                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8422                         break;
8423
8424                         default:
8425                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8426                 }
8427         }
8428         return NDR_ERR_SUCCESS;
8429 }
8430
8431 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8432 {
8433         int level;
8434         level = ndr_print_get_switch_value(ndr, r);
8435         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8436         switch (level) {
8437                 case 2:
8438                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8439                 break;
8440
8441                 default:
8442                         ndr_print_bad_level(ndr, name, level);
8443         }
8444 }
8445
8446 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8447 {
8448         if (ndr_flags & NDR_SCALARS) {
8449                 NDR_CHECK(ndr_push_align(ndr, 4));
8450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8451                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8453                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8454                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8455         }
8456         if (ndr_flags & NDR_BUFFERS) {
8457         }
8458         return NDR_ERR_SUCCESS;
8459 }
8460
8461 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8462 {
8463         if (ndr_flags & NDR_SCALARS) {
8464                 NDR_CHECK(ndr_pull_align(ndr, 4));
8465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8466                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8468                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8469                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8470         }
8471         if (ndr_flags & NDR_BUFFERS) {
8472         }
8473         return NDR_ERR_SUCCESS;
8474 }
8475
8476 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8477 {
8478         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8479         ndr->depth++;
8480         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8481         ndr_print_WERROR(ndr, "status", r->status);
8482         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8483         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8484         ndr->depth--;
8485 }
8486
8487 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8488 {
8489         if (ndr_flags & NDR_SCALARS) {
8490                 NDR_CHECK(ndr_push_align(ndr, 5));
8491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8493                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8494         }
8495         if (ndr_flags & NDR_BUFFERS) {
8496                 if (r->data) {
8497                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8498                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8499                 }
8500         }
8501         return NDR_ERR_SUCCESS;
8502 }
8503
8504 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8505 {
8506         uint32_t _ptr_data;
8507         TALLOC_CTX *_mem_save_data_0;
8508         if (ndr_flags & NDR_SCALARS) {
8509                 NDR_CHECK(ndr_pull_align(ndr, 5));
8510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8511                 if (r->size > 10485760) {
8512                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8513                 }
8514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8515                 if (_ptr_data) {
8516                         NDR_PULL_ALLOC(ndr, r->data);
8517                 } else {
8518                         r->data = NULL;
8519                 }
8520                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8521         }
8522         if (ndr_flags & NDR_BUFFERS) {
8523                 if (r->data) {
8524                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8525                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8527                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8528                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8530                 }
8531                 if (r->data) {
8532                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8533                 }
8534         }
8535         return NDR_ERR_SUCCESS;
8536 }
8537
8538 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8539 {
8540         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8541         ndr->depth++;
8542         ndr_print_uint32(ndr, "size", r->size);
8543         ndr_print_ptr(ndr, "data", r->data);
8544         ndr->depth++;
8545         if (r->data) {
8546                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8547         }
8548         ndr->depth--;
8549         ndr->depth--;
8550 }
8551
8552 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8553 {
8554         if (ndr_flags & NDR_SCALARS) {
8555                 NDR_CHECK(ndr_push_align(ndr, 5));
8556                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8557                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8559                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8560                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8561         }
8562         if (ndr_flags & NDR_BUFFERS) {
8563                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8564         }
8565         return NDR_ERR_SUCCESS;
8566 }
8567
8568 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8569 {
8570         if (ndr_flags & NDR_SCALARS) {
8571                 NDR_CHECK(ndr_pull_align(ndr, 5));
8572                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8573                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8575                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8576                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8577         }
8578         if (ndr_flags & NDR_BUFFERS) {
8579                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8580         }
8581         return NDR_ERR_SUCCESS;
8582 }
8583
8584 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8585 {
8586         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8587         ndr->depth++;
8588         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8589         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8590         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8591         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8592         ndr->depth--;
8593 }
8594
8595 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8596 {
8597         if (ndr_flags & NDR_SCALARS) {
8598                 NDR_CHECK(ndr_push_align(ndr, 5));
8599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8600                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8601                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8602         }
8603         if (ndr_flags & NDR_BUFFERS) {
8604                 if (r->next) {
8605                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8606                 }
8607                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8608         }
8609         return NDR_ERR_SUCCESS;
8610 }
8611
8612 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8613 {
8614         uint32_t _ptr_next;
8615         TALLOC_CTX *_mem_save_next_0;
8616         if (ndr_flags & NDR_SCALARS) {
8617                 NDR_CHECK(ndr_pull_align(ndr, 5));
8618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8619                 if (_ptr_next) {
8620                         NDR_PULL_ALLOC(ndr, r->next);
8621                 } else {
8622                         r->next = NULL;
8623                 }
8624                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8625                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8626         }
8627         if (ndr_flags & NDR_BUFFERS) {
8628                 if (r->next) {
8629                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8630                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8631                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8633                 }
8634                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8635         }
8636         return NDR_ERR_SUCCESS;
8637 }
8638
8639 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8640 {
8641         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8642         ndr->depth++;
8643         ndr_print_ptr(ndr, "next", r->next);
8644         ndr->depth++;
8645         if (r->next) {
8646                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8647         }
8648         ndr->depth--;
8649         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8650         ndr->depth--;
8651 }
8652
8653 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8654 {
8655         if (ndr_flags & NDR_SCALARS) {
8656                 NDR_CHECK(ndr_push_align(ndr, 5));
8657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8658                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8659                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8660                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8661         }
8662         if (ndr_flags & NDR_BUFFERS) {
8663                 if (r->id) {
8664                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8665                 }
8666                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8667         }
8668         return NDR_ERR_SUCCESS;
8669 }
8670
8671 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8672 {
8673         uint32_t _ptr_id;
8674         TALLOC_CTX *_mem_save_id_0;
8675         if (ndr_flags & NDR_SCALARS) {
8676                 NDR_CHECK(ndr_pull_align(ndr, 5));
8677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8678                 if (_ptr_id) {
8679                         NDR_PULL_ALLOC(ndr, r->id);
8680                 } else {
8681                         r->id = NULL;
8682                 }
8683                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8684                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8685                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8686         }
8687         if (ndr_flags & NDR_BUFFERS) {
8688                 if (r->id) {
8689                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8690                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8691                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8693                 }
8694                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8695         }
8696         return NDR_ERR_SUCCESS;
8697 }
8698
8699 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8700 {
8701         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8702         ndr->depth++;
8703         ndr_print_ptr(ndr, "id", r->id);
8704         ndr->depth++;
8705         if (r->id) {
8706                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8707         }
8708         ndr->depth--;
8709         ndr_print_WERROR(ndr, "status", r->status);
8710         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8711         ndr->depth--;
8712 }
8713
8714 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8715 {
8716         if (ndr_flags & NDR_SCALARS) {
8717                 int level = ndr_push_get_switch_value(ndr, r);
8718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8719                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8720                 switch (level) {
8721                         case 1: {
8722                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8723                         break; }
8724
8725                         case 4: {
8726                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8727                         break; }
8728
8729                         case 5: {
8730                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8731                         break; }
8732
8733                         case 6: {
8734                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8735                         break; }
8736
8737                         case 7: {
8738                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8739                         break; }
8740
8741                         default:
8742                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8743                 }
8744         }
8745         if (ndr_flags & NDR_BUFFERS) {
8746                 int level = ndr_push_get_switch_value(ndr, r);
8747                 switch (level) {
8748                         case 1:
8749                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8750                         break;
8751
8752                         case 4:
8753                         break;
8754
8755                         case 5:
8756                         break;
8757
8758                         case 6:
8759                         break;
8760
8761                         case 7:
8762                         break;
8763
8764                         default:
8765                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8766                 }
8767         }
8768         return NDR_ERR_SUCCESS;
8769 }
8770
8771 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8772 {
8773         int level;
8774         uint32_t _level;
8775         level = ndr_pull_get_switch_value(ndr, r);
8776         if (ndr_flags & NDR_SCALARS) {
8777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8778                 if (_level != level) {
8779                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8780                 }
8781                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8782                 switch (level) {
8783                         case 1: {
8784                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8785                         break; }
8786
8787                         case 4: {
8788                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8789                         break; }
8790
8791                         case 5: {
8792                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8793                         break; }
8794
8795                         case 6: {
8796                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8797                         break; }
8798
8799                         case 7: {
8800                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8801                         break; }
8802
8803                         default:
8804                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8805                 }
8806         }
8807         if (ndr_flags & NDR_BUFFERS) {
8808                 switch (level) {
8809                         case 1:
8810                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8811                         break;
8812
8813                         case 4:
8814                         break;
8815
8816                         case 5:
8817                         break;
8818
8819                         case 6:
8820                         break;
8821
8822                         case 7:
8823                         break;
8824
8825                         default:
8826                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8827                 }
8828         }
8829         return NDR_ERR_SUCCESS;
8830 }
8831
8832 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8833 {
8834         int level;
8835         level = ndr_print_get_switch_value(ndr, r);
8836         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8837         switch (level) {
8838                 case 1:
8839                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8840                 break;
8841
8842                 case 4:
8843                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8844                 break;
8845
8846                 case 5:
8847                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8848                 break;
8849
8850                 case 6:
8851                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8852                 break;
8853
8854                 case 7:
8855                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8856                 break;
8857
8858                 default:
8859                         ndr_print_bad_level(ndr, name, level);
8860         }
8861 }
8862
8863 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8864 {
8865         if (ndr_flags & NDR_SCALARS) {
8866                 NDR_CHECK(ndr_push_align(ndr, 5));
8867                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8870                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8871         }
8872         if (ndr_flags & NDR_BUFFERS) {
8873                 if (r->info) {
8874                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8875                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8876                 }
8877         }
8878         return NDR_ERR_SUCCESS;
8879 }
8880
8881 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8882 {
8883         uint32_t _ptr_info;
8884         TALLOC_CTX *_mem_save_info_0;
8885         if (ndr_flags & NDR_SCALARS) {
8886                 NDR_CHECK(ndr_pull_align(ndr, 5));
8887                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8890                 if (_ptr_info) {
8891                         NDR_PULL_ALLOC(ndr, r->info);
8892                 } else {
8893                         r->info = NULL;
8894                 }
8895                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8896         }
8897         if (ndr_flags & NDR_BUFFERS) {
8898                 if (r->info) {
8899                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8900                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8901                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8902                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8904                 }
8905         }
8906         return NDR_ERR_SUCCESS;
8907 }
8908
8909 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8910 {
8911         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8912         ndr->depth++;
8913         ndr_print_WERROR(ndr, "status", r->status);
8914         ndr_print_uint32(ndr, "level", r->level);
8915         ndr_print_ptr(ndr, "info", r->info);
8916         ndr->depth++;
8917         if (r->info) {
8918                 ndr_print_set_switch_value(ndr, r->info, r->level);
8919                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8920         }
8921         ndr->depth--;
8922         ndr->depth--;
8923 }
8924
8925 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8926 {
8927         if (ndr_flags & NDR_SCALARS) {
8928                 int level = ndr_push_get_switch_value(ndr, r);
8929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8930                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8931                 switch (level) {
8932                         case 1: {
8933                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8934                         break; }
8935
8936                         default:
8937                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8938                 }
8939         }
8940         if (ndr_flags & NDR_BUFFERS) {
8941                 int level = ndr_push_get_switch_value(ndr, r);
8942                 switch (level) {
8943                         case 1:
8944                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8945                         break;
8946
8947                         default:
8948                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8949                 }
8950         }
8951         return NDR_ERR_SUCCESS;
8952 }
8953
8954 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8955 {
8956         int level;
8957         uint32_t _level;
8958         level = ndr_pull_get_switch_value(ndr, r);
8959         if (ndr_flags & NDR_SCALARS) {
8960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8961                 if (_level != level) {
8962                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8963                 }
8964                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8965                 switch (level) {
8966                         case 1: {
8967                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8968                         break; }
8969
8970                         default:
8971                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8972                 }
8973         }
8974         if (ndr_flags & NDR_BUFFERS) {
8975                 switch (level) {
8976                         case 1:
8977                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8978                         break;
8979
8980                         default:
8981                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8982                 }
8983         }
8984         return NDR_ERR_SUCCESS;
8985 }
8986
8987 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8988 {
8989         int level;
8990         level = ndr_print_get_switch_value(ndr, r);
8991         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8992         switch (level) {
8993                 case 1:
8994                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8995                 break;
8996
8997                 default:
8998                         ndr_print_bad_level(ndr, name, level);
8999         }
9000 }
9001
9002 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9003 {
9004         if (ndr_flags & NDR_SCALARS) {
9005                 NDR_CHECK(ndr_push_align(ndr, 4));
9006                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9007                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9008                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9009         }
9010         if (ndr_flags & NDR_BUFFERS) {
9011                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9012         }
9013         return NDR_ERR_SUCCESS;
9014 }
9015
9016 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9017 {
9018         if (ndr_flags & NDR_SCALARS) {
9019                 NDR_CHECK(ndr_pull_align(ndr, 4));
9020                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9021                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9022                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9023         }
9024         if (ndr_flags & NDR_BUFFERS) {
9025                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9026         }
9027         return NDR_ERR_SUCCESS;
9028 }
9029
9030 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9031 {
9032         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9033         ndr->depth++;
9034         ndr_print_GUID(ndr, "guid", &r->guid);
9035         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9036         ndr->depth--;
9037 }
9038
9039 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9040 {
9041         uint32_t cntr_objects_1;
9042         if (ndr_flags & NDR_SCALARS) {
9043                 NDR_CHECK(ndr_push_align(ndr, 5));
9044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9046                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9049                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9050         }
9051         if (ndr_flags & NDR_BUFFERS) {
9052                 if (r->id) {
9053                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9054                 }
9055                 if (r->objects) {
9056                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9057                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9058                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9059                         }
9060                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9061                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9062                         }
9063                 }
9064         }
9065         return NDR_ERR_SUCCESS;
9066 }
9067
9068 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9069 {
9070         uint32_t _ptr_id;
9071         TALLOC_CTX *_mem_save_id_0;
9072         uint32_t _ptr_objects;
9073         uint32_t cntr_objects_1;
9074         TALLOC_CTX *_mem_save_objects_0;
9075         TALLOC_CTX *_mem_save_objects_1;
9076         if (ndr_flags & NDR_SCALARS) {
9077                 NDR_CHECK(ndr_pull_align(ndr, 5));
9078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9079                 if (_ptr_id) {
9080                         NDR_PULL_ALLOC(ndr, r->id);
9081                 } else {
9082                         r->id = NULL;
9083                 }
9084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9085                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9087                 if (r->count > 10000) {
9088                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9089                 }
9090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9091                 if (_ptr_objects) {
9092                         NDR_PULL_ALLOC(ndr, r->objects);
9093                 } else {
9094                         r->objects = NULL;
9095                 }
9096                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9097         }
9098         if (ndr_flags & NDR_BUFFERS) {
9099                 if (r->id) {
9100                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9101                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9102                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9104                 }
9105                 if (r->objects) {
9106                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9107                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9109                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9110                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9111                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9112                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9113                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9114                         }
9115                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9116                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9117                         }
9118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9120                 }
9121                 if (r->objects) {
9122                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9123                 }
9124         }
9125         return NDR_ERR_SUCCESS;
9126 }
9127
9128 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9129 {
9130         uint32_t cntr_objects_1;
9131         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9132         ndr->depth++;
9133         ndr_print_ptr(ndr, "id", r->id);
9134         ndr->depth++;
9135         if (r->id) {
9136                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9137         }
9138         ndr->depth--;
9139         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9140         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9141         ndr_print_uint32(ndr, "count", r->count);
9142         ndr_print_ptr(ndr, "objects", r->objects);
9143         ndr->depth++;
9144         if (r->objects) {
9145                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9146                 ndr->depth++;
9147                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9148                         char *idx_1=NULL;
9149                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9150                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9151                                 free(idx_1);
9152                         }
9153                 }
9154                 ndr->depth--;
9155         }
9156         ndr->depth--;
9157         ndr->depth--;
9158 }
9159
9160 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9161 {
9162         uint32_t cntr_objects_1;
9163         if (ndr_flags & NDR_SCALARS) {
9164                 NDR_CHECK(ndr_push_align(ndr, 5));
9165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9170                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9171         }
9172         if (ndr_flags & NDR_BUFFERS) {
9173                 if (r->id) {
9174                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9175                 }
9176                 if (r->error) {
9177                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9178                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9179                 }
9180                 if (r->objects) {
9181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9182                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9183                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9184                         }
9185                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9186                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9187                         }
9188                 }
9189         }
9190         return NDR_ERR_SUCCESS;
9191 }
9192
9193 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9194 {
9195         uint32_t _ptr_id;
9196         TALLOC_CTX *_mem_save_id_0;
9197         uint32_t _ptr_error;
9198         TALLOC_CTX *_mem_save_error_0;
9199         uint32_t _ptr_objects;
9200         uint32_t cntr_objects_1;
9201         TALLOC_CTX *_mem_save_objects_0;
9202         TALLOC_CTX *_mem_save_objects_1;
9203         if (ndr_flags & NDR_SCALARS) {
9204                 NDR_CHECK(ndr_pull_align(ndr, 5));
9205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9206                 if (_ptr_id) {
9207                         NDR_PULL_ALLOC(ndr, r->id);
9208                 } else {
9209                         r->id = NULL;
9210                 }
9211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9213                 if (_ptr_error) {
9214                         NDR_PULL_ALLOC(ndr, r->error);
9215                 } else {
9216                         r->error = NULL;
9217                 }
9218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9219                 if (r->count > 10000) {
9220                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9221                 }
9222                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9223                 if (_ptr_objects) {
9224                         NDR_PULL_ALLOC(ndr, r->objects);
9225                 } else {
9226                         r->objects = NULL;
9227                 }
9228                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9229         }
9230         if (ndr_flags & NDR_BUFFERS) {
9231                 if (r->id) {
9232                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9233                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9234                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9235                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9236                 }
9237                 if (r->error) {
9238                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9239                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9240                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9241                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9243                 }
9244                 if (r->objects) {
9245                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9246                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9248                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9249                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9250                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9251                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9252                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9253                         }
9254                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9255                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9256                         }
9257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9259                 }
9260                 if (r->objects) {
9261                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9262                 }
9263         }
9264         return NDR_ERR_SUCCESS;
9265 }
9266
9267 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9268 {
9269         uint32_t cntr_objects_1;
9270         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9271         ndr->depth++;
9272         ndr_print_ptr(ndr, "id", r->id);
9273         ndr->depth++;
9274         if (r->id) {
9275                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9276         }
9277         ndr->depth--;
9278         ndr_print_uint32(ndr, "level", r->level);
9279         ndr_print_ptr(ndr, "error", r->error);
9280         ndr->depth++;
9281         if (r->error) {
9282                 ndr_print_set_switch_value(ndr, r->error, r->level);
9283                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9284         }
9285         ndr->depth--;
9286         ndr_print_uint32(ndr, "count", r->count);
9287         ndr_print_ptr(ndr, "objects", r->objects);
9288         ndr->depth++;
9289         if (r->objects) {
9290                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9291                 ndr->depth++;
9292                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9293                         char *idx_1=NULL;
9294                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9295                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9296                                 free(idx_1);
9297                         }
9298                 }
9299                 ndr->depth--;
9300         }
9301         ndr->depth--;
9302         ndr->depth--;
9303 }
9304
9305 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9306 {
9307         if (ndr_flags & NDR_SCALARS) {
9308                 int level = ndr_push_get_switch_value(ndr, r);
9309                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9310                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9311                 switch (level) {
9312                         case 2: {
9313                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9314                         break; }
9315
9316                         case 3: {
9317                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9318                         break; }
9319
9320                         default:
9321                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9322                 }
9323         }
9324         if (ndr_flags & NDR_BUFFERS) {
9325                 int level = ndr_push_get_switch_value(ndr, r);
9326                 switch (level) {
9327                         case 2:
9328                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9329                         break;
9330
9331                         case 3:
9332                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9333                         break;
9334
9335                         default:
9336                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9337                 }
9338         }
9339         return NDR_ERR_SUCCESS;
9340 }
9341
9342 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9343 {
9344         int level;
9345         int32_t _level;
9346         level = ndr_pull_get_switch_value(ndr, r);
9347         if (ndr_flags & NDR_SCALARS) {
9348                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9349                 if (_level != level) {
9350                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9351                 }
9352                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9353                 switch (level) {
9354                         case 2: {
9355                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9356                         break; }
9357
9358                         case 3: {
9359                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9360                         break; }
9361
9362                         default:
9363                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9364                 }
9365         }
9366         if (ndr_flags & NDR_BUFFERS) {
9367                 switch (level) {
9368                         case 2:
9369                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9370                         break;
9371
9372                         case 3:
9373                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9374                         break;
9375
9376                         default:
9377                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9378                 }
9379         }
9380         return NDR_ERR_SUCCESS;
9381 }
9382
9383 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9384 {
9385         int level;
9386         level = ndr_print_get_switch_value(ndr, r);
9387         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9388         switch (level) {
9389                 case 2:
9390                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9391                 break;
9392
9393                 case 3:
9394                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9395                 break;
9396
9397                 default:
9398                         ndr_print_bad_level(ndr, name, level);
9399         }
9400 }
9401
9402 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9403 {
9404         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9405         return NDR_ERR_SUCCESS;
9406 }
9407
9408 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9409 {
9410         uint32_t v;
9411         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9412         *r = v;
9413         return NDR_ERR_SUCCESS;
9414 }
9415
9416 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9417 {
9418         ndr_print_uint32(ndr, name, r);
9419         ndr->depth++;
9420         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9421         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9422         ndr->depth--;
9423 }
9424
9425 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9426 {
9427         if (ndr_flags & NDR_SCALARS) {
9428                 NDR_CHECK(ndr_push_align(ndr, 4));
9429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9430                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9431                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9432         }
9433         if (ndr_flags & NDR_BUFFERS) {
9434         }
9435         return NDR_ERR_SUCCESS;
9436 }
9437
9438 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9439 {
9440         if (ndr_flags & NDR_SCALARS) {
9441                 NDR_CHECK(ndr_pull_align(ndr, 4));
9442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9443                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9444                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9445         }
9446         if (ndr_flags & NDR_BUFFERS) {
9447         }
9448         return NDR_ERR_SUCCESS;
9449 }
9450
9451 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9452 {
9453         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9454         ndr->depth++;
9455         ndr_print_uint32(ndr, "taskID", r->taskID);
9456         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9457         ndr->depth--;
9458 }
9459
9460 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9461 {
9462         if (ndr_flags & NDR_SCALARS) {
9463                 int level = ndr_push_get_switch_value(ndr, r);
9464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9465                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9466                 switch (level) {
9467                         case 1: {
9468                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9469                         break; }
9470
9471                         default:
9472                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9473                 }
9474         }
9475         if (ndr_flags & NDR_BUFFERS) {
9476                 int level = ndr_push_get_switch_value(ndr, r);
9477                 switch (level) {
9478                         case 1:
9479                         break;
9480
9481                         default:
9482                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9483                 }
9484         }
9485         return NDR_ERR_SUCCESS;
9486 }
9487
9488 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9489 {
9490         int level;
9491         uint32_t _level;
9492         level = ndr_pull_get_switch_value(ndr, r);
9493         if (ndr_flags & NDR_SCALARS) {
9494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9495                 if (_level != level) {
9496                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9497                 }
9498                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9499                 switch (level) {
9500                         case 1: {
9501                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9502                         break; }
9503
9504                         default:
9505                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9506                 }
9507         }
9508         if (ndr_flags & NDR_BUFFERS) {
9509                 switch (level) {
9510                         case 1:
9511                         break;
9512
9513                         default:
9514                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9515                 }
9516         }
9517         return NDR_ERR_SUCCESS;
9518 }
9519
9520 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9521 {
9522         int level;
9523         level = ndr_print_get_switch_value(ndr, r);
9524         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9525         switch (level) {
9526                 case 1:
9527                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9528                 break;
9529
9530                 default:
9531                         ndr_print_bad_level(ndr, name, level);
9532         }
9533 }
9534
9535 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9536 {
9537         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9538         return NDR_ERR_SUCCESS;
9539 }
9540
9541 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9542 {
9543         uint32_t v;
9544         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9545         *r = v;
9546         return NDR_ERR_SUCCESS;
9547 }
9548
9549 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9550 {
9551         const char *val = NULL;
9552
9553         switch (r) {
9554                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9555                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9556         }
9557         ndr_print_enum(ndr, name, "ENUM", val, r);
9558 }
9559
9560 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9561 {
9562         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9563         return NDR_ERR_SUCCESS;
9564 }
9565
9566 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9567 {
9568         uint32_t v;
9569         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9570         *r = v;
9571         return NDR_ERR_SUCCESS;
9572 }
9573
9574 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9575 {
9576         const char *val = NULL;
9577
9578         switch (r) {
9579                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9580                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9581                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9582                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9583                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9584                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9585                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9586                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9587                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9588                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9589                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9590                 case DRSUAPI_DS_REPLICA_INFO_REPSTO: val = "DRSUAPI_DS_REPLICA_INFO_REPSTO"; break;
9591                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: val = "DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS"; break;
9592                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: val = "DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1"; break;
9593                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: val = "DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS"; break;
9594         }
9595         ndr_print_enum(ndr, name, "ENUM", val, r);
9596 }
9597
9598 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9599 {
9600         if (ndr_flags & NDR_SCALARS) {
9601                 NDR_CHECK(ndr_push_align(ndr, 5));
9602                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9604                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9605                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9606         }
9607         if (ndr_flags & NDR_BUFFERS) {
9608                 if (r->object_dn) {
9609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9613                 }
9614         }
9615         return NDR_ERR_SUCCESS;
9616 }
9617
9618 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9619 {
9620         uint32_t _ptr_object_dn;
9621         TALLOC_CTX *_mem_save_object_dn_0;
9622         if (ndr_flags & NDR_SCALARS) {
9623                 NDR_CHECK(ndr_pull_align(ndr, 5));
9624                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9626                 if (_ptr_object_dn) {
9627                         NDR_PULL_ALLOC(ndr, r->object_dn);
9628                 } else {
9629                         r->object_dn = NULL;
9630                 }
9631                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9632                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9633         }
9634         if (ndr_flags & NDR_BUFFERS) {
9635                 if (r->object_dn) {
9636                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9637                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9640                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9641                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
9642                         }
9643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9646                 }
9647         }
9648         return NDR_ERR_SUCCESS;
9649 }
9650
9651 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9652 {
9653         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9654         ndr->depth++;
9655         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9656         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9657         ndr->depth++;
9658         if (r->object_dn) {
9659                 ndr_print_string(ndr, "object_dn", r->object_dn);
9660         }
9661         ndr->depth--;
9662         ndr_print_GUID(ndr, "guid1", &r->guid1);
9663         ndr->depth--;
9664 }
9665
9666 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9667 {
9668         if (ndr_flags & NDR_SCALARS) {
9669                 NDR_CHECK(ndr_push_align(ndr, 5));
9670                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9672                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
9674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
9677                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9678         }
9679         if (ndr_flags & NDR_BUFFERS) {
9680                 if (r->object_dn) {
9681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9684                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9685                 }
9686                 if (r->string1) {
9687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9691                 }
9692                 if (r->string2) {
9693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9696                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9697                 }
9698         }
9699         return NDR_ERR_SUCCESS;
9700 }
9701
9702 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9703 {
9704         uint32_t _ptr_object_dn;
9705         TALLOC_CTX *_mem_save_object_dn_0;
9706         uint32_t _ptr_string1;
9707         TALLOC_CTX *_mem_save_string1_0;
9708         uint32_t _ptr_string2;
9709         TALLOC_CTX *_mem_save_string2_0;
9710         if (ndr_flags & NDR_SCALARS) {
9711                 NDR_CHECK(ndr_pull_align(ndr, 5));
9712                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9714                 if (_ptr_object_dn) {
9715                         NDR_PULL_ALLOC(ndr, r->object_dn);
9716                 } else {
9717                         r->object_dn = NULL;
9718                 }
9719                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
9721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9722                 if (_ptr_string1) {
9723                         NDR_PULL_ALLOC(ndr, r->string1);
9724                 } else {
9725                         r->string1 = NULL;
9726                 }
9727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9728                 if (_ptr_string2) {
9729                         NDR_PULL_ALLOC(ndr, r->string2);
9730                 } else {
9731                         r->string2 = NULL;
9732                 }
9733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
9734                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9735         }
9736         if (ndr_flags & NDR_BUFFERS) {
9737                 if (r->object_dn) {
9738                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9739                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9742                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9743                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
9744                         }
9745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9748                 }
9749                 if (r->string1) {
9750                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9751                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9754                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9755                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string1), ndr_get_array_length(ndr, &r->string1));
9756                         }
9757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9760                 }
9761                 if (r->string2) {
9762                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9763                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9765                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9766                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9767                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string2), ndr_get_array_length(ndr, &r->string2));
9768                         }
9769                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9770                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9772                 }
9773         }
9774         return NDR_ERR_SUCCESS;
9775 }
9776
9777 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9778 {
9779         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9780         ndr->depth++;
9781         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9782         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9783         ndr->depth++;
9784         if (r->object_dn) {
9785                 ndr_print_string(ndr, "object_dn", r->object_dn);
9786         }
9787         ndr->depth--;
9788         ndr_print_GUID(ndr, "guid1", &r->guid1);
9789         ndr_print_uint32(ndr, "flags", r->flags);
9790         ndr_print_ptr(ndr, "string1", r->string1);
9791         ndr->depth++;
9792         if (r->string1) {
9793                 ndr_print_string(ndr, "string1", r->string1);
9794         }
9795         ndr->depth--;
9796         ndr_print_ptr(ndr, "string2", r->string2);
9797         ndr->depth++;
9798         if (r->string2) {
9799                 ndr_print_string(ndr, "string2", r->string2);
9800         }
9801         ndr->depth--;
9802         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
9803         ndr->depth--;
9804 }
9805
9806 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9807 {
9808         if (ndr_flags & NDR_SCALARS) {
9809                 int level = ndr_push_get_switch_value(ndr, r);
9810                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9811                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9812                 switch (level) {
9813                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9814                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9815                         break; }
9816
9817                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9818                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9819                         break; }
9820
9821                         default:
9822                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9823                 }
9824         }
9825         if (ndr_flags & NDR_BUFFERS) {
9826                 int level = ndr_push_get_switch_value(ndr, r);
9827                 switch (level) {
9828                         case DRSUAPI_DS_REPLICA_GET_INFO:
9829                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9830                         break;
9831
9832                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9833                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9834                         break;
9835
9836                         default:
9837                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9838                 }
9839         }
9840         return NDR_ERR_SUCCESS;
9841 }
9842
9843 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9844 {
9845         int level;
9846         uint32_t _level;
9847         level = ndr_pull_get_switch_value(ndr, r);
9848         if (ndr_flags & NDR_SCALARS) {
9849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9850                 if (_level != level) {
9851                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9852                 }
9853                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9854                 switch (level) {
9855                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9856                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9857                         break; }
9858
9859                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9860                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9861                         break; }
9862
9863                         default:
9864                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9865                 }
9866         }
9867         if (ndr_flags & NDR_BUFFERS) {
9868                 switch (level) {
9869                         case DRSUAPI_DS_REPLICA_GET_INFO:
9870                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9871                         break;
9872
9873                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9874                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9875                         break;
9876
9877                         default:
9878                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9879                 }
9880         }
9881         return NDR_ERR_SUCCESS;
9882 }
9883
9884 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9885 {
9886         int level;
9887         level = ndr_print_get_switch_value(ndr, r);
9888         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9889         switch (level) {
9890                 case DRSUAPI_DS_REPLICA_GET_INFO:
9891                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9892                 break;
9893
9894                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9895                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9896                 break;
9897
9898                 default:
9899                         ndr_print_bad_level(ndr, name, level);
9900         }
9901 }
9902
9903 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9904 {
9905         if (ndr_flags & NDR_SCALARS) {
9906                 NDR_CHECK(ndr_push_align(ndr, 8));
9907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9911                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
9912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9913                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9914                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9915                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9916                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9917                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9918                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9919                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9920                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9923                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9924         }
9925         if (ndr_flags & NDR_BUFFERS) {
9926                 if (r->naming_context_dn) {
9927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->naming_context_dn, ndr_charset_length(r->naming_context_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9931                 }
9932                 if (r->source_dsa_obj_dn) {
9933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9935                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_obj_dn, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9937                 }
9938                 if (r->source_dsa_address) {
9939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9941                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9942                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9943                 }
9944                 if (r->transport_obj_dn) {
9945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9948                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->transport_obj_dn, ndr_charset_length(r->transport_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9949                 }
9950         }
9951         return NDR_ERR_SUCCESS;
9952 }
9953
9954 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9955 {
9956         uint32_t _ptr_naming_context_dn;
9957         TALLOC_CTX *_mem_save_naming_context_dn_0;
9958         uint32_t _ptr_source_dsa_obj_dn;
9959         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9960         uint32_t _ptr_source_dsa_address;
9961         TALLOC_CTX *_mem_save_source_dsa_address_0;
9962         uint32_t _ptr_transport_obj_dn;
9963         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9964         if (ndr_flags & NDR_SCALARS) {
9965                 NDR_CHECK(ndr_pull_align(ndr, 8));
9966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9967                 if (_ptr_naming_context_dn) {
9968                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9969                 } else {
9970                         r->naming_context_dn = NULL;
9971                 }
9972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9973                 if (_ptr_source_dsa_obj_dn) {
9974                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9975                 } else {
9976                         r->source_dsa_obj_dn = NULL;
9977                 }
9978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9979                 if (_ptr_source_dsa_address) {
9980                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9981                 } else {
9982                         r->source_dsa_address = NULL;
9983                 }
9984                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9985                 if (_ptr_transport_obj_dn) {
9986                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9987                 } else {
9988                         r->transport_obj_dn = NULL;
9989                 }
9990                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
9991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9992                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9994                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9995                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9996                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9997                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9998                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9999                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10002                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10003         }
10004         if (ndr_flags & NDR_BUFFERS) {
10005                 if (r->naming_context_dn) {
10006                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10007                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10010                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10011                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->naming_context_dn), ndr_get_array_length(ndr, &r->naming_context_dn));
10012                         }
10013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10014                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->naming_context_dn, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t), CH_UTF16));
10015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10016                 }
10017                 if (r->source_dsa_obj_dn) {
10018                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10019                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10020                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10021                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10022                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10023                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_obj_dn), ndr_get_array_length(ndr, &r->source_dsa_obj_dn));
10024                         }
10025                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10026                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
10027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10028                 }
10029                 if (r->source_dsa_address) {
10030                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10031                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10034                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10035                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
10036                         }
10037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
10039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10040                 }
10041                 if (r->transport_obj_dn) {
10042                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10043                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10046                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10047                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->transport_obj_dn), ndr_get_array_length(ndr, &r->transport_obj_dn));
10048                         }
10049                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport_obj_dn, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t), CH_UTF16));
10051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10052                 }
10053         }
10054         return NDR_ERR_SUCCESS;
10055 }
10056
10057 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10058 {
10059         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10060         ndr->depth++;
10061         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10062         ndr->depth++;
10063         if (r->naming_context_dn) {
10064                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10065         }
10066         ndr->depth--;
10067         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10068         ndr->depth++;
10069         if (r->source_dsa_obj_dn) {
10070                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10071         }
10072         ndr->depth--;
10073         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10074         ndr->depth++;
10075         if (r->source_dsa_address) {
10076                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10077         }
10078         ndr->depth--;
10079         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10080         ndr->depth++;
10081         if (r->transport_obj_dn) {
10082                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10083         }
10084         ndr->depth--;
10085         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
10086         ndr_print_uint32(ndr, "reserved", r->reserved);
10087         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10088         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10089         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10090         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10091         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10092         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10093         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10094         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10095         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10096         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10097         ndr->depth--;
10098 }
10099
10100 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10101 {
10102         uint32_t cntr_array_0;
10103         if (ndr_flags & NDR_SCALARS) {
10104                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10105                 NDR_CHECK(ndr_push_align(ndr, 8));
10106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10108                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10109                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10110                 }
10111                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10112         }
10113         if (ndr_flags & NDR_BUFFERS) {
10114                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10115                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10116                 }
10117         }
10118         return NDR_ERR_SUCCESS;
10119 }
10120
10121 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10122 {
10123         uint32_t cntr_array_0;
10124         TALLOC_CTX *_mem_save_array_0;
10125         if (ndr_flags & NDR_SCALARS) {
10126                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10127                 NDR_CHECK(ndr_pull_align(ndr, 8));
10128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10130                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10131                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10132                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10133                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10134                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10135                 }
10136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10137                 if (r->array) {
10138                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10139                 }
10140                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10141         }
10142         if (ndr_flags & NDR_BUFFERS) {
10143                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10144                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10145                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10146                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10147                 }
10148                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10149         }
10150         return NDR_ERR_SUCCESS;
10151 }
10152
10153 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10154 {
10155         uint32_t cntr_array_0;
10156         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10157         ndr->depth++;
10158         ndr_print_uint32(ndr, "count", r->count);
10159         ndr_print_uint32(ndr, "reserved", r->reserved);
10160         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10161         ndr->depth++;
10162         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10163                 char *idx_0=NULL;
10164                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10165                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10166                         free(idx_0);
10167                 }
10168         }
10169         ndr->depth--;
10170         ndr->depth--;
10171 }
10172
10173 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10174 {
10175         uint32_t cntr_array_0;
10176         if (ndr_flags & NDR_SCALARS) {
10177                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10178                 NDR_CHECK(ndr_push_align(ndr, 8));
10179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10181                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10182                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10183                 }
10184                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10185         }
10186         if (ndr_flags & NDR_BUFFERS) {
10187         }
10188         return NDR_ERR_SUCCESS;
10189 }
10190
10191 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10192 {
10193         uint32_t cntr_array_0;
10194         TALLOC_CTX *_mem_save_array_0;
10195         if (ndr_flags & NDR_SCALARS) {
10196                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10197                 NDR_CHECK(ndr_pull_align(ndr, 8));
10198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10200                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10201                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10202                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10203                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10204                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10205                 }
10206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10207                 if (r->array) {
10208                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10209                 }
10210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10211         }
10212         if (ndr_flags & NDR_BUFFERS) {
10213         }
10214         return NDR_ERR_SUCCESS;
10215 }
10216
10217 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10218 {
10219         uint32_t cntr_array_0;
10220         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10221         ndr->depth++;
10222         ndr_print_uint32(ndr, "count", r->count);
10223         ndr_print_uint32(ndr, "reserved", r->reserved);
10224         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10225         ndr->depth++;
10226         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10227                 char *idx_0=NULL;
10228                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10229                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10230                         free(idx_0);
10231                 }
10232         }
10233         ndr->depth--;
10234         ndr->depth--;
10235 }
10236
10237 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10238 {
10239         if (ndr_flags & NDR_SCALARS) {
10240                 NDR_CHECK(ndr_push_align(ndr, 8));
10241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10243                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10244                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10245                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10246                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10247                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10248         }
10249         if (ndr_flags & NDR_BUFFERS) {
10250                 if (r->attribute_name) {
10251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10254                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10255                 }
10256         }
10257         return NDR_ERR_SUCCESS;
10258 }
10259
10260 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10261 {
10262         uint32_t _ptr_attribute_name;
10263         TALLOC_CTX *_mem_save_attribute_name_0;
10264         if (ndr_flags & NDR_SCALARS) {
10265                 NDR_CHECK(ndr_pull_align(ndr, 8));
10266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10267                 if (_ptr_attribute_name) {
10268                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10269                 } else {
10270                         r->attribute_name = NULL;
10271                 }
10272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10273                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10274                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10275                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10276                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10278         }
10279         if (ndr_flags & NDR_BUFFERS) {
10280                 if (r->attribute_name) {
10281                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10282                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10283                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10284                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10285                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10286                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
10287                         }
10288                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10289                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10291                 }
10292         }
10293         return NDR_ERR_SUCCESS;
10294 }
10295
10296 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10297 {
10298         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10299         ndr->depth++;
10300         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10301         ndr->depth++;
10302         if (r->attribute_name) {
10303                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10304         }
10305         ndr->depth--;
10306         ndr_print_uint32(ndr, "version", r->version);
10307         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10308         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10309         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10310         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10311         ndr->depth--;
10312 }
10313
10314 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10315 {
10316         uint32_t cntr_array_0;
10317         if (ndr_flags & NDR_SCALARS) {
10318                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10319                 NDR_CHECK(ndr_push_align(ndr, 8));
10320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10322                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10323                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10324                 }
10325                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10326         }
10327         if (ndr_flags & NDR_BUFFERS) {
10328                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10329                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10330                 }
10331         }
10332         return NDR_ERR_SUCCESS;
10333 }
10334
10335 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10336 {
10337         uint32_t cntr_array_0;
10338         TALLOC_CTX *_mem_save_array_0;
10339         if (ndr_flags & NDR_SCALARS) {
10340                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10341                 NDR_CHECK(ndr_pull_align(ndr, 8));
10342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10344                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10345                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10346                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10347                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10348                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10349                 }
10350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10351                 if (r->array) {
10352                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10353                 }
10354                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10355         }
10356         if (ndr_flags & NDR_BUFFERS) {
10357                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10358                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10359                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10360                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10361                 }
10362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10363         }
10364         return NDR_ERR_SUCCESS;
10365 }
10366
10367 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10368 {
10369         uint32_t cntr_array_0;
10370         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10371         ndr->depth++;
10372         ndr_print_uint32(ndr, "count", r->count);
10373         ndr_print_uint32(ndr, "reserved", r->reserved);
10374         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10375         ndr->depth++;
10376         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10377                 char *idx_0=NULL;
10378                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10379                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10380                         free(idx_0);
10381                 }
10382         }
10383         ndr->depth--;
10384         ndr->depth--;
10385 }
10386
10387 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10388 {
10389         if (ndr_flags & NDR_SCALARS) {
10390                 NDR_CHECK(ndr_push_align(ndr, 5));
10391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10392                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10393                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10395                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10396                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10397         }
10398         if (ndr_flags & NDR_BUFFERS) {
10399                 if (r->dsa_obj_dn) {
10400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dsa_obj_dn, ndr_charset_length(r->dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10404                 }
10405         }
10406         return NDR_ERR_SUCCESS;
10407 }
10408
10409 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10410 {
10411         uint32_t _ptr_dsa_obj_dn;
10412         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10413         if (ndr_flags & NDR_SCALARS) {
10414                 NDR_CHECK(ndr_pull_align(ndr, 5));
10415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10416                 if (_ptr_dsa_obj_dn) {
10417                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10418                 } else {
10419                         r->dsa_obj_dn = NULL;
10420                 }
10421                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10422                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10425                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10426         }
10427         if (ndr_flags & NDR_BUFFERS) {
10428                 if (r->dsa_obj_dn) {
10429                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10430                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10433                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10434                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dsa_obj_dn), ndr_get_array_length(ndr, &r->dsa_obj_dn));
10435                         }
10436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dsa_obj_dn, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
10438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10439                 }
10440         }
10441         return NDR_ERR_SUCCESS;
10442 }
10443
10444 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10445 {
10446         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10447         ndr->depth++;
10448         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10449         ndr->depth++;
10450         if (r->dsa_obj_dn) {
10451                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10452         }
10453         ndr->depth--;
10454         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10455         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10456         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10457         ndr_print_WERROR(ndr, "last_result", r->last_result);
10458         ndr->depth--;
10459 }
10460
10461 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10462 {
10463         uint32_t cntr_array_0;
10464         if (ndr_flags & NDR_SCALARS) {
10465                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10466                 NDR_CHECK(ndr_push_align(ndr, 5));
10467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10469                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10470                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10471                 }
10472                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10473         }
10474         if (ndr_flags & NDR_BUFFERS) {
10475                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10476                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10477                 }
10478         }
10479         return NDR_ERR_SUCCESS;
10480 }
10481
10482 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10483 {
10484         uint32_t cntr_array_0;
10485         TALLOC_CTX *_mem_save_array_0;
10486         if (ndr_flags & NDR_SCALARS) {
10487                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10488                 NDR_CHECK(ndr_pull_align(ndr, 5));
10489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10491                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10492                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10493                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10494                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10495                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10496                 }
10497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10498                 if (r->array) {
10499                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10500                 }
10501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10502         }
10503         if (ndr_flags & NDR_BUFFERS) {
10504                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10505                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10506                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10507                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10508                 }
10509                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10510         }
10511         return NDR_ERR_SUCCESS;
10512 }
10513
10514 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10515 {
10516         uint32_t cntr_array_0;
10517         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10518         ndr->depth++;
10519         ndr_print_uint32(ndr, "count", r->count);
10520         ndr_print_uint32(ndr, "reserved", r->reserved);
10521         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10522         ndr->depth++;
10523         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10524                 char *idx_0=NULL;
10525                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10526                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10527                         free(idx_0);
10528                 }
10529         }
10530         ndr->depth--;
10531         ndr->depth--;
10532 }
10533
10534 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10535 {
10536         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10537         return NDR_ERR_SUCCESS;
10538 }
10539
10540 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10541 {
10542         uint16_t v;
10543         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10544         *r = v;
10545         return NDR_ERR_SUCCESS;
10546 }
10547
10548 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10549 {
10550         const char *val = NULL;
10551
10552         switch (r) {
10553                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10554                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10555                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10556                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10557                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10558         }
10559         ndr_print_enum(ndr, name, "ENUM", val, r);
10560 }
10561
10562 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10563 {
10564         if (ndr_flags & NDR_SCALARS) {
10565                 NDR_CHECK(ndr_push_align(ndr, 5));
10566                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10569                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10570                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10574                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10575                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10576                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10577         }
10578         if (ndr_flags & NDR_BUFFERS) {
10579                 if (r->nc_dn) {
10580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10583                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10584                 }
10585                 if (r->remote_dsa_obj_dn) {
10586                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10587                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10588                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10589                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote_dsa_obj_dn, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10590                 }
10591                 if (r->remote_dsa_address) {
10592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10593                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10594                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10595                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote_dsa_address, ndr_charset_length(r->remote_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10596                 }
10597         }
10598         return NDR_ERR_SUCCESS;
10599 }
10600
10601 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10602 {
10603         uint32_t _ptr_nc_dn;
10604         TALLOC_CTX *_mem_save_nc_dn_0;
10605         uint32_t _ptr_remote_dsa_obj_dn;
10606         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10607         uint32_t _ptr_remote_dsa_address;
10608         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10609         if (ndr_flags & NDR_SCALARS) {
10610                 NDR_CHECK(ndr_pull_align(ndr, 5));
10611                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10614                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10615                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10617                 if (_ptr_nc_dn) {
10618                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10619                 } else {
10620                         r->nc_dn = NULL;
10621                 }
10622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10623                 if (_ptr_remote_dsa_obj_dn) {
10624                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10625                 } else {
10626                         r->remote_dsa_obj_dn = NULL;
10627                 }
10628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10629                 if (_ptr_remote_dsa_address) {
10630                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10631                 } else {
10632                         r->remote_dsa_address = NULL;
10633                 }
10634                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10635                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10636                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10637         }
10638         if (ndr_flags & NDR_BUFFERS) {
10639                 if (r->nc_dn) {
10640                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10641                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10644                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->nc_dn), ndr_get_array_length(ndr, &r->nc_dn));
10646                         }
10647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10650                 }
10651                 if (r->remote_dsa_obj_dn) {
10652                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10653                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10656                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote_dsa_obj_dn), ndr_get_array_length(ndr, &r->remote_dsa_obj_dn));
10658                         }
10659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_obj_dn, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
10661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10662                 }
10663                 if (r->remote_dsa_address) {
10664                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10665                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10668                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote_dsa_address), ndr_get_array_length(ndr, &r->remote_dsa_address));
10670                         }
10671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_address, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t), CH_UTF16));
10673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10674                 }
10675         }
10676         return NDR_ERR_SUCCESS;
10677 }
10678
10679 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10680 {
10681         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10682         ndr->depth++;
10683         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10684         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10685         ndr_print_uint32(ndr, "priority", r->priority);
10686         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10687         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10688         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10689         ndr->depth++;
10690         if (r->nc_dn) {
10691                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10692         }
10693         ndr->depth--;
10694         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10695         ndr->depth++;
10696         if (r->remote_dsa_obj_dn) {
10697                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10698         }
10699         ndr->depth--;
10700         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10701         ndr->depth++;
10702         if (r->remote_dsa_address) {
10703                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10704         }
10705         ndr->depth--;
10706         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10707         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10708         ndr->depth--;
10709 }
10710
10711 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10712 {
10713         uint32_t cntr_array_0;
10714         if (ndr_flags & NDR_SCALARS) {
10715                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10716                 NDR_CHECK(ndr_push_align(ndr, 5));
10717                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10719                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10720                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10721                 }
10722                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10723         }
10724         if (ndr_flags & NDR_BUFFERS) {
10725                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10726                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10727                 }
10728         }
10729         return NDR_ERR_SUCCESS;
10730 }
10731
10732 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10733 {
10734         uint32_t cntr_array_0;
10735         TALLOC_CTX *_mem_save_array_0;
10736         if (ndr_flags & NDR_SCALARS) {
10737                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10738                 NDR_CHECK(ndr_pull_align(ndr, 5));
10739                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10741                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10742                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10743                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10744                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10745                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10746                 }
10747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10748                 if (r->array) {
10749                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10750                 }
10751                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10752         }
10753         if (ndr_flags & NDR_BUFFERS) {
10754                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10755                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10756                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10757                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10758                 }
10759                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10760         }
10761         return NDR_ERR_SUCCESS;
10762 }
10763
10764 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10765 {
10766         uint32_t cntr_array_0;
10767         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10768         ndr->depth++;
10769         ndr_print_NTTIME(ndr, "time", r->time);
10770         ndr_print_uint32(ndr, "count", r->count);
10771         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10772         ndr->depth++;
10773         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10774                 char *idx_0=NULL;
10775                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10776                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10777                         free(idx_0);
10778                 }
10779         }
10780         ndr->depth--;
10781         ndr->depth--;
10782 }
10783
10784 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10785 {
10786         if (ndr_flags & NDR_SCALARS) {
10787                 NDR_CHECK(ndr_push_align(ndr, 8));
10788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10792                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10793                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10795                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10796                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10797                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10798                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10799                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10800         }
10801         if (ndr_flags & NDR_BUFFERS) {
10802                 if (r->attribute_name) {
10803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10806                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10807                 }
10808                 if (r->object_dn) {
10809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10812                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10813                 }
10814                 if (r->binary) {
10815                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10816                 }
10817         }
10818         return NDR_ERR_SUCCESS;
10819 }
10820
10821 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10822 {
10823         uint32_t _ptr_attribute_name;
10824         TALLOC_CTX *_mem_save_attribute_name_0;
10825         uint32_t _ptr_object_dn;
10826         TALLOC_CTX *_mem_save_object_dn_0;
10827         uint32_t _ptr_binary;
10828         TALLOC_CTX *_mem_save_binary_0;
10829         if (ndr_flags & NDR_SCALARS) {
10830                 NDR_CHECK(ndr_pull_align(ndr, 8));
10831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10832                 if (_ptr_attribute_name) {
10833                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10834                 } else {
10835                         r->attribute_name = NULL;
10836                 }
10837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10838                 if (_ptr_object_dn) {
10839                         NDR_PULL_ALLOC(ndr, r->object_dn);
10840                 } else {
10841                         r->object_dn = NULL;
10842                 }
10843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10845                 if (_ptr_binary) {
10846                         NDR_PULL_ALLOC(ndr, r->binary);
10847                 } else {
10848                         r->binary = NULL;
10849                 }
10850                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10851                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10853                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10854                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10855                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10856                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10857                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10858         }
10859         if (ndr_flags & NDR_BUFFERS) {
10860                 if (r->attribute_name) {
10861                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10862                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10865                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10866                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
10867                         }
10868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10871                 }
10872                 if (r->object_dn) {
10873                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10874                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10877                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10878                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
10879                         }
10880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10883                 }
10884                 if (r->binary) {
10885                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10886                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10887                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10889                 }
10890         }
10891         return NDR_ERR_SUCCESS;
10892 }
10893
10894 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10895 {
10896         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10897         ndr->depth++;
10898         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10899         ndr->depth++;
10900         if (r->attribute_name) {
10901                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10902         }
10903         ndr->depth--;
10904         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10905         ndr->depth++;
10906         if (r->object_dn) {
10907                 ndr_print_string(ndr, "object_dn", r->object_dn);
10908         }
10909         ndr->depth--;
10910         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->binary, 0):r->__ndr_size_binary);
10911         ndr_print_ptr(ndr, "binary", r->binary);
10912         ndr->depth++;
10913         if (r->binary) {
10914                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10915         }
10916         ndr->depth--;
10917         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10918         ndr_print_NTTIME(ndr, "created", r->created);
10919         ndr_print_uint32(ndr, "version", r->version);
10920         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10921         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10922         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10923         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10924         ndr->depth--;
10925 }
10926
10927 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10928 {
10929         uint32_t cntr_array_0;
10930         if (ndr_flags & NDR_SCALARS) {
10931                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10932                 NDR_CHECK(ndr_push_align(ndr, 8));
10933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10935                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10936                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10937                 }
10938                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10939         }
10940         if (ndr_flags & NDR_BUFFERS) {
10941                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10942                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10943                 }
10944         }
10945         return NDR_ERR_SUCCESS;
10946 }
10947
10948 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10949 {
10950         uint32_t cntr_array_0;
10951         TALLOC_CTX *_mem_save_array_0;
10952         if (ndr_flags & NDR_SCALARS) {
10953                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10954                 NDR_CHECK(ndr_pull_align(ndr, 8));
10955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10957                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10958                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10959                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10960                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10961                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10962                 }
10963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10964                 if (r->array) {
10965                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10966                 }
10967                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10968         }
10969         if (ndr_flags & NDR_BUFFERS) {
10970                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10971                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10972                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10973                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10974                 }
10975                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10976         }
10977         return NDR_ERR_SUCCESS;
10978 }
10979
10980 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10981 {
10982         uint32_t cntr_array_0;
10983         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10984         ndr->depth++;
10985         ndr_print_uint32(ndr, "count", r->count);
10986         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
10987         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10988         ndr->depth++;
10989         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10990                 char *idx_0=NULL;
10991                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10992                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10993                         free(idx_0);
10994                 }
10995         }
10996         ndr->depth--;
10997         ndr->depth--;
10998 }
10999
11000 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11001 {
11002         uint32_t cntr_array_0;
11003         if (ndr_flags & NDR_SCALARS) {
11004                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11005                 NDR_CHECK(ndr_push_align(ndr, 8));
11006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11008                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11009                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11010                 }
11011                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11012         }
11013         if (ndr_flags & NDR_BUFFERS) {
11014         }
11015         return NDR_ERR_SUCCESS;
11016 }
11017
11018 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11019 {
11020         uint32_t cntr_array_0;
11021         TALLOC_CTX *_mem_save_array_0;
11022         if (ndr_flags & NDR_SCALARS) {
11023                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11024                 NDR_CHECK(ndr_pull_align(ndr, 8));
11025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11027                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11028                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11029                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11030                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11031                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11032                 }
11033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11034                 if (r->array) {
11035                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11036                 }
11037                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11038         }
11039         if (ndr_flags & NDR_BUFFERS) {
11040         }
11041         return NDR_ERR_SUCCESS;
11042 }
11043
11044 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11045 {
11046         uint32_t cntr_array_0;
11047         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11048         ndr->depth++;
11049         ndr_print_uint32(ndr, "count", r->count);
11050         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11051         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11052         ndr->depth++;
11053         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11054                 char *idx_0=NULL;
11055                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11056                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11057                         free(idx_0);
11058                 }
11059         }
11060         ndr->depth--;
11061         ndr->depth--;
11062 }
11063
11064 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11065 {
11066         if (ndr_flags & NDR_SCALARS) {
11067                 NDR_CHECK(ndr_push_align(ndr, 8));
11068                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11069                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11070                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11072                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11073         }
11074         if (ndr_flags & NDR_BUFFERS) {
11075                 if (r->source_dsa_obj_dn) {
11076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11079                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_obj_dn, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11080                 }
11081         }
11082         return NDR_ERR_SUCCESS;
11083 }
11084
11085 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11086 {
11087         uint32_t _ptr_source_dsa_obj_dn;
11088         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11089         if (ndr_flags & NDR_SCALARS) {
11090                 NDR_CHECK(ndr_pull_align(ndr, 8));
11091                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11092                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11093                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11095                 if (_ptr_source_dsa_obj_dn) {
11096                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11097                 } else {
11098                         r->source_dsa_obj_dn = NULL;
11099                 }
11100                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11101         }
11102         if (ndr_flags & NDR_BUFFERS) {
11103                 if (r->source_dsa_obj_dn) {
11104                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11105                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11108                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11109                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_obj_dn), ndr_get_array_length(ndr, &r->source_dsa_obj_dn));
11110                         }
11111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
11113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11114                 }
11115         }
11116         return NDR_ERR_SUCCESS;
11117 }
11118
11119 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11120 {
11121         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11122         ndr->depth++;
11123         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11124         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11125         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11126         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11127         ndr->depth++;
11128         if (r->source_dsa_obj_dn) {
11129                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11130         }
11131         ndr->depth--;
11132         ndr->depth--;
11133 }
11134
11135 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11136 {
11137         uint32_t cntr_array_0;
11138         if (ndr_flags & NDR_SCALARS) {
11139                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11140                 NDR_CHECK(ndr_push_align(ndr, 8));
11141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11143                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11144                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11145                 }
11146                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11147         }
11148         if (ndr_flags & NDR_BUFFERS) {
11149                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11150                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11151                 }
11152         }
11153         return NDR_ERR_SUCCESS;
11154 }
11155
11156 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11157 {
11158         uint32_t cntr_array_0;
11159         TALLOC_CTX *_mem_save_array_0;
11160         if (ndr_flags & NDR_SCALARS) {
11161                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11162                 NDR_CHECK(ndr_pull_align(ndr, 8));
11163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11165                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11166                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11167                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11168                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11169                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11170                 }
11171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11172                 if (r->array) {
11173                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11174                 }
11175                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11176         }
11177         if (ndr_flags & NDR_BUFFERS) {
11178                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11179                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11180                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11181                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11182                 }
11183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11184         }
11185         return NDR_ERR_SUCCESS;
11186 }
11187
11188 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11189 {
11190         uint32_t cntr_array_0;
11191         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11192         ndr->depth++;
11193         ndr_print_uint32(ndr, "count", r->count);
11194         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11195         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11196         ndr->depth++;
11197         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11198                 char *idx_0=NULL;
11199                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11200                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11201                         free(idx_0);
11202                 }
11203         }
11204         ndr->depth--;
11205         ndr->depth--;
11206 }
11207
11208 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11209 {
11210         if (ndr_flags & NDR_SCALARS) {
11211                 NDR_CHECK(ndr_push_align(ndr, 8));
11212                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11214                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11215                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11216                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11217                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11219                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11220         }
11221         if (ndr_flags & NDR_BUFFERS) {
11222                 if (r->attribute_name) {
11223                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11226                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11227                 }
11228                 if (r->originating_dsa_dn) {
11229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11232                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->originating_dsa_dn, ndr_charset_length(r->originating_dsa_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11233                 }
11234         }
11235         return NDR_ERR_SUCCESS;
11236 }
11237
11238 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11239 {
11240         uint32_t _ptr_attribute_name;
11241         TALLOC_CTX *_mem_save_attribute_name_0;
11242         uint32_t _ptr_originating_dsa_dn;
11243         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11244         if (ndr_flags & NDR_SCALARS) {
11245                 NDR_CHECK(ndr_pull_align(ndr, 8));
11246                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11247                 if (_ptr_attribute_name) {
11248                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11249                 } else {
11250                         r->attribute_name = NULL;
11251                 }
11252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11253                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11254                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11255                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11256                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11258                 if (_ptr_originating_dsa_dn) {
11259                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11260                 } else {
11261                         r->originating_dsa_dn = NULL;
11262                 }
11263                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11264         }
11265         if (ndr_flags & NDR_BUFFERS) {
11266                 if (r->attribute_name) {
11267                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11268                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11271                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11272                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
11273                         }
11274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11277                 }
11278                 if (r->originating_dsa_dn) {
11279                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11280                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11283                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11284                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->originating_dsa_dn), ndr_get_array_length(ndr, &r->originating_dsa_dn));
11285                         }
11286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t), CH_UTF16));
11288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11289                 }
11290         }
11291         return NDR_ERR_SUCCESS;
11292 }
11293
11294 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11295 {
11296         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11297         ndr->depth++;
11298         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11299         ndr->depth++;
11300         if (r->attribute_name) {
11301                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11302         }
11303         ndr->depth--;
11304         ndr_print_uint32(ndr, "version", r->version);
11305         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11306         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11307         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11308         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11309         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11310         ndr->depth++;
11311         if (r->originating_dsa_dn) {
11312                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11313         }
11314         ndr->depth--;
11315         ndr->depth--;
11316 }
11317
11318 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11319 {
11320         uint32_t cntr_array_0;
11321         if (ndr_flags & NDR_SCALARS) {
11322                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11323                 NDR_CHECK(ndr_push_align(ndr, 8));
11324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11326                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11327                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11328                 }
11329                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11330         }
11331         if (ndr_flags & NDR_BUFFERS) {
11332                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11333                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11334                 }
11335         }
11336         return NDR_ERR_SUCCESS;
11337 }
11338
11339 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11340 {
11341         uint32_t cntr_array_0;
11342         TALLOC_CTX *_mem_save_array_0;
11343         if (ndr_flags & NDR_SCALARS) {
11344                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11345                 NDR_CHECK(ndr_pull_align(ndr, 8));
11346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11348                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11349                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11350                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11351                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11352                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11353                 }
11354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11355                 if (r->array) {
11356                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11357                 }
11358                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11359         }
11360         if (ndr_flags & NDR_BUFFERS) {
11361                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11362                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11363                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11364                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11365                 }
11366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11367         }
11368         return NDR_ERR_SUCCESS;
11369 }
11370
11371 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11372 {
11373         uint32_t cntr_array_0;
11374         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11375         ndr->depth++;
11376         ndr_print_uint32(ndr, "count", r->count);
11377         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11378         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11379         ndr->depth++;
11380         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11381                 char *idx_0=NULL;
11382                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11383                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11384                         free(idx_0);
11385                 }
11386         }
11387         ndr->depth--;
11388         ndr->depth--;
11389 }
11390
11391 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11392 {
11393         if (ndr_flags & NDR_SCALARS) {
11394                 NDR_CHECK(ndr_push_align(ndr, 8));
11395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11399                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11400                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11402                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11403                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11404                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11405                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11407                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11408         }
11409         if (ndr_flags & NDR_BUFFERS) {
11410                 if (r->attribute_name) {
11411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11413                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11414                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11415                 }
11416                 if (r->object_dn) {
11417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11419                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11420                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11421                 }
11422                 if (r->binary) {
11423                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11424                 }
11425                 if (r->originating_dsa_dn) {
11426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->originating_dsa_dn, ndr_charset_length(r->originating_dsa_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11430                 }
11431         }
11432         return NDR_ERR_SUCCESS;
11433 }
11434
11435 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11436 {
11437         uint32_t _ptr_attribute_name;
11438         TALLOC_CTX *_mem_save_attribute_name_0;
11439         uint32_t _ptr_object_dn;
11440         TALLOC_CTX *_mem_save_object_dn_0;
11441         uint32_t _ptr_binary;
11442         TALLOC_CTX *_mem_save_binary_0;
11443         uint32_t _ptr_originating_dsa_dn;
11444         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11445         if (ndr_flags & NDR_SCALARS) {
11446                 NDR_CHECK(ndr_pull_align(ndr, 8));
11447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11448                 if (_ptr_attribute_name) {
11449                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11450                 } else {
11451                         r->attribute_name = NULL;
11452                 }
11453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11454                 if (_ptr_object_dn) {
11455                         NDR_PULL_ALLOC(ndr, r->object_dn);
11456                 } else {
11457                         r->object_dn = NULL;
11458                 }
11459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11461                 if (_ptr_binary) {
11462                         NDR_PULL_ALLOC(ndr, r->binary);
11463                 } else {
11464                         r->binary = NULL;
11465                 }
11466                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11467                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11469                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11470                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11471                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11472                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11474                 if (_ptr_originating_dsa_dn) {
11475                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11476                 } else {
11477                         r->originating_dsa_dn = NULL;
11478                 }
11479                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11480         }
11481         if (ndr_flags & NDR_BUFFERS) {
11482                 if (r->attribute_name) {
11483                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11484                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11487                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11488                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
11489                         }
11490                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11493                 }
11494                 if (r->object_dn) {
11495                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11496                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11499                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11500                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
11501                         }
11502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11505                 }
11506                 if (r->binary) {
11507                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11508                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11509                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11511                 }
11512                 if (r->originating_dsa_dn) {
11513                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11514                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11517                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11518                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->originating_dsa_dn), ndr_get_array_length(ndr, &r->originating_dsa_dn));
11519                         }
11520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t), CH_UTF16));
11522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11523                 }
11524         }
11525         return NDR_ERR_SUCCESS;
11526 }
11527
11528 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11529 {
11530         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11531         ndr->depth++;
11532         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11533         ndr->depth++;
11534         if (r->attribute_name) {
11535                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11536         }
11537         ndr->depth--;
11538         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11539         ndr->depth++;
11540         if (r->object_dn) {
11541                 ndr_print_string(ndr, "object_dn", r->object_dn);
11542         }
11543         ndr->depth--;
11544         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->binary, 0):r->__ndr_size_binary);
11545         ndr_print_ptr(ndr, "binary", r->binary);
11546         ndr->depth++;
11547         if (r->binary) {
11548                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11549         }
11550         ndr->depth--;
11551         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11552         ndr_print_NTTIME(ndr, "created", r->created);
11553         ndr_print_uint32(ndr, "version", r->version);
11554         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11555         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11556         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11557         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11558         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11559         ndr->depth++;
11560         if (r->originating_dsa_dn) {
11561                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11562         }
11563         ndr->depth--;
11564         ndr->depth--;
11565 }
11566
11567 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11568 {
11569         uint32_t cntr_array_0;
11570         if (ndr_flags & NDR_SCALARS) {
11571                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11572                 NDR_CHECK(ndr_push_align(ndr, 8));
11573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11575                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11576                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11577                 }
11578                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11579         }
11580         if (ndr_flags & NDR_BUFFERS) {
11581                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11582                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11583                 }
11584         }
11585         return NDR_ERR_SUCCESS;
11586 }
11587
11588 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11589 {
11590         uint32_t cntr_array_0;
11591         TALLOC_CTX *_mem_save_array_0;
11592         if (ndr_flags & NDR_SCALARS) {
11593                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11594                 NDR_CHECK(ndr_pull_align(ndr, 8));
11595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11597                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11598                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11599                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11600                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11601                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11602                 }
11603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11604                 if (r->array) {
11605                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11606                 }
11607                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11608         }
11609         if (ndr_flags & NDR_BUFFERS) {
11610                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11611                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11612                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11613                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11614                 }
11615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11616         }
11617         return NDR_ERR_SUCCESS;
11618 }
11619
11620 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11621 {
11622         uint32_t cntr_array_0;
11623         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11624         ndr->depth++;
11625         ndr_print_uint32(ndr, "count", r->count);
11626         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11627         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11628         ndr->depth++;
11629         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11630                 char *idx_0=NULL;
11631                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11632                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11633                         free(idx_0);
11634                 }
11635         }
11636         ndr->depth--;
11637         ndr->depth--;
11638 }
11639
11640 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11641 {
11642         if (ndr_flags & NDR_SCALARS) {
11643                 NDR_CHECK(ndr_push_align(ndr, 8));
11644                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11647                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11648                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11649                 {
11650                         uint32_t _flags_save_ipv4address = ndr->flags;
11651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11652                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11653                         ndr->flags = _flags_save_ipv4address;
11654                 }
11655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11656                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11657         }
11658         if (ndr_flags & NDR_BUFFERS) {
11659         }
11660         return NDR_ERR_SUCCESS;
11661 }
11662
11663 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11664 {
11665         if (ndr_flags & NDR_SCALARS) {
11666                 NDR_CHECK(ndr_pull_align(ndr, 8));
11667                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11670                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11671                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11672                 {
11673                         uint32_t _flags_save_ipv4address = ndr->flags;
11674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11675                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11676                         ndr->flags = _flags_save_ipv4address;
11677                 }
11678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11679                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11680         }
11681         if (ndr_flags & NDR_BUFFERS) {
11682         }
11683         return NDR_ERR_SUCCESS;
11684 }
11685
11686 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11687 {
11688         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11689         ndr->depth++;
11690         ndr_print_hyper(ndr, "u1", r->u1);
11691         ndr_print_uint32(ndr, "u2", r->u2);
11692         ndr_print_uint32(ndr, "u3", r->u3);
11693         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11694         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11695         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11696         ndr_print_uint32(ndr, "u5", r->u5);
11697         ndr->depth--;
11698 }
11699
11700 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11701 {
11702         uint32_t cntr_array_0;
11703         if (ndr_flags & NDR_SCALARS) {
11704                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11705                 NDR_CHECK(ndr_push_align(ndr, 8));
11706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11708                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11709                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11710                 }
11711                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11712         }
11713         if (ndr_flags & NDR_BUFFERS) {
11714         }
11715         return NDR_ERR_SUCCESS;
11716 }
11717
11718 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11719 {
11720         uint32_t cntr_array_0;
11721         TALLOC_CTX *_mem_save_array_0;
11722         if (ndr_flags & NDR_SCALARS) {
11723                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11724                 NDR_CHECK(ndr_pull_align(ndr, 8));
11725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11726                 if (r->count > 10000) {
11727                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11728                 }
11729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11730                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11731                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11732                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11733                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11734                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11735                 }
11736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11737                 if (r->array) {
11738                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11739                 }
11740                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11741         }
11742         if (ndr_flags & NDR_BUFFERS) {
11743         }
11744         return NDR_ERR_SUCCESS;
11745 }
11746
11747 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11748 {
11749         uint32_t cntr_array_0;
11750         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11751         ndr->depth++;
11752         ndr_print_uint32(ndr, "count", r->count);
11753         ndr_print_uint32(ndr, "reserved", r->reserved);
11754         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11755         ndr->depth++;
11756         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11757                 char *idx_0=NULL;
11758                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11759                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11760                         free(idx_0);
11761                 }
11762         }
11763         ndr->depth--;
11764         ndr->depth--;
11765 }
11766
11767 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11768 {
11769         if (ndr_flags & NDR_SCALARS) {
11770                 NDR_CHECK(ndr_push_align(ndr, 8));
11771                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11777                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11779                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11780         }
11781         if (ndr_flags & NDR_BUFFERS) {
11782                 if (r->str1) {
11783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11786                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11787                 }
11788         }
11789         return NDR_ERR_SUCCESS;
11790 }
11791
11792 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11793 {
11794         uint32_t _ptr_str1;
11795         TALLOC_CTX *_mem_save_str1_0;
11796         if (ndr_flags & NDR_SCALARS) {
11797                 NDR_CHECK(ndr_pull_align(ndr, 8));
11798                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11799                 if (_ptr_str1) {
11800                         NDR_PULL_ALLOC(ndr, r->str1);
11801                 } else {
11802                         r->str1 = NULL;
11803                 }
11804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11809                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11811                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11812         }
11813         if (ndr_flags & NDR_BUFFERS) {
11814                 if (r->str1) {
11815                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11816                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11819                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11820                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->str1), ndr_get_array_length(ndr, &r->str1));
11821                         }
11822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11825                 }
11826         }
11827         return NDR_ERR_SUCCESS;
11828 }
11829
11830 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11831 {
11832         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11833         ndr->depth++;
11834         ndr_print_ptr(ndr, "str1", r->str1);
11835         ndr->depth++;
11836         if (r->str1) {
11837                 ndr_print_string(ndr, "str1", r->str1);
11838         }
11839         ndr->depth--;
11840         ndr_print_uint32(ndr, "u1", r->u1);
11841         ndr_print_uint32(ndr, "u2", r->u2);
11842         ndr_print_uint32(ndr, "u3", r->u3);
11843         ndr_print_uint32(ndr, "u4", r->u4);
11844         ndr_print_uint32(ndr, "u5", r->u5);
11845         ndr_print_hyper(ndr, "u6", r->u6);
11846         ndr_print_uint32(ndr, "u7", r->u7);
11847         ndr->depth--;
11848 }
11849
11850 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11851 {
11852         uint32_t cntr_array_0;
11853         if (ndr_flags & NDR_SCALARS) {
11854                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11855                 NDR_CHECK(ndr_push_align(ndr, 8));
11856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11858                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11859                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11860                 }
11861                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11862         }
11863         if (ndr_flags & NDR_BUFFERS) {
11864                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11865                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11866                 }
11867         }
11868         return NDR_ERR_SUCCESS;
11869 }
11870
11871 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11872 {
11873         uint32_t cntr_array_0;
11874         TALLOC_CTX *_mem_save_array_0;
11875         if (ndr_flags & NDR_SCALARS) {
11876                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11877                 NDR_CHECK(ndr_pull_align(ndr, 8));
11878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11879                 if (r->count > 256) {
11880                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11881                 }
11882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11883                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11884                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11885                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11886                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11887                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11888                 }
11889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11890                 if (r->array) {
11891                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11892                 }
11893                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11894         }
11895         if (ndr_flags & NDR_BUFFERS) {
11896                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11897                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11898                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11899                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11900                 }
11901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11902         }
11903         return NDR_ERR_SUCCESS;
11904 }
11905
11906 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11907 {
11908         uint32_t cntr_array_0;
11909         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11910         ndr->depth++;
11911         ndr_print_uint32(ndr, "count", r->count);
11912         ndr_print_uint32(ndr, "reserved", r->reserved);
11913         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11914         ndr->depth++;
11915         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11916                 char *idx_0=NULL;
11917                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11918                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11919                         free(idx_0);
11920                 }
11921         }
11922         ndr->depth--;
11923         ndr->depth--;
11924 }
11925
11926 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11927 {
11928         if (ndr_flags & NDR_SCALARS) {
11929                 int level = ndr_push_get_switch_value(ndr, r);
11930                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11931                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11932                 switch (level) {
11933                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11934                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11935                         break; }
11936
11937                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11938                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11939                         break; }
11940
11941                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11942                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11943                         break; }
11944
11945                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11946                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11947                         break; }
11948
11949                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11950                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11951                         break; }
11952
11953                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11954                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11955                         break; }
11956
11957                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11958                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11959                         break; }
11960
11961                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11962                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11963                         break; }
11964
11965                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11966                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11967                         break; }
11968
11969                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11970                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11971                         break; }
11972
11973                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11974                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11975                         break; }
11976
11977                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
11978                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->repsto));
11979                         break; }
11980
11981                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
11982                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->clientctx));
11983                         break; }
11984
11985                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
11986                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->udv1));
11987                         break; }
11988
11989                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
11990                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvoutgoingcalls));
11991                         break; }
11992
11993                         default:
11994                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11995                 }
11996         }
11997         if (ndr_flags & NDR_BUFFERS) {
11998                 int level = ndr_push_get_switch_value(ndr, r);
11999                 switch (level) {
12000                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12001                                 if (r->neighbours) {
12002                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12003                                 }
12004                         break;
12005
12006                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12007                                 if (r->cursors) {
12008                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12009                                 }
12010                         break;
12011
12012                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12013                                 if (r->objmetadata) {
12014                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12015                                 }
12016                         break;
12017
12018                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12019                                 if (r->connectfailures) {
12020                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12021                                 }
12022                         break;
12023
12024                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12025                                 if (r->linkfailures) {
12026                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12027                                 }
12028                         break;
12029
12030                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12031                                 if (r->pendingops) {
12032                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12033                                 }
12034                         break;
12035
12036                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12037                                 if (r->attrvalmetadata) {
12038                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12039                                 }
12040                         break;
12041
12042                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12043                                 if (r->cursors2) {
12044                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12045                                 }
12046                         break;
12047
12048                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12049                                 if (r->cursors3) {
12050                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12051                                 }
12052                         break;
12053
12054                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12055                                 if (r->objmetadata2) {
12056                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12057                                 }
12058                         break;
12059
12060                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12061                                 if (r->attrvalmetadata2) {
12062                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12063                                 }
12064                         break;
12065
12066                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12067                                 if (r->repsto) {
12068                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12069                                 }
12070                         break;
12071
12072                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12073                                 if (r->clientctx) {
12074                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12075                                 }
12076                         break;
12077
12078                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12079                                 if (r->udv1) {
12080                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12081                                 }
12082                         break;
12083
12084                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12085                                 if (r->srvoutgoingcalls) {
12086                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12087                                 }
12088                         break;
12089
12090                         default:
12091                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12092                 }
12093         }
12094         return NDR_ERR_SUCCESS;
12095 }
12096
12097 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12098 {
12099         int level;
12100         uint32_t _level;
12101         TALLOC_CTX *_mem_save_neighbours_0;
12102         TALLOC_CTX *_mem_save_cursors_0;
12103         TALLOC_CTX *_mem_save_objmetadata_0;
12104         TALLOC_CTX *_mem_save_connectfailures_0;
12105         TALLOC_CTX *_mem_save_linkfailures_0;
12106         TALLOC_CTX *_mem_save_pendingops_0;
12107         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12108         TALLOC_CTX *_mem_save_cursors2_0;
12109         TALLOC_CTX *_mem_save_cursors3_0;
12110         TALLOC_CTX *_mem_save_objmetadata2_0;
12111         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12112         TALLOC_CTX *_mem_save_repsto_0;
12113         TALLOC_CTX *_mem_save_clientctx_0;
12114         TALLOC_CTX *_mem_save_udv1_0;
12115         TALLOC_CTX *_mem_save_srvoutgoingcalls_0;
12116         level = ndr_pull_get_switch_value(ndr, r);
12117         if (ndr_flags & NDR_SCALARS) {
12118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12119                 if (_level != level) {
12120                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12121                 }
12122                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12123                 switch (level) {
12124                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12125                                 uint32_t _ptr_neighbours;
12126                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12127                                 if (_ptr_neighbours) {
12128                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12129                                 } else {
12130                                         r->neighbours = NULL;
12131                                 }
12132                         break; }
12133
12134                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12135                                 uint32_t _ptr_cursors;
12136                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12137                                 if (_ptr_cursors) {
12138                                         NDR_PULL_ALLOC(ndr, r->cursors);
12139                                 } else {
12140                                         r->cursors = NULL;
12141                                 }
12142                         break; }
12143
12144                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12145                                 uint32_t _ptr_objmetadata;
12146                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12147                                 if (_ptr_objmetadata) {
12148                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12149                                 } else {
12150                                         r->objmetadata = NULL;
12151                                 }
12152                         break; }
12153
12154                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12155                                 uint32_t _ptr_connectfailures;
12156                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12157                                 if (_ptr_connectfailures) {
12158                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12159                                 } else {
12160                                         r->connectfailures = NULL;
12161                                 }
12162                         break; }
12163
12164                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12165                                 uint32_t _ptr_linkfailures;
12166                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12167                                 if (_ptr_linkfailures) {
12168                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12169                                 } else {
12170                                         r->linkfailures = NULL;
12171                                 }
12172                         break; }
12173
12174                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12175                                 uint32_t _ptr_pendingops;
12176                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12177                                 if (_ptr_pendingops) {
12178                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12179                                 } else {
12180                                         r->pendingops = NULL;
12181                                 }
12182                         break; }
12183
12184                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12185                                 uint32_t _ptr_attrvalmetadata;
12186                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12187                                 if (_ptr_attrvalmetadata) {
12188                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12189                                 } else {
12190                                         r->attrvalmetadata = NULL;
12191                                 }
12192                         break; }
12193
12194                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12195                                 uint32_t _ptr_cursors2;
12196                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12197                                 if (_ptr_cursors2) {
12198                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12199                                 } else {
12200                                         r->cursors2 = NULL;
12201                                 }
12202                         break; }
12203
12204                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12205                                 uint32_t _ptr_cursors3;
12206                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12207                                 if (_ptr_cursors3) {
12208                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12209                                 } else {
12210                                         r->cursors3 = NULL;
12211                                 }
12212                         break; }
12213
12214                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12215                                 uint32_t _ptr_objmetadata2;
12216                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12217                                 if (_ptr_objmetadata2) {
12218                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12219                                 } else {
12220                                         r->objmetadata2 = NULL;
12221                                 }
12222                         break; }
12223
12224                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12225                                 uint32_t _ptr_attrvalmetadata2;
12226                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12227                                 if (_ptr_attrvalmetadata2) {
12228                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12229                                 } else {
12230                                         r->attrvalmetadata2 = NULL;
12231                                 }
12232                         break; }
12233
12234                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
12235                                 uint32_t _ptr_repsto;
12236                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_repsto));
12237                                 if (_ptr_repsto) {
12238                                         NDR_PULL_ALLOC(ndr, r->repsto);
12239                                 } else {
12240                                         r->repsto = NULL;
12241                                 }
12242                         break; }
12243
12244                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
12245                                 uint32_t _ptr_clientctx;
12246                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_clientctx));
12247                                 if (_ptr_clientctx) {
12248                                         NDR_PULL_ALLOC(ndr, r->clientctx);
12249                                 } else {
12250                                         r->clientctx = NULL;
12251                                 }
12252                         break; }
12253
12254                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
12255                                 uint32_t _ptr_udv1;
12256                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_udv1));
12257                                 if (_ptr_udv1) {
12258                                         NDR_PULL_ALLOC(ndr, r->udv1);
12259                                 } else {
12260                                         r->udv1 = NULL;
12261                                 }
12262                         break; }
12263
12264                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
12265                                 uint32_t _ptr_srvoutgoingcalls;
12266                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvoutgoingcalls));
12267                                 if (_ptr_srvoutgoingcalls) {
12268                                         NDR_PULL_ALLOC(ndr, r->srvoutgoingcalls);
12269                                 } else {
12270                                         r->srvoutgoingcalls = NULL;
12271                                 }
12272                         break; }
12273
12274                         default:
12275                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12276                 }
12277         }
12278         if (ndr_flags & NDR_BUFFERS) {
12279                 switch (level) {
12280                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12281                                 if (r->neighbours) {
12282                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12283                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12284                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12285                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12286                                 }
12287                         break;
12288
12289                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12290                                 if (r->cursors) {
12291                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12292                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12293                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12294                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12295                                 }
12296                         break;
12297
12298                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12299                                 if (r->objmetadata) {
12300                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12301                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12302                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12303                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12304                                 }
12305                         break;
12306
12307                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12308                                 if (r->connectfailures) {
12309                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12310                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12311                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12312                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12313                                 }
12314                         break;
12315
12316                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12317                                 if (r->linkfailures) {
12318                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12319                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12320                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12321                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12322                                 }
12323                         break;
12324
12325                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12326                                 if (r->pendingops) {
12327                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12328                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12329                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12330                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12331                                 }
12332                         break;
12333
12334                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12335                                 if (r->attrvalmetadata) {
12336                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12337                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12338                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12339                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12340                                 }
12341                         break;
12342
12343                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12344                                 if (r->cursors2) {
12345                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12346                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12347                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12348                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12349                                 }
12350                         break;
12351
12352                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12353                                 if (r->cursors3) {
12354                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12355                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12356                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12357                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12358                                 }
12359                         break;
12360
12361                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12362                                 if (r->objmetadata2) {
12363                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12364                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12365                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12366                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12367                                 }
12368                         break;
12369
12370                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12371                                 if (r->attrvalmetadata2) {
12372                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12373                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12374                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12375                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12376                                 }
12377                         break;
12378
12379                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12380                                 if (r->repsto) {
12381                                         _mem_save_repsto_0 = NDR_PULL_GET_MEM_CTX(ndr);
12382                                         NDR_PULL_SET_MEM_CTX(ndr, r->repsto, 0);
12383                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12384                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_repsto_0, 0);
12385                                 }
12386                         break;
12387
12388                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12389                                 if (r->clientctx) {
12390                                         _mem_save_clientctx_0 = NDR_PULL_GET_MEM_CTX(ndr);
12391                                         NDR_PULL_SET_MEM_CTX(ndr, r->clientctx, 0);
12392                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12393                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_clientctx_0, 0);
12394                                 }
12395                         break;
12396
12397                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12398                                 if (r->udv1) {
12399                                         _mem_save_udv1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12400                                         NDR_PULL_SET_MEM_CTX(ndr, r->udv1, 0);
12401                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12402                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_udv1_0, 0);
12403                                 }
12404                         break;
12405
12406                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12407                                 if (r->srvoutgoingcalls) {
12408                                         _mem_save_srvoutgoingcalls_0 = NDR_PULL_GET_MEM_CTX(ndr);
12409                                         NDR_PULL_SET_MEM_CTX(ndr, r->srvoutgoingcalls, 0);
12410                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12411                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvoutgoingcalls_0, 0);
12412                                 }
12413                         break;
12414
12415                         default:
12416                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12417                 }
12418         }
12419         return NDR_ERR_SUCCESS;
12420 }
12421
12422 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12423 {
12424         int level;
12425         level = ndr_print_get_switch_value(ndr, r);
12426         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12427         switch (level) {
12428                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12429                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12430                         ndr->depth++;
12431                         if (r->neighbours) {
12432                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12433                         }
12434                         ndr->depth--;
12435                 break;
12436
12437                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12438                         ndr_print_ptr(ndr, "cursors", r->cursors);
12439                         ndr->depth++;
12440                         if (r->cursors) {
12441                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12442                         }
12443                         ndr->depth--;
12444                 break;
12445
12446                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12447                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12448                         ndr->depth++;
12449                         if (r->objmetadata) {
12450                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12451                         }
12452                         ndr->depth--;
12453                 break;
12454
12455                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12456                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12457                         ndr->depth++;
12458                         if (r->connectfailures) {
12459                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12460                         }
12461                         ndr->depth--;
12462                 break;
12463
12464                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12465                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12466                         ndr->depth++;
12467                         if (r->linkfailures) {
12468                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12469                         }
12470                         ndr->depth--;
12471                 break;
12472
12473                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12474                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12475                         ndr->depth++;
12476                         if (r->pendingops) {
12477                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12478                         }
12479                         ndr->depth--;
12480                 break;
12481
12482                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12483                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12484                         ndr->depth++;
12485                         if (r->attrvalmetadata) {
12486                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12487                         }
12488                         ndr->depth--;
12489                 break;
12490
12491                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12492                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12493                         ndr->depth++;
12494                         if (r->cursors2) {
12495                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12496                         }
12497                         ndr->depth--;
12498                 break;
12499
12500                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12501                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12502                         ndr->depth++;
12503                         if (r->cursors3) {
12504                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12505                         }
12506                         ndr->depth--;
12507                 break;
12508
12509                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12510                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12511                         ndr->depth++;
12512                         if (r->objmetadata2) {
12513                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12514                         }
12515                         ndr->depth--;
12516                 break;
12517
12518                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12519                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12520                         ndr->depth++;
12521                         if (r->attrvalmetadata2) {
12522                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12523                         }
12524                         ndr->depth--;
12525                 break;
12526
12527                 case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12528                         ndr_print_ptr(ndr, "repsto", r->repsto);
12529                         ndr->depth++;
12530                         if (r->repsto) {
12531                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "repsto", r->repsto);
12532                         }
12533                         ndr->depth--;
12534                 break;
12535
12536                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12537                         ndr_print_ptr(ndr, "clientctx", r->clientctx);
12538                         ndr->depth++;
12539                         if (r->clientctx) {
12540                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "clientctx", r->clientctx);
12541                         }
12542                         ndr->depth--;
12543                 break;
12544
12545                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12546                         ndr_print_ptr(ndr, "udv1", r->udv1);
12547                         ndr->depth++;
12548                         if (r->udv1) {
12549                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "udv1", r->udv1);
12550                         }
12551                         ndr->depth--;
12552                 break;
12553
12554                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12555                         ndr_print_ptr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12556                         ndr->depth++;
12557                         if (r->srvoutgoingcalls) {
12558                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12559                         }
12560                         ndr->depth--;
12561                 break;
12562
12563                 default:
12564                         ndr_print_bad_level(ndr, name, level);
12565         }
12566 }
12567
12568 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12569 {
12570         if (ndr_flags & NDR_SCALARS) {
12571                 int level = ndr_push_get_switch_value(ndr, r);
12572                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12573                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12574                 switch (level) {
12575                         case 1: {
12576                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12577                         break; }
12578
12579                         default:
12580                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12581                 }
12582         }
12583         if (ndr_flags & NDR_BUFFERS) {
12584                 int level = ndr_push_get_switch_value(ndr, r);
12585                 switch (level) {
12586                         case 1:
12587                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12588                         break;
12589
12590                         default:
12591                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12592                 }
12593         }
12594         return NDR_ERR_SUCCESS;
12595 }
12596
12597 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12598 {
12599         int level;
12600         int32_t _level;
12601         level = ndr_pull_get_switch_value(ndr, r);
12602         if (ndr_flags & NDR_SCALARS) {
12603                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12604                 if (_level != level) {
12605                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12606                 }
12607                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12608                 switch (level) {
12609                         case 1: {
12610                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12611                         break; }
12612
12613                         default:
12614                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12615                 }
12616         }
12617         if (ndr_flags & NDR_BUFFERS) {
12618                 switch (level) {
12619                         case 1:
12620                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12621                         break;
12622
12623                         default:
12624                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12625                 }
12626         }
12627         return NDR_ERR_SUCCESS;
12628 }
12629
12630 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12631 {
12632         int level;
12633         level = ndr_print_get_switch_value(ndr, r);
12634         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12635         switch (level) {
12636                 case 1:
12637                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12638                 break;
12639
12640                 default:
12641                         ndr_print_bad_level(ndr, name, level);
12642         }
12643 }
12644
12645 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12646 {
12647         uint32_t cntr_req_array_1;
12648         if (ndr_flags & NDR_SCALARS) {
12649                 NDR_CHECK(ndr_push_align(ndr, 5));
12650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12652                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12653         }
12654         if (ndr_flags & NDR_BUFFERS) {
12655                 if (r->req_array) {
12656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12657                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12658                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12659                         }
12660                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12661                                 if (r->req_array[cntr_req_array_1]) {
12662                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12663                                 }
12664                         }
12665                 }
12666         }
12667         return NDR_ERR_SUCCESS;
12668 }
12669
12670 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12671 {
12672         uint32_t _ptr_req_array;
12673         uint32_t cntr_req_array_1;
12674         TALLOC_CTX *_mem_save_req_array_0;
12675         TALLOC_CTX *_mem_save_req_array_1;
12676         TALLOC_CTX *_mem_save_req_array_2;
12677         if (ndr_flags & NDR_SCALARS) {
12678                 NDR_CHECK(ndr_pull_align(ndr, 5));
12679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12680                 if (r->num_req < 1 || r->num_req > 10000) {
12681                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12682                 }
12683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12684                 if (_ptr_req_array) {
12685                         NDR_PULL_ALLOC(ndr, r->req_array);
12686                 } else {
12687                         r->req_array = NULL;
12688                 }
12689                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12690         }
12691         if (ndr_flags & NDR_BUFFERS) {
12692                 if (r->req_array) {
12693                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12694                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12695                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12696                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12697                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12698                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12699                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12700                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12701                                 if (_ptr_req_array) {
12702                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12703                                 } else {
12704                                         r->req_array[cntr_req_array_1] = NULL;
12705                                 }
12706                         }
12707                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12708                                 if (r->req_array[cntr_req_array_1]) {
12709                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12710                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12711                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12712                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12713                                 }
12714                         }
12715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12717                 }
12718                 if (r->req_array) {
12719                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12720                 }
12721         }
12722         return NDR_ERR_SUCCESS;
12723 }
12724
12725 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12726 {
12727         uint32_t cntr_req_array_1;
12728         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12729         ndr->depth++;
12730         ndr_print_uint32(ndr, "num_req", r->num_req);
12731         ndr_print_ptr(ndr, "req_array", r->req_array);
12732         ndr->depth++;
12733         if (r->req_array) {
12734                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12735                 ndr->depth++;
12736                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12737                         char *idx_1=NULL;
12738                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12739                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12740                                 ndr->depth++;
12741                                 if (r->req_array[cntr_req_array_1]) {
12742                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12743                                 }
12744                                 ndr->depth--;
12745                                 free(idx_1);
12746                         }
12747                 }
12748                 ndr->depth--;
12749         }
12750         ndr->depth--;
12751         ndr->depth--;
12752 }
12753
12754 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12755 {
12756         if (ndr_flags & NDR_SCALARS) {
12757                 int level = ndr_push_get_switch_value(ndr, r);
12758                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12759                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12760                 switch (level) {
12761                         case 1: {
12762                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12763                         break; }
12764
12765                         default:
12766                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12767                 }
12768         }
12769         if (ndr_flags & NDR_BUFFERS) {
12770                 int level = ndr_push_get_switch_value(ndr, r);
12771                 switch (level) {
12772                         case 1:
12773                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12774                         break;
12775
12776                         default:
12777                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12778                 }
12779         }
12780         return NDR_ERR_SUCCESS;
12781 }
12782
12783 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12784 {
12785         int level;
12786         int32_t _level;
12787         level = ndr_pull_get_switch_value(ndr, r);
12788         if (ndr_flags & NDR_SCALARS) {
12789                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12790                 if (_level != level) {
12791                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12792                 }
12793                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12794                 switch (level) {
12795                         case 1: {
12796                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12797                         break; }
12798
12799                         default:
12800                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12801                 }
12802         }
12803         if (ndr_flags & NDR_BUFFERS) {
12804                 switch (level) {
12805                         case 1:
12806                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12807                         break;
12808
12809                         default:
12810                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12811                 }
12812         }
12813         return NDR_ERR_SUCCESS;
12814 }
12815
12816 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12817 {
12818         int level;
12819         level = ndr_print_get_switch_value(ndr, r);
12820         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12821         switch (level) {
12822                 case 1:
12823                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12824                 break;
12825
12826                 default:
12827                         ndr_print_bad_level(ndr, name, level);
12828         }
12829 }
12830
12831 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12832 {
12833         if (ndr_flags & NDR_SCALARS) {
12834                 NDR_CHECK(ndr_push_align(ndr, 4));
12835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12837                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12838         }
12839         if (ndr_flags & NDR_BUFFERS) {
12840         }
12841         return NDR_ERR_SUCCESS;
12842 }
12843
12844 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12845 {
12846         if (ndr_flags & NDR_SCALARS) {
12847                 NDR_CHECK(ndr_pull_align(ndr, 4));
12848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12850                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12851         }
12852         if (ndr_flags & NDR_BUFFERS) {
12853         }
12854         return NDR_ERR_SUCCESS;
12855 }
12856
12857 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12858 {
12859         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12860         ndr->depth++;
12861         ndr_print_WERROR(ndr, "error_code", r->error_code);
12862         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12863         ndr->depth--;
12864 }
12865
12866 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12867 {
12868         uint32_t cntr_info_1;
12869         if (ndr_flags & NDR_SCALARS) {
12870                 NDR_CHECK(ndr_push_align(ndr, 5));
12871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12874                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12875         }
12876         if (ndr_flags & NDR_BUFFERS) {
12877                 if (r->info) {
12878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12879                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12880                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12881                         }
12882                 }
12883         }
12884         return NDR_ERR_SUCCESS;
12885 }
12886
12887 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12888 {
12889         uint32_t _ptr_info;
12890         uint32_t cntr_info_1;
12891         TALLOC_CTX *_mem_save_info_0;
12892         TALLOC_CTX *_mem_save_info_1;
12893         if (ndr_flags & NDR_SCALARS) {
12894                 NDR_CHECK(ndr_pull_align(ndr, 5));
12895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12896                 if (r->num_info > 10000) {
12897                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12898                 }
12899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12900                 if (_ptr_info) {
12901                         NDR_PULL_ALLOC(ndr, r->info);
12902                 } else {
12903                         r->info = NULL;
12904                 }
12905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12906                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12907         }
12908         if (ndr_flags & NDR_BUFFERS) {
12909                 if (r->info) {
12910                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12911                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12913                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12914                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12915                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12916                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12917                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12918                         }
12919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12921                 }
12922                 if (r->info) {
12923                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12924                 }
12925         }
12926         return NDR_ERR_SUCCESS;
12927 }
12928
12929 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12930 {
12931         uint32_t cntr_info_1;
12932         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12933         ndr->depth++;
12934         ndr_print_uint32(ndr, "num_info", r->num_info);
12935         ndr_print_ptr(ndr, "info", r->info);
12936         ndr->depth++;
12937         if (r->info) {
12938                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12939                 ndr->depth++;
12940                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12941                         char *idx_1=NULL;
12942                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12943                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12944                                 free(idx_1);
12945                         }
12946                 }
12947                 ndr->depth--;
12948         }
12949         ndr->depth--;
12950         ndr_print_uint32(ndr, "unknown", r->unknown);
12951         ndr->depth--;
12952 }
12953
12954 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12955 {
12956         if (ndr_flags & NDR_SCALARS) {
12957                 int level = ndr_push_get_switch_value(ndr, r);
12958                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12959                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12960                 switch (level) {
12961                         case 1: {
12962                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12963                         break; }
12964
12965                         default:
12966                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12967                 }
12968         }
12969         if (ndr_flags & NDR_BUFFERS) {
12970                 int level = ndr_push_get_switch_value(ndr, r);
12971                 switch (level) {
12972                         case 1:
12973                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12974                         break;
12975
12976                         default:
12977                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12978                 }
12979         }
12980         return NDR_ERR_SUCCESS;
12981 }
12982
12983 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12984 {
12985         int level;
12986         int32_t _level;
12987         level = ndr_pull_get_switch_value(ndr, r);
12988         if (ndr_flags & NDR_SCALARS) {
12989                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12990                 if (_level != level) {
12991                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12992                 }
12993                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12994                 switch (level) {
12995                         case 1: {
12996                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12997                         break; }
12998
12999                         default:
13000                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13001                 }
13002         }
13003         if (ndr_flags & NDR_BUFFERS) {
13004                 switch (level) {
13005                         case 1:
13006                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13007                         break;
13008
13009                         default:
13010                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13011                 }
13012         }
13013         return NDR_ERR_SUCCESS;
13014 }
13015
13016 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13017 {
13018         int level;
13019         level = ndr_print_get_switch_value(ndr, r);
13020         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13021         switch (level) {
13022                 case 1:
13023                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13024                 break;
13025
13026                 default:
13027                         ndr_print_bad_level(ndr, name, level);
13028         }
13029 }
13030
13031 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13032 {
13033         uint32_t cntr_site_to_1;
13034         if (ndr_flags & NDR_SCALARS) {
13035                 NDR_CHECK(ndr_push_align(ndr, 5));
13036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13040                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13041         }
13042         if (ndr_flags & NDR_BUFFERS) {
13043                 if (r->site_from) {
13044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13046                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13048                 }
13049                 if (r->site_to) {
13050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13051                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13052                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13053                         }
13054                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13055                                 if (r->site_to[cntr_site_to_1]) {
13056                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13057                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13058                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13059                                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_to[cntr_site_to_1], ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16), sizeof(uint16_t), CH_UTF16));
13060                                 }
13061                         }
13062                 }
13063         }
13064         return NDR_ERR_SUCCESS;
13065 }
13066
13067 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13068 {
13069         uint32_t _ptr_site_from;
13070         TALLOC_CTX *_mem_save_site_from_0;
13071         uint32_t _ptr_site_to;
13072         uint32_t cntr_site_to_1;
13073         TALLOC_CTX *_mem_save_site_to_0;
13074         TALLOC_CTX *_mem_save_site_to_1;
13075         TALLOC_CTX *_mem_save_site_to_2;
13076         if (ndr_flags & NDR_SCALARS) {
13077                 NDR_CHECK(ndr_pull_align(ndr, 5));
13078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13079                 if (_ptr_site_from) {
13080                         NDR_PULL_ALLOC(ndr, r->site_from);
13081                 } else {
13082                         r->site_from = NULL;
13083                 }
13084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13085                 if (r->num_req < 1 || r->num_req > 10000) {
13086                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13087                 }
13088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13089                 if (_ptr_site_to) {
13090                         NDR_PULL_ALLOC(ndr, r->site_to);
13091                 } else {
13092                         r->site_to = NULL;
13093                 }
13094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13095                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13096         }
13097         if (ndr_flags & NDR_BUFFERS) {
13098                 if (r->site_from) {
13099                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13100                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13101                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13102                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13103                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13104                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_from), ndr_get_array_length(ndr, &r->site_from));
13105                         }
13106                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13107                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13108                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13109                 }
13110                 if (r->site_to) {
13111                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13112                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13113                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13114                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13115                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13116                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13117                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13118                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13119                                 if (_ptr_site_to) {
13120                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13121                                 } else {
13122                                         r->site_to[cntr_site_to_1] = NULL;
13123                                 }
13124                         }
13125                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13126                                 if (r->site_to[cntr_site_to_1]) {
13127                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13128                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13129                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13130                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13131                                         if (ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]) > ndr_get_array_size(ndr, &r->site_to[cntr_site_to_1])) {
13132                                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_to[cntr_site_to_1]), ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]));
13133                                         }
13134                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13135                                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_to[cntr_site_to_1], ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t), CH_UTF16));
13136                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13137                                 }
13138                         }
13139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13141                 }
13142                 if (r->site_to) {
13143                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13144                 }
13145         }
13146         return NDR_ERR_SUCCESS;
13147 }
13148
13149 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13150 {
13151         uint32_t cntr_site_to_1;
13152         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13153         ndr->depth++;
13154         ndr_print_ptr(ndr, "site_from", r->site_from);
13155         ndr->depth++;
13156         if (r->site_from) {
13157                 ndr_print_string(ndr, "site_from", r->site_from);
13158         }
13159         ndr->depth--;
13160         ndr_print_uint32(ndr, "num_req", r->num_req);
13161         ndr_print_ptr(ndr, "site_to", r->site_to);
13162         ndr->depth++;
13163         if (r->site_to) {
13164                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13165                 ndr->depth++;
13166                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13167                         char *idx_1=NULL;
13168                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13169                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13170                                 ndr->depth++;
13171                                 if (r->site_to[cntr_site_to_1]) {
13172                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13173                                 }
13174                                 ndr->depth--;
13175                                 free(idx_1);
13176                         }
13177                 }
13178                 ndr->depth--;
13179         }
13180         ndr->depth--;
13181         ndr_print_uint32(ndr, "flags", r->flags);
13182         ndr->depth--;
13183 }
13184
13185 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13186 {
13187         if (ndr_flags & NDR_SCALARS) {
13188                 int level = ndr_push_get_switch_value(ndr, r);
13189                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13190                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13191                 switch (level) {
13192                         case 1: {
13193                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13194                         break; }
13195
13196                         default:
13197                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13198                 }
13199         }
13200         if (ndr_flags & NDR_BUFFERS) {
13201                 int level = ndr_push_get_switch_value(ndr, r);
13202                 switch (level) {
13203                         case 1:
13204                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13205                         break;
13206
13207                         default:
13208                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13209                 }
13210         }
13211         return NDR_ERR_SUCCESS;
13212 }
13213
13214 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13215 {
13216         int level;
13217         int32_t _level;
13218         level = ndr_pull_get_switch_value(ndr, r);
13219         if (ndr_flags & NDR_SCALARS) {
13220                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13221                 if (_level != level) {
13222                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13223                 }
13224                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13225                 switch (level) {
13226                         case 1: {
13227                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13228                         break; }
13229
13230                         default:
13231                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13232                 }
13233         }
13234         if (ndr_flags & NDR_BUFFERS) {
13235                 switch (level) {
13236                         case 1:
13237                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13238                         break;
13239
13240                         default:
13241                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13242                 }
13243         }
13244         return NDR_ERR_SUCCESS;
13245 }
13246
13247 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13248 {
13249         int level;
13250         level = ndr_print_get_switch_value(ndr, r);
13251         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13252         switch (level) {
13253                 case 1:
13254                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13255                 break;
13256
13257                 default:
13258                         ndr_print_bad_level(ndr, name, level);
13259         }
13260 }
13261
13262 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13263 {
13264         if (flags & NDR_IN) {
13265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13266                 if (r->in.bind_guid) {
13267                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13268                 }
13269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13270                 if (r->in.bind_info) {
13271                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13272                 }
13273         }
13274         if (flags & NDR_OUT) {
13275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13276                 if (r->out.bind_info) {
13277                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13278                 }
13279                 if (r->out.bind_handle == NULL) {
13280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13281                 }
13282                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13284         }
13285         return NDR_ERR_SUCCESS;
13286 }
13287
13288 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13289 {
13290         uint32_t _ptr_bind_guid;
13291         uint32_t _ptr_bind_info;
13292         TALLOC_CTX *_mem_save_bind_guid_0;
13293         TALLOC_CTX *_mem_save_bind_info_0;
13294         TALLOC_CTX *_mem_save_bind_handle_0;
13295         if (flags & NDR_IN) {
13296                 ZERO_STRUCT(r->out);
13297
13298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13299                 if (_ptr_bind_guid) {
13300                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13301                 } else {
13302                         r->in.bind_guid = NULL;
13303                 }
13304                 if (r->in.bind_guid) {
13305                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13306                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13307                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13309                 }
13310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13311                 if (_ptr_bind_info) {
13312                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13313                 } else {
13314                         r->in.bind_info = NULL;
13315                 }
13316                 if (r->in.bind_info) {
13317                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13318                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13319                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13320                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13321                 }
13322                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13323                 ZERO_STRUCTP(r->out.bind_handle);
13324         }
13325         if (flags & NDR_OUT) {
13326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13327                 if (_ptr_bind_info) {
13328                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13329                 } else {
13330                         r->out.bind_info = NULL;
13331                 }
13332                 if (r->out.bind_info) {
13333                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13334                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13335                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13337                 }
13338                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13339                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13340                 }
13341                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13342                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13343                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13344                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13345                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13346         }
13347         return NDR_ERR_SUCCESS;
13348 }
13349
13350 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13351 {
13352         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13353         ndr->depth++;
13354         if (flags & NDR_SET_VALUES) {
13355                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13356         }
13357         if (flags & NDR_IN) {
13358                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13359                 ndr->depth++;
13360                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13361                 ndr->depth++;
13362                 if (r->in.bind_guid) {
13363                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13364                 }
13365                 ndr->depth--;
13366                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13367                 ndr->depth++;
13368                 if (r->in.bind_info) {
13369                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13370                 }
13371                 ndr->depth--;
13372                 ndr->depth--;
13373         }
13374         if (flags & NDR_OUT) {
13375                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13376                 ndr->depth++;
13377                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13378                 ndr->depth++;
13379                 if (r->out.bind_info) {
13380                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13381                 }
13382                 ndr->depth--;
13383                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13384                 ndr->depth++;
13385                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13386                 ndr->depth--;
13387                 ndr_print_WERROR(ndr, "result", r->out.result);
13388                 ndr->depth--;
13389         }
13390         ndr->depth--;
13391 }
13392
13393 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13394 {
13395         if (flags & NDR_IN) {
13396                 if (r->in.bind_handle == NULL) {
13397                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13398                 }
13399                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13400         }
13401         if (flags & NDR_OUT) {
13402                 if (r->out.bind_handle == NULL) {
13403                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13404                 }
13405                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13407         }
13408         return NDR_ERR_SUCCESS;
13409 }
13410
13411 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13412 {
13413         TALLOC_CTX *_mem_save_bind_handle_0;
13414         if (flags & NDR_IN) {
13415                 ZERO_STRUCT(r->out);
13416
13417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13418                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13419                 }
13420                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13421                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13422                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13424                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13425                 *r->out.bind_handle = *r->in.bind_handle;
13426         }
13427         if (flags & NDR_OUT) {
13428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13429                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13430                 }
13431                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13433                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13436         }
13437         return NDR_ERR_SUCCESS;
13438 }
13439
13440 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13441 {
13442         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13443         ndr->depth++;
13444         if (flags & NDR_SET_VALUES) {
13445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13446         }
13447         if (flags & NDR_IN) {
13448                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13449                 ndr->depth++;
13450                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13451                 ndr->depth++;
13452                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13453                 ndr->depth--;
13454                 ndr->depth--;
13455         }
13456         if (flags & NDR_OUT) {
13457                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13458                 ndr->depth++;
13459                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13460                 ndr->depth++;
13461                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13462                 ndr->depth--;
13463                 ndr_print_WERROR(ndr, "result", r->out.result);
13464                 ndr->depth--;
13465         }
13466         ndr->depth--;
13467 }
13468
13469 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13470 {
13471         if (flags & NDR_IN) {
13472                 if (r->in.bind_handle == NULL) {
13473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13474                 }
13475                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13476                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13477                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13478                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13479         }
13480         if (flags & NDR_OUT) {
13481                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13482         }
13483         return NDR_ERR_SUCCESS;
13484 }
13485
13486 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13487 {
13488         TALLOC_CTX *_mem_save_bind_handle_0;
13489         if (flags & NDR_IN) {
13490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13491                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13492                 }
13493                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13494                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13495                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13497                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13498                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13499                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13500         }
13501         if (flags & NDR_OUT) {
13502                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13503         }
13504         return NDR_ERR_SUCCESS;
13505 }
13506
13507 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13508 {
13509         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13510         ndr->depth++;
13511         if (flags & NDR_SET_VALUES) {
13512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13513         }
13514         if (flags & NDR_IN) {
13515                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13516                 ndr->depth++;
13517                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13518                 ndr->depth++;
13519                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13520                 ndr->depth--;
13521                 ndr_print_int32(ndr, "level", r->in.level);
13522                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13523                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13524                 ndr->depth--;
13525         }
13526         if (flags & NDR_OUT) {
13527                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13528                 ndr->depth++;
13529                 ndr_print_WERROR(ndr, "result", r->out.result);
13530                 ndr->depth--;
13531         }
13532         ndr->depth--;
13533 }
13534
13535 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13536 {
13537         if (flags & NDR_IN) {
13538                 if (r->in.bind_handle == NULL) {
13539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13540                 }
13541                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13542                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13543                 if (r->in.req == NULL) {
13544                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13545                 }
13546                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13547                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13548         }
13549         if (flags & NDR_OUT) {
13550                 if (r->out.level_out == NULL) {
13551                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13552                 }
13553                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13554                 if (r->out.ctr == NULL) {
13555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13556                 }
13557                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13558                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13559                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13560         }
13561         return NDR_ERR_SUCCESS;
13562 }
13563
13564 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13565 {
13566         TALLOC_CTX *_mem_save_bind_handle_0;
13567         TALLOC_CTX *_mem_save_req_0;
13568         TALLOC_CTX *_mem_save_level_out_0;
13569         TALLOC_CTX *_mem_save_ctr_0;
13570         if (flags & NDR_IN) {
13571                 ZERO_STRUCT(r->out);
13572
13573                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13574                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13575                 }
13576                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13577                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13578                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13580                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13581                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13582                         NDR_PULL_ALLOC(ndr, r->in.req);
13583                 }
13584                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13585                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13586                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13587                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13589                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13590                 ZERO_STRUCTP(r->out.level_out);
13591                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13592                 ZERO_STRUCTP(r->out.ctr);
13593         }
13594         if (flags & NDR_OUT) {
13595                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13596                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13597                 }
13598                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13599                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13600                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13603                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13604                 }
13605                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13606                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13607                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13608                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13610                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13611         }
13612         return NDR_ERR_SUCCESS;
13613 }
13614
13615 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13616 {
13617         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13618         ndr->depth++;
13619         if (flags & NDR_SET_VALUES) {
13620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13621         }
13622         if (flags & NDR_IN) {
13623                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13624                 ndr->depth++;
13625                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13626                 ndr->depth++;
13627                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13628                 ndr->depth--;
13629                 ndr_print_int32(ndr, "level", r->in.level);
13630                 ndr_print_ptr(ndr, "req", r->in.req);
13631                 ndr->depth++;
13632                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13633                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13634                 ndr->depth--;
13635                 ndr->depth--;
13636         }
13637         if (flags & NDR_OUT) {
13638                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13639                 ndr->depth++;
13640                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13641                 ndr->depth++;
13642                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13643                 ndr->depth--;
13644                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13645                 ndr->depth++;
13646                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13647                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13648                 ndr->depth--;
13649                 ndr_print_WERROR(ndr, "result", r->out.result);
13650                 ndr->depth--;
13651         }
13652         ndr->depth--;
13653 }
13654
13655 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13656 {
13657         if (flags & NDR_IN) {
13658                 if (r->in.bind_handle == NULL) {
13659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13660                 }
13661                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13662                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13664                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13665         }
13666         if (flags & NDR_OUT) {
13667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13668         }
13669         return NDR_ERR_SUCCESS;
13670 }
13671
13672 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13673 {
13674         TALLOC_CTX *_mem_save_bind_handle_0;
13675         if (flags & NDR_IN) {
13676                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13677                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13678                 }
13679                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13680                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13681                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13683                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13684                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13685                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13686         }
13687         if (flags & NDR_OUT) {
13688                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13689         }
13690         return NDR_ERR_SUCCESS;
13691 }
13692
13693 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13694 {
13695         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13696         ndr->depth++;
13697         if (flags & NDR_SET_VALUES) {
13698                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13699         }
13700         if (flags & NDR_IN) {
13701                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13702                 ndr->depth++;
13703                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13704                 ndr->depth++;
13705                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13706                 ndr->depth--;
13707                 ndr_print_int32(ndr, "level", r->in.level);
13708                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13709                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13710                 ndr->depth--;
13711         }
13712         if (flags & NDR_OUT) {
13713                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13714                 ndr->depth++;
13715                 ndr_print_WERROR(ndr, "result", r->out.result);
13716                 ndr->depth--;
13717         }
13718         ndr->depth--;
13719 }
13720
13721 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13722 {
13723         if (flags & NDR_IN) {
13724                 if (r->in.bind_handle == NULL) {
13725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13726                 }
13727                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13728                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13729                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13730                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13731         }
13732         if (flags & NDR_OUT) {
13733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13734         }
13735         return NDR_ERR_SUCCESS;
13736 }
13737
13738 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13739 {
13740         TALLOC_CTX *_mem_save_bind_handle_0;
13741         if (flags & NDR_IN) {
13742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13743                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13744                 }
13745                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13746                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13749                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13750                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13751                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13752         }
13753         if (flags & NDR_OUT) {
13754                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13755         }
13756         return NDR_ERR_SUCCESS;
13757 }
13758
13759 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13760 {
13761         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13762         ndr->depth++;
13763         if (flags & NDR_SET_VALUES) {
13764                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13765         }
13766         if (flags & NDR_IN) {
13767                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13768                 ndr->depth++;
13769                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13770                 ndr->depth++;
13771                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13772                 ndr->depth--;
13773                 ndr_print_int32(ndr, "level", r->in.level);
13774                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13775                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13776                 ndr->depth--;
13777         }
13778         if (flags & NDR_OUT) {
13779                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13780                 ndr->depth++;
13781                 ndr_print_WERROR(ndr, "result", r->out.result);
13782                 ndr->depth--;
13783         }
13784         ndr->depth--;
13785 }
13786
13787 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13788 {
13789         if (flags & NDR_IN) {
13790                 if (r->in.bind_handle == NULL) {
13791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13792                 }
13793                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13794                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13795                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13796                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13797         }
13798         if (flags & NDR_OUT) {
13799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13800         }
13801         return NDR_ERR_SUCCESS;
13802 }
13803
13804 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13805 {
13806         TALLOC_CTX *_mem_save_bind_handle_0;
13807         if (flags & NDR_IN) {
13808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13809                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13810                 }
13811                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13815                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13816                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13817                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13818         }
13819         if (flags & NDR_OUT) {
13820                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13821         }
13822         return NDR_ERR_SUCCESS;
13823 }
13824
13825 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13826 {
13827         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13828         ndr->depth++;
13829         if (flags & NDR_SET_VALUES) {
13830                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13831         }
13832         if (flags & NDR_IN) {
13833                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13834                 ndr->depth++;
13835                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13836                 ndr->depth++;
13837                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13838                 ndr->depth--;
13839                 ndr_print_int32(ndr, "level", r->in.level);
13840                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13841                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13842                 ndr->depth--;
13843         }
13844         if (flags & NDR_OUT) {
13845                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13846                 ndr->depth++;
13847                 ndr_print_WERROR(ndr, "result", r->out.result);
13848                 ndr->depth--;
13849         }
13850         ndr->depth--;
13851 }
13852
13853 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13854 {
13855         if (flags & NDR_IN) {
13856                 if (r->in.bind_handle == NULL) {
13857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13858                 }
13859                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13860                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13861                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13862                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13863         }
13864         if (flags & NDR_OUT) {
13865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13866         }
13867         return NDR_ERR_SUCCESS;
13868 }
13869
13870 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13871 {
13872         TALLOC_CTX *_mem_save_bind_handle_0;
13873         if (flags & NDR_IN) {
13874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13875                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13876                 }
13877                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13881                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13882                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13883                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13884         }
13885         if (flags & NDR_OUT) {
13886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13887         }
13888         return NDR_ERR_SUCCESS;
13889 }
13890
13891 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13892 {
13893         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13894         ndr->depth++;
13895         if (flags & NDR_SET_VALUES) {
13896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13897         }
13898         if (flags & NDR_IN) {
13899                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13900                 ndr->depth++;
13901                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13902                 ndr->depth++;
13903                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13904                 ndr->depth--;
13905                 ndr_print_int32(ndr, "level", r->in.level);
13906                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13907                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13908                 ndr->depth--;
13909         }
13910         if (flags & NDR_OUT) {
13911                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13912                 ndr->depth++;
13913                 ndr_print_WERROR(ndr, "result", r->out.result);
13914                 ndr->depth--;
13915         }
13916         ndr->depth--;
13917 }
13918
13919 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13920 {
13921         if (flags & NDR_IN) {
13922         }
13923         if (flags & NDR_OUT) {
13924                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13925         }
13926         return NDR_ERR_SUCCESS;
13927 }
13928
13929 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13930 {
13931         if (flags & NDR_IN) {
13932         }
13933         if (flags & NDR_OUT) {
13934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13935         }
13936         return NDR_ERR_SUCCESS;
13937 }
13938
13939 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13940 {
13941         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13942         ndr->depth++;
13943         if (flags & NDR_SET_VALUES) {
13944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13945         }
13946         if (flags & NDR_IN) {
13947                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13948                 ndr->depth++;
13949                 ndr->depth--;
13950         }
13951         if (flags & NDR_OUT) {
13952                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13953                 ndr->depth++;
13954                 ndr_print_WERROR(ndr, "result", r->out.result);
13955                 ndr->depth--;
13956         }
13957         ndr->depth--;
13958 }
13959
13960 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13961 {
13962         if (flags & NDR_IN) {
13963                 if (r->in.bind_handle == NULL) {
13964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13965                 }
13966                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13967                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13968                 if (r->in.req == NULL) {
13969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13970                 }
13971                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13972                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13973         }
13974         if (flags & NDR_OUT) {
13975                 if (r->out.level_out == NULL) {
13976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13977                 }
13978                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13979                 if (r->out.ctr == NULL) {
13980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13981                 }
13982                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13983                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13984                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13985         }
13986         return NDR_ERR_SUCCESS;
13987 }
13988
13989 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13990 {
13991         TALLOC_CTX *_mem_save_bind_handle_0;
13992         TALLOC_CTX *_mem_save_req_0;
13993         TALLOC_CTX *_mem_save_level_out_0;
13994         TALLOC_CTX *_mem_save_ctr_0;
13995         if (flags & NDR_IN) {
13996                 ZERO_STRUCT(r->out);
13997
13998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13999                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14000                 }
14001                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14002                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14003                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14005                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14007                         NDR_PULL_ALLOC(ndr, r->in.req);
14008                 }
14009                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14010                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14011                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14012                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14014                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14015                 ZERO_STRUCTP(r->out.level_out);
14016                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14017                 ZERO_STRUCTP(r->out.ctr);
14018         }
14019         if (flags & NDR_OUT) {
14020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14021                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14022                 }
14023                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14025                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14028                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14029                 }
14030                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14031                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14032                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14033                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14035                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14036         }
14037         return NDR_ERR_SUCCESS;
14038 }
14039
14040 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14041 {
14042         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14043         ndr->depth++;
14044         if (flags & NDR_SET_VALUES) {
14045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14046         }
14047         if (flags & NDR_IN) {
14048                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14049                 ndr->depth++;
14050                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14051                 ndr->depth++;
14052                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14053                 ndr->depth--;
14054                 ndr_print_int32(ndr, "level", r->in.level);
14055                 ndr_print_ptr(ndr, "req", r->in.req);
14056                 ndr->depth++;
14057                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14058                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14059                 ndr->depth--;
14060                 ndr->depth--;
14061         }
14062         if (flags & NDR_OUT) {
14063                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14064                 ndr->depth++;
14065                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14066                 ndr->depth++;
14067                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14068                 ndr->depth--;
14069                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14070                 ndr->depth++;
14071                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14072                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14073                 ndr->depth--;
14074                 ndr_print_WERROR(ndr, "result", r->out.result);
14075                 ndr->depth--;
14076         }
14077         ndr->depth--;
14078 }
14079
14080 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14081 {
14082         if (flags & NDR_IN) {
14083         }
14084         if (flags & NDR_OUT) {
14085                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14086         }
14087         return NDR_ERR_SUCCESS;
14088 }
14089
14090 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14091 {
14092         if (flags & NDR_IN) {
14093         }
14094         if (flags & NDR_OUT) {
14095                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14096         }
14097         return NDR_ERR_SUCCESS;
14098 }
14099
14100 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14101 {
14102         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14103         ndr->depth++;
14104         if (flags & NDR_SET_VALUES) {
14105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14106         }
14107         if (flags & NDR_IN) {
14108                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14109                 ndr->depth++;
14110                 ndr->depth--;
14111         }
14112         if (flags & NDR_OUT) {
14113                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14114                 ndr->depth++;
14115                 ndr_print_WERROR(ndr, "result", r->out.result);
14116                 ndr->depth--;
14117         }
14118         ndr->depth--;
14119 }
14120
14121 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14122 {
14123         if (flags & NDR_IN) {
14124                 if (r->in.bind_handle == NULL) {
14125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14126                 }
14127                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14129                 if (r->in.req == NULL) {
14130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14131                 }
14132                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14133                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14134         }
14135         if (flags & NDR_OUT) {
14136                 if (r->out.level_out == NULL) {
14137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14138                 }
14139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14140                 if (r->out.info == NULL) {
14141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14142                 }
14143                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14144                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14146         }
14147         return NDR_ERR_SUCCESS;
14148 }
14149
14150 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14151 {
14152         TALLOC_CTX *_mem_save_bind_handle_0;
14153         TALLOC_CTX *_mem_save_req_0;
14154         TALLOC_CTX *_mem_save_level_out_0;
14155         TALLOC_CTX *_mem_save_info_0;
14156         if (flags & NDR_IN) {
14157                 ZERO_STRUCT(r->out);
14158
14159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14160                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14161                 }
14162                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14163                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14164                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14168                         NDR_PULL_ALLOC(ndr, r->in.req);
14169                 }
14170                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14172                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14173                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14175                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14176                 ZERO_STRUCTP(r->out.level_out);
14177                 NDR_PULL_ALLOC(ndr, r->out.info);
14178                 ZERO_STRUCTP(r->out.info);
14179         }
14180         if (flags & NDR_OUT) {
14181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14182                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14183                 }
14184                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14185                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14187                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14189                         NDR_PULL_ALLOC(ndr, r->out.info);
14190                 }
14191                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14192                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14193                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14194                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14197         }
14198         return NDR_ERR_SUCCESS;
14199 }
14200
14201 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14202 {
14203         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14204         ndr->depth++;
14205         if (flags & NDR_SET_VALUES) {
14206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14207         }
14208         if (flags & NDR_IN) {
14209                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14210                 ndr->depth++;
14211                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14212                 ndr->depth++;
14213                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14214                 ndr->depth--;
14215                 ndr_print_uint32(ndr, "level", r->in.level);
14216                 ndr_print_ptr(ndr, "req", r->in.req);
14217                 ndr->depth++;
14218                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14219                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14220                 ndr->depth--;
14221                 ndr->depth--;
14222         }
14223         if (flags & NDR_OUT) {
14224                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14225                 ndr->depth++;
14226                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14227                 ndr->depth++;
14228                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14229                 ndr->depth--;
14230                 ndr_print_ptr(ndr, "info", r->out.info);
14231                 ndr->depth++;
14232                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14233                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14234                 ndr->depth--;
14235                 ndr_print_WERROR(ndr, "result", r->out.result);
14236                 ndr->depth--;
14237         }
14238         ndr->depth--;
14239 }
14240
14241 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14242 {
14243         if (flags & NDR_IN) {
14244                 if (r->in.bind_handle == NULL) {
14245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14246                 }
14247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14248                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14249                 if (r->in.req == NULL) {
14250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14251                 }
14252                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14253                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14254         }
14255         if (flags & NDR_OUT) {
14256                 if (r->out.level_out == NULL) {
14257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14258                 }
14259                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14260                 if (r->out.ctr == NULL) {
14261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14262                 }
14263                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14264                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14266         }
14267         return NDR_ERR_SUCCESS;
14268 }
14269
14270 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14271 {
14272         TALLOC_CTX *_mem_save_bind_handle_0;
14273         TALLOC_CTX *_mem_save_req_0;
14274         TALLOC_CTX *_mem_save_level_out_0;
14275         TALLOC_CTX *_mem_save_ctr_0;
14276         if (flags & NDR_IN) {
14277                 ZERO_STRUCT(r->out);
14278
14279                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14280                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14281                 }
14282                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14283                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14284                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14285                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14286                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14288                         NDR_PULL_ALLOC(ndr, r->in.req);
14289                 }
14290                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14291                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14292                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14293                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14295                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14296                 ZERO_STRUCTP(r->out.level_out);
14297                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14298                 ZERO_STRUCTP(r->out.ctr);
14299         }
14300         if (flags & NDR_OUT) {
14301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14302                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14303                 }
14304                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14305                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14306                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14309                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14310                 }
14311                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14313                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14314                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14316                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14317         }
14318         return NDR_ERR_SUCCESS;
14319 }
14320
14321 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14322 {
14323         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14324         ndr->depth++;
14325         if (flags & NDR_SET_VALUES) {
14326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14327         }
14328         if (flags & NDR_IN) {
14329                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14330                 ndr->depth++;
14331                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14332                 ndr->depth++;
14333                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14334                 ndr->depth--;
14335                 ndr_print_int32(ndr, "level", r->in.level);
14336                 ndr_print_ptr(ndr, "req", r->in.req);
14337                 ndr->depth++;
14338                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14339                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14340                 ndr->depth--;
14341                 ndr->depth--;
14342         }
14343         if (flags & NDR_OUT) {
14344                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14345                 ndr->depth++;
14346                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14347                 ndr->depth++;
14348                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14349                 ndr->depth--;
14350                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14351                 ndr->depth++;
14352                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14353                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14354                 ndr->depth--;
14355                 ndr_print_WERROR(ndr, "result", r->out.result);
14356                 ndr->depth--;
14357         }
14358         ndr->depth--;
14359 }
14360
14361 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14362 {
14363         if (flags & NDR_IN) {
14364                 if (r->in.bind_handle == NULL) {
14365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14366                 }
14367                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14368                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14369                 if (r->in.req == NULL) {
14370                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14371                 }
14372                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14373                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14374         }
14375         if (flags & NDR_OUT) {
14376                 if (r->out.level_out == NULL) {
14377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14378                 }
14379                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14380                 if (r->out.res == NULL) {
14381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14382                 }
14383                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14384                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14385                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14386         }
14387         return NDR_ERR_SUCCESS;
14388 }
14389
14390 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14391 {
14392         TALLOC_CTX *_mem_save_bind_handle_0;
14393         TALLOC_CTX *_mem_save_req_0;
14394         TALLOC_CTX *_mem_save_level_out_0;
14395         TALLOC_CTX *_mem_save_res_0;
14396         if (flags & NDR_IN) {
14397                 ZERO_STRUCT(r->out);
14398
14399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14400                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14401                 }
14402                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14403                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14404                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14406                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14408                         NDR_PULL_ALLOC(ndr, r->in.req);
14409                 }
14410                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14412                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14413                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14415                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14416                 ZERO_STRUCTP(r->out.level_out);
14417                 NDR_PULL_ALLOC(ndr, r->out.res);
14418                 ZERO_STRUCTP(r->out.res);
14419         }
14420         if (flags & NDR_OUT) {
14421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14422                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14423                 }
14424                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14425                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14426                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14429                         NDR_PULL_ALLOC(ndr, r->out.res);
14430                 }
14431                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14433                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14434                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14436                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14437         }
14438         return NDR_ERR_SUCCESS;
14439 }
14440
14441 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14442 {
14443         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14444         ndr->depth++;
14445         if (flags & NDR_SET_VALUES) {
14446                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14447         }
14448         if (flags & NDR_IN) {
14449                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14450                 ndr->depth++;
14451                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14452                 ndr->depth++;
14453                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14454                 ndr->depth--;
14455                 ndr_print_int32(ndr, "level", r->in.level);
14456                 ndr_print_ptr(ndr, "req", r->in.req);
14457                 ndr->depth++;
14458                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14459                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14460                 ndr->depth--;
14461                 ndr->depth--;
14462         }
14463         if (flags & NDR_OUT) {
14464                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14465                 ndr->depth++;
14466                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14467                 ndr->depth++;
14468                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14469                 ndr->depth--;
14470                 ndr_print_ptr(ndr, "res", r->out.res);
14471                 ndr->depth++;
14472                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14473                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14474                 ndr->depth--;
14475                 ndr_print_WERROR(ndr, "result", r->out.result);
14476                 ndr->depth--;
14477         }
14478         ndr->depth--;
14479 }
14480
14481 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14482 {
14483         if (flags & NDR_IN) {
14484                 if (r->in.bind_handle == NULL) {
14485                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14486                 }
14487                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14488                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14489                 if (r->in.req == NULL) {
14490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14491                 }
14492                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14493                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14494         }
14495         if (flags & NDR_OUT) {
14496                 if (r->out.level_out == NULL) {
14497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14498                 }
14499                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14500                 if (r->out.res == NULL) {
14501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14502                 }
14503                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14504                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14505                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14506         }
14507         return NDR_ERR_SUCCESS;
14508 }
14509
14510 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14511 {
14512         TALLOC_CTX *_mem_save_bind_handle_0;
14513         TALLOC_CTX *_mem_save_req_0;
14514         TALLOC_CTX *_mem_save_level_out_0;
14515         TALLOC_CTX *_mem_save_res_0;
14516         if (flags & NDR_IN) {
14517                 ZERO_STRUCT(r->out);
14518
14519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14520                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14521                 }
14522                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14523                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14524                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14526                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14528                         NDR_PULL_ALLOC(ndr, r->in.req);
14529                 }
14530                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14531                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14532                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14533                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14535                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14536                 ZERO_STRUCTP(r->out.level_out);
14537                 NDR_PULL_ALLOC(ndr, r->out.res);
14538                 ZERO_STRUCTP(r->out.res);
14539         }
14540         if (flags & NDR_OUT) {
14541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14542                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14543                 }
14544                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14546                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14548                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14549                         NDR_PULL_ALLOC(ndr, r->out.res);
14550                 }
14551                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14552                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14553                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14554                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14557         }
14558         return NDR_ERR_SUCCESS;
14559 }
14560
14561 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14562 {
14563         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14564         ndr->depth++;
14565         if (flags & NDR_SET_VALUES) {
14566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14567         }
14568         if (flags & NDR_IN) {
14569                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14570                 ndr->depth++;
14571                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14572                 ndr->depth++;
14573                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14574                 ndr->depth--;
14575                 ndr_print_int32(ndr, "level", r->in.level);
14576                 ndr_print_ptr(ndr, "req", r->in.req);
14577                 ndr->depth++;
14578                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14579                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14580                 ndr->depth--;
14581                 ndr->depth--;
14582         }
14583         if (flags & NDR_OUT) {
14584                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14585                 ndr->depth++;
14586                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14587                 ndr->depth++;
14588                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14589                 ndr->depth--;
14590                 ndr_print_ptr(ndr, "res", r->out.res);
14591                 ndr->depth++;
14592                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14593                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14594                 ndr->depth--;
14595                 ndr_print_WERROR(ndr, "result", r->out.result);
14596                 ndr->depth--;
14597         }
14598         ndr->depth--;
14599 }
14600
14601 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14602 {
14603         if (flags & NDR_IN) {
14604         }
14605         if (flags & NDR_OUT) {
14606                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14607         }
14608         return NDR_ERR_SUCCESS;
14609 }
14610
14611 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14612 {
14613         if (flags & NDR_IN) {
14614         }
14615         if (flags & NDR_OUT) {
14616                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14617         }
14618         return NDR_ERR_SUCCESS;
14619 }
14620
14621 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14622 {
14623         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14624         ndr->depth++;
14625         if (flags & NDR_SET_VALUES) {
14626                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14627         }
14628         if (flags & NDR_IN) {
14629                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14630                 ndr->depth++;
14631                 ndr->depth--;
14632         }
14633         if (flags & NDR_OUT) {
14634                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14635                 ndr->depth++;
14636                 ndr_print_WERROR(ndr, "result", r->out.result);
14637                 ndr->depth--;
14638         }
14639         ndr->depth--;
14640 }
14641
14642 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14643 {
14644         if (flags & NDR_IN) {
14645                 if (r->in.bind_handle == NULL) {
14646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14647                 }
14648                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14649                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14650                 if (r->in.req == NULL) {
14651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14652                 }
14653                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14654                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14655         }
14656         if (flags & NDR_OUT) {
14657                 if (r->out.level_out == NULL) {
14658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14659                 }
14660                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14661                 if (r->out.ctr == NULL) {
14662                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14663                 }
14664                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14665                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14667         }
14668         return NDR_ERR_SUCCESS;
14669 }
14670
14671 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14672 {
14673         TALLOC_CTX *_mem_save_bind_handle_0;
14674         TALLOC_CTX *_mem_save_req_0;
14675         TALLOC_CTX *_mem_save_level_out_0;
14676         TALLOC_CTX *_mem_save_ctr_0;
14677         if (flags & NDR_IN) {
14678                 ZERO_STRUCT(r->out);
14679
14680                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14681                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14682                 }
14683                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14684                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14685                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14687                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14689                         NDR_PULL_ALLOC(ndr, r->in.req);
14690                 }
14691                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14692                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14693                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14694                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14696                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14697                 ZERO_STRUCTP(r->out.level_out);
14698                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14699                 ZERO_STRUCTP(r->out.ctr);
14700         }
14701         if (flags & NDR_OUT) {
14702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14703                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14704                 }
14705                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14706                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14707                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14709                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14710                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14711                 }
14712                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14713                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14714                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14715                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14717                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14718         }
14719         return NDR_ERR_SUCCESS;
14720 }
14721
14722 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14723 {
14724         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14725         ndr->depth++;
14726         if (flags & NDR_SET_VALUES) {
14727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14728         }
14729         if (flags & NDR_IN) {
14730                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14731                 ndr->depth++;
14732                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14733                 ndr->depth++;
14734                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14735                 ndr->depth--;
14736                 ndr_print_int32(ndr, "level", r->in.level);
14737                 ndr_print_ptr(ndr, "req", r->in.req);
14738                 ndr->depth++;
14739                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14740                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14741                 ndr->depth--;
14742                 ndr->depth--;
14743         }
14744         if (flags & NDR_OUT) {
14745                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14746                 ndr->depth++;
14747                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14748                 ndr->depth++;
14749                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14750                 ndr->depth--;
14751                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14752                 ndr->depth++;
14753                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14754                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14755                 ndr->depth--;
14756                 ndr_print_WERROR(ndr, "result", r->out.result);
14757                 ndr->depth--;
14758         }
14759         ndr->depth--;
14760 }
14761
14762 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14763 {
14764         if (flags & NDR_IN) {
14765                 if (r->in.bind_handle == NULL) {
14766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14767                 }
14768                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14769                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14770                 if (r->in.req == NULL) {
14771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14772                 }
14773                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14774                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14775         }
14776         if (flags & NDR_OUT) {
14777                 if (r->out.level_out == NULL) {
14778                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14779                 }
14780                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14781                 if (r->out.ctr == NULL) {
14782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14783                 }
14784                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14785                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14787         }
14788         return NDR_ERR_SUCCESS;
14789 }
14790
14791 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14792 {
14793         TALLOC_CTX *_mem_save_bind_handle_0;
14794         TALLOC_CTX *_mem_save_req_0;
14795         TALLOC_CTX *_mem_save_level_out_0;
14796         TALLOC_CTX *_mem_save_ctr_0;
14797         if (flags & NDR_IN) {
14798                 ZERO_STRUCT(r->out);
14799
14800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14801                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14802                 }
14803                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14804                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14805                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14807                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14809                         NDR_PULL_ALLOC(ndr, r->in.req);
14810                 }
14811                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14813                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14814                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14816                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14817                 ZERO_STRUCTP(r->out.level_out);
14818                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14819                 ZERO_STRUCTP(r->out.ctr);
14820         }
14821         if (flags & NDR_OUT) {
14822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14823                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14824                 }
14825                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14826                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14827                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14830                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14831                 }
14832                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14833                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14834                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14835                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14836                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14838         }
14839         return NDR_ERR_SUCCESS;
14840 }
14841
14842 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14843 {
14844         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14845         ndr->depth++;
14846         if (flags & NDR_SET_VALUES) {
14847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14848         }
14849         if (flags & NDR_IN) {
14850                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14851                 ndr->depth++;
14852                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14853                 ndr->depth++;
14854                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14855                 ndr->depth--;
14856                 ndr_print_int32(ndr, "level", r->in.level);
14857                 ndr_print_ptr(ndr, "req", r->in.req);
14858                 ndr->depth++;
14859                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14860                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14861                 ndr->depth--;
14862                 ndr->depth--;
14863         }
14864         if (flags & NDR_OUT) {
14865                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14866                 ndr->depth++;
14867                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14868                 ndr->depth++;
14869                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14870                 ndr->depth--;
14871                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14872                 ndr->depth++;
14873                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14874                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14875                 ndr->depth--;
14876                 ndr_print_WERROR(ndr, "result", r->out.result);
14877                 ndr->depth--;
14878         }
14879         ndr->depth--;
14880 }
14881
14882 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14883 {
14884         if (flags & NDR_IN) {
14885                 if (r->in.bind_handle == NULL) {
14886                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14887                 }
14888                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14890                 if (r->in.req == NULL) {
14891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14892                 }
14893                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14894                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14895         }
14896         if (flags & NDR_OUT) {
14897                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14898         }
14899         return NDR_ERR_SUCCESS;
14900 }
14901
14902 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14903 {
14904         TALLOC_CTX *_mem_save_bind_handle_0;
14905         TALLOC_CTX *_mem_save_req_0;
14906         if (flags & NDR_IN) {
14907                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14908                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14909                 }
14910                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14911                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14912                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14913                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14916                         NDR_PULL_ALLOC(ndr, r->in.req);
14917                 }
14918                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14919                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14920                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14921                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14923         }
14924         if (flags & NDR_OUT) {
14925                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14926         }
14927         return NDR_ERR_SUCCESS;
14928 }
14929
14930 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14931 {
14932         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14933         ndr->depth++;
14934         if (flags & NDR_SET_VALUES) {
14935                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14936         }
14937         if (flags & NDR_IN) {
14938                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14939                 ndr->depth++;
14940                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14941                 ndr->depth++;
14942                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14943                 ndr->depth--;
14944                 ndr_print_uint32(ndr, "level", r->in.level);
14945                 ndr_print_ptr(ndr, "req", r->in.req);
14946                 ndr->depth++;
14947                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14948                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14949                 ndr->depth--;
14950                 ndr->depth--;
14951         }
14952         if (flags & NDR_OUT) {
14953                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14954                 ndr->depth++;
14955                 ndr_print_WERROR(ndr, "result", r->out.result);
14956                 ndr->depth--;
14957         }
14958         ndr->depth--;
14959 }
14960
14961 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14962 {
14963         if (flags & NDR_IN) {
14964                 if (r->in.bind_handle == NULL) {
14965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14966                 }
14967                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14968                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14969                 if (r->in.req == NULL) {
14970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14971                 }
14972                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14973                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14974         }
14975         if (flags & NDR_OUT) {
14976                 if (r->out.info_type == NULL) {
14977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14978                 }
14979                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14980                 if (r->out.info == NULL) {
14981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14982                 }
14983                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14984                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14986         }
14987         return NDR_ERR_SUCCESS;
14988 }
14989
14990 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14991 {
14992         TALLOC_CTX *_mem_save_bind_handle_0;
14993         TALLOC_CTX *_mem_save_req_0;
14994         TALLOC_CTX *_mem_save_info_type_0;
14995         TALLOC_CTX *_mem_save_info_0;
14996         if (flags & NDR_IN) {
14997                 ZERO_STRUCT(r->out);
14998
14999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15000                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15001                 }
15002                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15006                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15008                         NDR_PULL_ALLOC(ndr, r->in.req);
15009                 }
15010                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15011                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15012                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15013                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15015                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15016                 ZERO_STRUCTP(r->out.info_type);
15017                 NDR_PULL_ALLOC(ndr, r->out.info);
15018                 ZERO_STRUCTP(r->out.info);
15019         }
15020         if (flags & NDR_OUT) {
15021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15022                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15023                 }
15024                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15025                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15026                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15029                         NDR_PULL_ALLOC(ndr, r->out.info);
15030                 }
15031                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15033                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15034                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15036                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15037         }
15038         return NDR_ERR_SUCCESS;
15039 }
15040
15041 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15042 {
15043         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15044         ndr->depth++;
15045         if (flags & NDR_SET_VALUES) {
15046                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15047         }
15048         if (flags & NDR_IN) {
15049                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15050                 ndr->depth++;
15051                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15052                 ndr->depth++;
15053                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15054                 ndr->depth--;
15055                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15056                 ndr_print_ptr(ndr, "req", r->in.req);
15057                 ndr->depth++;
15058                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15059                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15060                 ndr->depth--;
15061                 ndr->depth--;
15062         }
15063         if (flags & NDR_OUT) {
15064                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15065                 ndr->depth++;
15066                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15067                 ndr->depth++;
15068                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15069                 ndr->depth--;
15070                 ndr_print_ptr(ndr, "info", r->out.info);
15071                 ndr->depth++;
15072                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15073                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15074                 ndr->depth--;
15075                 ndr_print_WERROR(ndr, "result", r->out.result);
15076                 ndr->depth--;
15077         }
15078         ndr->depth--;
15079 }
15080
15081 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15082 {
15083         if (flags & NDR_IN) {
15084         }
15085         if (flags & NDR_OUT) {
15086                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15087         }
15088         return NDR_ERR_SUCCESS;
15089 }
15090
15091 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15092 {
15093         if (flags & NDR_IN) {
15094         }
15095         if (flags & NDR_OUT) {
15096                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15097         }
15098         return NDR_ERR_SUCCESS;
15099 }
15100
15101 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15102 {
15103         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15104         ndr->depth++;
15105         if (flags & NDR_SET_VALUES) {
15106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15107         }
15108         if (flags & NDR_IN) {
15109                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15110                 ndr->depth++;
15111                 ndr->depth--;
15112         }
15113         if (flags & NDR_OUT) {
15114                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15115                 ndr->depth++;
15116                 ndr_print_WERROR(ndr, "result", r->out.result);
15117                 ndr->depth--;
15118         }
15119         ndr->depth--;
15120 }
15121
15122 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15123 {
15124         if (flags & NDR_IN) {
15125                 if (r->in.bind_handle == NULL) {
15126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15127                 }
15128                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15129                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15130                 if (r->in.req == NULL) {
15131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15132                 }
15133                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15134                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15135         }
15136         if (flags & NDR_OUT) {
15137                 if (r->out.level_out == NULL) {
15138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15139                 }
15140                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15141                 if (r->out.ctr == NULL) {
15142                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15143                 }
15144                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15145                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15147         }
15148         return NDR_ERR_SUCCESS;
15149 }
15150
15151 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15152 {
15153         TALLOC_CTX *_mem_save_bind_handle_0;
15154         TALLOC_CTX *_mem_save_req_0;
15155         TALLOC_CTX *_mem_save_level_out_0;
15156         TALLOC_CTX *_mem_save_ctr_0;
15157         if (flags & NDR_IN) {
15158                 ZERO_STRUCT(r->out);
15159
15160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15161                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15162                 }
15163                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15165                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15167                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15169                         NDR_PULL_ALLOC(ndr, r->in.req);
15170                 }
15171                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15172                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15173                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15174                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15176                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15177                 ZERO_STRUCTP(r->out.level_out);
15178                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15179                 ZERO_STRUCTP(r->out.ctr);
15180         }
15181         if (flags & NDR_OUT) {
15182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15183                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15184                 }
15185                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15186                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15187                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15190                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15191                 }
15192                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15194                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15195                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15198         }
15199         return NDR_ERR_SUCCESS;
15200 }
15201
15202 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15203 {
15204         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15205         ndr->depth++;
15206         if (flags & NDR_SET_VALUES) {
15207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15208         }
15209         if (flags & NDR_IN) {
15210                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15211                 ndr->depth++;
15212                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15213                 ndr->depth++;
15214                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15215                 ndr->depth--;
15216                 ndr_print_int32(ndr, "level", r->in.level);
15217                 ndr_print_ptr(ndr, "req", r->in.req);
15218                 ndr->depth++;
15219                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15220                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15221                 ndr->depth--;
15222                 ndr->depth--;
15223         }
15224         if (flags & NDR_OUT) {
15225                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15226                 ndr->depth++;
15227                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15228                 ndr->depth++;
15229                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15230                 ndr->depth--;
15231                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15232                 ndr->depth++;
15233                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15234                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15235                 ndr->depth--;
15236                 ndr_print_WERROR(ndr, "result", r->out.result);
15237                 ndr->depth--;
15238         }
15239         ndr->depth--;
15240 }
15241
15242 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15243 {
15244         if (flags & NDR_IN) {
15245         }
15246         if (flags & NDR_OUT) {
15247                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15248         }
15249         return NDR_ERR_SUCCESS;
15250 }
15251
15252 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15253 {
15254         if (flags & NDR_IN) {
15255         }
15256         if (flags & NDR_OUT) {
15257                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15258         }
15259         return NDR_ERR_SUCCESS;
15260 }
15261
15262 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15263 {
15264         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15265         ndr->depth++;
15266         if (flags & NDR_SET_VALUES) {
15267                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15268         }
15269         if (flags & NDR_IN) {
15270                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15271                 ndr->depth++;
15272                 ndr->depth--;
15273         }
15274         if (flags & NDR_OUT) {
15275                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15276                 ndr->depth++;
15277                 ndr_print_WERROR(ndr, "result", r->out.result);
15278                 ndr->depth--;
15279         }
15280         ndr->depth--;
15281 }
15282
15283 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15284 {
15285         if (flags & NDR_IN) {
15286         }
15287         if (flags & NDR_OUT) {
15288                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15289         }
15290         return NDR_ERR_SUCCESS;
15291 }
15292
15293 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15294 {
15295         if (flags & NDR_IN) {
15296         }
15297         if (flags & NDR_OUT) {
15298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15299         }
15300         return NDR_ERR_SUCCESS;
15301 }
15302
15303 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15304 {
15305         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15306         ndr->depth++;
15307         if (flags & NDR_SET_VALUES) {
15308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15309         }
15310         if (flags & NDR_IN) {
15311                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15312                 ndr->depth++;
15313                 ndr->depth--;
15314         }
15315         if (flags & NDR_OUT) {
15316                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15317                 ndr->depth++;
15318                 ndr_print_WERROR(ndr, "result", r->out.result);
15319                 ndr->depth--;
15320         }
15321         ndr->depth--;
15322 }
15323
15324 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15325 {
15326         if (flags & NDR_IN) {
15327                 if (r->in.bind_handle == NULL) {
15328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15329                 }
15330                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15331                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15332                 if (r->in.req == NULL) {
15333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15334                 }
15335                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15336                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15337         }
15338         if (flags & NDR_OUT) {
15339                 if (r->out.level_out == NULL) {
15340                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15341                 }
15342                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15343                 if (r->out.ctr == NULL) {
15344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15345                 }
15346                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15347                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15349         }
15350         return NDR_ERR_SUCCESS;
15351 }
15352
15353 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15354 {
15355         TALLOC_CTX *_mem_save_bind_handle_0;
15356         TALLOC_CTX *_mem_save_req_0;
15357         TALLOC_CTX *_mem_save_level_out_0;
15358         TALLOC_CTX *_mem_save_ctr_0;
15359         if (flags & NDR_IN) {
15360                 ZERO_STRUCT(r->out);
15361
15362                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15363                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15364                 }
15365                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15366                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15367                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15368                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15369                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15371                         NDR_PULL_ALLOC(ndr, r->in.req);
15372                 }
15373                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15374                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15375                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15376                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15378                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15379                 ZERO_STRUCTP(r->out.level_out);
15380                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15381                 ZERO_STRUCTP(r->out.ctr);
15382         }
15383         if (flags & NDR_OUT) {
15384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15385                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15386                 }
15387                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15388                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15389                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15391                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15392                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15393                 }
15394                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15395                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15396                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15397                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15399                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15400         }
15401         return NDR_ERR_SUCCESS;
15402 }
15403
15404 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15405 {
15406         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15407         ndr->depth++;
15408         if (flags & NDR_SET_VALUES) {
15409                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15410         }
15411         if (flags & NDR_IN) {
15412                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15413                 ndr->depth++;
15414                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15415                 ndr->depth++;
15416                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15417                 ndr->depth--;
15418                 ndr_print_int32(ndr, "level", r->in.level);
15419                 ndr_print_ptr(ndr, "req", r->in.req);
15420                 ndr->depth++;
15421                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15422                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15423                 ndr->depth--;
15424                 ndr->depth--;
15425         }
15426         if (flags & NDR_OUT) {
15427                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15428                 ndr->depth++;
15429                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15430                 ndr->depth++;
15431                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15432                 ndr->depth--;
15433                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15434                 ndr->depth++;
15435                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15436                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15437                 ndr->depth--;
15438                 ndr_print_WERROR(ndr, "result", r->out.result);
15439                 ndr->depth--;
15440         }
15441         ndr->depth--;
15442 }
15443
15444 static const struct ndr_interface_call drsuapi_calls[] = {
15445         {
15446                 "drsuapi_DsBind",
15447                 sizeof(struct drsuapi_DsBind),
15448                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15449                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15450                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15451                 false,
15452         },
15453         {
15454                 "drsuapi_DsUnbind",
15455                 sizeof(struct drsuapi_DsUnbind),
15456                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15457                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15458                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15459                 false,
15460         },
15461         {
15462                 "drsuapi_DsReplicaSync",
15463                 sizeof(struct drsuapi_DsReplicaSync),
15464                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15465                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15466                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15467                 false,
15468         },
15469         {
15470                 "drsuapi_DsGetNCChanges",
15471                 sizeof(struct drsuapi_DsGetNCChanges),
15472                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15473                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15474                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15475                 false,
15476         },
15477         {
15478                 "drsuapi_DsReplicaUpdateRefs",
15479                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15480                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15481                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15482                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15483                 false,
15484         },
15485         {
15486                 "drsuapi_DsReplicaAdd",
15487                 sizeof(struct drsuapi_DsReplicaAdd),
15488                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15489                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15490                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15491                 false,
15492         },
15493         {
15494                 "drsuapi_DsReplicaDel",
15495                 sizeof(struct drsuapi_DsReplicaDel),
15496                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15497                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15498                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15499                 false,
15500         },
15501         {
15502                 "drsuapi_DsReplicaMod",
15503                 sizeof(struct drsuapi_DsReplicaMod),
15504                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15505                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15506                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15507                 false,
15508         },
15509         {
15510                 "DRSUAPI_VERIFY_NAMES",
15511                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15512                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15513                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15514                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15515                 false,
15516         },
15517         {
15518                 "drsuapi_DsGetMemberships",
15519                 sizeof(struct drsuapi_DsGetMemberships),
15520                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15521                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15522                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15523                 false,
15524         },
15525         {
15526                 "DRSUAPI_INTER_DOMAIN_MOVE",
15527                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15528                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15529                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15530                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15531                 false,
15532         },
15533         {
15534                 "drsuapi_DsGetNT4ChangeLog",
15535                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15536                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15537                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15538                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15539                 false,
15540         },
15541         {
15542                 "drsuapi_DsCrackNames",
15543                 sizeof(struct drsuapi_DsCrackNames),
15544                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15545                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15546                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15547                 false,
15548         },
15549         {
15550                 "drsuapi_DsWriteAccountSpn",
15551                 sizeof(struct drsuapi_DsWriteAccountSpn),
15552                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15553                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15554                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15555                 false,
15556         },
15557         {
15558                 "drsuapi_DsRemoveDSServer",
15559                 sizeof(struct drsuapi_DsRemoveDSServer),
15560                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15561                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15562                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15563                 false,
15564         },
15565         {
15566                 "DRSUAPI_REMOVE_DS_DOMAIN",
15567                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15568                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15569                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15570                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15571                 false,
15572         },
15573         {
15574                 "drsuapi_DsGetDomainControllerInfo",
15575                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15576                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15577                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15578                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15579                 false,
15580         },
15581         {
15582                 "drsuapi_DsAddEntry",
15583                 sizeof(struct drsuapi_DsAddEntry),
15584                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15585                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15586                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15587                 false,
15588         },
15589         {
15590                 "drsuapi_DsExecuteKCC",
15591                 sizeof(struct drsuapi_DsExecuteKCC),
15592                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15593                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15594                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15595                 false,
15596         },
15597         {
15598                 "drsuapi_DsReplicaGetInfo",
15599                 sizeof(struct drsuapi_DsReplicaGetInfo),
15600                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15601                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15602                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15603                 false,
15604         },
15605         {
15606                 "DRSUAPI_ADD_SID_HISTORY",
15607                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15608                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15609                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15610                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15611                 false,
15612         },
15613         {
15614                 "drsuapi_DsGetMemberships2",
15615                 sizeof(struct drsuapi_DsGetMemberships2),
15616                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15617                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15618                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15619                 false,
15620         },
15621         {
15622                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15623                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15624                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15625                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15626                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15627                 false,
15628         },
15629         {
15630                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15631                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15632                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15633                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15634                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15635                 false,
15636         },
15637         {
15638                 "drsuapi_QuerySitesByCost",
15639                 sizeof(struct drsuapi_QuerySitesByCost),
15640                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15641                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15642                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15643                 false,
15644         },
15645         { NULL, 0, NULL, NULL, NULL, false }
15646 };
15647
15648 static const char * const drsuapi_endpoint_strings[] = {
15649         "ncacn_np:[\\pipe\\lsass]",
15650         "ncacn_np:[\\pipe\\protected_storage]",
15651         "ncacn_ip_tcp:",
15652         "ncalrpc:",
15653 };
15654
15655 static const struct ndr_interface_string_array drsuapi_endpoints = {
15656         .count  = 4,
15657         .names  = drsuapi_endpoint_strings
15658 };
15659
15660 static const char * const drsuapi_authservice_strings[] = {
15661         "ldap",
15662 };
15663
15664 static const struct ndr_interface_string_array drsuapi_authservices = {
15665         .count  = 1,
15666         .names  = drsuapi_authservice_strings
15667 };
15668
15669
15670 const struct ndr_interface_table ndr_table_drsuapi = {
15671         .name           = "drsuapi",
15672         .syntax_id      = {
15673                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15674                 NDR_DRSUAPI_VERSION
15675         },
15676         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15677         .num_calls      = 25,
15678         .calls          = drsuapi_calls,
15679         .endpoints      = &drsuapi_endpoints,
15680         .authservices   = &drsuapi_authservices
15681 };
15682