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 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 571 {
 572         if (ndr_flags & NDR_SCALARS) {
 573                 NDR_CHECK(ndr_push_align(ndr, 5));
 574                 if (r->naming_context == NULL) {
 575                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 576                 }
 577                 NDR_CHECK(ndr_push_ref_ptr(ndr));
 578                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 579                 {
 580                         uint32_t _flags_save_string = ndr->flags;
 581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 582                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dns));
 583                         ndr->flags = _flags_save_string;
 584                 }
 585                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
 586                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 587         }
 588         if (ndr_flags & NDR_BUFFERS) {
 589                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 590                 {
 591                         uint32_t _flags_save_string = ndr->flags;
 592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 593                         if (r->source_dsa_dns) {
 594                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->source_dsa_dns));
 595                         }
 596                         ndr->flags = _flags_save_string;
 597                 }
 598         }
 599         return NDR_ERR_SUCCESS;
 600 }
 601
 602 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 603 {
 604         uint32_t _ptr_naming_context;
 605         TALLOC_CTX *_mem_save_naming_context_0;
 606         uint32_t _ptr_source_dsa_dns;
 607         TALLOC_CTX *_mem_save_source_dsa_dns_0;
 608         if (ndr_flags & NDR_SCALARS) {
 609                 NDR_CHECK(ndr_pull_align(ndr, 5));
 610                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
 611                 if (_ptr_naming_context) {
 612                         NDR_PULL_ALLOC(ndr, r->naming_context);
 613                 } else {
 614                         r->naming_context = NULL;
 615                 }
 616                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 617                 {
 618                         uint32_t _flags_save_string = ndr->flags;
 619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 620                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dns));
 621                         if (_ptr_source_dsa_dns) {
 622                                 NDR_PULL_ALLOC(ndr, r->source_dsa_dns);
 623                         } else {
 624                                 r->source_dsa_dns = NULL;
 625                         }
 626                         ndr->flags = _flags_save_string;
 627                 }
 628                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
 629                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 630         }
 631         if (ndr_flags & NDR_BUFFERS) {
 632                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 633                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 634                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 636                 {
 637                         uint32_t _flags_save_string = ndr->flags;
 638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 639                         if (r->source_dsa_dns) {
 640                                 _mem_save_source_dsa_dns_0 = NDR_PULL_GET_MEM_CTX(ndr);
 641                                 NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dns, 0);
 642                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->source_dsa_dns));
 643                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dns_0, 0);
 644                         }
 645                         ndr->flags = _flags_save_string;
 646                 }
 647         }
 648         return NDR_ERR_SUCCESS;
 649 }
 650
 651 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 652 {
 653         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 654         ndr->depth++;
 655         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 656         ndr->depth++;
 657         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 658         ndr->depth--;
 659         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 660         ndr_print_ptr(ndr, "source_dsa_dns", r->source_dsa_dns);
 661         ndr->depth++;
 662         if (r->source_dsa_dns) {
 663                 ndr_print_string(ndr, "source_dsa_dns", r->source_dsa_dns);
 664         }
 665         ndr->depth--;
 666         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
 667         ndr->depth--;
 668 }
 669
 670 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 671 {
 672         if (ndr_flags & NDR_SCALARS) {
 673                 int level = ndr_push_get_switch_value(ndr, r);
 674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 675                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 676                 switch (level) {
 677                         case 1: {
 678                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 679                         break; }
 680
 681                         default:
 682                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 683                 }
 684         }
 685         if (ndr_flags & NDR_BUFFERS) {
 686                 int level = ndr_push_get_switch_value(ndr, r);
 687                 switch (level) {
 688                         case 1:
 689                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 690                         break;
 691
 692                         default:
 693                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 694                 }
 695         }
 696         return NDR_ERR_SUCCESS;
 697 }
 698
 699 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 700 {
 701         int level;
 702         uint32_t _level;
 703         level = ndr_pull_get_switch_value(ndr, r);
 704         if (ndr_flags & NDR_SCALARS) {
 705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 706                 if (_level != level) {
 707                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 708                 }
 709                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 710                 switch (level) {
 711                         case 1: {
 712                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 713                         break; }
 714
 715                         default:
 716                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 717                 }
 718         }
 719         if (ndr_flags & NDR_BUFFERS) {
 720                 switch (level) {
 721                         case 1:
 722                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 723                         break;
 724
 725                         default:
 726                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 727                 }
 728         }
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 733 {
 734         int level;
 735         level = ndr_print_get_switch_value(ndr, r);
 736         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 737         switch (level) {
 738                 case 1:
 739                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 740                 break;
 741
 742                 default:
 743                         ndr_print_bad_level(ndr, name, level);
 744         }
 745 }
 746
 747 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 748 {
 749         if (ndr_flags & NDR_SCALARS) {
 750                 NDR_CHECK(ndr_push_align(ndr, 8));
 751                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 752                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 753                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 754                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 755         }
 756         if (ndr_flags & NDR_BUFFERS) {
 757         }
 758         return NDR_ERR_SUCCESS;
 759 }
 760
 761 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 762 {
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_pull_align(ndr, 8));
 765                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 766                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 767                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 769         }
 770         if (ndr_flags & NDR_BUFFERS) {
 771         }
 772         return NDR_ERR_SUCCESS;
 773 }
 774
 775 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 776 {
 777         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 778         ndr->depth++;
 779         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 780         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 781         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 782         ndr->depth--;
 783 }
 784
 785 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 786 {
 787         if (ndr_flags & NDR_SCALARS) {
 788                 NDR_CHECK(ndr_push_align(ndr, 8));
 789                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 790                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 791                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 792         }
 793         if (ndr_flags & NDR_BUFFERS) {
 794         }
 795         return NDR_ERR_SUCCESS;
 796 }
 797
 798 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 799 {
 800         if (ndr_flags & NDR_SCALARS) {
 801                 NDR_CHECK(ndr_pull_align(ndr, 8));
 802                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 803                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 804                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 805         }
 806         if (ndr_flags & NDR_BUFFERS) {
 807         }
 808         return NDR_ERR_SUCCESS;
 809 }
 810
 811 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 812 {
 813         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 814         ndr->depth++;
 815         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 816         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 817         ndr->depth--;
 818 }
 819
 820 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 821 {
 822         uint32_t cntr_cursors_0;
 823         if (ndr_flags & NDR_SCALARS) {
 824                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 825                 NDR_CHECK(ndr_push_align(ndr, 8));
 826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 830                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 831                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 832                 }
 833                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 834         }
 835         if (ndr_flags & NDR_BUFFERS) {
 836         }
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 841 {
 842         uint32_t cntr_cursors_0;
 843         TALLOC_CTX *_mem_save_cursors_0;
 844         if (ndr_flags & NDR_SCALARS) {
 845                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 846                 NDR_CHECK(ndr_pull_align(ndr, 8));
 847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 850                 if (r->count > 0x100000) {
 851                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 852                 }
 853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 854                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 855                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 856                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 857                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 858                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 859                 }
 860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 861                 if (r->cursors) {
 862                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 863                 }
 864                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 865         }
 866         if (ndr_flags & NDR_BUFFERS) {
 867         }
 868         return NDR_ERR_SUCCESS;
 869 }
 870
 871 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 872 {
 873         uint32_t cntr_cursors_0;
 874         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 875         ndr->depth++;
 876         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 877         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 878         ndr_print_uint32(ndr, "count", r->count);
 879         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 880         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 881         ndr->depth++;
 882         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 883                 char *idx_0=NULL;
 884                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 885                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 886                         free(idx_0);
 887                 }
 888         }
 889         ndr->depth--;
 890         ndr->depth--;
 891 }
 892
 893 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 894 {
 895         {
 896                 uint32_t _flags_save_ENUM = ndr->flags;
 897                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 898                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 899                 ndr->flags = _flags_save_ENUM;
 900         }
 901         return NDR_ERR_SUCCESS;
 902 }
 903
 904 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 905 {
 906         uint32_t v;
 907         {
 908                 uint32_t _flags_save_ENUM = ndr->flags;
 909                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 910                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 911                 *r = v;
 912                 ndr->flags = _flags_save_ENUM;
 913         }
 914         return NDR_ERR_SUCCESS;
 915 }
 916
 917 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 918 {
 919         const char *val = NULL;
 920
 921         {
 922                 uint32_t _flags_save_ENUM = ndr->flags;
 923                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 924                 switch (r) {
 925                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 926                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 927                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 928                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 929                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 930                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 931                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 932                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 933                 }
 934                 ndr_print_enum(ndr, name, "ENUM", val, r);
 935                 ndr->flags = _flags_save_ENUM;
 936         }
 937 }
 938
 939 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 940 {
 941         {
 942                 uint32_t _flags_save_ENUM = ndr->flags;
 943                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 944                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 945                 ndr->flags = _flags_save_ENUM;
 946         }
 947         return NDR_ERR_SUCCESS;
 948 }
 949
 950 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 951 {
 952         uint32_t v;
 953         {
 954                 uint32_t _flags_save_ENUM = ndr->flags;
 955                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 956                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 957                 *r = v;
 958                 ndr->flags = _flags_save_ENUM;
 959         }
 960         return NDR_ERR_SUCCESS;
 961 }
 962
 963 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
 964 {
 965         const char *val = NULL;
 966
 967         {
 968                 uint32_t _flags_save_ENUM = ndr->flags;
 969                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 970                 switch (r) {
 971                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
 972                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
 973                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
 974                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
 975                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
 976                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
 977                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
 978                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
 979                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
 980                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
 981                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
 982                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
 983                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
 984                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
 985                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
 986                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
 987                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
 988                 }
 989                 ndr_print_enum(ndr, name, "ENUM", val, r);
 990                 ndr->flags = _flags_save_ENUM;
 991         }
 992 }
 993
 994 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
 995 {
 996         if (ndr_flags & NDR_SCALARS) {
 997                 NDR_CHECK(ndr_push_align(ndr, 8));
 998                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
 999                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1000                 if (r->naming_context == NULL) {
1001                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1002                 }
1003                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1004                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1006                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1009                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1010                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1011                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1012         }
1013         if (ndr_flags & NDR_BUFFERS) {
1014                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1015                 if (r->uptodateness_vector) {
1016                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1017                 }
1018         }
1019         return NDR_ERR_SUCCESS;
1020 }
1021
1022 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1023 {
1024         uint32_t _ptr_naming_context;
1025         TALLOC_CTX *_mem_save_naming_context_0;
1026         uint32_t _ptr_uptodateness_vector;
1027         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1028         if (ndr_flags & NDR_SCALARS) {
1029                 NDR_CHECK(ndr_pull_align(ndr, 8));
1030                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1031                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1032                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1033                 if (_ptr_naming_context) {
1034                         NDR_PULL_ALLOC(ndr, r->naming_context);
1035                 } else {
1036                         r->naming_context = NULL;
1037                 }
1038                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1040                 if (_ptr_uptodateness_vector) {
1041                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1042                 } else {
1043                         r->uptodateness_vector = NULL;
1044                 }
1045                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1048                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1049                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1050                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1051         }
1052         if (ndr_flags & NDR_BUFFERS) {
1053                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1054                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1055                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1056                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1057                 if (r->uptodateness_vector) {
1058                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1059                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1060                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1062                 }
1063         }
1064         return NDR_ERR_SUCCESS;
1065 }
1066
1067 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1068 {
1069         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1070         ndr->depth++;
1071         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1072         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1073         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1074         ndr->depth++;
1075         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1076         ndr->depth--;
1077         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1078         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1079         ndr->depth++;
1080         if (r->uptodateness_vector) {
1081                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1082         }
1083         ndr->depth--;
1084         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1085         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1086         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1087         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1088         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1089         ndr->depth--;
1090 }
1091
1092 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1093 {
1094         if (ndr_flags & NDR_SCALARS) {
1095                 NDR_CHECK(ndr_push_align(ndr, 5));
1096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1098                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1099         }
1100         if (ndr_flags & NDR_BUFFERS) {
1101                 if (r->binary_oid) {
1102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1103                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1104                 }
1105         }
1106         return NDR_ERR_SUCCESS;
1107 }
1108
1109 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1110 {
1111         uint32_t _ptr_binary_oid;
1112         TALLOC_CTX *_mem_save_binary_oid_0;
1113         if (ndr_flags & NDR_SCALARS) {
1114                 NDR_CHECK(ndr_pull_align(ndr, 5));
1115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1116                 if (r->length > 10000) {
1117                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1118                 }
1119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1120                 if (_ptr_binary_oid) {
1121                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1122                 } else {
1123                         r->binary_oid = NULL;
1124                 }
1125                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1126         }
1127         if (ndr_flags & NDR_BUFFERS) {
1128                 if (r->binary_oid) {
1129                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1130                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1132                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1133                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1135                 }
1136                 if (r->binary_oid) {
1137                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1138                 }
1139         }
1140         return NDR_ERR_SUCCESS;
1141 }
1142
1143 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1144 {
1145         if (ndr_flags & NDR_SCALARS) {
1146                 NDR_CHECK(ndr_push_align(ndr, 5));
1147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1148                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1149                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1150         }
1151         if (ndr_flags & NDR_BUFFERS) {
1152                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1153         }
1154         return NDR_ERR_SUCCESS;
1155 }
1156
1157 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1158 {
1159         if (ndr_flags & NDR_SCALARS) {
1160                 NDR_CHECK(ndr_pull_align(ndr, 5));
1161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1162                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1163                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1164         }
1165         if (ndr_flags & NDR_BUFFERS) {
1166                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1167         }
1168         return NDR_ERR_SUCCESS;
1169 }
1170
1171 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1172 {
1173         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1174         ndr->depth++;
1175         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1176         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1177         ndr->depth--;
1178 }
1179
1180 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1181 {
1182         uint32_t cntr_mappings_1;
1183         if (ndr_flags & NDR_SCALARS) {
1184                 NDR_CHECK(ndr_push_align(ndr, 5));
1185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1187                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1188         }
1189         if (ndr_flags & NDR_BUFFERS) {
1190                 if (r->mappings) {
1191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1192                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1193                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1194                         }
1195                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1196                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1197                         }
1198                 }
1199         }
1200         return NDR_ERR_SUCCESS;
1201 }
1202
1203 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1204 {
1205         uint32_t _ptr_mappings;
1206         uint32_t cntr_mappings_1;
1207         TALLOC_CTX *_mem_save_mappings_0;
1208         TALLOC_CTX *_mem_save_mappings_1;
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 5));
1211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1212                 if (r->num_mappings > 0x100000) {
1213                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1214                 }
1215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1216                 if (_ptr_mappings) {
1217                         NDR_PULL_ALLOC(ndr, r->mappings);
1218                 } else {
1219                         r->mappings = NULL;
1220                 }
1221                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1222         }
1223         if (ndr_flags & NDR_BUFFERS) {
1224                 if (r->mappings) {
1225                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1226                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1228                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1229                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1230                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1231                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1232                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1233                         }
1234                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1235                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1236                         }
1237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1239                 }
1240                 if (r->mappings) {
1241                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1242                 }
1243         }
1244         return NDR_ERR_SUCCESS;
1245 }
1246
1247 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1248 {
1249         uint32_t cntr_mappings_1;
1250         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1251         ndr->depth++;
1252         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1253         ndr_print_ptr(ndr, "mappings", r->mappings);
1254         ndr->depth++;
1255         if (r->mappings) {
1256                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1257                 ndr->depth++;
1258                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1259                         char *idx_1=NULL;
1260                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1261                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1262                                 free(idx_1);
1263                         }
1264                 }
1265                 ndr->depth--;
1266         }
1267         ndr->depth--;
1268         ndr->depth--;
1269 }
1270
1271 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1272 {
1273         {
1274                 uint32_t _flags_save_ENUM = ndr->flags;
1275                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1276                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1277                 ndr->flags = _flags_save_ENUM;
1278         }
1279         return NDR_ERR_SUCCESS;
1280 }
1281
1282 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1283 {
1284         uint32_t v;
1285         {
1286                 uint32_t _flags_save_ENUM = ndr->flags;
1287                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1288                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1289                 *r = v;
1290                 ndr->flags = _flags_save_ENUM;
1291         }
1292         return NDR_ERR_SUCCESS;
1293 }
1294
1295 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1296 {
1297         const char *val = NULL;
1298
1299         {
1300                 uint32_t _flags_save_ENUM = ndr->flags;
1301                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1302                 switch (r) {
1303                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1304                         case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
1305                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1306                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1307                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1308                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1309                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1310                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1311                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1312                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1313                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1314                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1315                         case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1316                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1317                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1318                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1319                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1320                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1321                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1322                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1323                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1324                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1325                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1326                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1327                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1328                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1329                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1330                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1331                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1332                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1333                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1334                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1335                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1336                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1337                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1338                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1339                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1340                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1341                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1342                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1343                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1344                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1345                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1346                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1347                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1348                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1349                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1350                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1351                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1352                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1353                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1354                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1355                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1356                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1357                         case DRSUAPI_ATTRIBUTE_options: val = "DRSUAPI_ATTRIBUTE_options"; break;
1358                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1359                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1360                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1361                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1362                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1363                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1364                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1365                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1366                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1367                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1368                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1369                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1370                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1371                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1372                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1373                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1374                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1375                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1376                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1377                         case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
1378                 }
1379                 ndr_print_enum(ndr, name, "ENUM", val, r);
1380                 ndr->flags = _flags_save_ENUM;
1381         }
1382 }
1383
1384 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1385 {
1386         uint32_t cntr_attids_0;
1387         if (ndr_flags & NDR_SCALARS) {
1388                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1389                 NDR_CHECK(ndr_push_align(ndr, 4));
1390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1393                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1394                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1395                 }
1396                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1397         }
1398         if (ndr_flags & NDR_BUFFERS) {
1399         }
1400         return NDR_ERR_SUCCESS;
1401 }
1402
1403 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1404 {
1405         uint32_t cntr_attids_0;
1406         TALLOC_CTX *_mem_save_attids_0;
1407         if (ndr_flags & NDR_SCALARS) {
1408                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1409                 NDR_CHECK(ndr_pull_align(ndr, 4));
1410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1413                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1414                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1415                 }
1416                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1417                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1418                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1419                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1420                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1421                 }
1422                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1423                 if (r->attids) {
1424                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1425                 }
1426                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1427         }
1428         if (ndr_flags & NDR_BUFFERS) {
1429         }
1430         return NDR_ERR_SUCCESS;
1431 }
1432
1433 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1434 {
1435         uint32_t cntr_attids_0;
1436         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1437         ndr->depth++;
1438         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1439         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1440         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1441         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1442         ndr->depth++;
1443         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1444                 char *idx_0=NULL;
1445                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1446                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1447                         free(idx_0);
1448                 }
1449         }
1450         ndr->depth--;
1451         ndr->depth--;
1452 }
1453
1454 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1455 {
1456         if (ndr_flags & NDR_SCALARS) {
1457                 NDR_CHECK(ndr_push_align(ndr, 8));
1458                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1459                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1460                 if (r->naming_context == NULL) {
1461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1462                 }
1463                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1464                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1466                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1469                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1470                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1473                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1474                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1475         }
1476         if (ndr_flags & NDR_BUFFERS) {
1477                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1478                 if (r->uptodateness_vector) {
1479                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1480                 }
1481                 if (r->partial_attribute_set) {
1482                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1483                 }
1484                 if (r->partial_attribute_set_ex) {
1485                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1486                 }
1487                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1488         }
1489         return NDR_ERR_SUCCESS;
1490 }
1491
1492 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1493 {
1494         uint32_t _ptr_naming_context;
1495         TALLOC_CTX *_mem_save_naming_context_0;
1496         uint32_t _ptr_uptodateness_vector;
1497         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1498         uint32_t _ptr_partial_attribute_set;
1499         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1500         uint32_t _ptr_partial_attribute_set_ex;
1501         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1502         if (ndr_flags & NDR_SCALARS) {
1503                 NDR_CHECK(ndr_pull_align(ndr, 8));
1504                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1505                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1506                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1507                 if (_ptr_naming_context) {
1508                         NDR_PULL_ALLOC(ndr, r->naming_context);
1509                 } else {
1510                         r->naming_context = NULL;
1511                 }
1512                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1513                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1514                 if (_ptr_uptodateness_vector) {
1515                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1516                 } else {
1517                         r->uptodateness_vector = NULL;
1518                 }
1519                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1522                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1523                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1525                 if (_ptr_partial_attribute_set) {
1526                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1527                 } else {
1528                         r->partial_attribute_set = NULL;
1529                 }
1530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1531                 if (_ptr_partial_attribute_set_ex) {
1532                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1533                 } else {
1534                         r->partial_attribute_set_ex = NULL;
1535                 }
1536                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1538         }
1539         if (ndr_flags & NDR_BUFFERS) {
1540                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1541                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1542                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1544                 if (r->uptodateness_vector) {
1545                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1546                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1547                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1549                 }
1550                 if (r->partial_attribute_set) {
1551                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1552                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1553                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1555                 }
1556                 if (r->partial_attribute_set_ex) {
1557                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1558                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1559                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1560                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1561                 }
1562                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1563         }
1564         return NDR_ERR_SUCCESS;
1565 }
1566
1567 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1568 {
1569         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1570         ndr->depth++;
1571         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1572         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1573         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1574         ndr->depth++;
1575         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1576         ndr->depth--;
1577         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1578         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1579         ndr->depth++;
1580         if (r->uptodateness_vector) {
1581                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1582         }
1583         ndr->depth--;
1584         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1585         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1586         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1587         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1588         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1589         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1590         ndr->depth++;
1591         if (r->partial_attribute_set) {
1592                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1593         }
1594         ndr->depth--;
1595         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1596         ndr->depth++;
1597         if (r->partial_attribute_set_ex) {
1598                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1599         }
1600         ndr->depth--;
1601         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1602         ndr->depth--;
1603 }
1604
1605 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1606 {
1607         if (ndr_flags & NDR_SCALARS) {
1608                 NDR_CHECK(ndr_push_align(ndr, 8));
1609                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1610                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1611                 if (r->naming_context == NULL) {
1612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1613                 }
1614                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1615                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1617                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1620                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1621                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1624                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1626                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1627         }
1628         if (ndr_flags & NDR_BUFFERS) {
1629                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1630                 if (r->uptodateness_vector) {
1631                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1632                 }
1633                 if (r->partial_attribute_set) {
1634                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1635                 }
1636                 if (r->partial_attribute_set_ex) {
1637                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1638                 }
1639                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1640         }
1641         return NDR_ERR_SUCCESS;
1642 }
1643
1644 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1645 {
1646         uint32_t _ptr_naming_context;
1647         TALLOC_CTX *_mem_save_naming_context_0;
1648         uint32_t _ptr_uptodateness_vector;
1649         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1650         uint32_t _ptr_partial_attribute_set;
1651         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1652         uint32_t _ptr_partial_attribute_set_ex;
1653         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1654         if (ndr_flags & NDR_SCALARS) {
1655                 NDR_CHECK(ndr_pull_align(ndr, 8));
1656                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1657                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1658                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1659                 if (_ptr_naming_context) {
1660                         NDR_PULL_ALLOC(ndr, r->naming_context);
1661                 } else {
1662                         r->naming_context = NULL;
1663                 }
1664                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1666                 if (_ptr_uptodateness_vector) {
1667                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1668                 } else {
1669                         r->uptodateness_vector = NULL;
1670                 }
1671                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1674                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1675                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1677                 if (_ptr_partial_attribute_set) {
1678                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1679                 } else {
1680                         r->partial_attribute_set = NULL;
1681                 }
1682                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1683                 if (_ptr_partial_attribute_set_ex) {
1684                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1685                 } else {
1686                         r->partial_attribute_set_ex = NULL;
1687                 }
1688                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1690                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1691         }
1692         if (ndr_flags & NDR_BUFFERS) {
1693                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1694                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1695                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1697                 if (r->uptodateness_vector) {
1698                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1700                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1702                 }
1703                 if (r->partial_attribute_set) {
1704                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1705                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1706                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1707                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1708                 }
1709                 if (r->partial_attribute_set_ex) {
1710                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1711                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1712                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1714                 }
1715                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1716         }
1717         return NDR_ERR_SUCCESS;
1718 }
1719
1720 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1721 {
1722         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1723         ndr->depth++;
1724         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1725         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1726         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1727         ndr->depth++;
1728         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1729         ndr->depth--;
1730         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1731         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1732         ndr->depth++;
1733         if (r->uptodateness_vector) {
1734                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1735         }
1736         ndr->depth--;
1737         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1738         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1739         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1740         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1741         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1742         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1743         ndr->depth++;
1744         if (r->partial_attribute_set) {
1745                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1746         }
1747         ndr->depth--;
1748         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1749         ndr->depth++;
1750         if (r->partial_attribute_set_ex) {
1751                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1752         }
1753         ndr->depth--;
1754         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1755         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1756         ndr->depth--;
1757 }
1758
1759 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1760 {
1761         if (ndr_flags & NDR_SCALARS) {
1762                 int level = ndr_push_get_switch_value(ndr, r);
1763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1764                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1765                 switch (level) {
1766                         case 5: {
1767                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1768                         break; }
1769
1770                         case 8: {
1771                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1772                         break; }
1773
1774                         case 10: {
1775                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1776                         break; }
1777
1778                         default:
1779                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1780                 }
1781         }
1782         if (ndr_flags & NDR_BUFFERS) {
1783                 int level = ndr_push_get_switch_value(ndr, r);
1784                 switch (level) {
1785                         case 5:
1786                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1787                         break;
1788
1789                         case 8:
1790                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1791                         break;
1792
1793                         case 10:
1794                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1795                         break;
1796
1797                         default:
1798                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1799                 }
1800         }
1801         return NDR_ERR_SUCCESS;
1802 }
1803
1804 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1805 {
1806         int level;
1807         uint32_t _level;
1808         level = ndr_pull_get_switch_value(ndr, r);
1809         if (ndr_flags & NDR_SCALARS) {
1810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1811                 if (_level != level) {
1812                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1813                 }
1814                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1815                 switch (level) {
1816                         case 5: {
1817                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1818                         break; }
1819
1820                         case 8: {
1821                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1822                         break; }
1823
1824                         case 10: {
1825                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1826                         break; }
1827
1828                         default:
1829                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1830                 }
1831         }
1832         if (ndr_flags & NDR_BUFFERS) {
1833                 switch (level) {
1834                         case 5:
1835                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1836                         break;
1837
1838                         case 8:
1839                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1840                         break;
1841
1842                         case 10:
1843                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1844                         break;
1845
1846                         default:
1847                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1848                 }
1849         }
1850         return NDR_ERR_SUCCESS;
1851 }
1852
1853 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1854 {
1855         int level;
1856         level = ndr_print_get_switch_value(ndr, r);
1857         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1858         switch (level) {
1859                 case 5:
1860                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1861                 break;
1862
1863                 case 8:
1864                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1865                 break;
1866
1867                 case 10:
1868                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1869                 break;
1870
1871                 default:
1872                         ndr_print_bad_level(ndr, name, level);
1873         }
1874 }
1875
1876 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1877 {
1878         if (ndr_flags & NDR_SCALARS) {
1879                 NDR_CHECK(ndr_push_align(ndr, 8));
1880                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1881                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1882                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1883                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1884         }
1885         if (ndr_flags & NDR_BUFFERS) {
1886         }
1887         return NDR_ERR_SUCCESS;
1888 }
1889
1890 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1891 {
1892         if (ndr_flags & NDR_SCALARS) {
1893                 NDR_CHECK(ndr_pull_align(ndr, 8));
1894                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1895                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1896                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1897                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1898         }
1899         if (ndr_flags & NDR_BUFFERS) {
1900         }
1901         return NDR_ERR_SUCCESS;
1902 }
1903
1904 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1905 {
1906         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1907         ndr->depth++;
1908         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1909         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1910         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1911         ndr->depth--;
1912 }
1913
1914 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1915 {
1916         uint32_t cntr_cursors_0;
1917         if (ndr_flags & NDR_SCALARS) {
1918                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1919                 NDR_CHECK(ndr_push_align(ndr, 8));
1920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1924                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1925                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1926                 }
1927                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1928         }
1929         if (ndr_flags & NDR_BUFFERS) {
1930         }
1931         return NDR_ERR_SUCCESS;
1932 }
1933
1934 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1935 {
1936         uint32_t cntr_cursors_0;
1937         TALLOC_CTX *_mem_save_cursors_0;
1938         if (ndr_flags & NDR_SCALARS) {
1939                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1940                 NDR_CHECK(ndr_pull_align(ndr, 8));
1941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1944                 if (r->count > 0x100000) {
1945                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1946                 }
1947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1948                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1949                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1950                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1951                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1952                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1953                 }
1954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1955                 if (r->cursors) {
1956                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1957                 }
1958                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1959         }
1960         if (ndr_flags & NDR_BUFFERS) {
1961         }
1962         return NDR_ERR_SUCCESS;
1963 }
1964
1965 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1966 {
1967         uint32_t cntr_cursors_0;
1968         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
1969         ndr->depth++;
1970         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
1971         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1972         ndr_print_uint32(ndr, "count", r->count);
1973         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
1974         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
1975         ndr->depth++;
1976         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
1977                 char *idx_0=NULL;
1978                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
1979                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
1980                         free(idx_0);
1981                 }
1982         }
1983         ndr->depth--;
1984         ndr->depth--;
1985 }
1986
1987 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
1988 {
1989         if (ndr_flags & NDR_SCALARS) {
1990                 NDR_CHECK(ndr_push_align(ndr, 5));
1991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
1992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
1993                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1994         }
1995         if (ndr_flags & NDR_BUFFERS) {
1996                 if (r->blob) {
1997                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
1998                 }
1999         }
2000         return NDR_ERR_SUCCESS;
2001 }
2002
2003 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2004 {
2005         uint32_t _ptr_blob;
2006         TALLOC_CTX *_mem_save_blob_0;
2007         if (ndr_flags & NDR_SCALARS) {
2008                 NDR_CHECK(ndr_pull_align(ndr, 5));
2009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2010                 if (r->__ndr_size > 10485760) {
2011                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2012                 }
2013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2014                 if (_ptr_blob) {
2015                         NDR_PULL_ALLOC(ndr, r->blob);
2016                 } else {
2017                         r->blob = NULL;
2018                 }
2019                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2020         }
2021         if (ndr_flags & NDR_BUFFERS) {
2022                 if (r->blob) {
2023                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2024                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2025                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2027                 }
2028         }
2029         return NDR_ERR_SUCCESS;
2030 }
2031
2032 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2033 {
2034         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2035         ndr->depth++;
2036         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2037         ndr_print_ptr(ndr, "blob", r->blob);
2038         ndr->depth++;
2039         if (r->blob) {
2040                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2041         }
2042         ndr->depth--;
2043         ndr->depth--;
2044 }
2045
2046 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2047 {
2048         uint32_t cntr_values_1;
2049         if (ndr_flags & NDR_SCALARS) {
2050                 NDR_CHECK(ndr_push_align(ndr, 5));
2051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2053                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2054         }
2055         if (ndr_flags & NDR_BUFFERS) {
2056                 if (r->values) {
2057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2058                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2059                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2060                         }
2061                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2062                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2063                         }
2064                 }
2065         }
2066         return NDR_ERR_SUCCESS;
2067 }
2068
2069 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2070 {
2071         uint32_t _ptr_values;
2072         uint32_t cntr_values_1;
2073         TALLOC_CTX *_mem_save_values_0;
2074         TALLOC_CTX *_mem_save_values_1;
2075         if (ndr_flags & NDR_SCALARS) {
2076                 NDR_CHECK(ndr_pull_align(ndr, 5));
2077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2078                 if (r->num_values > 10485760) {
2079                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2080                 }
2081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2082                 if (_ptr_values) {
2083                         NDR_PULL_ALLOC(ndr, r->values);
2084                 } else {
2085                         r->values = NULL;
2086                 }
2087                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2088         }
2089         if (ndr_flags & NDR_BUFFERS) {
2090                 if (r->values) {
2091                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2092                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2093                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2094                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2095                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2096                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2097                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2098                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2099                         }
2100                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2101                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2102                         }
2103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2105                 }
2106                 if (r->values) {
2107                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2108                 }
2109         }
2110         return NDR_ERR_SUCCESS;
2111 }
2112
2113 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2114 {
2115         uint32_t cntr_values_1;
2116         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2117         ndr->depth++;
2118         ndr_print_uint32(ndr, "num_values", r->num_values);
2119         ndr_print_ptr(ndr, "values", r->values);
2120         ndr->depth++;
2121         if (r->values) {
2122                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2123                 ndr->depth++;
2124                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2125                         char *idx_1=NULL;
2126                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2127                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2128                                 free(idx_1);
2129                         }
2130                 }
2131                 ndr->depth--;
2132         }
2133         ndr->depth--;
2134         ndr->depth--;
2135 }
2136
2137 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2138 {
2139         if (ndr_flags & NDR_SCALARS) {
2140                 NDR_CHECK(ndr_push_align(ndr, 4));
2141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2143                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2144                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2146                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2147                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2148         }
2149         if (ndr_flags & NDR_BUFFERS) {
2150                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2151         }
2152         return NDR_ERR_SUCCESS;
2153 }
2154
2155 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2156 {
2157         if (ndr_flags & NDR_SCALARS) {
2158                 NDR_CHECK(ndr_pull_align(ndr, 4));
2159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2161                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2162                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2164                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2165                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2166         }
2167         if (ndr_flags & NDR_BUFFERS) {
2168                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2169         }
2170         return NDR_ERR_SUCCESS;
2171 }
2172
2173 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2174 {
2175         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2176         ndr->depth++;
2177         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);
2178         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);
2179         ndr_print_GUID(ndr, "guid", &r->guid);
2180         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2181         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2182         ndr_print_string(ndr, "dn", r->dn);
2183         ndr->depth--;
2184 }
2185
2186 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2187 {
2188         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2189 }
2190
2191 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2192 {
2193         if (ndr_flags & NDR_SCALARS) {
2194                 NDR_CHECK(ndr_push_align(ndr, 4));
2195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2197                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2198                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2200                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2202                 {
2203                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2205                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2206                         ndr->flags = _flags_save_DATA_BLOB;
2207                 }
2208                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2209         }
2210         if (ndr_flags & NDR_BUFFERS) {
2211                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2212         }
2213         return NDR_ERR_SUCCESS;
2214 }
2215
2216 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2217 {
2218         if (ndr_flags & NDR_SCALARS) {
2219                 NDR_CHECK(ndr_pull_align(ndr, 4));
2220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2222                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2223                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2225                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2227                 {
2228                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2230                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2231                         ndr->flags = _flags_save_DATA_BLOB;
2232                 }
2233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2234         }
2235         if (ndr_flags & NDR_BUFFERS) {
2236                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2237         }
2238         return NDR_ERR_SUCCESS;
2239 }
2240
2241 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2242 {
2243         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2244         ndr->depth++;
2245         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);
2246         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);
2247         ndr_print_GUID(ndr, "guid", &r->guid);
2248         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2249         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2250         ndr_print_string(ndr, "dn", r->dn);
2251         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2252         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2253         ndr->depth--;
2254 }
2255
2256 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2257 {
2258         if (ndr_flags & NDR_SCALARS) {
2259                 NDR_CHECK(ndr_push_align(ndr, 5));
2260                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2261                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2262                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2263         }
2264         if (ndr_flags & NDR_BUFFERS) {
2265                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2266         }
2267         return NDR_ERR_SUCCESS;
2268 }
2269
2270 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2271 {
2272         if (ndr_flags & NDR_SCALARS) {
2273                 NDR_CHECK(ndr_pull_align(ndr, 5));
2274                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2275                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2277         }
2278         if (ndr_flags & NDR_BUFFERS) {
2279                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2280         }
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2285 {
2286         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2287         ndr->depth++;
2288         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2289         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2290         ndr->depth--;
2291 }
2292
2293 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2294 {
2295         uint32_t cntr_attributes_1;
2296         if (ndr_flags & NDR_SCALARS) {
2297                 NDR_CHECK(ndr_push_align(ndr, 5));
2298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2299                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2300                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2301         }
2302         if (ndr_flags & NDR_BUFFERS) {
2303                 if (r->attributes) {
2304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2305                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2306                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2307                         }
2308                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2309                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2310                         }
2311                 }
2312         }
2313         return NDR_ERR_SUCCESS;
2314 }
2315
2316 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2317 {
2318         uint32_t _ptr_attributes;
2319         uint32_t cntr_attributes_1;
2320         TALLOC_CTX *_mem_save_attributes_0;
2321         TALLOC_CTX *_mem_save_attributes_1;
2322         if (ndr_flags & NDR_SCALARS) {
2323                 NDR_CHECK(ndr_pull_align(ndr, 5));
2324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2325                 if (r->num_attributes > 1048576) {
2326                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2327                 }
2328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2329                 if (_ptr_attributes) {
2330                         NDR_PULL_ALLOC(ndr, r->attributes);
2331                 } else {
2332                         r->attributes = NULL;
2333                 }
2334                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2335         }
2336         if (ndr_flags & NDR_BUFFERS) {
2337                 if (r->attributes) {
2338                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2339                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2341                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2342                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2343                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2344                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2345                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2346                         }
2347                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2348                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2349                         }
2350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2352                 }
2353                 if (r->attributes) {
2354                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2355                 }
2356         }
2357         return NDR_ERR_SUCCESS;
2358 }
2359
2360 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2361 {
2362         uint32_t cntr_attributes_1;
2363         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2364         ndr->depth++;
2365         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2366         ndr_print_ptr(ndr, "attributes", r->attributes);
2367         ndr->depth++;
2368         if (r->attributes) {
2369                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2370                 ndr->depth++;
2371                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2372                         char *idx_1=NULL;
2373                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2374                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2375                                 free(idx_1);
2376                         }
2377                 }
2378                 ndr->depth--;
2379         }
2380         ndr->depth--;
2381         ndr->depth--;
2382 }
2383
2384 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2385 {
2386         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2387         return NDR_ERR_SUCCESS;
2388 }
2389
2390 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2391 {
2392         uint32_t v;
2393         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2394         *r = v;
2395         return NDR_ERR_SUCCESS;
2396 }
2397
2398 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2399 {
2400         ndr_print_uint32(ndr, name, r);
2401         ndr->depth++;
2402         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2403         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2404         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2405         ndr->depth--;
2406 }
2407
2408 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2409 {
2410         if (ndr_flags & NDR_SCALARS) {
2411                 NDR_CHECK(ndr_push_align(ndr, 5));
2412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2413                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2414                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2415                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2416         }
2417         if (ndr_flags & NDR_BUFFERS) {
2418                 if (r->identifier) {
2419                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2420                 }
2421                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2422         }
2423         return NDR_ERR_SUCCESS;
2424 }
2425
2426 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2427 {
2428         uint32_t _ptr_identifier;
2429         TALLOC_CTX *_mem_save_identifier_0;
2430         if (ndr_flags & NDR_SCALARS) {
2431                 NDR_CHECK(ndr_pull_align(ndr, 5));
2432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2433                 if (_ptr_identifier) {
2434                         NDR_PULL_ALLOC(ndr, r->identifier);
2435                 } else {
2436                         r->identifier = NULL;
2437                 }
2438                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2439                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2440                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2441         }
2442         if (ndr_flags & NDR_BUFFERS) {
2443                 if (r->identifier) {
2444                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2445                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2446                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2448                 }
2449                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2450         }
2451         return NDR_ERR_SUCCESS;
2452 }
2453
2454 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2455 {
2456         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2457         ndr->depth++;
2458         ndr_print_ptr(ndr, "identifier", r->identifier);
2459         ndr->depth++;
2460         if (r->identifier) {
2461                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2462         }
2463         ndr->depth--;
2464         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2465         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2466         ndr->depth--;
2467 }
2468
2469 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2470 {
2471         if (ndr_flags & NDR_SCALARS) {
2472                 NDR_CHECK(ndr_push_align(ndr, 8));
2473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2474                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2475                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2476                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2477                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2478         }
2479         if (ndr_flags & NDR_BUFFERS) {
2480         }
2481         return NDR_ERR_SUCCESS;
2482 }
2483
2484 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2485 {
2486         if (ndr_flags & NDR_SCALARS) {
2487                 NDR_CHECK(ndr_pull_align(ndr, 8));
2488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2489                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2490                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2491                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2492                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2493         }
2494         if (ndr_flags & NDR_BUFFERS) {
2495         }
2496         return NDR_ERR_SUCCESS;
2497 }
2498
2499 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2500 {
2501         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2502         ndr->depth++;
2503         ndr_print_uint32(ndr, "version", r->version);
2504         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2505         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2506         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2507         ndr->depth--;
2508 }
2509
2510 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2511 {
2512         uint32_t cntr_meta_data_0;
2513         if (ndr_flags & NDR_SCALARS) {
2514                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2515                 NDR_CHECK(ndr_push_align(ndr, 8));
2516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2517                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2518                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2519                 }
2520                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2521         }
2522         if (ndr_flags & NDR_BUFFERS) {
2523         }
2524         return NDR_ERR_SUCCESS;
2525 }
2526
2527 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2528 {
2529         uint32_t cntr_meta_data_0;
2530         TALLOC_CTX *_mem_save_meta_data_0;
2531         if (ndr_flags & NDR_SCALARS) {
2532                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2533                 NDR_CHECK(ndr_pull_align(ndr, 8));
2534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2535                 if (r->count > 1048576) {
2536                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2537                 }
2538                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2539                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2540                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2541                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2542                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2543                 }
2544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2545                 if (r->meta_data) {
2546                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2547                 }
2548                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2549         }
2550         if (ndr_flags & NDR_BUFFERS) {
2551         }
2552         return NDR_ERR_SUCCESS;
2553 }
2554
2555 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2556 {
2557         uint32_t cntr_meta_data_0;
2558         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2559         ndr->depth++;
2560         ndr_print_uint32(ndr, "count", r->count);
2561         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2562         ndr->depth++;
2563         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2564                 char *idx_0=NULL;
2565                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2566                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2567                         free(idx_0);
2568                 }
2569         }
2570         ndr->depth--;
2571         ndr->depth--;
2572 }
2573
2574 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2575 {
2576         if (ndr_flags & NDR_SCALARS) {
2577                 NDR_CHECK(ndr_push_align(ndr, 5));
2578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2579                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2583                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2584         }
2585         if (ndr_flags & NDR_BUFFERS) {
2586                 if (r->next_object) {
2587                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2588                 }
2589                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2590                 if (r->parent_object_guid) {
2591                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2592                 }
2593                 if (r->meta_data_ctr) {
2594                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2595                 }
2596         }
2597         return NDR_ERR_SUCCESS;
2598 }
2599
2600 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2601 {
2602         uint32_t _ptr_next_object;
2603         TALLOC_CTX *_mem_save_next_object_0;
2604         uint32_t _ptr_parent_object_guid;
2605         TALLOC_CTX *_mem_save_parent_object_guid_0;
2606         uint32_t _ptr_meta_data_ctr;
2607         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2608         if (ndr_flags & NDR_SCALARS) {
2609                 NDR_CHECK(ndr_pull_align(ndr, 5));
2610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2611                 if (_ptr_next_object) {
2612                         NDR_PULL_ALLOC(ndr, r->next_object);
2613                 } else {
2614                         r->next_object = NULL;
2615                 }
2616                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2619                 if (_ptr_parent_object_guid) {
2620                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2621                 } else {
2622                         r->parent_object_guid = NULL;
2623                 }
2624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2625                 if (_ptr_meta_data_ctr) {
2626                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2627                 } else {
2628                         r->meta_data_ctr = NULL;
2629                 }
2630                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2631         }
2632         if (ndr_flags & NDR_BUFFERS) {
2633                 if (r->next_object) {
2634                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2635                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2636                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2638                 }
2639                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2640                 if (r->parent_object_guid) {
2641                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2642                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2643                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2645                 }
2646                 if (r->meta_data_ctr) {
2647                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2648                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2649                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2651                 }
2652         }
2653         return NDR_ERR_SUCCESS;
2654 }
2655
2656 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2657 {
2658         if (ndr_flags & NDR_SCALARS) {
2659                 NDR_CHECK(ndr_push_align(ndr, 8));
2660                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2661                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2663                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2664                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2666                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2667                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2672                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2673         }
2674         if (ndr_flags & NDR_BUFFERS) {
2675                 if (r->naming_context) {
2676                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2677                 }
2678                 if (r->uptodateness_vector) {
2679                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2680                 }
2681                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2682                 if (r->first_object) {
2683                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2684                 }
2685         }
2686         return NDR_ERR_SUCCESS;
2687 }
2688
2689 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2690 {
2691         uint32_t _ptr_naming_context;
2692         TALLOC_CTX *_mem_save_naming_context_0;
2693         uint32_t _ptr_uptodateness_vector;
2694         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2695         uint32_t _ptr_first_object;
2696         TALLOC_CTX *_mem_save_first_object_0;
2697         if (ndr_flags & NDR_SCALARS) {
2698                 NDR_CHECK(ndr_pull_align(ndr, 8));
2699                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2700                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2702                 if (_ptr_naming_context) {
2703                         NDR_PULL_ALLOC(ndr, r->naming_context);
2704                 } else {
2705                         r->naming_context = NULL;
2706                 }
2707                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2708                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2710                 if (_ptr_uptodateness_vector) {
2711                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2712                 } else {
2713                         r->uptodateness_vector = NULL;
2714                 }
2715                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2716                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2720                 if (_ptr_first_object) {
2721                         NDR_PULL_ALLOC(ndr, r->first_object);
2722                 } else {
2723                         r->first_object = NULL;
2724                 }
2725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2726                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2727         }
2728         if (ndr_flags & NDR_BUFFERS) {
2729                 if (r->naming_context) {
2730                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2731                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2732                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2734                 }
2735                 if (r->uptodateness_vector) {
2736                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2737                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2738                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2740                 }
2741                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2742                 if (r->first_object) {
2743                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2744                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2745                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2747                 }
2748         }
2749         return NDR_ERR_SUCCESS;
2750 }
2751
2752 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2753 {
2754         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2755         ndr->depth++;
2756         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2757         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2758         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2759         ndr->depth++;
2760         if (r->naming_context) {
2761                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2762         }
2763         ndr->depth--;
2764         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2765         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2766         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2767         ndr->depth++;
2768         if (r->uptodateness_vector) {
2769                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2770         }
2771         ndr->depth--;
2772         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2773         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2774         ndr_print_uint32(ndr, "object_count", r->object_count);
2775         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);
2776         ndr_print_ptr(ndr, "first_object", r->first_object);
2777         ndr->depth++;
2778         if (r->first_object) {
2779                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2780         }
2781         ndr->depth--;
2782         ndr_print_uint32(ndr, "more_data", r->more_data);
2783         ndr->depth--;
2784 }
2785
2786 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2787 {
2788         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2789 }
2790
2791 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2792 {
2793         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2794         return NDR_ERR_SUCCESS;
2795 }
2796
2797 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2798 {
2799         uint32_t v;
2800         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2801         *r = v;
2802         return NDR_ERR_SUCCESS;
2803 }
2804
2805 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2806 {
2807         ndr_print_uint32(ndr, name, r);
2808         ndr->depth++;
2809         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2810         ndr->depth--;
2811 }
2812
2813 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2814 {
2815         if (ndr_flags & NDR_SCALARS) {
2816                 NDR_CHECK(ndr_push_align(ndr, 8));
2817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2818                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2819                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2820                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2821                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2822                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2823                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2824         }
2825         if (ndr_flags & NDR_BUFFERS) {
2826                 if (r->identifier) {
2827                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2828                 }
2829                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2830         }
2831         return NDR_ERR_SUCCESS;
2832 }
2833
2834 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2835 {
2836         uint32_t _ptr_identifier;
2837         TALLOC_CTX *_mem_save_identifier_0;
2838         if (ndr_flags & NDR_SCALARS) {
2839                 NDR_CHECK(ndr_pull_align(ndr, 8));
2840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2841                 if (_ptr_identifier) {
2842                         NDR_PULL_ALLOC(ndr, r->identifier);
2843                 } else {
2844                         r->identifier = NULL;
2845                 }
2846                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2847                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2848                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2849                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2850                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2852         }
2853         if (ndr_flags & NDR_BUFFERS) {
2854                 if (r->identifier) {
2855                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2856                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2857                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2859                 }
2860                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2861         }
2862         return NDR_ERR_SUCCESS;
2863 }
2864
2865 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2866 {
2867         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2868         ndr->depth++;
2869         ndr_print_ptr(ndr, "identifier", r->identifier);
2870         ndr->depth++;
2871         if (r->identifier) {
2872                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2873         }
2874         ndr->depth--;
2875         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2876         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2877         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2878         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2879         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2880         ndr->depth--;
2881 }
2882
2883 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2884 {
2885         uint32_t cntr_linked_attributes_1;
2886         if (ndr_flags & NDR_SCALARS) {
2887                 NDR_CHECK(ndr_push_align(ndr, 8));
2888                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2889                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2891                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2892                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2894                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2895                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2905                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2906         }
2907         if (ndr_flags & NDR_BUFFERS) {
2908                 if (r->naming_context) {
2909                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2910                 }
2911                 if (r->uptodateness_vector) {
2912                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2913                 }
2914                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2915                 if (r->first_object) {
2916                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2917                 }
2918                 if (r->linked_attributes) {
2919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2920                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2921                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2922                         }
2923                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2924                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2925                         }
2926                 }
2927         }
2928         return NDR_ERR_SUCCESS;
2929 }
2930
2931 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2932 {
2933         uint32_t _ptr_naming_context;
2934         TALLOC_CTX *_mem_save_naming_context_0;
2935         uint32_t _ptr_uptodateness_vector;
2936         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2937         uint32_t _ptr_first_object;
2938         TALLOC_CTX *_mem_save_first_object_0;
2939         uint32_t _ptr_linked_attributes;
2940         uint32_t cntr_linked_attributes_1;
2941         TALLOC_CTX *_mem_save_linked_attributes_0;
2942         TALLOC_CTX *_mem_save_linked_attributes_1;
2943         if (ndr_flags & NDR_SCALARS) {
2944                 NDR_CHECK(ndr_pull_align(ndr, 8));
2945                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2946                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2948                 if (_ptr_naming_context) {
2949                         NDR_PULL_ALLOC(ndr, r->naming_context);
2950                 } else {
2951                         r->naming_context = NULL;
2952                 }
2953                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2954                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2956                 if (_ptr_uptodateness_vector) {
2957                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2958                 } else {
2959                         r->uptodateness_vector = NULL;
2960                 }
2961                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2962                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2966                 if (_ptr_first_object) {
2967                         NDR_PULL_ALLOC(ndr, r->first_object);
2968                 } else {
2969                         r->first_object = NULL;
2970                 }
2971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
2973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
2974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
2975                 if (r->linked_attributes_count > 1048576) {
2976                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2977                 }
2978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
2979                 if (_ptr_linked_attributes) {
2980                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
2981                 } else {
2982                         r->linked_attributes = NULL;
2983                 }
2984                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
2985                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2986         }
2987         if (ndr_flags & NDR_BUFFERS) {
2988                 if (r->naming_context) {
2989                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2990                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2991                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2993                 }
2994                 if (r->uptodateness_vector) {
2995                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2996                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2997                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2999                 }
3000                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3001                 if (r->first_object) {
3002                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3003                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3004                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3006                 }
3007                 if (r->linked_attributes) {
3008                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3009                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3010                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3011                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3012                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3013                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3014                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3015                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3016                         }
3017                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3018                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3019                         }
3020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3022                 }
3023                 if (r->linked_attributes) {
3024                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3025                 }
3026         }
3027         return NDR_ERR_SUCCESS;
3028 }
3029
3030 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3031 {
3032         uint32_t cntr_linked_attributes_1;
3033         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3034         ndr->depth++;
3035         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3036         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3037         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3038         ndr->depth++;
3039         if (r->naming_context) {
3040                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3041         }
3042         ndr->depth--;
3043         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3044         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3045         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3046         ndr->depth++;
3047         if (r->uptodateness_vector) {
3048                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3049         }
3050         ndr->depth--;
3051         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3052         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3053         ndr_print_uint32(ndr, "object_count", r->object_count);
3054         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);
3055         ndr_print_ptr(ndr, "first_object", r->first_object);
3056         ndr->depth++;
3057         if (r->first_object) {
3058                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3059         }
3060         ndr->depth--;
3061         ndr_print_uint32(ndr, "more_data", r->more_data);
3062         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3063         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3064         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3065         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3066         ndr->depth++;
3067         if (r->linked_attributes) {
3068                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3069                 ndr->depth++;
3070                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3071                         char *idx_1=NULL;
3072                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3073                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3074                                 free(idx_1);
3075                         }
3076                 }
3077                 ndr->depth--;
3078         }
3079         ndr->depth--;
3080         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3081         ndr->depth--;
3082 }
3083
3084 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3085 {
3086         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3087 }
3088
3089 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3090 {
3091         if (ndr_flags & NDR_SCALARS) {
3092                 NDR_CHECK(ndr_push_align(ndr, 1));
3093                 {
3094                         struct ndr_push *_ndr_ctr1;
3095                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3096                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3097                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3098                 }
3099                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3100         }
3101         if (ndr_flags & NDR_BUFFERS) {
3102         }
3103         return NDR_ERR_SUCCESS;
3104 }
3105
3106 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3107 {
3108         if (ndr_flags & NDR_SCALARS) {
3109                 NDR_CHECK(ndr_pull_align(ndr, 1));
3110                 {
3111                         struct ndr_pull *_ndr_ctr1;
3112                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3113                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3114                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3115                 }
3116                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3117         }
3118         if (ndr_flags & NDR_BUFFERS) {
3119         }
3120         return NDR_ERR_SUCCESS;
3121 }
3122
3123 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3124 {
3125         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3126         ndr->depth++;
3127         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3128         ndr->depth--;
3129 }
3130
3131 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3132 {
3133         if (ndr_flags & NDR_SCALARS) {
3134                 NDR_CHECK(ndr_push_align(ndr, 1));
3135                 {
3136                         struct ndr_push *_ndr_ctr6;
3137                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3138                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3139                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3140                 }
3141                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3142         }
3143         if (ndr_flags & NDR_BUFFERS) {
3144         }
3145         return NDR_ERR_SUCCESS;
3146 }
3147
3148 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3149 {
3150         if (ndr_flags & NDR_SCALARS) {
3151                 NDR_CHECK(ndr_pull_align(ndr, 1));
3152                 {
3153                         struct ndr_pull *_ndr_ctr6;
3154                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3155                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3156                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3157                 }
3158                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3159         }
3160         if (ndr_flags & NDR_BUFFERS) {
3161         }
3162         return NDR_ERR_SUCCESS;
3163 }
3164
3165 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3166 {
3167         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3168         ndr->depth++;
3169         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3170         ndr->depth--;
3171 }
3172
3173 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3174 {
3175         uint32_t _ptr_ts;
3176         TALLOC_CTX *_mem_save_ts_0;
3177         if (ndr_flags & NDR_SCALARS) {
3178                 NDR_CHECK(ndr_pull_align(ndr, 5));
3179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3182                 if (_ptr_ts) {
3183                         NDR_PULL_ALLOC(ndr, r->ts);
3184                 } else {
3185                         r->ts = NULL;
3186                 }
3187                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3188         }
3189         if (ndr_flags & NDR_BUFFERS) {
3190                 if (r->ts) {
3191                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3192                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3193                         {
3194                                 struct ndr_pull *_ndr_ts;
3195                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3196                                 {
3197                                         struct ndr_pull *_ndr_ts_compressed;
3198                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3199                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3200                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3201                                 }
3202                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3203                         }
3204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3205                 }
3206         }
3207         return NDR_ERR_SUCCESS;
3208 }
3209
3210 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3211 {
3212         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3213         ndr->depth++;
3214         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3215         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3216         ndr_print_ptr(ndr, "ts", r->ts);
3217         ndr->depth++;
3218         if (r->ts) {
3219                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3220         }
3221         ndr->depth--;
3222         ndr->depth--;
3223 }
3224
3225 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3226 {
3227         uint32_t _ptr_ts;
3228         TALLOC_CTX *_mem_save_ts_0;
3229         if (ndr_flags & NDR_SCALARS) {
3230                 NDR_CHECK(ndr_pull_align(ndr, 5));
3231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3234                 if (_ptr_ts) {
3235                         NDR_PULL_ALLOC(ndr, r->ts);
3236                 } else {
3237                         r->ts = NULL;
3238                 }
3239                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3240         }
3241         if (ndr_flags & NDR_BUFFERS) {
3242                 if (r->ts) {
3243                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3244                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3245                         {
3246                                 struct ndr_pull *_ndr_ts;
3247                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3248                                 {
3249                                         struct ndr_pull *_ndr_ts_compressed;
3250                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3251                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3252                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3253                                 }
3254                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3255                         }
3256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3257                 }
3258         }
3259         return NDR_ERR_SUCCESS;
3260 }
3261
3262 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3263 {
3264         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3265         ndr->depth++;
3266         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3267         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3268         ndr_print_ptr(ndr, "ts", r->ts);
3269         ndr->depth++;
3270         if (r->ts) {
3271                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3272         }
3273         ndr->depth--;
3274         ndr->depth--;
3275 }
3276
3277 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3278 {
3279         uint32_t _ptr_ts;
3280         TALLOC_CTX *_mem_save_ts_0;
3281         if (ndr_flags & NDR_SCALARS) {
3282                 NDR_CHECK(ndr_pull_align(ndr, 5));
3283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3286                 if (_ptr_ts) {
3287                         NDR_PULL_ALLOC(ndr, r->ts);
3288                 } else {
3289                         r->ts = NULL;
3290                 }
3291                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3292         }
3293         if (ndr_flags & NDR_BUFFERS) {
3294                 if (r->ts) {
3295                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3296                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3297                         {
3298                                 struct ndr_pull *_ndr_ts;
3299                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3300                                 {
3301                                         struct ndr_pull *_ndr_ts_compressed;
3302                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3303                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3304                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3305                                 }
3306                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3307                         }
3308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3309                 }
3310         }
3311         return NDR_ERR_SUCCESS;
3312 }
3313
3314 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3315 {
3316         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3317         ndr->depth++;
3318         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3319         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3320         ndr_print_ptr(ndr, "ts", r->ts);
3321         ndr->depth++;
3322         if (r->ts) {
3323                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3324         }
3325         ndr->depth--;
3326         ndr->depth--;
3327 }
3328
3329 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3330 {
3331         uint32_t _ptr_ts;
3332         TALLOC_CTX *_mem_save_ts_0;
3333         if (ndr_flags & NDR_SCALARS) {
3334                 NDR_CHECK(ndr_pull_align(ndr, 5));
3335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3338                 if (_ptr_ts) {
3339                         NDR_PULL_ALLOC(ndr, r->ts);
3340                 } else {
3341                         r->ts = NULL;
3342                 }
3343                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3344         }
3345         if (ndr_flags & NDR_BUFFERS) {
3346                 if (r->ts) {
3347                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3348                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3349                         {
3350                                 struct ndr_pull *_ndr_ts;
3351                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3352                                 {
3353                                         struct ndr_pull *_ndr_ts_compressed;
3354                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3355                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3356                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3357                                 }
3358                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3359                         }
3360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3361                 }
3362         }
3363         return NDR_ERR_SUCCESS;
3364 }
3365
3366 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3367 {
3368         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3369         ndr->depth++;
3370         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3371         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3372         ndr_print_ptr(ndr, "ts", r->ts);
3373         ndr->depth++;
3374         if (r->ts) {
3375                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3376         }
3377         ndr->depth--;
3378         ndr->depth--;
3379 }
3380
3381 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3382 {
3383         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3384         return NDR_ERR_SUCCESS;
3385 }
3386
3387 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3388 {
3389         uint16_t v;
3390         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3391         *r = v;
3392         return NDR_ERR_SUCCESS;
3393 }
3394
3395 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3396 {
3397         const char *val = NULL;
3398
3399         switch (r) {
3400                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3401                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3402         }
3403         ndr_print_enum(ndr, name, "ENUM", val, r);
3404 }
3405
3406 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3407 {
3408         {
3409                 uint32_t _flags_save_UNION = ndr->flags;
3410                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3411                 if (ndr_flags & NDR_SCALARS) {
3412                         int level = ndr_push_get_switch_value(ndr, r);
3413                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3414                         switch (level) {
3415                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3416                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3417                                 break; }
3418
3419                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3420                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3421                                 break; }
3422
3423                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3424                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3425                                 break; }
3426
3427                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3428                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3429                                 break; }
3430
3431                                 default:
3432                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3433                         }
3434                 }
3435                 if (ndr_flags & NDR_BUFFERS) {
3436                         int level = ndr_push_get_switch_value(ndr, r);
3437                         switch (level) {
3438                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3439                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3440                                 break;
3441
3442                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3443                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3444                                 break;
3445
3446                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3447                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3448                                 break;
3449
3450                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3451                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3452                                 break;
3453
3454                                 default:
3455                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3456                         }
3457                 }
3458                 ndr->flags = _flags_save_UNION;
3459         }
3460         return NDR_ERR_SUCCESS;
3461 }
3462
3463 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3464 {
3465         int level;
3466         {
3467                 uint32_t _flags_save_UNION = ndr->flags;
3468                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3469                 level = ndr_pull_get_switch_value(ndr, r);
3470                 if (ndr_flags & NDR_SCALARS) {
3471                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3472                         switch (level) {
3473                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3474                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3475                                 break; }
3476
3477                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3478                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3479                                 break; }
3480
3481                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3482                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3483                                 break; }
3484
3485                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3486                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3487                                 break; }
3488
3489                                 default:
3490                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3491                         }
3492                 }
3493                 if (ndr_flags & NDR_BUFFERS) {
3494                         switch (level) {
3495                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3496                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3497                                 break;
3498
3499                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3500                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3501                                 break;
3502
3503                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3504                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3505                                 break;
3506
3507                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3508                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3509                                 break;
3510
3511                                 default:
3512                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3513                         }
3514                 }
3515                 ndr->flags = _flags_save_UNION;
3516         }
3517         return NDR_ERR_SUCCESS;
3518 }
3519
3520 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3521 {
3522         int level;
3523         {
3524                 uint32_t _flags_save_UNION = ndr->flags;
3525                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3526                 level = ndr_print_get_switch_value(ndr, r);
3527                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3528                 switch (level) {
3529                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3530                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3531                         break;
3532
3533                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3534                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3535                         break;
3536
3537                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3538                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3539                         break;
3540
3541                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3542                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3543                         break;
3544
3545                         default:
3546                                 ndr_print_bad_level(ndr, name, level);
3547                 }
3548                 ndr->flags = _flags_save_UNION;
3549         }
3550 }
3551
3552 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3553 {
3554         if (ndr_flags & NDR_SCALARS) {
3555                 NDR_CHECK(ndr_push_align(ndr, 5));
3556                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3557                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3558         }
3559         if (ndr_flags & NDR_BUFFERS) {
3560                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3561         }
3562         return NDR_ERR_SUCCESS;
3563 }
3564
3565 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3566 {
3567         if (ndr_flags & NDR_SCALARS) {
3568                 NDR_CHECK(ndr_pull_align(ndr, 5));
3569                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3570                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3571         }
3572         if (ndr_flags & NDR_BUFFERS) {
3573                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3574         }
3575         return NDR_ERR_SUCCESS;
3576 }
3577
3578 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3579 {
3580         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3581         ndr->depth++;
3582         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3583         ndr->depth--;
3584 }
3585
3586 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3587 {
3588         if (ndr_flags & NDR_SCALARS) {
3589                 NDR_CHECK(ndr_push_align(ndr, 5));
3590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3591                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3592                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3593                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3594                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3595         }
3596         if (ndr_flags & NDR_BUFFERS) {
3597                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3598         }
3599         return NDR_ERR_SUCCESS;
3600 }
3601
3602 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3603 {
3604         if (ndr_flags & NDR_SCALARS) {
3605                 NDR_CHECK(ndr_pull_align(ndr, 5));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3607                 if (r->level > 6) {
3608                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3609                 }
3610                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3611                 if (r->type < 2 || r->type > 3) {
3612                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3613                 }
3614                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3615                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3616                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3617         }
3618         if (ndr_flags & NDR_BUFFERS) {
3619                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3620         }
3621         return NDR_ERR_SUCCESS;
3622 }
3623
3624 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3625 {
3626         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3627         ndr->depth++;
3628         ndr_print_uint32(ndr, "level", r->level);
3629         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3630         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3631         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3632         ndr->depth--;
3633 }
3634
3635 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3636 {
3637         if (ndr_flags & NDR_SCALARS) {
3638                 int level = ndr_push_get_switch_value(ndr, r);
3639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3640                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3641                 switch (level) {
3642                         case 1: {
3643                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3644                         break; }
3645
3646                         case 2: {
3647                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3648                         break; }
3649
3650                         case 6: {
3651                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3652                         break; }
3653
3654                         case 7: {
3655                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3656                         break; }
3657
3658                         default:
3659                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3660                 }
3661         }
3662         if (ndr_flags & NDR_BUFFERS) {
3663                 int level = ndr_push_get_switch_value(ndr, r);
3664                 switch (level) {
3665                         case 1:
3666                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3667                         break;
3668
3669                         case 2:
3670                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3671                         break;
3672
3673                         case 6:
3674                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3675                         break;
3676
3677                         case 7:
3678                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3679                         break;
3680
3681                         default:
3682                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3683                 }
3684         }
3685         return NDR_ERR_SUCCESS;
3686 }
3687
3688 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3689 {
3690         int level;
3691         uint32_t _level;
3692         level = ndr_pull_get_switch_value(ndr, r);
3693         if (ndr_flags & NDR_SCALARS) {
3694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3695                 if (_level != level) {
3696                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3697                 }
3698                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3699                 switch (level) {
3700                         case 1: {
3701                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3702                         break; }
3703
3704                         case 2: {
3705                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3706                         break; }
3707
3708                         case 6: {
3709                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3710                         break; }
3711
3712                         case 7: {
3713                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3714                         break; }
3715
3716                         default:
3717                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3718                 }
3719         }
3720         if (ndr_flags & NDR_BUFFERS) {
3721                 switch (level) {
3722                         case 1:
3723                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3724                         break;
3725
3726                         case 2:
3727                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3728                         break;
3729
3730                         case 6:
3731                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3732                         break;
3733
3734                         case 7:
3735                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3736                         break;
3737
3738                         default:
3739                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3740                 }
3741         }
3742         return NDR_ERR_SUCCESS;
3743 }
3744
3745 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3746 {
3747         int level;
3748         level = ndr_print_get_switch_value(ndr, r);
3749         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3750         switch (level) {
3751                 case 1:
3752                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3753                 break;
3754
3755                 case 2:
3756                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3757                 break;
3758
3759                 case 6:
3760                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3761                 break;
3762
3763                 case 7:
3764                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3765                 break;
3766
3767                 default:
3768                         ndr_print_bad_level(ndr, name, level);
3769         }
3770 }
3771
3772 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3773 {
3774         if (ndr_flags & NDR_SCALARS) {
3775                 NDR_CHECK(ndr_push_align(ndr, 5));
3776                 if (r->naming_context == NULL) {
3777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3778                 }
3779                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3780                 if (r->dest_dsa_dns_name == NULL) {
3781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3782                 }
3783                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3784                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3785                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3786                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3787         }
3788         if (ndr_flags & NDR_BUFFERS) {
3789                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3790                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3791                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3792                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3793                 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));
3794         }
3795         return NDR_ERR_SUCCESS;
3796 }
3797
3798 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3799 {
3800         uint32_t _ptr_naming_context;
3801         TALLOC_CTX *_mem_save_naming_context_0;
3802         uint32_t _ptr_dest_dsa_dns_name;
3803         if (ndr_flags & NDR_SCALARS) {
3804                 NDR_CHECK(ndr_pull_align(ndr, 5));
3805                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3806                 if (_ptr_naming_context) {
3807                         NDR_PULL_ALLOC(ndr, r->naming_context);
3808                 } else {
3809                         r->naming_context = NULL;
3810                 }
3811                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3812                 if (_ptr_dest_dsa_dns_name) {
3813                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3814                 } else {
3815                         r->dest_dsa_dns_name = NULL;
3816                 }
3817                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3818                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3819                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3820         }
3821         if (ndr_flags & NDR_BUFFERS) {
3822                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3823                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3824                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3826                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3827                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3828                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3829                         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));
3830                 }
3831                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3832                 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));
3833         }
3834         return NDR_ERR_SUCCESS;
3835 }
3836
3837 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3838 {
3839         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3840         ndr->depth++;
3841         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3842         ndr->depth++;
3843         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3844         ndr->depth--;
3845         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3846         ndr->depth++;
3847         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3848         ndr->depth--;
3849         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3850         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
3851         ndr->depth--;
3852 }
3853
3854 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3855 {
3856         if (ndr_flags & NDR_SCALARS) {
3857                 int level = ndr_push_get_switch_value(ndr, r);
3858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3859                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3860                 switch (level) {
3861                         case 1: {
3862                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3863                         break; }
3864
3865                         default:
3866                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3867                 }
3868         }
3869         if (ndr_flags & NDR_BUFFERS) {
3870                 int level = ndr_push_get_switch_value(ndr, r);
3871                 switch (level) {
3872                         case 1:
3873                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3874                         break;
3875
3876                         default:
3877                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3878                 }
3879         }
3880         return NDR_ERR_SUCCESS;
3881 }
3882
3883 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3884 {
3885         int level;
3886         uint32_t _level;
3887         level = ndr_pull_get_switch_value(ndr, r);
3888         if (ndr_flags & NDR_SCALARS) {
3889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3890                 if (_level != level) {
3891                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3892                 }
3893                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3894                 switch (level) {
3895                         case 1: {
3896                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3897                         break; }
3898
3899                         default:
3900                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3901                 }
3902         }
3903         if (ndr_flags & NDR_BUFFERS) {
3904                 switch (level) {
3905                         case 1:
3906                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3907                         break;
3908
3909                         default:
3910                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3911                 }
3912         }
3913         return NDR_ERR_SUCCESS;
3914 }
3915
3916 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3917 {
3918         int level;
3919         level = ndr_print_get_switch_value(ndr, r);
3920         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3921         switch (level) {
3922                 case 1:
3923                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3924                 break;
3925
3926                 default:
3927                         ndr_print_bad_level(ndr, name, level);
3928         }
3929 }
3930
3931 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3932 {
3933         if (ndr_flags & NDR_SCALARS) {
3934                 NDR_CHECK(ndr_push_align(ndr, 5));
3935                 if (r->naming_context == NULL) {
3936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3937                 }
3938                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3940                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3941                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3942                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3943         }
3944         if (ndr_flags & NDR_BUFFERS) {
3945                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3946                 if (r->source_dsa_address) {
3947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3950                         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));
3951                 }
3952         }
3953         return NDR_ERR_SUCCESS;
3954 }
3955
3956 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
3957 {
3958         uint32_t _ptr_naming_context;
3959         TALLOC_CTX *_mem_save_naming_context_0;
3960         uint32_t _ptr_source_dsa_address;
3961         TALLOC_CTX *_mem_save_source_dsa_address_0;
3962         if (ndr_flags & NDR_SCALARS) {
3963                 NDR_CHECK(ndr_pull_align(ndr, 5));
3964                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3965                 if (_ptr_naming_context) {
3966                         NDR_PULL_ALLOC(ndr, r->naming_context);
3967                 } else {
3968                         r->naming_context = NULL;
3969                 }
3970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
3971                 if (_ptr_source_dsa_address) {
3972                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
3973                 } else {
3974                         r->source_dsa_address = NULL;
3975                 }
3976                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3977                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3978                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3979         }
3980         if (ndr_flags & NDR_BUFFERS) {
3981                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3982                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3983                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3985                 if (r->source_dsa_address) {
3986                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
3988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
3989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
3990                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
3991                                 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));
3992                         }
3993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
3994                         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));
3995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
3996                 }
3997         }
3998         return NDR_ERR_SUCCESS;
3999 }
4000
4001 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4002 {
4003         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4004         ndr->depth++;
4005         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4006         ndr->depth++;
4007         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4008         ndr->depth--;
4009         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4010         ndr->depth++;
4011         if (r->source_dsa_address) {
4012                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4013         }
4014         ndr->depth--;
4015         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4016         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4017         ndr->depth--;
4018 }
4019
4020 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4021 {
4022         if (ndr_flags & NDR_SCALARS) {
4023                 NDR_CHECK(ndr_push_align(ndr, 5));
4024                 if (r->naming_context == NULL) {
4025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4026                 }
4027                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4031                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4032                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4033                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4034         }
4035         if (ndr_flags & NDR_BUFFERS) {
4036                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4037                 if (r->source_dsa_dn) {
4038                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4039                 }
4040                 if (r->transport_dn) {
4041                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4042                 }
4043                 if (r->source_dsa_address) {
4044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4046                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4047                         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));
4048                 }
4049         }
4050         return NDR_ERR_SUCCESS;
4051 }
4052
4053 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4054 {
4055         uint32_t _ptr_naming_context;
4056         TALLOC_CTX *_mem_save_naming_context_0;
4057         uint32_t _ptr_source_dsa_dn;
4058         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4059         uint32_t _ptr_transport_dn;
4060         TALLOC_CTX *_mem_save_transport_dn_0;
4061         uint32_t _ptr_source_dsa_address;
4062         TALLOC_CTX *_mem_save_source_dsa_address_0;
4063         if (ndr_flags & NDR_SCALARS) {
4064                 NDR_CHECK(ndr_pull_align(ndr, 5));
4065                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4066                 if (_ptr_naming_context) {
4067                         NDR_PULL_ALLOC(ndr, r->naming_context);
4068                 } else {
4069                         r->naming_context = NULL;
4070                 }
4071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4072                 if (_ptr_source_dsa_dn) {
4073                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4074                 } else {
4075                         r->source_dsa_dn = NULL;
4076                 }
4077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4078                 if (_ptr_transport_dn) {
4079                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4080                 } else {
4081                         r->transport_dn = NULL;
4082                 }
4083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4084                 if (_ptr_source_dsa_address) {
4085                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4086                 } else {
4087                         r->source_dsa_address = NULL;
4088                 }
4089                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4090                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4091                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4092         }
4093         if (ndr_flags & NDR_BUFFERS) {
4094                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4095                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4096                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4098                 if (r->source_dsa_dn) {
4099                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4100                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4101                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4103                 }
4104                 if (r->transport_dn) {
4105                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4106                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4107                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4108                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4109                 }
4110                 if (r->source_dsa_address) {
4111                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4112                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4113                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4114                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4115                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4116                                 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));
4117                         }
4118                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4119                         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));
4120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4121                 }
4122         }
4123         return NDR_ERR_SUCCESS;
4124 }
4125
4126 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4127 {
4128         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4129         ndr->depth++;
4130         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4131         ndr->depth++;
4132         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4133         ndr->depth--;
4134         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4135         ndr->depth++;
4136         if (r->source_dsa_dn) {
4137                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4141         ndr->depth++;
4142         if (r->transport_dn) {
4143                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4144         }
4145         ndr->depth--;
4146         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4147         ndr->depth++;
4148         if (r->source_dsa_address) {
4149                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4150         }
4151         ndr->depth--;
4152         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4153         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4154         ndr->depth--;
4155 }
4156
4157 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4158 {
4159         if (ndr_flags & NDR_SCALARS) {
4160                 int level = ndr_push_get_switch_value(ndr, r);
4161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4162                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4163                 switch (level) {
4164                         case 1: {
4165                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4166                         break; }
4167
4168                         case 2: {
4169                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4170                         break; }
4171
4172                         default:
4173                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4174                 }
4175         }
4176         if (ndr_flags & NDR_BUFFERS) {
4177                 int level = ndr_push_get_switch_value(ndr, r);
4178                 switch (level) {
4179                         case 1:
4180                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4181                         break;
4182
4183                         case 2:
4184                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4185                         break;
4186
4187                         default:
4188                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4189                 }
4190         }
4191         return NDR_ERR_SUCCESS;
4192 }
4193
4194 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4195 {
4196         int level;
4197         uint32_t _level;
4198         level = ndr_pull_get_switch_value(ndr, r);
4199         if (ndr_flags & NDR_SCALARS) {
4200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4201                 if (_level != level) {
4202                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4203                 }
4204                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4205                 switch (level) {
4206                         case 1: {
4207                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4208                         break; }
4209
4210                         case 2: {
4211                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4212                         break; }
4213
4214                         default:
4215                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4216                 }
4217         }
4218         if (ndr_flags & NDR_BUFFERS) {
4219                 switch (level) {
4220                         case 1:
4221                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4222                         break;
4223
4224                         case 2:
4225                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4226                         break;
4227
4228                         default:
4229                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4230                 }
4231         }
4232         return NDR_ERR_SUCCESS;
4233 }
4234
4235 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4236 {
4237         int level;
4238         level = ndr_print_get_switch_value(ndr, r);
4239         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4240         switch (level) {
4241                 case 1:
4242                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4243                 break;
4244
4245                 case 2:
4246                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4247                 break;
4248
4249                 default:
4250                         ndr_print_bad_level(ndr, name, level);
4251         }
4252 }
4253
4254 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4255 {
4256         if (ndr_flags & NDR_SCALARS) {
4257                 NDR_CHECK(ndr_push_align(ndr, 5));
4258                 if (r->naming_context == NULL) {
4259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4260                 }
4261                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4263                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4264                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4265         }
4266         if (ndr_flags & NDR_BUFFERS) {
4267                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4268                 if (r->source_dsa_address) {
4269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4270                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4272                         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));
4273                 }
4274         }
4275         return NDR_ERR_SUCCESS;
4276 }
4277
4278 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4279 {
4280         uint32_t _ptr_naming_context;
4281         TALLOC_CTX *_mem_save_naming_context_0;
4282         uint32_t _ptr_source_dsa_address;
4283         TALLOC_CTX *_mem_save_source_dsa_address_0;
4284         if (ndr_flags & NDR_SCALARS) {
4285                 NDR_CHECK(ndr_pull_align(ndr, 5));
4286                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4287                 if (_ptr_naming_context) {
4288                         NDR_PULL_ALLOC(ndr, r->naming_context);
4289                 } else {
4290                         r->naming_context = NULL;
4291                 }
4292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4293                 if (_ptr_source_dsa_address) {
4294                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4295                 } else {
4296                         r->source_dsa_address = NULL;
4297                 }
4298                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4299                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4300         }
4301         if (ndr_flags & NDR_BUFFERS) {
4302                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4303                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4304                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4306                 if (r->source_dsa_address) {
4307                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4308                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4309                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4310                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4311                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4312                                 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));
4313                         }
4314                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4315                         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));
4316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4317                 }
4318         }
4319         return NDR_ERR_SUCCESS;
4320 }
4321
4322 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4323 {
4324         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4325         ndr->depth++;
4326         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4327         ndr->depth++;
4328         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4329         ndr->depth--;
4330         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4331         ndr->depth++;
4332         if (r->source_dsa_address) {
4333                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4334         }
4335         ndr->depth--;
4336         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4337         ndr->depth--;
4338 }
4339
4340 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4341 {
4342         if (ndr_flags & NDR_SCALARS) {
4343                 int level = ndr_push_get_switch_value(ndr, r);
4344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4345                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4346                 switch (level) {
4347                         case 1: {
4348                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4349                         break; }
4350
4351                         default:
4352                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4353                 }
4354         }
4355         if (ndr_flags & NDR_BUFFERS) {
4356                 int level = ndr_push_get_switch_value(ndr, r);
4357                 switch (level) {
4358                         case 1:
4359                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4360                         break;
4361
4362                         default:
4363                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4364                 }
4365         }
4366         return NDR_ERR_SUCCESS;
4367 }
4368
4369 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4370 {
4371         int level;
4372         uint32_t _level;
4373         level = ndr_pull_get_switch_value(ndr, r);
4374         if (ndr_flags & NDR_SCALARS) {
4375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4376                 if (_level != level) {
4377                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4378                 }
4379                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4380                 switch (level) {
4381                         case 1: {
4382                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4383                         break; }
4384
4385                         default:
4386                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4387                 }
4388         }
4389         if (ndr_flags & NDR_BUFFERS) {
4390                 switch (level) {
4391                         case 1:
4392                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4393                         break;
4394
4395                         default:
4396                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4397                 }
4398         }
4399         return NDR_ERR_SUCCESS;
4400 }
4401
4402 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4403 {
4404         int level;
4405         level = ndr_print_get_switch_value(ndr, r);
4406         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4407         switch (level) {
4408                 case 1:
4409                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4410                 break;
4411
4412                 default:
4413                         ndr_print_bad_level(ndr, name, level);
4414         }
4415 }
4416
4417 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4418 {
4419         if (ndr_flags & NDR_SCALARS) {
4420                 NDR_CHECK(ndr_push_align(ndr, 5));
4421                 if (r->naming_context == NULL) {
4422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4423                 }
4424                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4425                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4427                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4430                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4431                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4432         }
4433         if (ndr_flags & NDR_BUFFERS) {
4434                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4435                 if (r->source_dra_address) {
4436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4438                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4439                         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));
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4446 {
4447         uint32_t _ptr_naming_context;
4448         TALLOC_CTX *_mem_save_naming_context_0;
4449         uint32_t _ptr_source_dra_address;
4450         TALLOC_CTX *_mem_save_source_dra_address_0;
4451         if (ndr_flags & NDR_SCALARS) {
4452                 NDR_CHECK(ndr_pull_align(ndr, 5));
4453                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4454                 if (_ptr_naming_context) {
4455                         NDR_PULL_ALLOC(ndr, r->naming_context);
4456                 } else {
4457                         r->naming_context = NULL;
4458                 }
4459                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4461                 if (_ptr_source_dra_address) {
4462                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4463                 } else {
4464                         r->source_dra_address = NULL;
4465                 }
4466                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4469                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4470                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4471         }
4472         if (ndr_flags & NDR_BUFFERS) {
4473                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4474                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4475                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4477                 if (r->source_dra_address) {
4478                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4479                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4480                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4481                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4482                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4483                                 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));
4484                         }
4485                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4486                         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));
4487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4488                 }
4489         }
4490         return NDR_ERR_SUCCESS;
4491 }
4492
4493 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4494 {
4495         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4496         ndr->depth++;
4497         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4498         ndr->depth++;
4499         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4500         ndr->depth--;
4501         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4502         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4503         ndr->depth++;
4504         if (r->source_dra_address) {
4505                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4506         }
4507         ndr->depth--;
4508         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4509         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4510         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4511         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4512         ndr->depth--;
4513 }
4514
4515 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4516 {
4517         if (ndr_flags & NDR_SCALARS) {
4518                 int level = ndr_push_get_switch_value(ndr, r);
4519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4520                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4521                 switch (level) {
4522                         case 1: {
4523                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4524                         break; }
4525
4526                         default:
4527                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4528                 }
4529         }
4530         if (ndr_flags & NDR_BUFFERS) {
4531                 int level = ndr_push_get_switch_value(ndr, r);
4532                 switch (level) {
4533                         case 1:
4534                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4535                         break;
4536
4537                         default:
4538                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4539                 }
4540         }
4541         return NDR_ERR_SUCCESS;
4542 }
4543
4544 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4545 {
4546         int level;
4547         uint32_t _level;
4548         level = ndr_pull_get_switch_value(ndr, r);
4549         if (ndr_flags & NDR_SCALARS) {
4550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4551                 if (_level != level) {
4552                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4553                 }
4554                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4555                 switch (level) {
4556                         case 1: {
4557                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4558                         break; }
4559
4560                         default:
4561                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4562                 }
4563         }
4564         if (ndr_flags & NDR_BUFFERS) {
4565                 switch (level) {
4566                         case 1:
4567                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4568                         break;
4569
4570                         default:
4571                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4572                 }
4573         }
4574         return NDR_ERR_SUCCESS;
4575 }
4576
4577 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4578 {
4579         int level;
4580         level = ndr_print_get_switch_value(ndr, r);
4581         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4582         switch (level) {
4583                 case 1:
4584                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4585                 break;
4586
4587                 default:
4588                         ndr_print_bad_level(ndr, name, level);
4589         }
4590 }
4591
4592 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4593 {
4594         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4595         return NDR_ERR_SUCCESS;
4596 }
4597
4598 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4599 {
4600         uint32_t v;
4601         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4602         *r = v;
4603         return NDR_ERR_SUCCESS;
4604 }
4605
4606 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4607 {
4608         const char *val = NULL;
4609
4610         switch (r) {
4611                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4612                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4613                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4614                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4615                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4616                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4617                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4618         }
4619         ndr_print_enum(ndr, name, "ENUM", val, r);
4620 }
4621
4622 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4623 {
4624         uint32_t cntr_info_array_1;
4625         uint32_t cntr_group_attrs_1;
4626         uint32_t cntr_sids_1;
4627         if (ndr_flags & NDR_SCALARS) {
4628                 NDR_CHECK(ndr_push_align(ndr, 5));
4629                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4635                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4636         }
4637         if (ndr_flags & NDR_BUFFERS) {
4638                 if (r->info_array) {
4639                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4640                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4641                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4642                         }
4643                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4644                                 if (r->info_array[cntr_info_array_1]) {
4645                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4646                                 }
4647                         }
4648                 }
4649                 if (r->group_attrs) {
4650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4651                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4652                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4653                         }
4654                 }
4655                 if (r->sids) {
4656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4657                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4658                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4659                         }
4660                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4661                                 if (r->sids[cntr_sids_1]) {
4662                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4663                                 }
4664                         }
4665                 }
4666         }
4667         return NDR_ERR_SUCCESS;
4668 }
4669
4670 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4671 {
4672         uint32_t _ptr_info_array;
4673         uint32_t cntr_info_array_1;
4674         TALLOC_CTX *_mem_save_info_array_0;
4675         TALLOC_CTX *_mem_save_info_array_1;
4676         TALLOC_CTX *_mem_save_info_array_2;
4677         uint32_t _ptr_group_attrs;
4678         uint32_t cntr_group_attrs_1;
4679         TALLOC_CTX *_mem_save_group_attrs_0;
4680         TALLOC_CTX *_mem_save_group_attrs_1;
4681         uint32_t _ptr_sids;
4682         uint32_t cntr_sids_1;
4683         TALLOC_CTX *_mem_save_sids_0;
4684         TALLOC_CTX *_mem_save_sids_1;
4685         TALLOC_CTX *_mem_save_sids_2;
4686         if (ndr_flags & NDR_SCALARS) {
4687                 NDR_CHECK(ndr_pull_align(ndr, 5));
4688                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4690                 if (r->num_memberships > 10000) {
4691                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4692                 }
4693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4694                 if (r->num_sids > 10000) {
4695                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4696                 }
4697                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4698                 if (_ptr_info_array) {
4699                         NDR_PULL_ALLOC(ndr, r->info_array);
4700                 } else {
4701                         r->info_array = NULL;
4702                 }
4703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4704                 if (_ptr_group_attrs) {
4705                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4706                 } else {
4707                         r->group_attrs = NULL;
4708                 }
4709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4710                 if (_ptr_sids) {
4711                         NDR_PULL_ALLOC(ndr, r->sids);
4712                 } else {
4713                         r->sids = NULL;
4714                 }
4715                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4716         }
4717         if (ndr_flags & NDR_BUFFERS) {
4718                 if (r->info_array) {
4719                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4720                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4722                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4723                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4724                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4725                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4726                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4727                                 if (_ptr_info_array) {
4728                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4729                                 } else {
4730                                         r->info_array[cntr_info_array_1] = NULL;
4731                                 }
4732                         }
4733                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4734                                 if (r->info_array[cntr_info_array_1]) {
4735                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4736                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4737                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4738                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4739                                 }
4740                         }
4741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4743                 }
4744                 if (r->group_attrs) {
4745                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4746                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4748                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4749                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4750                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4751                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4752                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4753                         }
4754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4756                 }
4757                 if (r->sids) {
4758                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4759                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4761                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4762                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4763                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4764                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4765                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4766                                 if (_ptr_sids) {
4767                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4768                                 } else {
4769                                         r->sids[cntr_sids_1] = NULL;
4770                                 }
4771                         }
4772                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4773                                 if (r->sids[cntr_sids_1]) {
4774                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4775                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4776                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4777                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4778                                 }
4779                         }
4780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4782                 }
4783                 if (r->info_array) {
4784                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4785                 }
4786                 if (r->group_attrs) {
4787                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4788                 }
4789                 if (r->sids) {
4790                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4791                 }
4792         }
4793         return NDR_ERR_SUCCESS;
4794 }
4795
4796 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4797 {
4798         uint32_t cntr_info_array_1;
4799         uint32_t cntr_group_attrs_1;
4800         uint32_t cntr_sids_1;
4801         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4802         ndr->depth++;
4803         ndr_print_NTSTATUS(ndr, "status", r->status);
4804         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4805         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4806         ndr_print_ptr(ndr, "info_array", r->info_array);
4807         ndr->depth++;
4808         if (r->info_array) {
4809                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4810                 ndr->depth++;
4811                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4812                         char *idx_1=NULL;
4813                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4814                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4815                                 ndr->depth++;
4816                                 if (r->info_array[cntr_info_array_1]) {
4817                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4818                                 }
4819                                 ndr->depth--;
4820                                 free(idx_1);
4821                         }
4822                 }
4823                 ndr->depth--;
4824         }
4825         ndr->depth--;
4826         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4827         ndr->depth++;
4828         if (r->group_attrs) {
4829                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4830                 ndr->depth++;
4831                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4832                         char *idx_1=NULL;
4833                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4834                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4835                                 free(idx_1);
4836                         }
4837                 }
4838                 ndr->depth--;
4839         }
4840         ndr->depth--;
4841         ndr_print_ptr(ndr, "sids", r->sids);
4842         ndr->depth++;
4843         if (r->sids) {
4844                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4845                 ndr->depth++;
4846                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4847                         char *idx_1=NULL;
4848                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4849                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4850                                 ndr->depth++;
4851                                 if (r->sids[cntr_sids_1]) {
4852                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4853                                 }
4854                                 ndr->depth--;
4855                                 free(idx_1);
4856                         }
4857                 }
4858                 ndr->depth--;
4859         }
4860         ndr->depth--;
4861         ndr->depth--;
4862 }
4863
4864 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4865 {
4866         if (ndr_flags & NDR_SCALARS) {
4867                 int level = ndr_push_get_switch_value(ndr, r);
4868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4869                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4870                 switch (level) {
4871                         case 1: {
4872                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4873                         break; }
4874
4875                         default:
4876                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4877                 }
4878         }
4879         if (ndr_flags & NDR_BUFFERS) {
4880                 int level = ndr_push_get_switch_value(ndr, r);
4881                 switch (level) {
4882                         case 1:
4883                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4884                         break;
4885
4886                         default:
4887                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4888                 }
4889         }
4890         return NDR_ERR_SUCCESS;
4891 }
4892
4893 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4894 {
4895         int level;
4896         uint32_t _level;
4897         level = ndr_pull_get_switch_value(ndr, r);
4898         if (ndr_flags & NDR_SCALARS) {
4899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4900                 if (_level != level) {
4901                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4902                 }
4903                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4904                 switch (level) {
4905                         case 1: {
4906                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4907                         break; }
4908
4909                         default:
4910                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4911                 }
4912         }
4913         if (ndr_flags & NDR_BUFFERS) {
4914                 switch (level) {
4915                         case 1:
4916                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4917                         break;
4918
4919                         default:
4920                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4921                 }
4922         }
4923         return NDR_ERR_SUCCESS;
4924 }
4925
4926 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4927 {
4928         int level;
4929         level = ndr_print_get_switch_value(ndr, r);
4930         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4931         switch (level) {
4932                 case 1:
4933                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4934                 break;
4935
4936                 default:
4937                         ndr_print_bad_level(ndr, name, level);
4938         }
4939 }
4940
4941 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4942 {
4943         uint32_t cntr_info_array_1;
4944         if (ndr_flags & NDR_SCALARS) {
4945                 NDR_CHECK(ndr_push_align(ndr, 5));
4946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4949                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4950                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4951                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4952         }
4953         if (ndr_flags & NDR_BUFFERS) {
4954                 if (r->info_array) {
4955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4956                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4957                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4958                         }
4959                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
4960                                 if (r->info_array[cntr_info_array_1]) {
4961                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4962                                 }
4963                         }
4964                 }
4965                 if (r->domain) {
4966                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
4967                 }
4968         }
4969         return NDR_ERR_SUCCESS;
4970 }
4971
4972 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
4973 {
4974         uint32_t _ptr_info_array;
4975         uint32_t cntr_info_array_1;
4976         TALLOC_CTX *_mem_save_info_array_0;
4977         TALLOC_CTX *_mem_save_info_array_1;
4978         TALLOC_CTX *_mem_save_info_array_2;
4979         uint32_t _ptr_domain;
4980         TALLOC_CTX *_mem_save_domain_0;
4981         if (ndr_flags & NDR_SCALARS) {
4982                 NDR_CHECK(ndr_pull_align(ndr, 5));
4983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4984                 if (r->count < 1 || r->count > 10000) {
4985                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4986                 }
4987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4988                 if (_ptr_info_array) {
4989                         NDR_PULL_ALLOC(ndr, r->info_array);
4990                 } else {
4991                         r->info_array = NULL;
4992                 }
4993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4994                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
4995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
4996                 if (_ptr_domain) {
4997                         NDR_PULL_ALLOC(ndr, r->domain);
4998                 } else {
4999                         r->domain = NULL;
5000                 }
5001                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5002         }
5003         if (ndr_flags & NDR_BUFFERS) {
5004                 if (r->info_array) {
5005                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5006                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5008                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5009                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5010                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5011                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5012                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5013                                 if (_ptr_info_array) {
5014                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5015                                 } else {
5016                                         r->info_array[cntr_info_array_1] = NULL;
5017                                 }
5018                         }
5019                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5020                                 if (r->info_array[cntr_info_array_1]) {
5021                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5022                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5023                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5024                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5025                                 }
5026                         }
5027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5029                 }
5030                 if (r->domain) {
5031                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5032                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5033                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5035                 }
5036                 if (r->info_array) {
5037                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5038                 }
5039         }
5040         return NDR_ERR_SUCCESS;
5041 }
5042
5043 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5044 {
5045         uint32_t cntr_info_array_1;
5046         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5047         ndr->depth++;
5048         ndr_print_uint32(ndr, "count", r->count);
5049         ndr_print_ptr(ndr, "info_array", r->info_array);
5050         ndr->depth++;
5051         if (r->info_array) {
5052                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5053                 ndr->depth++;
5054                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5055                         char *idx_1=NULL;
5056                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5057                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5058                                 ndr->depth++;
5059                                 if (r->info_array[cntr_info_array_1]) {
5060                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5061                                 }
5062                                 ndr->depth--;
5063                                 free(idx_1);
5064                         }
5065                 }
5066                 ndr->depth--;
5067         }
5068         ndr->depth--;
5069         ndr_print_uint32(ndr, "flags", r->flags);
5070         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5071         ndr_print_ptr(ndr, "domain", r->domain);
5072         ndr->depth++;
5073         if (r->domain) {
5074                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5075         }
5076         ndr->depth--;
5077         ndr->depth--;
5078 }
5079
5080 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5081 {
5082         if (ndr_flags & NDR_SCALARS) {
5083                 int level = ndr_push_get_switch_value(ndr, r);
5084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5085                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5086                 switch (level) {
5087                         case 1: {
5088                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5089                         break; }
5090
5091                         default:
5092                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5093                 }
5094         }
5095         if (ndr_flags & NDR_BUFFERS) {
5096                 int level = ndr_push_get_switch_value(ndr, r);
5097                 switch (level) {
5098                         case 1:
5099                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5100                         break;
5101
5102                         default:
5103                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5104                 }
5105         }
5106         return NDR_ERR_SUCCESS;
5107 }
5108
5109 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5110 {
5111         int level;
5112         uint32_t _level;
5113         level = ndr_pull_get_switch_value(ndr, r);
5114         if (ndr_flags & NDR_SCALARS) {
5115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5116                 if (_level != level) {
5117                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5118                 }
5119                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5120                 switch (level) {
5121                         case 1: {
5122                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5123                         break; }
5124
5125                         default:
5126                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5127                 }
5128         }
5129         if (ndr_flags & NDR_BUFFERS) {
5130                 switch (level) {
5131                         case 1:
5132                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5133                         break;
5134
5135                         default:
5136                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5137                 }
5138         }
5139         return NDR_ERR_SUCCESS;
5140 }
5141
5142 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5143 {
5144         int level;
5145         level = ndr_print_get_switch_value(ndr, r);
5146         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5147         switch (level) {
5148                 case 1:
5149                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5150                 break;
5151
5152                 default:
5153                         ndr_print_bad_level(ndr, name, level);
5154         }
5155 }
5156
5157 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5158 {
5159         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5160         return NDR_ERR_SUCCESS;
5161 }
5162
5163 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5164 {
5165         uint32_t v;
5166         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5167         *r = v;
5168         return NDR_ERR_SUCCESS;
5169 }
5170
5171 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogFlags(struct ndr_print *ndr, const char *name, uint32_t r)
5172 {
5173         ndr_print_uint32(ndr, name, r);
5174         ndr->depth++;
5175         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_NT4_CHANGELOG_GET_CHANGELOG", DRSUAPI_NT4_CHANGELOG_GET_CHANGELOG, r);
5176         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_NT4_CHANGELOG_GET_SERIAL_NUMBERS", DRSUAPI_NT4_CHANGELOG_GET_SERIAL_NUMBERS, r);
5177         ndr->depth--;
5178 }
5179
5180 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5181 {
5182         if (ndr_flags & NDR_SCALARS) {
5183                 NDR_CHECK(ndr_push_align(ndr, 5));
5184                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogFlags(ndr, NDR_SCALARS, r->flags));
5185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->preferred_maximum_length));
5186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->restart_length));
5187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->restart_data));
5188                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5189         }
5190         if (ndr_flags & NDR_BUFFERS) {
5191                 if (r->restart_data) {
5192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->restart_length));
5193                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->restart_data, r->restart_length));
5194                 }
5195         }
5196         return NDR_ERR_SUCCESS;
5197 }
5198
5199 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5200 {
5201         uint32_t _ptr_restart_data;
5202         TALLOC_CTX *_mem_save_restart_data_0;
5203         if (ndr_flags & NDR_SCALARS) {
5204                 NDR_CHECK(ndr_pull_align(ndr, 5));
5205                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogFlags(ndr, NDR_SCALARS, &r->flags));
5206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->preferred_maximum_length));
5207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->restart_length));
5208                 if (r->restart_length > 0x00A00000) {
5209                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5210                 }
5211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_restart_data));
5212                 if (_ptr_restart_data) {
5213                         NDR_PULL_ALLOC(ndr, r->restart_data);
5214                 } else {
5215                         r->restart_data = NULL;
5216                 }
5217                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5218         }
5219         if (ndr_flags & NDR_BUFFERS) {
5220                 if (r->restart_data) {
5221                         _mem_save_restart_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5222                         NDR_PULL_SET_MEM_CTX(ndr, r->restart_data, 0);
5223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->restart_data));
5224                         NDR_PULL_ALLOC_N(ndr, r->restart_data, ndr_get_array_size(ndr, &r->restart_data));
5225                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->restart_data, ndr_get_array_size(ndr, &r->restart_data)));
5226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_restart_data_0, 0);
5227                 }
5228                 if (r->restart_data) {
5229                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->restart_data, r->restart_length));
5230                 }
5231         }
5232         return NDR_ERR_SUCCESS;
5233 }
5234
5235 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5236 {
5237         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5238         ndr->depth++;
5239         ndr_print_drsuapi_DsGetNT4ChangeLogFlags(ndr, "flags", r->flags);
5240         ndr_print_uint32(ndr, "preferred_maximum_length", r->preferred_maximum_length);
5241         ndr_print_uint32(ndr, "restart_length", r->restart_length);
5242         ndr_print_ptr(ndr, "restart_data", r->restart_data);
5243         ndr->depth++;
5244         if (r->restart_data) {
5245                 ndr_print_array_uint8(ndr, "restart_data", r->restart_data, r->restart_length);
5246         }
5247         ndr->depth--;
5248         ndr->depth--;
5249 }
5250
5251 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5252 {
5253         if (ndr_flags & NDR_SCALARS) {
5254                 int level = ndr_push_get_switch_value(ndr, r);
5255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5256                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5257                 switch (level) {
5258                         case 1: {
5259                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5260                         break; }
5261
5262                         default:
5263                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5264                 }
5265         }
5266         if (ndr_flags & NDR_BUFFERS) {
5267                 int level = ndr_push_get_switch_value(ndr, r);
5268                 switch (level) {
5269                         case 1:
5270                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5271                         break;
5272
5273                         default:
5274                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5275                 }
5276         }
5277         return NDR_ERR_SUCCESS;
5278 }
5279
5280 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5281 {
5282         int level;
5283         uint32_t _level;
5284         level = ndr_pull_get_switch_value(ndr, r);
5285         if (ndr_flags & NDR_SCALARS) {
5286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5287                 if (_level != level) {
5288                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5289                 }
5290                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5291                 switch (level) {
5292                         case 1: {
5293                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5294                         break; }
5295
5296                         default:
5297                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5298                 }
5299         }
5300         if (ndr_flags & NDR_BUFFERS) {
5301                 switch (level) {
5302                         case 1:
5303                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5304                         break;
5305
5306                         default:
5307                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5308                 }
5309         }
5310         return NDR_ERR_SUCCESS;
5311 }
5312
5313 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5314 {
5315         int level;
5316         level = ndr_print_get_switch_value(ndr, r);
5317         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5318         switch (level) {
5319                 case 1:
5320                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5321                 break;
5322
5323                 default:
5324                         ndr_print_bad_level(ndr, name, level);
5325         }
5326 }
5327
5328 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5329 {
5330         if (ndr_flags & NDR_SCALARS) {
5331                 NDR_CHECK(ndr_push_align(ndr, 8));
5332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->restart_length));
5333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_length));
5334                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sam_serial_number));
5335                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->sam_creation_time));
5336                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->builtin_serial_number));
5337                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->builtin_creation_time));
5338                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lsa_serial_number));
5339                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->lsa_creation_time));
5340                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5341                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->restart_data));
5342                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->log_data));
5343                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5344         }
5345         if (ndr_flags & NDR_BUFFERS) {
5346                 if (r->restart_data) {
5347                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->restart_length));
5348                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->restart_data, r->restart_length));
5349                 }
5350                 if (r->log_data) {
5351                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->log_length));
5352                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->log_data, r->log_length));
5353                 }
5354         }
5355         return NDR_ERR_SUCCESS;
5356 }
5357
5358 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5359 {
5360         uint32_t _ptr_restart_data;
5361         TALLOC_CTX *_mem_save_restart_data_0;
5362         uint32_t _ptr_log_data;
5363         TALLOC_CTX *_mem_save_log_data_0;
5364         if (ndr_flags & NDR_SCALARS) {
5365                 NDR_CHECK(ndr_pull_align(ndr, 8));
5366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->restart_length));
5367                 if (r->restart_length > 0x00A00000) {
5368                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5369                 }
5370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_length));
5371                 if (r->log_length > 0x00A00000) {
5372                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5373                 }
5374                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sam_serial_number));
5375                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->sam_creation_time));
5376                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->builtin_serial_number));
5377                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->builtin_creation_time));
5378                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lsa_serial_number));
5379                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->lsa_creation_time));
5380                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5381                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_restart_data));
5382                 if (_ptr_restart_data) {
5383                         NDR_PULL_ALLOC(ndr, r->restart_data);
5384                 } else {
5385                         r->restart_data = NULL;
5386                 }
5387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_log_data));
5388                 if (_ptr_log_data) {
5389                         NDR_PULL_ALLOC(ndr, r->log_data);
5390                 } else {
5391                         r->log_data = NULL;
5392                 }
5393                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5394         }
5395         if (ndr_flags & NDR_BUFFERS) {
5396                 if (r->restart_data) {
5397                         _mem_save_restart_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5398                         NDR_PULL_SET_MEM_CTX(ndr, r->restart_data, 0);
5399                         NDR_CHECK(ndr_pull_array_size(ndr, &r->restart_data));
5400                         NDR_PULL_ALLOC_N(ndr, r->restart_data, ndr_get_array_size(ndr, &r->restart_data));
5401                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->restart_data, ndr_get_array_size(ndr, &r->restart_data)));
5402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_restart_data_0, 0);
5403                 }
5404                 if (r->log_data) {
5405                         _mem_save_log_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5406                         NDR_PULL_SET_MEM_CTX(ndr, r->log_data, 0);
5407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->log_data));
5408                         NDR_PULL_ALLOC_N(ndr, r->log_data, ndr_get_array_size(ndr, &r->log_data));
5409                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->log_data, ndr_get_array_size(ndr, &r->log_data)));
5410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_log_data_0, 0);
5411                 }
5412                 if (r->restart_data) {
5413                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->restart_data, r->restart_length));
5414                 }
5415                 if (r->log_data) {
5416                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->log_data, r->log_length));
5417                 }
5418         }
5419         return NDR_ERR_SUCCESS;
5420 }
5421
5422 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5423 {
5424         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5425         ndr->depth++;
5426         ndr_print_uint32(ndr, "restart_length", r->restart_length);
5427         ndr_print_uint32(ndr, "log_length", r->log_length);
5428         ndr_print_hyper(ndr, "sam_serial_number", r->sam_serial_number);
5429         ndr_print_NTTIME(ndr, "sam_creation_time", r->sam_creation_time);
5430         ndr_print_hyper(ndr, "builtin_serial_number", r->builtin_serial_number);
5431         ndr_print_NTTIME(ndr, "builtin_creation_time", r->builtin_creation_time);
5432         ndr_print_hyper(ndr, "lsa_serial_number", r->lsa_serial_number);
5433         ndr_print_NTTIME(ndr, "lsa_creation_time", r->lsa_creation_time);
5434         ndr_print_NTSTATUS(ndr, "status", r->status);
5435         ndr_print_ptr(ndr, "restart_data", r->restart_data);
5436         ndr->depth++;
5437         if (r->restart_data) {
5438                 ndr_print_array_uint8(ndr, "restart_data", r->restart_data, r->restart_length);
5439         }
5440         ndr->depth--;
5441         ndr_print_ptr(ndr, "log_data", r->log_data);
5442         ndr->depth++;
5443         if (r->log_data) {
5444                 ndr_print_array_uint8(ndr, "log_data", r->log_data, r->log_length);
5445         }
5446         ndr->depth--;
5447         ndr->depth--;
5448 }
5449
5450 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5451 {
5452         if (ndr_flags & NDR_SCALARS) {
5453                 int level = ndr_push_get_switch_value(ndr, r);
5454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5455                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5456                 switch (level) {
5457                         case 1: {
5458                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5459                         break; }
5460
5461                         default:
5462                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5463                 }
5464         }
5465         if (ndr_flags & NDR_BUFFERS) {
5466                 int level = ndr_push_get_switch_value(ndr, r);
5467                 switch (level) {
5468                         case 1:
5469                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5470                         break;
5471
5472                         default:
5473                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5474                 }
5475         }
5476         return NDR_ERR_SUCCESS;
5477 }
5478
5479 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5480 {
5481         int level;
5482         uint32_t _level;
5483         level = ndr_pull_get_switch_value(ndr, r);
5484         if (ndr_flags & NDR_SCALARS) {
5485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5486                 if (_level != level) {
5487                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5488                 }
5489                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5490                 switch (level) {
5491                         case 1: {
5492                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5493                         break; }
5494
5495                         default:
5496                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5497                 }
5498         }
5499         if (ndr_flags & NDR_BUFFERS) {
5500                 switch (level) {
5501                         case 1:
5502                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5503                         break;
5504
5505                         default:
5506                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5507                 }
5508         }
5509         return NDR_ERR_SUCCESS;
5510 }
5511
5512 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5513 {
5514         int level;
5515         level = ndr_print_get_switch_value(ndr, r);
5516         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5517         switch (level) {
5518                 case 1:
5519                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5520                 break;
5521
5522                 default:
5523                         ndr_print_bad_level(ndr, name, level);
5524         }
5525 }
5526
5527 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5528 {
5529         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5530         return NDR_ERR_SUCCESS;
5531 }
5532
5533 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5534 {
5535         uint32_t v;
5536         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5537         *r = v;
5538         return NDR_ERR_SUCCESS;
5539 }
5540
5541 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5542 {
5543         const char *val = NULL;
5544
5545         switch (r) {
5546                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5547                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5548                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5549                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5550                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5551                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5552                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5553                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5554         }
5555         ndr_print_enum(ndr, name, "ENUM", val, r);
5556 }
5557
5558 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5559 {
5560         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5561         return NDR_ERR_SUCCESS;
5562 }
5563
5564 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5565 {
5566         uint32_t v;
5567         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5568         *r = v;
5569         return NDR_ERR_SUCCESS;
5570 }
5571
5572 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5573 {
5574         const char *val = NULL;
5575
5576         switch (r) {
5577                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5578                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5579                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5580                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5581                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5582         }
5583         ndr_print_enum(ndr, name, "ENUM", val, r);
5584 }
5585
5586 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5587 {
5588         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5589         return NDR_ERR_SUCCESS;
5590 }
5591
5592 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5593 {
5594         uint32_t v;
5595         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5596         *r = v;
5597         return NDR_ERR_SUCCESS;
5598 }
5599
5600 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5601 {
5602         const char *val = NULL;
5603
5604         switch (r) {
5605                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5606                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5607                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5608                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5609                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5610                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5611                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5612                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5613                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5614                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5615                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5616         }
5617         ndr_print_enum(ndr, name, "ENUM", val, r);
5618 }
5619
5620 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5621 {
5622         if (ndr_flags & NDR_SCALARS) {
5623                 NDR_CHECK(ndr_push_align(ndr, 5));
5624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5625                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5626         }
5627         if (ndr_flags & NDR_BUFFERS) {
5628                 if (r->str) {
5629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5633                 }
5634         }
5635         return NDR_ERR_SUCCESS;
5636 }
5637
5638 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5639 {
5640         uint32_t _ptr_str;
5641         TALLOC_CTX *_mem_save_str_0;
5642         if (ndr_flags & NDR_SCALARS) {
5643                 NDR_CHECK(ndr_pull_align(ndr, 5));
5644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5645                 if (_ptr_str) {
5646                         NDR_PULL_ALLOC(ndr, r->str);
5647                 } else {
5648                         r->str = NULL;
5649                 }
5650                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5651         }
5652         if (ndr_flags & NDR_BUFFERS) {
5653                 if (r->str) {
5654                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5655                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5658                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5659                                 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));
5660                         }
5661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5664                 }
5665         }
5666         return NDR_ERR_SUCCESS;
5667 }
5668
5669 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5670 {
5671         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5672         ndr->depth++;
5673         ndr_print_ptr(ndr, "str", r->str);
5674         ndr->depth++;
5675         if (r->str) {
5676                 ndr_print_string(ndr, "str", r->str);
5677         }
5678         ndr->depth--;
5679         ndr->depth--;
5680 }
5681
5682 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5683 {
5684         uint32_t cntr_names_1;
5685         if (ndr_flags & NDR_SCALARS) {
5686                 NDR_CHECK(ndr_push_align(ndr, 5));
5687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5689                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5690                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5691                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5694                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5695         }
5696         if (ndr_flags & NDR_BUFFERS) {
5697                 if (r->names) {
5698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5699                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5700                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5701                         }
5702                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5703                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5704                         }
5705                 }
5706         }
5707         return NDR_ERR_SUCCESS;
5708 }
5709
5710 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5711 {
5712         uint32_t _ptr_names;
5713         uint32_t cntr_names_1;
5714         TALLOC_CTX *_mem_save_names_0;
5715         TALLOC_CTX *_mem_save_names_1;
5716         if (ndr_flags & NDR_SCALARS) {
5717                 NDR_CHECK(ndr_pull_align(ndr, 5));
5718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5720                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5721                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5722                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5724                 if (r->count < 1 || r->count > 10000) {
5725                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5726                 }
5727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5728                 if (_ptr_names) {
5729                         NDR_PULL_ALLOC(ndr, r->names);
5730                 } else {
5731                         r->names = NULL;
5732                 }
5733                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5734         }
5735         if (ndr_flags & NDR_BUFFERS) {
5736                 if (r->names) {
5737                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5738                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5739                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5740                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5741                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5742                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5743                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5744                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5745                         }
5746                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5747                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5748                         }
5749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5751                 }
5752                 if (r->names) {
5753                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5754                 }
5755         }
5756         return NDR_ERR_SUCCESS;
5757 }
5758
5759 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5760 {
5761         uint32_t cntr_names_1;
5762         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5763         ndr->depth++;
5764         ndr_print_uint32(ndr, "codepage", r->codepage);
5765         ndr_print_uint32(ndr, "language", r->language);
5766         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5767         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5768         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5769         ndr_print_uint32(ndr, "count", r->count);
5770         ndr_print_ptr(ndr, "names", r->names);
5771         ndr->depth++;
5772         if (r->names) {
5773                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5774                 ndr->depth++;
5775                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5776                         char *idx_1=NULL;
5777                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5778                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5779                                 free(idx_1);
5780                         }
5781                 }
5782                 ndr->depth--;
5783         }
5784         ndr->depth--;
5785         ndr->depth--;
5786 }
5787
5788 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5789 {
5790         if (ndr_flags & NDR_SCALARS) {
5791                 int level = ndr_push_get_switch_value(ndr, r);
5792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5793                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5794                 switch (level) {
5795                         case 1: {
5796                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5797                         break; }
5798
5799                         default:
5800                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5801                 }
5802         }
5803         if (ndr_flags & NDR_BUFFERS) {
5804                 int level = ndr_push_get_switch_value(ndr, r);
5805                 switch (level) {
5806                         case 1:
5807                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5808                         break;
5809
5810                         default:
5811                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5812                 }
5813         }
5814         return NDR_ERR_SUCCESS;
5815 }
5816
5817 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5818 {
5819         int level;
5820         uint32_t _level;
5821         level = ndr_pull_get_switch_value(ndr, r);
5822         if (ndr_flags & NDR_SCALARS) {
5823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5824                 if (_level != level) {
5825                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5826                 }
5827                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5828                 switch (level) {
5829                         case 1: {
5830                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5831                         break; }
5832
5833                         default:
5834                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5835                 }
5836         }
5837         if (ndr_flags & NDR_BUFFERS) {
5838                 switch (level) {
5839                         case 1:
5840                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5841                         break;
5842
5843                         default:
5844                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5845                 }
5846         }
5847         return NDR_ERR_SUCCESS;
5848 }
5849
5850 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5851 {
5852         int level;
5853         level = ndr_print_get_switch_value(ndr, r);
5854         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5855         switch (level) {
5856                 case 1:
5857                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5858                 break;
5859
5860                 default:
5861                         ndr_print_bad_level(ndr, name, level);
5862         }
5863 }
5864
5865 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5866 {
5867         if (ndr_flags & NDR_SCALARS) {
5868                 NDR_CHECK(ndr_push_align(ndr, 5));
5869                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5872                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5873         }
5874         if (ndr_flags & NDR_BUFFERS) {
5875                 if (r->dns_domain_name) {
5876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5879                         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));
5880                 }
5881                 if (r->result_name) {
5882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5885                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5886                 }
5887         }
5888         return NDR_ERR_SUCCESS;
5889 }
5890
5891 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5892 {
5893         uint32_t _ptr_dns_domain_name;
5894         TALLOC_CTX *_mem_save_dns_domain_name_0;
5895         uint32_t _ptr_result_name;
5896         TALLOC_CTX *_mem_save_result_name_0;
5897         if (ndr_flags & NDR_SCALARS) {
5898                 NDR_CHECK(ndr_pull_align(ndr, 5));
5899                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5901                 if (_ptr_dns_domain_name) {
5902                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5903                 } else {
5904                         r->dns_domain_name = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5907                 if (_ptr_result_name) {
5908                         NDR_PULL_ALLOC(ndr, r->result_name);
5909                 } else {
5910                         r->result_name = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5913         }
5914         if (ndr_flags & NDR_BUFFERS) {
5915                 if (r->dns_domain_name) {
5916                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5917                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5920                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5921                                 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));
5922                         }
5923                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5924                         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));
5925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5926                 }
5927                 if (r->result_name) {
5928                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5929                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5932                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5933                                 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));
5934                         }
5935                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5936                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5938                 }
5939         }
5940         return NDR_ERR_SUCCESS;
5941 }
5942
5943 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5944 {
5945         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5946         ndr->depth++;
5947         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5948         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5949         ndr->depth++;
5950         if (r->dns_domain_name) {
5951                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5952         }
5953         ndr->depth--;
5954         ndr_print_ptr(ndr, "result_name", r->result_name);
5955         ndr->depth++;
5956         if (r->result_name) {
5957                 ndr_print_string(ndr, "result_name", r->result_name);
5958         }
5959         ndr->depth--;
5960         ndr->depth--;
5961 }
5962
5963 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5964 {
5965         uint32_t cntr_array_1;
5966         if (ndr_flags & NDR_SCALARS) {
5967                 NDR_CHECK(ndr_push_align(ndr, 5));
5968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5970                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5971         }
5972         if (ndr_flags & NDR_BUFFERS) {
5973                 if (r->array) {
5974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5975                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5976                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5977                         }
5978                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5979                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5980                         }
5981                 }
5982         }
5983         return NDR_ERR_SUCCESS;
5984 }
5985
5986 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
5987 {
5988         uint32_t _ptr_array;
5989         uint32_t cntr_array_1;
5990         TALLOC_CTX *_mem_save_array_0;
5991         TALLOC_CTX *_mem_save_array_1;
5992         if (ndr_flags & NDR_SCALARS) {
5993                 NDR_CHECK(ndr_pull_align(ndr, 5));
5994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5996                 if (_ptr_array) {
5997                         NDR_PULL_ALLOC(ndr, r->array);
5998                 } else {
5999                         r->array = NULL;
6000                 }
6001                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6002         }
6003         if (ndr_flags & NDR_BUFFERS) {
6004                 if (r->array) {
6005                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6006                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6008                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6009                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6010                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6011                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6012                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6013                         }
6014                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6015                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6016                         }
6017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6018                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6019                 }
6020                 if (r->array) {
6021                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6022                 }
6023         }
6024         return NDR_ERR_SUCCESS;
6025 }
6026
6027 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6028 {
6029         uint32_t cntr_array_1;
6030         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6031         ndr->depth++;
6032         ndr_print_uint32(ndr, "count", r->count);
6033         ndr_print_ptr(ndr, "array", r->array);
6034         ndr->depth++;
6035         if (r->array) {
6036                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6037                 ndr->depth++;
6038                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6039                         char *idx_1=NULL;
6040                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6041                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6042                                 free(idx_1);
6043                         }
6044                 }
6045                 ndr->depth--;
6046         }
6047         ndr->depth--;
6048         ndr->depth--;
6049 }
6050
6051 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6052 {
6053         if (ndr_flags & NDR_SCALARS) {
6054                 int level = ndr_push_get_switch_value(ndr, r);
6055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6056                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6057                 switch (level) {
6058                         case 1: {
6059                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6060                         break; }
6061
6062                         default:
6063                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6064                 }
6065         }
6066         if (ndr_flags & NDR_BUFFERS) {
6067                 int level = ndr_push_get_switch_value(ndr, r);
6068                 switch (level) {
6069                         case 1:
6070                                 if (r->ctr1) {
6071                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6072                                 }
6073                         break;
6074
6075                         default:
6076                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6077                 }
6078         }
6079         return NDR_ERR_SUCCESS;
6080 }
6081
6082 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6083 {
6084         int level;
6085         uint32_t _level;
6086         TALLOC_CTX *_mem_save_ctr1_0;
6087         level = ndr_pull_get_switch_value(ndr, r);
6088         if (ndr_flags & NDR_SCALARS) {
6089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6090                 if (_level != level) {
6091                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6092                 }
6093                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6094                 switch (level) {
6095                         case 1: {
6096                                 uint32_t _ptr_ctr1;
6097                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6098                                 if (_ptr_ctr1) {
6099                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6100                                 } else {
6101                                         r->ctr1 = NULL;
6102                                 }
6103                         break; }
6104
6105                         default:
6106                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6107                 }
6108         }
6109         if (ndr_flags & NDR_BUFFERS) {
6110                 switch (level) {
6111                         case 1:
6112                                 if (r->ctr1) {
6113                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6114                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6115                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6116                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6117                                 }
6118                         break;
6119
6120                         default:
6121                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6122                 }
6123         }
6124         return NDR_ERR_SUCCESS;
6125 }
6126
6127 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6128 {
6129         int level;
6130         level = ndr_print_get_switch_value(ndr, r);
6131         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6132         switch (level) {
6133                 case 1:
6134                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6135                         ndr->depth++;
6136                         if (r->ctr1) {
6137                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6138                         }
6139                         ndr->depth--;
6140                 break;
6141
6142                 default:
6143                         ndr_print_bad_level(ndr, name, level);
6144         }
6145 }
6146
6147 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6148 {
6149         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6150         return NDR_ERR_SUCCESS;
6151 }
6152
6153 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6154 {
6155         uint32_t v;
6156         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6157         *r = v;
6158         return NDR_ERR_SUCCESS;
6159 }
6160
6161 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6162 {
6163         const char *val = NULL;
6164
6165         switch (r) {
6166                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6167                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6168                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6169         }
6170         ndr_print_enum(ndr, name, "ENUM", val, r);
6171 }
6172
6173 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6174 {
6175         uint32_t cntr_spn_names_1;
6176         if (ndr_flags & NDR_SCALARS) {
6177                 NDR_CHECK(ndr_push_align(ndr, 5));
6178                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6180                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6183                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6184         }
6185         if (ndr_flags & NDR_BUFFERS) {
6186                 if (r->object_dn) {
6187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6191                 }
6192                 if (r->spn_names) {
6193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6194                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6195                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6196                         }
6197                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6198                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6199                         }
6200                 }
6201         }
6202         return NDR_ERR_SUCCESS;
6203 }
6204
6205 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6206 {
6207         uint32_t _ptr_object_dn;
6208         TALLOC_CTX *_mem_save_object_dn_0;
6209         uint32_t _ptr_spn_names;
6210         uint32_t cntr_spn_names_1;
6211         TALLOC_CTX *_mem_save_spn_names_0;
6212         TALLOC_CTX *_mem_save_spn_names_1;
6213         if (ndr_flags & NDR_SCALARS) {
6214                 NDR_CHECK(ndr_pull_align(ndr, 5));
6215                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6218                 if (_ptr_object_dn) {
6219                         NDR_PULL_ALLOC(ndr, r->object_dn);
6220                 } else {
6221                         r->object_dn = NULL;
6222                 }
6223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6224                 if (r->count > 10000) {
6225                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6226                 }
6227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6228                 if (_ptr_spn_names) {
6229                         NDR_PULL_ALLOC(ndr, r->spn_names);
6230                 } else {
6231                         r->spn_names = NULL;
6232                 }
6233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6234         }
6235         if (ndr_flags & NDR_BUFFERS) {
6236                 if (r->object_dn) {
6237                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6238                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6241                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6242                                 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));
6243                         }
6244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6245                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6247                 }
6248                 if (r->spn_names) {
6249                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6250                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6252                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6253                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6254                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6255                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6256                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6257                         }
6258                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6259                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6260                         }
6261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6263                 }
6264                 if (r->spn_names) {
6265                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6266                 }
6267         }
6268         return NDR_ERR_SUCCESS;
6269 }
6270
6271 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6272 {
6273         uint32_t cntr_spn_names_1;
6274         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6275         ndr->depth++;
6276         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6277         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6278         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6279         ndr->depth++;
6280         if (r->object_dn) {
6281                 ndr_print_string(ndr, "object_dn", r->object_dn);
6282         }
6283         ndr->depth--;
6284         ndr_print_uint32(ndr, "count", r->count);
6285         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6286         ndr->depth++;
6287         if (r->spn_names) {
6288                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6289                 ndr->depth++;
6290                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6291                         char *idx_1=NULL;
6292                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6293                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6294                                 free(idx_1);
6295                         }
6296                 }
6297                 ndr->depth--;
6298         }
6299         ndr->depth--;
6300         ndr->depth--;
6301 }
6302
6303 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6304 {
6305         if (ndr_flags & NDR_SCALARS) {
6306                 int level = ndr_push_get_switch_value(ndr, r);
6307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6308                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6309                 switch (level) {
6310                         case 1: {
6311                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6312                         break; }
6313
6314                         default:
6315                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6316                 }
6317         }
6318         if (ndr_flags & NDR_BUFFERS) {
6319                 int level = ndr_push_get_switch_value(ndr, r);
6320                 switch (level) {
6321                         case 1:
6322                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6323                         break;
6324
6325                         default:
6326                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6327                 }
6328         }
6329         return NDR_ERR_SUCCESS;
6330 }
6331
6332 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6333 {
6334         int level;
6335         uint32_t _level;
6336         level = ndr_pull_get_switch_value(ndr, r);
6337         if (ndr_flags & NDR_SCALARS) {
6338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6339                 if (_level != level) {
6340                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6341                 }
6342                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6343                 switch (level) {
6344                         case 1: {
6345                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6346                         break; }
6347
6348                         default:
6349                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6350                 }
6351         }
6352         if (ndr_flags & NDR_BUFFERS) {
6353                 switch (level) {
6354                         case 1:
6355                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6356                         break;
6357
6358                         default:
6359                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6360                 }
6361         }
6362         return NDR_ERR_SUCCESS;
6363 }
6364
6365 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6366 {
6367         int level;
6368         level = ndr_print_get_switch_value(ndr, r);
6369         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6370         switch (level) {
6371                 case 1:
6372                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6373                 break;
6374
6375                 default:
6376                         ndr_print_bad_level(ndr, name, level);
6377         }
6378 }
6379
6380 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6381 {
6382         if (ndr_flags & NDR_SCALARS) {
6383                 NDR_CHECK(ndr_push_align(ndr, 4));
6384                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6385                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6386         }
6387         if (ndr_flags & NDR_BUFFERS) {
6388         }
6389         return NDR_ERR_SUCCESS;
6390 }
6391
6392 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6393 {
6394         if (ndr_flags & NDR_SCALARS) {
6395                 NDR_CHECK(ndr_pull_align(ndr, 4));
6396                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6397                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6398         }
6399         if (ndr_flags & NDR_BUFFERS) {
6400         }
6401         return NDR_ERR_SUCCESS;
6402 }
6403
6404 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6405 {
6406         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6407         ndr->depth++;
6408         ndr_print_WERROR(ndr, "status", r->status);
6409         ndr->depth--;
6410 }
6411
6412 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6413 {
6414         if (ndr_flags & NDR_SCALARS) {
6415                 int level = ndr_push_get_switch_value(ndr, r);
6416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6417                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6418                 switch (level) {
6419                         case 1: {
6420                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6421                         break; }
6422
6423                         default:
6424                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6425                 }
6426         }
6427         if (ndr_flags & NDR_BUFFERS) {
6428                 int level = ndr_push_get_switch_value(ndr, r);
6429                 switch (level) {
6430                         case 1:
6431                         break;
6432
6433                         default:
6434                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6435                 }
6436         }
6437         return NDR_ERR_SUCCESS;
6438 }
6439
6440 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6441 {
6442         int level;
6443         uint32_t _level;
6444         level = ndr_pull_get_switch_value(ndr, r);
6445         if (ndr_flags & NDR_SCALARS) {
6446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6447                 if (_level != level) {
6448                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6449                 }
6450                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6451                 switch (level) {
6452                         case 1: {
6453                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6454                         break; }
6455
6456                         default:
6457                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6458                 }
6459         }
6460         if (ndr_flags & NDR_BUFFERS) {
6461                 switch (level) {
6462                         case 1:
6463                         break;
6464
6465                         default:
6466                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6467                 }
6468         }
6469         return NDR_ERR_SUCCESS;
6470 }
6471
6472 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6473 {
6474         int level;
6475         level = ndr_print_get_switch_value(ndr, r);
6476         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6477         switch (level) {
6478                 case 1:
6479                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6480                 break;
6481
6482                 default:
6483                         ndr_print_bad_level(ndr, name, level);
6484         }
6485 }
6486
6487 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6488 {
6489         if (ndr_flags & NDR_SCALARS) {
6490                 NDR_CHECK(ndr_push_align(ndr, 5));
6491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6494                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6495         }
6496         if (ndr_flags & NDR_BUFFERS) {
6497                 if (r->server_dn) {
6498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6499                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6500                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6501                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6502                 }
6503                 if (r->domain_dn) {
6504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6506                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6507                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6508                 }
6509         }
6510         return NDR_ERR_SUCCESS;
6511 }
6512
6513 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6514 {
6515         uint32_t _ptr_server_dn;
6516         TALLOC_CTX *_mem_save_server_dn_0;
6517         uint32_t _ptr_domain_dn;
6518         TALLOC_CTX *_mem_save_domain_dn_0;
6519         if (ndr_flags & NDR_SCALARS) {
6520                 NDR_CHECK(ndr_pull_align(ndr, 5));
6521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6522                 if (_ptr_server_dn) {
6523                         NDR_PULL_ALLOC(ndr, r->server_dn);
6524                 } else {
6525                         r->server_dn = NULL;
6526                 }
6527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6528                 if (_ptr_domain_dn) {
6529                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6530                 } else {
6531                         r->domain_dn = NULL;
6532                 }
6533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6534                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6535         }
6536         if (ndr_flags & NDR_BUFFERS) {
6537                 if (r->server_dn) {
6538                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6539                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6542                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6543                                 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));
6544                         }
6545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6548                 }
6549                 if (r->domain_dn) {
6550                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6551                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6554                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6555                                 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));
6556                         }
6557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6560                 }
6561         }
6562         return NDR_ERR_SUCCESS;
6563 }
6564
6565 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6566 {
6567         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6568         ndr->depth++;
6569         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6570         ndr->depth++;
6571         if (r->server_dn) {
6572                 ndr_print_string(ndr, "server_dn", r->server_dn);
6573         }
6574         ndr->depth--;
6575         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6576         ndr->depth++;
6577         if (r->domain_dn) {
6578                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6579         }
6580         ndr->depth--;
6581         ndr_print_uint32(ndr, "commit", r->commit);
6582         ndr->depth--;
6583 }
6584
6585 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6586 {
6587         if (ndr_flags & NDR_SCALARS) {
6588                 int level = ndr_push_get_switch_value(ndr, r);
6589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6590                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6591                 switch (level) {
6592                         case 1: {
6593                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6594                         break; }
6595
6596                         default:
6597                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6598                 }
6599         }
6600         if (ndr_flags & NDR_BUFFERS) {
6601                 int level = ndr_push_get_switch_value(ndr, r);
6602                 switch (level) {
6603                         case 1:
6604                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6605                         break;
6606
6607                         default:
6608                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6609                 }
6610         }
6611         return NDR_ERR_SUCCESS;
6612 }
6613
6614 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6615 {
6616         int level;
6617         uint32_t _level;
6618         level = ndr_pull_get_switch_value(ndr, r);
6619         if (ndr_flags & NDR_SCALARS) {
6620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6621                 if (_level != level) {
6622                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6623                 }
6624                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6625                 switch (level) {
6626                         case 1: {
6627                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6628                         break; }
6629
6630                         default:
6631                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6632                 }
6633         }
6634         if (ndr_flags & NDR_BUFFERS) {
6635                 switch (level) {
6636                         case 1:
6637                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6638                         break;
6639
6640                         default:
6641                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6642                 }
6643         }
6644         return NDR_ERR_SUCCESS;
6645 }
6646
6647 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6648 {
6649         int level;
6650         level = ndr_print_get_switch_value(ndr, r);
6651         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6652         switch (level) {
6653                 case 1:
6654                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6655                 break;
6656
6657                 default:
6658                         ndr_print_bad_level(ndr, name, level);
6659         }
6660 }
6661
6662 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6663 {
6664         if (ndr_flags & NDR_SCALARS) {
6665                 NDR_CHECK(ndr_push_align(ndr, 4));
6666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6667                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6668         }
6669         if (ndr_flags & NDR_BUFFERS) {
6670         }
6671         return NDR_ERR_SUCCESS;
6672 }
6673
6674 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6675 {
6676         if (ndr_flags & NDR_SCALARS) {
6677                 NDR_CHECK(ndr_pull_align(ndr, 4));
6678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6679                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6680         }
6681         if (ndr_flags & NDR_BUFFERS) {
6682         }
6683         return NDR_ERR_SUCCESS;
6684 }
6685
6686 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6687 {
6688         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6689         ndr->depth++;
6690         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6691         ndr->depth--;
6692 }
6693
6694 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6695 {
6696         if (ndr_flags & NDR_SCALARS) {
6697                 int level = ndr_push_get_switch_value(ndr, r);
6698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6699                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6700                 switch (level) {
6701                         case 1: {
6702                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6703                         break; }
6704
6705                         default:
6706                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6707                 }
6708         }
6709         if (ndr_flags & NDR_BUFFERS) {
6710                 int level = ndr_push_get_switch_value(ndr, r);
6711                 switch (level) {
6712                         case 1:
6713                         break;
6714
6715                         default:
6716                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6717                 }
6718         }
6719         return NDR_ERR_SUCCESS;
6720 }
6721
6722 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6723 {
6724         int level;
6725         uint32_t _level;
6726         level = ndr_pull_get_switch_value(ndr, r);
6727         if (ndr_flags & NDR_SCALARS) {
6728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6729                 if (_level != level) {
6730                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6731                 }
6732                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6733                 switch (level) {
6734                         case 1: {
6735                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6736                         break; }
6737
6738                         default:
6739                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6740                 }
6741         }
6742         if (ndr_flags & NDR_BUFFERS) {
6743                 switch (level) {
6744                         case 1:
6745                         break;
6746
6747                         default:
6748                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6749                 }
6750         }
6751         return NDR_ERR_SUCCESS;
6752 }
6753
6754 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6755 {
6756         int level;
6757         level = ndr_print_get_switch_value(ndr, r);
6758         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6759         switch (level) {
6760                 case 1:
6761                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6762                 break;
6763
6764                 default:
6765                         ndr_print_bad_level(ndr, name, level);
6766         }
6767 }
6768
6769 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6770 {
6771         if (ndr_flags & NDR_SCALARS) {
6772                 NDR_CHECK(ndr_push_align(ndr, 5));
6773                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6774                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6775                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6776         }
6777         if (ndr_flags & NDR_BUFFERS) {
6778                 if (r->domain_name) {
6779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6783                 }
6784         }
6785         return NDR_ERR_SUCCESS;
6786 }
6787
6788 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6789 {
6790         uint32_t _ptr_domain_name;
6791         TALLOC_CTX *_mem_save_domain_name_0;
6792         if (ndr_flags & NDR_SCALARS) {
6793                 NDR_CHECK(ndr_pull_align(ndr, 5));
6794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6795                 if (_ptr_domain_name) {
6796                         NDR_PULL_ALLOC(ndr, r->domain_name);
6797                 } else {
6798                         r->domain_name = NULL;
6799                 }
6800                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6801                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6802         }
6803         if (ndr_flags & NDR_BUFFERS) {
6804                 if (r->domain_name) {
6805                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6806                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6807                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6808                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6809                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6810                                 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));
6811                         }
6812                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6813                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6815                 }
6816         }
6817         return NDR_ERR_SUCCESS;
6818 }
6819
6820 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6821 {
6822         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6823         ndr->depth++;
6824         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6825         ndr->depth++;
6826         if (r->domain_name) {
6827                 ndr_print_string(ndr, "domain_name", r->domain_name);
6828         }
6829         ndr->depth--;
6830         ndr_print_int32(ndr, "level", r->level);
6831         ndr->depth--;
6832 }
6833
6834 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6835 {
6836         if (ndr_flags & NDR_SCALARS) {
6837                 int level = ndr_push_get_switch_value(ndr, r);
6838                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6839                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6840                 switch (level) {
6841                         case 1: {
6842                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6843                         break; }
6844
6845                         default:
6846                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6847                 }
6848         }
6849         if (ndr_flags & NDR_BUFFERS) {
6850                 int level = ndr_push_get_switch_value(ndr, r);
6851                 switch (level) {
6852                         case 1:
6853                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6854                         break;
6855
6856                         default:
6857                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6858                 }
6859         }
6860         return NDR_ERR_SUCCESS;
6861 }
6862
6863 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6864 {
6865         int level;
6866         int32_t _level;
6867         level = ndr_pull_get_switch_value(ndr, r);
6868         if (ndr_flags & NDR_SCALARS) {
6869                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6870                 if (_level != level) {
6871                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6872                 }
6873                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6874                 switch (level) {
6875                         case 1: {
6876                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6877                         break; }
6878
6879                         default:
6880                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6881                 }
6882         }
6883         if (ndr_flags & NDR_BUFFERS) {
6884                 switch (level) {
6885                         case 1:
6886                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6887                         break;
6888
6889                         default:
6890                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6891                 }
6892         }
6893         return NDR_ERR_SUCCESS;
6894 }
6895
6896 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6897 {
6898         int level;
6899         level = ndr_print_get_switch_value(ndr, r);
6900         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6901         switch (level) {
6902                 case 1:
6903                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6904                 break;
6905
6906                 default:
6907                         ndr_print_bad_level(ndr, name, level);
6908         }
6909 }
6910
6911 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6912 {
6913         if (ndr_flags & NDR_SCALARS) {
6914                 NDR_CHECK(ndr_push_align(ndr, 5));
6915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6918                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6922                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6923         }
6924         if (ndr_flags & NDR_BUFFERS) {
6925                 if (r->netbios_name) {
6926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6930                 }
6931                 if (r->dns_name) {
6932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6935                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6936                 }
6937                 if (r->site_name) {
6938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6941                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6942                 }
6943                 if (r->computer_dn) {
6944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6947                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6948                 }
6949                 if (r->server_dn) {
6950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, 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->server_dn, CH_UTF16)));
6953                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6954                 }
6955         }
6956         return NDR_ERR_SUCCESS;
6957 }
6958
6959 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6960 {
6961         uint32_t _ptr_netbios_name;
6962         TALLOC_CTX *_mem_save_netbios_name_0;
6963         uint32_t _ptr_dns_name;
6964         TALLOC_CTX *_mem_save_dns_name_0;
6965         uint32_t _ptr_site_name;
6966         TALLOC_CTX *_mem_save_site_name_0;
6967         uint32_t _ptr_computer_dn;
6968         TALLOC_CTX *_mem_save_computer_dn_0;
6969         uint32_t _ptr_server_dn;
6970         TALLOC_CTX *_mem_save_server_dn_0;
6971         if (ndr_flags & NDR_SCALARS) {
6972                 NDR_CHECK(ndr_pull_align(ndr, 5));
6973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6974                 if (_ptr_netbios_name) {
6975                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6976                 } else {
6977                         r->netbios_name = NULL;
6978                 }
6979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6980                 if (_ptr_dns_name) {
6981                         NDR_PULL_ALLOC(ndr, r->dns_name);
6982                 } else {
6983                         r->dns_name = NULL;
6984                 }
6985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6986                 if (_ptr_site_name) {
6987                         NDR_PULL_ALLOC(ndr, r->site_name);
6988                 } else {
6989                         r->site_name = NULL;
6990                 }
6991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6992                 if (_ptr_computer_dn) {
6993                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6994                 } else {
6995                         r->computer_dn = NULL;
6996                 }
6997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6998                 if (_ptr_server_dn) {
6999                         NDR_PULL_ALLOC(ndr, r->server_dn);
7000                 } else {
7001                         r->server_dn = NULL;
7002                 }
7003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7005                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7006         }
7007         if (ndr_flags & NDR_BUFFERS) {
7008                 if (r->netbios_name) {
7009                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7010                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7011                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7012                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7013                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7014                                 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));
7015                         }
7016                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7017                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7018                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7019                 }
7020                 if (r->dns_name) {
7021                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7022                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7023                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7024                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7025                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7026                                 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));
7027                         }
7028                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7029                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7030                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7031                 }
7032                 if (r->site_name) {
7033                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7034                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7037                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_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->site_name), ndr_get_array_length(ndr, &r->site_name));
7039                         }
7040                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7041                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7043                 }
7044                 if (r->computer_dn) {
7045                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7046                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7048                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7049                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
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->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7051                         }
7052                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7053                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7055                 }
7056                 if (r->server_dn) {
7057                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7058                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7059                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7060                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7061                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
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->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7063                         }
7064                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7065                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7067                 }
7068         }
7069         return NDR_ERR_SUCCESS;
7070 }
7071
7072 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7073 {
7074         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7075         ndr->depth++;
7076         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7077         ndr->depth++;
7078         if (r->netbios_name) {
7079                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7080         }
7081         ndr->depth--;
7082         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7083         ndr->depth++;
7084         if (r->dns_name) {
7085                 ndr_print_string(ndr, "dns_name", r->dns_name);
7086         }
7087         ndr->depth--;
7088         ndr_print_ptr(ndr, "site_name", r->site_name);
7089         ndr->depth++;
7090         if (r->site_name) {
7091                 ndr_print_string(ndr, "site_name", r->site_name);
7092         }
7093         ndr->depth--;
7094         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7095         ndr->depth++;
7096         if (r->computer_dn) {
7097                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7098         }
7099         ndr->depth--;
7100         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7101         ndr->depth++;
7102         if (r->server_dn) {
7103                 ndr_print_string(ndr, "server_dn", r->server_dn);
7104         }
7105         ndr->depth--;
7106         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7107         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7108         ndr->depth--;
7109 }
7110
7111 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7112 {
7113         uint32_t cntr_array_1;
7114         if (ndr_flags & NDR_SCALARS) {
7115                 NDR_CHECK(ndr_push_align(ndr, 5));
7116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7118                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7119         }
7120         if (ndr_flags & NDR_BUFFERS) {
7121                 if (r->array) {
7122                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7123                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7124                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7125                         }
7126                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7127                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7128                         }
7129                 }
7130         }
7131         return NDR_ERR_SUCCESS;
7132 }
7133
7134 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7135 {
7136         uint32_t _ptr_array;
7137         uint32_t cntr_array_1;
7138         TALLOC_CTX *_mem_save_array_0;
7139         TALLOC_CTX *_mem_save_array_1;
7140         if (ndr_flags & NDR_SCALARS) {
7141                 NDR_CHECK(ndr_pull_align(ndr, 5));
7142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7143                 if (r->count > 10000) {
7144                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7145                 }
7146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7147                 if (_ptr_array) {
7148                         NDR_PULL_ALLOC(ndr, r->array);
7149                 } else {
7150                         r->array = NULL;
7151                 }
7152                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7153         }
7154         if (ndr_flags & NDR_BUFFERS) {
7155                 if (r->array) {
7156                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7157                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7159                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7160                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7161                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7162                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7163                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7164                         }
7165                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7166                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7167                         }
7168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7170                 }
7171                 if (r->array) {
7172                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7173                 }
7174         }
7175         return NDR_ERR_SUCCESS;
7176 }
7177
7178 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7179 {
7180         uint32_t cntr_array_1;
7181         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7182         ndr->depth++;
7183         ndr_print_uint32(ndr, "count", r->count);
7184         ndr_print_ptr(ndr, "array", r->array);
7185         ndr->depth++;
7186         if (r->array) {
7187                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7188                 ndr->depth++;
7189                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7190                         char *idx_1=NULL;
7191                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7192                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7193                                 free(idx_1);
7194                         }
7195                 }
7196                 ndr->depth--;
7197         }
7198         ndr->depth--;
7199         ndr->depth--;
7200 }
7201
7202 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7203 {
7204         if (ndr_flags & NDR_SCALARS) {
7205                 NDR_CHECK(ndr_push_align(ndr, 5));
7206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7209                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7212                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7216                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7217                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7218                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7219                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7220                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7221         }
7222         if (ndr_flags & NDR_BUFFERS) {
7223                 if (r->netbios_name) {
7224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7228                 }
7229                 if (r->dns_name) {
7230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7233                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7234                 }
7235                 if (r->site_name) {
7236                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7239                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7240                 }
7241                 if (r->site_dn) {
7242                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7245                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7246                 }
7247                 if (r->computer_dn) {
7248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, 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->computer_dn, CH_UTF16)));
7251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7252                 }
7253                 if (r->server_dn) {
7254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, 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->server_dn, CH_UTF16)));
7257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7258                 }
7259                 if (r->ntds_dn) {
7260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, 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->ntds_dn, CH_UTF16)));
7263                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7264                 }
7265         }
7266         return NDR_ERR_SUCCESS;
7267 }
7268
7269 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7270 {
7271         uint32_t _ptr_netbios_name;
7272         TALLOC_CTX *_mem_save_netbios_name_0;
7273         uint32_t _ptr_dns_name;
7274         TALLOC_CTX *_mem_save_dns_name_0;
7275         uint32_t _ptr_site_name;
7276         TALLOC_CTX *_mem_save_site_name_0;
7277         uint32_t _ptr_site_dn;
7278         TALLOC_CTX *_mem_save_site_dn_0;
7279         uint32_t _ptr_computer_dn;
7280         TALLOC_CTX *_mem_save_computer_dn_0;
7281         uint32_t _ptr_server_dn;
7282         TALLOC_CTX *_mem_save_server_dn_0;
7283         uint32_t _ptr_ntds_dn;
7284         TALLOC_CTX *_mem_save_ntds_dn_0;
7285         if (ndr_flags & NDR_SCALARS) {
7286                 NDR_CHECK(ndr_pull_align(ndr, 5));
7287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7288                 if (_ptr_netbios_name) {
7289                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7290                 } else {
7291                         r->netbios_name = NULL;
7292                 }
7293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7294                 if (_ptr_dns_name) {
7295                         NDR_PULL_ALLOC(ndr, r->dns_name);
7296                 } else {
7297                         r->dns_name = NULL;
7298                 }
7299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7300                 if (_ptr_site_name) {
7301                         NDR_PULL_ALLOC(ndr, r->site_name);
7302                 } else {
7303                         r->site_name = NULL;
7304                 }
7305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7306                 if (_ptr_site_dn) {
7307                         NDR_PULL_ALLOC(ndr, r->site_dn);
7308                 } else {
7309                         r->site_dn = NULL;
7310                 }
7311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7312                 if (_ptr_computer_dn) {
7313                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7314                 } else {
7315                         r->computer_dn = NULL;
7316                 }
7317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7318                 if (_ptr_server_dn) {
7319                         NDR_PULL_ALLOC(ndr, r->server_dn);
7320                 } else {
7321                         r->server_dn = NULL;
7322                 }
7323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7324                 if (_ptr_ntds_dn) {
7325                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7326                 } else {
7327                         r->ntds_dn = NULL;
7328                 }
7329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7332                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7333                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7334                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7335                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7336                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7337         }
7338         if (ndr_flags & NDR_BUFFERS) {
7339                 if (r->netbios_name) {
7340                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7341                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7342                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7343                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7344                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7345                                 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));
7346                         }
7347                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7348                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7349                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7350                 }
7351                 if (r->dns_name) {
7352                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7353                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7356                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7357                                 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));
7358                         }
7359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7360                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7362                 }
7363                 if (r->site_name) {
7364                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7365                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7368                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_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->site_name), ndr_get_array_length(ndr, &r->site_name));
7370                         }
7371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7374                 }
7375                 if (r->site_dn) {
7376                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7377                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7380                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
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->site_dn), ndr_get_array_length(ndr, &r->site_dn));
7382                         }
7383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7386                 }
7387                 if (r->computer_dn) {
7388                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7389                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7392                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
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->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7394                         }
7395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7398                 }
7399                 if (r->server_dn) {
7400                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7401                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7404                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_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->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7406                         }
7407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7410                 }
7411                 if (r->ntds_dn) {
7412                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7413                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7416                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_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->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
7418                         }
7419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7422                 }
7423         }
7424         return NDR_ERR_SUCCESS;
7425 }
7426
7427 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7428 {
7429         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7430         ndr->depth++;
7431         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7432         ndr->depth++;
7433         if (r->netbios_name) {
7434                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7435         }
7436         ndr->depth--;
7437         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7438         ndr->depth++;
7439         if (r->dns_name) {
7440                 ndr_print_string(ndr, "dns_name", r->dns_name);
7441         }
7442         ndr->depth--;
7443         ndr_print_ptr(ndr, "site_name", r->site_name);
7444         ndr->depth++;
7445         if (r->site_name) {
7446                 ndr_print_string(ndr, "site_name", r->site_name);
7447         }
7448         ndr->depth--;
7449         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7450         ndr->depth++;
7451         if (r->site_dn) {
7452                 ndr_print_string(ndr, "site_dn", r->site_dn);
7453         }
7454         ndr->depth--;
7455         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7456         ndr->depth++;
7457         if (r->computer_dn) {
7458                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7459         }
7460         ndr->depth--;
7461         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7462         ndr->depth++;
7463         if (r->server_dn) {
7464                 ndr_print_string(ndr, "server_dn", r->server_dn);
7465         }
7466         ndr->depth--;
7467         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7468         ndr->depth++;
7469         if (r->ntds_dn) {
7470                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7471         }
7472         ndr->depth--;
7473         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7474         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7475         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7476         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7477         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7478         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7479         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7480         ndr->depth--;
7481 }
7482
7483 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7484 {
7485         uint32_t cntr_array_1;
7486         if (ndr_flags & NDR_SCALARS) {
7487                 NDR_CHECK(ndr_push_align(ndr, 5));
7488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7490                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7491         }
7492         if (ndr_flags & NDR_BUFFERS) {
7493                 if (r->array) {
7494                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7495                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7496                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7497                         }
7498                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7499                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7500                         }
7501                 }
7502         }
7503         return NDR_ERR_SUCCESS;
7504 }
7505
7506 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7507 {
7508         uint32_t _ptr_array;
7509         uint32_t cntr_array_1;
7510         TALLOC_CTX *_mem_save_array_0;
7511         TALLOC_CTX *_mem_save_array_1;
7512         if (ndr_flags & NDR_SCALARS) {
7513                 NDR_CHECK(ndr_pull_align(ndr, 5));
7514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7515                 if (r->count > 10000) {
7516                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7517                 }
7518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7519                 if (_ptr_array) {
7520                         NDR_PULL_ALLOC(ndr, r->array);
7521                 } else {
7522                         r->array = NULL;
7523                 }
7524                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7525         }
7526         if (ndr_flags & NDR_BUFFERS) {
7527                 if (r->array) {
7528                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7529                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7531                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7532                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7533                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7534                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7535                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7536                         }
7537                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7538                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7539                         }
7540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7541                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7542                 }
7543                 if (r->array) {
7544                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7545                 }
7546         }
7547         return NDR_ERR_SUCCESS;
7548 }
7549
7550 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7551 {
7552         uint32_t cntr_array_1;
7553         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7554         ndr->depth++;
7555         ndr_print_uint32(ndr, "count", r->count);
7556         ndr_print_ptr(ndr, "array", r->array);
7557         ndr->depth++;
7558         if (r->array) {
7559                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7560                 ndr->depth++;
7561                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7562                         char *idx_1=NULL;
7563                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7564                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7565                                 free(idx_1);
7566                         }
7567                 }
7568                 ndr->depth--;
7569         }
7570         ndr->depth--;
7571         ndr->depth--;
7572 }
7573
7574 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7575 {
7576         if (ndr_flags & NDR_SCALARS) {
7577                 NDR_CHECK(ndr_push_align(ndr, 5));
7578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7581                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7583                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7589                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7590                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7591                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7592                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7593                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7594         }
7595         if (ndr_flags & NDR_BUFFERS) {
7596                 if (r->netbios_name) {
7597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7599                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7600                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7601                 }
7602                 if (r->dns_name) {
7603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7606                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7607                 }
7608                 if (r->site_name) {
7609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7613                 }
7614                 if (r->site_dn) {
7615                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7618                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7619                 }
7620                 if (r->computer_dn) {
7621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, 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->computer_dn, CH_UTF16)));
7624                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7625                 }
7626                 if (r->server_dn) {
7627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, 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->server_dn, CH_UTF16)));
7630                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7631                 }
7632                 if (r->ntds_dn) {
7633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, 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->ntds_dn, CH_UTF16)));
7636                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7637                 }
7638         }
7639         return NDR_ERR_SUCCESS;
7640 }
7641
7642 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7643 {
7644         uint32_t _ptr_netbios_name;
7645         TALLOC_CTX *_mem_save_netbios_name_0;
7646         uint32_t _ptr_dns_name;
7647         TALLOC_CTX *_mem_save_dns_name_0;
7648         uint32_t _ptr_site_name;
7649         TALLOC_CTX *_mem_save_site_name_0;
7650         uint32_t _ptr_site_dn;
7651         TALLOC_CTX *_mem_save_site_dn_0;
7652         uint32_t _ptr_computer_dn;
7653         TALLOC_CTX *_mem_save_computer_dn_0;
7654         uint32_t _ptr_server_dn;
7655         TALLOC_CTX *_mem_save_server_dn_0;
7656         uint32_t _ptr_ntds_dn;
7657         TALLOC_CTX *_mem_save_ntds_dn_0;
7658         if (ndr_flags & NDR_SCALARS) {
7659                 NDR_CHECK(ndr_pull_align(ndr, 5));
7660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7661                 if (_ptr_netbios_name) {
7662                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7663                 } else {
7664                         r->netbios_name = NULL;
7665                 }
7666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7667                 if (_ptr_dns_name) {
7668                         NDR_PULL_ALLOC(ndr, r->dns_name);
7669                 } else {
7670                         r->dns_name = NULL;
7671                 }
7672                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7673                 if (_ptr_site_name) {
7674                         NDR_PULL_ALLOC(ndr, r->site_name);
7675                 } else {
7676                         r->site_name = NULL;
7677                 }
7678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7679                 if (_ptr_site_dn) {
7680                         NDR_PULL_ALLOC(ndr, r->site_dn);
7681                 } else {
7682                         r->site_dn = NULL;
7683                 }
7684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7685                 if (_ptr_computer_dn) {
7686                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7687                 } else {
7688                         r->computer_dn = NULL;
7689                 }
7690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7691                 if (_ptr_server_dn) {
7692                         NDR_PULL_ALLOC(ndr, r->server_dn);
7693                 } else {
7694                         r->server_dn = NULL;
7695                 }
7696                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7697                 if (_ptr_ntds_dn) {
7698                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7699                 } else {
7700                         r->ntds_dn = NULL;
7701                 }
7702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7706                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7707                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7708                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7709                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7710                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7711         }
7712         if (ndr_flags & NDR_BUFFERS) {
7713                 if (r->netbios_name) {
7714                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7715                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7718                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7719                                 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));
7720                         }
7721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7724                 }
7725                 if (r->dns_name) {
7726                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7727                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7730                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7731                                 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));
7732                         }
7733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7736                 }
7737                 if (r->site_name) {
7738                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7739                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7742                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_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->site_name), ndr_get_array_length(ndr, &r->site_name));
7744                         }
7745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7748                 }
7749                 if (r->site_dn) {
7750                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7751                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7754                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
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->site_dn), ndr_get_array_length(ndr, &r->site_dn));
7756                         }
7757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7760                 }
7761                 if (r->computer_dn) {
7762                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7763                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7765                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7766                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
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->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7768                         }
7769                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7770                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7772                 }
7773                 if (r->server_dn) {
7774                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7775                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7776                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7777                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7778                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_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->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7780                         }
7781                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7782                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7784                 }
7785                 if (r->ntds_dn) {
7786                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7787                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7788                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7789                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7790                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_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->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
7792                         }
7793                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7794                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7796                 }
7797         }
7798         return NDR_ERR_SUCCESS;
7799 }
7800
7801 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7802 {
7803         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7804         ndr->depth++;
7805         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7806         ndr->depth++;
7807         if (r->netbios_name) {
7808                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7809         }
7810         ndr->depth--;
7811         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7812         ndr->depth++;
7813         if (r->dns_name) {
7814                 ndr_print_string(ndr, "dns_name", r->dns_name);
7815         }
7816         ndr->depth--;
7817         ndr_print_ptr(ndr, "site_name", r->site_name);
7818         ndr->depth++;
7819         if (r->site_name) {
7820                 ndr_print_string(ndr, "site_name", r->site_name);
7821         }
7822         ndr->depth--;
7823         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7824         ndr->depth++;
7825         if (r->site_dn) {
7826                 ndr_print_string(ndr, "site_dn", r->site_dn);
7827         }
7828         ndr->depth--;
7829         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7830         ndr->depth++;
7831         if (r->computer_dn) {
7832                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7833         }
7834         ndr->depth--;
7835         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7836         ndr->depth++;
7837         if (r->server_dn) {
7838                 ndr_print_string(ndr, "server_dn", r->server_dn);
7839         }
7840         ndr->depth--;
7841         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7842         ndr->depth++;
7843         if (r->ntds_dn) {
7844                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7845         }
7846         ndr->depth--;
7847         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7848         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7849         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7850         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7851         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7852         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7853         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7854         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7855         ndr->depth--;
7856 }
7857
7858 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7859 {
7860         uint32_t cntr_array_1;
7861         if (ndr_flags & NDR_SCALARS) {
7862                 NDR_CHECK(ndr_push_align(ndr, 5));
7863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7865                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7866         }
7867         if (ndr_flags & NDR_BUFFERS) {
7868                 if (r->array) {
7869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7870                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7871                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7872                         }
7873                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7874                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7875                         }
7876                 }
7877         }
7878         return NDR_ERR_SUCCESS;
7879 }
7880
7881 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7882 {
7883         uint32_t _ptr_array;
7884         uint32_t cntr_array_1;
7885         TALLOC_CTX *_mem_save_array_0;
7886         TALLOC_CTX *_mem_save_array_1;
7887         if (ndr_flags & NDR_SCALARS) {
7888                 NDR_CHECK(ndr_pull_align(ndr, 5));
7889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7890                 if (r->count > 10000) {
7891                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7892                 }
7893                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7894                 if (_ptr_array) {
7895                         NDR_PULL_ALLOC(ndr, r->array);
7896                 } else {
7897                         r->array = NULL;
7898                 }
7899                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7900         }
7901         if (ndr_flags & NDR_BUFFERS) {
7902                 if (r->array) {
7903                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7904                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7905                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7906                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7907                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7908                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7909                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7910                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7911                         }
7912                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7913                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7914                         }
7915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7917                 }
7918                 if (r->array) {
7919                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7920                 }
7921         }
7922         return NDR_ERR_SUCCESS;
7923 }
7924
7925 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7926 {
7927         uint32_t cntr_array_1;
7928         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7929         ndr->depth++;
7930         ndr_print_uint32(ndr, "count", r->count);
7931         ndr_print_ptr(ndr, "array", r->array);
7932         ndr->depth++;
7933         if (r->array) {
7934                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7935                 ndr->depth++;
7936                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7937                         char *idx_1=NULL;
7938                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7939                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7940                                 free(idx_1);
7941                         }
7942                 }
7943                 ndr->depth--;
7944         }
7945         ndr->depth--;
7946         ndr->depth--;
7947 }
7948
7949 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7950 {
7951         if (ndr_flags & NDR_SCALARS) {
7952                 NDR_CHECK(ndr_push_align(ndr, 5));
7953                 {
7954                         uint32_t _flags_save_ipv4address = ndr->flags;
7955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7956                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7957                         ndr->flags = _flags_save_ipv4address;
7958                 }
7959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7965                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7966         }
7967         if (ndr_flags & NDR_BUFFERS) {
7968                 if (r->client_account) {
7969                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7973                 }
7974         }
7975         return NDR_ERR_SUCCESS;
7976 }
7977
7978 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
7979 {
7980         uint32_t _ptr_client_account;
7981         TALLOC_CTX *_mem_save_client_account_0;
7982         if (ndr_flags & NDR_SCALARS) {
7983                 NDR_CHECK(ndr_pull_align(ndr, 5));
7984                 {
7985                         uint32_t _flags_save_ipv4address = ndr->flags;
7986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7987                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
7988                         ndr->flags = _flags_save_ipv4address;
7989                 }
7990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
7992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
7993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
7994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
7995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
7996                 if (_ptr_client_account) {
7997                         NDR_PULL_ALLOC(ndr, r->client_account);
7998                 } else {
7999                         r->client_account = NULL;
8000                 }
8001                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8002         }
8003         if (ndr_flags & NDR_BUFFERS) {
8004                 if (r->client_account) {
8005                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8006                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8009                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8010                                 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));
8011                         }
8012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8015                 }
8016         }
8017         return NDR_ERR_SUCCESS;
8018 }
8019
8020 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8021 {
8022         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8023         ndr->depth++;
8024         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8025         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8026         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8027         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8028         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8029         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8030         ndr_print_ptr(ndr, "client_account", r->client_account);
8031         ndr->depth++;
8032         if (r->client_account) {
8033                 ndr_print_string(ndr, "client_account", r->client_account);
8034         }
8035         ndr->depth--;
8036         ndr->depth--;
8037 }
8038
8039 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8040 {
8041         uint32_t cntr_array_1;
8042         if (ndr_flags & NDR_SCALARS) {
8043                 NDR_CHECK(ndr_push_align(ndr, 5));
8044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8046                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8047         }
8048         if (ndr_flags & NDR_BUFFERS) {
8049                 if (r->array) {
8050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8051                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8052                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8053                         }
8054                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8055                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8056                         }
8057                 }
8058         }
8059         return NDR_ERR_SUCCESS;
8060 }
8061
8062 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8063 {
8064         uint32_t _ptr_array;
8065         uint32_t cntr_array_1;
8066         TALLOC_CTX *_mem_save_array_0;
8067         TALLOC_CTX *_mem_save_array_1;
8068         if (ndr_flags & NDR_SCALARS) {
8069                 NDR_CHECK(ndr_pull_align(ndr, 5));
8070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8071                 if (r->count > 10000) {
8072                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8073                 }
8074                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8075                 if (_ptr_array) {
8076                         NDR_PULL_ALLOC(ndr, r->array);
8077                 } else {
8078                         r->array = NULL;
8079                 }
8080                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8081         }
8082         if (ndr_flags & NDR_BUFFERS) {
8083                 if (r->array) {
8084                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8085                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8087                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8088                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8089                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8090                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8091                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8092                         }
8093                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8094                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8095                         }
8096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8098                 }
8099                 if (r->array) {
8100                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8101                 }
8102         }
8103         return NDR_ERR_SUCCESS;
8104 }
8105
8106 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8107 {
8108         uint32_t cntr_array_1;
8109         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8110         ndr->depth++;
8111         ndr_print_uint32(ndr, "count", r->count);
8112         ndr_print_ptr(ndr, "array", r->array);
8113         ndr->depth++;
8114         if (r->array) {
8115                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8116                 ndr->depth++;
8117                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8118                         char *idx_1=NULL;
8119                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8120                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8121                                 free(idx_1);
8122                         }
8123                 }
8124                 ndr->depth--;
8125         }
8126         ndr->depth--;
8127         ndr->depth--;
8128 }
8129
8130 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8131 {
8132         if (ndr_flags & NDR_SCALARS) {
8133                 int level = ndr_push_get_switch_value(ndr, r);
8134                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8135                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8136                 switch (level) {
8137                         case DRSUAPI_DC_INFO_CTR_1: {
8138                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8139                         break; }
8140
8141                         case DRSUAPI_DC_INFO_CTR_2: {
8142                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8143                         break; }
8144
8145                         case DRSUAPI_DC_INFO_CTR_3: {
8146                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8147                         break; }
8148
8149                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8150                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8151                         break; }
8152
8153                         default:
8154                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8155                 }
8156         }
8157         if (ndr_flags & NDR_BUFFERS) {
8158                 int level = ndr_push_get_switch_value(ndr, r);
8159                 switch (level) {
8160                         case DRSUAPI_DC_INFO_CTR_1:
8161                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8162                         break;
8163
8164                         case DRSUAPI_DC_INFO_CTR_2:
8165                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8166                         break;
8167
8168                         case DRSUAPI_DC_INFO_CTR_3:
8169                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8170                         break;
8171
8172                         case DRSUAPI_DC_CONNECTION_CTR_01:
8173                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8174                         break;
8175
8176                         default:
8177                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8178                 }
8179         }
8180         return NDR_ERR_SUCCESS;
8181 }
8182
8183 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8184 {
8185         int level;
8186         int32_t _level;
8187         level = ndr_pull_get_switch_value(ndr, r);
8188         if (ndr_flags & NDR_SCALARS) {
8189                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8190                 if (_level != level) {
8191                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8192                 }
8193                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8194                 switch (level) {
8195                         case DRSUAPI_DC_INFO_CTR_1: {
8196                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8197                         break; }
8198
8199                         case DRSUAPI_DC_INFO_CTR_2: {
8200                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8201                         break; }
8202
8203                         case DRSUAPI_DC_INFO_CTR_3: {
8204                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8205                         break; }
8206
8207                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8208                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8209                         break; }
8210
8211                         default:
8212                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8213                 }
8214         }
8215         if (ndr_flags & NDR_BUFFERS) {
8216                 switch (level) {
8217                         case DRSUAPI_DC_INFO_CTR_1:
8218                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8219                         break;
8220
8221                         case DRSUAPI_DC_INFO_CTR_2:
8222                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8223                         break;
8224
8225                         case DRSUAPI_DC_INFO_CTR_3:
8226                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8227                         break;
8228
8229                         case DRSUAPI_DC_CONNECTION_CTR_01:
8230                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8231                         break;
8232
8233                         default:
8234                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8235                 }
8236         }
8237         return NDR_ERR_SUCCESS;
8238 }
8239
8240 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8241 {
8242         int level;
8243         level = ndr_print_get_switch_value(ndr, r);
8244         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8245         switch (level) {
8246                 case DRSUAPI_DC_INFO_CTR_1:
8247                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8248                 break;
8249
8250                 case DRSUAPI_DC_INFO_CTR_2:
8251                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8252                 break;
8253
8254                 case DRSUAPI_DC_INFO_CTR_3:
8255                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8256                 break;
8257
8258                 case DRSUAPI_DC_CONNECTION_CTR_01:
8259                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8260                 break;
8261
8262                 default:
8263                         ndr_print_bad_level(ndr, name, level);
8264         }
8265 }
8266
8267 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8268 {
8269         if (ndr_flags & NDR_SCALARS) {
8270                 NDR_CHECK(ndr_push_align(ndr, 5));
8271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8272                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8273                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8274         }
8275         if (ndr_flags & NDR_BUFFERS) {
8276                 if (r->next_object) {
8277                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8278                 }
8279                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8280         }
8281         return NDR_ERR_SUCCESS;
8282 }
8283
8284 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8285 {
8286         uint32_t _ptr_next_object;
8287         TALLOC_CTX *_mem_save_next_object_0;
8288         if (ndr_flags & NDR_SCALARS) {
8289                 NDR_CHECK(ndr_pull_align(ndr, 5));
8290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8291                 if (_ptr_next_object) {
8292                         NDR_PULL_ALLOC(ndr, r->next_object);
8293                 } else {
8294                         r->next_object = NULL;
8295                 }
8296                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8297                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8298         }
8299         if (ndr_flags & NDR_BUFFERS) {
8300                 if (r->next_object) {
8301                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8302                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8303                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8304                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8305                 }
8306                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8307         }
8308         return NDR_ERR_SUCCESS;
8309 }
8310
8311 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8312 {
8313         if (ndr_flags & NDR_SCALARS) {
8314                 NDR_CHECK(ndr_push_align(ndr, 5));
8315                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8316                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8317         }
8318         if (ndr_flags & NDR_BUFFERS) {
8319                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8320         }
8321         return NDR_ERR_SUCCESS;
8322 }
8323
8324 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8325 {
8326         if (ndr_flags & NDR_SCALARS) {
8327                 NDR_CHECK(ndr_pull_align(ndr, 5));
8328                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8329                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8330         }
8331         if (ndr_flags & NDR_BUFFERS) {
8332                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8333         }
8334         return NDR_ERR_SUCCESS;
8335 }
8336
8337 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8338 {
8339         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8340         ndr->depth++;
8341         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8342         ndr->depth--;
8343 }
8344
8345 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8346 {
8347         if (ndr_flags & NDR_SCALARS) {
8348                 int level = ndr_push_get_switch_value(ndr, r);
8349                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8350                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8351                 switch (level) {
8352                         case 2: {
8353                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8354                         break; }
8355
8356                         default:
8357                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8358                 }
8359         }
8360         if (ndr_flags & NDR_BUFFERS) {
8361                 int level = ndr_push_get_switch_value(ndr, r);
8362                 switch (level) {
8363                         case 2:
8364                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8365                         break;
8366
8367                         default:
8368                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8369                 }
8370         }
8371         return NDR_ERR_SUCCESS;
8372 }
8373
8374 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8375 {
8376         int level;
8377         int32_t _level;
8378         level = ndr_pull_get_switch_value(ndr, r);
8379         if (ndr_flags & NDR_SCALARS) {
8380                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8381                 if (_level != level) {
8382                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8383                 }
8384                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8385                 switch (level) {
8386                         case 2: {
8387                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8388                         break; }
8389
8390                         default:
8391                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8392                 }
8393         }
8394         if (ndr_flags & NDR_BUFFERS) {
8395                 switch (level) {
8396                         case 2:
8397                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8398                         break;
8399
8400                         default:
8401                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8402                 }
8403         }
8404         return NDR_ERR_SUCCESS;
8405 }
8406
8407 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8408 {
8409         int level;
8410         level = ndr_print_get_switch_value(ndr, r);
8411         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8412         switch (level) {
8413                 case 2:
8414                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8415                 break;
8416
8417                 default:
8418                         ndr_print_bad_level(ndr, name, level);
8419         }
8420 }
8421
8422 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8423 {
8424         if (ndr_flags & NDR_SCALARS) {
8425                 NDR_CHECK(ndr_push_align(ndr, 4));
8426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8429                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8430                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8431         }
8432         if (ndr_flags & NDR_BUFFERS) {
8433         }
8434         return NDR_ERR_SUCCESS;
8435 }
8436
8437 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8438 {
8439         if (ndr_flags & NDR_SCALARS) {
8440                 NDR_CHECK(ndr_pull_align(ndr, 4));
8441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8442                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8444                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8445                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8446         }
8447         if (ndr_flags & NDR_BUFFERS) {
8448         }
8449         return NDR_ERR_SUCCESS;
8450 }
8451
8452 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8453 {
8454         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8455         ndr->depth++;
8456         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8457         ndr_print_WERROR(ndr, "status", r->status);
8458         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8459         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8460         ndr->depth--;
8461 }
8462
8463 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8464 {
8465         if (ndr_flags & NDR_SCALARS) {
8466                 NDR_CHECK(ndr_push_align(ndr, 5));
8467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8468                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8469                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8470         }
8471         if (ndr_flags & NDR_BUFFERS) {
8472                 if (r->data) {
8473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8474                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8475                 }
8476         }
8477         return NDR_ERR_SUCCESS;
8478 }
8479
8480 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8481 {
8482         uint32_t _ptr_data;
8483         TALLOC_CTX *_mem_save_data_0;
8484         if (ndr_flags & NDR_SCALARS) {
8485                 NDR_CHECK(ndr_pull_align(ndr, 5));
8486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8487                 if (r->size > 10485760) {
8488                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8489                 }
8490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8491                 if (_ptr_data) {
8492                         NDR_PULL_ALLOC(ndr, r->data);
8493                 } else {
8494                         r->data = NULL;
8495                 }
8496                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8497         }
8498         if (ndr_flags & NDR_BUFFERS) {
8499                 if (r->data) {
8500                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8501                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8503                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8504                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8506                 }
8507                 if (r->data) {
8508                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8509                 }
8510         }
8511         return NDR_ERR_SUCCESS;
8512 }
8513
8514 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8515 {
8516         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8517         ndr->depth++;
8518         ndr_print_uint32(ndr, "size", r->size);
8519         ndr_print_ptr(ndr, "data", r->data);
8520         ndr->depth++;
8521         if (r->data) {
8522                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8523         }
8524         ndr->depth--;
8525         ndr->depth--;
8526 }
8527
8528 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8529 {
8530         if (ndr_flags & NDR_SCALARS) {
8531                 NDR_CHECK(ndr_push_align(ndr, 5));
8532                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8533                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8535                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8536                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8537         }
8538         if (ndr_flags & NDR_BUFFERS) {
8539                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8540         }
8541         return NDR_ERR_SUCCESS;
8542 }
8543
8544 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8545 {
8546         if (ndr_flags & NDR_SCALARS) {
8547                 NDR_CHECK(ndr_pull_align(ndr, 5));
8548                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8549                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8551                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8552                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8553         }
8554         if (ndr_flags & NDR_BUFFERS) {
8555                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8556         }
8557         return NDR_ERR_SUCCESS;
8558 }
8559
8560 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8561 {
8562         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8563         ndr->depth++;
8564         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8565         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8566         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8567         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8568         ndr->depth--;
8569 }
8570
8571 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8572 {
8573         if (ndr_flags & NDR_SCALARS) {
8574                 NDR_CHECK(ndr_push_align(ndr, 5));
8575                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8576                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8577                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8578         }
8579         if (ndr_flags & NDR_BUFFERS) {
8580                 if (r->next) {
8581                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8582                 }
8583                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8584         }
8585         return NDR_ERR_SUCCESS;
8586 }
8587
8588 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8589 {
8590         uint32_t _ptr_next;
8591         TALLOC_CTX *_mem_save_next_0;
8592         if (ndr_flags & NDR_SCALARS) {
8593                 NDR_CHECK(ndr_pull_align(ndr, 5));
8594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8595                 if (_ptr_next) {
8596                         NDR_PULL_ALLOC(ndr, r->next);
8597                 } else {
8598                         r->next = NULL;
8599                 }
8600                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8601                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8602         }
8603         if (ndr_flags & NDR_BUFFERS) {
8604                 if (r->next) {
8605                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8606                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8607                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8609                 }
8610                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8611         }
8612         return NDR_ERR_SUCCESS;
8613 }
8614
8615 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8616 {
8617         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8618         ndr->depth++;
8619         ndr_print_ptr(ndr, "next", r->next);
8620         ndr->depth++;
8621         if (r->next) {
8622                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8623         }
8624         ndr->depth--;
8625         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8626         ndr->depth--;
8627 }
8628
8629 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8630 {
8631         if (ndr_flags & NDR_SCALARS) {
8632                 NDR_CHECK(ndr_push_align(ndr, 5));
8633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8635                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8636                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8637         }
8638         if (ndr_flags & NDR_BUFFERS) {
8639                 if (r->id) {
8640                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8641                 }
8642                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8643         }
8644         return NDR_ERR_SUCCESS;
8645 }
8646
8647 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8648 {
8649         uint32_t _ptr_id;
8650         TALLOC_CTX *_mem_save_id_0;
8651         if (ndr_flags & NDR_SCALARS) {
8652                 NDR_CHECK(ndr_pull_align(ndr, 5));
8653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8654                 if (_ptr_id) {
8655                         NDR_PULL_ALLOC(ndr, r->id);
8656                 } else {
8657                         r->id = NULL;
8658                 }
8659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8660                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8661                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8662         }
8663         if (ndr_flags & NDR_BUFFERS) {
8664                 if (r->id) {
8665                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8666                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8667                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8669                 }
8670                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8671         }
8672         return NDR_ERR_SUCCESS;
8673 }
8674
8675 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8676 {
8677         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8678         ndr->depth++;
8679         ndr_print_ptr(ndr, "id", r->id);
8680         ndr->depth++;
8681         if (r->id) {
8682                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8683         }
8684         ndr->depth--;
8685         ndr_print_WERROR(ndr, "status", r->status);
8686         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8687         ndr->depth--;
8688 }
8689
8690 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8691 {
8692         if (ndr_flags & NDR_SCALARS) {
8693                 int level = ndr_push_get_switch_value(ndr, r);
8694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8695                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8696                 switch (level) {
8697                         case 1: {
8698                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8699                         break; }
8700
8701                         case 4: {
8702                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8703                         break; }
8704
8705                         case 5: {
8706                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8707                         break; }
8708
8709                         case 6: {
8710                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8711                         break; }
8712
8713                         case 7: {
8714                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8715                         break; }
8716
8717                         default:
8718                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8719                 }
8720         }
8721         if (ndr_flags & NDR_BUFFERS) {
8722                 int level = ndr_push_get_switch_value(ndr, r);
8723                 switch (level) {
8724                         case 1:
8725                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8726                         break;
8727
8728                         case 4:
8729                         break;
8730
8731                         case 5:
8732                         break;
8733
8734                         case 6:
8735                         break;
8736
8737                         case 7:
8738                         break;
8739
8740                         default:
8741                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8742                 }
8743         }
8744         return NDR_ERR_SUCCESS;
8745 }
8746
8747 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8748 {
8749         int level;
8750         uint32_t _level;
8751         level = ndr_pull_get_switch_value(ndr, r);
8752         if (ndr_flags & NDR_SCALARS) {
8753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8754                 if (_level != level) {
8755                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8756                 }
8757                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8758                 switch (level) {
8759                         case 1: {
8760                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8761                         break; }
8762
8763                         case 4: {
8764                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8765                         break; }
8766
8767                         case 5: {
8768                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8769                         break; }
8770
8771                         case 6: {
8772                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8773                         break; }
8774
8775                         case 7: {
8776                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8777                         break; }
8778
8779                         default:
8780                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8781                 }
8782         }
8783         if (ndr_flags & NDR_BUFFERS) {
8784                 switch (level) {
8785                         case 1:
8786                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8787                         break;
8788
8789                         case 4:
8790                         break;
8791
8792                         case 5:
8793                         break;
8794
8795                         case 6:
8796                         break;
8797
8798                         case 7:
8799                         break;
8800
8801                         default:
8802                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8803                 }
8804         }
8805         return NDR_ERR_SUCCESS;
8806 }
8807
8808 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8809 {
8810         int level;
8811         level = ndr_print_get_switch_value(ndr, r);
8812         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8813         switch (level) {
8814                 case 1:
8815                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8816                 break;
8817
8818                 case 4:
8819                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8820                 break;
8821
8822                 case 5:
8823                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8824                 break;
8825
8826                 case 6:
8827                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8828                 break;
8829
8830                 case 7:
8831                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8832                 break;
8833
8834                 default:
8835                         ndr_print_bad_level(ndr, name, level);
8836         }
8837 }
8838
8839 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8840 {
8841         if (ndr_flags & NDR_SCALARS) {
8842                 NDR_CHECK(ndr_push_align(ndr, 5));
8843                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8846                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8847         }
8848         if (ndr_flags & NDR_BUFFERS) {
8849                 if (r->info) {
8850                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8851                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8852                 }
8853         }
8854         return NDR_ERR_SUCCESS;
8855 }
8856
8857 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8858 {
8859         uint32_t _ptr_info;
8860         TALLOC_CTX *_mem_save_info_0;
8861         if (ndr_flags & NDR_SCALARS) {
8862                 NDR_CHECK(ndr_pull_align(ndr, 5));
8863                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8866                 if (_ptr_info) {
8867                         NDR_PULL_ALLOC(ndr, r->info);
8868                 } else {
8869                         r->info = NULL;
8870                 }
8871                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8872         }
8873         if (ndr_flags & NDR_BUFFERS) {
8874                 if (r->info) {
8875                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8876                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8877                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8878                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8879                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8880                 }
8881         }
8882         return NDR_ERR_SUCCESS;
8883 }
8884
8885 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8886 {
8887         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8888         ndr->depth++;
8889         ndr_print_WERROR(ndr, "status", r->status);
8890         ndr_print_uint32(ndr, "level", r->level);
8891         ndr_print_ptr(ndr, "info", r->info);
8892         ndr->depth++;
8893         if (r->info) {
8894                 ndr_print_set_switch_value(ndr, r->info, r->level);
8895                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8896         }
8897         ndr->depth--;
8898         ndr->depth--;
8899 }
8900
8901 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8902 {
8903         if (ndr_flags & NDR_SCALARS) {
8904                 int level = ndr_push_get_switch_value(ndr, r);
8905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8906                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8907                 switch (level) {
8908                         case 1: {
8909                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8910                         break; }
8911
8912                         default:
8913                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8914                 }
8915         }
8916         if (ndr_flags & NDR_BUFFERS) {
8917                 int level = ndr_push_get_switch_value(ndr, r);
8918                 switch (level) {
8919                         case 1:
8920                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8921                         break;
8922
8923                         default:
8924                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8925                 }
8926         }
8927         return NDR_ERR_SUCCESS;
8928 }
8929
8930 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8931 {
8932         int level;
8933         uint32_t _level;
8934         level = ndr_pull_get_switch_value(ndr, r);
8935         if (ndr_flags & NDR_SCALARS) {
8936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8937                 if (_level != level) {
8938                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8939                 }
8940                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8941                 switch (level) {
8942                         case 1: {
8943                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8944                         break; }
8945
8946                         default:
8947                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8948                 }
8949         }
8950         if (ndr_flags & NDR_BUFFERS) {
8951                 switch (level) {
8952                         case 1:
8953                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8954                         break;
8955
8956                         default:
8957                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8958                 }
8959         }
8960         return NDR_ERR_SUCCESS;
8961 }
8962
8963 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8964 {
8965         int level;
8966         level = ndr_print_get_switch_value(ndr, r);
8967         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8968         switch (level) {
8969                 case 1:
8970                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8971                 break;
8972
8973                 default:
8974                         ndr_print_bad_level(ndr, name, level);
8975         }
8976 }
8977
8978 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8979 {
8980         if (ndr_flags & NDR_SCALARS) {
8981                 NDR_CHECK(ndr_push_align(ndr, 4));
8982                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
8983                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8984                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8985         }
8986         if (ndr_flags & NDR_BUFFERS) {
8987                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8988         }
8989         return NDR_ERR_SUCCESS;
8990 }
8991
8992 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
8993 {
8994         if (ndr_flags & NDR_SCALARS) {
8995                 NDR_CHECK(ndr_pull_align(ndr, 4));
8996                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
8997                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8998                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8999         }
9000         if (ndr_flags & NDR_BUFFERS) {
9001                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9002         }
9003         return NDR_ERR_SUCCESS;
9004 }
9005
9006 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9007 {
9008         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9009         ndr->depth++;
9010         ndr_print_GUID(ndr, "guid", &r->guid);
9011         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9012         ndr->depth--;
9013 }
9014
9015 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9016 {
9017         uint32_t cntr_objects_1;
9018         if (ndr_flags & NDR_SCALARS) {
9019                 NDR_CHECK(ndr_push_align(ndr, 5));
9020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9022                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9025                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9026         }
9027         if (ndr_flags & NDR_BUFFERS) {
9028                 if (r->id) {
9029                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9030                 }
9031                 if (r->objects) {
9032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9033                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9034                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9035                         }
9036                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9037                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9038                         }
9039                 }
9040         }
9041         return NDR_ERR_SUCCESS;
9042 }
9043
9044 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9045 {
9046         uint32_t _ptr_id;
9047         TALLOC_CTX *_mem_save_id_0;
9048         uint32_t _ptr_objects;
9049         uint32_t cntr_objects_1;
9050         TALLOC_CTX *_mem_save_objects_0;
9051         TALLOC_CTX *_mem_save_objects_1;
9052         if (ndr_flags & NDR_SCALARS) {
9053                 NDR_CHECK(ndr_pull_align(ndr, 5));
9054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9055                 if (_ptr_id) {
9056                         NDR_PULL_ALLOC(ndr, r->id);
9057                 } else {
9058                         r->id = NULL;
9059                 }
9060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9061                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9063                 if (r->count > 10000) {
9064                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9065                 }
9066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9067                 if (_ptr_objects) {
9068                         NDR_PULL_ALLOC(ndr, r->objects);
9069                 } else {
9070                         r->objects = NULL;
9071                 }
9072                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9073         }
9074         if (ndr_flags & NDR_BUFFERS) {
9075                 if (r->id) {
9076                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9077                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9078                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9080                 }
9081                 if (r->objects) {
9082                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9083                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9085                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9086                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9087                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9088                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9089                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9090                         }
9091                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9092                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9093                         }
9094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9096                 }
9097                 if (r->objects) {
9098                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9099                 }
9100         }
9101         return NDR_ERR_SUCCESS;
9102 }
9103
9104 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9105 {
9106         uint32_t cntr_objects_1;
9107         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9108         ndr->depth++;
9109         ndr_print_ptr(ndr, "id", r->id);
9110         ndr->depth++;
9111         if (r->id) {
9112                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9113         }
9114         ndr->depth--;
9115         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9116         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9117         ndr_print_uint32(ndr, "count", r->count);
9118         ndr_print_ptr(ndr, "objects", r->objects);
9119         ndr->depth++;
9120         if (r->objects) {
9121                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9122                 ndr->depth++;
9123                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9124                         char *idx_1=NULL;
9125                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9126                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9127                                 free(idx_1);
9128                         }
9129                 }
9130                 ndr->depth--;
9131         }
9132         ndr->depth--;
9133         ndr->depth--;
9134 }
9135
9136 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9137 {
9138         uint32_t cntr_objects_1;
9139         if (ndr_flags & NDR_SCALARS) {
9140                 NDR_CHECK(ndr_push_align(ndr, 5));
9141                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9143                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9145                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9146                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9147         }
9148         if (ndr_flags & NDR_BUFFERS) {
9149                 if (r->id) {
9150                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9151                 }
9152                 if (r->error) {
9153                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9154                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9155                 }
9156                 if (r->objects) {
9157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9158                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9159                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9160                         }
9161                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9162                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9163                         }
9164                 }
9165         }
9166         return NDR_ERR_SUCCESS;
9167 }
9168
9169 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9170 {
9171         uint32_t _ptr_id;
9172         TALLOC_CTX *_mem_save_id_0;
9173         uint32_t _ptr_error;
9174         TALLOC_CTX *_mem_save_error_0;
9175         uint32_t _ptr_objects;
9176         uint32_t cntr_objects_1;
9177         TALLOC_CTX *_mem_save_objects_0;
9178         TALLOC_CTX *_mem_save_objects_1;
9179         if (ndr_flags & NDR_SCALARS) {
9180                 NDR_CHECK(ndr_pull_align(ndr, 5));
9181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9182                 if (_ptr_id) {
9183                         NDR_PULL_ALLOC(ndr, r->id);
9184                 } else {
9185                         r->id = NULL;
9186                 }
9187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9189                 if (_ptr_error) {
9190                         NDR_PULL_ALLOC(ndr, r->error);
9191                 } else {
9192                         r->error = NULL;
9193                 }
9194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9195                 if (r->count > 10000) {
9196                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9197                 }
9198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9199                 if (_ptr_objects) {
9200                         NDR_PULL_ALLOC(ndr, r->objects);
9201                 } else {
9202                         r->objects = NULL;
9203                 }
9204                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9205         }
9206         if (ndr_flags & NDR_BUFFERS) {
9207                 if (r->id) {
9208                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9209                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9210                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9212                 }
9213                 if (r->error) {
9214                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9215                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9216                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9217                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9219                 }
9220                 if (r->objects) {
9221                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9222                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9224                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9225                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9226                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9227                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9228                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9229                         }
9230                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9231                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9232                         }
9233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9235                 }
9236                 if (r->objects) {
9237                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9238                 }
9239         }
9240         return NDR_ERR_SUCCESS;
9241 }
9242
9243 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9244 {
9245         uint32_t cntr_objects_1;
9246         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9247         ndr->depth++;
9248         ndr_print_ptr(ndr, "id", r->id);
9249         ndr->depth++;
9250         if (r->id) {
9251                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9252         }
9253         ndr->depth--;
9254         ndr_print_uint32(ndr, "level", r->level);
9255         ndr_print_ptr(ndr, "error", r->error);
9256         ndr->depth++;
9257         if (r->error) {
9258                 ndr_print_set_switch_value(ndr, r->error, r->level);
9259                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9260         }
9261         ndr->depth--;
9262         ndr_print_uint32(ndr, "count", r->count);
9263         ndr_print_ptr(ndr, "objects", r->objects);
9264         ndr->depth++;
9265         if (r->objects) {
9266                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9267                 ndr->depth++;
9268                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9269                         char *idx_1=NULL;
9270                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9271                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9272                                 free(idx_1);
9273                         }
9274                 }
9275                 ndr->depth--;
9276         }
9277         ndr->depth--;
9278         ndr->depth--;
9279 }
9280
9281 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9282 {
9283         if (ndr_flags & NDR_SCALARS) {
9284                 int level = ndr_push_get_switch_value(ndr, r);
9285                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9286                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9287                 switch (level) {
9288                         case 2: {
9289                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9290                         break; }
9291
9292                         case 3: {
9293                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9294                         break; }
9295
9296                         default:
9297                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9298                 }
9299         }
9300         if (ndr_flags & NDR_BUFFERS) {
9301                 int level = ndr_push_get_switch_value(ndr, r);
9302                 switch (level) {
9303                         case 2:
9304                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9305                         break;
9306
9307                         case 3:
9308                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9309                         break;
9310
9311                         default:
9312                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9313                 }
9314         }
9315         return NDR_ERR_SUCCESS;
9316 }
9317
9318 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9319 {
9320         int level;
9321         int32_t _level;
9322         level = ndr_pull_get_switch_value(ndr, r);
9323         if (ndr_flags & NDR_SCALARS) {
9324                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9325                 if (_level != level) {
9326                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9327                 }
9328                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9329                 switch (level) {
9330                         case 2: {
9331                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9332                         break; }
9333
9334                         case 3: {
9335                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9336                         break; }
9337
9338                         default:
9339                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9340                 }
9341         }
9342         if (ndr_flags & NDR_BUFFERS) {
9343                 switch (level) {
9344                         case 2:
9345                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9346                         break;
9347
9348                         case 3:
9349                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9350                         break;
9351
9352                         default:
9353                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9354                 }
9355         }
9356         return NDR_ERR_SUCCESS;
9357 }
9358
9359 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9360 {
9361         int level;
9362         level = ndr_print_get_switch_value(ndr, r);
9363         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9364         switch (level) {
9365                 case 2:
9366                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9367                 break;
9368
9369                 case 3:
9370                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9371                 break;
9372
9373                 default:
9374                         ndr_print_bad_level(ndr, name, level);
9375         }
9376 }
9377
9378 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9379 {
9380         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9381         return NDR_ERR_SUCCESS;
9382 }
9383
9384 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9385 {
9386         uint32_t v;
9387         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9388         *r = v;
9389         return NDR_ERR_SUCCESS;
9390 }
9391
9392 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9393 {
9394         ndr_print_uint32(ndr, name, r);
9395         ndr->depth++;
9396         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9397         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9398         ndr->depth--;
9399 }
9400
9401 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9402 {
9403         if (ndr_flags & NDR_SCALARS) {
9404                 NDR_CHECK(ndr_push_align(ndr, 4));
9405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9406                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9407                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9408         }
9409         if (ndr_flags & NDR_BUFFERS) {
9410         }
9411         return NDR_ERR_SUCCESS;
9412 }
9413
9414 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9415 {
9416         if (ndr_flags & NDR_SCALARS) {
9417                 NDR_CHECK(ndr_pull_align(ndr, 4));
9418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9419                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9420                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9421         }
9422         if (ndr_flags & NDR_BUFFERS) {
9423         }
9424         return NDR_ERR_SUCCESS;
9425 }
9426
9427 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9428 {
9429         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9430         ndr->depth++;
9431         ndr_print_uint32(ndr, "taskID", r->taskID);
9432         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9433         ndr->depth--;
9434 }
9435
9436 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9437 {
9438         if (ndr_flags & NDR_SCALARS) {
9439                 int level = ndr_push_get_switch_value(ndr, r);
9440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9441                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9442                 switch (level) {
9443                         case 1: {
9444                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9445                         break; }
9446
9447                         default:
9448                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9449                 }
9450         }
9451         if (ndr_flags & NDR_BUFFERS) {
9452                 int level = ndr_push_get_switch_value(ndr, r);
9453                 switch (level) {
9454                         case 1:
9455                         break;
9456
9457                         default:
9458                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9459                 }
9460         }
9461         return NDR_ERR_SUCCESS;
9462 }
9463
9464 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9465 {
9466         int level;
9467         uint32_t _level;
9468         level = ndr_pull_get_switch_value(ndr, r);
9469         if (ndr_flags & NDR_SCALARS) {
9470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9471                 if (_level != level) {
9472                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9473                 }
9474                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9475                 switch (level) {
9476                         case 1: {
9477                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9478                         break; }
9479
9480                         default:
9481                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9482                 }
9483         }
9484         if (ndr_flags & NDR_BUFFERS) {
9485                 switch (level) {
9486                         case 1:
9487                         break;
9488
9489                         default:
9490                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9491                 }
9492         }
9493         return NDR_ERR_SUCCESS;
9494 }
9495
9496 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9497 {
9498         int level;
9499         level = ndr_print_get_switch_value(ndr, r);
9500         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9501         switch (level) {
9502                 case 1:
9503                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9504                 break;
9505
9506                 default:
9507                         ndr_print_bad_level(ndr, name, level);
9508         }
9509 }
9510
9511 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9512 {
9513         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9514         return NDR_ERR_SUCCESS;
9515 }
9516
9517 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9518 {
9519         uint32_t v;
9520         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9521         *r = v;
9522         return NDR_ERR_SUCCESS;
9523 }
9524
9525 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9526 {
9527         const char *val = NULL;
9528
9529         switch (r) {
9530                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9531                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9532         }
9533         ndr_print_enum(ndr, name, "ENUM", val, r);
9534 }
9535
9536 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9537 {
9538         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9539         return NDR_ERR_SUCCESS;
9540 }
9541
9542 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9543 {
9544         uint32_t v;
9545         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9546         *r = v;
9547         return NDR_ERR_SUCCESS;
9548 }
9549
9550 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9551 {
9552         const char *val = NULL;
9553
9554         switch (r) {
9555                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9556                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9557                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9558                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9559                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9560                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9561                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9562                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9563                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9564                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9565                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9566                 case DRSUAPI_DS_REPLICA_INFO_REPSTO: val = "DRSUAPI_DS_REPLICA_INFO_REPSTO"; break;
9567                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: val = "DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS"; break;
9568                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: val = "DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1"; break;
9569                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: val = "DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS"; break;
9570         }
9571         ndr_print_enum(ndr, name, "ENUM", val, r);
9572 }
9573
9574 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9575 {
9576         if (ndr_flags & NDR_SCALARS) {
9577                 NDR_CHECK(ndr_push_align(ndr, 5));
9578                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9580                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9581                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9582         }
9583         if (ndr_flags & NDR_BUFFERS) {
9584                 if (r->object_dn) {
9585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9586                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9587                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9588                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9589                 }
9590         }
9591         return NDR_ERR_SUCCESS;
9592 }
9593
9594 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9595 {
9596         uint32_t _ptr_object_dn;
9597         TALLOC_CTX *_mem_save_object_dn_0;
9598         if (ndr_flags & NDR_SCALARS) {
9599                 NDR_CHECK(ndr_pull_align(ndr, 5));
9600                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9602                 if (_ptr_object_dn) {
9603                         NDR_PULL_ALLOC(ndr, r->object_dn);
9604                 } else {
9605                         r->object_dn = NULL;
9606                 }
9607                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9608                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9609         }
9610         if (ndr_flags & NDR_BUFFERS) {
9611                 if (r->object_dn) {
9612                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9613                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9614                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9615                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9616                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9617                                 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));
9618                         }
9619                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9620                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9622                 }
9623         }
9624         return NDR_ERR_SUCCESS;
9625 }
9626
9627 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9628 {
9629         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9630         ndr->depth++;
9631         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9632         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9633         ndr->depth++;
9634         if (r->object_dn) {
9635                 ndr_print_string(ndr, "object_dn", r->object_dn);
9636         }
9637         ndr->depth--;
9638         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
9639         ndr->depth--;
9640 }
9641
9642 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9643 {
9644         if (ndr_flags & NDR_SCALARS) {
9645                 NDR_CHECK(ndr_push_align(ndr, 5));
9646                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9648                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
9650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->value_dn_str));
9652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
9653                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9654         }
9655         if (ndr_flags & NDR_BUFFERS) {
9656                 if (r->object_dn) {
9657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9661                 }
9662                 if (r->attribute_name) {
9663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9667                 }
9668                 if (r->value_dn_str) {
9669                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->value_dn_str, CH_UTF16)));
9670                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9671                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->value_dn_str, CH_UTF16)));
9672                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->value_dn_str, ndr_charset_length(r->value_dn_str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9673                 }
9674         }
9675         return NDR_ERR_SUCCESS;
9676 }
9677
9678 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9679 {
9680         uint32_t _ptr_object_dn;
9681         TALLOC_CTX *_mem_save_object_dn_0;
9682         uint32_t _ptr_attribute_name;
9683         TALLOC_CTX *_mem_save_attribute_name_0;
9684         uint32_t _ptr_value_dn_str;
9685         TALLOC_CTX *_mem_save_value_dn_str_0;
9686         if (ndr_flags & NDR_SCALARS) {
9687                 NDR_CHECK(ndr_pull_align(ndr, 5));
9688                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9689                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9690                 if (_ptr_object_dn) {
9691                         NDR_PULL_ALLOC(ndr, r->object_dn);
9692                 } else {
9693                         r->object_dn = NULL;
9694                 }
9695                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
9697                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9698                 if (_ptr_attribute_name) {
9699                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9700                 } else {
9701                         r->attribute_name = NULL;
9702                 }
9703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_dn_str));
9704                 if (_ptr_value_dn_str) {
9705                         NDR_PULL_ALLOC(ndr, r->value_dn_str);
9706                 } else {
9707                         r->value_dn_str = NULL;
9708                 }
9709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
9710                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9711         }
9712         if (ndr_flags & NDR_BUFFERS) {
9713                 if (r->object_dn) {
9714                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9715                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9718                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9719                                 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));
9720                         }
9721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9724                 }
9725                 if (r->attribute_name) {
9726                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9727                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9730                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
9731                                 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));
9732                         }
9733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
9734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
9735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9736                 }
9737                 if (r->value_dn_str) {
9738                         _mem_save_value_dn_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
9739                         NDR_PULL_SET_MEM_CTX(ndr, r->value_dn_str, 0);
9740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->value_dn_str));
9741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->value_dn_str));
9742                         if (ndr_get_array_length(ndr, &r->value_dn_str) > ndr_get_array_size(ndr, &r->value_dn_str)) {
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->value_dn_str), ndr_get_array_length(ndr, &r->value_dn_str));
9744                         }
9745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->value_dn_str), sizeof(uint16_t)));
9746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->value_dn_str, ndr_get_array_length(ndr, &r->value_dn_str), sizeof(uint16_t), CH_UTF16));
9747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_dn_str_0, 0);
9748                 }
9749         }
9750         return NDR_ERR_SUCCESS;
9751 }
9752
9753 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9754 {
9755         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9756         ndr->depth++;
9757         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9758         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9759         ndr->depth++;
9760         if (r->object_dn) {
9761                 ndr_print_string(ndr, "object_dn", r->object_dn);
9762         }
9763         ndr->depth--;
9764         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
9765         ndr_print_uint32(ndr, "flags", r->flags);
9766         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9767         ndr->depth++;
9768         if (r->attribute_name) {
9769                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9770         }
9771         ndr->depth--;
9772         ndr_print_ptr(ndr, "value_dn_str", r->value_dn_str);
9773         ndr->depth++;
9774         if (r->value_dn_str) {
9775                 ndr_print_string(ndr, "value_dn_str", r->value_dn_str);
9776         }
9777         ndr->depth--;
9778         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
9779         ndr->depth--;
9780 }
9781
9782 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9783 {
9784         if (ndr_flags & NDR_SCALARS) {
9785                 int level = ndr_push_get_switch_value(ndr, r);
9786                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9787                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9788                 switch (level) {
9789                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9790                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9791                         break; }
9792
9793                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9794                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9795                         break; }
9796
9797                         default:
9798                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9799                 }
9800         }
9801         if (ndr_flags & NDR_BUFFERS) {
9802                 int level = ndr_push_get_switch_value(ndr, r);
9803                 switch (level) {
9804                         case DRSUAPI_DS_REPLICA_GET_INFO:
9805                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9806                         break;
9807
9808                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9809                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9810                         break;
9811
9812                         default:
9813                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9814                 }
9815         }
9816         return NDR_ERR_SUCCESS;
9817 }
9818
9819 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9820 {
9821         int level;
9822         uint32_t _level;
9823         level = ndr_pull_get_switch_value(ndr, r);
9824         if (ndr_flags & NDR_SCALARS) {
9825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9826                 if (_level != level) {
9827                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9828                 }
9829                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9830                 switch (level) {
9831                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9832                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9833                         break; }
9834
9835                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9836                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9837                         break; }
9838
9839                         default:
9840                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9841                 }
9842         }
9843         if (ndr_flags & NDR_BUFFERS) {
9844                 switch (level) {
9845                         case DRSUAPI_DS_REPLICA_GET_INFO:
9846                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9847                         break;
9848
9849                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9850                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9851                         break;
9852
9853                         default:
9854                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9855                 }
9856         }
9857         return NDR_ERR_SUCCESS;
9858 }
9859
9860 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9861 {
9862         int level;
9863         level = ndr_print_get_switch_value(ndr, r);
9864         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9865         switch (level) {
9866                 case DRSUAPI_DS_REPLICA_GET_INFO:
9867                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9868                 break;
9869
9870                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9871                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9872                 break;
9873
9874                 default:
9875                         ndr_print_bad_level(ndr, name, level);
9876         }
9877 }
9878
9879 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9880 {
9881         if (ndr_flags & NDR_SCALARS) {
9882                 NDR_CHECK(ndr_push_align(ndr, 8));
9883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9887                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
9888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9889                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9890                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9891                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9892                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9893                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9894                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9895                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9896                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9897                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9899                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9900         }
9901         if (ndr_flags & NDR_BUFFERS) {
9902                 if (r->naming_context_dn) {
9903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9906                         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));
9907                 }
9908                 if (r->source_dsa_obj_dn) {
9909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9910                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9912                         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));
9913                 }
9914                 if (r->source_dsa_address) {
9915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9918                         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));
9919                 }
9920                 if (r->transport_obj_dn) {
9921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9922                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9923                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9924                         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));
9925                 }
9926         }
9927         return NDR_ERR_SUCCESS;
9928 }
9929
9930 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9931 {
9932         uint32_t _ptr_naming_context_dn;
9933         TALLOC_CTX *_mem_save_naming_context_dn_0;
9934         uint32_t _ptr_source_dsa_obj_dn;
9935         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9936         uint32_t _ptr_source_dsa_address;
9937         TALLOC_CTX *_mem_save_source_dsa_address_0;
9938         uint32_t _ptr_transport_obj_dn;
9939         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9940         if (ndr_flags & NDR_SCALARS) {
9941                 NDR_CHECK(ndr_pull_align(ndr, 8));
9942                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9943                 if (_ptr_naming_context_dn) {
9944                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9945                 } else {
9946                         r->naming_context_dn = NULL;
9947                 }
9948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9949                 if (_ptr_source_dsa_obj_dn) {
9950                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9951                 } else {
9952                         r->source_dsa_obj_dn = NULL;
9953                 }
9954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9955                 if (_ptr_source_dsa_address) {
9956                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9957                 } else {
9958                         r->source_dsa_address = NULL;
9959                 }
9960                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9961                 if (_ptr_transport_obj_dn) {
9962                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9963                 } else {
9964                         r->transport_obj_dn = NULL;
9965                 }
9966                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
9967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9968                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9969                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9970                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9971                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9972                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9973                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9974                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9975                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9976                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
9978                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9979         }
9980         if (ndr_flags & NDR_BUFFERS) {
9981                 if (r->naming_context_dn) {
9982                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9983                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
9984                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
9985                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
9986                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
9987                                 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));
9988                         }
9989                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
9990                         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));
9991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
9992                 }
9993                 if (r->source_dsa_obj_dn) {
9994                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9995                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
9996                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
9997                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
9998                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
9999                                 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));
10000                         }
10001                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10002                         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));
10003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10004                 }
10005                 if (r->source_dsa_address) {
10006                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10007                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10010                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
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->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
10012                         }
10013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10014                         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));
10015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10016                 }
10017                 if (r->transport_obj_dn) {
10018                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10019                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10020                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10021                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10022                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_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->transport_obj_dn), ndr_get_array_length(ndr, &r->transport_obj_dn));
10024                         }
10025                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10026                         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));
10027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10028                 }
10029         }
10030         return NDR_ERR_SUCCESS;
10031 }
10032
10033 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10034 {
10035         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10036         ndr->depth++;
10037         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10038         ndr->depth++;
10039         if (r->naming_context_dn) {
10040                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10041         }
10042         ndr->depth--;
10043         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10044         ndr->depth++;
10045         if (r->source_dsa_obj_dn) {
10046                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10047         }
10048         ndr->depth--;
10049         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10050         ndr->depth++;
10051         if (r->source_dsa_address) {
10052                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10053         }
10054         ndr->depth--;
10055         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10056         ndr->depth++;
10057         if (r->transport_obj_dn) {
10058                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10059         }
10060         ndr->depth--;
10061         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
10062         ndr_print_uint32(ndr, "reserved", r->reserved);
10063         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10064         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10065         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10066         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10067         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10068         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10069         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10070         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10071         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10072         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10073         ndr->depth--;
10074 }
10075
10076 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10077 {
10078         uint32_t cntr_array_0;
10079         if (ndr_flags & NDR_SCALARS) {
10080                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10081                 NDR_CHECK(ndr_push_align(ndr, 8));
10082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10084                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10085                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10086                 }
10087                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10088         }
10089         if (ndr_flags & NDR_BUFFERS) {
10090                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10091                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10092                 }
10093         }
10094         return NDR_ERR_SUCCESS;
10095 }
10096
10097 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10098 {
10099         uint32_t cntr_array_0;
10100         TALLOC_CTX *_mem_save_array_0;
10101         if (ndr_flags & NDR_SCALARS) {
10102                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10103                 NDR_CHECK(ndr_pull_align(ndr, 8));
10104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10106                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10107                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10108                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10109                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10110                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10111                 }
10112                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10113                 if (r->array) {
10114                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10115                 }
10116                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10117         }
10118         if (ndr_flags & NDR_BUFFERS) {
10119                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10120                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10121                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10122                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10123                 }
10124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10125         }
10126         return NDR_ERR_SUCCESS;
10127 }
10128
10129 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10130 {
10131         uint32_t cntr_array_0;
10132         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10133         ndr->depth++;
10134         ndr_print_uint32(ndr, "count", r->count);
10135         ndr_print_uint32(ndr, "reserved", r->reserved);
10136         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10137         ndr->depth++;
10138         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10139                 char *idx_0=NULL;
10140                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10141                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10142                         free(idx_0);
10143                 }
10144         }
10145         ndr->depth--;
10146         ndr->depth--;
10147 }
10148
10149 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10150 {
10151         uint32_t cntr_array_0;
10152         if (ndr_flags & NDR_SCALARS) {
10153                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10154                 NDR_CHECK(ndr_push_align(ndr, 8));
10155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10157                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10158                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10159                 }
10160                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10161         }
10162         if (ndr_flags & NDR_BUFFERS) {
10163         }
10164         return NDR_ERR_SUCCESS;
10165 }
10166
10167 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10168 {
10169         uint32_t cntr_array_0;
10170         TALLOC_CTX *_mem_save_array_0;
10171         if (ndr_flags & NDR_SCALARS) {
10172                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10173                 NDR_CHECK(ndr_pull_align(ndr, 8));
10174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10176                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10177                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10178                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10179                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10180                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10181                 }
10182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10183                 if (r->array) {
10184                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10185                 }
10186                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10187         }
10188         if (ndr_flags & NDR_BUFFERS) {
10189         }
10190         return NDR_ERR_SUCCESS;
10191 }
10192
10193 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10194 {
10195         uint32_t cntr_array_0;
10196         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10197         ndr->depth++;
10198         ndr_print_uint32(ndr, "count", r->count);
10199         ndr_print_uint32(ndr, "reserved", r->reserved);
10200         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10201         ndr->depth++;
10202         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10203                 char *idx_0=NULL;
10204                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10205                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10206                         free(idx_0);
10207                 }
10208         }
10209         ndr->depth--;
10210         ndr->depth--;
10211 }
10212
10213 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10214 {
10215         if (ndr_flags & NDR_SCALARS) {
10216                 NDR_CHECK(ndr_push_align(ndr, 8));
10217                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10219                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10220                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10221                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10222                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10223                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10224         }
10225         if (ndr_flags & NDR_BUFFERS) {
10226                 if (r->attribute_name) {
10227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10228                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10230                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10231                 }
10232         }
10233         return NDR_ERR_SUCCESS;
10234 }
10235
10236 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10237 {
10238         uint32_t _ptr_attribute_name;
10239         TALLOC_CTX *_mem_save_attribute_name_0;
10240         if (ndr_flags & NDR_SCALARS) {
10241                 NDR_CHECK(ndr_pull_align(ndr, 8));
10242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10243                 if (_ptr_attribute_name) {
10244                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10245                 } else {
10246                         r->attribute_name = NULL;
10247                 }
10248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10249                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10250                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10251                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10252                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10253                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10254         }
10255         if (ndr_flags & NDR_BUFFERS) {
10256                 if (r->attribute_name) {
10257                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10258                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10259                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10260                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10261                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10262                                 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));
10263                         }
10264                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10265                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10267                 }
10268         }
10269         return NDR_ERR_SUCCESS;
10270 }
10271
10272 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10273 {
10274         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10275         ndr->depth++;
10276         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10277         ndr->depth++;
10278         if (r->attribute_name) {
10279                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10280         }
10281         ndr->depth--;
10282         ndr_print_uint32(ndr, "version", r->version);
10283         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10284         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10285         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10286         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10287         ndr->depth--;
10288 }
10289
10290 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10291 {
10292         uint32_t cntr_array_0;
10293         if (ndr_flags & NDR_SCALARS) {
10294                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10295                 NDR_CHECK(ndr_push_align(ndr, 8));
10296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10298                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10299                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10300                 }
10301                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10302         }
10303         if (ndr_flags & NDR_BUFFERS) {
10304                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10305                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10306                 }
10307         }
10308         return NDR_ERR_SUCCESS;
10309 }
10310
10311 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10312 {
10313         uint32_t cntr_array_0;
10314         TALLOC_CTX *_mem_save_array_0;
10315         if (ndr_flags & NDR_SCALARS) {
10316                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10317                 NDR_CHECK(ndr_pull_align(ndr, 8));
10318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10320                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10321                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10322                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10323                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10324                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10325                 }
10326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10327                 if (r->array) {
10328                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10329                 }
10330                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10331         }
10332         if (ndr_flags & NDR_BUFFERS) {
10333                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10334                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10335                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10336                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10337                 }
10338                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10339         }
10340         return NDR_ERR_SUCCESS;
10341 }
10342
10343 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10344 {
10345         uint32_t cntr_array_0;
10346         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10347         ndr->depth++;
10348         ndr_print_uint32(ndr, "count", r->count);
10349         ndr_print_uint32(ndr, "reserved", r->reserved);
10350         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10351         ndr->depth++;
10352         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10353                 char *idx_0=NULL;
10354                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10355                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10356                         free(idx_0);
10357                 }
10358         }
10359         ndr->depth--;
10360         ndr->depth--;
10361 }
10362
10363 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10364 {
10365         if (ndr_flags & NDR_SCALARS) {
10366                 NDR_CHECK(ndr_push_align(ndr, 5));
10367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10368                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10369                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10371                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10372                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10373         }
10374         if (ndr_flags & NDR_BUFFERS) {
10375                 if (r->dsa_obj_dn) {
10376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10379                         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));
10380                 }
10381         }
10382         return NDR_ERR_SUCCESS;
10383 }
10384
10385 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10386 {
10387         uint32_t _ptr_dsa_obj_dn;
10388         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10389         if (ndr_flags & NDR_SCALARS) {
10390                 NDR_CHECK(ndr_pull_align(ndr, 5));
10391                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10392                 if (_ptr_dsa_obj_dn) {
10393                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10394                 } else {
10395                         r->dsa_obj_dn = NULL;
10396                 }
10397                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10398                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10401                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10402         }
10403         if (ndr_flags & NDR_BUFFERS) {
10404                 if (r->dsa_obj_dn) {
10405                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10406                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10408                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10409                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10410                                 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));
10411                         }
10412                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10413                         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));
10414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10415                 }
10416         }
10417         return NDR_ERR_SUCCESS;
10418 }
10419
10420 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10421 {
10422         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10423         ndr->depth++;
10424         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10425         ndr->depth++;
10426         if (r->dsa_obj_dn) {
10427                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10428         }
10429         ndr->depth--;
10430         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10431         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10432         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10433         ndr_print_WERROR(ndr, "last_result", r->last_result);
10434         ndr->depth--;
10435 }
10436
10437 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10438 {
10439         uint32_t cntr_array_0;
10440         if (ndr_flags & NDR_SCALARS) {
10441                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10442                 NDR_CHECK(ndr_push_align(ndr, 5));
10443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10445                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10446                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10447                 }
10448                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10449         }
10450         if (ndr_flags & NDR_BUFFERS) {
10451                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10452                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10453                 }
10454         }
10455         return NDR_ERR_SUCCESS;
10456 }
10457
10458 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10459 {
10460         uint32_t cntr_array_0;
10461         TALLOC_CTX *_mem_save_array_0;
10462         if (ndr_flags & NDR_SCALARS) {
10463                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10464                 NDR_CHECK(ndr_pull_align(ndr, 5));
10465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10467                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10468                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10469                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10470                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10471                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10472                 }
10473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10474                 if (r->array) {
10475                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10476                 }
10477                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10478         }
10479         if (ndr_flags & NDR_BUFFERS) {
10480                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10482                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10483                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10484                 }
10485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10486         }
10487         return NDR_ERR_SUCCESS;
10488 }
10489
10490 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10491 {
10492         uint32_t cntr_array_0;
10493         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10494         ndr->depth++;
10495         ndr_print_uint32(ndr, "count", r->count);
10496         ndr_print_uint32(ndr, "reserved", r->reserved);
10497         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10498         ndr->depth++;
10499         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10500                 char *idx_0=NULL;
10501                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10502                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10503                         free(idx_0);
10504                 }
10505         }
10506         ndr->depth--;
10507         ndr->depth--;
10508 }
10509
10510 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10511 {
10512         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10513         return NDR_ERR_SUCCESS;
10514 }
10515
10516 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10517 {
10518         uint16_t v;
10519         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10520         *r = v;
10521         return NDR_ERR_SUCCESS;
10522 }
10523
10524 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10525 {
10526         const char *val = NULL;
10527
10528         switch (r) {
10529                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10530                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10531                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10532                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10533                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10534         }
10535         ndr_print_enum(ndr, name, "ENUM", val, r);
10536 }
10537
10538 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10539 {
10540         if (ndr_flags & NDR_SCALARS) {
10541                 NDR_CHECK(ndr_push_align(ndr, 5));
10542                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10545                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10546                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10547                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10550                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10551                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10552                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10553         }
10554         if (ndr_flags & NDR_BUFFERS) {
10555                 if (r->nc_dn) {
10556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10557                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10558                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10559                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10560                 }
10561                 if (r->remote_dsa_obj_dn) {
10562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10565                         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));
10566                 }
10567                 if (r->remote_dsa_address) {
10568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10571                         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));
10572                 }
10573         }
10574         return NDR_ERR_SUCCESS;
10575 }
10576
10577 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10578 {
10579         uint32_t _ptr_nc_dn;
10580         TALLOC_CTX *_mem_save_nc_dn_0;
10581         uint32_t _ptr_remote_dsa_obj_dn;
10582         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10583         uint32_t _ptr_remote_dsa_address;
10584         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10585         if (ndr_flags & NDR_SCALARS) {
10586                 NDR_CHECK(ndr_pull_align(ndr, 5));
10587                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10590                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10591                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10592                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10593                 if (_ptr_nc_dn) {
10594                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10595                 } else {
10596                         r->nc_dn = NULL;
10597                 }
10598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10599                 if (_ptr_remote_dsa_obj_dn) {
10600                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10601                 } else {
10602                         r->remote_dsa_obj_dn = NULL;
10603                 }
10604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10605                 if (_ptr_remote_dsa_address) {
10606                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10607                 } else {
10608                         r->remote_dsa_address = NULL;
10609                 }
10610                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10611                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10612                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10613         }
10614         if (ndr_flags & NDR_BUFFERS) {
10615                 if (r->nc_dn) {
10616                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10617                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10618                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10619                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10620                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10621                                 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));
10622                         }
10623                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10624                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10626                 }
10627                 if (r->remote_dsa_obj_dn) {
10628                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10629                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10632                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10633                                 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));
10634                         }
10635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10636                         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));
10637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10638                 }
10639                 if (r->remote_dsa_address) {
10640                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10641                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10644                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
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->remote_dsa_address), ndr_get_array_length(ndr, &r->remote_dsa_address));
10646                         }
10647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10648                         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));
10649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10650                 }
10651         }
10652         return NDR_ERR_SUCCESS;
10653 }
10654
10655 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10656 {
10657         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10658         ndr->depth++;
10659         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10660         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10661         ndr_print_uint32(ndr, "priority", r->priority);
10662         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10663         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10664         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10665         ndr->depth++;
10666         if (r->nc_dn) {
10667                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10668         }
10669         ndr->depth--;
10670         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10671         ndr->depth++;
10672         if (r->remote_dsa_obj_dn) {
10673                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10674         }
10675         ndr->depth--;
10676         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10677         ndr->depth++;
10678         if (r->remote_dsa_address) {
10679                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10680         }
10681         ndr->depth--;
10682         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10683         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10684         ndr->depth--;
10685 }
10686
10687 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10688 {
10689         uint32_t cntr_array_0;
10690         if (ndr_flags & NDR_SCALARS) {
10691                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10692                 NDR_CHECK(ndr_push_align(ndr, 5));
10693                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10695                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10696                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10697                 }
10698                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10699         }
10700         if (ndr_flags & NDR_BUFFERS) {
10701                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10702                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10703                 }
10704         }
10705         return NDR_ERR_SUCCESS;
10706 }
10707
10708 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10709 {
10710         uint32_t cntr_array_0;
10711         TALLOC_CTX *_mem_save_array_0;
10712         if (ndr_flags & NDR_SCALARS) {
10713                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10714                 NDR_CHECK(ndr_pull_align(ndr, 5));
10715                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10717                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10718                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10719                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10720                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10721                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10722                 }
10723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10724                 if (r->array) {
10725                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10726                 }
10727                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10728         }
10729         if (ndr_flags & NDR_BUFFERS) {
10730                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10731                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10732                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10733                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10734                 }
10735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10736         }
10737         return NDR_ERR_SUCCESS;
10738 }
10739
10740 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10741 {
10742         uint32_t cntr_array_0;
10743         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10744         ndr->depth++;
10745         ndr_print_NTTIME(ndr, "time", r->time);
10746         ndr_print_uint32(ndr, "count", r->count);
10747         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10748         ndr->depth++;
10749         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10750                 char *idx_0=NULL;
10751                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10752                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10753                         free(idx_0);
10754                 }
10755         }
10756         ndr->depth--;
10757         ndr->depth--;
10758 }
10759
10760 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10761 {
10762         if (ndr_flags & NDR_SCALARS) {
10763                 NDR_CHECK(ndr_push_align(ndr, 8));
10764                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10768                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10769                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10771                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10772                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10773                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10774                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10775                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10776         }
10777         if (ndr_flags & NDR_BUFFERS) {
10778                 if (r->attribute_name) {
10779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10783                 }
10784                 if (r->object_dn) {
10785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10788                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10789                 }
10790                 if (r->binary) {
10791                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10792                 }
10793         }
10794         return NDR_ERR_SUCCESS;
10795 }
10796
10797 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10798 {
10799         uint32_t _ptr_attribute_name;
10800         TALLOC_CTX *_mem_save_attribute_name_0;
10801         uint32_t _ptr_object_dn;
10802         TALLOC_CTX *_mem_save_object_dn_0;
10803         uint32_t _ptr_binary;
10804         TALLOC_CTX *_mem_save_binary_0;
10805         if (ndr_flags & NDR_SCALARS) {
10806                 NDR_CHECK(ndr_pull_align(ndr, 8));
10807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10808                 if (_ptr_attribute_name) {
10809                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10810                 } else {
10811                         r->attribute_name = NULL;
10812                 }
10813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10814                 if (_ptr_object_dn) {
10815                         NDR_PULL_ALLOC(ndr, r->object_dn);
10816                 } else {
10817                         r->object_dn = NULL;
10818                 }
10819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10821                 if (_ptr_binary) {
10822                         NDR_PULL_ALLOC(ndr, r->binary);
10823                 } else {
10824                         r->binary = NULL;
10825                 }
10826                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10827                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10829                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10830                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10831                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10832                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10833                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10834         }
10835         if (ndr_flags & NDR_BUFFERS) {
10836                 if (r->attribute_name) {
10837                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10838                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10840                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10841                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10842                                 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));
10843                         }
10844                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10845                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10847                 }
10848                 if (r->object_dn) {
10849                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10850                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10853                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10854                                 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));
10855                         }
10856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10859                 }
10860                 if (r->binary) {
10861                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10862                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10863                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10865                 }
10866         }
10867         return NDR_ERR_SUCCESS;
10868 }
10869
10870 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10871 {
10872         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10873         ndr->depth++;
10874         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10875         ndr->depth++;
10876         if (r->attribute_name) {
10877                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10878         }
10879         ndr->depth--;
10880         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10881         ndr->depth++;
10882         if (r->object_dn) {
10883                 ndr_print_string(ndr, "object_dn", r->object_dn);
10884         }
10885         ndr->depth--;
10886         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);
10887         ndr_print_ptr(ndr, "binary", r->binary);
10888         ndr->depth++;
10889         if (r->binary) {
10890                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10891         }
10892         ndr->depth--;
10893         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10894         ndr_print_NTTIME(ndr, "created", r->created);
10895         ndr_print_uint32(ndr, "version", r->version);
10896         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10897         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10898         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10899         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10900         ndr->depth--;
10901 }
10902
10903 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10904 {
10905         uint32_t cntr_array_0;
10906         if (ndr_flags & NDR_SCALARS) {
10907                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10908                 NDR_CHECK(ndr_push_align(ndr, 8));
10909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10911                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10912                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10913                 }
10914                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10915         }
10916         if (ndr_flags & NDR_BUFFERS) {
10917                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10918                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10919                 }
10920         }
10921         return NDR_ERR_SUCCESS;
10922 }
10923
10924 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10925 {
10926         uint32_t cntr_array_0;
10927         TALLOC_CTX *_mem_save_array_0;
10928         if (ndr_flags & NDR_SCALARS) {
10929                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10930                 NDR_CHECK(ndr_pull_align(ndr, 8));
10931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10933                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10934                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10935                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10936                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10937                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10938                 }
10939                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10940                 if (r->array) {
10941                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10942                 }
10943                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10944         }
10945         if (ndr_flags & NDR_BUFFERS) {
10946                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10947                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10948                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10949                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10950                 }
10951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10952         }
10953         return NDR_ERR_SUCCESS;
10954 }
10955
10956 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10957 {
10958         uint32_t cntr_array_0;
10959         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10960         ndr->depth++;
10961         ndr_print_uint32(ndr, "count", r->count);
10962         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
10963         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10964         ndr->depth++;
10965         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10966                 char *idx_0=NULL;
10967                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10968                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10969                         free(idx_0);
10970                 }
10971         }
10972         ndr->depth--;
10973         ndr->depth--;
10974 }
10975
10976 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10977 {
10978         uint32_t cntr_array_0;
10979         if (ndr_flags & NDR_SCALARS) {
10980                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10981                 NDR_CHECK(ndr_push_align(ndr, 8));
10982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10984                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10985                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10986                 }
10987                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10988         }
10989         if (ndr_flags & NDR_BUFFERS) {
10990         }
10991         return NDR_ERR_SUCCESS;
10992 }
10993
10994 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10995 {
10996         uint32_t cntr_array_0;
10997         TALLOC_CTX *_mem_save_array_0;
10998         if (ndr_flags & NDR_SCALARS) {
10999                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11000                 NDR_CHECK(ndr_pull_align(ndr, 8));
11001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11003                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11004                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11005                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11006                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11007                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11008                 }
11009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11010                 if (r->array) {
11011                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11012                 }
11013                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11014         }
11015         if (ndr_flags & NDR_BUFFERS) {
11016         }
11017         return NDR_ERR_SUCCESS;
11018 }
11019
11020 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11021 {
11022         uint32_t cntr_array_0;
11023         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11024         ndr->depth++;
11025         ndr_print_uint32(ndr, "count", r->count);
11026         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11027         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11028         ndr->depth++;
11029         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11030                 char *idx_0=NULL;
11031                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11032                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11033                         free(idx_0);
11034                 }
11035         }
11036         ndr->depth--;
11037         ndr->depth--;
11038 }
11039
11040 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11041 {
11042         if (ndr_flags & NDR_SCALARS) {
11043                 NDR_CHECK(ndr_push_align(ndr, 8));
11044                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11045                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11046                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11048                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11049         }
11050         if (ndr_flags & NDR_BUFFERS) {
11051                 if (r->source_dsa_obj_dn) {
11052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11053                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11054                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11055                         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));
11056                 }
11057         }
11058         return NDR_ERR_SUCCESS;
11059 }
11060
11061 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11062 {
11063         uint32_t _ptr_source_dsa_obj_dn;
11064         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11065         if (ndr_flags & NDR_SCALARS) {
11066                 NDR_CHECK(ndr_pull_align(ndr, 8));
11067                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11068                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11069                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11071                 if (_ptr_source_dsa_obj_dn) {
11072                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11073                 } else {
11074                         r->source_dsa_obj_dn = NULL;
11075                 }
11076                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11077         }
11078         if (ndr_flags & NDR_BUFFERS) {
11079                 if (r->source_dsa_obj_dn) {
11080                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11081                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11084                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11085                                 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));
11086                         }
11087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11088                         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));
11089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11090                 }
11091         }
11092         return NDR_ERR_SUCCESS;
11093 }
11094
11095 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11096 {
11097         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11098         ndr->depth++;
11099         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11100         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11101         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11102         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11103         ndr->depth++;
11104         if (r->source_dsa_obj_dn) {
11105                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11106         }
11107         ndr->depth--;
11108         ndr->depth--;
11109 }
11110
11111 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11112 {
11113         uint32_t cntr_array_0;
11114         if (ndr_flags & NDR_SCALARS) {
11115                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11116                 NDR_CHECK(ndr_push_align(ndr, 8));
11117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11119                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11120                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11121                 }
11122                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11123         }
11124         if (ndr_flags & NDR_BUFFERS) {
11125                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11126                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11127                 }
11128         }
11129         return NDR_ERR_SUCCESS;
11130 }
11131
11132 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11133 {
11134         uint32_t cntr_array_0;
11135         TALLOC_CTX *_mem_save_array_0;
11136         if (ndr_flags & NDR_SCALARS) {
11137                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11138                 NDR_CHECK(ndr_pull_align(ndr, 8));
11139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11141                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11142                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11143                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11144                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11145                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11146                 }
11147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11148                 if (r->array) {
11149                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11150                 }
11151                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11152         }
11153         if (ndr_flags & NDR_BUFFERS) {
11154                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11155                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11156                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11157                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11158                 }
11159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11160         }
11161         return NDR_ERR_SUCCESS;
11162 }
11163
11164 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11165 {
11166         uint32_t cntr_array_0;
11167         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11168         ndr->depth++;
11169         ndr_print_uint32(ndr, "count", r->count);
11170         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11171         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11172         ndr->depth++;
11173         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11174                 char *idx_0=NULL;
11175                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11176                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11177                         free(idx_0);
11178                 }
11179         }
11180         ndr->depth--;
11181         ndr->depth--;
11182 }
11183
11184 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11185 {
11186         if (ndr_flags & NDR_SCALARS) {
11187                 NDR_CHECK(ndr_push_align(ndr, 8));
11188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11190                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11191                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11192                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11193                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11195                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11196         }
11197         if (ndr_flags & NDR_BUFFERS) {
11198                 if (r->attribute_name) {
11199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11203                 }
11204                 if (r->originating_dsa_dn) {
11205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11208                         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));
11209                 }
11210         }
11211         return NDR_ERR_SUCCESS;
11212 }
11213
11214 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11215 {
11216         uint32_t _ptr_attribute_name;
11217         TALLOC_CTX *_mem_save_attribute_name_0;
11218         uint32_t _ptr_originating_dsa_dn;
11219         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11220         if (ndr_flags & NDR_SCALARS) {
11221                 NDR_CHECK(ndr_pull_align(ndr, 8));
11222                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11223                 if (_ptr_attribute_name) {
11224                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11225                 } else {
11226                         r->attribute_name = NULL;
11227                 }
11228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11229                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11230                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11231                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11232                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11234                 if (_ptr_originating_dsa_dn) {
11235                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11236                 } else {
11237                         r->originating_dsa_dn = NULL;
11238                 }
11239                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11240         }
11241         if (ndr_flags & NDR_BUFFERS) {
11242                 if (r->attribute_name) {
11243                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11244                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11247                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11248                                 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));
11249                         }
11250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11253                 }
11254                 if (r->originating_dsa_dn) {
11255                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11256                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11259                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11260                                 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));
11261                         }
11262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11263                         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));
11264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11265                 }
11266         }
11267         return NDR_ERR_SUCCESS;
11268 }
11269
11270 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11271 {
11272         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11273         ndr->depth++;
11274         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11275         ndr->depth++;
11276         if (r->attribute_name) {
11277                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11278         }
11279         ndr->depth--;
11280         ndr_print_uint32(ndr, "version", r->version);
11281         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11282         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11283         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11284         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11285         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11286         ndr->depth++;
11287         if (r->originating_dsa_dn) {
11288                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11289         }
11290         ndr->depth--;
11291         ndr->depth--;
11292 }
11293
11294 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11295 {
11296         uint32_t cntr_array_0;
11297         if (ndr_flags & NDR_SCALARS) {
11298                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11299                 NDR_CHECK(ndr_push_align(ndr, 8));
11300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11302                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11303                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11304                 }
11305                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11306         }
11307         if (ndr_flags & NDR_BUFFERS) {
11308                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11309                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11310                 }
11311         }
11312         return NDR_ERR_SUCCESS;
11313 }
11314
11315 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11316 {
11317         uint32_t cntr_array_0;
11318         TALLOC_CTX *_mem_save_array_0;
11319         if (ndr_flags & NDR_SCALARS) {
11320                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11321                 NDR_CHECK(ndr_pull_align(ndr, 8));
11322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11324                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11325                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11326                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11327                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11328                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11329                 }
11330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11331                 if (r->array) {
11332                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11333                 }
11334                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11335         }
11336         if (ndr_flags & NDR_BUFFERS) {
11337                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11338                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11339                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11340                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11341                 }
11342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11343         }
11344         return NDR_ERR_SUCCESS;
11345 }
11346
11347 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11348 {
11349         uint32_t cntr_array_0;
11350         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11351         ndr->depth++;
11352         ndr_print_uint32(ndr, "count", r->count);
11353         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11354         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11355         ndr->depth++;
11356         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11357                 char *idx_0=NULL;
11358                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11359                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11360                         free(idx_0);
11361                 }
11362         }
11363         ndr->depth--;
11364         ndr->depth--;
11365 }
11366
11367 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11368 {
11369         if (ndr_flags & NDR_SCALARS) {
11370                 NDR_CHECK(ndr_push_align(ndr, 8));
11371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11375                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11376                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11378                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11379                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11380                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11381                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11383                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11384         }
11385         if (ndr_flags & NDR_BUFFERS) {
11386                 if (r->attribute_name) {
11387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11390                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11391                 }
11392                 if (r->object_dn) {
11393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11395                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11396                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11397                 }
11398                 if (r->binary) {
11399                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11400                 }
11401                 if (r->originating_dsa_dn) {
11402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11405                         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));
11406                 }
11407         }
11408         return NDR_ERR_SUCCESS;
11409 }
11410
11411 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11412 {
11413         uint32_t _ptr_attribute_name;
11414         TALLOC_CTX *_mem_save_attribute_name_0;
11415         uint32_t _ptr_object_dn;
11416         TALLOC_CTX *_mem_save_object_dn_0;
11417         uint32_t _ptr_binary;
11418         TALLOC_CTX *_mem_save_binary_0;
11419         uint32_t _ptr_originating_dsa_dn;
11420         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11421         if (ndr_flags & NDR_SCALARS) {
11422                 NDR_CHECK(ndr_pull_align(ndr, 8));
11423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11424                 if (_ptr_attribute_name) {
11425                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11426                 } else {
11427                         r->attribute_name = NULL;
11428                 }
11429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11430                 if (_ptr_object_dn) {
11431                         NDR_PULL_ALLOC(ndr, r->object_dn);
11432                 } else {
11433                         r->object_dn = NULL;
11434                 }
11435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11437                 if (_ptr_binary) {
11438                         NDR_PULL_ALLOC(ndr, r->binary);
11439                 } else {
11440                         r->binary = NULL;
11441                 }
11442                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11443                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11445                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11446                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11447                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11448                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11449                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11450                 if (_ptr_originating_dsa_dn) {
11451                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11452                 } else {
11453                         r->originating_dsa_dn = NULL;
11454                 }
11455                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11456         }
11457         if (ndr_flags & NDR_BUFFERS) {
11458                 if (r->attribute_name) {
11459                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11460                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11463                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11464                                 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));
11465                         }
11466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11469                 }
11470                 if (r->object_dn) {
11471                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11472                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11475                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11476                                 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));
11477                         }
11478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11481                 }
11482                 if (r->binary) {
11483                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11484                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11485                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11487                 }
11488                 if (r->originating_dsa_dn) {
11489                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11490                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11493                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11494                                 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));
11495                         }
11496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11497                         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));
11498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11499                 }
11500         }
11501         return NDR_ERR_SUCCESS;
11502 }
11503
11504 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11505 {
11506         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11507         ndr->depth++;
11508         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11509         ndr->depth++;
11510         if (r->attribute_name) {
11511                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11512         }
11513         ndr->depth--;
11514         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11515         ndr->depth++;
11516         if (r->object_dn) {
11517                 ndr_print_string(ndr, "object_dn", r->object_dn);
11518         }
11519         ndr->depth--;
11520         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);
11521         ndr_print_ptr(ndr, "binary", r->binary);
11522         ndr->depth++;
11523         if (r->binary) {
11524                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11525         }
11526         ndr->depth--;
11527         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11528         ndr_print_NTTIME(ndr, "created", r->created);
11529         ndr_print_uint32(ndr, "version", r->version);
11530         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11531         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11532         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11533         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11534         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11535         ndr->depth++;
11536         if (r->originating_dsa_dn) {
11537                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11538         }
11539         ndr->depth--;
11540         ndr->depth--;
11541 }
11542
11543 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11544 {
11545         uint32_t cntr_array_0;
11546         if (ndr_flags & NDR_SCALARS) {
11547                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11548                 NDR_CHECK(ndr_push_align(ndr, 8));
11549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11551                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11552                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11553                 }
11554                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11555         }
11556         if (ndr_flags & NDR_BUFFERS) {
11557                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11558                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11559                 }
11560         }
11561         return NDR_ERR_SUCCESS;
11562 }
11563
11564 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11565 {
11566         uint32_t cntr_array_0;
11567         TALLOC_CTX *_mem_save_array_0;
11568         if (ndr_flags & NDR_SCALARS) {
11569                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11570                 NDR_CHECK(ndr_pull_align(ndr, 8));
11571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11573                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11574                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11575                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11576                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11577                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11578                 }
11579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11580                 if (r->array) {
11581                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11582                 }
11583                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11584         }
11585         if (ndr_flags & NDR_BUFFERS) {
11586                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11587                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11588                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11589                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11590                 }
11591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11592         }
11593         return NDR_ERR_SUCCESS;
11594 }
11595
11596 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11597 {
11598         uint32_t cntr_array_0;
11599         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11600         ndr->depth++;
11601         ndr_print_uint32(ndr, "count", r->count);
11602         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11603         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11604         ndr->depth++;
11605         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11606                 char *idx_0=NULL;
11607                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11608                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11609                         free(idx_0);
11610                 }
11611         }
11612         ndr->depth--;
11613         ndr->depth--;
11614 }
11615
11616 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11617 {
11618         if (ndr_flags & NDR_SCALARS) {
11619                 NDR_CHECK(ndr_push_align(ndr, 8));
11620                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11623                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11624                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11625                 {
11626                         uint32_t _flags_save_ipv4address = ndr->flags;
11627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11628                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11629                         ndr->flags = _flags_save_ipv4address;
11630                 }
11631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11632                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11633         }
11634         if (ndr_flags & NDR_BUFFERS) {
11635         }
11636         return NDR_ERR_SUCCESS;
11637 }
11638
11639 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11640 {
11641         if (ndr_flags & NDR_SCALARS) {
11642                 NDR_CHECK(ndr_pull_align(ndr, 8));
11643                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11646                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11647                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11648                 {
11649                         uint32_t _flags_save_ipv4address = ndr->flags;
11650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11651                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11652                         ndr->flags = _flags_save_ipv4address;
11653                 }
11654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11655                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11656         }
11657         if (ndr_flags & NDR_BUFFERS) {
11658         }
11659         return NDR_ERR_SUCCESS;
11660 }
11661
11662 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11663 {
11664         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11665         ndr->depth++;
11666         ndr_print_hyper(ndr, "u1", r->u1);
11667         ndr_print_uint32(ndr, "u2", r->u2);
11668         ndr_print_uint32(ndr, "u3", r->u3);
11669         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11670         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11671         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11672         ndr_print_uint32(ndr, "u5", r->u5);
11673         ndr->depth--;
11674 }
11675
11676 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11677 {
11678         uint32_t cntr_array_0;
11679         if (ndr_flags & NDR_SCALARS) {
11680                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11681                 NDR_CHECK(ndr_push_align(ndr, 8));
11682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11684                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11685                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11686                 }
11687                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11688         }
11689         if (ndr_flags & NDR_BUFFERS) {
11690         }
11691         return NDR_ERR_SUCCESS;
11692 }
11693
11694 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11695 {
11696         uint32_t cntr_array_0;
11697         TALLOC_CTX *_mem_save_array_0;
11698         if (ndr_flags & NDR_SCALARS) {
11699                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11700                 NDR_CHECK(ndr_pull_align(ndr, 8));
11701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11702                 if (r->count > 10000) {
11703                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11704                 }
11705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11706                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11707                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11708                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11709                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11710                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11711                 }
11712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11713                 if (r->array) {
11714                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11715                 }
11716                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11717         }
11718         if (ndr_flags & NDR_BUFFERS) {
11719         }
11720         return NDR_ERR_SUCCESS;
11721 }
11722
11723 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11724 {
11725         uint32_t cntr_array_0;
11726         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11727         ndr->depth++;
11728         ndr_print_uint32(ndr, "count", r->count);
11729         ndr_print_uint32(ndr, "reserved", r->reserved);
11730         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11731         ndr->depth++;
11732         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11733                 char *idx_0=NULL;
11734                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11735                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11736                         free(idx_0);
11737                 }
11738         }
11739         ndr->depth--;
11740         ndr->depth--;
11741 }
11742
11743 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11744 {
11745         if (ndr_flags & NDR_SCALARS) {
11746                 NDR_CHECK(ndr_push_align(ndr, 8));
11747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11753                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11755                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11756         }
11757         if (ndr_flags & NDR_BUFFERS) {
11758                 if (r->str1) {
11759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11761                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11762                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11763                 }
11764         }
11765         return NDR_ERR_SUCCESS;
11766 }
11767
11768 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11769 {
11770         uint32_t _ptr_str1;
11771         TALLOC_CTX *_mem_save_str1_0;
11772         if (ndr_flags & NDR_SCALARS) {
11773                 NDR_CHECK(ndr_pull_align(ndr, 8));
11774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11775                 if (_ptr_str1) {
11776                         NDR_PULL_ALLOC(ndr, r->str1);
11777                 } else {
11778                         r->str1 = NULL;
11779                 }
11780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11785                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11787                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11788         }
11789         if (ndr_flags & NDR_BUFFERS) {
11790                 if (r->str1) {
11791                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11792                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11794                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11795                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11796                                 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));
11797                         }
11798                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11799                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11801                 }
11802         }
11803         return NDR_ERR_SUCCESS;
11804 }
11805
11806 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11807 {
11808         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11809         ndr->depth++;
11810         ndr_print_ptr(ndr, "str1", r->str1);
11811         ndr->depth++;
11812         if (r->str1) {
11813                 ndr_print_string(ndr, "str1", r->str1);
11814         }
11815         ndr->depth--;
11816         ndr_print_uint32(ndr, "u1", r->u1);
11817         ndr_print_uint32(ndr, "u2", r->u2);
11818         ndr_print_uint32(ndr, "u3", r->u3);
11819         ndr_print_uint32(ndr, "u4", r->u4);
11820         ndr_print_uint32(ndr, "u5", r->u5);
11821         ndr_print_hyper(ndr, "u6", r->u6);
11822         ndr_print_uint32(ndr, "u7", r->u7);
11823         ndr->depth--;
11824 }
11825
11826 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11827 {
11828         uint32_t cntr_array_0;
11829         if (ndr_flags & NDR_SCALARS) {
11830                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11831                 NDR_CHECK(ndr_push_align(ndr, 8));
11832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11834                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11835                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11836                 }
11837                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11838         }
11839         if (ndr_flags & NDR_BUFFERS) {
11840                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11841                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11842                 }
11843         }
11844         return NDR_ERR_SUCCESS;
11845 }
11846
11847 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11848 {
11849         uint32_t cntr_array_0;
11850         TALLOC_CTX *_mem_save_array_0;
11851         if (ndr_flags & NDR_SCALARS) {
11852                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11853                 NDR_CHECK(ndr_pull_align(ndr, 8));
11854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11855                 if (r->count > 256) {
11856                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11857                 }
11858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11859                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11860                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11861                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11862                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11863                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11864                 }
11865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11866                 if (r->array) {
11867                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11868                 }
11869                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11870         }
11871         if (ndr_flags & NDR_BUFFERS) {
11872                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11873                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11874                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11875                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11876                 }
11877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11878         }
11879         return NDR_ERR_SUCCESS;
11880 }
11881
11882 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11883 {
11884         uint32_t cntr_array_0;
11885         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11886         ndr->depth++;
11887         ndr_print_uint32(ndr, "count", r->count);
11888         ndr_print_uint32(ndr, "reserved", r->reserved);
11889         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11890         ndr->depth++;
11891         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11892                 char *idx_0=NULL;
11893                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11894                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11895                         free(idx_0);
11896                 }
11897         }
11898         ndr->depth--;
11899         ndr->depth--;
11900 }
11901
11902 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11903 {
11904         if (ndr_flags & NDR_SCALARS) {
11905                 int level = ndr_push_get_switch_value(ndr, r);
11906                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11907                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11908                 switch (level) {
11909                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11910                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11911                         break; }
11912
11913                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11914                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11915                         break; }
11916
11917                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11918                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11919                         break; }
11920
11921                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11922                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11923                         break; }
11924
11925                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11926                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11927                         break; }
11928
11929                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11930                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11931                         break; }
11932
11933                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11934                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11935                         break; }
11936
11937                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11938                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11939                         break; }
11940
11941                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11942                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11943                         break; }
11944
11945                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11946                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11947                         break; }
11948
11949                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11950                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11951                         break; }
11952
11953                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
11954                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->repsto));
11955                         break; }
11956
11957                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
11958                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->clientctx));
11959                         break; }
11960
11961                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
11962                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->udv1));
11963                         break; }
11964
11965                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
11966                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvoutgoingcalls));
11967                         break; }
11968
11969                         default:
11970                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11971                 }
11972         }
11973         if (ndr_flags & NDR_BUFFERS) {
11974                 int level = ndr_push_get_switch_value(ndr, r);
11975                 switch (level) {
11976                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11977                                 if (r->neighbours) {
11978                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11979                                 }
11980                         break;
11981
11982                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11983                                 if (r->cursors) {
11984                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11985                                 }
11986                         break;
11987
11988                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11989                                 if (r->objmetadata) {
11990                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11991                                 }
11992                         break;
11993
11994                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11995                                 if (r->connectfailures) {
11996                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11997                                 }
11998                         break;
11999
12000                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12001                                 if (r->linkfailures) {
12002                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12003                                 }
12004                         break;
12005
12006                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12007                                 if (r->pendingops) {
12008                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12009                                 }
12010                         break;
12011
12012                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12013                                 if (r->attrvalmetadata) {
12014                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12015                                 }
12016                         break;
12017
12018                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12019                                 if (r->cursors2) {
12020                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12021                                 }
12022                         break;
12023
12024                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12025                                 if (r->cursors3) {
12026                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12027                                 }
12028                         break;
12029
12030                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12031                                 if (r->objmetadata2) {
12032                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12033                                 }
12034                         break;
12035
12036                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12037                                 if (r->attrvalmetadata2) {
12038                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12039                                 }
12040                         break;
12041
12042                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12043                                 if (r->repsto) {
12044                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12045                                 }
12046                         break;
12047
12048                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12049                                 if (r->clientctx) {
12050                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12051                                 }
12052                         break;
12053
12054                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12055                                 if (r->udv1) {
12056                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12057                                 }
12058                         break;
12059
12060                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12061                                 if (r->srvoutgoingcalls) {
12062                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12063                                 }
12064                         break;
12065
12066                         default:
12067                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12068                 }
12069         }
12070         return NDR_ERR_SUCCESS;
12071 }
12072
12073 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12074 {
12075         int level;
12076         uint32_t _level;
12077         TALLOC_CTX *_mem_save_neighbours_0;
12078         TALLOC_CTX *_mem_save_cursors_0;
12079         TALLOC_CTX *_mem_save_objmetadata_0;
12080         TALLOC_CTX *_mem_save_connectfailures_0;
12081         TALLOC_CTX *_mem_save_linkfailures_0;
12082         TALLOC_CTX *_mem_save_pendingops_0;
12083         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12084         TALLOC_CTX *_mem_save_cursors2_0;
12085         TALLOC_CTX *_mem_save_cursors3_0;
12086         TALLOC_CTX *_mem_save_objmetadata2_0;
12087         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12088         TALLOC_CTX *_mem_save_repsto_0;
12089         TALLOC_CTX *_mem_save_clientctx_0;
12090         TALLOC_CTX *_mem_save_udv1_0;
12091         TALLOC_CTX *_mem_save_srvoutgoingcalls_0;
12092         level = ndr_pull_get_switch_value(ndr, r);
12093         if (ndr_flags & NDR_SCALARS) {
12094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12095                 if (_level != level) {
12096                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12097                 }
12098                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12099                 switch (level) {
12100                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12101                                 uint32_t _ptr_neighbours;
12102                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12103                                 if (_ptr_neighbours) {
12104                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12105                                 } else {
12106                                         r->neighbours = NULL;
12107                                 }
12108                         break; }
12109
12110                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12111                                 uint32_t _ptr_cursors;
12112                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12113                                 if (_ptr_cursors) {
12114                                         NDR_PULL_ALLOC(ndr, r->cursors);
12115                                 } else {
12116                                         r->cursors = NULL;
12117                                 }
12118                         break; }
12119
12120                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12121                                 uint32_t _ptr_objmetadata;
12122                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12123                                 if (_ptr_objmetadata) {
12124                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12125                                 } else {
12126                                         r->objmetadata = NULL;
12127                                 }
12128                         break; }
12129
12130                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12131                                 uint32_t _ptr_connectfailures;
12132                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12133                                 if (_ptr_connectfailures) {
12134                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12135                                 } else {
12136                                         r->connectfailures = NULL;
12137                                 }
12138                         break; }
12139
12140                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12141                                 uint32_t _ptr_linkfailures;
12142                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12143                                 if (_ptr_linkfailures) {
12144                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12145                                 } else {
12146                                         r->linkfailures = NULL;
12147                                 }
12148                         break; }
12149
12150                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12151                                 uint32_t _ptr_pendingops;
12152                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12153                                 if (_ptr_pendingops) {
12154                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12155                                 } else {
12156                                         r->pendingops = NULL;
12157                                 }
12158                         break; }
12159
12160                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12161                                 uint32_t _ptr_attrvalmetadata;
12162                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12163                                 if (_ptr_attrvalmetadata) {
12164                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12165                                 } else {
12166                                         r->attrvalmetadata = NULL;
12167                                 }
12168                         break; }
12169
12170                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12171                                 uint32_t _ptr_cursors2;
12172                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12173                                 if (_ptr_cursors2) {
12174                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12175                                 } else {
12176                                         r->cursors2 = NULL;
12177                                 }
12178                         break; }
12179
12180                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12181                                 uint32_t _ptr_cursors3;
12182                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12183                                 if (_ptr_cursors3) {
12184                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12185                                 } else {
12186                                         r->cursors3 = NULL;
12187                                 }
12188                         break; }
12189
12190                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12191                                 uint32_t _ptr_objmetadata2;
12192                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12193                                 if (_ptr_objmetadata2) {
12194                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12195                                 } else {
12196                                         r->objmetadata2 = NULL;
12197                                 }
12198                         break; }
12199
12200                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12201                                 uint32_t _ptr_attrvalmetadata2;
12202                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12203                                 if (_ptr_attrvalmetadata2) {
12204                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12205                                 } else {
12206                                         r->attrvalmetadata2 = NULL;
12207                                 }
12208                         break; }
12209
12210                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
12211                                 uint32_t _ptr_repsto;
12212                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_repsto));
12213                                 if (_ptr_repsto) {
12214                                         NDR_PULL_ALLOC(ndr, r->repsto);
12215                                 } else {
12216                                         r->repsto = NULL;
12217                                 }
12218                         break; }
12219
12220                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
12221                                 uint32_t _ptr_clientctx;
12222                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_clientctx));
12223                                 if (_ptr_clientctx) {
12224                                         NDR_PULL_ALLOC(ndr, r->clientctx);
12225                                 } else {
12226                                         r->clientctx = NULL;
12227                                 }
12228                         break; }
12229
12230                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
12231                                 uint32_t _ptr_udv1;
12232                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_udv1));
12233                                 if (_ptr_udv1) {
12234                                         NDR_PULL_ALLOC(ndr, r->udv1);
12235                                 } else {
12236                                         r->udv1 = NULL;
12237                                 }
12238                         break; }
12239
12240                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
12241                                 uint32_t _ptr_srvoutgoingcalls;
12242                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvoutgoingcalls));
12243                                 if (_ptr_srvoutgoingcalls) {
12244                                         NDR_PULL_ALLOC(ndr, r->srvoutgoingcalls);
12245                                 } else {
12246                                         r->srvoutgoingcalls = NULL;
12247                                 }
12248                         break; }
12249
12250                         default:
12251                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12252                 }
12253         }
12254         if (ndr_flags & NDR_BUFFERS) {
12255                 switch (level) {
12256                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12257                                 if (r->neighbours) {
12258                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12259                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12260                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12261                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12262                                 }
12263                         break;
12264
12265                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12266                                 if (r->cursors) {
12267                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12268                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12269                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12270                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12271                                 }
12272                         break;
12273
12274                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12275                                 if (r->objmetadata) {
12276                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12277                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12278                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12279                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12280                                 }
12281                         break;
12282
12283                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12284                                 if (r->connectfailures) {
12285                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12286                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12287                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12288                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12289                                 }
12290                         break;
12291
12292                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12293                                 if (r->linkfailures) {
12294                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12295                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12296                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12298                                 }
12299                         break;
12300
12301                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12302                                 if (r->pendingops) {
12303                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12304                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12305                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12306                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12307                                 }
12308                         break;
12309
12310                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12311                                 if (r->attrvalmetadata) {
12312                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12313                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12314                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12315                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12316                                 }
12317                         break;
12318
12319                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12320                                 if (r->cursors2) {
12321                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12322                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12323                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12324                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12325                                 }
12326                         break;
12327
12328                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12329                                 if (r->cursors3) {
12330                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12331                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12332                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12333                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12334                                 }
12335                         break;
12336
12337                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12338                                 if (r->objmetadata2) {
12339                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12340                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12341                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12342                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12343                                 }
12344                         break;
12345
12346                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12347                                 if (r->attrvalmetadata2) {
12348                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12349                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12350                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12351                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12352                                 }
12353                         break;
12354
12355                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12356                                 if (r->repsto) {
12357                                         _mem_save_repsto_0 = NDR_PULL_GET_MEM_CTX(ndr);
12358                                         NDR_PULL_SET_MEM_CTX(ndr, r->repsto, 0);
12359                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12360                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_repsto_0, 0);
12361                                 }
12362                         break;
12363
12364                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12365                                 if (r->clientctx) {
12366                                         _mem_save_clientctx_0 = NDR_PULL_GET_MEM_CTX(ndr);
12367                                         NDR_PULL_SET_MEM_CTX(ndr, r->clientctx, 0);
12368                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12369                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_clientctx_0, 0);
12370                                 }
12371                         break;
12372
12373                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12374                                 if (r->udv1) {
12375                                         _mem_save_udv1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12376                                         NDR_PULL_SET_MEM_CTX(ndr, r->udv1, 0);
12377                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12378                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_udv1_0, 0);
12379                                 }
12380                         break;
12381
12382                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12383                                 if (r->srvoutgoingcalls) {
12384                                         _mem_save_srvoutgoingcalls_0 = NDR_PULL_GET_MEM_CTX(ndr);
12385                                         NDR_PULL_SET_MEM_CTX(ndr, r->srvoutgoingcalls, 0);
12386                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12387                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvoutgoingcalls_0, 0);
12388                                 }
12389                         break;
12390
12391                         default:
12392                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12393                 }
12394         }
12395         return NDR_ERR_SUCCESS;
12396 }
12397
12398 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12399 {
12400         int level;
12401         level = ndr_print_get_switch_value(ndr, r);
12402         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12403         switch (level) {
12404                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12405                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12406                         ndr->depth++;
12407                         if (r->neighbours) {
12408                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12409                         }
12410                         ndr->depth--;
12411                 break;
12412
12413                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12414                         ndr_print_ptr(ndr, "cursors", r->cursors);
12415                         ndr->depth++;
12416                         if (r->cursors) {
12417                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12418                         }
12419                         ndr->depth--;
12420                 break;
12421
12422                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12423                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12424                         ndr->depth++;
12425                         if (r->objmetadata) {
12426                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12427                         }
12428                         ndr->depth--;
12429                 break;
12430
12431                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12432                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12433                         ndr->depth++;
12434                         if (r->connectfailures) {
12435                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12436                         }
12437                         ndr->depth--;
12438                 break;
12439
12440                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12441                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12442                         ndr->depth++;
12443                         if (r->linkfailures) {
12444                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12445                         }
12446                         ndr->depth--;
12447                 break;
12448
12449                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12450                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12451                         ndr->depth++;
12452                         if (r->pendingops) {
12453                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12454                         }
12455                         ndr->depth--;
12456                 break;
12457
12458                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12459                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12460                         ndr->depth++;
12461                         if (r->attrvalmetadata) {
12462                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12463                         }
12464                         ndr->depth--;
12465                 break;
12466
12467                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12468                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12469                         ndr->depth++;
12470                         if (r->cursors2) {
12471                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12472                         }
12473                         ndr->depth--;
12474                 break;
12475
12476                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12477                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12478                         ndr->depth++;
12479                         if (r->cursors3) {
12480                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12481                         }
12482                         ndr->depth--;
12483                 break;
12484
12485                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12486                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12487                         ndr->depth++;
12488                         if (r->objmetadata2) {
12489                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12490                         }
12491                         ndr->depth--;
12492                 break;
12493
12494                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12495                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12496                         ndr->depth++;
12497                         if (r->attrvalmetadata2) {
12498                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12499                         }
12500                         ndr->depth--;
12501                 break;
12502
12503                 case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12504                         ndr_print_ptr(ndr, "repsto", r->repsto);
12505                         ndr->depth++;
12506                         if (r->repsto) {
12507                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "repsto", r->repsto);
12508                         }
12509                         ndr->depth--;
12510                 break;
12511
12512                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12513                         ndr_print_ptr(ndr, "clientctx", r->clientctx);
12514                         ndr->depth++;
12515                         if (r->clientctx) {
12516                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "clientctx", r->clientctx);
12517                         }
12518                         ndr->depth--;
12519                 break;
12520
12521                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12522                         ndr_print_ptr(ndr, "udv1", r->udv1);
12523                         ndr->depth++;
12524                         if (r->udv1) {
12525                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "udv1", r->udv1);
12526                         }
12527                         ndr->depth--;
12528                 break;
12529
12530                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12531                         ndr_print_ptr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12532                         ndr->depth++;
12533                         if (r->srvoutgoingcalls) {
12534                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12535                         }
12536                         ndr->depth--;
12537                 break;
12538
12539                 default:
12540                         ndr_print_bad_level(ndr, name, level);
12541         }
12542 }
12543
12544 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12545 {
12546         if (ndr_flags & NDR_SCALARS) {
12547                 int level = ndr_push_get_switch_value(ndr, r);
12548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12549                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12550                 switch (level) {
12551                         case 1: {
12552                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12553                         break; }
12554
12555                         default:
12556                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12557                 }
12558         }
12559         if (ndr_flags & NDR_BUFFERS) {
12560                 int level = ndr_push_get_switch_value(ndr, r);
12561                 switch (level) {
12562                         case 1:
12563                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12564                         break;
12565
12566                         default:
12567                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12568                 }
12569         }
12570         return NDR_ERR_SUCCESS;
12571 }
12572
12573 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12574 {
12575         int level;
12576         uint32_t _level;
12577         level = ndr_pull_get_switch_value(ndr, r);
12578         if (ndr_flags & NDR_SCALARS) {
12579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12580                 if (_level != level) {
12581                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12582                 }
12583                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12584                 switch (level) {
12585                         case 1: {
12586                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12587                         break; }
12588
12589                         default:
12590                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12591                 }
12592         }
12593         if (ndr_flags & NDR_BUFFERS) {
12594                 switch (level) {
12595                         case 1:
12596                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12597                         break;
12598
12599                         default:
12600                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12601                 }
12602         }
12603         return NDR_ERR_SUCCESS;
12604 }
12605
12606 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12607 {
12608         int level;
12609         level = ndr_print_get_switch_value(ndr, r);
12610         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12611         switch (level) {
12612                 case 1:
12613                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12614                 break;
12615
12616                 default:
12617                         ndr_print_bad_level(ndr, name, level);
12618         }
12619 }
12620
12621 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12622 {
12623         uint32_t cntr_req_array_1;
12624         if (ndr_flags & NDR_SCALARS) {
12625                 NDR_CHECK(ndr_push_align(ndr, 5));
12626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12628                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12629         }
12630         if (ndr_flags & NDR_BUFFERS) {
12631                 if (r->req_array) {
12632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12633                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12634                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12635                         }
12636                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12637                                 if (r->req_array[cntr_req_array_1]) {
12638                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12639                                 }
12640                         }
12641                 }
12642         }
12643         return NDR_ERR_SUCCESS;
12644 }
12645
12646 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12647 {
12648         uint32_t _ptr_req_array;
12649         uint32_t cntr_req_array_1;
12650         TALLOC_CTX *_mem_save_req_array_0;
12651         TALLOC_CTX *_mem_save_req_array_1;
12652         TALLOC_CTX *_mem_save_req_array_2;
12653         if (ndr_flags & NDR_SCALARS) {
12654                 NDR_CHECK(ndr_pull_align(ndr, 5));
12655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12656                 if (r->num_req < 1 || r->num_req > 10000) {
12657                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12658                 }
12659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12660                 if (_ptr_req_array) {
12661                         NDR_PULL_ALLOC(ndr, r->req_array);
12662                 } else {
12663                         r->req_array = NULL;
12664                 }
12665                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12666         }
12667         if (ndr_flags & NDR_BUFFERS) {
12668                 if (r->req_array) {
12669                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12670                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12672                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12673                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12674                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12675                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12676                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12677                                 if (_ptr_req_array) {
12678                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12679                                 } else {
12680                                         r->req_array[cntr_req_array_1] = NULL;
12681                                 }
12682                         }
12683                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12684                                 if (r->req_array[cntr_req_array_1]) {
12685                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12686                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12687                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12688                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12689                                 }
12690                         }
12691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12693                 }
12694                 if (r->req_array) {
12695                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12696                 }
12697         }
12698         return NDR_ERR_SUCCESS;
12699 }
12700
12701 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12702 {
12703         uint32_t cntr_req_array_1;
12704         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12705         ndr->depth++;
12706         ndr_print_uint32(ndr, "num_req", r->num_req);
12707         ndr_print_ptr(ndr, "req_array", r->req_array);
12708         ndr->depth++;
12709         if (r->req_array) {
12710                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12711                 ndr->depth++;
12712                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12713                         char *idx_1=NULL;
12714                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12715                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12716                                 ndr->depth++;
12717                                 if (r->req_array[cntr_req_array_1]) {
12718                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12719                                 }
12720                                 ndr->depth--;
12721                                 free(idx_1);
12722                         }
12723                 }
12724                 ndr->depth--;
12725         }
12726         ndr->depth--;
12727         ndr->depth--;
12728 }
12729
12730 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12731 {
12732         if (ndr_flags & NDR_SCALARS) {
12733                 int level = ndr_push_get_switch_value(ndr, r);
12734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12735                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12736                 switch (level) {
12737                         case 1: {
12738                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12739                         break; }
12740
12741                         default:
12742                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12743                 }
12744         }
12745         if (ndr_flags & NDR_BUFFERS) {
12746                 int level = ndr_push_get_switch_value(ndr, r);
12747                 switch (level) {
12748                         case 1:
12749                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12750                         break;
12751
12752                         default:
12753                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12754                 }
12755         }
12756         return NDR_ERR_SUCCESS;
12757 }
12758
12759 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12760 {
12761         int level;
12762         uint32_t _level;
12763         level = ndr_pull_get_switch_value(ndr, r);
12764         if (ndr_flags & NDR_SCALARS) {
12765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12766                 if (_level != level) {
12767                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12768                 }
12769                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12770                 switch (level) {
12771                         case 1: {
12772                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12773                         break; }
12774
12775                         default:
12776                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12777                 }
12778         }
12779         if (ndr_flags & NDR_BUFFERS) {
12780                 switch (level) {
12781                         case 1:
12782                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12783                         break;
12784
12785                         default:
12786                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12787                 }
12788         }
12789         return NDR_ERR_SUCCESS;
12790 }
12791
12792 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12793 {
12794         int level;
12795         level = ndr_print_get_switch_value(ndr, r);
12796         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12797         switch (level) {
12798                 case 1:
12799                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12800                 break;
12801
12802                 default:
12803                         ndr_print_bad_level(ndr, name, level);
12804         }
12805 }
12806
12807 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12808 {
12809         if (ndr_flags & NDR_SCALARS) {
12810                 NDR_CHECK(ndr_push_align(ndr, 4));
12811                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12813                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12814         }
12815         if (ndr_flags & NDR_BUFFERS) {
12816         }
12817         return NDR_ERR_SUCCESS;
12818 }
12819
12820 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12821 {
12822         if (ndr_flags & NDR_SCALARS) {
12823                 NDR_CHECK(ndr_pull_align(ndr, 4));
12824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12826                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12827         }
12828         if (ndr_flags & NDR_BUFFERS) {
12829         }
12830         return NDR_ERR_SUCCESS;
12831 }
12832
12833 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12834 {
12835         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12836         ndr->depth++;
12837         ndr_print_WERROR(ndr, "error_code", r->error_code);
12838         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12839         ndr->depth--;
12840 }
12841
12842 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12843 {
12844         uint32_t cntr_info_1;
12845         if (ndr_flags & NDR_SCALARS) {
12846                 NDR_CHECK(ndr_push_align(ndr, 5));
12847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12850                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12851         }
12852         if (ndr_flags & NDR_BUFFERS) {
12853                 if (r->info) {
12854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12855                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12856                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12857                         }
12858                 }
12859         }
12860         return NDR_ERR_SUCCESS;
12861 }
12862
12863 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12864 {
12865         uint32_t _ptr_info;
12866         uint32_t cntr_info_1;
12867         TALLOC_CTX *_mem_save_info_0;
12868         TALLOC_CTX *_mem_save_info_1;
12869         if (ndr_flags & NDR_SCALARS) {
12870                 NDR_CHECK(ndr_pull_align(ndr, 5));
12871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12872                 if (r->num_info > 10000) {
12873                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12874                 }
12875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12876                 if (_ptr_info) {
12877                         NDR_PULL_ALLOC(ndr, r->info);
12878                 } else {
12879                         r->info = NULL;
12880                 }
12881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags_reserved));
12882                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12883         }
12884         if (ndr_flags & NDR_BUFFERS) {
12885                 if (r->info) {
12886                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12887                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12889                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12890                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12891                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12892                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12893                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12894                         }
12895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12897                 }
12898                 if (r->info) {
12899                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12900                 }
12901         }
12902         return NDR_ERR_SUCCESS;
12903 }
12904
12905 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12906 {
12907         uint32_t cntr_info_1;
12908         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12909         ndr->depth++;
12910         ndr_print_uint32(ndr, "num_info", r->num_info);
12911         ndr_print_ptr(ndr, "info", r->info);
12912         ndr->depth++;
12913         if (r->info) {
12914                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12915                 ndr->depth++;
12916                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12917                         char *idx_1=NULL;
12918                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12919                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12920                                 free(idx_1);
12921                         }
12922                 }
12923                 ndr->depth--;
12924         }
12925         ndr->depth--;
12926         ndr_print_uint32(ndr, "flags_reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flags_reserved);
12927         ndr->depth--;
12928 }
12929
12930 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12931 {
12932         if (ndr_flags & NDR_SCALARS) {
12933                 int level = ndr_push_get_switch_value(ndr, r);
12934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12935                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12936                 switch (level) {
12937                         case 1: {
12938                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12939                         break; }
12940
12941                         default:
12942                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12943                 }
12944         }
12945         if (ndr_flags & NDR_BUFFERS) {
12946                 int level = ndr_push_get_switch_value(ndr, r);
12947                 switch (level) {
12948                         case 1:
12949                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12950                         break;
12951
12952                         default:
12953                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12954                 }
12955         }
12956         return NDR_ERR_SUCCESS;
12957 }
12958
12959 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12960 {
12961         int level;
12962         uint32_t _level;
12963         level = ndr_pull_get_switch_value(ndr, r);
12964         if (ndr_flags & NDR_SCALARS) {
12965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12966                 if (_level != level) {
12967                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12968                 }
12969                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12970                 switch (level) {
12971                         case 1: {
12972                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12973                         break; }
12974
12975                         default:
12976                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12977                 }
12978         }
12979         if (ndr_flags & NDR_BUFFERS) {
12980                 switch (level) {
12981                         case 1:
12982                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12983                         break;
12984
12985                         default:
12986                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12987                 }
12988         }
12989         return NDR_ERR_SUCCESS;
12990 }
12991
12992 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12993 {
12994         int level;
12995         level = ndr_print_get_switch_value(ndr, r);
12996         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12997         switch (level) {
12998                 case 1:
12999                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13000                 break;
13001
13002                 default:
13003                         ndr_print_bad_level(ndr, name, level);
13004         }
13005 }
13006
13007 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13008 {
13009         uint32_t cntr_site_to_1;
13010         if (ndr_flags & NDR_SCALARS) {
13011                 NDR_CHECK(ndr_push_align(ndr, 5));
13012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13016                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13017         }
13018         if (ndr_flags & NDR_BUFFERS) {
13019                 if (r->site_from) {
13020                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13021                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13023                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13024                 }
13025                 if (r->site_to) {
13026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13027                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13028                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13029                         }
13030                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13031                                 if (r->site_to[cntr_site_to_1]) {
13032                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13033                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13034                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13035                                         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));
13036                                 }
13037                         }
13038                 }
13039         }
13040         return NDR_ERR_SUCCESS;
13041 }
13042
13043 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13044 {
13045         uint32_t _ptr_site_from;
13046         TALLOC_CTX *_mem_save_site_from_0;
13047         uint32_t _ptr_site_to;
13048         uint32_t cntr_site_to_1;
13049         TALLOC_CTX *_mem_save_site_to_0;
13050         TALLOC_CTX *_mem_save_site_to_1;
13051         TALLOC_CTX *_mem_save_site_to_2;
13052         if (ndr_flags & NDR_SCALARS) {
13053                 NDR_CHECK(ndr_pull_align(ndr, 5));
13054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13055                 if (_ptr_site_from) {
13056                         NDR_PULL_ALLOC(ndr, r->site_from);
13057                 } else {
13058                         r->site_from = NULL;
13059                 }
13060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13061                 if (r->num_req < 1 || r->num_req > 10000) {
13062                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13063                 }
13064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13065                 if (_ptr_site_to) {
13066                         NDR_PULL_ALLOC(ndr, r->site_to);
13067                 } else {
13068                         r->site_to = NULL;
13069                 }
13070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13071                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13072         }
13073         if (ndr_flags & NDR_BUFFERS) {
13074                 if (r->site_from) {
13075                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13076                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13078                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13079                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13080                                 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));
13081                         }
13082                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13083                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13085                 }
13086                 if (r->site_to) {
13087                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13088                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13089                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13090                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13091                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13092                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13093                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13094                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13095                                 if (_ptr_site_to) {
13096                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13097                                 } else {
13098                                         r->site_to[cntr_site_to_1] = NULL;
13099                                 }
13100                         }
13101                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13102                                 if (r->site_to[cntr_site_to_1]) {
13103                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13104                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13105                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13106                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13107                                         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])) {
13108                                                 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]));
13109                                         }
13110                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13111                                         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));
13112                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13113                                 }
13114                         }
13115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13117                 }
13118                 if (r->site_to) {
13119                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13120                 }
13121         }
13122         return NDR_ERR_SUCCESS;
13123 }
13124
13125 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13126 {
13127         uint32_t cntr_site_to_1;
13128         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13129         ndr->depth++;
13130         ndr_print_ptr(ndr, "site_from", r->site_from);
13131         ndr->depth++;
13132         if (r->site_from) {
13133                 ndr_print_string(ndr, "site_from", r->site_from);
13134         }
13135         ndr->depth--;
13136         ndr_print_uint32(ndr, "num_req", r->num_req);
13137         ndr_print_ptr(ndr, "site_to", r->site_to);
13138         ndr->depth++;
13139         if (r->site_to) {
13140                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13141                 ndr->depth++;
13142                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13143                         char *idx_1=NULL;
13144                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13145                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13146                                 ndr->depth++;
13147                                 if (r->site_to[cntr_site_to_1]) {
13148                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13149                                 }
13150                                 ndr->depth--;
13151                                 free(idx_1);
13152                         }
13153                 }
13154                 ndr->depth--;
13155         }
13156         ndr->depth--;
13157         ndr_print_uint32(ndr, "flags", r->flags);
13158         ndr->depth--;
13159 }
13160
13161 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13162 {
13163         if (ndr_flags & NDR_SCALARS) {
13164                 int level = ndr_push_get_switch_value(ndr, r);
13165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13166                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13167                 switch (level) {
13168                         case 1: {
13169                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13170                         break; }
13171
13172                         default:
13173                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13174                 }
13175         }
13176         if (ndr_flags & NDR_BUFFERS) {
13177                 int level = ndr_push_get_switch_value(ndr, r);
13178                 switch (level) {
13179                         case 1:
13180                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13181                         break;
13182
13183                         default:
13184                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13185                 }
13186         }
13187         return NDR_ERR_SUCCESS;
13188 }
13189
13190 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13191 {
13192         int level;
13193         uint32_t _level;
13194         level = ndr_pull_get_switch_value(ndr, r);
13195         if (ndr_flags & NDR_SCALARS) {
13196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13197                 if (_level != level) {
13198                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13199                 }
13200                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13201                 switch (level) {
13202                         case 1: {
13203                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13204                         break; }
13205
13206                         default:
13207                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13208                 }
13209         }
13210         if (ndr_flags & NDR_BUFFERS) {
13211                 switch (level) {
13212                         case 1:
13213                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13214                         break;
13215
13216                         default:
13217                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13218                 }
13219         }
13220         return NDR_ERR_SUCCESS;
13221 }
13222
13223 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13224 {
13225         int level;
13226         level = ndr_print_get_switch_value(ndr, r);
13227         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13228         switch (level) {
13229                 case 1:
13230                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13231                 break;
13232
13233                 default:
13234                         ndr_print_bad_level(ndr, name, level);
13235         }
13236 }
13237
13238 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13239 {
13240         if (flags & NDR_IN) {
13241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13242                 if (r->in.bind_guid) {
13243                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13244                 }
13245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13246                 if (r->in.bind_info) {
13247                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13248                 }
13249         }
13250         if (flags & NDR_OUT) {
13251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13252                 if (r->out.bind_info) {
13253                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13254                 }
13255                 if (r->out.bind_handle == NULL) {
13256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13257                 }
13258                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13260         }
13261         return NDR_ERR_SUCCESS;
13262 }
13263
13264 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13265 {
13266         uint32_t _ptr_bind_guid;
13267         uint32_t _ptr_bind_info;
13268         TALLOC_CTX *_mem_save_bind_guid_0;
13269         TALLOC_CTX *_mem_save_bind_info_0;
13270         TALLOC_CTX *_mem_save_bind_handle_0;
13271         if (flags & NDR_IN) {
13272                 ZERO_STRUCT(r->out);
13273
13274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13275                 if (_ptr_bind_guid) {
13276                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13277                 } else {
13278                         r->in.bind_guid = NULL;
13279                 }
13280                 if (r->in.bind_guid) {
13281                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13282                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13283                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13285                 }
13286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13287                 if (_ptr_bind_info) {
13288                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13289                 } else {
13290                         r->in.bind_info = NULL;
13291                 }
13292                 if (r->in.bind_info) {
13293                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13294                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13295                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13297                 }
13298                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13299                 ZERO_STRUCTP(r->out.bind_handle);
13300         }
13301         if (flags & NDR_OUT) {
13302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13303                 if (_ptr_bind_info) {
13304                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13305                 } else {
13306                         r->out.bind_info = NULL;
13307                 }
13308                 if (r->out.bind_info) {
13309                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13310                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13311                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13313                 }
13314                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13315                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13316                 }
13317                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13318                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13319                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13320                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13321                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13322         }
13323         return NDR_ERR_SUCCESS;
13324 }
13325
13326 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13327 {
13328         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13329         ndr->depth++;
13330         if (flags & NDR_SET_VALUES) {
13331                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13332         }
13333         if (flags & NDR_IN) {
13334                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13335                 ndr->depth++;
13336                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13337                 ndr->depth++;
13338                 if (r->in.bind_guid) {
13339                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13340                 }
13341                 ndr->depth--;
13342                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13343                 ndr->depth++;
13344                 if (r->in.bind_info) {
13345                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13346                 }
13347                 ndr->depth--;
13348                 ndr->depth--;
13349         }
13350         if (flags & NDR_OUT) {
13351                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13352                 ndr->depth++;
13353                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13354                 ndr->depth++;
13355                 if (r->out.bind_info) {
13356                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13357                 }
13358                 ndr->depth--;
13359                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13360                 ndr->depth++;
13361                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13362                 ndr->depth--;
13363                 ndr_print_WERROR(ndr, "result", r->out.result);
13364                 ndr->depth--;
13365         }
13366         ndr->depth--;
13367 }
13368
13369 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13370 {
13371         if (flags & NDR_IN) {
13372                 if (r->in.bind_handle == NULL) {
13373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13374                 }
13375                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13376         }
13377         if (flags & NDR_OUT) {
13378                 if (r->out.bind_handle == NULL) {
13379                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13380                 }
13381                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13382                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13383         }
13384         return NDR_ERR_SUCCESS;
13385 }
13386
13387 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13388 {
13389         TALLOC_CTX *_mem_save_bind_handle_0;
13390         if (flags & NDR_IN) {
13391                 ZERO_STRUCT(r->out);
13392
13393                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13394                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13395                 }
13396                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13397                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13398                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13400                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13401                 *r->out.bind_handle = *r->in.bind_handle;
13402         }
13403         if (flags & NDR_OUT) {
13404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13405                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13406                 }
13407                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13408                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13409                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13412         }
13413         return NDR_ERR_SUCCESS;
13414 }
13415
13416 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13417 {
13418         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13419         ndr->depth++;
13420         if (flags & NDR_SET_VALUES) {
13421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13422         }
13423         if (flags & NDR_IN) {
13424                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13425                 ndr->depth++;
13426                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13427                 ndr->depth++;
13428                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13429                 ndr->depth--;
13430                 ndr->depth--;
13431         }
13432         if (flags & NDR_OUT) {
13433                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13434                 ndr->depth++;
13435                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13436                 ndr->depth++;
13437                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13438                 ndr->depth--;
13439                 ndr_print_WERROR(ndr, "result", r->out.result);
13440                 ndr->depth--;
13441         }
13442         ndr->depth--;
13443 }
13444
13445 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13446 {
13447         if (flags & NDR_IN) {
13448                 if (r->in.bind_handle == NULL) {
13449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13450                 }
13451                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13453                 if (r->in.req == NULL) {
13454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13455                 }
13456                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13457                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13458         }
13459         if (flags & NDR_OUT) {
13460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13461         }
13462         return NDR_ERR_SUCCESS;
13463 }
13464
13465 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13466 {
13467         TALLOC_CTX *_mem_save_bind_handle_0;
13468         TALLOC_CTX *_mem_save_req_0;
13469         if (flags & NDR_IN) {
13470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13471                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13472                 }
13473                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13474                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13479                         NDR_PULL_ALLOC(ndr, r->in.req);
13480                 }
13481                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13482                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13483                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13484                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13486         }
13487         if (flags & NDR_OUT) {
13488                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13489         }
13490         return NDR_ERR_SUCCESS;
13491 }
13492
13493 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13494 {
13495         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13496         ndr->depth++;
13497         if (flags & NDR_SET_VALUES) {
13498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13499         }
13500         if (flags & NDR_IN) {
13501                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13502                 ndr->depth++;
13503                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13504                 ndr->depth++;
13505                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13506                 ndr->depth--;
13507                 ndr_print_uint32(ndr, "level", r->in.level);
13508                 ndr_print_ptr(ndr, "req", r->in.req);
13509                 ndr->depth++;
13510                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13511                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", r->in.req);
13512                 ndr->depth--;
13513                 ndr->depth--;
13514         }
13515         if (flags & NDR_OUT) {
13516                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13517                 ndr->depth++;
13518                 ndr_print_WERROR(ndr, "result", r->out.result);
13519                 ndr->depth--;
13520         }
13521         ndr->depth--;
13522 }
13523
13524 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13525 {
13526         if (flags & NDR_IN) {
13527                 if (r->in.bind_handle == NULL) {
13528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13529                 }
13530                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13532                 if (r->in.req == NULL) {
13533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13534                 }
13535                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13536                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13537         }
13538         if (flags & NDR_OUT) {
13539                 if (r->out.level_out == NULL) {
13540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13541                 }
13542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13543                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
13547                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13549         }
13550         return NDR_ERR_SUCCESS;
13551 }
13552
13553 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13554 {
13555         TALLOC_CTX *_mem_save_bind_handle_0;
13556         TALLOC_CTX *_mem_save_req_0;
13557         TALLOC_CTX *_mem_save_level_out_0;
13558         TALLOC_CTX *_mem_save_ctr_0;
13559         if (flags & NDR_IN) {
13560                 ZERO_STRUCT(r->out);
13561
13562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13563                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13564                 }
13565                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13566                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13567                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13571                         NDR_PULL_ALLOC(ndr, r->in.req);
13572                 }
13573                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13574                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13575                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13576                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13578                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13579                 ZERO_STRUCTP(r->out.level_out);
13580                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13581                 ZERO_STRUCTP(r->out.ctr);
13582         }
13583         if (flags & NDR_OUT) {
13584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13585                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13586                 }
13587                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13588                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13591                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13592                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13593                 }
13594                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13595                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13596                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13597                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13599                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13600         }
13601         return NDR_ERR_SUCCESS;
13602 }
13603
13604 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13605 {
13606         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13607         ndr->depth++;
13608         if (flags & NDR_SET_VALUES) {
13609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13610         }
13611         if (flags & NDR_IN) {
13612                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13613                 ndr->depth++;
13614                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13615                 ndr->depth++;
13616                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13617                 ndr->depth--;
13618                 ndr_print_uint32(ndr, "level", r->in.level);
13619                 ndr_print_ptr(ndr, "req", r->in.req);
13620                 ndr->depth++;
13621                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13622                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13623                 ndr->depth--;
13624                 ndr->depth--;
13625         }
13626         if (flags & NDR_OUT) {
13627                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13628                 ndr->depth++;
13629                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13630                 ndr->depth++;
13631                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
13632                 ndr->depth--;
13633                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13634                 ndr->depth++;
13635                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13636                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13637                 ndr->depth--;
13638                 ndr_print_WERROR(ndr, "result", r->out.result);
13639                 ndr->depth--;
13640         }
13641         ndr->depth--;
13642 }
13643
13644 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13645 {
13646         if (flags & NDR_IN) {
13647                 if (r->in.bind_handle == NULL) {
13648                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13649                 }
13650                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13652                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13653                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13654         }
13655         if (flags & NDR_OUT) {
13656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13657         }
13658         return NDR_ERR_SUCCESS;
13659 }
13660
13661 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13662 {
13663         TALLOC_CTX *_mem_save_bind_handle_0;
13664         if (flags & NDR_IN) {
13665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13666                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13667                 }
13668                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13669                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13670                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13673                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13674                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13675         }
13676         if (flags & NDR_OUT) {
13677                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13678         }
13679         return NDR_ERR_SUCCESS;
13680 }
13681
13682 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13683 {
13684         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13685         ndr->depth++;
13686         if (flags & NDR_SET_VALUES) {
13687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13688         }
13689         if (flags & NDR_IN) {
13690                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13691                 ndr->depth++;
13692                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13693                 ndr->depth++;
13694                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13695                 ndr->depth--;
13696                 ndr_print_uint32(ndr, "level", r->in.level);
13697                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13698                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13699                 ndr->depth--;
13700         }
13701         if (flags & NDR_OUT) {
13702                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13703                 ndr->depth++;
13704                 ndr_print_WERROR(ndr, "result", r->out.result);
13705                 ndr->depth--;
13706         }
13707         ndr->depth--;
13708 }
13709
13710 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13711 {
13712         if (flags & NDR_IN) {
13713                 if (r->in.bind_handle == NULL) {
13714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13715                 }
13716                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13718                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13719                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13720         }
13721         if (flags & NDR_OUT) {
13722                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13723         }
13724         return NDR_ERR_SUCCESS;
13725 }
13726
13727 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13728 {
13729         TALLOC_CTX *_mem_save_bind_handle_0;
13730         if (flags & NDR_IN) {
13731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13732                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13733                 }
13734                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13735                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13739                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13740                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13741         }
13742         if (flags & NDR_OUT) {
13743                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13744         }
13745         return NDR_ERR_SUCCESS;
13746 }
13747
13748 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13749 {
13750         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13751         ndr->depth++;
13752         if (flags & NDR_SET_VALUES) {
13753                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13754         }
13755         if (flags & NDR_IN) {
13756                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13757                 ndr->depth++;
13758                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13759                 ndr->depth++;
13760                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13761                 ndr->depth--;
13762                 ndr_print_uint32(ndr, "level", r->in.level);
13763                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13764                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13765                 ndr->depth--;
13766         }
13767         if (flags & NDR_OUT) {
13768                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13769                 ndr->depth++;
13770                 ndr_print_WERROR(ndr, "result", r->out.result);
13771                 ndr->depth--;
13772         }
13773         ndr->depth--;
13774 }
13775
13776 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13777 {
13778         if (flags & NDR_IN) {
13779                 if (r->in.bind_handle == NULL) {
13780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13781                 }
13782                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13784                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13785                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13786         }
13787         if (flags & NDR_OUT) {
13788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13789         }
13790         return NDR_ERR_SUCCESS;
13791 }
13792
13793 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13794 {
13795         TALLOC_CTX *_mem_save_bind_handle_0;
13796         if (flags & NDR_IN) {
13797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13798                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13799                 }
13800                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13801                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13802                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13803                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13805                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13806                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13807         }
13808         if (flags & NDR_OUT) {
13809                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13810         }
13811         return NDR_ERR_SUCCESS;
13812 }
13813
13814 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13815 {
13816         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13817         ndr->depth++;
13818         if (flags & NDR_SET_VALUES) {
13819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13820         }
13821         if (flags & NDR_IN) {
13822                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13823                 ndr->depth++;
13824                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13825                 ndr->depth++;
13826                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13827                 ndr->depth--;
13828                 ndr_print_uint32(ndr, "level", r->in.level);
13829                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13830                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13831                 ndr->depth--;
13832         }
13833         if (flags & NDR_OUT) {
13834                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13835                 ndr->depth++;
13836                 ndr_print_WERROR(ndr, "result", r->out.result);
13837                 ndr->depth--;
13838         }
13839         ndr->depth--;
13840 }
13841
13842 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13843 {
13844         if (flags & NDR_IN) {
13845                 if (r->in.bind_handle == NULL) {
13846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13847                 }
13848                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13850                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13851                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13852         }
13853         if (flags & NDR_OUT) {
13854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13855         }
13856         return NDR_ERR_SUCCESS;
13857 }
13858
13859 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13860 {
13861         TALLOC_CTX *_mem_save_bind_handle_0;
13862         if (flags & NDR_IN) {
13863                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13864                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13865                 }
13866                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13867                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13868                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13871                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13872                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13873         }
13874         if (flags & NDR_OUT) {
13875                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13876         }
13877         return NDR_ERR_SUCCESS;
13878 }
13879
13880 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13881 {
13882         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13883         ndr->depth++;
13884         if (flags & NDR_SET_VALUES) {
13885                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13886         }
13887         if (flags & NDR_IN) {
13888                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13889                 ndr->depth++;
13890                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13891                 ndr->depth++;
13892                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13893                 ndr->depth--;
13894                 ndr_print_uint32(ndr, "level", r->in.level);
13895                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13896                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13897                 ndr->depth--;
13898         }
13899         if (flags & NDR_OUT) {
13900                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13901                 ndr->depth++;
13902                 ndr_print_WERROR(ndr, "result", r->out.result);
13903                 ndr->depth--;
13904         }
13905         ndr->depth--;
13906 }
13907
13908 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13909 {
13910         if (flags & NDR_IN) {
13911         }
13912         if (flags & NDR_OUT) {
13913                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13914         }
13915         return NDR_ERR_SUCCESS;
13916 }
13917
13918 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13919 {
13920         if (flags & NDR_IN) {
13921         }
13922         if (flags & NDR_OUT) {
13923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13924         }
13925         return NDR_ERR_SUCCESS;
13926 }
13927
13928 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13929 {
13930         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13931         ndr->depth++;
13932         if (flags & NDR_SET_VALUES) {
13933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13934         }
13935         if (flags & NDR_IN) {
13936                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13937                 ndr->depth++;
13938                 ndr->depth--;
13939         }
13940         if (flags & NDR_OUT) {
13941                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13942                 ndr->depth++;
13943                 ndr_print_WERROR(ndr, "result", r->out.result);
13944                 ndr->depth--;
13945         }
13946         ndr->depth--;
13947 }
13948
13949 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13950 {
13951         if (flags & NDR_IN) {
13952                 if (r->in.bind_handle == NULL) {
13953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13954                 }
13955                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13957                 if (r->in.req == NULL) {
13958                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13959                 }
13960                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13961                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13962         }
13963         if (flags & NDR_OUT) {
13964                 if (r->out.level_out == NULL) {
13965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13966                 }
13967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13968                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
13972                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13973                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13974         }
13975         return NDR_ERR_SUCCESS;
13976 }
13977
13978 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13979 {
13980         TALLOC_CTX *_mem_save_bind_handle_0;
13981         TALLOC_CTX *_mem_save_req_0;
13982         TALLOC_CTX *_mem_save_level_out_0;
13983         TALLOC_CTX *_mem_save_ctr_0;
13984         if (flags & NDR_IN) {
13985                 ZERO_STRUCT(r->out);
13986
13987                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13988                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13989                 }
13990                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13991                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13992                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13995                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13996                         NDR_PULL_ALLOC(ndr, r->in.req);
13997                 }
13998                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13999                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14000                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14001                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14003                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14004                 ZERO_STRUCTP(r->out.level_out);
14005                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14006                 ZERO_STRUCTP(r->out.ctr);
14007         }
14008         if (flags & NDR_OUT) {
14009                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14010                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14011                 }
14012                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14013                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14016                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14017                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14018                 }
14019                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14020                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14021                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14022                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14024                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14025         }
14026         return NDR_ERR_SUCCESS;
14027 }
14028
14029 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14030 {
14031         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14032         ndr->depth++;
14033         if (flags & NDR_SET_VALUES) {
14034                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14035         }
14036         if (flags & NDR_IN) {
14037                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14038                 ndr->depth++;
14039                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14040                 ndr->depth++;
14041                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14042                 ndr->depth--;
14043                 ndr_print_uint32(ndr, "level", r->in.level);
14044                 ndr_print_ptr(ndr, "req", r->in.req);
14045                 ndr->depth++;
14046                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14047                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14048                 ndr->depth--;
14049                 ndr->depth--;
14050         }
14051         if (flags & NDR_OUT) {
14052                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14053                 ndr->depth++;
14054                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14055                 ndr->depth++;
14056                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14057                 ndr->depth--;
14058                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14059                 ndr->depth++;
14060                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14061                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14062                 ndr->depth--;
14063                 ndr_print_WERROR(ndr, "result", r->out.result);
14064                 ndr->depth--;
14065         }
14066         ndr->depth--;
14067 }
14068
14069 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14070 {
14071         if (flags & NDR_IN) {
14072         }
14073         if (flags & NDR_OUT) {
14074                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14075         }
14076         return NDR_ERR_SUCCESS;
14077 }
14078
14079 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14080 {
14081         if (flags & NDR_IN) {
14082         }
14083         if (flags & NDR_OUT) {
14084                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14085         }
14086         return NDR_ERR_SUCCESS;
14087 }
14088
14089 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14090 {
14091         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14092         ndr->depth++;
14093         if (flags & NDR_SET_VALUES) {
14094                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14095         }
14096         if (flags & NDR_IN) {
14097                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14098                 ndr->depth++;
14099                 ndr->depth--;
14100         }
14101         if (flags & NDR_OUT) {
14102                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14103                 ndr->depth++;
14104                 ndr_print_WERROR(ndr, "result", r->out.result);
14105                 ndr->depth--;
14106         }
14107         ndr->depth--;
14108 }
14109
14110 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14111 {
14112         if (flags & NDR_IN) {
14113                 if (r->in.bind_handle == NULL) {
14114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14115                 }
14116                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14118                 if (r->in.req == NULL) {
14119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14120                 }
14121                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14122                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14123         }
14124         if (flags & NDR_OUT) {
14125                 if (r->out.level_out == NULL) {
14126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14127                 }
14128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14129                 if (r->out.info == 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->out.info, *r->out.level_out));
14133                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14134                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14135         }
14136         return NDR_ERR_SUCCESS;
14137 }
14138
14139 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14140 {
14141         TALLOC_CTX *_mem_save_bind_handle_0;
14142         TALLOC_CTX *_mem_save_req_0;
14143         TALLOC_CTX *_mem_save_level_out_0;
14144         TALLOC_CTX *_mem_save_info_0;
14145         if (flags & NDR_IN) {
14146                 ZERO_STRUCT(r->out);
14147
14148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14149                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14150                 }
14151                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14152                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14153                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14156                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14157                         NDR_PULL_ALLOC(ndr, r->in.req);
14158                 }
14159                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14160                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14161                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14162                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14163                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14164                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14165                 ZERO_STRUCTP(r->out.level_out);
14166                 NDR_PULL_ALLOC(ndr, r->out.info);
14167                 ZERO_STRUCTP(r->out.info);
14168         }
14169         if (flags & NDR_OUT) {
14170                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14171                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14172                 }
14173                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14174                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14176                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14178                         NDR_PULL_ALLOC(ndr, r->out.info);
14179                 }
14180                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14181                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14182                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14183                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14185                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14186         }
14187         return NDR_ERR_SUCCESS;
14188 }
14189
14190 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14191 {
14192         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14193         ndr->depth++;
14194         if (flags & NDR_SET_VALUES) {
14195                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14196         }
14197         if (flags & NDR_IN) {
14198                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14199                 ndr->depth++;
14200                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14201                 ndr->depth++;
14202                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14203                 ndr->depth--;
14204                 ndr_print_uint32(ndr, "level", r->in.level);
14205                 ndr_print_ptr(ndr, "req", r->in.req);
14206                 ndr->depth++;
14207                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14208                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14209                 ndr->depth--;
14210                 ndr->depth--;
14211         }
14212         if (flags & NDR_OUT) {
14213                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14214                 ndr->depth++;
14215                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14216                 ndr->depth++;
14217                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14218                 ndr->depth--;
14219                 ndr_print_ptr(ndr, "info", r->out.info);
14220                 ndr->depth++;
14221                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14222                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14223                 ndr->depth--;
14224                 ndr_print_WERROR(ndr, "result", r->out.result);
14225                 ndr->depth--;
14226         }
14227         ndr->depth--;
14228 }
14229
14230 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14231 {
14232         if (flags & NDR_IN) {
14233                 if (r->in.bind_handle == NULL) {
14234                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14235                 }
14236                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14238                 if (r->in.req == NULL) {
14239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14240                 }
14241                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14242                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14243         }
14244         if (flags & NDR_OUT) {
14245                 if (r->out.level_out == NULL) {
14246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14247                 }
14248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14249                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
14253                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14255         }
14256         return NDR_ERR_SUCCESS;
14257 }
14258
14259 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14260 {
14261         TALLOC_CTX *_mem_save_bind_handle_0;
14262         TALLOC_CTX *_mem_save_req_0;
14263         TALLOC_CTX *_mem_save_level_out_0;
14264         TALLOC_CTX *_mem_save_ctr_0;
14265         if (flags & NDR_IN) {
14266                 ZERO_STRUCT(r->out);
14267
14268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14269                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14270                 }
14271                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14272                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14273                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14277                         NDR_PULL_ALLOC(ndr, r->in.req);
14278                 }
14279                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14280                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14281                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14282                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14284                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14285                 ZERO_STRUCTP(r->out.level_out);
14286                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14287                 ZERO_STRUCTP(r->out.ctr);
14288         }
14289         if (flags & NDR_OUT) {
14290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14291                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14292                 }
14293                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14294                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14297                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14298                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14299                 }
14300                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14301                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14302                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14303                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14306         }
14307         return NDR_ERR_SUCCESS;
14308 }
14309
14310 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14311 {
14312         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14313         ndr->depth++;
14314         if (flags & NDR_SET_VALUES) {
14315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14316         }
14317         if (flags & NDR_IN) {
14318                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14319                 ndr->depth++;
14320                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14321                 ndr->depth++;
14322                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14323                 ndr->depth--;
14324                 ndr_print_uint32(ndr, "level", r->in.level);
14325                 ndr_print_ptr(ndr, "req", r->in.req);
14326                 ndr->depth++;
14327                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14328                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14329                 ndr->depth--;
14330                 ndr->depth--;
14331         }
14332         if (flags & NDR_OUT) {
14333                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14334                 ndr->depth++;
14335                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14336                 ndr->depth++;
14337                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14338                 ndr->depth--;
14339                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14340                 ndr->depth++;
14341                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14342                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14343                 ndr->depth--;
14344                 ndr_print_WERROR(ndr, "result", r->out.result);
14345                 ndr->depth--;
14346         }
14347         ndr->depth--;
14348 }
14349
14350 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14351 {
14352         if (flags & NDR_IN) {
14353                 if (r->in.bind_handle == NULL) {
14354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14355                 }
14356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14358                 if (r->in.req == NULL) {
14359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14360                 }
14361                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14362                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14363         }
14364         if (flags & NDR_OUT) {
14365                 if (r->out.level_out == NULL) {
14366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14367                 }
14368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14369                 if (r->out.res == 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->out.res, *r->out.level_out));
14373                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14374                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14375         }
14376         return NDR_ERR_SUCCESS;
14377 }
14378
14379 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14380 {
14381         TALLOC_CTX *_mem_save_bind_handle_0;
14382         TALLOC_CTX *_mem_save_req_0;
14383         TALLOC_CTX *_mem_save_level_out_0;
14384         TALLOC_CTX *_mem_save_res_0;
14385         if (flags & NDR_IN) {
14386                 ZERO_STRUCT(r->out);
14387
14388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14389                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14390                 }
14391                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14392                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14393                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14397                         NDR_PULL_ALLOC(ndr, r->in.req);
14398                 }
14399                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14401                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14402                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14404                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14405                 ZERO_STRUCTP(r->out.level_out);
14406                 NDR_PULL_ALLOC(ndr, r->out.res);
14407                 ZERO_STRUCTP(r->out.res);
14408         }
14409         if (flags & NDR_OUT) {
14410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14411                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14412                 }
14413                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14414                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14418                         NDR_PULL_ALLOC(ndr, r->out.res);
14419                 }
14420                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14421                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14422                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14423                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14426         }
14427         return NDR_ERR_SUCCESS;
14428 }
14429
14430 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14431 {
14432         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14433         ndr->depth++;
14434         if (flags & NDR_SET_VALUES) {
14435                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14436         }
14437         if (flags & NDR_IN) {
14438                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14439                 ndr->depth++;
14440                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14441                 ndr->depth++;
14442                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14443                 ndr->depth--;
14444                 ndr_print_uint32(ndr, "level", r->in.level);
14445                 ndr_print_ptr(ndr, "req", r->in.req);
14446                 ndr->depth++;
14447                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14448                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14449                 ndr->depth--;
14450                 ndr->depth--;
14451         }
14452         if (flags & NDR_OUT) {
14453                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14454                 ndr->depth++;
14455                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14456                 ndr->depth++;
14457                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14458                 ndr->depth--;
14459                 ndr_print_ptr(ndr, "res", r->out.res);
14460                 ndr->depth++;
14461                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14462                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14463                 ndr->depth--;
14464                 ndr_print_WERROR(ndr, "result", r->out.result);
14465                 ndr->depth--;
14466         }
14467         ndr->depth--;
14468 }
14469
14470 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14471 {
14472         if (flags & NDR_IN) {
14473                 if (r->in.bind_handle == NULL) {
14474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14475                 }
14476                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14478                 if (r->in.req == NULL) {
14479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14480                 }
14481                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14482                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14483         }
14484         if (flags & NDR_OUT) {
14485                 if (r->out.level_out == NULL) {
14486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14487                 }
14488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14489                 if (r->out.res == 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->out.res, *r->out.level_out));
14493                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14495         }
14496         return NDR_ERR_SUCCESS;
14497 }
14498
14499 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14500 {
14501         TALLOC_CTX *_mem_save_bind_handle_0;
14502         TALLOC_CTX *_mem_save_req_0;
14503         TALLOC_CTX *_mem_save_level_out_0;
14504         TALLOC_CTX *_mem_save_res_0;
14505         if (flags & NDR_IN) {
14506                 ZERO_STRUCT(r->out);
14507
14508                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14509                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14510                 }
14511                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14512                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14513                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14514                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14517                         NDR_PULL_ALLOC(ndr, r->in.req);
14518                 }
14519                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14520                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14521                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14522                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14524                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14525                 ZERO_STRUCTP(r->out.level_out);
14526                 NDR_PULL_ALLOC(ndr, r->out.res);
14527                 ZERO_STRUCTP(r->out.res);
14528         }
14529         if (flags & NDR_OUT) {
14530                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14531                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14532                 }
14533                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14534                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14536                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14538                         NDR_PULL_ALLOC(ndr, r->out.res);
14539                 }
14540                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14541                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14542                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14543                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14546         }
14547         return NDR_ERR_SUCCESS;
14548 }
14549
14550 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14551 {
14552         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14553         ndr->depth++;
14554         if (flags & NDR_SET_VALUES) {
14555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14556         }
14557         if (flags & NDR_IN) {
14558                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14559                 ndr->depth++;
14560                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14561                 ndr->depth++;
14562                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14563                 ndr->depth--;
14564                 ndr_print_uint32(ndr, "level", r->in.level);
14565                 ndr_print_ptr(ndr, "req", r->in.req);
14566                 ndr->depth++;
14567                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14568                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14569                 ndr->depth--;
14570                 ndr->depth--;
14571         }
14572         if (flags & NDR_OUT) {
14573                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14574                 ndr->depth++;
14575                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14576                 ndr->depth++;
14577                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14578                 ndr->depth--;
14579                 ndr_print_ptr(ndr, "res", r->out.res);
14580                 ndr->depth++;
14581                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14582                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14583                 ndr->depth--;
14584                 ndr_print_WERROR(ndr, "result", r->out.result);
14585                 ndr->depth--;
14586         }
14587         ndr->depth--;
14588 }
14589
14590 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14591 {
14592         if (flags & NDR_IN) {
14593         }
14594         if (flags & NDR_OUT) {
14595                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14596         }
14597         return NDR_ERR_SUCCESS;
14598 }
14599
14600 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14601 {
14602         if (flags & NDR_IN) {
14603         }
14604         if (flags & NDR_OUT) {
14605                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14606         }
14607         return NDR_ERR_SUCCESS;
14608 }
14609
14610 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14611 {
14612         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14613         ndr->depth++;
14614         if (flags & NDR_SET_VALUES) {
14615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14616         }
14617         if (flags & NDR_IN) {
14618                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14619                 ndr->depth++;
14620                 ndr->depth--;
14621         }
14622         if (flags & NDR_OUT) {
14623                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14624                 ndr->depth++;
14625                 ndr_print_WERROR(ndr, "result", r->out.result);
14626                 ndr->depth--;
14627         }
14628         ndr->depth--;
14629 }
14630
14631 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14632 {
14633         if (flags & NDR_IN) {
14634                 if (r->in.bind_handle == NULL) {
14635                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14636                 }
14637                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14638                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14639                 if (r->in.req == NULL) {
14640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14641                 }
14642                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14643                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14644         }
14645         if (flags & NDR_OUT) {
14646                 if (r->out.level_out == NULL) {
14647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14648                 }
14649                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14650                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
14654                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14656         }
14657         return NDR_ERR_SUCCESS;
14658 }
14659
14660 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14661 {
14662         TALLOC_CTX *_mem_save_bind_handle_0;
14663         TALLOC_CTX *_mem_save_req_0;
14664         TALLOC_CTX *_mem_save_level_out_0;
14665         TALLOC_CTX *_mem_save_ctr_0;
14666         if (flags & NDR_IN) {
14667                 ZERO_STRUCT(r->out);
14668
14669                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14670                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14671                 }
14672                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14673                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14674                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14675                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14676                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14678                         NDR_PULL_ALLOC(ndr, r->in.req);
14679                 }
14680                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14682                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14683                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14684                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14685                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14686                 ZERO_STRUCTP(r->out.level_out);
14687                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14688                 ZERO_STRUCTP(r->out.ctr);
14689         }
14690         if (flags & NDR_OUT) {
14691                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14692                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14693                 }
14694                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14695                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14696                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14697                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14699                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14700                 }
14701                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14702                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14703                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14704                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14706                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14707         }
14708         return NDR_ERR_SUCCESS;
14709 }
14710
14711 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14712 {
14713         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14714         ndr->depth++;
14715         if (flags & NDR_SET_VALUES) {
14716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14717         }
14718         if (flags & NDR_IN) {
14719                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14720                 ndr->depth++;
14721                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14722                 ndr->depth++;
14723                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14724                 ndr->depth--;
14725                 ndr_print_int32(ndr, "level", r->in.level);
14726                 ndr_print_ptr(ndr, "req", r->in.req);
14727                 ndr->depth++;
14728                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14729                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14730                 ndr->depth--;
14731                 ndr->depth--;
14732         }
14733         if (flags & NDR_OUT) {
14734                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14735                 ndr->depth++;
14736                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14737                 ndr->depth++;
14738                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14739                 ndr->depth--;
14740                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14741                 ndr->depth++;
14742                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14743                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14744                 ndr->depth--;
14745                 ndr_print_WERROR(ndr, "result", r->out.result);
14746                 ndr->depth--;
14747         }
14748         ndr->depth--;
14749 }
14750
14751 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14752 {
14753         if (flags & NDR_IN) {
14754                 if (r->in.bind_handle == NULL) {
14755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14756                 }
14757                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14758                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14759                 if (r->in.req == NULL) {
14760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14761                 }
14762                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14763                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14764         }
14765         if (flags & NDR_OUT) {
14766                 if (r->out.level_out == NULL) {
14767                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14768                 }
14769                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14770                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
14774                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14775                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14776         }
14777         return NDR_ERR_SUCCESS;
14778 }
14779
14780 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14781 {
14782         TALLOC_CTX *_mem_save_bind_handle_0;
14783         TALLOC_CTX *_mem_save_req_0;
14784         TALLOC_CTX *_mem_save_level_out_0;
14785         TALLOC_CTX *_mem_save_ctr_0;
14786         if (flags & NDR_IN) {
14787                 ZERO_STRUCT(r->out);
14788
14789                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14790                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14791                 }
14792                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14793                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14794                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14795                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14796                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14797                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14798                         NDR_PULL_ALLOC(ndr, r->in.req);
14799                 }
14800                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14801                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14802                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14803                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14805                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14806                 ZERO_STRUCTP(r->out.level_out);
14807                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14808                 ZERO_STRUCTP(r->out.ctr);
14809         }
14810         if (flags & NDR_OUT) {
14811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14812                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14813                 }
14814                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14815                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14816                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14819                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14820                 }
14821                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14822                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14823                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14824                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14826                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14827         }
14828         return NDR_ERR_SUCCESS;
14829 }
14830
14831 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14832 {
14833         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14834         ndr->depth++;
14835         if (flags & NDR_SET_VALUES) {
14836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14837         }
14838         if (flags & NDR_IN) {
14839                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14840                 ndr->depth++;
14841                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14842                 ndr->depth++;
14843                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14844                 ndr->depth--;
14845                 ndr_print_int32(ndr, "level", r->in.level);
14846                 ndr_print_ptr(ndr, "req", r->in.req);
14847                 ndr->depth++;
14848                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14849                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14850                 ndr->depth--;
14851                 ndr->depth--;
14852         }
14853         if (flags & NDR_OUT) {
14854                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14855                 ndr->depth++;
14856                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14857                 ndr->depth++;
14858                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14859                 ndr->depth--;
14860                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14861                 ndr->depth++;
14862                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14863                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14864                 ndr->depth--;
14865                 ndr_print_WERROR(ndr, "result", r->out.result);
14866                 ndr->depth--;
14867         }
14868         ndr->depth--;
14869 }
14870
14871 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14872 {
14873         if (flags & NDR_IN) {
14874                 if (r->in.bind_handle == NULL) {
14875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14876                 }
14877                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14879                 if (r->in.req == NULL) {
14880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14881                 }
14882                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14883                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14884         }
14885         if (flags & NDR_OUT) {
14886                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14887         }
14888         return NDR_ERR_SUCCESS;
14889 }
14890
14891 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14892 {
14893         TALLOC_CTX *_mem_save_bind_handle_0;
14894         TALLOC_CTX *_mem_save_req_0;
14895         if (flags & NDR_IN) {
14896                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14897                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14898                 }
14899                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14900                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14901                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14905                         NDR_PULL_ALLOC(ndr, r->in.req);
14906                 }
14907                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14908                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14909                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14910                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14912         }
14913         if (flags & NDR_OUT) {
14914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14915         }
14916         return NDR_ERR_SUCCESS;
14917 }
14918
14919 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14920 {
14921         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14922         ndr->depth++;
14923         if (flags & NDR_SET_VALUES) {
14924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14925         }
14926         if (flags & NDR_IN) {
14927                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14928                 ndr->depth++;
14929                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14930                 ndr->depth++;
14931                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14932                 ndr->depth--;
14933                 ndr_print_uint32(ndr, "level", r->in.level);
14934                 ndr_print_ptr(ndr, "req", r->in.req);
14935                 ndr->depth++;
14936                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14937                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14938                 ndr->depth--;
14939                 ndr->depth--;
14940         }
14941         if (flags & NDR_OUT) {
14942                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14943                 ndr->depth++;
14944                 ndr_print_WERROR(ndr, "result", r->out.result);
14945                 ndr->depth--;
14946         }
14947         ndr->depth--;
14948 }
14949
14950 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14951 {
14952         if (flags & NDR_IN) {
14953                 if (r->in.bind_handle == NULL) {
14954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14955                 }
14956                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14957                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14958                 if (r->in.req == NULL) {
14959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14960                 }
14961                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14962                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14963         }
14964         if (flags & NDR_OUT) {
14965                 if (r->out.info_type == NULL) {
14966                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14967                 }
14968                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14969                 if (r->out.info == 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->out.info, *r->out.info_type));
14973                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14974                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14975         }
14976         return NDR_ERR_SUCCESS;
14977 }
14978
14979 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14980 {
14981         TALLOC_CTX *_mem_save_bind_handle_0;
14982         TALLOC_CTX *_mem_save_req_0;
14983         TALLOC_CTX *_mem_save_info_type_0;
14984         TALLOC_CTX *_mem_save_info_0;
14985         if (flags & NDR_IN) {
14986                 ZERO_STRUCT(r->out);
14987
14988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14989                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14990                 }
14991                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14992                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14993                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14995                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
14996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14997                         NDR_PULL_ALLOC(ndr, r->in.req);
14998                 }
14999                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15000                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15001                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15002                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15004                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15005                 ZERO_STRUCTP(r->out.info_type);
15006                 NDR_PULL_ALLOC(ndr, r->out.info);
15007                 ZERO_STRUCTP(r->out.info);
15008         }
15009         if (flags & NDR_OUT) {
15010                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15011                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15012                 }
15013                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15014                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15015                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15018                         NDR_PULL_ALLOC(ndr, r->out.info);
15019                 }
15020                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15021                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15022                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15023                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15025                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15026         }
15027         return NDR_ERR_SUCCESS;
15028 }
15029
15030 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15031 {
15032         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15033         ndr->depth++;
15034         if (flags & NDR_SET_VALUES) {
15035                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15036         }
15037         if (flags & NDR_IN) {
15038                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15039                 ndr->depth++;
15040                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15041                 ndr->depth++;
15042                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15043                 ndr->depth--;
15044                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15045                 ndr_print_ptr(ndr, "req", r->in.req);
15046                 ndr->depth++;
15047                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15048                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15049                 ndr->depth--;
15050                 ndr->depth--;
15051         }
15052         if (flags & NDR_OUT) {
15053                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15054                 ndr->depth++;
15055                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15056                 ndr->depth++;
15057                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15058                 ndr->depth--;
15059                 ndr_print_ptr(ndr, "info", r->out.info);
15060                 ndr->depth++;
15061                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15062                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15063                 ndr->depth--;
15064                 ndr_print_WERROR(ndr, "result", r->out.result);
15065                 ndr->depth--;
15066         }
15067         ndr->depth--;
15068 }
15069
15070 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15071 {
15072         if (flags & NDR_IN) {
15073         }
15074         if (flags & NDR_OUT) {
15075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15076         }
15077         return NDR_ERR_SUCCESS;
15078 }
15079
15080 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15081 {
15082         if (flags & NDR_IN) {
15083         }
15084         if (flags & NDR_OUT) {
15085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15086         }
15087         return NDR_ERR_SUCCESS;
15088 }
15089
15090 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15091 {
15092         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15093         ndr->depth++;
15094         if (flags & NDR_SET_VALUES) {
15095                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15096         }
15097         if (flags & NDR_IN) {
15098                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15099                 ndr->depth++;
15100                 ndr->depth--;
15101         }
15102         if (flags & NDR_OUT) {
15103                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15104                 ndr->depth++;
15105                 ndr_print_WERROR(ndr, "result", r->out.result);
15106                 ndr->depth--;
15107         }
15108         ndr->depth--;
15109 }
15110
15111 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15112 {
15113         if (flags & NDR_IN) {
15114                 if (r->in.bind_handle == NULL) {
15115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15116                 }
15117                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15119                 if (r->in.req == NULL) {
15120                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15121                 }
15122                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15123                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15124         }
15125         if (flags & NDR_OUT) {
15126                 if (r->out.level_out == NULL) {
15127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15128                 }
15129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
15130                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
15134                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15135                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15136         }
15137         return NDR_ERR_SUCCESS;
15138 }
15139
15140 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15141 {
15142         TALLOC_CTX *_mem_save_bind_handle_0;
15143         TALLOC_CTX *_mem_save_req_0;
15144         TALLOC_CTX *_mem_save_level_out_0;
15145         TALLOC_CTX *_mem_save_ctr_0;
15146         if (flags & NDR_IN) {
15147                 ZERO_STRUCT(r->out);
15148
15149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15150                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15151                 }
15152                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15157                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15158                         NDR_PULL_ALLOC(ndr, r->in.req);
15159                 }
15160                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15161                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15162                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15163                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15165                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15166                 ZERO_STRUCTP(r->out.level_out);
15167                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15168                 ZERO_STRUCTP(r->out.ctr);
15169         }
15170         if (flags & NDR_OUT) {
15171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15172                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15173                 }
15174                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15175                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
15177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15178                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15179                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15180                 }
15181                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15182                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15183                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15184                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15186                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15187         }
15188         return NDR_ERR_SUCCESS;
15189 }
15190
15191 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15192 {
15193         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15194         ndr->depth++;
15195         if (flags & NDR_SET_VALUES) {
15196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15197         }
15198         if (flags & NDR_IN) {
15199                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15200                 ndr->depth++;
15201                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15202                 ndr->depth++;
15203                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15204                 ndr->depth--;
15205                 ndr_print_uint32(ndr, "level", r->in.level);
15206                 ndr_print_ptr(ndr, "req", r->in.req);
15207                 ndr->depth++;
15208                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15209                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15210                 ndr->depth--;
15211                 ndr->depth--;
15212         }
15213         if (flags & NDR_OUT) {
15214                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15215                 ndr->depth++;
15216                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15217                 ndr->depth++;
15218                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
15219                 ndr->depth--;
15220                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15221                 ndr->depth++;
15222                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15223                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15224                 ndr->depth--;
15225                 ndr_print_WERROR(ndr, "result", r->out.result);
15226                 ndr->depth--;
15227         }
15228         ndr->depth--;
15229 }
15230
15231 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15232 {
15233         if (flags & NDR_IN) {
15234         }
15235         if (flags & NDR_OUT) {
15236                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15237         }
15238         return NDR_ERR_SUCCESS;
15239 }
15240
15241 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15242 {
15243         if (flags & NDR_IN) {
15244         }
15245         if (flags & NDR_OUT) {
15246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15247         }
15248         return NDR_ERR_SUCCESS;
15249 }
15250
15251 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15252 {
15253         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15254         ndr->depth++;
15255         if (flags & NDR_SET_VALUES) {
15256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15257         }
15258         if (flags & NDR_IN) {
15259                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15260                 ndr->depth++;
15261                 ndr->depth--;
15262         }
15263         if (flags & NDR_OUT) {
15264                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15265                 ndr->depth++;
15266                 ndr_print_WERROR(ndr, "result", r->out.result);
15267                 ndr->depth--;
15268         }
15269         ndr->depth--;
15270 }
15271
15272 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15273 {
15274         if (flags & NDR_IN) {
15275         }
15276         if (flags & NDR_OUT) {
15277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15278         }
15279         return NDR_ERR_SUCCESS;
15280 }
15281
15282 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15283 {
15284         if (flags & NDR_IN) {
15285         }
15286         if (flags & NDR_OUT) {
15287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15288         }
15289         return NDR_ERR_SUCCESS;
15290 }
15291
15292 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15293 {
15294         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15295         ndr->depth++;
15296         if (flags & NDR_SET_VALUES) {
15297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15298         }
15299         if (flags & NDR_IN) {
15300                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15301                 ndr->depth++;
15302                 ndr->depth--;
15303         }
15304         if (flags & NDR_OUT) {
15305                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15306                 ndr->depth++;
15307                 ndr_print_WERROR(ndr, "result", r->out.result);
15308                 ndr->depth--;
15309         }
15310         ndr->depth--;
15311 }
15312
15313 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15314 {
15315         if (flags & NDR_IN) {
15316                 if (r->in.bind_handle == NULL) {
15317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15318                 }
15319                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15321                 if (r->in.req == NULL) {
15322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15323                 }
15324                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15325                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15326         }
15327         if (flags & NDR_OUT) {
15328                 if (r->out.level_out == NULL) {
15329                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15330                 }
15331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
15332                 if (r->out.ctr == 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->out.ctr, *r->out.level_out));
15336                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15337                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15338         }
15339         return NDR_ERR_SUCCESS;
15340 }
15341
15342 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15343 {
15344         TALLOC_CTX *_mem_save_bind_handle_0;
15345         TALLOC_CTX *_mem_save_req_0;
15346         TALLOC_CTX *_mem_save_level_out_0;
15347         TALLOC_CTX *_mem_save_ctr_0;
15348         if (flags & NDR_IN) {
15349                 ZERO_STRUCT(r->out);
15350
15351                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15352                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15353                 }
15354                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15355                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15356                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15357                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15360                         NDR_PULL_ALLOC(ndr, r->in.req);
15361                 }
15362                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15363                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15364                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15365                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15367                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15368                 ZERO_STRUCTP(r->out.level_out);
15369                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15370                 ZERO_STRUCTP(r->out.ctr);
15371         }
15372         if (flags & NDR_OUT) {
15373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15374                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15375                 }
15376                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15377                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
15379                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15381                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15382                 }
15383                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15384                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15385                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15386                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15388                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15389         }
15390         return NDR_ERR_SUCCESS;
15391 }
15392
15393 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15394 {
15395         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15396         ndr->depth++;
15397         if (flags & NDR_SET_VALUES) {
15398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15399         }
15400         if (flags & NDR_IN) {
15401                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15402                 ndr->depth++;
15403                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15404                 ndr->depth++;
15405                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15406                 ndr->depth--;
15407                 ndr_print_uint32(ndr, "level", r->in.level);
15408                 ndr_print_ptr(ndr, "req", r->in.req);
15409                 ndr->depth++;
15410                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15411                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15412                 ndr->depth--;
15413                 ndr->depth--;
15414         }
15415         if (flags & NDR_OUT) {
15416                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15417                 ndr->depth++;
15418                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15419                 ndr->depth++;
15420                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
15421                 ndr->depth--;
15422                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15423                 ndr->depth++;
15424                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15425                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15426                 ndr->depth--;
15427                 ndr_print_WERROR(ndr, "result", r->out.result);
15428                 ndr->depth--;
15429         }
15430         ndr->depth--;
15431 }
15432
15433 static const struct ndr_interface_call drsuapi_calls[] = {
15434         {
15435                 "drsuapi_DsBind",
15436                 sizeof(struct drsuapi_DsBind),
15437                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15438                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15439                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15440                 false,
15441         },
15442         {
15443                 "drsuapi_DsUnbind",
15444                 sizeof(struct drsuapi_DsUnbind),
15445                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15446                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15447                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15448                 false,
15449         },
15450         {
15451                 "drsuapi_DsReplicaSync",
15452                 sizeof(struct drsuapi_DsReplicaSync),
15453                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15454                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15455                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15456                 false,
15457         },
15458         {
15459                 "drsuapi_DsGetNCChanges",
15460                 sizeof(struct drsuapi_DsGetNCChanges),
15461                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15462                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15463                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15464                 false,
15465         },
15466         {
15467                 "drsuapi_DsReplicaUpdateRefs",
15468                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15469                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15470                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15471                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15472                 false,
15473         },
15474         {
15475                 "drsuapi_DsReplicaAdd",
15476                 sizeof(struct drsuapi_DsReplicaAdd),
15477                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15478                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15479                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15480                 false,
15481         },
15482         {
15483                 "drsuapi_DsReplicaDel",
15484                 sizeof(struct drsuapi_DsReplicaDel),
15485                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15486                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15487                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15488                 false,
15489         },
15490         {
15491                 "drsuapi_DsReplicaMod",
15492                 sizeof(struct drsuapi_DsReplicaMod),
15493                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15494                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15495                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15496                 false,
15497         },
15498         {
15499                 "DRSUAPI_VERIFY_NAMES",
15500                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15501                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15502                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15503                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15504                 false,
15505         },
15506         {
15507                 "drsuapi_DsGetMemberships",
15508                 sizeof(struct drsuapi_DsGetMemberships),
15509                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15510                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15511                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15512                 false,
15513         },
15514         {
15515                 "DRSUAPI_INTER_DOMAIN_MOVE",
15516                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15517                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15518                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15519                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15520                 false,
15521         },
15522         {
15523                 "drsuapi_DsGetNT4ChangeLog",
15524                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15525                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15526                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15527                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15528                 false,
15529         },
15530         {
15531                 "drsuapi_DsCrackNames",
15532                 sizeof(struct drsuapi_DsCrackNames),
15533                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15534                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15535                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15536                 false,
15537         },
15538         {
15539                 "drsuapi_DsWriteAccountSpn",
15540                 sizeof(struct drsuapi_DsWriteAccountSpn),
15541                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15542                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15543                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15544                 false,
15545         },
15546         {
15547                 "drsuapi_DsRemoveDSServer",
15548                 sizeof(struct drsuapi_DsRemoveDSServer),
15549                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15550                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15551                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15552                 false,
15553         },
15554         {
15555                 "DRSUAPI_REMOVE_DS_DOMAIN",
15556                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15557                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15558                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15559                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15560                 false,
15561         },
15562         {
15563                 "drsuapi_DsGetDomainControllerInfo",
15564                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15565                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15566                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15567                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15568                 false,
15569         },
15570         {
15571                 "drsuapi_DsAddEntry",
15572                 sizeof(struct drsuapi_DsAddEntry),
15573                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15574                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15575                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15576                 false,
15577         },
15578         {
15579                 "drsuapi_DsExecuteKCC",
15580                 sizeof(struct drsuapi_DsExecuteKCC),
15581                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15582                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15583                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15584                 false,
15585         },
15586         {
15587                 "drsuapi_DsReplicaGetInfo",
15588                 sizeof(struct drsuapi_DsReplicaGetInfo),
15589                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15590                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15591                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15592                 false,
15593         },
15594         {
15595                 "DRSUAPI_ADD_SID_HISTORY",
15596                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15597                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15598                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15599                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15600                 false,
15601         },
15602         {
15603                 "drsuapi_DsGetMemberships2",
15604                 sizeof(struct drsuapi_DsGetMemberships2),
15605                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15606                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15607                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15608                 false,
15609         },
15610         {
15611                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15612                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15613                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15614                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15615                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15616                 false,
15617         },
15618         {
15619                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15620                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15621                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15622                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15623                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15624                 false,
15625         },
15626         {
15627                 "drsuapi_QuerySitesByCost",
15628                 sizeof(struct drsuapi_QuerySitesByCost),
15629                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15630                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15631                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15632                 false,
15633         },
15634         { NULL, 0, NULL, NULL, NULL, false }
15635 };
15636
15637 static const char * const drsuapi_endpoint_strings[] = {
15638         "ncacn_np:[\\pipe\\lsass]",
15639         "ncacn_np:[\\pipe\\protected_storage]",
15640         "ncacn_ip_tcp:",
15641         "ncalrpc:",
15642 };
15643
15644 static const struct ndr_interface_string_array drsuapi_endpoints = {
15645         .count  = 4,
15646         .names  = drsuapi_endpoint_strings
15647 };
15648
15649 static const char * const drsuapi_authservice_strings[] = {
15650         "ldap",
15651 };
15652
15653 static const struct ndr_interface_string_array drsuapi_authservices = {
15654         .count  = 1,
15655         .names  = drsuapi_authservice_strings
15656 };
15657
15658
15659 const struct ndr_interface_table ndr_table_drsuapi = {
15660         .name           = "drsuapi",
15661         .syntax_id      = {
15662                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15663                 NDR_DRSUAPI_VERSION
15664         },
15665         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15666         .num_calls      = 25,
15667         .calls          = drsuapi_calls,
15668         .endpoints      = &drsuapi_endpoints,
15669         .authservices   = &drsuapi_authservices
15670 };
15671